1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/csky.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
107 #include "elf/epiphany.h"
108 #include "elf/fr30.h"
110 #include "elf/ft32.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/s12z.h"
126 #include "elf/mcore.h"
128 #include "elf/metag.h"
129 #include "elf/microblaze.h"
130 #include "elf/mips.h"
131 #include "elf/mmix.h"
132 #include "elf/mn10200.h"
133 #include "elf/mn10300.h"
134 #include "elf/moxie.h"
136 #include "elf/msp430.h"
137 #include "elf/nds32.h"
139 #include "elf/nios2.h"
140 #include "elf/or1k.h"
143 #include "elf/ppc64.h"
145 #include "elf/riscv.h"
146 #include "elf/rl78.h"
148 #include "elf/s390.h"
149 #include "elf/score.h"
151 #include "elf/sparc.h"
153 #include "elf/tic6x.h"
154 #include "elf/tilegx.h"
155 #include "elf/tilepro.h"
156 #include "elf/v850.h"
158 #include "elf/visium.h"
159 #include "elf/wasm32.h"
160 #include "elf/x86-64.h"
161 #include "elf/xc16x.h"
162 #include "elf/xgate.h"
163 #include "elf/xstormy16.h"
164 #include "elf/xtensa.h"
168 #include "libiberty.h"
169 #include "safe-ctype.h"
170 #include "filenames.h"
173 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
176 typedef struct elf_section_list
178 Elf_Internal_Shdr
* hdr
;
179 struct elf_section_list
* next
;
182 /* Flag bits indicating particular types of dump. */
183 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
184 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
187 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
190 typedef unsigned char dump_type
;
192 /* A linked list of the section names for which dumps were requested. */
193 struct dump_list_entry
197 struct dump_list_entry
* next
;
200 typedef struct filedata
202 const char * file_name
;
204 bfd_size_type file_size
;
205 Elf_Internal_Ehdr file_header
;
206 Elf_Internal_Shdr
* section_headers
;
207 Elf_Internal_Phdr
* program_headers
;
209 unsigned long string_table_length
;
210 /* A dynamic array of flags indicating for which sections a dump of
211 some kind has been requested. It is reset on a per-object file
212 basis and then initialised from the cmdline_dump_sects array,
213 the results of interpreting the -w switch, and the
214 dump_sects_byname list. */
215 dump_type
* dump_sects
;
216 unsigned int num_dump_sects
;
219 char * program_name
= "readelf";
221 static unsigned long archive_file_offset
;
222 static unsigned long archive_file_size
;
223 static unsigned long dynamic_addr
;
224 static bfd_size_type dynamic_size
;
225 static size_t dynamic_nent
;
226 static char * dynamic_strings
;
227 static unsigned long dynamic_strings_length
;
228 static unsigned long num_dynamic_syms
;
229 static Elf_Internal_Sym
* dynamic_symbols
;
230 static Elf_Internal_Syminfo
* dynamic_syminfo
;
231 static unsigned long dynamic_syminfo_offset
;
232 static unsigned int dynamic_syminfo_nent
;
233 static char program_interpreter
[PATH_MAX
];
234 static bfd_vma dynamic_info
[DT_ENCODING
];
235 static bfd_vma dynamic_info_DT_GNU_HASH
;
236 static bfd_vma dynamic_info_DT_MIPS_XHASH
;
237 static bfd_vma version_info
[16];
238 static Elf_Internal_Dyn
* dynamic_section
;
239 static elf_section_list
* symtab_shndx_list
;
240 static bfd_boolean show_name
= FALSE
;
241 static bfd_boolean do_dynamic
= FALSE
;
242 static bfd_boolean do_syms
= FALSE
;
243 static bfd_boolean do_dyn_syms
= FALSE
;
244 static bfd_boolean do_reloc
= FALSE
;
245 static bfd_boolean do_sections
= FALSE
;
246 static bfd_boolean do_section_groups
= FALSE
;
247 static bfd_boolean do_section_details
= FALSE
;
248 static bfd_boolean do_segments
= FALSE
;
249 static bfd_boolean do_unwind
= FALSE
;
250 static bfd_boolean do_using_dynamic
= FALSE
;
251 static bfd_boolean do_header
= FALSE
;
252 static bfd_boolean do_dump
= FALSE
;
253 static bfd_boolean do_version
= FALSE
;
254 static bfd_boolean do_histogram
= FALSE
;
255 static bfd_boolean do_debugging
= FALSE
;
256 static bfd_boolean do_ctf
= FALSE
;
257 static bfd_boolean do_arch
= FALSE
;
258 static bfd_boolean do_notes
= FALSE
;
259 static bfd_boolean do_archive_index
= FALSE
;
260 static bfd_boolean is_32bit_elf
= FALSE
;
261 static bfd_boolean decompress_dumps
= FALSE
;
263 static char *dump_ctf_parent_name
;
264 static char *dump_ctf_symtab_name
;
265 static char *dump_ctf_strtab_name
;
269 struct group_list
* next
;
270 unsigned int section_index
;
275 struct group_list
* root
;
276 unsigned int group_index
;
279 static size_t group_count
;
280 static struct group
* section_groups
;
281 static struct group
** section_headers_groups
;
283 /* A dynamic array of flags indicating for which sections a dump
284 has been requested via command line switches. */
285 static Filedata cmdline
;
287 static struct dump_list_entry
* dump_sects_byname
;
289 /* How to print a vma value. */
290 typedef enum print_mode
302 /* Versioned symbol info. */
303 enum versioned_symbol_info
310 static const char * get_symbol_version_string
311 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
312 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
316 #define SECTION_NAME(X) \
317 ((X) == NULL ? _("<none>") \
318 : filedata->string_table == NULL ? _("<no-strings>") \
319 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
320 : filedata->string_table + (X)->sh_name))
322 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
324 #define GET_ELF_SYMBOLS(file, section, sym_count) \
325 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
326 : get_64bit_elf_symbols (file, section, sym_count))
328 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
329 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
330 already been called and verified that the string exists. */
331 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
333 #define REMOVE_ARCH_BITS(ADDR) \
336 if (filedata->file_header.e_machine == EM_ARM) \
341 /* Get the correct GNU hash section name. */
342 #define GNU_HASH_SECTION_NAME \
343 dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
345 /* Print a BFD_VMA to an internal buffer, for use in error messages.
346 BFD_FMA_FMT can't be used in translated strings. */
349 bfd_vmatoa (char *fmtch
, bfd_vma value
)
351 /* bfd_vmatoa is used more then once in a printf call for output.
352 Cycle through an array of buffers. */
353 static int buf_pos
= 0;
354 static struct bfd_vmatoa_buf
361 ret
= buf
[buf_pos
++].place
;
362 buf_pos
%= ARRAY_SIZE (buf
);
364 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
365 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
369 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
370 OFFSET + the offset of the current archive member, if we are examining an
371 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
372 allocate a buffer using malloc and fill that. In either case return the
373 pointer to the start of the retrieved data or NULL if something went wrong.
374 If something does go wrong and REASON is not NULL then emit an error
375 message using REASON as part of the context. */
378 get_data (void * var
,
380 unsigned long offset
,
386 bfd_size_type amt
= size
* nmemb
;
388 if (size
== 0 || nmemb
== 0)
391 /* If the size_t type is smaller than the bfd_size_type, eg because
392 you are building a 32-bit tool on a 64-bit host, then make sure
393 that when the sizes are cast to (size_t) no information is lost. */
394 if ((size_t) size
!= size
395 || (size_t) nmemb
!= nmemb
396 || (size_t) amt
!= amt
)
399 error (_("Size truncation prevents reading %s"
400 " elements of size %s for %s\n"),
401 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
405 /* Check for size overflow. */
406 if (amt
/ size
!= nmemb
|| (size_t) amt
+ 1 == 0)
409 error (_("Size overflow prevents reading %s"
410 " elements of size %s for %s\n"),
411 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
415 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
416 attempting to allocate memory when the read is bound to fail. */
417 if (archive_file_offset
> filedata
->file_size
418 || offset
> filedata
->file_size
- archive_file_offset
419 || amt
> filedata
->file_size
- archive_file_offset
- offset
)
422 error (_("Reading %s bytes extends past end of file for %s\n"),
423 bfd_vmatoa ("u", amt
), reason
);
427 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
430 error (_("Unable to seek to 0x%lx for %s\n"),
431 archive_file_offset
+ offset
, reason
);
438 /* + 1 so that we can '\0' terminate invalid string table sections. */
439 mvar
= malloc ((size_t) amt
+ 1);
444 error (_("Out of memory allocating %s bytes for %s\n"),
445 bfd_vmatoa ("u", amt
), reason
);
449 ((char *) mvar
)[amt
] = '\0';
452 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
455 error (_("Unable to read in %s bytes of %s\n"),
456 bfd_vmatoa ("u", amt
), reason
);
465 /* Print a VMA value in the MODE specified.
466 Returns the number of characters displayed. */
469 print_vma (bfd_vma vma
, print_mode mode
)
481 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
488 return printf ("%5" BFD_VMA_FMT
"d", vma
);
494 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
497 return printf ("%" BFD_VMA_FMT
"d", vma
);
500 return printf ("%" BFD_VMA_FMT
"u", vma
);
503 /* FIXME: Report unrecognised mode ? */
508 /* Display a symbol on stdout. Handles the display of control characters and
509 multibye characters (assuming the host environment supports them).
511 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
513 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
514 padding as necessary.
516 Returns the number of emitted characters. */
519 print_symbol (signed int width
, const char *symbol
)
521 bfd_boolean extra_padding
= FALSE
;
522 signed int num_printed
= 0;
523 #ifdef HAVE_MBSTATE_T
526 unsigned int width_remaining
;
530 /* Keep the width positive. This helps the code below. */
532 extra_padding
= TRUE
;
538 /* Set the remaining width to a very large value.
539 This simplifies the code below. */
540 width_remaining
= INT_MAX
;
542 width_remaining
= width
;
544 #ifdef HAVE_MBSTATE_T
545 /* Initialise the multibyte conversion state. */
546 memset (& state
, 0, sizeof (state
));
549 while (width_remaining
)
552 const char c
= *symbol
++;
557 /* Do not print control characters directly as they can affect terminal
558 settings. Such characters usually appear in the names generated
559 by the assembler for local labels. */
562 if (width_remaining
< 2)
565 printf ("^%c", c
+ 0x40);
566 width_remaining
-= 2;
569 else if (ISPRINT (c
))
577 #ifdef HAVE_MBSTATE_T
580 /* Let printf do the hard work of displaying multibyte characters. */
581 printf ("%.1s", symbol
- 1);
585 #ifdef HAVE_MBSTATE_T
586 /* Try to find out how many bytes made up the character that was
587 just printed. Advance the symbol pointer past the bytes that
589 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
593 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
598 if (extra_padding
&& num_printed
< width
)
600 /* Fill in the remaining spaces. */
601 printf ("%-*s", width
- num_printed
, " ");
608 /* Returns a pointer to a static buffer containing a printable version of
609 the given section's name. Like print_symbol, except that it does not try
610 to print multibyte characters, it just interprets them as hex values. */
613 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
615 #define MAX_PRINT_SEC_NAME_LEN 128
616 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
617 const char * name
= SECTION_NAME (sec
);
618 char * buf
= sec_name_buf
;
620 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
622 while ((c
= * name
++) != 0)
633 else if (ISPRINT (c
))
640 static char hex
[17] = "0123456789ABCDEF";
645 * buf
++ = hex
[(c
& 0xf0) >> 4];
646 * buf
++ = hex
[c
& 0x0f];
660 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
662 if (ndx
>= filedata
->file_header
.e_shnum
)
663 return _("<corrupt>");
665 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
668 /* Return a pointer to section NAME, or NULL if no such section exists. */
670 static Elf_Internal_Shdr
*
671 find_section (Filedata
* filedata
, const char * name
)
675 if (filedata
->section_headers
== NULL
)
678 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
679 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
680 return filedata
->section_headers
+ i
;
685 /* Return a pointer to a section containing ADDR, or NULL if no such
688 static Elf_Internal_Shdr
*
689 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
693 if (filedata
->section_headers
== NULL
)
696 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
698 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
700 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
707 static Elf_Internal_Shdr
*
708 find_section_by_type (Filedata
* filedata
, unsigned int type
)
712 if (filedata
->section_headers
== NULL
)
715 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
717 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
719 if (sec
->sh_type
== type
)
726 /* Return a pointer to section NAME, or NULL if no such section exists,
727 restricted to the list of sections given in SET. */
729 static Elf_Internal_Shdr
*
730 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
734 if (filedata
->section_headers
== NULL
)
739 while ((i
= *set
++) > 0)
741 /* See PR 21156 for a reproducer. */
742 if (i
>= filedata
->file_header
.e_shnum
)
743 continue; /* FIXME: Should we issue an error message ? */
745 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
746 return filedata
->section_headers
+ i
;
750 return find_section (filedata
, name
);
753 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
754 This OS has so many departures from the ELF standard that we test it at
757 static inline bfd_boolean
758 is_ia64_vms (Filedata
* filedata
)
760 return filedata
->file_header
.e_machine
== EM_IA_64
761 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
764 /* Guess the relocation size commonly used by the specific machines. */
767 guess_is_rela (unsigned int e_machine
)
771 /* Targets that use REL relocations. */
788 /* Targets that use RELA relocations. */
792 case EM_ADAPTEVA_EPIPHANY
:
794 case EM_ALTERA_NIOS2
:
797 case EM_ARC_COMPACT2
:
818 case EM_LATTICEMICO32
:
827 case EM_CYGNUS_MN10200
:
829 case EM_CYGNUS_MN10300
:
865 case EM_MICROBLAZE_OLD
:
887 warn (_("Don't know about relocations on this machine architecture\n"));
892 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
893 Returns TRUE upon success, FALSE otherwise. If successful then a
894 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
895 and the number of relocs loaded is placed in *NRELASP. It is the caller's
896 responsibility to free the allocated buffer. */
899 slurp_rela_relocs (Filedata
* filedata
,
900 unsigned long rel_offset
,
901 unsigned long rel_size
,
902 Elf_Internal_Rela
** relasp
,
903 unsigned long * nrelasp
)
905 Elf_Internal_Rela
* relas
;
911 Elf32_External_Rela
* erelas
;
913 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
914 rel_size
, _("32-bit relocation data"));
918 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
920 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
921 sizeof (Elf_Internal_Rela
));
926 error (_("out of memory parsing relocs\n"));
930 for (i
= 0; i
< nrelas
; i
++)
932 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
933 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
934 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
941 Elf64_External_Rela
* erelas
;
943 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
944 rel_size
, _("64-bit relocation data"));
948 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
950 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
951 sizeof (Elf_Internal_Rela
));
956 error (_("out of memory parsing relocs\n"));
960 for (i
= 0; i
< nrelas
; i
++)
962 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
963 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
964 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
966 /* The #ifdef BFD64 below is to prevent a compile time
967 warning. We know that if we do not have a 64 bit data
968 type that we will never execute this code anyway. */
970 if (filedata
->file_header
.e_machine
== EM_MIPS
971 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
973 /* In little-endian objects, r_info isn't really a
974 64-bit little-endian value: it has a 32-bit
975 little-endian symbol index followed by four
976 individual byte fields. Reorder INFO
978 bfd_vma inf
= relas
[i
].r_info
;
979 inf
= (((inf
& 0xffffffff) << 32)
980 | ((inf
>> 56) & 0xff)
981 | ((inf
>> 40) & 0xff00)
982 | ((inf
>> 24) & 0xff0000)
983 | ((inf
>> 8) & 0xff000000));
984 relas
[i
].r_info
= inf
;
997 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
998 Returns TRUE upon success, FALSE otherwise. If successful then a
999 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1000 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1001 responsibility to free the allocated buffer. */
1004 slurp_rel_relocs (Filedata
* filedata
,
1005 unsigned long rel_offset
,
1006 unsigned long rel_size
,
1007 Elf_Internal_Rela
** relsp
,
1008 unsigned long * nrelsp
)
1010 Elf_Internal_Rela
* rels
;
1016 Elf32_External_Rel
* erels
;
1018 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1019 rel_size
, _("32-bit relocation data"));
1023 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1025 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1030 error (_("out of memory parsing relocs\n"));
1034 for (i
= 0; i
< nrels
; i
++)
1036 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1037 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1038 rels
[i
].r_addend
= 0;
1045 Elf64_External_Rel
* erels
;
1047 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1048 rel_size
, _("64-bit relocation data"));
1052 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1054 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1059 error (_("out of memory parsing relocs\n"));
1063 for (i
= 0; i
< nrels
; i
++)
1065 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1066 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1067 rels
[i
].r_addend
= 0;
1069 /* The #ifdef BFD64 below is to prevent a compile time
1070 warning. We know that if we do not have a 64 bit data
1071 type that we will never execute this code anyway. */
1073 if (filedata
->file_header
.e_machine
== EM_MIPS
1074 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1076 /* In little-endian objects, r_info isn't really a
1077 64-bit little-endian value: it has a 32-bit
1078 little-endian symbol index followed by four
1079 individual byte fields. Reorder INFO
1081 bfd_vma inf
= rels
[i
].r_info
;
1082 inf
= (((inf
& 0xffffffff) << 32)
1083 | ((inf
>> 56) & 0xff)
1084 | ((inf
>> 40) & 0xff00)
1085 | ((inf
>> 24) & 0xff0000)
1086 | ((inf
>> 8) & 0xff000000));
1087 rels
[i
].r_info
= inf
;
1100 /* Returns the reloc type extracted from the reloc info field. */
1103 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1106 return ELF32_R_TYPE (reloc_info
);
1108 switch (filedata
->file_header
.e_machine
)
1111 /* Note: We assume that reloc_info has already been adjusted for us. */
1112 return ELF64_MIPS_R_TYPE (reloc_info
);
1115 return ELF64_R_TYPE_ID (reloc_info
);
1118 return ELF64_R_TYPE (reloc_info
);
1122 /* Return the symbol index extracted from the reloc info field. */
1125 get_reloc_symindex (bfd_vma reloc_info
)
1127 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1130 static inline bfd_boolean
1131 uses_msp430x_relocs (Filedata
* filedata
)
1134 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1135 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1136 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1137 /* TI compiler uses ELFOSABI_NONE. */
1138 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1141 /* Display the contents of the relocation data found at the specified
1145 dump_relocations (Filedata
* filedata
,
1146 unsigned long rel_offset
,
1147 unsigned long rel_size
,
1148 Elf_Internal_Sym
* symtab
,
1149 unsigned long nsyms
,
1151 unsigned long strtablen
,
1153 bfd_boolean is_dynsym
)
1156 Elf_Internal_Rela
* rels
;
1157 bfd_boolean res
= TRUE
;
1159 if (is_rela
== UNKNOWN
)
1160 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1164 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1169 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1178 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1180 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1185 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1187 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1195 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1197 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1202 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1204 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1208 for (i
= 0; i
< rel_size
; i
++)
1213 bfd_vma symtab_index
;
1216 offset
= rels
[i
].r_offset
;
1217 inf
= rels
[i
].r_info
;
1219 type
= get_reloc_type (filedata
, inf
);
1220 symtab_index
= get_reloc_symindex (inf
);
1224 printf ("%8.8lx %8.8lx ",
1225 (unsigned long) offset
& 0xffffffff,
1226 (unsigned long) inf
& 0xffffffff);
1230 #if BFD_HOST_64BIT_LONG
1232 ? "%16.16lx %16.16lx "
1233 : "%12.12lx %12.12lx ",
1235 #elif BFD_HOST_64BIT_LONG_LONG
1238 ? "%16.16llx %16.16llx "
1239 : "%12.12llx %12.12llx ",
1243 ? "%16.16I64x %16.16I64x "
1244 : "%12.12I64x %12.12I64x ",
1249 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1250 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1251 _bfd_int64_high (offset
),
1252 _bfd_int64_low (offset
),
1253 _bfd_int64_high (inf
),
1254 _bfd_int64_low (inf
));
1258 switch (filedata
->file_header
.e_machine
)
1265 rtype
= elf_aarch64_reloc_type (type
);
1269 case EM_CYGNUS_M32R
:
1270 rtype
= elf_m32r_reloc_type (type
);
1275 rtype
= elf_i386_reloc_type (type
);
1280 rtype
= elf_m68hc11_reloc_type (type
);
1284 rtype
= elf_s12z_reloc_type (type
);
1288 rtype
= elf_m68k_reloc_type (type
);
1292 rtype
= elf_i960_reloc_type (type
);
1297 rtype
= elf_avr_reloc_type (type
);
1300 case EM_OLD_SPARCV9
:
1301 case EM_SPARC32PLUS
:
1304 rtype
= elf_sparc_reloc_type (type
);
1308 rtype
= elf_spu_reloc_type (type
);
1312 rtype
= v800_reloc_type (type
);
1315 case EM_CYGNUS_V850
:
1316 rtype
= v850_reloc_type (type
);
1320 case EM_CYGNUS_D10V
:
1321 rtype
= elf_d10v_reloc_type (type
);
1325 case EM_CYGNUS_D30V
:
1326 rtype
= elf_d30v_reloc_type (type
);
1330 rtype
= elf_dlx_reloc_type (type
);
1334 rtype
= elf_sh_reloc_type (type
);
1338 case EM_CYGNUS_MN10300
:
1339 rtype
= elf_mn10300_reloc_type (type
);
1343 case EM_CYGNUS_MN10200
:
1344 rtype
= elf_mn10200_reloc_type (type
);
1348 case EM_CYGNUS_FR30
:
1349 rtype
= elf_fr30_reloc_type (type
);
1353 rtype
= elf_frv_reloc_type (type
);
1357 rtype
= elf_csky_reloc_type (type
);
1361 rtype
= elf_ft32_reloc_type (type
);
1365 rtype
= elf_mcore_reloc_type (type
);
1369 rtype
= elf_mmix_reloc_type (type
);
1373 rtype
= elf_moxie_reloc_type (type
);
1377 if (uses_msp430x_relocs (filedata
))
1379 rtype
= elf_msp430x_reloc_type (type
);
1384 rtype
= elf_msp430_reloc_type (type
);
1388 rtype
= elf_nds32_reloc_type (type
);
1392 rtype
= elf_ppc_reloc_type (type
);
1396 rtype
= elf_ppc64_reloc_type (type
);
1400 case EM_MIPS_RS3_LE
:
1401 rtype
= elf_mips_reloc_type (type
);
1405 rtype
= elf_riscv_reloc_type (type
);
1409 rtype
= elf_alpha_reloc_type (type
);
1413 rtype
= elf_arm_reloc_type (type
);
1417 case EM_ARC_COMPACT
:
1418 case EM_ARC_COMPACT2
:
1419 rtype
= elf_arc_reloc_type (type
);
1423 rtype
= elf_hppa_reloc_type (type
);
1429 rtype
= elf_h8_reloc_type (type
);
1433 rtype
= elf_or1k_reloc_type (type
);
1438 rtype
= elf_pj_reloc_type (type
);
1441 rtype
= elf_ia64_reloc_type (type
);
1445 rtype
= elf_cris_reloc_type (type
);
1449 rtype
= elf_i860_reloc_type (type
);
1455 rtype
= elf_x86_64_reloc_type (type
);
1459 rtype
= i370_reloc_type (type
);
1464 rtype
= elf_s390_reloc_type (type
);
1468 rtype
= elf_score_reloc_type (type
);
1472 rtype
= elf_xstormy16_reloc_type (type
);
1476 rtype
= elf_crx_reloc_type (type
);
1480 rtype
= elf_vax_reloc_type (type
);
1484 rtype
= elf_visium_reloc_type (type
);
1488 rtype
= elf_bpf_reloc_type (type
);
1491 case EM_ADAPTEVA_EPIPHANY
:
1492 rtype
= elf_epiphany_reloc_type (type
);
1497 rtype
= elf_ip2k_reloc_type (type
);
1501 rtype
= elf_iq2000_reloc_type (type
);
1506 rtype
= elf_xtensa_reloc_type (type
);
1509 case EM_LATTICEMICO32
:
1510 rtype
= elf_lm32_reloc_type (type
);
1515 rtype
= elf_m32c_reloc_type (type
);
1519 rtype
= elf_mt_reloc_type (type
);
1523 rtype
= elf_bfin_reloc_type (type
);
1527 rtype
= elf_mep_reloc_type (type
);
1531 rtype
= elf_cr16_reloc_type (type
);
1535 case EM_MICROBLAZE_OLD
:
1536 rtype
= elf_microblaze_reloc_type (type
);
1540 rtype
= elf_rl78_reloc_type (type
);
1544 rtype
= elf_rx_reloc_type (type
);
1548 rtype
= elf_metag_reloc_type (type
);
1553 rtype
= elf_xc16x_reloc_type (type
);
1557 rtype
= elf_tic6x_reloc_type (type
);
1561 rtype
= elf_tilegx_reloc_type (type
);
1565 rtype
= elf_tilepro_reloc_type (type
);
1568 case EM_WEBASSEMBLY
:
1569 rtype
= elf_wasm32_reloc_type (type
);
1573 rtype
= elf_xgate_reloc_type (type
);
1576 case EM_ALTERA_NIOS2
:
1577 rtype
= elf_nios2_reloc_type (type
);
1581 rtype
= elf_pru_reloc_type (type
);
1585 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1586 rtype
= elf_nfp3200_reloc_type (type
);
1588 rtype
= elf_nfp_reloc_type (type
);
1592 rtype
= elf_z80_reloc_type (type
);
1597 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1599 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1601 if (filedata
->file_header
.e_machine
== EM_ALPHA
1603 && streq (rtype
, "R_ALPHA_LITUSE")
1606 switch (rels
[i
].r_addend
)
1608 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1609 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1610 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1611 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1612 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1613 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1614 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1615 default: rtype
= NULL
;
1619 printf (" (%s)", rtype
);
1623 printf (_("<unknown addend: %lx>"),
1624 (unsigned long) rels
[i
].r_addend
);
1628 else if (symtab_index
)
1630 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1632 error (_(" bad symbol index: %08lx in reloc\n"),
1633 (unsigned long) symtab_index
);
1638 Elf_Internal_Sym
* psym
;
1639 const char * version_string
;
1640 enum versioned_symbol_info sym_info
;
1641 unsigned short vna_other
;
1643 psym
= symtab
+ symtab_index
;
1646 = get_symbol_version_string (filedata
, is_dynsym
,
1655 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1659 unsigned int width
= is_32bit_elf
? 8 : 14;
1661 /* Relocations against GNU_IFUNC symbols do not use the value
1662 of the symbol as the address to relocate against. Instead
1663 they invoke the function named by the symbol and use its
1664 result as the address for relocation.
1666 To indicate this to the user, do not display the value of
1667 the symbol in the "Symbols's Value" field. Instead show
1668 its name followed by () as a hint that the symbol is
1672 || psym
->st_name
== 0
1673 || psym
->st_name
>= strtablen
)
1676 name
= strtab
+ psym
->st_name
;
1678 len
= print_symbol (width
, name
);
1680 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1682 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1686 print_vma (psym
->st_value
, LONG_HEX
);
1688 printf (is_32bit_elf
? " " : " ");
1691 if (psym
->st_name
== 0)
1693 const char * sec_name
= "<null>";
1696 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1698 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1699 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1700 else if (psym
->st_shndx
== SHN_ABS
)
1702 else if (psym
->st_shndx
== SHN_COMMON
)
1703 sec_name
= "COMMON";
1704 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1705 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1706 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1707 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1708 sec_name
= "SCOMMON";
1709 else if (filedata
->file_header
.e_machine
== EM_MIPS
1710 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1711 sec_name
= "SUNDEF";
1712 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1713 || filedata
->file_header
.e_machine
== EM_L1OM
1714 || filedata
->file_header
.e_machine
== EM_K1OM
)
1715 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1716 sec_name
= "LARGE_COMMON";
1717 else if (filedata
->file_header
.e_machine
== EM_IA_64
1718 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1719 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1720 sec_name
= "ANSI_COM";
1721 else if (is_ia64_vms (filedata
)
1722 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1723 sec_name
= "VMS_SYMVEC";
1726 sprintf (name_buf
, "<section 0x%x>",
1727 (unsigned int) psym
->st_shndx
);
1728 sec_name
= name_buf
;
1731 print_symbol (22, sec_name
);
1733 else if (strtab
== NULL
)
1734 printf (_("<string table index: %3ld>"), psym
->st_name
);
1735 else if (psym
->st_name
>= strtablen
)
1737 error (_("<corrupt string table index: %3ld>\n"),
1743 print_symbol (22, strtab
+ psym
->st_name
);
1745 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1751 bfd_vma off
= rels
[i
].r_addend
;
1753 if ((bfd_signed_vma
) off
< 0)
1754 printf (" - %" BFD_VMA_FMT
"x", - off
);
1756 printf (" + %" BFD_VMA_FMT
"x", off
);
1762 bfd_vma off
= rels
[i
].r_addend
;
1764 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1765 if ((bfd_signed_vma
) off
< 0)
1766 printf ("-%" BFD_VMA_FMT
"x", - off
);
1768 printf ("%" BFD_VMA_FMT
"x", off
);
1771 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1773 && streq (rtype
, "R_SPARC_OLO10"))
1774 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1779 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1781 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1782 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1783 const char * rtype2
= elf_mips_reloc_type (type2
);
1784 const char * rtype3
= elf_mips_reloc_type (type3
);
1786 printf (" Type2: ");
1789 printf (_("unrecognized: %-7lx"),
1790 (unsigned long) type2
& 0xffffffff);
1792 printf ("%-17.17s", rtype2
);
1794 printf ("\n Type3: ");
1797 printf (_("unrecognized: %-7lx"),
1798 (unsigned long) type3
& 0xffffffff);
1800 printf ("%-17.17s", rtype3
);
1813 get_aarch64_dynamic_type (unsigned long type
)
1817 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1818 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1819 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1826 get_mips_dynamic_type (unsigned long type
)
1830 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1831 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1832 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1833 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1834 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1835 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1836 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1837 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1838 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1839 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1840 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1841 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1842 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1843 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1844 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1845 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1846 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1847 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1848 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1849 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1850 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1851 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1852 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1853 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1854 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1855 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1856 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1857 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1858 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1859 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1860 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1861 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1862 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1863 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1864 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1865 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1866 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1867 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1868 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1869 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1870 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1871 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1872 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1873 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1874 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1875 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1876 case DT_MIPS_XHASH
: return "MIPS_XHASH";
1883 get_sparc64_dynamic_type (unsigned long type
)
1887 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1894 get_ppc_dynamic_type (unsigned long type
)
1898 case DT_PPC_GOT
: return "PPC_GOT";
1899 case DT_PPC_OPT
: return "PPC_OPT";
1906 get_ppc64_dynamic_type (unsigned long type
)
1910 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1911 case DT_PPC64_OPD
: return "PPC64_OPD";
1912 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1913 case DT_PPC64_OPT
: return "PPC64_OPT";
1920 get_parisc_dynamic_type (unsigned long type
)
1924 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1925 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1926 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1927 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1928 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1929 case DT_HP_PREINIT
: return "HP_PREINIT";
1930 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1931 case DT_HP_NEEDED
: return "HP_NEEDED";
1932 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1933 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1934 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1935 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1936 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1937 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1938 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1939 case DT_HP_FILTERED
: return "HP_FILTERED";
1940 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1941 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1942 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1943 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1944 case DT_PLT
: return "PLT";
1945 case DT_PLT_SIZE
: return "PLT_SIZE";
1946 case DT_DLT
: return "DLT";
1947 case DT_DLT_SIZE
: return "DLT_SIZE";
1954 get_ia64_dynamic_type (unsigned long type
)
1958 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1959 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1960 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1961 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1962 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1963 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1964 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1965 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1966 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1967 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1968 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1969 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1970 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1971 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1972 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1973 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1974 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1975 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1976 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1977 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1978 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1979 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1980 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1981 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1982 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1983 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1984 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1985 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1986 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1987 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1988 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1995 get_solaris_section_type (unsigned long type
)
1999 case 0x6fffffee: return "SUNW_ancillary";
2000 case 0x6fffffef: return "SUNW_capchain";
2001 case 0x6ffffff0: return "SUNW_capinfo";
2002 case 0x6ffffff1: return "SUNW_symsort";
2003 case 0x6ffffff2: return "SUNW_tlssort";
2004 case 0x6ffffff3: return "SUNW_LDYNSYM";
2005 case 0x6ffffff4: return "SUNW_dof";
2006 case 0x6ffffff5: return "SUNW_cap";
2007 case 0x6ffffff6: return "SUNW_SIGNATURE";
2008 case 0x6ffffff7: return "SUNW_ANNOTATE";
2009 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2010 case 0x6ffffff9: return "SUNW_DEBUG";
2011 case 0x6ffffffa: return "SUNW_move";
2012 case 0x6ffffffb: return "SUNW_COMDAT";
2013 case 0x6ffffffc: return "SUNW_syminfo";
2014 case 0x6ffffffd: return "SUNW_verdef";
2015 case 0x6ffffffe: return "SUNW_verneed";
2016 case 0x6fffffff: return "SUNW_versym";
2017 case 0x70000000: return "SPARC_GOTDATA";
2018 default: return NULL
;
2023 get_alpha_dynamic_type (unsigned long type
)
2027 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2028 default: return NULL
;
2033 get_score_dynamic_type (unsigned long type
)
2037 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2038 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2039 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2040 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2041 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2042 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2043 default: return NULL
;
2048 get_tic6x_dynamic_type (unsigned long type
)
2052 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2053 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2054 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2055 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2056 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2057 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2058 default: return NULL
;
2063 get_nios2_dynamic_type (unsigned long type
)
2067 case DT_NIOS2_GP
: return "NIOS2_GP";
2068 default: return NULL
;
2073 get_solaris_dynamic_type (unsigned long type
)
2077 case 0x6000000d: return "SUNW_AUXILIARY";
2078 case 0x6000000e: return "SUNW_RTLDINF";
2079 case 0x6000000f: return "SUNW_FILTER";
2080 case 0x60000010: return "SUNW_CAP";
2081 case 0x60000011: return "SUNW_SYMTAB";
2082 case 0x60000012: return "SUNW_SYMSZ";
2083 case 0x60000013: return "SUNW_SORTENT";
2084 case 0x60000014: return "SUNW_SYMSORT";
2085 case 0x60000015: return "SUNW_SYMSORTSZ";
2086 case 0x60000016: return "SUNW_TLSSORT";
2087 case 0x60000017: return "SUNW_TLSSORTSZ";
2088 case 0x60000018: return "SUNW_CAPINFO";
2089 case 0x60000019: return "SUNW_STRPAD";
2090 case 0x6000001a: return "SUNW_CAPCHAIN";
2091 case 0x6000001b: return "SUNW_LDMACH";
2092 case 0x6000001d: return "SUNW_CAPCHAINENT";
2093 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2094 case 0x60000021: return "SUNW_PARENT";
2095 case 0x60000023: return "SUNW_ASLR";
2096 case 0x60000025: return "SUNW_RELAX";
2097 case 0x60000029: return "SUNW_NXHEAP";
2098 case 0x6000002b: return "SUNW_NXSTACK";
2100 case 0x70000001: return "SPARC_REGISTER";
2101 case 0x7ffffffd: return "AUXILIARY";
2102 case 0x7ffffffe: return "USED";
2103 case 0x7fffffff: return "FILTER";
2105 default: return NULL
;
2110 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2112 static char buff
[64];
2116 case DT_NULL
: return "NULL";
2117 case DT_NEEDED
: return "NEEDED";
2118 case DT_PLTRELSZ
: return "PLTRELSZ";
2119 case DT_PLTGOT
: return "PLTGOT";
2120 case DT_HASH
: return "HASH";
2121 case DT_STRTAB
: return "STRTAB";
2122 case DT_SYMTAB
: return "SYMTAB";
2123 case DT_RELA
: return "RELA";
2124 case DT_RELASZ
: return "RELASZ";
2125 case DT_RELAENT
: return "RELAENT";
2126 case DT_STRSZ
: return "STRSZ";
2127 case DT_SYMENT
: return "SYMENT";
2128 case DT_INIT
: return "INIT";
2129 case DT_FINI
: return "FINI";
2130 case DT_SONAME
: return "SONAME";
2131 case DT_RPATH
: return "RPATH";
2132 case DT_SYMBOLIC
: return "SYMBOLIC";
2133 case DT_REL
: return "REL";
2134 case DT_RELSZ
: return "RELSZ";
2135 case DT_RELENT
: return "RELENT";
2136 case DT_PLTREL
: return "PLTREL";
2137 case DT_DEBUG
: return "DEBUG";
2138 case DT_TEXTREL
: return "TEXTREL";
2139 case DT_JMPREL
: return "JMPREL";
2140 case DT_BIND_NOW
: return "BIND_NOW";
2141 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2142 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2143 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2144 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2145 case DT_RUNPATH
: return "RUNPATH";
2146 case DT_FLAGS
: return "FLAGS";
2148 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2149 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2150 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2152 case DT_CHECKSUM
: return "CHECKSUM";
2153 case DT_PLTPADSZ
: return "PLTPADSZ";
2154 case DT_MOVEENT
: return "MOVEENT";
2155 case DT_MOVESZ
: return "MOVESZ";
2156 case DT_FEATURE
: return "FEATURE";
2157 case DT_POSFLAG_1
: return "POSFLAG_1";
2158 case DT_SYMINSZ
: return "SYMINSZ";
2159 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2161 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2162 case DT_CONFIG
: return "CONFIG";
2163 case DT_DEPAUDIT
: return "DEPAUDIT";
2164 case DT_AUDIT
: return "AUDIT";
2165 case DT_PLTPAD
: return "PLTPAD";
2166 case DT_MOVETAB
: return "MOVETAB";
2167 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2169 case DT_VERSYM
: return "VERSYM";
2171 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2172 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2173 case DT_RELACOUNT
: return "RELACOUNT";
2174 case DT_RELCOUNT
: return "RELCOUNT";
2175 case DT_FLAGS_1
: return "FLAGS_1";
2176 case DT_VERDEF
: return "VERDEF";
2177 case DT_VERDEFNUM
: return "VERDEFNUM";
2178 case DT_VERNEED
: return "VERNEED";
2179 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2181 case DT_AUXILIARY
: return "AUXILIARY";
2182 case DT_USED
: return "USED";
2183 case DT_FILTER
: return "FILTER";
2185 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2186 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2187 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2188 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2189 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2190 case DT_GNU_HASH
: return "GNU_HASH";
2193 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2195 const char * result
;
2197 switch (filedata
->file_header
.e_machine
)
2200 result
= get_aarch64_dynamic_type (type
);
2203 case EM_MIPS_RS3_LE
:
2204 result
= get_mips_dynamic_type (type
);
2207 result
= get_sparc64_dynamic_type (type
);
2210 result
= get_ppc_dynamic_type (type
);
2213 result
= get_ppc64_dynamic_type (type
);
2216 result
= get_ia64_dynamic_type (type
);
2219 result
= get_alpha_dynamic_type (type
);
2222 result
= get_score_dynamic_type (type
);
2225 result
= get_tic6x_dynamic_type (type
);
2227 case EM_ALTERA_NIOS2
:
2228 result
= get_nios2_dynamic_type (type
);
2231 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2232 result
= get_solaris_dynamic_type (type
);
2241 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2243 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2244 || (filedata
->file_header
.e_machine
== EM_PARISC
2245 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2247 const char * result
;
2249 switch (filedata
->file_header
.e_machine
)
2252 result
= get_parisc_dynamic_type (type
);
2255 result
= get_ia64_dynamic_type (type
);
2258 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2259 result
= get_solaris_dynamic_type (type
);
2268 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2272 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2279 get_file_type (unsigned e_type
)
2281 static char buff
[32];
2285 case ET_NONE
: return _("NONE (None)");
2286 case ET_REL
: return _("REL (Relocatable file)");
2287 case ET_EXEC
: return _("EXEC (Executable file)");
2288 case ET_DYN
: return _("DYN (Shared object file)");
2289 case ET_CORE
: return _("CORE (Core file)");
2292 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2293 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2294 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2295 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2297 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2303 get_machine_name (unsigned e_machine
)
2305 static char buff
[64]; /* XXX */
2309 /* Please keep this switch table sorted by increasing EM_ value. */
2311 case EM_NONE
: return _("None");
2312 case EM_M32
: return "WE32100";
2313 case EM_SPARC
: return "Sparc";
2314 case EM_386
: return "Intel 80386";
2315 case EM_68K
: return "MC68000";
2316 case EM_88K
: return "MC88000";
2317 case EM_IAMCU
: return "Intel MCU";
2318 case EM_860
: return "Intel 80860";
2319 case EM_MIPS
: return "MIPS R3000";
2320 case EM_S370
: return "IBM System/370";
2322 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2323 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2324 case EM_PARISC
: return "HPPA";
2325 case EM_VPP550
: return "Fujitsu VPP500";
2326 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2327 case EM_960
: return "Intel 80960";
2328 case EM_PPC
: return "PowerPC";
2330 case EM_PPC64
: return "PowerPC64";
2332 case EM_S390
: return "IBM S/390";
2333 case EM_SPU
: return "SPU";
2335 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2336 case EM_FR20
: return "Fujitsu FR20";
2337 case EM_RH32
: return "TRW RH32";
2338 case EM_MCORE
: return "MCORE";
2340 case EM_ARM
: return "ARM";
2341 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2342 case EM_SH
: return "Renesas / SuperH SH";
2343 case EM_SPARCV9
: return "Sparc v9";
2344 case EM_TRICORE
: return "Siemens Tricore";
2345 case EM_ARC
: return "ARC";
2346 case EM_H8_300
: return "Renesas H8/300";
2347 case EM_H8_300H
: return "Renesas H8/300H";
2348 case EM_H8S
: return "Renesas H8S";
2349 case EM_H8_500
: return "Renesas H8/500";
2351 case EM_IA_64
: return "Intel IA-64";
2352 case EM_MIPS_X
: return "Stanford MIPS-X";
2353 case EM_COLDFIRE
: return "Motorola Coldfire";
2354 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2355 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2356 case EM_PCP
: return "Siemens PCP";
2357 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2358 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2359 case EM_STARCORE
: return "Motorola Star*Core processor";
2360 case EM_ME16
: return "Toyota ME16 processor";
2362 case EM_ST100
: return "STMicroelectronics ST100 processor";
2363 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2364 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2365 case EM_PDSP
: return "Sony DSP processor";
2366 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2367 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2368 case EM_FX66
: return "Siemens FX66 microcontroller";
2369 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2370 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2371 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2373 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2374 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2375 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2376 case EM_SVX
: return "Silicon Graphics SVx";
2377 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2378 case EM_VAX
: return "Digital VAX";
2379 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2380 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2381 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2382 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2384 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2385 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2386 case EM_PRISM
: return "Vitesse Prism";
2388 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2389 case EM_CYGNUS_FR30
:
2390 case EM_FR30
: return "Fujitsu FR30";
2391 case EM_CYGNUS_D10V
:
2392 case EM_D10V
: return "d10v";
2393 case EM_CYGNUS_D30V
:
2394 case EM_D30V
: return "d30v";
2395 case EM_CYGNUS_V850
:
2396 case EM_V850
: return "Renesas V850";
2397 case EM_CYGNUS_M32R
:
2398 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2399 case EM_CYGNUS_MN10300
:
2400 case EM_MN10300
: return "mn10300";
2402 case EM_CYGNUS_MN10200
:
2403 case EM_MN10200
: return "mn10200";
2404 case EM_PJ
: return "picoJava";
2405 case EM_OR1K
: return "OpenRISC 1000";
2406 case EM_ARC_COMPACT
: return "ARCompact";
2408 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2409 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2410 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2411 case EM_NS32K
: return "National Semiconductor 32000 series";
2412 case EM_TPC
: return "Tenor Network TPC processor";
2413 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2415 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2417 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2418 case EM_MAX
: return "MAX Processor";
2419 case EM_CR
: return "National Semiconductor CompactRISC";
2420 case EM_F2MC16
: return "Fujitsu F2MC16";
2421 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2422 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2423 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2424 case EM_SEP
: return "Sharp embedded microprocessor";
2425 case EM_ARCA
: return "Arca RISC microprocessor";
2427 case EM_UNICORE
: return "Unicore";
2428 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2429 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2430 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2431 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2432 case EM_XGATE
: return "Motorola XGATE embedded processor";
2434 case EM_XC16X
: return "Infineon Technologies xc16x";
2435 case EM_M16C
: return "Renesas M16C series microprocessors";
2436 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2437 case EM_CE
: return "Freescale Communication Engine RISC core";
2439 case EM_M32C
: return "Renesas M32c";
2441 case EM_TSK3000
: return "Altium TSK3000 core";
2442 case EM_RS08
: return "Freescale RS08 embedded processor";
2443 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2444 case EM_SCORE
: return "SUNPLUS S+Core";
2445 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2446 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2447 case EM_LATTICEMICO32
: return "Lattice Mico32";
2448 case EM_SE_C17
: return "Seiko Epson C17 family";
2450 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2451 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2452 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2453 case EM_TI_PRU
: return "TI PRU I/O processor";
2455 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2456 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2457 case EM_R32C
: return "Renesas R32C series microprocessors";
2458 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2459 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2460 case EM_8051
: return "Intel 8051 and variants";
2461 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2462 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2463 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2464 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2466 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2467 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2468 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2469 case EM_RX
: return "Renesas RX";
2470 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2471 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2472 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2475 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2476 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2477 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2479 case EM_L1OM
: return "Intel L1OM";
2480 case EM_K1OM
: return "Intel K1OM";
2481 case EM_INTEL182
: return "Intel (reserved)";
2482 case EM_AARCH64
: return "AArch64";
2483 case EM_ARM184
: return "ARM (reserved)";
2484 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2485 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2486 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2487 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2489 case EM_CUDA
: return "NVIDIA CUDA architecture";
2490 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2491 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2492 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2493 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2494 case EM_ARC_COMPACT2
: return "ARCv2";
2495 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2496 case EM_RL78
: return "Renesas RL78";
2497 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2498 case EM_78K0R
: return "Renesas 78K0R";
2500 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2501 case EM_BA1
: return "Beyond BA1 CPU architecture";
2502 case EM_BA2
: return "Beyond BA2 CPU architecture";
2503 case EM_XCORE
: return "XMOS xCORE processor family";
2504 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2506 case EM_KM32
: return "KM211 KM32 32-bit processor";
2507 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2508 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2509 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2510 case EM_KVARC
: return "KM211 KVARC processor";
2511 case EM_CDP
: return "Paneve CDP architecture family";
2512 case EM_COGE
: return "Cognitive Smart Memory Processor";
2513 case EM_COOL
: return "Bluechip Systems CoolEngine";
2514 case EM_NORC
: return "Nanoradio Optimized RISC";
2515 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2517 case EM_Z80
: return "Zilog Z80";
2518 case EM_VISIUM
: return "CDS VISIUMcore processor";
2519 case EM_FT32
: return "FTDI Chip FT32";
2520 case EM_MOXIE
: return "Moxie";
2521 case EM_AMDGPU
: return "AMD GPU";
2522 case EM_RISCV
: return "RISC-V";
2523 case EM_LANAI
: return "Lanai 32-bit processor";
2524 case EM_BPF
: return "Linux BPF";
2525 case EM_NFP
: return "Netronome Flow Processor";
2527 /* Large numbers... */
2528 case EM_MT
: return "Morpho Techologies MT processor";
2529 case EM_ALPHA
: return "Alpha";
2530 case EM_WEBASSEMBLY
: return "Web Assembly";
2531 case EM_DLX
: return "OpenDLX";
2532 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2533 case EM_IQ2000
: return "Vitesse IQ2000";
2535 case EM_NIOS32
: return "Altera Nios";
2536 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2537 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2538 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2539 case EM_S12Z
: return "Freescale S12Z";
2540 case EM_CSKY
: return "C-SKY";
2543 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2549 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2551 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2552 other compilers don't a specific architecture type in the e_flags, and
2553 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2554 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2557 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2558 but also sets a specific architecture type in the e_flags field.
2560 However, when decoding the flags we don't worry if we see an
2561 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2562 ARCEM architecture type. */
2564 switch (e_flags
& EF_ARC_MACH_MSK
)
2566 /* We only expect these to occur for EM_ARC_COMPACT2. */
2567 case EF_ARC_CPU_ARCV2EM
:
2568 strcat (buf
, ", ARC EM");
2570 case EF_ARC_CPU_ARCV2HS
:
2571 strcat (buf
, ", ARC HS");
2574 /* We only expect these to occur for EM_ARC_COMPACT. */
2575 case E_ARC_MACH_ARC600
:
2576 strcat (buf
, ", ARC600");
2578 case E_ARC_MACH_ARC601
:
2579 strcat (buf
, ", ARC601");
2581 case E_ARC_MACH_ARC700
:
2582 strcat (buf
, ", ARC700");
2585 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2586 new ELF with new architecture being read by an old version of
2587 readelf, or (c) An ELF built with non-GNU compiler that does not
2588 set the architecture in the e_flags. */
2590 if (e_machine
== EM_ARC_COMPACT
)
2591 strcat (buf
, ", Unknown ARCompact");
2593 strcat (buf
, ", Unknown ARC");
2597 switch (e_flags
& EF_ARC_OSABI_MSK
)
2599 case E_ARC_OSABI_ORIG
:
2600 strcat (buf
, ", (ABI:legacy)");
2602 case E_ARC_OSABI_V2
:
2603 strcat (buf
, ", (ABI:v2)");
2605 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2606 case E_ARC_OSABI_V3
:
2607 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2609 case E_ARC_OSABI_V4
:
2610 strcat (buf
, ", v4 ABI");
2613 strcat (buf
, ", unrecognised ARC OSABI flag");
2619 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2622 bfd_boolean unknown
= FALSE
;
2624 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2625 e_flags
&= ~ EF_ARM_EABIMASK
;
2627 /* Handle "generic" ARM flags. */
2628 if (e_flags
& EF_ARM_RELEXEC
)
2630 strcat (buf
, ", relocatable executable");
2631 e_flags
&= ~ EF_ARM_RELEXEC
;
2634 if (e_flags
& EF_ARM_PIC
)
2636 strcat (buf
, ", position independent");
2637 e_flags
&= ~ EF_ARM_PIC
;
2640 /* Now handle EABI specific flags. */
2644 strcat (buf
, ", <unrecognized EABI>");
2649 case EF_ARM_EABI_VER1
:
2650 strcat (buf
, ", Version1 EABI");
2655 /* Process flags one bit at a time. */
2656 flag
= e_flags
& - e_flags
;
2661 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2662 strcat (buf
, ", sorted symbol tables");
2672 case EF_ARM_EABI_VER2
:
2673 strcat (buf
, ", Version2 EABI");
2678 /* Process flags one bit at a time. */
2679 flag
= e_flags
& - e_flags
;
2684 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2685 strcat (buf
, ", sorted symbol tables");
2688 case EF_ARM_DYNSYMSUSESEGIDX
:
2689 strcat (buf
, ", dynamic symbols use segment index");
2692 case EF_ARM_MAPSYMSFIRST
:
2693 strcat (buf
, ", mapping symbols precede others");
2703 case EF_ARM_EABI_VER3
:
2704 strcat (buf
, ", Version3 EABI");
2707 case EF_ARM_EABI_VER4
:
2708 strcat (buf
, ", Version4 EABI");
2713 /* Process flags one bit at a time. */
2714 flag
= e_flags
& - e_flags
;
2720 strcat (buf
, ", BE8");
2724 strcat (buf
, ", LE8");
2734 case EF_ARM_EABI_VER5
:
2735 strcat (buf
, ", Version5 EABI");
2740 /* Process flags one bit at a time. */
2741 flag
= e_flags
& - e_flags
;
2747 strcat (buf
, ", BE8");
2751 strcat (buf
, ", LE8");
2754 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2755 strcat (buf
, ", soft-float ABI");
2758 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2759 strcat (buf
, ", hard-float ABI");
2769 case EF_ARM_EABI_UNKNOWN
:
2770 strcat (buf
, ", GNU EABI");
2775 /* Process flags one bit at a time. */
2776 flag
= e_flags
& - e_flags
;
2781 case EF_ARM_INTERWORK
:
2782 strcat (buf
, ", interworking enabled");
2785 case EF_ARM_APCS_26
:
2786 strcat (buf
, ", uses APCS/26");
2789 case EF_ARM_APCS_FLOAT
:
2790 strcat (buf
, ", uses APCS/float");
2794 strcat (buf
, ", position independent");
2798 strcat (buf
, ", 8 bit structure alignment");
2801 case EF_ARM_NEW_ABI
:
2802 strcat (buf
, ", uses new ABI");
2805 case EF_ARM_OLD_ABI
:
2806 strcat (buf
, ", uses old ABI");
2809 case EF_ARM_SOFT_FLOAT
:
2810 strcat (buf
, ", software FP");
2813 case EF_ARM_VFP_FLOAT
:
2814 strcat (buf
, ", VFP");
2817 case EF_ARM_MAVERICK_FLOAT
:
2818 strcat (buf
, ", Maverick FP");
2829 strcat (buf
,_(", <unknown>"));
2833 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2835 --size
; /* Leave space for null terminator. */
2837 switch (e_flags
& EF_AVR_MACH
)
2839 case E_AVR_MACH_AVR1
:
2840 strncat (buf
, ", avr:1", size
);
2842 case E_AVR_MACH_AVR2
:
2843 strncat (buf
, ", avr:2", size
);
2845 case E_AVR_MACH_AVR25
:
2846 strncat (buf
, ", avr:25", size
);
2848 case E_AVR_MACH_AVR3
:
2849 strncat (buf
, ", avr:3", size
);
2851 case E_AVR_MACH_AVR31
:
2852 strncat (buf
, ", avr:31", size
);
2854 case E_AVR_MACH_AVR35
:
2855 strncat (buf
, ", avr:35", size
);
2857 case E_AVR_MACH_AVR4
:
2858 strncat (buf
, ", avr:4", size
);
2860 case E_AVR_MACH_AVR5
:
2861 strncat (buf
, ", avr:5", size
);
2863 case E_AVR_MACH_AVR51
:
2864 strncat (buf
, ", avr:51", size
);
2866 case E_AVR_MACH_AVR6
:
2867 strncat (buf
, ", avr:6", size
);
2869 case E_AVR_MACH_AVRTINY
:
2870 strncat (buf
, ", avr:100", size
);
2872 case E_AVR_MACH_XMEGA1
:
2873 strncat (buf
, ", avr:101", size
);
2875 case E_AVR_MACH_XMEGA2
:
2876 strncat (buf
, ", avr:102", size
);
2878 case E_AVR_MACH_XMEGA3
:
2879 strncat (buf
, ", avr:103", size
);
2881 case E_AVR_MACH_XMEGA4
:
2882 strncat (buf
, ", avr:104", size
);
2884 case E_AVR_MACH_XMEGA5
:
2885 strncat (buf
, ", avr:105", size
);
2887 case E_AVR_MACH_XMEGA6
:
2888 strncat (buf
, ", avr:106", size
);
2890 case E_AVR_MACH_XMEGA7
:
2891 strncat (buf
, ", avr:107", size
);
2894 strncat (buf
, ", avr:<unknown>", size
);
2898 size
-= strlen (buf
);
2899 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2900 strncat (buf
, ", link-relax", size
);
2904 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2910 bfd_boolean has_fpu
= FALSE
;
2913 static const char *ABI_STRINGS
[] =
2915 "ABI v0", /* use r5 as return register; only used in N1213HC */
2916 "ABI v1", /* use r0 as return register */
2917 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2918 "ABI v2fp", /* for FPU */
2922 static const char *VER_STRINGS
[] =
2924 "Andes ELF V1.3 or older",
2928 static const char *ARCH_STRINGS
[] =
2937 abi
= EF_NDS_ABI
& e_flags
;
2938 arch
= EF_NDS_ARCH
& e_flags
;
2939 config
= EF_NDS_INST
& e_flags
;
2940 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2942 memset (buf
, 0, size
);
2949 case E_NDS_ABI_V2FP
:
2950 case E_NDS_ABI_AABI
:
2951 case E_NDS_ABI_V2FP_PLUS
:
2952 /* In case there are holes in the array. */
2953 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2957 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2963 case E_NDS32_ELF_VER_1_2
:
2964 case E_NDS32_ELF_VER_1_3
:
2965 case E_NDS32_ELF_VER_1_4
:
2966 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2970 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2974 if (E_NDS_ABI_V0
== abi
)
2976 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2977 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2978 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2979 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2985 case E_NDS_ARCH_STAR_V1_0
:
2986 case E_NDS_ARCH_STAR_V2_0
:
2987 case E_NDS_ARCH_STAR_V3_0
:
2988 case E_NDS_ARCH_STAR_V3_M
:
2989 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2993 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2994 /* ARCH version determines how the e_flags are interpreted.
2995 If it is unknown, we cannot proceed. */
2999 /* Newer ABI; Now handle architecture specific flags. */
3000 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3002 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3003 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3005 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3006 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3008 if (config
& E_NDS32_HAS_DIV_INST
)
3009 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3011 if (config
& E_NDS32_HAS_16BIT_INST
)
3012 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3016 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3018 if (version
<= E_NDS32_ELF_VER_1_3
)
3019 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3021 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3024 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3025 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3027 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3028 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3030 if (config
& E_NDS32_HAS_16BIT_INST
)
3032 if (version
<= E_NDS32_ELF_VER_1_3
)
3033 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3035 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3039 if (config
& E_NDS32_HAS_EXT_INST
)
3040 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3042 if (config
& E_NDS32_HAS_EXT2_INST
)
3043 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3045 if (config
& E_NDS32_HAS_FPU_INST
)
3048 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3051 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3054 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3057 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3060 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3065 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3067 case E_NDS32_FPU_REG_8SP_4DP
:
3068 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3070 case E_NDS32_FPU_REG_16SP_8DP
:
3071 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3073 case E_NDS32_FPU_REG_32SP_16DP
:
3074 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3076 case E_NDS32_FPU_REG_32SP_32DP
:
3077 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3082 if (config
& E_NDS32_HAS_AUDIO_INST
)
3083 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3085 if (config
& E_NDS32_HAS_STRING_INST
)
3086 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3088 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3089 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3091 if (config
& E_NDS32_HAS_VIDEO_INST
)
3093 if (version
<= E_NDS32_ELF_VER_1_3
)
3094 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3096 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3099 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3100 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3102 if (config
& E_NDS32_HAS_L2C_INST
)
3103 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3107 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3109 static char buf
[1024];
3120 case EM_ARC_COMPACT2
:
3121 case EM_ARC_COMPACT
:
3122 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3126 decode_ARM_machine_flags (e_flags
, buf
);
3130 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3134 if (e_flags
& EF_BFIN_PIC
)
3135 strcat (buf
, ", PIC");
3137 if (e_flags
& EF_BFIN_FDPIC
)
3138 strcat (buf
, ", FDPIC");
3140 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3141 strcat (buf
, ", code in L1");
3143 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3144 strcat (buf
, ", data in L1");
3149 switch (e_flags
& EF_FRV_CPU_MASK
)
3151 case EF_FRV_CPU_GENERIC
:
3155 strcat (buf
, ", fr???");
3158 case EF_FRV_CPU_FR300
:
3159 strcat (buf
, ", fr300");
3162 case EF_FRV_CPU_FR400
:
3163 strcat (buf
, ", fr400");
3165 case EF_FRV_CPU_FR405
:
3166 strcat (buf
, ", fr405");
3169 case EF_FRV_CPU_FR450
:
3170 strcat (buf
, ", fr450");
3173 case EF_FRV_CPU_FR500
:
3174 strcat (buf
, ", fr500");
3176 case EF_FRV_CPU_FR550
:
3177 strcat (buf
, ", fr550");
3180 case EF_FRV_CPU_SIMPLE
:
3181 strcat (buf
, ", simple");
3183 case EF_FRV_CPU_TOMCAT
:
3184 strcat (buf
, ", tomcat");
3190 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3191 strcat (buf
, ", m68000");
3192 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3193 strcat (buf
, ", cpu32");
3194 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3195 strcat (buf
, ", fido_a");
3198 char const * isa
= _("unknown");
3199 char const * mac
= _("unknown mac");
3200 char const * additional
= NULL
;
3202 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3204 case EF_M68K_CF_ISA_A_NODIV
:
3206 additional
= ", nodiv";
3208 case EF_M68K_CF_ISA_A
:
3211 case EF_M68K_CF_ISA_A_PLUS
:
3214 case EF_M68K_CF_ISA_B_NOUSP
:
3216 additional
= ", nousp";
3218 case EF_M68K_CF_ISA_B
:
3221 case EF_M68K_CF_ISA_C
:
3224 case EF_M68K_CF_ISA_C_NODIV
:
3226 additional
= ", nodiv";
3229 strcat (buf
, ", cf, isa ");
3232 strcat (buf
, additional
);
3233 if (e_flags
& EF_M68K_CF_FLOAT
)
3234 strcat (buf
, ", float");
3235 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3240 case EF_M68K_CF_MAC
:
3243 case EF_M68K_CF_EMAC
:
3246 case EF_M68K_CF_EMAC_B
:
3259 switch (e_flags
& EF_MEP_CPU_MASK
)
3261 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3262 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3263 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3264 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3265 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3266 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3267 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3270 switch (e_flags
& EF_MEP_COP_MASK
)
3272 case EF_MEP_COP_NONE
: break;
3273 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3274 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3275 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3276 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3277 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3280 if (e_flags
& EF_MEP_LIBRARY
)
3281 strcat (buf
, ", Built for Library");
3283 if (e_flags
& EF_MEP_INDEX_MASK
)
3284 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3285 e_flags
& EF_MEP_INDEX_MASK
);
3287 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3288 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3289 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3293 if (e_flags
& EF_PPC_EMB
)
3294 strcat (buf
, ", emb");
3296 if (e_flags
& EF_PPC_RELOCATABLE
)
3297 strcat (buf
, _(", relocatable"));
3299 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3300 strcat (buf
, _(", relocatable-lib"));
3304 if (e_flags
& EF_PPC64_ABI
)
3306 char abi
[] = ", abiv0";
3308 abi
[6] += e_flags
& EF_PPC64_ABI
;
3314 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3315 strcat (buf
, ", RH850 ABI");
3317 if (e_flags
& EF_V800_850E3
)
3318 strcat (buf
, ", V3 architecture");
3320 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3321 strcat (buf
, ", FPU not used");
3323 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3324 strcat (buf
, ", regmode: COMMON");
3326 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3327 strcat (buf
, ", r4 not used");
3329 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3330 strcat (buf
, ", r30 not used");
3332 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3333 strcat (buf
, ", r5 not used");
3335 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3336 strcat (buf
, ", r2 not used");
3338 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3340 switch (e_flags
& - e_flags
)
3342 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3343 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3344 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3345 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3346 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3347 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3348 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3349 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3350 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3351 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3352 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3353 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3360 case EM_CYGNUS_V850
:
3361 switch (e_flags
& EF_V850_ARCH
)
3363 case E_V850E3V5_ARCH
:
3364 strcat (buf
, ", v850e3v5");
3366 case E_V850E2V3_ARCH
:
3367 strcat (buf
, ", v850e2v3");
3370 strcat (buf
, ", v850e2");
3373 strcat (buf
, ", v850e1");
3376 strcat (buf
, ", v850e");
3379 strcat (buf
, ", v850");
3382 strcat (buf
, _(", unknown v850 architecture variant"));
3388 case EM_CYGNUS_M32R
:
3389 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3390 strcat (buf
, ", m32r");
3394 case EM_MIPS_RS3_LE
:
3395 if (e_flags
& EF_MIPS_NOREORDER
)
3396 strcat (buf
, ", noreorder");
3398 if (e_flags
& EF_MIPS_PIC
)
3399 strcat (buf
, ", pic");
3401 if (e_flags
& EF_MIPS_CPIC
)
3402 strcat (buf
, ", cpic");
3404 if (e_flags
& EF_MIPS_UCODE
)
3405 strcat (buf
, ", ugen_reserved");
3407 if (e_flags
& EF_MIPS_ABI2
)
3408 strcat (buf
, ", abi2");
3410 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3411 strcat (buf
, ", odk first");
3413 if (e_flags
& EF_MIPS_32BITMODE
)
3414 strcat (buf
, ", 32bitmode");
3416 if (e_flags
& EF_MIPS_NAN2008
)
3417 strcat (buf
, ", nan2008");
3419 if (e_flags
& EF_MIPS_FP64
)
3420 strcat (buf
, ", fp64");
3422 switch ((e_flags
& EF_MIPS_MACH
))
3424 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3425 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3426 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3427 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3428 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3429 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3430 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3431 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3432 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3433 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3434 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3435 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3436 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3437 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3438 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3439 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3440 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3441 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3442 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3443 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3444 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3446 /* We simply ignore the field in this case to avoid confusion:
3447 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3450 default: strcat (buf
, _(", unknown CPU")); break;
3453 switch ((e_flags
& EF_MIPS_ABI
))
3455 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3456 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3457 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3458 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3460 /* We simply ignore the field in this case to avoid confusion:
3461 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3462 This means it is likely to be an o32 file, but not for
3465 default: strcat (buf
, _(", unknown ABI")); break;
3468 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3469 strcat (buf
, ", mdmx");
3471 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3472 strcat (buf
, ", mips16");
3474 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3475 strcat (buf
, ", micromips");
3477 switch ((e_flags
& EF_MIPS_ARCH
))
3479 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3480 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3481 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3482 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3483 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3484 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3485 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3486 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3487 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3488 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3489 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3490 default: strcat (buf
, _(", unknown ISA")); break;
3495 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3499 switch (EF_NFP_MACH (e_flags
))
3501 case E_NFP_MACH_3200
:
3502 strcat (buf
, ", NFP-32xx");
3504 case E_NFP_MACH_6000
:
3505 strcat (buf
, ", NFP-6xxx");
3511 if (e_flags
& EF_RISCV_RVC
)
3512 strcat (buf
, ", RVC");
3514 if (e_flags
& EF_RISCV_RVE
)
3515 strcat (buf
, ", RVE");
3517 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3519 case EF_RISCV_FLOAT_ABI_SOFT
:
3520 strcat (buf
, ", soft-float ABI");
3523 case EF_RISCV_FLOAT_ABI_SINGLE
:
3524 strcat (buf
, ", single-float ABI");
3527 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3528 strcat (buf
, ", double-float ABI");
3531 case EF_RISCV_FLOAT_ABI_QUAD
:
3532 strcat (buf
, ", quad-float ABI");
3538 switch ((e_flags
& EF_SH_MACH_MASK
))
3540 case EF_SH1
: strcat (buf
, ", sh1"); break;
3541 case EF_SH2
: strcat (buf
, ", sh2"); break;
3542 case EF_SH3
: strcat (buf
, ", sh3"); break;
3543 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3544 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3545 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3546 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3547 case EF_SH4
: strcat (buf
, ", sh4"); break;
3548 case EF_SH5
: strcat (buf
, ", sh5"); break;
3549 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3550 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3551 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3552 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3553 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3554 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3555 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3556 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3557 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3558 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3559 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3560 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3561 default: strcat (buf
, _(", unknown ISA")); break;
3564 if (e_flags
& EF_SH_PIC
)
3565 strcat (buf
, ", pic");
3567 if (e_flags
& EF_SH_FDPIC
)
3568 strcat (buf
, ", fdpic");
3572 if (e_flags
& EF_OR1K_NODELAY
)
3573 strcat (buf
, ", no delay");
3577 if (e_flags
& EF_SPARC_32PLUS
)
3578 strcat (buf
, ", v8+");
3580 if (e_flags
& EF_SPARC_SUN_US1
)
3581 strcat (buf
, ", ultrasparcI");
3583 if (e_flags
& EF_SPARC_SUN_US3
)
3584 strcat (buf
, ", ultrasparcIII");
3586 if (e_flags
& EF_SPARC_HAL_R1
)
3587 strcat (buf
, ", halr1");
3589 if (e_flags
& EF_SPARC_LEDATA
)
3590 strcat (buf
, ", ledata");
3592 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3593 strcat (buf
, ", tso");
3595 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3596 strcat (buf
, ", pso");
3598 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3599 strcat (buf
, ", rmo");
3603 switch (e_flags
& EF_PARISC_ARCH
)
3605 case EFA_PARISC_1_0
:
3606 strcpy (buf
, ", PA-RISC 1.0");
3608 case EFA_PARISC_1_1
:
3609 strcpy (buf
, ", PA-RISC 1.1");
3611 case EFA_PARISC_2_0
:
3612 strcpy (buf
, ", PA-RISC 2.0");
3617 if (e_flags
& EF_PARISC_TRAPNIL
)
3618 strcat (buf
, ", trapnil");
3619 if (e_flags
& EF_PARISC_EXT
)
3620 strcat (buf
, ", ext");
3621 if (e_flags
& EF_PARISC_LSB
)
3622 strcat (buf
, ", lsb");
3623 if (e_flags
& EF_PARISC_WIDE
)
3624 strcat (buf
, ", wide");
3625 if (e_flags
& EF_PARISC_NO_KABP
)
3626 strcat (buf
, ", no kabp");
3627 if (e_flags
& EF_PARISC_LAZYSWAP
)
3628 strcat (buf
, ", lazyswap");
3633 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3634 strcat (buf
, ", new calling convention");
3636 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3637 strcat (buf
, ", gnu calling convention");
3641 if ((e_flags
& EF_IA_64_ABI64
))
3642 strcat (buf
, ", 64-bit");
3644 strcat (buf
, ", 32-bit");
3645 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3646 strcat (buf
, ", reduced fp model");
3647 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3648 strcat (buf
, ", no function descriptors, constant gp");
3649 else if ((e_flags
& EF_IA_64_CONS_GP
))
3650 strcat (buf
, ", constant gp");
3651 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3652 strcat (buf
, ", absolute");
3653 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3655 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3656 strcat (buf
, ", vms_linkages");
3657 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3659 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3661 case EF_IA_64_VMS_COMCOD_WARNING
:
3662 strcat (buf
, ", warning");
3664 case EF_IA_64_VMS_COMCOD_ERROR
:
3665 strcat (buf
, ", error");
3667 case EF_IA_64_VMS_COMCOD_ABORT
:
3668 strcat (buf
, ", abort");
3671 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3672 e_flags
& EF_IA_64_VMS_COMCOD
);
3673 strcat (buf
, ", <unknown>");
3679 if ((e_flags
& EF_VAX_NONPIC
))
3680 strcat (buf
, ", non-PIC");
3681 if ((e_flags
& EF_VAX_DFLOAT
))
3682 strcat (buf
, ", D-Float");
3683 if ((e_flags
& EF_VAX_GFLOAT
))
3684 strcat (buf
, ", G-Float");
3688 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3689 strcat (buf
, ", mcm");
3690 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3691 strcat (buf
, ", mcm24");
3692 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3693 strcat (buf
, ", gr6");
3697 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3699 case E_FLAG_RL78_ANY_CPU
: break;
3700 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3701 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3702 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3704 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3705 strcat (buf
, ", 64-bit doubles");
3709 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3710 strcat (buf
, ", 64-bit doubles");
3711 if (e_flags
& E_FLAG_RX_DSP
)
3712 strcat (buf
, ", dsp");
3713 if (e_flags
& E_FLAG_RX_PID
)
3714 strcat (buf
, ", pid");
3715 if (e_flags
& E_FLAG_RX_ABI
)
3716 strcat (buf
, ", RX ABI");
3717 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3718 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3719 ? ", uses String instructions" : ", bans String instructions");
3720 if (e_flags
& E_FLAG_RX_V2
)
3721 strcat (buf
, ", V2");
3722 if (e_flags
& E_FLAG_RX_V3
)
3723 strcat (buf
, ", V3");
3727 if (e_flags
& EF_S390_HIGH_GPRS
)
3728 strcat (buf
, ", highgprs");
3732 if ((e_flags
& EF_C6000_REL
))
3733 strcat (buf
, ", relocatable module");
3737 strcat (buf
, _(": architecture variant: "));
3738 switch (e_flags
& EF_MSP430_MACH
)
3740 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3741 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3742 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3743 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3744 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3745 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3746 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3747 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3748 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3749 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3750 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3751 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3752 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3753 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3754 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3756 strcat (buf
, _(": unknown")); break;
3759 if (e_flags
& ~ EF_MSP430_MACH
)
3760 strcat (buf
, _(": unknown extra flag bits also present"));
3764 switch (e_flags
& EF_Z80_MACH_MSK
)
3766 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3767 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3768 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3769 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3770 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3771 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3773 strcat (buf
, _(", unknown")); break;
3783 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3785 static char buff
[32];
3789 case ELFOSABI_NONE
: return "UNIX - System V";
3790 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3791 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3792 case ELFOSABI_GNU
: return "UNIX - GNU";
3793 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3794 case ELFOSABI_AIX
: return "UNIX - AIX";
3795 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3796 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3797 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3798 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3799 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3800 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3801 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3802 case ELFOSABI_AROS
: return "AROS";
3803 case ELFOSABI_FENIXOS
: return "FenixOS";
3804 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3805 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3808 switch (filedata
->file_header
.e_machine
)
3813 case ELFOSABI_ARM
: return "ARM";
3814 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3825 case ELFOSABI_STANDALONE
: return _("Standalone App");
3834 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3835 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3844 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3850 get_aarch64_segment_type (unsigned long type
)
3854 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3855 default: return NULL
;
3860 get_arm_segment_type (unsigned long type
)
3864 case PT_ARM_EXIDX
: return "EXIDX";
3865 default: return NULL
;
3870 get_s390_segment_type (unsigned long type
)
3874 case PT_S390_PGSTE
: return "S390_PGSTE";
3875 default: return NULL
;
3880 get_mips_segment_type (unsigned long type
)
3884 case PT_MIPS_REGINFO
: return "REGINFO";
3885 case PT_MIPS_RTPROC
: return "RTPROC";
3886 case PT_MIPS_OPTIONS
: return "OPTIONS";
3887 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3888 default: return NULL
;
3893 get_parisc_segment_type (unsigned long type
)
3897 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3898 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3899 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3900 default: return NULL
;
3905 get_ia64_segment_type (unsigned long type
)
3909 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3910 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3911 default: return NULL
;
3916 get_tic6x_segment_type (unsigned long type
)
3920 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3921 default: return NULL
;
3926 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3928 if (e_machine
== EM_PARISC
)
3931 case PT_HP_TLS
: return "HP_TLS";
3932 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3933 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3934 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3935 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3936 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3937 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3938 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3939 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3940 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3941 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3942 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3943 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3944 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3945 case PT_HP_STACK
: return "HP_STACK";
3946 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3947 default: return NULL
;
3950 if (e_machine
== EM_IA_64
)
3953 case PT_HP_TLS
: return "HP_TLS";
3954 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3955 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3956 case PT_IA_64_HP_STACK
: return "HP_STACK";
3957 default: return NULL
;
3964 get_solaris_segment_type (unsigned long type
)
3968 case 0x6464e550: return "PT_SUNW_UNWIND";
3969 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3970 case 0x6ffffff7: return "PT_LOSUNW";
3971 case 0x6ffffffa: return "PT_SUNWBSS";
3972 case 0x6ffffffb: return "PT_SUNWSTACK";
3973 case 0x6ffffffc: return "PT_SUNWDTRACE";
3974 case 0x6ffffffd: return "PT_SUNWCAP";
3975 case 0x6fffffff: return "PT_HISUNW";
3976 default: return NULL
;
3981 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3983 static char buff
[32];
3987 case PT_NULL
: return "NULL";
3988 case PT_LOAD
: return "LOAD";
3989 case PT_DYNAMIC
: return "DYNAMIC";
3990 case PT_INTERP
: return "INTERP";
3991 case PT_NOTE
: return "NOTE";
3992 case PT_SHLIB
: return "SHLIB";
3993 case PT_PHDR
: return "PHDR";
3994 case PT_TLS
: return "TLS";
3995 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3996 case PT_GNU_STACK
: return "GNU_STACK";
3997 case PT_GNU_RELRO
: return "GNU_RELRO";
3998 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4001 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4003 const char * result
;
4005 switch (filedata
->file_header
.e_machine
)
4008 result
= get_aarch64_segment_type (p_type
);
4011 result
= get_arm_segment_type (p_type
);
4014 case EM_MIPS_RS3_LE
:
4015 result
= get_mips_segment_type (p_type
);
4018 result
= get_parisc_segment_type (p_type
);
4021 result
= get_ia64_segment_type (p_type
);
4024 result
= get_tic6x_segment_type (p_type
);
4028 result
= get_s390_segment_type (p_type
);
4038 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4040 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4042 const char * result
= NULL
;
4044 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4047 case ELFOSABI_FREEBSD
:
4048 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4050 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4055 result
= get_hpux_segment_type (p_type
,
4056 filedata
->file_header
.e_machine
);
4058 case ELFOSABI_SOLARIS
:
4059 result
= get_solaris_segment_type (p_type
);
4067 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4070 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4077 get_arc_section_type_name (unsigned int sh_type
)
4081 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4089 get_mips_section_type_name (unsigned int sh_type
)
4093 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4094 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4095 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4096 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4097 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4098 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4099 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4100 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4101 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4102 case SHT_MIPS_RELD
: return "MIPS_RELD";
4103 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4104 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4105 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4106 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4107 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4108 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4109 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4110 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4111 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4112 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4113 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4114 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4115 case SHT_MIPS_LINE
: return "MIPS_LINE";
4116 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4117 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4118 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4119 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4120 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4121 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4122 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4123 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4124 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4125 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4126 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4127 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4128 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4129 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4130 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4131 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4132 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4133 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4141 get_parisc_section_type_name (unsigned int sh_type
)
4145 case SHT_PARISC_EXT
: return "PARISC_EXT";
4146 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4147 case SHT_PARISC_DOC
: return "PARISC_DOC";
4148 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4149 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4150 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4151 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4152 default: return NULL
;
4157 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4159 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4160 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4161 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4165 case SHT_IA_64_EXT
: return "IA_64_EXT";
4166 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4167 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4168 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4169 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4170 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4171 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4172 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4173 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4174 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4182 get_x86_64_section_type_name (unsigned int sh_type
)
4186 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4187 default: return NULL
;
4192 get_aarch64_section_type_name (unsigned int sh_type
)
4196 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4197 default: return NULL
;
4202 get_arm_section_type_name (unsigned int sh_type
)
4206 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4207 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4208 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4209 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4210 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4211 default: return NULL
;
4216 get_tic6x_section_type_name (unsigned int sh_type
)
4220 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4221 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4222 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4223 case SHT_TI_ICODE
: return "TI_ICODE";
4224 case SHT_TI_XREF
: return "TI_XREF";
4225 case SHT_TI_HANDLER
: return "TI_HANDLER";
4226 case SHT_TI_INITINFO
: return "TI_INITINFO";
4227 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4228 default: return NULL
;
4233 get_msp430x_section_type_name (unsigned int sh_type
)
4237 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4238 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4239 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4240 default: return NULL
;
4245 get_nfp_section_type_name (unsigned int sh_type
)
4249 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4250 case SHT_NFP_INITREG
: return "NFP_INITREG";
4251 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4252 default: return NULL
;
4257 get_v850_section_type_name (unsigned int sh_type
)
4261 case SHT_V850_SCOMMON
: return "V850 Small Common";
4262 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4263 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4264 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4265 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4266 default: return NULL
;
4271 get_riscv_section_type_name (unsigned int sh_type
)
4275 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4276 default: return NULL
;
4281 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4283 static char buff
[32];
4284 const char * result
;
4288 case SHT_NULL
: return "NULL";
4289 case SHT_PROGBITS
: return "PROGBITS";
4290 case SHT_SYMTAB
: return "SYMTAB";
4291 case SHT_STRTAB
: return "STRTAB";
4292 case SHT_RELA
: return "RELA";
4293 case SHT_HASH
: return "HASH";
4294 case SHT_DYNAMIC
: return "DYNAMIC";
4295 case SHT_NOTE
: return "NOTE";
4296 case SHT_NOBITS
: return "NOBITS";
4297 case SHT_REL
: return "REL";
4298 case SHT_SHLIB
: return "SHLIB";
4299 case SHT_DYNSYM
: return "DYNSYM";
4300 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4301 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4302 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4303 case SHT_GNU_HASH
: return "GNU_HASH";
4304 case SHT_GROUP
: return "GROUP";
4305 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4306 case SHT_GNU_verdef
: return "VERDEF";
4307 case SHT_GNU_verneed
: return "VERNEED";
4308 case SHT_GNU_versym
: return "VERSYM";
4309 case 0x6ffffff0: return "VERSYM";
4310 case 0x6ffffffc: return "VERDEF";
4311 case 0x7ffffffd: return "AUXILIARY";
4312 case 0x7fffffff: return "FILTER";
4313 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4316 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4318 switch (filedata
->file_header
.e_machine
)
4321 case EM_ARC_COMPACT
:
4322 case EM_ARC_COMPACT2
:
4323 result
= get_arc_section_type_name (sh_type
);
4326 case EM_MIPS_RS3_LE
:
4327 result
= get_mips_section_type_name (sh_type
);
4330 result
= get_parisc_section_type_name (sh_type
);
4333 result
= get_ia64_section_type_name (filedata
, sh_type
);
4338 result
= get_x86_64_section_type_name (sh_type
);
4341 result
= get_aarch64_section_type_name (sh_type
);
4344 result
= get_arm_section_type_name (sh_type
);
4347 result
= get_tic6x_section_type_name (sh_type
);
4350 result
= get_msp430x_section_type_name (sh_type
);
4353 result
= get_nfp_section_type_name (sh_type
);
4357 case EM_CYGNUS_V850
:
4358 result
= get_v850_section_type_name (sh_type
);
4361 result
= get_riscv_section_type_name (sh_type
);
4371 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4373 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4375 switch (filedata
->file_header
.e_machine
)
4378 result
= get_ia64_section_type_name (filedata
, sh_type
);
4381 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4382 result
= get_solaris_section_type (sh_type
);
4387 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4388 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4389 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4390 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4402 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4404 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4406 switch (filedata
->file_header
.e_machine
)
4410 case EM_CYGNUS_V850
:
4411 result
= get_v850_section_type_name (sh_type
);
4421 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4424 /* This message is probably going to be displayed in a 15
4425 character wide field, so put the hex value first. */
4426 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4432 #define OPTION_DEBUG_DUMP 512
4433 #define OPTION_DYN_SYMS 513
4434 #define OPTION_DWARF_DEPTH 514
4435 #define OPTION_DWARF_START 515
4436 #define OPTION_DWARF_CHECK 516
4437 #define OPTION_CTF_DUMP 517
4438 #define OPTION_CTF_PARENT 518
4439 #define OPTION_CTF_SYMBOLS 519
4440 #define OPTION_CTF_STRINGS 520
4442 static struct option options
[] =
4444 {"all", no_argument
, 0, 'a'},
4445 {"file-header", no_argument
, 0, 'h'},
4446 {"program-headers", no_argument
, 0, 'l'},
4447 {"headers", no_argument
, 0, 'e'},
4448 {"histogram", no_argument
, 0, 'I'},
4449 {"segments", no_argument
, 0, 'l'},
4450 {"sections", no_argument
, 0, 'S'},
4451 {"section-headers", no_argument
, 0, 'S'},
4452 {"section-groups", no_argument
, 0, 'g'},
4453 {"section-details", no_argument
, 0, 't'},
4454 {"full-section-name",no_argument
, 0, 'N'},
4455 {"symbols", no_argument
, 0, 's'},
4456 {"syms", no_argument
, 0, 's'},
4457 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4458 {"relocs", no_argument
, 0, 'r'},
4459 {"notes", no_argument
, 0, 'n'},
4460 {"dynamic", no_argument
, 0, 'd'},
4461 {"arch-specific", no_argument
, 0, 'A'},
4462 {"version-info", no_argument
, 0, 'V'},
4463 {"use-dynamic", no_argument
, 0, 'D'},
4464 {"unwind", no_argument
, 0, 'u'},
4465 {"archive-index", no_argument
, 0, 'c'},
4466 {"hex-dump", required_argument
, 0, 'x'},
4467 {"relocated-dump", required_argument
, 0, 'R'},
4468 {"string-dump", required_argument
, 0, 'p'},
4469 {"decompress", no_argument
, 0, 'z'},
4470 #ifdef SUPPORT_DISASSEMBLY
4471 {"instruction-dump", required_argument
, 0, 'i'},
4473 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4475 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4476 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4477 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4479 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4481 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4482 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4483 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4485 {"version", no_argument
, 0, 'v'},
4486 {"wide", no_argument
, 0, 'W'},
4487 {"help", no_argument
, 0, 'H'},
4488 {0, no_argument
, 0, 0}
4492 usage (FILE * stream
)
4494 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4495 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4496 fprintf (stream
, _(" Options are:\n\
4497 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4498 -h --file-header Display the ELF file header\n\
4499 -l --program-headers Display the program headers\n\
4500 --segments An alias for --program-headers\n\
4501 -S --section-headers Display the sections' header\n\
4502 --sections An alias for --section-headers\n\
4503 -g --section-groups Display the section groups\n\
4504 -t --section-details Display the section details\n\
4505 -e --headers Equivalent to: -h -l -S\n\
4506 -s --syms Display the symbol table\n\
4507 --symbols An alias for --syms\n\
4508 --dyn-syms Display the dynamic symbol table\n\
4509 -n --notes Display the core notes (if present)\n\
4510 -r --relocs Display the relocations (if present)\n\
4511 -u --unwind Display the unwind info (if present)\n\
4512 -d --dynamic Display the dynamic section (if present)\n\
4513 -V --version-info Display the version sections (if present)\n\
4514 -A --arch-specific Display architecture specific information (if any)\n\
4515 -c --archive-index Display the symbol/file index in an archive\n\
4516 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4517 -x --hex-dump=<number|name>\n\
4518 Dump the contents of section <number|name> as bytes\n\
4519 -p --string-dump=<number|name>\n\
4520 Dump the contents of section <number|name> as strings\n\
4521 -R --relocated-dump=<number|name>\n\
4522 Dump the contents of section <number|name> as relocated bytes\n\
4523 -z --decompress Decompress section before dumping it\n\
4524 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4525 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4526 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4527 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4528 =addr,=cu_index,=links,=follow-links]\n\
4529 Display the contents of DWARF debug sections\n"));
4530 fprintf (stream
, _("\
4531 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4532 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4534 fprintf (stream
, _("\
4535 --ctf=<number|name> Display CTF info from section <number|name>\n\
4536 --ctf-parent=<number|name>\n\
4537 Use section <number|name> as the CTF parent\n\n\
4538 --ctf-symbols=<number|name>\n\
4539 Use section <number|name> as the CTF external symtab\n\n\
4540 --ctf-strings=<number|name>\n\
4541 Use section <number|name> as the CTF external strtab\n\n"));
4543 #ifdef SUPPORT_DISASSEMBLY
4544 fprintf (stream
, _("\
4545 -i --instruction-dump=<number|name>\n\
4546 Disassemble the contents of section <number|name>\n"));
4548 fprintf (stream
, _("\
4549 -I --histogram Display histogram of bucket list lengths\n\
4550 -W --wide Allow output width to exceed 80 characters\n\
4551 @<file> Read options from <file>\n\
4552 -H --help Display this information\n\
4553 -v --version Display the version number of readelf\n"));
4555 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4556 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4558 exit (stream
== stdout
? 0 : 1);
4561 /* Record the fact that the user wants the contents of section number
4562 SECTION to be displayed using the method(s) encoded as flags bits
4563 in TYPE. Note, TYPE can be zero if we are creating the array for
4567 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4569 if (section
>= filedata
->num_dump_sects
)
4571 dump_type
* new_dump_sects
;
4573 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4574 sizeof (* new_dump_sects
));
4576 if (new_dump_sects
== NULL
)
4577 error (_("Out of memory allocating dump request table.\n"));
4580 if (filedata
->dump_sects
)
4582 /* Copy current flag settings. */
4583 memcpy (new_dump_sects
, filedata
->dump_sects
,
4584 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4586 free (filedata
->dump_sects
);
4589 filedata
->dump_sects
= new_dump_sects
;
4590 filedata
->num_dump_sects
= section
+ 1;
4594 if (filedata
->dump_sects
)
4595 filedata
->dump_sects
[section
] |= type
;
4598 /* Request a dump by section name. */
4601 request_dump_byname (const char * section
, dump_type type
)
4603 struct dump_list_entry
* new_request
;
4605 new_request
= (struct dump_list_entry
*)
4606 malloc (sizeof (struct dump_list_entry
));
4608 error (_("Out of memory allocating dump request table.\n"));
4610 new_request
->name
= strdup (section
);
4611 if (!new_request
->name
)
4612 error (_("Out of memory allocating dump request table.\n"));
4614 new_request
->type
= type
;
4616 new_request
->next
= dump_sects_byname
;
4617 dump_sects_byname
= new_request
;
4621 request_dump (Filedata
* filedata
, dump_type type
)
4627 section
= strtoul (optarg
, & cp
, 0);
4629 if (! *cp
&& section
>= 0)
4630 request_dump_bynumber (filedata
, section
, type
);
4632 request_dump_byname (optarg
, type
);
4636 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4643 while ((c
= getopt_long
4644 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4662 do_section_groups
= TRUE
;
4665 do_histogram
= TRUE
;
4670 do_section_groups
= TRUE
;
4675 do_section_details
= TRUE
;
4686 do_using_dynamic
= TRUE
;
4710 do_histogram
= TRUE
;
4716 do_archive_index
= TRUE
;
4719 request_dump (filedata
, HEX_DUMP
);
4722 request_dump (filedata
, STRING_DUMP
);
4725 request_dump (filedata
, RELOC_DUMP
);
4728 decompress_dumps
= TRUE
;
4734 do_debugging
= TRUE
;
4735 dwarf_select_sections_all ();
4739 do_debugging
= FALSE
;
4740 dwarf_select_sections_by_letters (optarg
);
4743 case OPTION_DEBUG_DUMP
:
4746 do_debugging
= TRUE
;
4749 do_debugging
= FALSE
;
4750 dwarf_select_sections_by_names (optarg
);
4753 case OPTION_DWARF_DEPTH
:
4757 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4760 case OPTION_DWARF_START
:
4764 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4767 case OPTION_DWARF_CHECK
:
4770 case OPTION_CTF_DUMP
:
4772 request_dump (filedata
, CTF_DUMP
);
4774 case OPTION_CTF_SYMBOLS
:
4775 dump_ctf_symtab_name
= strdup (optarg
);
4777 case OPTION_CTF_STRINGS
:
4778 dump_ctf_strtab_name
= strdup (optarg
);
4780 case OPTION_CTF_PARENT
:
4781 dump_ctf_parent_name
= strdup (optarg
);
4783 case OPTION_DYN_SYMS
:
4786 #ifdef SUPPORT_DISASSEMBLY
4788 request_dump (filedata
, DISASS_DUMP
);
4792 print_version (program_name
);
4801 /* xgettext:c-format */
4802 error (_("Invalid option '-%c'\n"), c
);
4809 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4810 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4811 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4812 && !do_section_groups
&& !do_archive_index
4818 get_elf_class (unsigned int elf_class
)
4820 static char buff
[32];
4824 case ELFCLASSNONE
: return _("none");
4825 case ELFCLASS32
: return "ELF32";
4826 case ELFCLASS64
: return "ELF64";
4828 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4834 get_data_encoding (unsigned int encoding
)
4836 static char buff
[32];
4840 case ELFDATANONE
: return _("none");
4841 case ELFDATA2LSB
: return _("2's complement, little endian");
4842 case ELFDATA2MSB
: return _("2's complement, big endian");
4844 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4849 /* Decode the data held in 'filedata->file_header'. */
4852 process_file_header (Filedata
* filedata
)
4854 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4856 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4857 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4858 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4859 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4862 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4866 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
4872 printf (_("ELF Header:\n"));
4873 printf (_(" Magic: "));
4874 for (i
= 0; i
< EI_NIDENT
; i
++)
4875 printf ("%2.2x ", header
->e_ident
[i
]);
4877 printf (_(" Class: %s\n"),
4878 get_elf_class (header
->e_ident
[EI_CLASS
]));
4879 printf (_(" Data: %s\n"),
4880 get_data_encoding (header
->e_ident
[EI_DATA
]));
4881 printf (_(" Version: %d%s\n"),
4882 header
->e_ident
[EI_VERSION
],
4883 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4885 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4888 printf (_(" OS/ABI: %s\n"),
4889 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4890 printf (_(" ABI Version: %d\n"),
4891 header
->e_ident
[EI_ABIVERSION
]);
4892 printf (_(" Type: %s\n"),
4893 get_file_type (header
->e_type
));
4894 printf (_(" Machine: %s\n"),
4895 get_machine_name (header
->e_machine
));
4896 printf (_(" Version: 0x%lx\n"),
4899 printf (_(" Entry point address: "));
4900 print_vma (header
->e_entry
, PREFIX_HEX
);
4901 printf (_("\n Start of program headers: "));
4902 print_vma (header
->e_phoff
, DEC
);
4903 printf (_(" (bytes into file)\n Start of section headers: "));
4904 print_vma (header
->e_shoff
, DEC
);
4905 printf (_(" (bytes into file)\n"));
4907 printf (_(" Flags: 0x%lx%s\n"),
4909 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4910 printf (_(" Size of this header: %u (bytes)\n"),
4912 printf (_(" Size of program headers: %u (bytes)\n"),
4913 header
->e_phentsize
);
4914 printf (_(" Number of program headers: %u"),
4916 if (filedata
->section_headers
!= NULL
4917 && header
->e_phnum
== PN_XNUM
4918 && filedata
->section_headers
[0].sh_info
!= 0)
4920 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4921 printf (" (%u)", header
->e_phnum
);
4923 putc ('\n', stdout
);
4924 printf (_(" Size of section headers: %u (bytes)\n"),
4925 header
->e_shentsize
);
4926 printf (_(" Number of section headers: %u"),
4928 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4930 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4931 printf (" (%u)", header
->e_shnum
);
4933 putc ('\n', stdout
);
4934 printf (_(" Section header string table index: %u"),
4935 header
->e_shstrndx
);
4936 if (filedata
->section_headers
!= NULL
4937 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4939 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4940 printf (" (%u)", header
->e_shstrndx
);
4942 if (header
->e_shstrndx
!= SHN_UNDEF
4943 && header
->e_shstrndx
>= header
->e_shnum
)
4945 header
->e_shstrndx
= SHN_UNDEF
;
4946 printf (_(" <corrupt: out of range>"));
4948 putc ('\n', stdout
);
4951 if (filedata
->section_headers
!= NULL
)
4953 if (header
->e_phnum
== PN_XNUM
4954 && filedata
->section_headers
[0].sh_info
!= 0)
4955 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4956 if (header
->e_shnum
== SHN_UNDEF
)
4957 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4958 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4959 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4960 if (header
->e_shstrndx
>= header
->e_shnum
)
4961 header
->e_shstrndx
= SHN_UNDEF
;
4962 free (filedata
->section_headers
);
4963 filedata
->section_headers
= NULL
;
4969 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4970 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4973 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4975 Elf32_External_Phdr
* phdrs
;
4976 Elf32_External_Phdr
* external
;
4977 Elf_Internal_Phdr
* internal
;
4979 unsigned int size
= filedata
->file_header
.e_phentsize
;
4980 unsigned int num
= filedata
->file_header
.e_phnum
;
4982 /* PR binutils/17531: Cope with unexpected section header sizes. */
4983 if (size
== 0 || num
== 0)
4985 if (size
< sizeof * phdrs
)
4987 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4990 if (size
> sizeof * phdrs
)
4991 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4993 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4994 size
, num
, _("program headers"));
4998 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4999 i
< filedata
->file_header
.e_phnum
;
5000 i
++, internal
++, external
++)
5002 internal
->p_type
= BYTE_GET (external
->p_type
);
5003 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5004 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5005 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5006 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5007 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5008 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5009 internal
->p_align
= BYTE_GET (external
->p_align
);
5016 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5017 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5020 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5022 Elf64_External_Phdr
* phdrs
;
5023 Elf64_External_Phdr
* external
;
5024 Elf_Internal_Phdr
* internal
;
5026 unsigned int size
= filedata
->file_header
.e_phentsize
;
5027 unsigned int num
= filedata
->file_header
.e_phnum
;
5029 /* PR binutils/17531: Cope with unexpected section header sizes. */
5030 if (size
== 0 || num
== 0)
5032 if (size
< sizeof * phdrs
)
5034 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5037 if (size
> sizeof * phdrs
)
5038 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5040 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5041 size
, num
, _("program headers"));
5045 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5046 i
< filedata
->file_header
.e_phnum
;
5047 i
++, internal
++, external
++)
5049 internal
->p_type
= BYTE_GET (external
->p_type
);
5050 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5051 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5052 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5053 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5054 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5055 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5056 internal
->p_align
= BYTE_GET (external
->p_align
);
5063 /* Returns TRUE if the program headers were read into `program_headers'. */
5066 get_program_headers (Filedata
* filedata
)
5068 Elf_Internal_Phdr
* phdrs
;
5070 /* Check cache of prior read. */
5071 if (filedata
->program_headers
!= NULL
)
5074 /* Be kind to memory checkers by looking for
5075 e_phnum values which we know must be invalid. */
5076 if (filedata
->file_header
.e_phnum
5077 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5078 >= filedata
->file_size
)
5080 error (_("Too many program headers - %#x - the file is not that big\n"),
5081 filedata
->file_header
.e_phnum
);
5085 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5086 sizeof (Elf_Internal_Phdr
));
5089 error (_("Out of memory reading %u program headers\n"),
5090 filedata
->file_header
.e_phnum
);
5095 ? get_32bit_program_headers (filedata
, phdrs
)
5096 : get_64bit_program_headers (filedata
, phdrs
))
5098 filedata
->program_headers
= phdrs
;
5106 /* Returns TRUE if the program headers were loaded. */
5109 process_program_headers (Filedata
* filedata
)
5111 Elf_Internal_Phdr
* segment
;
5113 Elf_Internal_Phdr
* previous_load
= NULL
;
5118 if (filedata
->file_header
.e_phnum
== 0)
5120 /* PR binutils/12467. */
5121 if (filedata
->file_header
.e_phoff
!= 0)
5123 warn (_("possibly corrupt ELF header - it has a non-zero program"
5124 " header offset, but no program headers\n"));
5127 else if (do_segments
)
5128 printf (_("\nThere are no program headers in this file.\n"));
5132 if (do_segments
&& !do_header
)
5134 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5135 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5136 printf (ngettext ("There is %d program header, starting at offset %s\n",
5137 "There are %d program headers, starting at offset %s\n",
5138 filedata
->file_header
.e_phnum
),
5139 filedata
->file_header
.e_phnum
,
5140 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5143 if (! get_program_headers (filedata
))
5148 if (filedata
->file_header
.e_phnum
> 1)
5149 printf (_("\nProgram Headers:\n"));
5151 printf (_("\nProgram Headers:\n"));
5155 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5158 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5162 (_(" Type Offset VirtAddr PhysAddr\n"));
5164 (_(" FileSiz MemSiz Flags Align\n"));
5168 for (i
= 0, segment
= filedata
->program_headers
;
5169 i
< filedata
->file_header
.e_phnum
;
5174 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5178 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5179 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5180 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5181 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5182 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5184 (segment
->p_flags
& PF_R
? 'R' : ' '),
5185 (segment
->p_flags
& PF_W
? 'W' : ' '),
5186 (segment
->p_flags
& PF_X
? 'E' : ' '));
5187 printf ("%#lx", (unsigned long) segment
->p_align
);
5191 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5192 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5195 print_vma (segment
->p_offset
, FULL_HEX
);
5199 print_vma (segment
->p_vaddr
, FULL_HEX
);
5201 print_vma (segment
->p_paddr
, FULL_HEX
);
5204 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5205 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5208 print_vma (segment
->p_filesz
, FULL_HEX
);
5212 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5213 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5216 print_vma (segment
->p_memsz
, FULL_HEX
);
5220 (segment
->p_flags
& PF_R
? 'R' : ' '),
5221 (segment
->p_flags
& PF_W
? 'W' : ' '),
5222 (segment
->p_flags
& PF_X
? 'E' : ' '));
5224 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5225 printf ("%#lx", (unsigned long) segment
->p_align
);
5228 print_vma (segment
->p_align
, PREFIX_HEX
);
5233 print_vma (segment
->p_offset
, FULL_HEX
);
5235 print_vma (segment
->p_vaddr
, FULL_HEX
);
5237 print_vma (segment
->p_paddr
, FULL_HEX
);
5239 print_vma (segment
->p_filesz
, FULL_HEX
);
5241 print_vma (segment
->p_memsz
, FULL_HEX
);
5243 (segment
->p_flags
& PF_R
? 'R' : ' '),
5244 (segment
->p_flags
& PF_W
? 'W' : ' '),
5245 (segment
->p_flags
& PF_X
? 'E' : ' '));
5246 print_vma (segment
->p_align
, PREFIX_HEX
);
5249 putc ('\n', stdout
);
5252 switch (segment
->p_type
)
5255 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5256 required by the ELF standard, several programs, including the Linux
5257 kernel, make use of non-ordered segments. */
5259 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5260 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5262 if (segment
->p_memsz
< segment
->p_filesz
)
5263 error (_("the segment's file size is larger than its memory size\n"));
5264 previous_load
= segment
;
5268 /* PR 20815 - Verify that the program header is loaded into memory. */
5269 if (i
> 0 && previous_load
!= NULL
)
5270 error (_("the PHDR segment must occur before any LOAD segment\n"));
5271 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5275 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5277 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5278 if (load
->p_type
== PT_LOAD
5279 && load
->p_offset
<= segment
->p_offset
5280 && (load
->p_offset
+ load
->p_filesz
5281 >= segment
->p_offset
+ segment
->p_filesz
)
5282 && load
->p_vaddr
<= segment
->p_vaddr
5283 && (load
->p_vaddr
+ load
->p_filesz
5284 >= segment
->p_vaddr
+ segment
->p_filesz
))
5287 if (j
== filedata
->file_header
.e_phnum
)
5288 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5294 error (_("more than one dynamic segment\n"));
5296 /* By default, assume that the .dynamic section is the first
5297 section in the DYNAMIC segment. */
5298 dynamic_addr
= segment
->p_offset
;
5299 dynamic_size
= segment
->p_filesz
;
5301 /* Try to locate the .dynamic section. If there is
5302 a section header table, we can easily locate it. */
5303 if (filedata
->section_headers
!= NULL
)
5305 Elf_Internal_Shdr
* sec
;
5307 sec
= find_section (filedata
, ".dynamic");
5308 if (sec
== NULL
|| sec
->sh_size
== 0)
5310 /* A corresponding .dynamic section is expected, but on
5311 IA-64/OpenVMS it is OK for it to be missing. */
5312 if (!is_ia64_vms (filedata
))
5313 error (_("no .dynamic section in the dynamic segment\n"));
5317 if (sec
->sh_type
== SHT_NOBITS
)
5323 dynamic_addr
= sec
->sh_offset
;
5324 dynamic_size
= sec
->sh_size
;
5326 if (dynamic_addr
< segment
->p_offset
5327 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5328 warn (_("the .dynamic section is not contained"
5329 " within the dynamic segment\n"));
5330 else if (dynamic_addr
> segment
->p_offset
)
5331 warn (_("the .dynamic section is not the first section"
5332 " in the dynamic segment.\n"));
5335 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5336 segment. Check this after matching against the section headers
5337 so we don't warn on debuginfo file (which have NOBITS .dynamic
5339 if (dynamic_addr
> filedata
->file_size
5340 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5342 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5343 dynamic_addr
= dynamic_size
= 0;
5348 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5350 error (_("Unable to find program interpreter name\n"));
5354 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5356 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5357 error (_("Internal error: failed to create format string to display program interpreter\n"));
5359 program_interpreter
[0] = 0;
5360 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5361 error (_("Unable to read program interpreter name\n"));
5364 printf (_(" [Requesting program interpreter: %s]\n"),
5365 program_interpreter
);
5372 && filedata
->section_headers
!= NULL
5373 && filedata
->string_table
!= NULL
)
5375 printf (_("\n Section to Segment mapping:\n"));
5376 printf (_(" Segment Sections...\n"));
5378 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5381 Elf_Internal_Shdr
* section
;
5383 segment
= filedata
->program_headers
+ i
;
5384 section
= filedata
->section_headers
+ 1;
5386 printf (" %2.2d ", i
);
5388 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5390 if (!ELF_TBSS_SPECIAL (section
, segment
)
5391 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5392 printf ("%s ", printable_section_name (filedata
, section
));
5403 /* Find the file offset corresponding to VMA by using the program headers. */
5406 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5408 Elf_Internal_Phdr
* seg
;
5410 if (! get_program_headers (filedata
))
5412 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5416 for (seg
= filedata
->program_headers
;
5417 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5420 if (seg
->p_type
!= PT_LOAD
)
5423 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5424 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5425 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5428 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5429 (unsigned long) vma
);
5434 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5435 If PROBE is true, this is just a probe and we do not generate any error
5436 messages if the load fails. */
5439 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5441 Elf32_External_Shdr
* shdrs
;
5442 Elf_Internal_Shdr
* internal
;
5444 unsigned int size
= filedata
->file_header
.e_shentsize
;
5445 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5447 /* PR binutils/17531: Cope with unexpected section header sizes. */
5448 if (size
== 0 || num
== 0)
5450 if (size
< sizeof * shdrs
)
5453 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5456 if (!probe
&& size
> sizeof * shdrs
)
5457 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5459 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5461 probe
? NULL
: _("section headers"));
5465 free (filedata
->section_headers
);
5466 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5467 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5468 if (filedata
->section_headers
== NULL
)
5471 error (_("Out of memory reading %u section headers\n"), num
);
5476 for (i
= 0, internal
= filedata
->section_headers
;
5480 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5481 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5482 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5483 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5484 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5485 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5486 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5487 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5488 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5489 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5490 if (!probe
&& internal
->sh_link
> num
)
5491 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5492 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5493 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5500 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5503 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5505 Elf64_External_Shdr
* shdrs
;
5506 Elf_Internal_Shdr
* internal
;
5508 unsigned int size
= filedata
->file_header
.e_shentsize
;
5509 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5511 /* PR binutils/17531: Cope with unexpected section header sizes. */
5512 if (size
== 0 || num
== 0)
5515 if (size
< sizeof * shdrs
)
5518 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5522 if (! probe
&& size
> sizeof * shdrs
)
5523 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5525 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5526 filedata
->file_header
.e_shoff
,
5528 probe
? NULL
: _("section headers"));
5532 free (filedata
->section_headers
);
5533 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5534 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5535 if (filedata
->section_headers
== NULL
)
5538 error (_("Out of memory reading %u section headers\n"), num
);
5543 for (i
= 0, internal
= filedata
->section_headers
;
5547 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5548 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5549 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5550 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5551 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5552 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5553 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5554 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5555 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5556 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5557 if (!probe
&& internal
->sh_link
> num
)
5558 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5559 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5560 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5567 static Elf_Internal_Sym
*
5568 get_32bit_elf_symbols (Filedata
* filedata
,
5569 Elf_Internal_Shdr
* section
,
5570 unsigned long * num_syms_return
)
5572 unsigned long number
= 0;
5573 Elf32_External_Sym
* esyms
= NULL
;
5574 Elf_External_Sym_Shndx
* shndx
= NULL
;
5575 Elf_Internal_Sym
* isyms
= NULL
;
5576 Elf_Internal_Sym
* psym
;
5578 elf_section_list
* entry
;
5580 if (section
->sh_size
== 0)
5582 if (num_syms_return
!= NULL
)
5583 * num_syms_return
= 0;
5587 /* Run some sanity checks first. */
5588 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5590 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5591 printable_section_name (filedata
, section
),
5592 (unsigned long) section
->sh_entsize
);
5596 if (section
->sh_size
> filedata
->file_size
)
5598 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5599 printable_section_name (filedata
, section
),
5600 (unsigned long) section
->sh_size
);
5604 number
= section
->sh_size
/ section
->sh_entsize
;
5606 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5608 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5609 (unsigned long) section
->sh_size
,
5610 printable_section_name (filedata
, section
),
5611 (unsigned long) section
->sh_entsize
);
5615 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5616 section
->sh_size
, _("symbols"));
5621 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5623 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5628 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5632 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5633 entry
->hdr
->sh_offset
,
5634 1, entry
->hdr
->sh_size
,
5635 _("symbol table section indices"));
5639 /* PR17531: file: heap-buffer-overflow */
5640 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5642 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5643 printable_section_name (filedata
, entry
->hdr
),
5644 (unsigned long) entry
->hdr
->sh_size
,
5645 (unsigned long) section
->sh_size
);
5650 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5654 error (_("Out of memory reading %lu symbols\n"),
5655 (unsigned long) number
);
5659 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5661 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5662 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5663 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5664 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5665 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5667 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5668 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5669 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5670 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5671 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5678 if (num_syms_return
!= NULL
)
5679 * num_syms_return
= isyms
== NULL
? 0 : number
;
5684 static Elf_Internal_Sym
*
5685 get_64bit_elf_symbols (Filedata
* filedata
,
5686 Elf_Internal_Shdr
* section
,
5687 unsigned long * num_syms_return
)
5689 unsigned long number
= 0;
5690 Elf64_External_Sym
* esyms
= NULL
;
5691 Elf_External_Sym_Shndx
* shndx
= NULL
;
5692 Elf_Internal_Sym
* isyms
= NULL
;
5693 Elf_Internal_Sym
* psym
;
5695 elf_section_list
* entry
;
5697 if (section
->sh_size
== 0)
5699 if (num_syms_return
!= NULL
)
5700 * num_syms_return
= 0;
5704 /* Run some sanity checks first. */
5705 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5707 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5708 printable_section_name (filedata
, section
),
5709 (unsigned long) section
->sh_entsize
);
5713 if (section
->sh_size
> filedata
->file_size
)
5715 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5716 printable_section_name (filedata
, section
),
5717 (unsigned long) section
->sh_size
);
5721 number
= section
->sh_size
/ section
->sh_entsize
;
5723 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5725 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5726 (unsigned long) section
->sh_size
,
5727 printable_section_name (filedata
, section
),
5728 (unsigned long) section
->sh_entsize
);
5732 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5733 section
->sh_size
, _("symbols"));
5738 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5740 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5745 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5749 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5750 entry
->hdr
->sh_offset
,
5751 1, entry
->hdr
->sh_size
,
5752 _("symbol table section indices"));
5756 /* PR17531: file: heap-buffer-overflow */
5757 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5759 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5760 printable_section_name (filedata
, entry
->hdr
),
5761 (unsigned long) entry
->hdr
->sh_size
,
5762 (unsigned long) section
->sh_size
);
5767 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5771 error (_("Out of memory reading %lu symbols\n"),
5772 (unsigned long) number
);
5776 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5778 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5779 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5780 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5781 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5783 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5785 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5786 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5787 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5789 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5790 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5797 if (num_syms_return
!= NULL
)
5798 * num_syms_return
= isyms
== NULL
? 0 : number
;
5804 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5806 static char buff
[1024];
5808 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5810 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5811 bfd_vma os_flags
= 0;
5812 bfd_vma proc_flags
= 0;
5813 bfd_vma unknown_flags
= 0;
5821 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5822 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5823 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5824 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5825 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5826 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5827 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5828 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5829 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5830 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5831 /* IA-64 specific. */
5832 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5833 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5834 /* IA-64 OpenVMS specific. */
5835 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5836 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5837 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5838 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5839 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5840 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5842 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5843 /* SPARC specific. */
5844 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5845 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5847 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5848 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5849 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5851 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5853 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5856 if (do_section_details
)
5858 sprintf (buff
, "[%*.*lx]: ",
5859 field_size
, field_size
, (unsigned long) sh_flags
);
5860 p
+= field_size
+ 4;
5867 flag
= sh_flags
& - sh_flags
;
5870 if (do_section_details
)
5874 case SHF_WRITE
: sindex
= 0; break;
5875 case SHF_ALLOC
: sindex
= 1; break;
5876 case SHF_EXECINSTR
: sindex
= 2; break;
5877 case SHF_MERGE
: sindex
= 3; break;
5878 case SHF_STRINGS
: sindex
= 4; break;
5879 case SHF_INFO_LINK
: sindex
= 5; break;
5880 case SHF_LINK_ORDER
: sindex
= 6; break;
5881 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5882 case SHF_GROUP
: sindex
= 8; break;
5883 case SHF_TLS
: sindex
= 9; break;
5884 case SHF_EXCLUDE
: sindex
= 18; break;
5885 case SHF_COMPRESSED
: sindex
= 20; break;
5886 case SHF_GNU_MBIND
: sindex
= 24; break;
5890 switch (filedata
->file_header
.e_machine
)
5893 if (flag
== SHF_IA_64_SHORT
)
5895 else if (flag
== SHF_IA_64_NORECOV
)
5898 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5901 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5902 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5903 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5904 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5905 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5906 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5917 case EM_OLD_SPARCV9
:
5918 case EM_SPARC32PLUS
:
5921 if (flag
== SHF_ORDERED
)
5928 case SHF_ENTRYSECT
: sindex
= 21; break;
5929 case SHF_ARM_PURECODE
: sindex
= 22; break;
5930 case SHF_COMDEF
: sindex
= 23; break;
5935 if (flag
== SHF_PPC_VLE
)
5946 if (p
!= buff
+ field_size
+ 4)
5948 if (size
< (10 + 2))
5950 warn (_("Internal error: not enough buffer room for section flag info"));
5951 return _("<unknown>");
5958 size
-= flags
[sindex
].len
;
5959 p
= stpcpy (p
, flags
[sindex
].str
);
5961 else if (flag
& SHF_MASKOS
)
5963 else if (flag
& SHF_MASKPROC
)
5966 unknown_flags
|= flag
;
5972 case SHF_WRITE
: *p
= 'W'; break;
5973 case SHF_ALLOC
: *p
= 'A'; break;
5974 case SHF_EXECINSTR
: *p
= 'X'; break;
5975 case SHF_MERGE
: *p
= 'M'; break;
5976 case SHF_STRINGS
: *p
= 'S'; break;
5977 case SHF_INFO_LINK
: *p
= 'I'; break;
5978 case SHF_LINK_ORDER
: *p
= 'L'; break;
5979 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5980 case SHF_GROUP
: *p
= 'G'; break;
5981 case SHF_TLS
: *p
= 'T'; break;
5982 case SHF_EXCLUDE
: *p
= 'E'; break;
5983 case SHF_COMPRESSED
: *p
= 'C'; break;
5984 case SHF_GNU_MBIND
: *p
= 'D'; break;
5987 if ((filedata
->file_header
.e_machine
== EM_X86_64
5988 || filedata
->file_header
.e_machine
== EM_L1OM
5989 || filedata
->file_header
.e_machine
== EM_K1OM
)
5990 && flag
== SHF_X86_64_LARGE
)
5992 else if (filedata
->file_header
.e_machine
== EM_ARM
5993 && flag
== SHF_ARM_PURECODE
)
5995 else if (filedata
->file_header
.e_machine
== EM_PPC
5996 && flag
== SHF_PPC_VLE
)
5998 else if (flag
& SHF_MASKOS
)
6001 sh_flags
&= ~ SHF_MASKOS
;
6003 else if (flag
& SHF_MASKPROC
)
6006 sh_flags
&= ~ SHF_MASKPROC
;
6016 if (do_section_details
)
6020 size
-= 5 + field_size
;
6021 if (p
!= buff
+ field_size
+ 4)
6025 warn (_("Internal error: not enough buffer room for section flag info"));
6026 return _("<unknown>");
6032 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6033 (unsigned long) os_flags
);
6034 p
+= 5 + field_size
;
6038 size
-= 7 + field_size
;
6039 if (p
!= buff
+ field_size
+ 4)
6043 warn (_("Internal error: not enough buffer room for section flag info"));
6044 return _("<unknown>");
6050 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6051 (unsigned long) proc_flags
);
6052 p
+= 7 + field_size
;
6056 size
-= 10 + field_size
;
6057 if (p
!= buff
+ field_size
+ 4)
6061 warn (_("Internal error: not enough buffer room for section flag info"));
6062 return _("<unknown>");
6068 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6069 (unsigned long) unknown_flags
);
6070 p
+= 10 + field_size
;
6079 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6083 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6085 if (size
< sizeof (* echdr
))
6087 error (_("Compressed section is too small even for a compression header\n"));
6091 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6092 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6093 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6094 return sizeof (*echdr
);
6098 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6100 if (size
< sizeof (* echdr
))
6102 error (_("Compressed section is too small even for a compression header\n"));
6106 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6107 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6108 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6109 return sizeof (*echdr
);
6114 process_section_headers (Filedata
* filedata
)
6116 Elf_Internal_Shdr
* section
;
6119 filedata
->section_headers
= NULL
;
6121 if (filedata
->file_header
.e_shnum
== 0)
6123 /* PR binutils/12467. */
6124 if (filedata
->file_header
.e_shoff
!= 0)
6126 warn (_("possibly corrupt ELF file header - it has a non-zero"
6127 " section header offset, but no section headers\n"));
6130 else if (do_sections
)
6131 printf (_("\nThere are no sections in this file.\n"));
6136 if (do_sections
&& !do_header
)
6137 printf (ngettext ("There is %d section header, "
6138 "starting at offset 0x%lx:\n",
6139 "There are %d section headers, "
6140 "starting at offset 0x%lx:\n",
6141 filedata
->file_header
.e_shnum
),
6142 filedata
->file_header
.e_shnum
,
6143 (unsigned long) filedata
->file_header
.e_shoff
);
6147 if (! get_32bit_section_headers (filedata
, FALSE
))
6152 if (! get_64bit_section_headers (filedata
, FALSE
))
6156 /* Read in the string table, so that we have names to display. */
6157 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6158 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6160 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6162 if (section
->sh_size
!= 0)
6164 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6165 1, section
->sh_size
,
6168 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6172 /* Scan the sections for the dynamic symbol table
6173 and dynamic string table and debug sections. */
6174 dynamic_symbols
= NULL
;
6175 dynamic_strings
= NULL
;
6176 dynamic_syminfo
= NULL
;
6177 symtab_shndx_list
= NULL
;
6179 eh_addr_size
= is_32bit_elf
? 4 : 8;
6180 switch (filedata
->file_header
.e_machine
)
6183 case EM_MIPS_RS3_LE
:
6184 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6185 FDE addresses. However, the ABI also has a semi-official ILP32
6186 variant for which the normal FDE address size rules apply.
6188 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6189 section, where XX is the size of longs in bits. Unfortunately,
6190 earlier compilers provided no way of distinguishing ILP32 objects
6191 from LP64 objects, so if there's any doubt, we should assume that
6192 the official LP64 form is being used. */
6193 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6194 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6200 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6202 case E_H8_MACH_H8300
:
6203 case E_H8_MACH_H8300HN
:
6204 case E_H8_MACH_H8300SN
:
6205 case E_H8_MACH_H8300SXN
:
6208 case E_H8_MACH_H8300H
:
6209 case E_H8_MACH_H8300S
:
6210 case E_H8_MACH_H8300SX
:
6218 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6220 case EF_M32C_CPU_M16C
:
6227 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6230 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6231 if (section->sh_entsize != expected_entsize) \
6234 sprintf_vma (buf, section->sh_entsize); \
6235 /* Note: coded this way so that there is a single string for \
6237 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6238 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6239 (unsigned) expected_entsize); \
6240 section->sh_entsize = expected_entsize; \
6245 #define CHECK_ENTSIZE(section, i, type) \
6246 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6247 sizeof (Elf64_External_##type))
6249 for (i
= 0, section
= filedata
->section_headers
;
6250 i
< filedata
->file_header
.e_shnum
;
6253 char * name
= SECTION_NAME (section
);
6255 if (section
->sh_type
== SHT_DYNSYM
)
6257 if (dynamic_symbols
!= NULL
)
6259 error (_("File contains multiple dynamic symbol tables\n"));
6263 CHECK_ENTSIZE (section
, i
, Sym
);
6264 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6266 else if (section
->sh_type
== SHT_STRTAB
6267 && streq (name
, ".dynstr"))
6269 if (dynamic_strings
!= NULL
)
6271 error (_("File contains multiple dynamic string tables\n"));
6275 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6276 1, section
->sh_size
,
6277 _("dynamic strings"));
6278 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6280 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6282 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6284 entry
->hdr
= section
;
6285 entry
->next
= symtab_shndx_list
;
6286 symtab_shndx_list
= entry
;
6288 else if (section
->sh_type
== SHT_SYMTAB
)
6289 CHECK_ENTSIZE (section
, i
, Sym
);
6290 else if (section
->sh_type
== SHT_GROUP
)
6291 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6292 else if (section
->sh_type
== SHT_REL
)
6293 CHECK_ENTSIZE (section
, i
, Rel
);
6294 else if (section
->sh_type
== SHT_RELA
)
6295 CHECK_ENTSIZE (section
, i
, Rela
);
6296 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6297 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6298 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6299 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6300 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6301 && (const_strneq (name
, ".debug_")
6302 || const_strneq (name
, ".zdebug_")))
6305 name
+= sizeof (".zdebug_") - 1;
6307 name
+= sizeof (".debug_") - 1;
6310 || (do_debug_info
&& const_strneq (name
, "info"))
6311 || (do_debug_info
&& const_strneq (name
, "types"))
6312 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6313 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6314 || (do_debug_lines
&& const_strneq (name
, "line."))
6315 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6316 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6317 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6318 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6319 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6320 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6321 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6322 || (do_debug_frames
&& const_strneq (name
, "frame"))
6323 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6324 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6325 || (do_debug_str
&& const_strneq (name
, "str"))
6326 || (do_debug_loc
&& const_strneq (name
, "loc"))
6327 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6328 || (do_debug_addr
&& const_strneq (name
, "addr"))
6329 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6330 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6332 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6334 /* Linkonce section to be combined with .debug_info at link time. */
6335 else if ((do_debugging
|| do_debug_info
)
6336 && const_strneq (name
, ".gnu.linkonce.wi."))
6337 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6338 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6339 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6340 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6341 || streq (name
, ".debug_names")))
6342 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6343 /* Trace sections for Itanium VMS. */
6344 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6345 || do_trace_aranges
)
6346 && const_strneq (name
, ".trace_"))
6348 name
+= sizeof (".trace_") - 1;
6351 || (do_trace_info
&& streq (name
, "info"))
6352 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6353 || (do_trace_aranges
&& streq (name
, "aranges"))
6355 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6357 else if ((do_debugging
|| do_debug_links
)
6358 && (const_strneq (name
, ".gnu_debuglink")
6359 || const_strneq (name
, ".gnu_debugaltlink")))
6360 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6366 if (filedata
->file_header
.e_shnum
> 1)
6367 printf (_("\nSection Headers:\n"));
6369 printf (_("\nSection Header:\n"));
6373 if (do_section_details
)
6375 printf (_(" [Nr] Name\n"));
6376 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6380 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6384 if (do_section_details
)
6386 printf (_(" [Nr] Name\n"));
6387 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6391 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6395 if (do_section_details
)
6397 printf (_(" [Nr] Name\n"));
6398 printf (_(" Type Address Offset Link\n"));
6399 printf (_(" Size EntSize Info Align\n"));
6403 printf (_(" [Nr] Name Type Address Offset\n"));
6404 printf (_(" Size EntSize Flags Link Info Align\n"));
6408 if (do_section_details
)
6409 printf (_(" Flags\n"));
6411 for (i
= 0, section
= filedata
->section_headers
;
6412 i
< filedata
->file_header
.e_shnum
;
6415 /* Run some sanity checks on the section header. */
6417 /* Check the sh_link field. */
6418 switch (section
->sh_type
)
6422 if (section
->sh_link
== 0
6423 && (filedata
->file_header
.e_type
== ET_EXEC
6424 || filedata
->file_header
.e_type
== ET_DYN
))
6425 /* A dynamic relocation section where all entries use a
6426 zero symbol index need not specify a symtab section. */
6429 case SHT_SYMTAB_SHNDX
:
6433 case SHT_GNU_versym
:
6434 if (section
->sh_link
== 0
6435 || section
->sh_link
>= filedata
->file_header
.e_shnum
6436 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6437 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6438 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6439 i
, section
->sh_link
);
6445 case SHT_GNU_verneed
:
6446 case SHT_GNU_verdef
:
6447 case SHT_GNU_LIBLIST
:
6448 if (section
->sh_link
== 0
6449 || section
->sh_link
>= filedata
->file_header
.e_shnum
6450 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6451 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6452 i
, section
->sh_link
);
6455 case SHT_INIT_ARRAY
:
6456 case SHT_FINI_ARRAY
:
6457 case SHT_PREINIT_ARRAY
:
6458 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6459 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6460 i
, section
->sh_link
);
6464 /* FIXME: Add support for target specific section types. */
6465 #if 0 /* Currently we do not check other section types as there are too
6466 many special cases. Stab sections for example have a type
6467 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6469 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6470 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6471 i
, section
->sh_link
);
6476 /* Check the sh_info field. */
6477 switch (section
->sh_type
)
6481 if (section
->sh_info
== 0
6482 && (filedata
->file_header
.e_type
== ET_EXEC
6483 || filedata
->file_header
.e_type
== ET_DYN
))
6484 /* Dynamic relocations apply to segments, so they do not
6485 need to specify the section they relocate. */
6487 if (section
->sh_info
== 0
6488 || section
->sh_info
>= filedata
->file_header
.e_shnum
6489 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6490 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6491 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6492 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6493 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6494 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6495 /* FIXME: Are other section types valid ? */
6496 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6497 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6498 i
, section
->sh_info
);
6503 case SHT_SYMTAB_SHNDX
:
6504 case SHT_INIT_ARRAY
:
6505 case SHT_FINI_ARRAY
:
6506 case SHT_PREINIT_ARRAY
:
6507 if (section
->sh_info
!= 0)
6508 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6509 i
, section
->sh_info
);
6515 /* A symbol index - we assume that it is valid. */
6519 /* FIXME: Add support for target specific section types. */
6520 if (section
->sh_type
== SHT_NOBITS
)
6521 /* NOBITS section headers with non-zero sh_info fields can be
6522 created when a binary is stripped of everything but its debug
6523 information. The stripped sections have their headers
6524 preserved but their types set to SHT_NOBITS. So do not check
6525 this type of section. */
6527 else if (section
->sh_flags
& SHF_INFO_LINK
)
6529 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6530 warn (_("[%2u]: Expected link to another section in info field"), i
);
6532 else if (section
->sh_type
< SHT_LOOS
6533 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6534 && section
->sh_info
!= 0)
6535 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6536 i
, section
->sh_info
);
6540 /* Check the sh_size field. */
6541 if (section
->sh_size
> filedata
->file_size
6542 && section
->sh_type
!= SHT_NOBITS
6543 && section
->sh_type
!= SHT_NULL
6544 && section
->sh_type
< SHT_LOOS
)
6545 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6547 printf (" [%2u] ", i
);
6548 if (do_section_details
)
6549 printf ("%s\n ", printable_section_name (filedata
, section
));
6551 print_symbol (-17, SECTION_NAME (section
));
6553 printf (do_wide
? " %-15s " : " %-15.15s ",
6554 get_section_type_name (filedata
, section
->sh_type
));
6558 const char * link_too_big
= NULL
;
6560 print_vma (section
->sh_addr
, LONG_HEX
);
6562 printf ( " %6.6lx %6.6lx %2.2lx",
6563 (unsigned long) section
->sh_offset
,
6564 (unsigned long) section
->sh_size
,
6565 (unsigned long) section
->sh_entsize
);
6567 if (do_section_details
)
6568 fputs (" ", stdout
);
6570 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6572 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6575 /* The sh_link value is out of range. Normally this indicates
6576 an error but it can have special values in Solaris binaries. */
6577 switch (filedata
->file_header
.e_machine
)
6584 case EM_OLD_SPARCV9
:
6585 case EM_SPARC32PLUS
:
6588 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6589 link_too_big
= "BEFORE";
6590 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6591 link_too_big
= "AFTER";
6598 if (do_section_details
)
6600 if (link_too_big
!= NULL
&& * link_too_big
)
6601 printf ("<%s> ", link_too_big
);
6603 printf ("%2u ", section
->sh_link
);
6604 printf ("%3u %2lu\n", section
->sh_info
,
6605 (unsigned long) section
->sh_addralign
);
6608 printf ("%2u %3u %2lu\n",
6611 (unsigned long) section
->sh_addralign
);
6613 if (link_too_big
&& ! * link_too_big
)
6614 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6615 i
, section
->sh_link
);
6619 print_vma (section
->sh_addr
, LONG_HEX
);
6621 if ((long) section
->sh_offset
== section
->sh_offset
)
6622 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6626 print_vma (section
->sh_offset
, LONG_HEX
);
6629 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6630 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6634 print_vma (section
->sh_size
, LONG_HEX
);
6637 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6638 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6642 print_vma (section
->sh_entsize
, LONG_HEX
);
6645 if (do_section_details
)
6646 fputs (" ", stdout
);
6648 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6650 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6652 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6653 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6656 print_vma (section
->sh_addralign
, DEC
);
6660 else if (do_section_details
)
6663 print_vma (section
->sh_addr
, LONG_HEX
);
6664 if ((long) section
->sh_offset
== section
->sh_offset
)
6665 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6669 print_vma (section
->sh_offset
, LONG_HEX
);
6671 printf (" %u\n ", section
->sh_link
);
6672 print_vma (section
->sh_size
, LONG_HEX
);
6674 print_vma (section
->sh_entsize
, LONG_HEX
);
6676 printf (" %-16u %lu\n",
6678 (unsigned long) section
->sh_addralign
);
6683 print_vma (section
->sh_addr
, LONG_HEX
);
6684 if ((long) section
->sh_offset
== section
->sh_offset
)
6685 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6689 print_vma (section
->sh_offset
, LONG_HEX
);
6692 print_vma (section
->sh_size
, LONG_HEX
);
6694 print_vma (section
->sh_entsize
, LONG_HEX
);
6696 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6698 printf (" %2u %3u %lu\n",
6701 (unsigned long) section
->sh_addralign
);
6704 if (do_section_details
)
6706 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6707 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6709 /* Minimum section size is 12 bytes for 32-bit compression
6710 header + 12 bytes for compressed data header. */
6711 unsigned char buf
[24];
6713 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6714 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6715 sizeof (buf
), _("compression header")))
6717 Elf_Internal_Chdr chdr
;
6719 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6721 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6724 printf (_(" [<unknown>: 0x%x], "),
6726 print_vma (chdr
.ch_size
, LONG_HEX
);
6727 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6733 if (!do_section_details
)
6735 /* The ordering of the letters shown here matches the ordering of the
6736 corresponding SHF_xxx values, and hence the order in which these
6737 letters will be displayed to the user. */
6738 printf (_("Key to Flags:\n\
6739 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6740 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6741 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6742 if (filedata
->file_header
.e_machine
== EM_X86_64
6743 || filedata
->file_header
.e_machine
== EM_L1OM
6744 || filedata
->file_header
.e_machine
== EM_K1OM
)
6745 printf (_("l (large), "));
6746 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6747 printf (_("y (purecode), "));
6748 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6749 printf (_("v (VLE), "));
6750 printf ("p (processor specific)\n");
6757 get_group_flags (unsigned int flags
)
6759 static char buff
[128];
6763 else if (flags
== GRP_COMDAT
)
6766 snprintf (buff
, 14, _("[0x%x: "), flags
);
6768 flags
&= ~ GRP_COMDAT
;
6769 if (flags
& GRP_MASKOS
)
6771 strcat (buff
, "<OS specific>");
6772 flags
&= ~ GRP_MASKOS
;
6775 if (flags
& GRP_MASKPROC
)
6777 strcat (buff
, "<PROC specific>");
6778 flags
&= ~ GRP_MASKPROC
;
6782 strcat (buff
, "<unknown>");
6789 process_section_groups (Filedata
* filedata
)
6791 Elf_Internal_Shdr
* section
;
6793 struct group
* group
;
6794 Elf_Internal_Shdr
* symtab_sec
;
6795 Elf_Internal_Shdr
* strtab_sec
;
6796 Elf_Internal_Sym
* symtab
;
6797 unsigned long num_syms
;
6801 /* Don't process section groups unless needed. */
6802 if (!do_unwind
&& !do_section_groups
)
6805 if (filedata
->file_header
.e_shnum
== 0)
6807 if (do_section_groups
)
6808 printf (_("\nThere are no sections to group in this file.\n"));
6813 if (filedata
->section_headers
== NULL
)
6815 error (_("Section headers are not available!\n"));
6816 /* PR 13622: This can happen with a corrupt ELF header. */
6820 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6821 sizeof (struct group
*));
6823 if (section_headers_groups
== NULL
)
6825 error (_("Out of memory reading %u section group headers\n"),
6826 filedata
->file_header
.e_shnum
);
6830 /* Scan the sections for the group section. */
6832 for (i
= 0, section
= filedata
->section_headers
;
6833 i
< filedata
->file_header
.e_shnum
;
6835 if (section
->sh_type
== SHT_GROUP
)
6838 if (group_count
== 0)
6840 if (do_section_groups
)
6841 printf (_("\nThere are no section groups in this file.\n"));
6846 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6848 if (section_groups
== NULL
)
6850 error (_("Out of memory reading %lu groups\n"),
6851 (unsigned long) group_count
);
6861 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6862 i
< filedata
->file_header
.e_shnum
;
6865 if (section
->sh_type
== SHT_GROUP
)
6867 const char * name
= printable_section_name (filedata
, section
);
6868 const char * group_name
;
6869 unsigned char * start
;
6870 unsigned char * indices
;
6871 unsigned int entry
, j
, size
;
6872 Elf_Internal_Shdr
* sec
;
6873 Elf_Internal_Sym
* sym
;
6875 /* Get the symbol table. */
6876 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6877 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6880 error (_("Bad sh_link in group section `%s'\n"), name
);
6884 if (symtab_sec
!= sec
)
6889 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6894 error (_("Corrupt header in group section `%s'\n"), name
);
6898 if (section
->sh_info
>= num_syms
)
6900 error (_("Bad sh_info in group section `%s'\n"), name
);
6904 sym
= symtab
+ section
->sh_info
;
6906 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6908 if (sym
->st_shndx
== 0
6909 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6911 error (_("Bad sh_info in group section `%s'\n"), name
);
6915 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6924 /* Get the string table. */
6925 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6934 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6940 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6941 1, strtab_sec
->sh_size
,
6943 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6945 group_name
= sym
->st_name
< strtab_size
6946 ? strtab
+ sym
->st_name
: _("<corrupt>");
6949 /* PR 17531: file: loop. */
6950 if (section
->sh_entsize
> section
->sh_size
)
6952 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6953 printable_section_name (filedata
, section
),
6954 (unsigned long) section
->sh_entsize
,
6955 (unsigned long) section
->sh_size
);
6959 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6960 1, section
->sh_size
,
6966 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6967 entry
= byte_get (indices
, 4);
6970 if (do_section_groups
)
6972 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6973 get_group_flags (entry
), i
, name
, group_name
, size
);
6975 printf (_(" [Index] Name\n"));
6978 group
->group_index
= i
;
6980 for (j
= 0; j
< size
; j
++)
6982 struct group_list
* g
;
6984 entry
= byte_get (indices
, 4);
6987 if (entry
>= filedata
->file_header
.e_shnum
)
6989 static unsigned num_group_errors
= 0;
6991 if (num_group_errors
++ < 10)
6993 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6994 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6995 if (num_group_errors
== 10)
6996 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7001 if (section_headers_groups
[entry
] != NULL
)
7005 static unsigned num_errs
= 0;
7007 if (num_errs
++ < 10)
7009 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7011 section_headers_groups
[entry
]->group_index
);
7013 warn (_("Further error messages about already contained group sections suppressed\n"));
7019 /* Intel C/C++ compiler may put section 0 in a
7020 section group. We just warn it the first time
7021 and ignore it afterwards. */
7022 static bfd_boolean warned
= FALSE
;
7025 error (_("section 0 in group section [%5u]\n"),
7026 section_headers_groups
[entry
]->group_index
);
7032 section_headers_groups
[entry
] = group
;
7034 if (do_section_groups
)
7036 sec
= filedata
->section_headers
+ entry
;
7037 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7040 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7041 g
->section_index
= entry
;
7042 g
->next
= group
->root
;
7060 /* Data used to display dynamic fixups. */
7062 struct ia64_vms_dynfixup
7064 bfd_vma needed_ident
; /* Library ident number. */
7065 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7066 bfd_vma fixup_needed
; /* Index of the library. */
7067 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7068 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7071 /* Data used to display dynamic relocations. */
7073 struct ia64_vms_dynimgrela
7075 bfd_vma img_rela_cnt
; /* Number of relocations. */
7076 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7079 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7083 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7084 struct ia64_vms_dynfixup
* fixup
,
7085 const char * strtab
,
7086 unsigned int strtab_sz
)
7088 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7090 const char * lib_name
;
7092 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7093 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
7094 _("dynamic section image fixups"));
7098 if (fixup
->needed
< strtab_sz
)
7099 lib_name
= strtab
+ fixup
->needed
;
7102 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7103 (unsigned long) fixup
->needed
);
7106 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7107 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7109 (_("Seg Offset Type SymVec DataType\n"));
7111 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7116 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7117 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7118 type
= BYTE_GET (imfs
[i
].type
);
7119 rtype
= elf_ia64_reloc_type (type
);
7121 printf (" 0x%08x ", type
);
7123 printf (" %-32s ", rtype
);
7124 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7125 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7132 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7135 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7137 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7140 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7141 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7142 _("dynamic section image relocations"));
7146 printf (_("\nImage relocs\n"));
7148 (_("Seg Offset Type Addend Seg Sym Off\n"));
7150 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7155 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7156 printf ("%08" BFD_VMA_FMT
"x ",
7157 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7158 type
= BYTE_GET (imrs
[i
].type
);
7159 rtype
= elf_ia64_reloc_type (type
);
7161 printf ("0x%08x ", type
);
7163 printf ("%-31s ", rtype
);
7164 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7165 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7166 printf ("%08" BFD_VMA_FMT
"x\n",
7167 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7174 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7177 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7179 struct ia64_vms_dynfixup fixup
;
7180 struct ia64_vms_dynimgrela imgrela
;
7181 Elf_Internal_Dyn
*entry
;
7182 bfd_vma strtab_off
= 0;
7183 bfd_vma strtab_sz
= 0;
7184 char *strtab
= NULL
;
7185 bfd_boolean res
= TRUE
;
7187 memset (&fixup
, 0, sizeof (fixup
));
7188 memset (&imgrela
, 0, sizeof (imgrela
));
7190 /* Note: the order of the entries is specified by the OpenVMS specs. */
7191 for (entry
= dynamic_section
;
7192 entry
< dynamic_section
+ dynamic_nent
;
7195 switch (entry
->d_tag
)
7197 case DT_IA_64_VMS_STRTAB_OFFSET
:
7198 strtab_off
= entry
->d_un
.d_val
;
7201 strtab_sz
= entry
->d_un
.d_val
;
7203 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7204 1, strtab_sz
, _("dynamic string section"));
7207 case DT_IA_64_VMS_NEEDED_IDENT
:
7208 fixup
.needed_ident
= entry
->d_un
.d_val
;
7211 fixup
.needed
= entry
->d_un
.d_val
;
7213 case DT_IA_64_VMS_FIXUP_NEEDED
:
7214 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7216 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7217 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7219 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7220 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7221 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7224 case DT_IA_64_VMS_IMG_RELA_CNT
:
7225 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7227 case DT_IA_64_VMS_IMG_RELA_OFF
:
7228 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7229 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7251 dynamic_relocations
[] =
7253 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7254 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7255 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7258 /* Process the reloc section. */
7261 process_relocs (Filedata
* filedata
)
7263 unsigned long rel_size
;
7264 unsigned long rel_offset
;
7269 if (do_using_dynamic
)
7273 bfd_boolean has_dynamic_reloc
;
7276 has_dynamic_reloc
= FALSE
;
7278 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7280 is_rela
= dynamic_relocations
[i
].rela
;
7281 name
= dynamic_relocations
[i
].name
;
7282 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7283 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7286 has_dynamic_reloc
= TRUE
;
7288 if (is_rela
== UNKNOWN
)
7290 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7291 switch (dynamic_info
[DT_PLTREL
])
7305 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7306 name
, rel_offset
, rel_size
);
7308 dump_relocations (filedata
,
7309 offset_from_vma (filedata
, rel_offset
, rel_size
),
7311 dynamic_symbols
, num_dynamic_syms
,
7312 dynamic_strings
, dynamic_strings_length
,
7313 is_rela
, TRUE
/* is_dynamic */);
7317 if (is_ia64_vms (filedata
))
7318 if (process_ia64_vms_dynamic_relocs (filedata
))
7319 has_dynamic_reloc
= TRUE
;
7321 if (! has_dynamic_reloc
)
7322 printf (_("\nThere are no dynamic relocations in this file.\n"));
7326 Elf_Internal_Shdr
* section
;
7328 bfd_boolean found
= FALSE
;
7330 for (i
= 0, section
= filedata
->section_headers
;
7331 i
< filedata
->file_header
.e_shnum
;
7334 if ( section
->sh_type
!= SHT_RELA
7335 && section
->sh_type
!= SHT_REL
)
7338 rel_offset
= section
->sh_offset
;
7339 rel_size
= section
->sh_size
;
7343 Elf_Internal_Shdr
* strsec
;
7345 unsigned long num_rela
;
7347 printf (_("\nRelocation section "));
7349 if (filedata
->string_table
== NULL
)
7350 printf ("%d", section
->sh_name
);
7352 printf ("'%s'", printable_section_name (filedata
, section
));
7354 num_rela
= rel_size
/ section
->sh_entsize
;
7355 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7356 " at offset 0x%lx contains %lu entries:\n",
7358 rel_offset
, num_rela
);
7360 is_rela
= section
->sh_type
== SHT_RELA
;
7362 if (section
->sh_link
!= 0
7363 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7365 Elf_Internal_Shdr
* symsec
;
7366 Elf_Internal_Sym
* symtab
;
7367 unsigned long nsyms
;
7368 unsigned long strtablen
= 0;
7369 char * strtab
= NULL
;
7371 symsec
= filedata
->section_headers
+ section
->sh_link
;
7372 if (symsec
->sh_type
!= SHT_SYMTAB
7373 && symsec
->sh_type
!= SHT_DYNSYM
)
7376 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7381 if (symsec
->sh_link
!= 0
7382 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7384 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7386 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7389 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7392 dump_relocations (filedata
, rel_offset
, rel_size
,
7393 symtab
, nsyms
, strtab
, strtablen
,
7395 symsec
->sh_type
== SHT_DYNSYM
);
7401 dump_relocations (filedata
, rel_offset
, rel_size
,
7402 NULL
, 0, NULL
, 0, is_rela
,
7403 FALSE
/* is_dynamic */);
7411 /* Users sometimes forget the -D option, so try to be helpful. */
7412 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7414 if (dynamic_info
[dynamic_relocations
[i
].size
])
7416 printf (_("\nThere are no static relocations in this file."));
7417 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7422 if (i
== ARRAY_SIZE (dynamic_relocations
))
7423 printf (_("\nThere are no relocations in this file.\n"));
7430 /* An absolute address consists of a section and an offset. If the
7431 section is NULL, the offset itself is the address, otherwise, the
7432 address equals to LOAD_ADDRESS(section) + offset. */
7436 unsigned short section
;
7440 /* Find the nearest symbol at or below ADDR. Returns the symbol
7441 name, if found, and the offset from the symbol to ADDR. */
7444 find_symbol_for_address (Filedata
* filedata
,
7445 Elf_Internal_Sym
* symtab
,
7446 unsigned long nsyms
,
7447 const char * strtab
,
7448 unsigned long strtab_size
,
7449 struct absaddr addr
,
7450 const char ** symname
,
7453 bfd_vma dist
= 0x100000;
7454 Elf_Internal_Sym
* sym
;
7455 Elf_Internal_Sym
* beg
;
7456 Elf_Internal_Sym
* end
;
7457 Elf_Internal_Sym
* best
= NULL
;
7459 REMOVE_ARCH_BITS (addr
.offset
);
7461 end
= symtab
+ nsyms
;
7467 sym
= beg
+ (end
- beg
) / 2;
7469 value
= sym
->st_value
;
7470 REMOVE_ARCH_BITS (value
);
7472 if (sym
->st_name
!= 0
7473 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7474 && addr
.offset
>= value
7475 && addr
.offset
- value
< dist
)
7478 dist
= addr
.offset
- value
;
7483 if (addr
.offset
< value
)
7491 *symname
= (best
->st_name
>= strtab_size
7492 ? _("<corrupt>") : strtab
+ best
->st_name
);
7498 *offset
= addr
.offset
;
7501 static /* signed */ int
7502 symcmp (const void *p
, const void *q
)
7504 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7505 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7507 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7510 /* Process the unwind section. */
7512 #include "unwind-ia64.h"
7514 struct ia64_unw_table_entry
7516 struct absaddr start
;
7518 struct absaddr info
;
7521 struct ia64_unw_aux_info
7523 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7524 unsigned long table_len
; /* Length of unwind table. */
7525 unsigned char * info
; /* Unwind info. */
7526 unsigned long info_size
; /* Size of unwind info. */
7527 bfd_vma info_addr
; /* Starting address of unwind info. */
7528 bfd_vma seg_base
; /* Starting address of segment. */
7529 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7530 unsigned long nsyms
; /* Number of symbols. */
7531 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7532 unsigned long nfuns
; /* Number of entries in funtab. */
7533 char * strtab
; /* The string table. */
7534 unsigned long strtab_size
; /* Size of string table. */
7538 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7540 struct ia64_unw_table_entry
* tp
;
7541 unsigned long j
, nfuns
;
7543 bfd_boolean res
= TRUE
;
7545 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7546 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7547 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7548 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7550 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7552 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7556 const unsigned char * dp
;
7557 const unsigned char * head
;
7558 const unsigned char * end
;
7559 const char * procname
;
7561 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7562 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7564 fputs ("\n<", stdout
);
7568 fputs (procname
, stdout
);
7571 printf ("+%lx", (unsigned long) offset
);
7574 fputs (">: [", stdout
);
7575 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7576 fputc ('-', stdout
);
7577 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7578 printf ("], info at +0x%lx\n",
7579 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7581 /* PR 17531: file: 86232b32. */
7582 if (aux
->info
== NULL
)
7585 offset
= tp
->info
.offset
;
7586 if (tp
->info
.section
)
7588 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7590 warn (_("Invalid section %u in table entry %ld\n"),
7591 tp
->info
.section
, (long) (tp
- aux
->table
));
7595 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7597 offset
-= aux
->info_addr
;
7598 /* PR 17531: file: 0997b4d1. */
7599 if (offset
>= aux
->info_size
7600 || aux
->info_size
- offset
< 8)
7602 warn (_("Invalid offset %lx in table entry %ld\n"),
7603 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7608 head
= aux
->info
+ offset
;
7609 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7611 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7612 (unsigned) UNW_VER (stamp
),
7613 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7614 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7615 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7616 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7618 if (UNW_VER (stamp
) != 1)
7620 printf (_("\tUnknown version.\n"));
7625 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7626 /* PR 17531: file: 16ceda89. */
7627 if (end
> aux
->info
+ aux
->info_size
)
7628 end
= aux
->info
+ aux
->info_size
;
7629 for (dp
= head
+ 8; dp
< end
;)
7630 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7639 slurp_ia64_unwind_table (Filedata
* filedata
,
7640 struct ia64_unw_aux_info
* aux
,
7641 Elf_Internal_Shdr
* sec
)
7643 unsigned long size
, nrelas
, i
;
7644 Elf_Internal_Phdr
* seg
;
7645 struct ia64_unw_table_entry
* tep
;
7646 Elf_Internal_Shdr
* relsec
;
7647 Elf_Internal_Rela
* rela
;
7648 Elf_Internal_Rela
* rp
;
7649 unsigned char * table
;
7651 Elf_Internal_Sym
* sym
;
7652 const char * relname
;
7656 /* First, find the starting address of the segment that includes
7659 if (filedata
->file_header
.e_phnum
)
7661 if (! get_program_headers (filedata
))
7664 for (seg
= filedata
->program_headers
;
7665 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7668 if (seg
->p_type
!= PT_LOAD
)
7671 if (sec
->sh_addr
>= seg
->p_vaddr
7672 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7674 aux
->seg_base
= seg
->p_vaddr
;
7680 /* Second, build the unwind table from the contents of the unwind section: */
7681 size
= sec
->sh_size
;
7682 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7687 aux
->table_len
= size
/ (3 * eh_addr_size
);
7688 aux
->table
= (struct ia64_unw_table_entry
*)
7689 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7692 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7694 tep
->start
.section
= SHN_UNDEF
;
7695 tep
->end
.section
= SHN_UNDEF
;
7696 tep
->info
.section
= SHN_UNDEF
;
7697 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7698 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7699 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7700 tep
->start
.offset
+= aux
->seg_base
;
7701 tep
->end
.offset
+= aux
->seg_base
;
7702 tep
->info
.offset
+= aux
->seg_base
;
7706 /* Third, apply any relocations to the unwind table: */
7707 for (relsec
= filedata
->section_headers
;
7708 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7711 if (relsec
->sh_type
!= SHT_RELA
7712 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7713 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7716 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7725 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7727 unsigned int sym_ndx
;
7728 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7729 relname
= elf_ia64_reloc_type (r_type
);
7731 /* PR 17531: file: 9fa67536. */
7732 if (relname
== NULL
)
7734 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7738 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7740 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7744 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7746 /* PR 17531: file: 5bc8d9bf. */
7747 if (i
>= aux
->table_len
)
7749 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7753 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7754 if (sym_ndx
>= aux
->nsyms
)
7756 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7760 sym
= aux
->symtab
+ sym_ndx
;
7762 switch (rp
->r_offset
/ eh_addr_size
% 3)
7765 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7766 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7769 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7770 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7773 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7774 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7788 ia64_process_unwind (Filedata
* filedata
)
7790 Elf_Internal_Shdr
* sec
;
7791 Elf_Internal_Shdr
* unwsec
= NULL
;
7792 Elf_Internal_Shdr
* strsec
;
7793 unsigned long i
, unwcount
= 0, unwstart
= 0;
7794 struct ia64_unw_aux_info aux
;
7795 bfd_boolean res
= TRUE
;
7797 memset (& aux
, 0, sizeof (aux
));
7799 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7801 if (sec
->sh_type
== SHT_SYMTAB
7802 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7804 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7806 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7807 if (aux
.strtab
!= NULL
)
7809 error (_("Multiple auxillary string tables encountered\n"));
7813 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7816 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7818 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7823 printf (_("\nThere are no unwind sections in this file.\n"));
7825 while (unwcount
-- > 0)
7830 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7831 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7832 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7837 /* We have already counted the number of SHT_IA64_UNWIND
7838 sections so the loop above should never fail. */
7839 assert (unwsec
!= NULL
);
7842 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7844 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7846 /* We need to find which section group it is in. */
7847 struct group_list
* g
;
7849 if (section_headers_groups
== NULL
7850 || section_headers_groups
[i
] == NULL
)
7851 i
= filedata
->file_header
.e_shnum
;
7854 g
= section_headers_groups
[i
]->root
;
7856 for (; g
!= NULL
; g
= g
->next
)
7858 sec
= filedata
->section_headers
+ g
->section_index
;
7860 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7865 i
= filedata
->file_header
.e_shnum
;
7868 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7870 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7871 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7872 suffix
= SECTION_NAME (unwsec
) + len
;
7873 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7875 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7876 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7881 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7882 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7883 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7884 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7886 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7887 suffix
= SECTION_NAME (unwsec
) + len
;
7888 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7890 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7891 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7895 if (i
== filedata
->file_header
.e_shnum
)
7897 printf (_("\nCould not find unwind info section for "));
7899 if (filedata
->string_table
== NULL
)
7900 printf ("%d", unwsec
->sh_name
);
7902 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7906 aux
.info_addr
= sec
->sh_addr
;
7907 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7910 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7912 printf (_("\nUnwind section "));
7914 if (filedata
->string_table
== NULL
)
7915 printf ("%d", unwsec
->sh_name
);
7917 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7919 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7920 (unsigned long) unwsec
->sh_offset
,
7921 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7923 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7924 && aux
.table_len
> 0)
7925 dump_ia64_unwind (filedata
, & aux
);
7928 free ((char *) aux
.table
);
7930 free ((char *) aux
.info
);
7939 free ((char *) aux
.strtab
);
7944 struct hppa_unw_table_entry
7946 struct absaddr start
;
7948 unsigned int Cannot_unwind
:1; /* 0 */
7949 unsigned int Millicode
:1; /* 1 */
7950 unsigned int Millicode_save_sr0
:1; /* 2 */
7951 unsigned int Region_description
:2; /* 3..4 */
7952 unsigned int reserved1
:1; /* 5 */
7953 unsigned int Entry_SR
:1; /* 6 */
7954 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7955 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7956 unsigned int Args_stored
:1; /* 16 */
7957 unsigned int Variable_Frame
:1; /* 17 */
7958 unsigned int Separate_Package_Body
:1; /* 18 */
7959 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7960 unsigned int Stack_Overflow_Check
:1; /* 20 */
7961 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7962 unsigned int Ada_Region
:1; /* 22 */
7963 unsigned int cxx_info
:1; /* 23 */
7964 unsigned int cxx_try_catch
:1; /* 24 */
7965 unsigned int sched_entry_seq
:1; /* 25 */
7966 unsigned int reserved2
:1; /* 26 */
7967 unsigned int Save_SP
:1; /* 27 */
7968 unsigned int Save_RP
:1; /* 28 */
7969 unsigned int Save_MRP_in_frame
:1; /* 29 */
7970 unsigned int extn_ptr_defined
:1; /* 30 */
7971 unsigned int Cleanup_defined
:1; /* 31 */
7973 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7974 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7975 unsigned int Large_frame
:1; /* 2 */
7976 unsigned int Pseudo_SP_Set
:1; /* 3 */
7977 unsigned int reserved4
:1; /* 4 */
7978 unsigned int Total_frame_size
:27; /* 5..31 */
7981 struct hppa_unw_aux_info
7983 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7984 unsigned long table_len
; /* Length of unwind table. */
7985 bfd_vma seg_base
; /* Starting address of segment. */
7986 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7987 unsigned long nsyms
; /* Number of symbols. */
7988 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7989 unsigned long nfuns
; /* Number of entries in funtab. */
7990 char * strtab
; /* The string table. */
7991 unsigned long strtab_size
; /* Size of string table. */
7995 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7997 struct hppa_unw_table_entry
* tp
;
7998 unsigned long j
, nfuns
;
7999 bfd_boolean res
= TRUE
;
8001 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8002 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8003 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8004 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8006 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8008 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8011 const char * procname
;
8013 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8014 aux
->strtab_size
, tp
->start
, &procname
,
8017 fputs ("\n<", stdout
);
8021 fputs (procname
, stdout
);
8024 printf ("+%lx", (unsigned long) offset
);
8027 fputs (">: [", stdout
);
8028 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8029 fputc ('-', stdout
);
8030 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8033 #define PF(_m) if (tp->_m) printf (#_m " ");
8034 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8037 PF(Millicode_save_sr0
);
8038 /* PV(Region_description); */
8044 PF(Separate_Package_Body
);
8045 PF(Frame_Extension_Millicode
);
8046 PF(Stack_Overflow_Check
);
8047 PF(Two_Instruction_SP_Increment
);
8051 PF(sched_entry_seq
);
8054 PF(Save_MRP_in_frame
);
8055 PF(extn_ptr_defined
);
8056 PF(Cleanup_defined
);
8057 PF(MPE_XL_interrupt_marker
);
8058 PF(HP_UX_interrupt_marker
);
8061 PV(Total_frame_size
);
8074 slurp_hppa_unwind_table (Filedata
* filedata
,
8075 struct hppa_unw_aux_info
* aux
,
8076 Elf_Internal_Shdr
* sec
)
8078 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8079 Elf_Internal_Phdr
* seg
;
8080 struct hppa_unw_table_entry
* tep
;
8081 Elf_Internal_Shdr
* relsec
;
8082 Elf_Internal_Rela
* rela
;
8083 Elf_Internal_Rela
* rp
;
8084 unsigned char * table
;
8086 Elf_Internal_Sym
* sym
;
8087 const char * relname
;
8089 /* First, find the starting address of the segment that includes
8091 if (filedata
->file_header
.e_phnum
)
8093 if (! get_program_headers (filedata
))
8096 for (seg
= filedata
->program_headers
;
8097 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8100 if (seg
->p_type
!= PT_LOAD
)
8103 if (sec
->sh_addr
>= seg
->p_vaddr
8104 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8106 aux
->seg_base
= seg
->p_vaddr
;
8112 /* Second, build the unwind table from the contents of the unwind
8114 size
= sec
->sh_size
;
8115 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8121 nentries
= size
/ unw_ent_size
;
8122 size
= unw_ent_size
* nentries
;
8124 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8125 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8127 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8129 unsigned int tmp1
, tmp2
;
8131 tep
->start
.section
= SHN_UNDEF
;
8132 tep
->end
.section
= SHN_UNDEF
;
8134 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8135 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8136 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8137 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8139 tep
->start
.offset
+= aux
->seg_base
;
8140 tep
->end
.offset
+= aux
->seg_base
;
8142 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8143 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8144 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8145 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8146 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8147 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8148 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8149 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8150 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8151 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8152 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8153 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8154 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8155 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8156 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8157 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8158 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8159 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8160 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8161 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8162 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8163 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8164 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8165 tep
->Cleanup_defined
= tmp1
& 0x1;
8167 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8168 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8169 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8170 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8171 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8172 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8176 /* Third, apply any relocations to the unwind table. */
8177 for (relsec
= filedata
->section_headers
;
8178 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8181 if (relsec
->sh_type
!= SHT_RELA
8182 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8183 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8186 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8190 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8192 unsigned int sym_ndx
;
8193 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8194 relname
= elf_hppa_reloc_type (r_type
);
8196 if (relname
== NULL
)
8198 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8202 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8203 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8205 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8209 i
= rp
->r_offset
/ unw_ent_size
;
8210 if (i
>= aux
->table_len
)
8212 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8216 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8217 if (sym_ndx
>= aux
->nsyms
)
8219 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8223 sym
= aux
->symtab
+ sym_ndx
;
8225 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8228 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8229 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8232 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8233 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8243 aux
->table_len
= nentries
;
8249 hppa_process_unwind (Filedata
* filedata
)
8251 struct hppa_unw_aux_info aux
;
8252 Elf_Internal_Shdr
* unwsec
= NULL
;
8253 Elf_Internal_Shdr
* strsec
;
8254 Elf_Internal_Shdr
* sec
;
8256 bfd_boolean res
= TRUE
;
8258 if (filedata
->string_table
== NULL
)
8261 memset (& aux
, 0, sizeof (aux
));
8263 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8265 if (sec
->sh_type
== SHT_SYMTAB
8266 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8268 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8270 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8271 if (aux
.strtab
!= NULL
)
8273 error (_("Multiple auxillary string tables encountered\n"));
8277 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8280 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8282 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8287 printf (_("\nThere are no unwind sections in this file.\n"));
8289 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8291 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8293 unsigned long num_unwind
= sec
->sh_size
/ 16;
8295 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8296 "contains %lu entry:\n",
8297 "\nUnwind section '%s' at offset 0x%lx "
8298 "contains %lu entries:\n",
8300 printable_section_name (filedata
, sec
),
8301 (unsigned long) sec
->sh_offset
,
8304 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8307 if (res
&& aux
.table_len
> 0)
8309 if (! dump_hppa_unwind (filedata
, &aux
))
8314 free ((char *) aux
.table
);
8322 free ((char *) aux
.strtab
);
8329 unsigned char * data
; /* The unwind data. */
8330 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8331 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8332 unsigned long nrelas
; /* The number of relocations. */
8333 unsigned int rel_type
; /* REL or RELA ? */
8334 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8337 struct arm_unw_aux_info
8339 Filedata
* filedata
; /* The file containing the unwind sections. */
8340 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8341 unsigned long nsyms
; /* Number of symbols. */
8342 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8343 unsigned long nfuns
; /* Number of these symbols. */
8344 char * strtab
; /* The file's string table. */
8345 unsigned long strtab_size
; /* Size of string table. */
8349 arm_print_vma_and_name (Filedata
* filedata
,
8350 struct arm_unw_aux_info
* aux
,
8352 struct absaddr addr
)
8354 const char *procname
;
8357 if (addr
.section
== SHN_UNDEF
)
8360 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8361 aux
->strtab_size
, addr
, &procname
,
8364 print_vma (fn
, PREFIX_HEX
);
8368 fputs (" <", stdout
);
8369 fputs (procname
, stdout
);
8372 printf ("+0x%lx", (unsigned long) sym_offset
);
8373 fputc ('>', stdout
);
8380 arm_free_section (struct arm_section
*arm_sec
)
8382 if (arm_sec
->data
!= NULL
)
8383 free (arm_sec
->data
);
8385 if (arm_sec
->rela
!= NULL
)
8386 free (arm_sec
->rela
);
8389 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8390 cached section and install SEC instead.
8391 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8392 and return its valued in * WORDP, relocating if necessary.
8393 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8394 relocation's offset in ADDR.
8395 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8396 into the string table of the symbol associated with the reloc. If no
8397 reloc was applied store -1 there.
8398 5) Return TRUE upon success, FALSE otherwise. */
8401 get_unwind_section_word (Filedata
* filedata
,
8402 struct arm_unw_aux_info
* aux
,
8403 struct arm_section
* arm_sec
,
8404 Elf_Internal_Shdr
* sec
,
8405 bfd_vma word_offset
,
8406 unsigned int * wordp
,
8407 struct absaddr
* addr
,
8410 Elf_Internal_Rela
*rp
;
8411 Elf_Internal_Sym
*sym
;
8412 const char * relname
;
8414 bfd_boolean wrapped
;
8416 if (sec
== NULL
|| arm_sec
== NULL
)
8419 addr
->section
= SHN_UNDEF
;
8422 if (sym_name
!= NULL
)
8423 *sym_name
= (bfd_vma
) -1;
8425 /* If necessary, update the section cache. */
8426 if (sec
!= arm_sec
->sec
)
8428 Elf_Internal_Shdr
*relsec
;
8430 arm_free_section (arm_sec
);
8433 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8434 sec
->sh_size
, _("unwind data"));
8435 arm_sec
->rela
= NULL
;
8436 arm_sec
->nrelas
= 0;
8438 for (relsec
= filedata
->section_headers
;
8439 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8442 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8443 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8444 /* PR 15745: Check the section type as well. */
8445 || (relsec
->sh_type
!= SHT_REL
8446 && relsec
->sh_type
!= SHT_RELA
))
8449 arm_sec
->rel_type
= relsec
->sh_type
;
8450 if (relsec
->sh_type
== SHT_REL
)
8452 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8454 & arm_sec
->rela
, & arm_sec
->nrelas
))
8457 else /* relsec->sh_type == SHT_RELA */
8459 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8461 & arm_sec
->rela
, & arm_sec
->nrelas
))
8467 arm_sec
->next_rela
= arm_sec
->rela
;
8470 /* If there is no unwind data we can do nothing. */
8471 if (arm_sec
->data
== NULL
)
8474 /* If the offset is invalid then fail. */
8475 if (/* PR 21343 *//* PR 18879 */
8477 || word_offset
> (sec
->sh_size
- 4)
8478 || ((bfd_signed_vma
) word_offset
) < 0)
8481 /* Get the word at the required offset. */
8482 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8484 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8485 if (arm_sec
->rela
== NULL
)
8491 /* Look through the relocs to find the one that applies to the provided offset. */
8493 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8495 bfd_vma prelval
, offset
;
8497 if (rp
->r_offset
> word_offset
&& !wrapped
)
8502 if (rp
->r_offset
> word_offset
)
8505 if (rp
->r_offset
& 3)
8507 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8508 (unsigned long) rp
->r_offset
);
8512 if (rp
->r_offset
< word_offset
)
8515 /* PR 17531: file: 027-161405-0.004 */
8516 if (aux
->symtab
== NULL
)
8519 if (arm_sec
->rel_type
== SHT_REL
)
8521 offset
= word
& 0x7fffffff;
8522 if (offset
& 0x40000000)
8523 offset
|= ~ (bfd_vma
) 0x7fffffff;
8525 else if (arm_sec
->rel_type
== SHT_RELA
)
8526 offset
= rp
->r_addend
;
8529 error (_("Unknown section relocation type %d encountered\n"),
8534 /* PR 17531 file: 027-1241568-0.004. */
8535 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8537 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8538 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8542 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8543 offset
+= sym
->st_value
;
8544 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8546 /* Check that we are processing the expected reloc type. */
8547 if (filedata
->file_header
.e_machine
== EM_ARM
)
8549 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8550 if (relname
== NULL
)
8552 warn (_("Skipping unknown ARM relocation type: %d\n"),
8553 (int) ELF32_R_TYPE (rp
->r_info
));
8557 if (streq (relname
, "R_ARM_NONE"))
8560 if (! streq (relname
, "R_ARM_PREL31"))
8562 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8566 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8568 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8569 if (relname
== NULL
)
8571 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8572 (int) ELF32_R_TYPE (rp
->r_info
));
8576 if (streq (relname
, "R_C6000_NONE"))
8579 if (! streq (relname
, "R_C6000_PREL31"))
8581 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8589 /* This function currently only supports ARM and TI unwinders. */
8590 warn (_("Only TI and ARM unwinders are currently supported\n"));
8594 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8595 addr
->section
= sym
->st_shndx
;
8596 addr
->offset
= offset
;
8599 * sym_name
= sym
->st_name
;
8604 arm_sec
->next_rela
= rp
;
8609 static const char *tic6x_unwind_regnames
[16] =
8611 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8612 "A14", "A13", "A12", "A11", "A10",
8613 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8617 decode_tic6x_unwind_regmask (unsigned int mask
)
8621 for (i
= 12; mask
; mask
>>= 1, i
--)
8625 fputs (tic6x_unwind_regnames
[i
], stdout
);
8627 fputs (", ", stdout
);
8633 if (remaining == 0 && more_words) \
8636 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8637 data_offset, & word, & addr, NULL)) \
8643 #define GET_OP(OP) \
8648 (OP) = word >> 24; \
8653 printf (_("[Truncated opcode]\n")); \
8656 printf ("0x%02x ", OP)
8659 decode_arm_unwind_bytecode (Filedata
* filedata
,
8660 struct arm_unw_aux_info
* aux
,
8662 unsigned int remaining
,
8663 unsigned int more_words
,
8664 bfd_vma data_offset
,
8665 Elf_Internal_Shdr
* data_sec
,
8666 struct arm_section
* data_arm_sec
)
8668 struct absaddr addr
;
8669 bfd_boolean res
= TRUE
;
8671 /* Decode the unwinding instructions. */
8674 unsigned int op
, op2
;
8683 printf (" 0x%02x ", op
);
8685 if ((op
& 0xc0) == 0x00)
8687 int offset
= ((op
& 0x3f) << 2) + 4;
8689 printf (" vsp = vsp + %d", offset
);
8691 else if ((op
& 0xc0) == 0x40)
8693 int offset
= ((op
& 0x3f) << 2) + 4;
8695 printf (" vsp = vsp - %d", offset
);
8697 else if ((op
& 0xf0) == 0x80)
8700 if (op
== 0x80 && op2
== 0)
8701 printf (_("Refuse to unwind"));
8704 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8705 bfd_boolean first
= TRUE
;
8709 for (i
= 0; i
< 12; i
++)
8710 if (mask
& (1 << i
))
8716 printf ("r%d", 4 + i
);
8721 else if ((op
& 0xf0) == 0x90)
8723 if (op
== 0x9d || op
== 0x9f)
8724 printf (_(" [Reserved]"));
8726 printf (" vsp = r%d", op
& 0x0f);
8728 else if ((op
& 0xf0) == 0xa0)
8730 int end
= 4 + (op
& 0x07);
8731 bfd_boolean first
= TRUE
;
8735 for (i
= 4; i
<= end
; i
++)
8751 else if (op
== 0xb0)
8752 printf (_(" finish"));
8753 else if (op
== 0xb1)
8756 if (op2
== 0 || (op2
& 0xf0) != 0)
8757 printf (_("[Spare]"));
8760 unsigned int mask
= op2
& 0x0f;
8761 bfd_boolean first
= TRUE
;
8765 for (i
= 0; i
< 12; i
++)
8766 if (mask
& (1 << i
))
8777 else if (op
== 0xb2)
8779 unsigned char buf
[9];
8780 unsigned int i
, len
;
8781 unsigned long offset
;
8783 for (i
= 0; i
< sizeof (buf
); i
++)
8786 if ((buf
[i
] & 0x80) == 0)
8789 if (i
== sizeof (buf
))
8791 error (_("corrupt change to vsp\n"));
8796 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
8797 assert (len
== i
+ 1);
8798 offset
= offset
* 4 + 0x204;
8799 printf ("vsp = vsp + %ld", offset
);
8802 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8804 unsigned int first
, last
;
8811 printf ("pop {D%d", first
);
8813 printf ("-D%d", first
+ last
);
8816 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8818 unsigned int count
= op
& 0x07;
8822 printf ("-D%d", 8 + count
);
8825 else if (op
>= 0xc0 && op
<= 0xc5)
8827 unsigned int count
= op
& 0x07;
8829 printf (" pop {wR10");
8831 printf ("-wR%d", 10 + count
);
8834 else if (op
== 0xc6)
8836 unsigned int first
, last
;
8841 printf ("pop {wR%d", first
);
8843 printf ("-wR%d", first
+ last
);
8846 else if (op
== 0xc7)
8849 if (op2
== 0 || (op2
& 0xf0) != 0)
8850 printf (_("[Spare]"));
8853 unsigned int mask
= op2
& 0x0f;
8854 bfd_boolean first
= TRUE
;
8858 for (i
= 0; i
< 4; i
++)
8859 if (mask
& (1 << i
))
8865 printf ("wCGR%d", i
);
8872 printf (_(" [unsupported opcode]"));
8883 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8884 struct arm_unw_aux_info
* aux
,
8886 unsigned int remaining
,
8887 unsigned int more_words
,
8888 bfd_vma data_offset
,
8889 Elf_Internal_Shdr
* data_sec
,
8890 struct arm_section
* data_arm_sec
)
8892 struct absaddr addr
;
8894 /* Decode the unwinding instructions. */
8897 unsigned int op
, op2
;
8906 printf (" 0x%02x ", op
);
8908 if ((op
& 0xc0) == 0x00)
8910 int offset
= ((op
& 0x3f) << 3) + 8;
8911 printf (" sp = sp + %d", offset
);
8913 else if ((op
& 0xc0) == 0x80)
8916 if (op
== 0x80 && op2
== 0)
8917 printf (_("Refuse to unwind"));
8920 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8922 printf ("pop compact {");
8926 decode_tic6x_unwind_regmask (mask
);
8930 else if ((op
& 0xf0) == 0xc0)
8938 unsigned int offset
;
8942 /* Scan entire instruction first so that GET_OP output is not
8943 interleaved with disassembly. */
8945 for (i
= 0; nregs
< (op
& 0xf); i
++)
8951 regpos
[nregs
].offset
= i
* 2;
8952 regpos
[nregs
].reg
= reg
;
8959 regpos
[nregs
].offset
= i
* 2 + 1;
8960 regpos
[nregs
].reg
= reg
;
8965 printf (_("pop frame {"));
8968 printf (_("*corrupt* - no registers specified"));
8973 for (i
= i
* 2; i
> 0; i
--)
8975 if (regpos
[reg
].offset
== i
- 1)
8977 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8984 fputs (name
, stdout
);
8992 else if (op
== 0xd0)
8993 printf (" MOV FP, SP");
8994 else if (op
== 0xd1)
8995 printf (" __c6xabi_pop_rts");
8996 else if (op
== 0xd2)
8998 unsigned char buf
[9];
8999 unsigned int i
, len
;
9000 unsigned long offset
;
9002 for (i
= 0; i
< sizeof (buf
); i
++)
9005 if ((buf
[i
] & 0x80) == 0)
9008 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9009 if (i
== sizeof (buf
))
9011 warn (_("Corrupt stack pointer adjustment detected\n"));
9015 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9016 assert (len
== i
+ 1);
9017 offset
= offset
* 8 + 0x408;
9018 printf (_("sp = sp + %ld"), offset
);
9020 else if ((op
& 0xf0) == 0xe0)
9022 if ((op
& 0x0f) == 7)
9025 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9029 printf (_(" [unsupported opcode]"));
9038 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9042 offset
= word
& 0x7fffffff;
9043 if (offset
& 0x40000000)
9044 offset
|= ~ (bfd_vma
) 0x7fffffff;
9046 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9049 return offset
+ where
;
9053 decode_arm_unwind (Filedata
* filedata
,
9054 struct arm_unw_aux_info
* aux
,
9056 unsigned int remaining
,
9057 bfd_vma data_offset
,
9058 Elf_Internal_Shdr
* data_sec
,
9059 struct arm_section
* data_arm_sec
)
9062 unsigned int more_words
= 0;
9063 struct absaddr addr
;
9064 bfd_vma sym_name
= (bfd_vma
) -1;
9065 bfd_boolean res
= TRUE
;
9069 /* Fetch the first word.
9070 Note - when decoding an object file the address extracted
9071 here will always be 0. So we also pass in the sym_name
9072 parameter so that we can find the symbol associated with
9073 the personality routine. */
9074 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9075 & word
, & addr
, & sym_name
))
9082 addr
.section
= SHN_UNDEF
;
9086 if ((word
& 0x80000000) == 0)
9088 /* Expand prel31 for personality routine. */
9090 const char *procname
;
9092 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9093 printf (_(" Personality routine: "));
9095 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9096 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9098 procname
= aux
->strtab
+ sym_name
;
9099 print_vma (fn
, PREFIX_HEX
);
9102 fputs (" <", stdout
);
9103 fputs (procname
, stdout
);
9104 fputc ('>', stdout
);
9108 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9109 fputc ('\n', stdout
);
9111 /* The GCC personality routines use the standard compact
9112 encoding, starting with one byte giving the number of
9114 if (procname
!= NULL
9115 && (const_strneq (procname
, "__gcc_personality_v0")
9116 || const_strneq (procname
, "__gxx_personality_v0")
9117 || const_strneq (procname
, "__gcj_personality_v0")
9118 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9125 printf (_(" [Truncated data]\n"));
9128 more_words
= word
>> 24;
9138 /* ARM EHABI Section 6.3:
9140 An exception-handling table entry for the compact model looks like:
9144 1 0 index Data for personalityRoutine[index] */
9146 if (filedata
->file_header
.e_machine
== EM_ARM
9147 && (word
& 0x70000000))
9149 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9153 per_index
= (word
>> 24) & 0x7f;
9154 printf (_(" Compact model index: %d\n"), per_index
);
9161 else if (per_index
< 3)
9163 more_words
= (word
>> 16) & 0xff;
9169 switch (filedata
->file_header
.e_machine
)
9174 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9175 data_offset
, data_sec
, data_arm_sec
))
9180 warn (_("Unknown ARM compact model index encountered\n"));
9181 printf (_(" [reserved]\n"));
9189 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9190 data_offset
, data_sec
, data_arm_sec
))
9193 else if (per_index
< 5)
9195 if (((word
>> 17) & 0x7f) == 0x7f)
9196 printf (_(" Restore stack from frame pointer\n"));
9198 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9199 printf (_(" Registers restored: "));
9201 printf (" (compact) ");
9202 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9204 printf (_(" Return register: %s\n"),
9205 tic6x_unwind_regnames
[word
& 0xf]);
9208 printf (_(" [reserved (%d)]\n"), per_index
);
9212 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9213 filedata
->file_header
.e_machine
);
9217 /* Decode the descriptors. Not implemented. */
9223 dump_arm_unwind (Filedata
* filedata
,
9224 struct arm_unw_aux_info
* aux
,
9225 Elf_Internal_Shdr
* exidx_sec
)
9227 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9228 unsigned int i
, exidx_len
;
9229 unsigned long j
, nfuns
;
9230 bfd_boolean res
= TRUE
;
9232 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9233 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9234 exidx_len
= exidx_sec
->sh_size
/ 8;
9236 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9237 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9238 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9239 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9241 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9243 for (i
= 0; i
< exidx_len
; i
++)
9245 unsigned int exidx_fn
, exidx_entry
;
9246 struct absaddr fn_addr
, entry_addr
;
9249 fputc ('\n', stdout
);
9251 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9252 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9253 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9254 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9257 arm_free_section (& exidx_arm_sec
);
9258 arm_free_section (& extab_arm_sec
);
9262 /* ARM EHABI, Section 5:
9263 An index table entry consists of 2 words.
9264 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9265 if (exidx_fn
& 0x80000000)
9267 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9271 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9273 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9274 fputs (": ", stdout
);
9276 if (exidx_entry
== 1)
9278 print_vma (exidx_entry
, PREFIX_HEX
);
9279 fputs (" [cantunwind]\n", stdout
);
9281 else if (exidx_entry
& 0x80000000)
9283 print_vma (exidx_entry
, PREFIX_HEX
);
9284 fputc ('\n', stdout
);
9285 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9289 bfd_vma table
, table_offset
= 0;
9290 Elf_Internal_Shdr
*table_sec
;
9292 fputs ("@", stdout
);
9293 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9294 print_vma (table
, PREFIX_HEX
);
9297 /* Locate the matching .ARM.extab. */
9298 if (entry_addr
.section
!= SHN_UNDEF
9299 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9301 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9302 table_offset
= entry_addr
.offset
;
9304 if (table_offset
> table_sec
->sh_size
9305 || ((bfd_signed_vma
) table_offset
) < 0)
9307 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9308 (unsigned long) table_offset
,
9309 printable_section_name (filedata
, table_sec
));
9316 table_sec
= find_section_by_address (filedata
, table
);
9317 if (table_sec
!= NULL
)
9318 table_offset
= table
- table_sec
->sh_addr
;
9321 if (table_sec
== NULL
)
9323 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9324 (unsigned long) table
);
9329 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9338 arm_free_section (&exidx_arm_sec
);
9339 arm_free_section (&extab_arm_sec
);
9344 /* Used for both ARM and C6X unwinding tables. */
9347 arm_process_unwind (Filedata
* filedata
)
9349 struct arm_unw_aux_info aux
;
9350 Elf_Internal_Shdr
*unwsec
= NULL
;
9351 Elf_Internal_Shdr
*strsec
;
9352 Elf_Internal_Shdr
*sec
;
9354 unsigned int sec_type
;
9355 bfd_boolean res
= TRUE
;
9357 switch (filedata
->file_header
.e_machine
)
9360 sec_type
= SHT_ARM_EXIDX
;
9364 sec_type
= SHT_C6000_UNWIND
;
9368 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9369 filedata
->file_header
.e_machine
);
9373 if (filedata
->string_table
== NULL
)
9376 memset (& aux
, 0, sizeof (aux
));
9377 aux
.filedata
= filedata
;
9379 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9381 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9383 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9385 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9387 /* PR binutils/17531 file: 011-12666-0.004. */
9388 if (aux
.strtab
!= NULL
)
9390 error (_("Multiple string tables found in file.\n"));
9394 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9395 1, strsec
->sh_size
, _("string table"));
9396 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9398 else if (sec
->sh_type
== sec_type
)
9403 printf (_("\nThere are no unwind sections in this file.\n"));
9405 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9407 if (sec
->sh_type
== sec_type
)
9409 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9410 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9411 "contains %lu entry:\n",
9412 "\nUnwind section '%s' at offset 0x%lx "
9413 "contains %lu entries:\n",
9415 printable_section_name (filedata
, sec
),
9416 (unsigned long) sec
->sh_offset
,
9419 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9427 free ((char *) aux
.strtab
);
9433 process_unwind (Filedata
* filedata
)
9435 struct unwind_handler
9437 unsigned int machtype
;
9438 bfd_boolean (* handler
)(Filedata
*);
9441 { EM_ARM
, arm_process_unwind
},
9442 { EM_IA_64
, ia64_process_unwind
},
9443 { EM_PARISC
, hppa_process_unwind
},
9444 { EM_TI_C6000
, arm_process_unwind
},
9452 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9453 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9454 return handlers
[i
].handler (filedata
);
9456 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9457 get_machine_name (filedata
->file_header
.e_machine
));
9462 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9464 switch (entry
->d_tag
)
9466 case DT_AARCH64_BTI_PLT
:
9467 case DT_AARCH64_PAC_PLT
:
9470 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9477 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9479 switch (entry
->d_tag
)
9482 if (entry
->d_un
.d_val
== 0)
9486 static const char * opts
[] =
9488 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9489 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9490 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9491 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9495 bfd_boolean first
= TRUE
;
9497 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9498 if (entry
->d_un
.d_val
& (1 << cnt
))
9500 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9506 case DT_MIPS_IVERSION
:
9507 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9508 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9512 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9513 /* Note: coded this way so that there is a single string for translation. */
9514 printf (_("<corrupt: %s>"), buf
);
9518 case DT_MIPS_TIME_STAMP
:
9522 time_t atime
= entry
->d_un
.d_val
;
9524 tmp
= gmtime (&atime
);
9525 /* PR 17531: file: 6accc532. */
9527 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9529 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9530 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9531 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9532 printf (_("Time Stamp: %s"), timebuf
);
9536 case DT_MIPS_RLD_VERSION
:
9537 case DT_MIPS_LOCAL_GOTNO
:
9538 case DT_MIPS_CONFLICTNO
:
9539 case DT_MIPS_LIBLISTNO
:
9540 case DT_MIPS_SYMTABNO
:
9541 case DT_MIPS_UNREFEXTNO
:
9542 case DT_MIPS_HIPAGENO
:
9543 case DT_MIPS_DELTA_CLASS_NO
:
9544 case DT_MIPS_DELTA_INSTANCE_NO
:
9545 case DT_MIPS_DELTA_RELOC_NO
:
9546 case DT_MIPS_DELTA_SYM_NO
:
9547 case DT_MIPS_DELTA_CLASSSYM_NO
:
9548 case DT_MIPS_COMPACT_SIZE
:
9549 print_vma (entry
->d_un
.d_val
, DEC
);
9553 dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9554 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9555 /* Falls through. */
9558 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9564 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9566 switch (entry
->d_tag
)
9568 case DT_HP_DLD_FLAGS
:
9577 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9578 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9579 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9580 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9581 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9582 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9583 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9584 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9585 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9586 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9587 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9588 { DT_HP_GST
, "HP_GST" },
9589 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9590 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9591 { DT_HP_NODELETE
, "HP_NODELETE" },
9592 { DT_HP_GROUP
, "HP_GROUP" },
9593 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9595 bfd_boolean first
= TRUE
;
9597 bfd_vma val
= entry
->d_un
.d_val
;
9599 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9600 if (val
& flags
[cnt
].bit
)
9604 fputs (flags
[cnt
].str
, stdout
);
9606 val
^= flags
[cnt
].bit
;
9609 if (val
!= 0 || first
)
9613 print_vma (val
, HEX
);
9619 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9627 /* VMS vs Unix time offset and factor. */
9629 #define VMS_EPOCH_OFFSET 35067168000000000LL
9630 #define VMS_GRANULARITY_FACTOR 10000000
9632 /* Display a VMS time in a human readable format. */
9635 print_vms_time (bfd_int64_t vmstime
)
9640 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9641 tm
= gmtime (&unxtime
);
9642 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9643 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9644 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9649 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9651 switch (entry
->d_tag
)
9653 case DT_IA_64_PLT_RESERVE
:
9654 /* First 3 slots reserved. */
9655 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9657 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9660 case DT_IA_64_VMS_LINKTIME
:
9662 print_vms_time (entry
->d_un
.d_val
);
9666 case DT_IA_64_VMS_LNKFLAGS
:
9667 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9668 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9669 printf (" CALL_DEBUG");
9670 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9671 printf (" NOP0BUFS");
9672 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9673 printf (" P0IMAGE");
9674 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9675 printf (" MKTHREADS");
9676 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9677 printf (" UPCALLS");
9678 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9680 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9681 printf (" INITIALIZE");
9682 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9684 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9685 printf (" EXE_INIT");
9686 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9687 printf (" TBK_IN_IMG");
9688 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9689 printf (" DBG_IN_IMG");
9690 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9691 printf (" TBK_IN_DSF");
9692 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9693 printf (" DBG_IN_DSF");
9694 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9695 printf (" SIGNATURES");
9696 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9697 printf (" REL_SEG_OFF");
9701 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9708 get_32bit_dynamic_section (Filedata
* filedata
)
9710 Elf32_External_Dyn
* edyn
;
9711 Elf32_External_Dyn
* ext
;
9712 Elf_Internal_Dyn
* entry
;
9714 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9715 dynamic_size
, _("dynamic section"));
9719 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9720 might not have the luxury of section headers. Look for the DT_NULL
9721 terminator to determine the number of entries. */
9722 for (ext
= edyn
, dynamic_nent
= 0;
9723 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9727 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9731 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9733 if (dynamic_section
== NULL
)
9735 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9736 (unsigned long) dynamic_nent
);
9741 for (ext
= edyn
, entry
= dynamic_section
;
9742 entry
< dynamic_section
+ dynamic_nent
;
9745 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9746 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9755 get_64bit_dynamic_section (Filedata
* filedata
)
9757 Elf64_External_Dyn
* edyn
;
9758 Elf64_External_Dyn
* ext
;
9759 Elf_Internal_Dyn
* entry
;
9761 /* Read in the data. */
9762 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9763 dynamic_size
, _("dynamic section"));
9767 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9768 might not have the luxury of section headers. Look for the DT_NULL
9769 terminator to determine the number of entries. */
9770 for (ext
= edyn
, dynamic_nent
= 0;
9771 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9772 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9776 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9780 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9782 if (dynamic_section
== NULL
)
9784 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9785 (unsigned long) dynamic_nent
);
9790 /* Convert from external to internal formats. */
9791 for (ext
= edyn
, entry
= dynamic_section
;
9792 entry
< dynamic_section
+ dynamic_nent
;
9795 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9796 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9805 print_dynamic_flags (bfd_vma flags
)
9807 bfd_boolean first
= TRUE
;
9813 flag
= flags
& - flags
;
9823 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9824 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9825 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9826 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9827 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9828 default: fputs (_("unknown"), stdout
); break;
9834 /* Parse and display the contents of the dynamic section. */
9837 process_dynamic_section (Filedata
* filedata
)
9839 Elf_Internal_Dyn
* entry
;
9841 if (dynamic_size
== 0)
9844 printf (_("\nThere is no dynamic section in this file.\n"));
9851 if (! get_32bit_dynamic_section (filedata
))
9856 if (! get_64bit_dynamic_section (filedata
))
9860 /* Find the appropriate symbol table. */
9861 if (dynamic_symbols
== NULL
)
9863 for (entry
= dynamic_section
;
9864 entry
< dynamic_section
+ dynamic_nent
;
9867 Elf_Internal_Shdr section
;
9869 if (entry
->d_tag
!= DT_SYMTAB
)
9872 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9874 /* Since we do not know how big the symbol table is,
9875 we default to reading in the entire file (!) and
9876 processing that. This is overkill, I know, but it
9878 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9879 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9881 /* See PR 21379 for a reproducer. */
9882 error (_("Invalid DT_SYMTAB entry: %lx\n"),
9883 (long) section
.sh_offset
);
9887 if (archive_file_offset
!= 0)
9888 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9890 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9893 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9895 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9896 section
.sh_name
= filedata
->string_table_length
;
9898 if (dynamic_symbols
!= NULL
)
9900 error (_("Multiple dynamic symbol table sections found\n"));
9901 free (dynamic_symbols
);
9903 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9904 if (num_dynamic_syms
< 1)
9906 error (_("Unable to determine the number of symbols to load\n"));
9912 /* Similarly find a string table. */
9913 if (dynamic_strings
== NULL
)
9915 for (entry
= dynamic_section
;
9916 entry
< dynamic_section
+ dynamic_nent
;
9919 unsigned long offset
;
9922 if (entry
->d_tag
!= DT_STRTAB
)
9925 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9927 /* Since we do not know how big the string table is,
9928 we default to reading in the entire file (!) and
9929 processing that. This is overkill, I know, but it
9932 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9934 if (archive_file_offset
!= 0)
9935 str_tab_len
= archive_file_size
- offset
;
9937 str_tab_len
= filedata
->file_size
- offset
;
9939 if (str_tab_len
< 1)
9942 (_("Unable to determine the length of the dynamic string table\n"));
9946 if (dynamic_strings
!= NULL
)
9948 error (_("Multiple dynamic string tables found\n"));
9949 free (dynamic_strings
);
9952 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9954 _("dynamic string table"));
9955 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9959 /* And find the syminfo section if available. */
9960 if (dynamic_syminfo
== NULL
)
9962 unsigned long syminsz
= 0;
9964 for (entry
= dynamic_section
;
9965 entry
< dynamic_section
+ dynamic_nent
;
9968 if (entry
->d_tag
== DT_SYMINENT
)
9970 /* Note: these braces are necessary to avoid a syntax
9971 error from the SunOS4 C compiler. */
9972 /* PR binutils/17531: A corrupt file can trigger this test.
9973 So do not use an assert, instead generate an error message. */
9974 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9975 error (_("Bad value (%d) for SYMINENT entry\n"),
9976 (int) entry
->d_un
.d_val
);
9978 else if (entry
->d_tag
== DT_SYMINSZ
)
9979 syminsz
= entry
->d_un
.d_val
;
9980 else if (entry
->d_tag
== DT_SYMINFO
)
9981 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9985 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9987 Elf_External_Syminfo
* extsyminfo
;
9988 Elf_External_Syminfo
* extsym
;
9989 Elf_Internal_Syminfo
* syminfo
;
9991 /* There is a syminfo section. Read the data. */
9992 extsyminfo
= (Elf_External_Syminfo
*)
9993 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9994 _("symbol information"));
9998 if (dynamic_syminfo
!= NULL
)
10000 error (_("Multiple dynamic symbol information sections found\n"));
10001 free (dynamic_syminfo
);
10003 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10004 if (dynamic_syminfo
== NULL
)
10006 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10007 (unsigned long) syminsz
);
10011 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
10012 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
10013 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
10014 ++syminfo
, ++extsym
)
10016 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10017 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10024 if (do_dynamic
&& dynamic_addr
)
10025 printf (ngettext ("\nDynamic section at offset 0x%lx "
10026 "contains %lu entry:\n",
10027 "\nDynamic section at offset 0x%lx "
10028 "contains %lu entries:\n",
10030 dynamic_addr
, (unsigned long) dynamic_nent
);
10032 printf (_(" Tag Type Name/Value\n"));
10034 for (entry
= dynamic_section
;
10035 entry
< dynamic_section
+ dynamic_nent
;
10040 const char * dtype
;
10043 print_vma (entry
->d_tag
, FULL_HEX
);
10044 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10045 printf (" (%s)%*s", dtype
,
10046 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10049 switch (entry
->d_tag
)
10053 print_dynamic_flags (entry
->d_un
.d_val
);
10063 switch (entry
->d_tag
)
10066 printf (_("Auxiliary library"));
10070 printf (_("Filter library"));
10074 printf (_("Configuration file"));
10078 printf (_("Dependency audit library"));
10082 printf (_("Audit library"));
10086 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10087 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10091 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10100 printf (_("Flags:"));
10102 if (entry
->d_un
.d_val
== 0)
10103 printf (_(" None\n"));
10106 unsigned long int val
= entry
->d_un
.d_val
;
10108 if (val
& DTF_1_PARINIT
)
10110 printf (" PARINIT");
10111 val
^= DTF_1_PARINIT
;
10113 if (val
& DTF_1_CONFEXP
)
10115 printf (" CONFEXP");
10116 val
^= DTF_1_CONFEXP
;
10119 printf (" %lx", val
);
10128 printf (_("Flags:"));
10130 if (entry
->d_un
.d_val
== 0)
10131 printf (_(" None\n"));
10134 unsigned long int val
= entry
->d_un
.d_val
;
10136 if (val
& DF_P1_LAZYLOAD
)
10138 printf (" LAZYLOAD");
10139 val
^= DF_P1_LAZYLOAD
;
10141 if (val
& DF_P1_GROUPPERM
)
10143 printf (" GROUPPERM");
10144 val
^= DF_P1_GROUPPERM
;
10147 printf (" %lx", val
);
10156 printf (_("Flags:"));
10157 if (entry
->d_un
.d_val
== 0)
10158 printf (_(" None\n"));
10161 unsigned long int val
= entry
->d_un
.d_val
;
10163 if (val
& DF_1_NOW
)
10168 if (val
& DF_1_GLOBAL
)
10170 printf (" GLOBAL");
10171 val
^= DF_1_GLOBAL
;
10173 if (val
& DF_1_GROUP
)
10178 if (val
& DF_1_NODELETE
)
10180 printf (" NODELETE");
10181 val
^= DF_1_NODELETE
;
10183 if (val
& DF_1_LOADFLTR
)
10185 printf (" LOADFLTR");
10186 val
^= DF_1_LOADFLTR
;
10188 if (val
& DF_1_INITFIRST
)
10190 printf (" INITFIRST");
10191 val
^= DF_1_INITFIRST
;
10193 if (val
& DF_1_NOOPEN
)
10195 printf (" NOOPEN");
10196 val
^= DF_1_NOOPEN
;
10198 if (val
& DF_1_ORIGIN
)
10200 printf (" ORIGIN");
10201 val
^= DF_1_ORIGIN
;
10203 if (val
& DF_1_DIRECT
)
10205 printf (" DIRECT");
10206 val
^= DF_1_DIRECT
;
10208 if (val
& DF_1_TRANS
)
10213 if (val
& DF_1_INTERPOSE
)
10215 printf (" INTERPOSE");
10216 val
^= DF_1_INTERPOSE
;
10218 if (val
& DF_1_NODEFLIB
)
10220 printf (" NODEFLIB");
10221 val
^= DF_1_NODEFLIB
;
10223 if (val
& DF_1_NODUMP
)
10225 printf (" NODUMP");
10226 val
^= DF_1_NODUMP
;
10228 if (val
& DF_1_CONFALT
)
10230 printf (" CONFALT");
10231 val
^= DF_1_CONFALT
;
10233 if (val
& DF_1_ENDFILTEE
)
10235 printf (" ENDFILTEE");
10236 val
^= DF_1_ENDFILTEE
;
10238 if (val
& DF_1_DISPRELDNE
)
10240 printf (" DISPRELDNE");
10241 val
^= DF_1_DISPRELDNE
;
10243 if (val
& DF_1_DISPRELPND
)
10245 printf (" DISPRELPND");
10246 val
^= DF_1_DISPRELPND
;
10248 if (val
& DF_1_NODIRECT
)
10250 printf (" NODIRECT");
10251 val
^= DF_1_NODIRECT
;
10253 if (val
& DF_1_IGNMULDEF
)
10255 printf (" IGNMULDEF");
10256 val
^= DF_1_IGNMULDEF
;
10258 if (val
& DF_1_NOKSYMS
)
10260 printf (" NOKSYMS");
10261 val
^= DF_1_NOKSYMS
;
10263 if (val
& DF_1_NOHDR
)
10268 if (val
& DF_1_EDITED
)
10270 printf (" EDITED");
10271 val
^= DF_1_EDITED
;
10273 if (val
& DF_1_NORELOC
)
10275 printf (" NORELOC");
10276 val
^= DF_1_NORELOC
;
10278 if (val
& DF_1_SYMINTPOSE
)
10280 printf (" SYMINTPOSE");
10281 val
^= DF_1_SYMINTPOSE
;
10283 if (val
& DF_1_GLOBAUDIT
)
10285 printf (" GLOBAUDIT");
10286 val
^= DF_1_GLOBAUDIT
;
10288 if (val
& DF_1_SINGLETON
)
10290 printf (" SINGLETON");
10291 val
^= DF_1_SINGLETON
;
10293 if (val
& DF_1_STUB
)
10298 if (val
& DF_1_PIE
)
10303 if (val
& DF_1_KMOD
)
10308 if (val
& DF_1_WEAKFILTER
)
10310 printf (" WEAKFILTER");
10311 val
^= DF_1_WEAKFILTER
;
10313 if (val
& DF_1_NOCOMMON
)
10315 printf (" NOCOMMON");
10316 val
^= DF_1_NOCOMMON
;
10319 printf (" %lx", val
);
10326 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10328 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10348 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10354 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10355 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10361 switch (entry
->d_tag
)
10364 printf (_("Shared library: [%s]"), name
);
10366 if (streq (name
, program_interpreter
))
10367 printf (_(" program interpreter"));
10371 printf (_("Library soname: [%s]"), name
);
10375 printf (_("Library rpath: [%s]"), name
);
10379 printf (_("Library runpath: [%s]"), name
);
10383 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10388 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10401 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10402 /* Fall through. */
10406 case DT_INIT_ARRAYSZ
:
10407 case DT_FINI_ARRAYSZ
:
10408 case DT_GNU_CONFLICTSZ
:
10409 case DT_GNU_LIBLISTSZ
:
10412 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10413 printf (_(" (bytes)\n"));
10418 case DT_VERNEEDNUM
:
10423 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10432 case DT_INIT_ARRAY
:
10433 case DT_FINI_ARRAY
:
10436 if (entry
->d_tag
== DT_USED
10437 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10439 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10443 printf (_("Not needed object: [%s]\n"), name
);
10448 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10454 /* The value of this entry is ignored. */
10459 case DT_GNU_PRELINKED
:
10463 time_t atime
= entry
->d_un
.d_val
;
10465 tmp
= gmtime (&atime
);
10466 /* PR 17533 file: 041-1244816-0.004. */
10468 printf (_("<corrupt time val: %lx"),
10469 (unsigned long) atime
);
10471 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10472 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10473 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10479 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10482 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10488 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10489 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10494 switch (filedata
->file_header
.e_machine
)
10497 dynamic_section_aarch64_val (entry
);
10500 case EM_MIPS_RS3_LE
:
10501 dynamic_section_mips_val (entry
);
10504 dynamic_section_parisc_val (entry
);
10507 dynamic_section_ia64_val (entry
);
10510 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10522 get_ver_flags (unsigned int flags
)
10524 static char buff
[128];
10531 if (flags
& VER_FLG_BASE
)
10532 strcat (buff
, "BASE");
10534 if (flags
& VER_FLG_WEAK
)
10536 if (flags
& VER_FLG_BASE
)
10537 strcat (buff
, " | ");
10539 strcat (buff
, "WEAK");
10542 if (flags
& VER_FLG_INFO
)
10544 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10545 strcat (buff
, " | ");
10547 strcat (buff
, "INFO");
10550 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10552 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10553 strcat (buff
, " | ");
10555 strcat (buff
, _("<unknown>"));
10561 /* Display the contents of the version sections. */
10564 process_version_sections (Filedata
* filedata
)
10566 Elf_Internal_Shdr
* section
;
10568 bfd_boolean found
= FALSE
;
10573 for (i
= 0, section
= filedata
->section_headers
;
10574 i
< filedata
->file_header
.e_shnum
;
10577 switch (section
->sh_type
)
10579 case SHT_GNU_verdef
:
10581 Elf_External_Verdef
* edefs
;
10588 printf (ngettext ("\nVersion definition section '%s' "
10589 "contains %u entry:\n",
10590 "\nVersion definition section '%s' "
10591 "contains %u entries:\n",
10593 printable_section_name (filedata
, section
),
10596 printf (_(" Addr: 0x"));
10597 printf_vma (section
->sh_addr
);
10598 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10599 (unsigned long) section
->sh_offset
, section
->sh_link
,
10600 printable_section_name_from_index (filedata
, section
->sh_link
));
10602 edefs
= (Elf_External_Verdef
*)
10603 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10604 _("version definition section"));
10607 endbuf
= (char *) edefs
+ section
->sh_size
;
10609 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10612 Elf_External_Verdef
* edef
;
10613 Elf_Internal_Verdef ent
;
10614 Elf_External_Verdaux
* eaux
;
10615 Elf_Internal_Verdaux aux
;
10616 unsigned long isum
;
10619 vstart
= ((char *) edefs
) + idx
;
10620 if (vstart
+ sizeof (*edef
) > endbuf
)
10623 edef
= (Elf_External_Verdef
*) vstart
;
10625 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10626 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10627 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10628 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10629 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10630 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10631 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10633 printf (_(" %#06lx: Rev: %d Flags: %s"),
10634 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10636 printf (_(" Index: %d Cnt: %d "),
10637 ent
.vd_ndx
, ent
.vd_cnt
);
10639 /* Check for overflow. */
10640 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10643 vstart
+= ent
.vd_aux
;
10645 if (vstart
+ sizeof (*eaux
) > endbuf
)
10647 eaux
= (Elf_External_Verdaux
*) vstart
;
10649 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10650 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10652 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10653 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10655 printf (_("Name index: %ld\n"), aux
.vda_name
);
10657 isum
= idx
+ ent
.vd_aux
;
10659 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10661 if (aux
.vda_next
< sizeof (*eaux
)
10662 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10664 warn (_("Invalid vda_next field of %lx\n"),
10669 /* Check for overflow. */
10670 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10673 isum
+= aux
.vda_next
;
10674 vstart
+= aux
.vda_next
;
10676 if (vstart
+ sizeof (*eaux
) > endbuf
)
10678 eaux
= (Elf_External_Verdaux
*) vstart
;
10680 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10681 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10683 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10684 printf (_(" %#06lx: Parent %d: %s\n"),
10685 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10687 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10688 isum
, j
, aux
.vda_name
);
10691 if (j
< ent
.vd_cnt
)
10692 printf (_(" Version def aux past end of section\n"));
10695 file: id:000001,src:000172+005151,op:splice,rep:2. */
10696 if (ent
.vd_next
< sizeof (*edef
)
10697 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10699 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10700 cnt
= section
->sh_info
;
10703 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10706 idx
+= ent
.vd_next
;
10709 if (cnt
< section
->sh_info
)
10710 printf (_(" Version definition past end of section\n"));
10716 case SHT_GNU_verneed
:
10718 Elf_External_Verneed
* eneed
;
10725 printf (ngettext ("\nVersion needs section '%s' "
10726 "contains %u entry:\n",
10727 "\nVersion needs section '%s' "
10728 "contains %u entries:\n",
10730 printable_section_name (filedata
, section
), section
->sh_info
);
10732 printf (_(" Addr: 0x"));
10733 printf_vma (section
->sh_addr
);
10734 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10735 (unsigned long) section
->sh_offset
, section
->sh_link
,
10736 printable_section_name_from_index (filedata
, section
->sh_link
));
10738 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10739 section
->sh_offset
, 1,
10741 _("Version Needs section"));
10744 endbuf
= (char *) eneed
+ section
->sh_size
;
10746 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10748 Elf_External_Verneed
* entry
;
10749 Elf_Internal_Verneed ent
;
10750 unsigned long isum
;
10754 vstart
= ((char *) eneed
) + idx
;
10755 if (vstart
+ sizeof (*entry
) > endbuf
)
10758 entry
= (Elf_External_Verneed
*) vstart
;
10760 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10761 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10762 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10763 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10764 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10766 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10768 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10769 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10771 printf (_(" File: %lx"), ent
.vn_file
);
10773 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10775 /* Check for overflow. */
10776 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10778 vstart
+= ent
.vn_aux
;
10780 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10782 Elf_External_Vernaux
* eaux
;
10783 Elf_Internal_Vernaux aux
;
10785 if (vstart
+ sizeof (*eaux
) > endbuf
)
10787 eaux
= (Elf_External_Vernaux
*) vstart
;
10789 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10790 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10791 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10792 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10793 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10795 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10796 printf (_(" %#06lx: Name: %s"),
10797 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10799 printf (_(" %#06lx: Name index: %lx"),
10800 isum
, aux
.vna_name
);
10802 printf (_(" Flags: %s Version: %d\n"),
10803 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10805 if (aux
.vna_next
< sizeof (*eaux
)
10806 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10808 warn (_("Invalid vna_next field of %lx\n"),
10813 /* Check for overflow. */
10814 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10816 isum
+= aux
.vna_next
;
10817 vstart
+= aux
.vna_next
;
10820 if (j
< ent
.vn_cnt
)
10821 warn (_("Missing Version Needs auxillary information\n"));
10823 if (ent
.vn_next
< sizeof (*entry
)
10824 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10826 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10827 cnt
= section
->sh_info
;
10830 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10832 idx
+= ent
.vn_next
;
10835 if (cnt
< section
->sh_info
)
10836 warn (_("Missing Version Needs information\n"));
10842 case SHT_GNU_versym
:
10844 Elf_Internal_Shdr
* link_section
;
10847 unsigned char * edata
;
10848 unsigned short * data
;
10850 Elf_Internal_Sym
* symbols
;
10851 Elf_Internal_Shdr
* string_sec
;
10852 unsigned long num_syms
;
10855 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10858 link_section
= filedata
->section_headers
+ section
->sh_link
;
10859 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10861 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10866 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10867 if (symbols
== NULL
)
10870 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10872 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10873 string_sec
->sh_size
,
10874 _("version string table"));
10881 printf (ngettext ("\nVersion symbols section '%s' "
10882 "contains %lu entry:\n",
10883 "\nVersion symbols section '%s' "
10884 "contains %lu entries:\n",
10886 printable_section_name (filedata
, section
), (unsigned long) total
);
10888 printf (_(" Addr: 0x"));
10889 printf_vma (section
->sh_addr
);
10890 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10891 (unsigned long) section
->sh_offset
, section
->sh_link
,
10892 printable_section_name (filedata
, link_section
));
10894 off
= offset_from_vma (filedata
,
10895 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10896 total
* sizeof (short));
10897 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10899 _("version symbol data"));
10907 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10909 for (cnt
= total
; cnt
--;)
10910 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10915 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10919 char *invalid
= _("*invalid*");
10921 printf (" %03x:", cnt
);
10923 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10924 switch (data
[cnt
+ j
])
10927 fputs (_(" 0 (*local*) "), stdout
);
10931 fputs (_(" 1 (*global*) "), stdout
);
10935 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10936 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10938 /* If this index value is greater than the size of the symbols
10939 array, break to avoid an out-of-bounds read. */
10940 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10942 warn (_("invalid index into symbol array\n"));
10947 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10949 Elf_Internal_Verneed ivn
;
10950 unsigned long offset
;
10952 offset
= offset_from_vma
10953 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10954 sizeof (Elf_External_Verneed
));
10958 Elf_Internal_Vernaux ivna
;
10959 Elf_External_Verneed evn
;
10960 Elf_External_Vernaux evna
;
10961 unsigned long a_off
;
10963 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10964 _("version need")) == NULL
)
10967 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10968 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10970 a_off
= offset
+ ivn
.vn_aux
;
10974 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10975 1, _("version need aux (2)")) == NULL
)
10978 ivna
.vna_other
= 0;
10982 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10983 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10986 a_off
+= ivna
.vna_next
;
10988 while (ivna
.vna_other
!= data
[cnt
+ j
]
10989 && ivna
.vna_next
!= 0);
10991 if (ivna
.vna_other
== data
[cnt
+ j
])
10993 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10995 if (ivna
.vna_name
>= string_sec
->sh_size
)
10998 name
= strtab
+ ivna
.vna_name
;
11002 offset
+= ivn
.vn_next
;
11004 while (ivn
.vn_next
);
11007 if (data
[cnt
+ j
] != 0x8001
11008 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11010 Elf_Internal_Verdef ivd
;
11011 Elf_External_Verdef evd
;
11012 unsigned long offset
;
11014 offset
= offset_from_vma
11015 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11020 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11021 _("version def")) == NULL
)
11024 /* PR 17531: file: 046-1082287-0.004. */
11025 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11030 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11031 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11034 offset
+= ivd
.vd_next
;
11036 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11037 && ivd
.vd_next
!= 0);
11039 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11041 Elf_External_Verdaux evda
;
11042 Elf_Internal_Verdaux ivda
;
11044 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11046 if (get_data (&evda
, filedata
,
11047 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11049 _("version def aux")) == NULL
)
11052 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11054 if (ivda
.vda_name
>= string_sec
->sh_size
)
11056 else if (name
!= NULL
&& name
!= invalid
)
11057 name
= _("*both*");
11059 name
= strtab
+ ivda
.vda_name
;
11063 nn
+= printf ("(%s%-*s",
11065 12 - (int) strlen (name
),
11069 printf ("%*c", 18 - nn
, ' ');
11087 printf (_("\nNo version information found in this file.\n"));
11092 static const char *
11093 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11095 static char buff
[32];
11099 case STB_LOCAL
: return "LOCAL";
11100 case STB_GLOBAL
: return "GLOBAL";
11101 case STB_WEAK
: return "WEAK";
11103 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11104 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11106 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11108 if (binding
== STB_GNU_UNIQUE
11109 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11111 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11114 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11119 static const char *
11120 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11122 static char buff
[32];
11126 case STT_NOTYPE
: return "NOTYPE";
11127 case STT_OBJECT
: return "OBJECT";
11128 case STT_FUNC
: return "FUNC";
11129 case STT_SECTION
: return "SECTION";
11130 case STT_FILE
: return "FILE";
11131 case STT_COMMON
: return "COMMON";
11132 case STT_TLS
: return "TLS";
11133 case STT_RELC
: return "RELC";
11134 case STT_SRELC
: return "SRELC";
11136 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11138 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11139 return "THUMB_FUNC";
11141 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11144 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11145 return "PARISC_MILLI";
11147 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11149 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11151 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11153 if (type
== STT_HP_OPAQUE
)
11154 return "HP_OPAQUE";
11155 if (type
== STT_HP_STUB
)
11159 if (type
== STT_GNU_IFUNC
11160 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11161 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11164 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11167 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11172 static const char *
11173 get_symbol_visibility (unsigned int visibility
)
11175 switch (visibility
)
11177 case STV_DEFAULT
: return "DEFAULT";
11178 case STV_INTERNAL
: return "INTERNAL";
11179 case STV_HIDDEN
: return "HIDDEN";
11180 case STV_PROTECTED
: return "PROTECTED";
11182 error (_("Unrecognized visibility value: %u\n"), visibility
);
11183 return _("<unknown>");
11187 static const char *
11188 get_alpha_symbol_other (unsigned int other
)
11192 case STO_ALPHA_NOPV
: return "NOPV";
11193 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11195 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11196 return _("<unknown>");
11200 static const char *
11201 get_solaris_symbol_visibility (unsigned int visibility
)
11203 switch (visibility
)
11205 case 4: return "EXPORTED";
11206 case 5: return "SINGLETON";
11207 case 6: return "ELIMINATE";
11208 default: return get_symbol_visibility (visibility
);
11212 static const char *
11213 get_aarch64_symbol_other (unsigned int other
)
11215 static char buf
[32];
11217 if (other
& STO_AARCH64_VARIANT_PCS
)
11219 other
&= ~STO_AARCH64_VARIANT_PCS
;
11221 return "VARIANT_PCS";
11222 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11228 static const char *
11229 get_mips_symbol_other (unsigned int other
)
11233 case STO_OPTIONAL
: return "OPTIONAL";
11234 case STO_MIPS_PLT
: return "MIPS PLT";
11235 case STO_MIPS_PIC
: return "MIPS PIC";
11236 case STO_MICROMIPS
: return "MICROMIPS";
11237 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11238 case STO_MIPS16
: return "MIPS16";
11239 default: return NULL
;
11243 static const char *
11244 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11246 if (is_ia64_vms (filedata
))
11248 static char res
[32];
11252 /* Function types is for images and .STB files only. */
11253 switch (filedata
->file_header
.e_type
)
11257 switch (VMS_ST_FUNC_TYPE (other
))
11259 case VMS_SFT_CODE_ADDR
:
11260 strcat (res
, " CA");
11262 case VMS_SFT_SYMV_IDX
:
11263 strcat (res
, " VEC");
11266 strcat (res
, " FD");
11268 case VMS_SFT_RESERVE
:
11269 strcat (res
, " RSV");
11272 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11273 VMS_ST_FUNC_TYPE (other
));
11274 strcat (res
, " <unknown>");
11281 switch (VMS_ST_LINKAGE (other
))
11283 case VMS_STL_IGNORE
:
11284 strcat (res
, " IGN");
11286 case VMS_STL_RESERVE
:
11287 strcat (res
, " RSV");
11290 strcat (res
, " STD");
11293 strcat (res
, " LNK");
11296 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11297 VMS_ST_LINKAGE (other
));
11298 strcat (res
, " <unknown>");
11310 static const char *
11311 get_ppc64_symbol_other (unsigned int other
)
11313 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11316 other
>>= STO_PPC64_LOCAL_BIT
;
11319 static char buf
[32];
11321 other
= ppc64_decode_local_entry (other
);
11322 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11328 static const char *
11329 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11331 const char * result
= NULL
;
11332 static char buff
[32];
11337 switch (filedata
->file_header
.e_machine
)
11340 result
= get_alpha_symbol_other (other
);
11343 result
= get_aarch64_symbol_other (other
);
11346 result
= get_mips_symbol_other (other
);
11349 result
= get_ia64_symbol_other (filedata
, other
);
11352 result
= get_ppc64_symbol_other (other
);
11362 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11366 static const char *
11367 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11369 static char buff
[32];
11373 case SHN_UNDEF
: return "UND";
11374 case SHN_ABS
: return "ABS";
11375 case SHN_COMMON
: return "COM";
11377 if (type
== SHN_IA_64_ANSI_COMMON
11378 && filedata
->file_header
.e_machine
== EM_IA_64
11379 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11381 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11382 || filedata
->file_header
.e_machine
== EM_L1OM
11383 || filedata
->file_header
.e_machine
== EM_K1OM
)
11384 && type
== SHN_X86_64_LCOMMON
)
11385 return "LARGE_COM";
11386 else if ((type
== SHN_MIPS_SCOMMON
11387 && filedata
->file_header
.e_machine
== EM_MIPS
)
11388 || (type
== SHN_TIC6X_SCOMMON
11389 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11391 else if (type
== SHN_MIPS_SUNDEFINED
11392 && filedata
->file_header
.e_machine
== EM_MIPS
)
11394 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11395 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11396 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11397 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11398 else if (type
>= SHN_LORESERVE
)
11399 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11400 else if (type
>= filedata
->file_header
.e_shnum
)
11401 sprintf (buff
, _("bad section index[%3d]"), type
);
11403 sprintf (buff
, "%3d", type
);
11411 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11413 unsigned char * e_data
;
11416 /* If the size_t type is smaller than the bfd_size_type, eg because
11417 you are building a 32-bit tool on a 64-bit host, then make sure
11418 that when (number) is cast to (size_t) no information is lost. */
11419 if (sizeof (size_t) < sizeof (bfd_size_type
)
11420 && (bfd_size_type
) ((size_t) number
) != number
)
11422 error (_("Size truncation prevents reading %s elements of size %u\n"),
11423 bfd_vmatoa ("u", number
), ent_size
);
11427 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11428 attempting to allocate memory when the read is bound to fail. */
11429 if (ent_size
* number
> filedata
->file_size
)
11431 error (_("Invalid number of dynamic entries: %s\n"),
11432 bfd_vmatoa ("u", number
));
11436 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11437 if (e_data
== NULL
)
11439 error (_("Out of memory reading %s dynamic entries\n"),
11440 bfd_vmatoa ("u", number
));
11444 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11446 error (_("Unable to read in %s bytes of dynamic data\n"),
11447 bfd_vmatoa ("u", number
* ent_size
));
11452 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11453 if (i_data
== NULL
)
11455 error (_("Out of memory allocating space for %s dynamic entries\n"),
11456 bfd_vmatoa ("u", number
));
11462 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11470 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11472 Elf_Internal_Sym
* psym
;
11475 n
= print_vma (si
, DEC_5
);
11477 fputs (&" "[n
], stdout
);
11478 printf (" %3lu: ", hn
);
11480 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11482 printf (_("<No info available for dynamic symbol number %lu>\n"),
11483 (unsigned long) si
);
11487 psym
= dynamic_symbols
+ si
;
11488 print_vma (psym
->st_value
, LONG_HEX
);
11490 print_vma (psym
->st_size
, DEC_5
);
11492 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11493 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11495 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11496 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11499 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11501 printf (" %-7s", get_symbol_visibility (vis
));
11502 /* Check to see if any other bits in the st_other field are set.
11503 Note - displaying this information disrupts the layout of the
11504 table being generated, but for the moment this case is very
11506 if (psym
->st_other
^ vis
)
11507 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11510 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11511 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11512 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11514 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11518 static const char *
11519 get_symbol_version_string (Filedata
* filedata
,
11520 bfd_boolean is_dynsym
,
11521 const char * strtab
,
11522 unsigned long int strtab_size
,
11524 Elf_Internal_Sym
* psym
,
11525 enum versioned_symbol_info
* sym_info
,
11526 unsigned short * vna_other
)
11528 unsigned char data
[2];
11529 unsigned short vers_data
;
11530 unsigned long offset
;
11531 unsigned short max_vd_ndx
;
11534 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11537 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11538 sizeof data
+ si
* sizeof (vers_data
));
11540 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11541 sizeof (data
), 1, _("version data")) == NULL
)
11544 vers_data
= byte_get (data
, 2);
11546 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11549 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
11552 /* Usually we'd only see verdef for defined symbols, and verneed for
11553 undefined symbols. However, symbols defined by the linker in
11554 .dynbss for variables copied from a shared library in order to
11555 avoid text relocations are defined yet have verneed. We could
11556 use a heuristic to detect the special case, for example, check
11557 for verneed first on symbols defined in SHT_NOBITS sections, but
11558 it is simpler and more reliable to just look for both verdef and
11559 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11561 if (psym
->st_shndx
!= SHN_UNDEF
11562 && vers_data
!= 0x8001
11563 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11565 Elf_Internal_Verdef ivd
;
11566 Elf_Internal_Verdaux ivda
;
11567 Elf_External_Verdaux evda
;
11570 off
= offset_from_vma (filedata
,
11571 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11572 sizeof (Elf_External_Verdef
));
11576 Elf_External_Verdef evd
;
11578 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11579 _("version def")) == NULL
)
11588 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11589 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11590 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11591 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11594 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11595 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11597 off
+= ivd
.vd_next
;
11599 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11601 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11603 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11606 off
-= ivd
.vd_next
;
11609 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11610 _("version def aux")) != NULL
)
11612 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11614 if (psym
->st_name
!= ivda
.vda_name
)
11615 return (ivda
.vda_name
< strtab_size
11616 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11621 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11623 Elf_External_Verneed evn
;
11624 Elf_Internal_Verneed ivn
;
11625 Elf_Internal_Vernaux ivna
;
11627 offset
= offset_from_vma (filedata
,
11628 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11632 unsigned long vna_off
;
11634 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11635 _("version need")) == NULL
)
11638 ivna
.vna_other
= 0;
11643 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11644 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11646 vna_off
= offset
+ ivn
.vn_aux
;
11650 Elf_External_Vernaux evna
;
11652 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11653 _("version need aux (3)")) == NULL
)
11656 ivna
.vna_other
= 0;
11661 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11662 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11663 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11666 vna_off
+= ivna
.vna_next
;
11668 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11670 if (ivna
.vna_other
== vers_data
)
11673 offset
+= ivn
.vn_next
;
11675 while (ivn
.vn_next
!= 0);
11677 if (ivna
.vna_other
== vers_data
)
11679 *sym_info
= symbol_undefined
;
11680 *vna_other
= ivna
.vna_other
;
11681 return (ivna
.vna_name
< strtab_size
11682 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11684 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11685 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11686 return _("<corrupt>");
11691 /* Dump the symbol table. */
11693 process_symbol_table (Filedata
* filedata
)
11695 Elf_Internal_Shdr
* section
;
11696 bfd_size_type nbuckets
= 0;
11697 bfd_size_type nchains
= 0;
11698 bfd_vma
* buckets
= NULL
;
11699 bfd_vma
* chains
= NULL
;
11700 bfd_vma ngnubuckets
= 0;
11701 bfd_vma
* gnubuckets
= NULL
;
11702 bfd_vma
* gnuchains
= NULL
;
11703 bfd_vma
* mipsxlat
= NULL
;
11704 bfd_vma gnusymidx
= 0;
11705 bfd_size_type ngnuchains
= 0;
11707 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11710 if (dynamic_info
[DT_HASH
]
11712 || (do_using_dynamic
11714 && dynamic_strings
!= NULL
)))
11716 unsigned char nb
[8];
11717 unsigned char nc
[8];
11718 unsigned int hash_ent_size
= 4;
11720 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11721 || filedata
->file_header
.e_machine
== EM_S390
11722 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11723 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11726 if (fseek (filedata
->handle
,
11727 (archive_file_offset
11728 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11729 sizeof nb
+ sizeof nc
)),
11732 error (_("Unable to seek to start of dynamic information\n"));
11736 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11738 error (_("Failed to read in number of buckets\n"));
11742 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11744 error (_("Failed to read in number of chains\n"));
11748 nbuckets
= byte_get (nb
, hash_ent_size
);
11749 nchains
= byte_get (nc
, hash_ent_size
);
11751 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11752 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11755 if (buckets
== NULL
|| chains
== NULL
)
11757 if (do_using_dynamic
)
11768 if (dynamic_info_DT_GNU_HASH
11770 || (do_using_dynamic
11772 && dynamic_strings
!= NULL
)))
11774 unsigned char nb
[16];
11775 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11776 bfd_vma buckets_vma
;
11778 if (fseek (filedata
->handle
,
11779 (archive_file_offset
11780 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11784 error (_("Unable to seek to start of dynamic information\n"));
11788 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11790 error (_("Failed to read in number of buckets\n"));
11794 ngnubuckets
= byte_get (nb
, 4);
11795 gnusymidx
= byte_get (nb
+ 4, 4);
11796 bitmaskwords
= byte_get (nb
+ 8, 4);
11797 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11799 buckets_vma
+= bitmaskwords
* 4;
11801 buckets_vma
+= bitmaskwords
* 8;
11803 if (fseek (filedata
->handle
,
11804 (archive_file_offset
11805 + offset_from_vma (filedata
, buckets_vma
, 4)),
11808 error (_("Unable to seek to start of dynamic information\n"));
11812 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11814 if (gnubuckets
== NULL
)
11817 for (i
= 0; i
< ngnubuckets
; i
++)
11818 if (gnubuckets
[i
] != 0)
11820 if (gnubuckets
[i
] < gnusymidx
)
11823 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11824 maxchain
= gnubuckets
[i
];
11827 if (maxchain
== 0xffffffff)
11830 maxchain
-= gnusymidx
;
11832 if (fseek (filedata
->handle
,
11833 (archive_file_offset
11834 + offset_from_vma (filedata
, buckets_vma
11835 + 4 * (ngnubuckets
+ maxchain
), 4)),
11838 error (_("Unable to seek to start of dynamic information\n"));
11844 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11846 error (_("Failed to determine last chain length\n"));
11850 if (maxchain
+ 1 == 0)
11855 while ((byte_get (nb
, 4) & 1) == 0);
11857 if (fseek (filedata
->handle
,
11858 (archive_file_offset
11859 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11862 error (_("Unable to seek to start of dynamic information\n"));
11866 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11867 ngnuchains
= maxchain
;
11869 if (gnuchains
== NULL
)
11872 if (dynamic_info_DT_MIPS_XHASH
)
11874 if (fseek (filedata
->handle
,
11875 (archive_file_offset
11876 + offset_from_vma (filedata
, (buckets_vma
11881 error (_("Unable to seek to start of dynamic information\n"));
11885 mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
11889 if (dynamic_info_DT_MIPS_XHASH
&& mipsxlat
== NULL
)
11894 if (gnuchains
== NULL
)
11899 if (do_using_dynamic
)
11904 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11906 && do_using_dynamic
11907 && dynamic_strings
!= NULL
11908 && dynamic_symbols
!= NULL
)
11912 if (dynamic_info
[DT_HASH
])
11917 printf (_("\nSymbol table for image:\n"));
11919 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11921 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11923 visited
= xcmalloc (nchains
, 1);
11924 memset (visited
, 0, nchains
);
11925 for (hn
= 0; hn
< nbuckets
; hn
++)
11927 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11929 print_dynamic_symbol (filedata
, si
, hn
);
11930 if (si
>= nchains
|| visited
[si
])
11932 error (_("histogram chain is corrupt\n"));
11941 if (dynamic_info_DT_GNU_HASH
)
11943 printf (_("\nSymbol table of `%s' for image:\n"),
11944 GNU_HASH_SECTION_NAME
);
11946 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11948 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11950 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11951 if (gnubuckets
[hn
] != 0)
11953 bfd_vma si
= gnubuckets
[hn
];
11954 bfd_vma off
= si
- gnusymidx
;
11958 if (dynamic_info_DT_MIPS_XHASH
)
11959 print_dynamic_symbol (filedata
, mipsxlat
[off
], hn
);
11961 print_dynamic_symbol (filedata
, si
, hn
);
11964 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11968 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11969 && filedata
->section_headers
!= NULL
)
11973 for (i
= 0, section
= filedata
->section_headers
;
11974 i
< filedata
->file_header
.e_shnum
;
11978 char * strtab
= NULL
;
11979 unsigned long int strtab_size
= 0;
11980 Elf_Internal_Sym
* symtab
;
11981 Elf_Internal_Sym
* psym
;
11982 unsigned long num_syms
;
11984 if ((section
->sh_type
!= SHT_SYMTAB
11985 && section
->sh_type
!= SHT_DYNSYM
)
11987 && section
->sh_type
== SHT_SYMTAB
))
11990 if (section
->sh_entsize
== 0)
11992 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11993 printable_section_name (filedata
, section
));
11997 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11998 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11999 "\nSymbol table '%s' contains %lu entries:\n",
12001 printable_section_name (filedata
, section
),
12005 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12007 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12009 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12010 if (symtab
== NULL
)
12013 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12015 strtab
= filedata
->string_table
;
12016 strtab_size
= filedata
->string_table_length
;
12018 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12020 Elf_Internal_Shdr
* string_sec
;
12022 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12024 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12025 1, string_sec
->sh_size
,
12026 _("string table"));
12027 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12030 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
12032 const char *version_string
;
12033 enum versioned_symbol_info sym_info
;
12034 unsigned short vna_other
;
12036 printf ("%6d: ", si
);
12037 print_vma (psym
->st_value
, LONG_HEX
);
12039 print_vma (psym
->st_size
, DEC_5
);
12040 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12041 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12042 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12043 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12046 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12048 printf (" %-7s", get_symbol_visibility (vis
));
12049 /* Check to see if any other bits in the st_other field are set.
12050 Note - displaying this information disrupts the layout of the
12051 table being generated, but for the moment this case is very rare. */
12052 if (psym
->st_other
^ vis
)
12053 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12055 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12056 print_symbol (25, psym
->st_name
< strtab_size
12057 ? strtab
+ psym
->st_name
: _("<corrupt>"));
12060 = get_symbol_version_string (filedata
,
12061 section
->sh_type
== SHT_DYNSYM
,
12062 strtab
, strtab_size
, si
,
12063 psym
, &sym_info
, &vna_other
);
12064 if (version_string
)
12066 if (sym_info
== symbol_undefined
)
12067 printf ("@%s (%d)", version_string
, vna_other
);
12069 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12075 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12076 && si
>= section
->sh_info
12077 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12078 && filedata
->file_header
.e_machine
!= EM_MIPS
12079 /* Solaris binaries have been found to violate this requirement as
12080 well. Not sure if this is a bug or an ABI requirement. */
12081 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12082 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12083 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12087 if (strtab
!= filedata
->string_table
)
12093 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12095 if (do_histogram
&& buckets
!= NULL
)
12097 unsigned long * lengths
;
12098 unsigned long * counts
;
12101 unsigned long maxlength
= 0;
12102 unsigned long nzero_counts
= 0;
12103 unsigned long nsyms
= 0;
12106 printf (ngettext ("\nHistogram for bucket list length "
12107 "(total of %lu bucket):\n",
12108 "\nHistogram for bucket list length "
12109 "(total of %lu buckets):\n",
12110 (unsigned long) nbuckets
),
12111 (unsigned long) nbuckets
);
12113 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12114 if (lengths
== NULL
)
12116 error (_("Out of memory allocating space for histogram buckets\n"));
12119 visited
= xcmalloc (nchains
, 1);
12120 memset (visited
, 0, nchains
);
12122 printf (_(" Length Number %% of total Coverage\n"));
12123 for (hn
= 0; hn
< nbuckets
; ++hn
)
12125 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12128 if (maxlength
< ++lengths
[hn
])
12130 if (si
>= nchains
|| visited
[si
])
12132 error (_("histogram chain is corrupt\n"));
12140 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12141 if (counts
== NULL
)
12144 error (_("Out of memory allocating space for histogram counts\n"));
12148 for (hn
= 0; hn
< nbuckets
; ++hn
)
12149 ++counts
[lengths
[hn
]];
12154 printf (" 0 %-10lu (%5.1f%%)\n",
12155 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12156 for (i
= 1; i
<= maxlength
; ++i
)
12158 nzero_counts
+= counts
[i
] * i
;
12159 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12160 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12161 (nzero_counts
* 100.0) / nsyms
);
12169 if (buckets
!= NULL
)
12175 if (do_histogram
&& gnubuckets
!= NULL
)
12177 unsigned long * lengths
;
12178 unsigned long * counts
;
12180 unsigned long maxlength
= 0;
12181 unsigned long nzero_counts
= 0;
12182 unsigned long nsyms
= 0;
12184 printf (ngettext ("\nHistogram for `%s' bucket list length "
12185 "(total of %lu bucket):\n",
12186 "\nHistogram for `%s' bucket list length "
12187 "(total of %lu buckets):\n",
12188 (unsigned long) ngnubuckets
),
12189 GNU_HASH_SECTION_NAME
,
12190 (unsigned long) ngnubuckets
);
12192 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12193 if (lengths
== NULL
)
12195 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12199 printf (_(" Length Number %% of total Coverage\n"));
12201 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12202 if (gnubuckets
[hn
] != 0)
12204 bfd_vma off
, length
= 1;
12206 for (off
= gnubuckets
[hn
] - gnusymidx
;
12207 /* PR 17531 file: 010-77222-0.004. */
12208 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12211 lengths
[hn
] = length
;
12212 if (length
> maxlength
)
12213 maxlength
= length
;
12217 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12218 if (counts
== NULL
)
12221 error (_("Out of memory allocating space for gnu histogram counts\n"));
12225 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12226 ++counts
[lengths
[hn
]];
12228 if (ngnubuckets
> 0)
12231 printf (" 0 %-10lu (%5.1f%%)\n",
12232 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12233 for (j
= 1; j
<= maxlength
; ++j
)
12235 nzero_counts
+= counts
[j
] * j
;
12236 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12237 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12238 (nzero_counts
* 100.0) / nsyms
);
12253 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12257 if (dynamic_syminfo
== NULL
12259 /* No syminfo, this is ok. */
12262 /* There better should be a dynamic symbol section. */
12263 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12267 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12268 "contains %d entry:\n",
12269 "\nDynamic info segment at offset 0x%lx "
12270 "contains %d entries:\n",
12271 dynamic_syminfo_nent
),
12272 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12274 printf (_(" Num: Name BoundTo Flags\n"));
12275 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12277 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12279 printf ("%4d: ", i
);
12280 if (i
>= num_dynamic_syms
)
12281 printf (_("<corrupt index>"));
12282 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12283 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12285 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12288 switch (dynamic_syminfo
[i
].si_boundto
)
12290 case SYMINFO_BT_SELF
:
12291 fputs ("SELF ", stdout
);
12293 case SYMINFO_BT_PARENT
:
12294 fputs ("PARENT ", stdout
);
12297 if (dynamic_syminfo
[i
].si_boundto
> 0
12298 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12299 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12301 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12305 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12309 if (flags
& SYMINFO_FLG_DIRECT
)
12310 printf (" DIRECT");
12311 if (flags
& SYMINFO_FLG_PASSTHRU
)
12312 printf (" PASSTHRU");
12313 if (flags
& SYMINFO_FLG_COPY
)
12315 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12316 printf (" LAZYLOAD");
12324 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12325 is contained by the region START .. END. The types of ADDR, START
12326 and END should all be the same. Note both ADDR + NELEM and END
12327 point to just beyond the end of the regions that are being tested. */
12328 #define IN_RANGE(START,END,ADDR,NELEM) \
12329 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12331 /* Check to see if the given reloc needs to be handled in a target specific
12332 manner. If so then process the reloc and return TRUE otherwise return
12335 If called with reloc == NULL, then this is a signal that reloc processing
12336 for the current section has finished, and any saved state should be
12340 target_specific_reloc_handling (Filedata
* filedata
,
12341 Elf_Internal_Rela
* reloc
,
12342 unsigned char * start
,
12343 unsigned char * end
,
12344 Elf_Internal_Sym
* symtab
,
12345 unsigned long num_syms
)
12347 unsigned int reloc_type
= 0;
12348 unsigned long sym_index
= 0;
12352 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12353 sym_index
= get_reloc_symindex (reloc
->r_info
);
12356 switch (filedata
->file_header
.e_machine
)
12359 case EM_MSP430_OLD
:
12361 static Elf_Internal_Sym
* saved_sym
= NULL
;
12369 switch (reloc_type
)
12371 case 10: /* R_MSP430_SYM_DIFF */
12372 if (uses_msp430x_relocs (filedata
))
12374 /* Fall through. */
12375 case 21: /* R_MSP430X_SYM_DIFF */
12377 if (sym_index
>= num_syms
)
12378 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12381 saved_sym
= symtab
+ sym_index
;
12384 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12385 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12386 goto handle_sym_diff
;
12388 case 5: /* R_MSP430_16_BYTE */
12389 case 9: /* R_MSP430_8 */
12390 if (uses_msp430x_relocs (filedata
))
12392 goto handle_sym_diff
;
12394 case 2: /* R_MSP430_ABS16 */
12395 case 15: /* R_MSP430X_ABS16 */
12396 if (! uses_msp430x_relocs (filedata
))
12398 goto handle_sym_diff
;
12401 if (saved_sym
!= NULL
)
12403 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12406 if (sym_index
>= num_syms
)
12407 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12411 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12412 - saved_sym
->st_value
);
12414 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12415 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12418 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12419 (long) reloc
->r_offset
);
12428 if (saved_sym
!= NULL
)
12429 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12436 case EM_CYGNUS_MN10300
:
12438 static Elf_Internal_Sym
* saved_sym
= NULL
;
12446 switch (reloc_type
)
12448 case 34: /* R_MN10300_ALIGN */
12450 case 33: /* R_MN10300_SYM_DIFF */
12451 if (sym_index
>= num_syms
)
12452 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12455 saved_sym
= symtab
+ sym_index
;
12458 case 1: /* R_MN10300_32 */
12459 case 2: /* R_MN10300_16 */
12460 if (saved_sym
!= NULL
)
12462 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12465 if (sym_index
>= num_syms
)
12466 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12470 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12471 - saved_sym
->st_value
);
12473 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12474 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12476 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12477 (long) reloc
->r_offset
);
12485 if (saved_sym
!= NULL
)
12486 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12494 static bfd_vma saved_sym1
= 0;
12495 static bfd_vma saved_sym2
= 0;
12496 static bfd_vma value
;
12500 saved_sym1
= saved_sym2
= 0;
12504 switch (reloc_type
)
12506 case 0x80: /* R_RL78_SYM. */
12507 saved_sym1
= saved_sym2
;
12508 if (sym_index
>= num_syms
)
12509 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12513 saved_sym2
= symtab
[sym_index
].st_value
;
12514 saved_sym2
+= reloc
->r_addend
;
12518 case 0x83: /* R_RL78_OPsub. */
12519 value
= saved_sym1
- saved_sym2
;
12520 saved_sym2
= saved_sym1
= 0;
12524 case 0x41: /* R_RL78_ABS32. */
12525 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12526 byte_put (start
+ reloc
->r_offset
, value
, 4);
12528 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12529 (long) reloc
->r_offset
);
12533 case 0x43: /* R_RL78_ABS16. */
12534 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12535 byte_put (start
+ reloc
->r_offset
, value
, 2);
12537 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12538 (long) reloc
->r_offset
);
12552 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12553 DWARF debug sections. This is a target specific test. Note - we do not
12554 go through the whole including-target-headers-multiple-times route, (as
12555 we have already done with <elf/h8.h>) because this would become very
12556 messy and even then this function would have to contain target specific
12557 information (the names of the relocs instead of their numeric values).
12558 FIXME: This is not the correct way to solve this problem. The proper way
12559 is to have target specific reloc sizing and typing functions created by
12560 the reloc-macros.h header, in the same way that it already creates the
12561 reloc naming functions. */
12564 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12566 /* Please keep this table alpha-sorted for ease of visual lookup. */
12567 switch (filedata
->file_header
.e_machine
)
12571 return reloc_type
== 1; /* R_386_32. */
12573 return reloc_type
== 1; /* R_68K_32. */
12575 return reloc_type
== 1; /* R_860_32. */
12577 return reloc_type
== 2; /* R_960_32. */
12579 return (reloc_type
== 258
12580 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12582 return reloc_type
== 11; /* R_BPF_DATA_32 */
12583 case EM_ADAPTEVA_EPIPHANY
:
12584 return reloc_type
== 3;
12586 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12588 return reloc_type
== 1; /* R_ARC_32. */
12589 case EM_ARC_COMPACT
:
12590 case EM_ARC_COMPACT2
:
12591 return reloc_type
== 4; /* R_ARC_32. */
12593 return reloc_type
== 2; /* R_ARM_ABS32 */
12596 return reloc_type
== 1;
12598 return reloc_type
== 0x12; /* R_byte4_data. */
12600 return reloc_type
== 3; /* R_CRIS_32. */
12602 return reloc_type
== 3; /* R_CR16_NUM32. */
12604 return reloc_type
== 15; /* R_CRX_NUM32. */
12606 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12607 case EM_CYGNUS_FRV
:
12608 return reloc_type
== 1;
12609 case EM_CYGNUS_D10V
:
12611 return reloc_type
== 6; /* R_D10V_32. */
12612 case EM_CYGNUS_D30V
:
12614 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12616 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12617 case EM_CYGNUS_FR30
:
12619 return reloc_type
== 3; /* R_FR30_32. */
12621 return reloc_type
== 1; /* R_FT32_32. */
12625 return reloc_type
== 1; /* R_H8_DIR32. */
12627 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12628 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12629 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12630 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12633 return reloc_type
== 2; /* R_IP2K_32. */
12635 return reloc_type
== 2; /* R_IQ2000_32. */
12636 case EM_LATTICEMICO32
:
12637 return reloc_type
== 3; /* R_LM32_32. */
12640 return reloc_type
== 3; /* R_M32C_32. */
12642 return reloc_type
== 34; /* R_M32R_32_RELA. */
12645 return reloc_type
== 6; /* R_M68HC11_32. */
12647 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12648 reloc_type
== 6; /* R_S12Z_CW32. */
12650 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12651 case EM_CYGNUS_MEP
:
12652 return reloc_type
== 4; /* R_MEP_32. */
12654 return reloc_type
== 2; /* R_METAG_ADDR32. */
12655 case EM_MICROBLAZE
:
12656 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12658 return reloc_type
== 2; /* R_MIPS_32. */
12660 return reloc_type
== 4; /* R_MMIX_32. */
12661 case EM_CYGNUS_MN10200
:
12663 return reloc_type
== 1; /* R_MN10200_32. */
12664 case EM_CYGNUS_MN10300
:
12666 return reloc_type
== 1; /* R_MN10300_32. */
12668 return reloc_type
== 1; /* R_MOXIE_32. */
12669 case EM_MSP430_OLD
:
12671 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12673 return reloc_type
== 2; /* R_MT_32. */
12675 return reloc_type
== 20; /* R_NDS32_RELA. */
12676 case EM_ALTERA_NIOS2
:
12677 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12679 return reloc_type
== 1; /* R_NIOS_32. */
12681 return reloc_type
== 1; /* R_OR1K_32. */
12683 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12684 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12685 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12688 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12690 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12692 return reloc_type
== 1; /* R_PPC_ADDR32. */
12694 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12696 return reloc_type
== 1; /* R_RISCV_32. */
12698 return reloc_type
== 1; /* R_RL78_DIR32. */
12700 return reloc_type
== 1; /* R_RX_DIR32. */
12702 return reloc_type
== 1; /* R_I370_ADDR31. */
12705 return reloc_type
== 4; /* R_S390_32. */
12707 return reloc_type
== 8; /* R_SCORE_ABS32. */
12709 return reloc_type
== 1; /* R_SH_DIR32. */
12710 case EM_SPARC32PLUS
:
12713 return reloc_type
== 3 /* R_SPARC_32. */
12714 || reloc_type
== 23; /* R_SPARC_UA32. */
12716 return reloc_type
== 6; /* R_SPU_ADDR32 */
12718 return reloc_type
== 1; /* R_C6000_ABS32. */
12720 return reloc_type
== 2; /* R_TILEGX_32. */
12722 return reloc_type
== 1; /* R_TILEPRO_32. */
12723 case EM_CYGNUS_V850
:
12725 return reloc_type
== 6; /* R_V850_ABS32. */
12727 return reloc_type
== 0x33; /* R_V810_WORD. */
12729 return reloc_type
== 1; /* R_VAX_32. */
12731 return reloc_type
== 3; /* R_VISIUM_32. */
12732 case EM_WEBASSEMBLY
:
12733 return reloc_type
== 1; /* R_WASM32_32. */
12737 return reloc_type
== 10; /* R_X86_64_32. */
12740 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12742 return reloc_type
== 4; /* R_XGATE_32. */
12744 return reloc_type
== 1; /* R_XSTROMY16_32. */
12745 case EM_XTENSA_OLD
:
12747 return reloc_type
== 1; /* R_XTENSA_32. */
12749 return reloc_type
== 6; /* R_Z80_32. */
12752 static unsigned int prev_warn
= 0;
12754 /* Avoid repeating the same warning multiple times. */
12755 if (prev_warn
!= filedata
->file_header
.e_machine
)
12756 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12757 filedata
->file_header
.e_machine
);
12758 prev_warn
= filedata
->file_header
.e_machine
;
12764 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12765 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12768 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12770 switch (filedata
->file_header
.e_machine
)
12771 /* Please keep this table alpha-sorted for ease of visual lookup. */
12775 return reloc_type
== 2; /* R_386_PC32. */
12777 return reloc_type
== 4; /* R_68K_PC32. */
12779 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12780 case EM_ADAPTEVA_EPIPHANY
:
12781 return reloc_type
== 6;
12783 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12784 case EM_ARC_COMPACT
:
12785 case EM_ARC_COMPACT2
:
12786 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12788 return reloc_type
== 3; /* R_ARM_REL32 */
12791 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12792 case EM_MICROBLAZE
:
12793 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12795 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12797 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12799 return reloc_type
== 26; /* R_PPC_REL32. */
12801 return reloc_type
== 26; /* R_PPC64_REL32. */
12803 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12806 return reloc_type
== 5; /* R_390_PC32. */
12808 return reloc_type
== 2; /* R_SH_REL32. */
12809 case EM_SPARC32PLUS
:
12812 return reloc_type
== 6; /* R_SPARC_DISP32. */
12814 return reloc_type
== 13; /* R_SPU_REL32. */
12816 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12818 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12820 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12824 return reloc_type
== 2; /* R_X86_64_PC32. */
12826 return reloc_type
== 4; /* R_VAX_PCREL32. */
12827 case EM_XTENSA_OLD
:
12829 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12831 /* Do not abort or issue an error message here. Not all targets use
12832 pc-relative 32-bit relocs in their DWARF debug information and we
12833 have already tested for target coverage in is_32bit_abs_reloc. A
12834 more helpful warning message will be generated by apply_relocations
12835 anyway, so just return. */
12840 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12841 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12844 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12846 switch (filedata
->file_header
.e_machine
)
12849 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12851 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12853 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12854 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12856 return reloc_type
== 80; /* R_PARISC_DIR64. */
12858 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12860 return reloc_type
== 2; /* R_RISCV_64. */
12861 case EM_SPARC32PLUS
:
12864 return reloc_type
== 32 /* R_SPARC_64. */
12865 || reloc_type
== 54; /* R_SPARC_UA64. */
12869 return reloc_type
== 1; /* R_X86_64_64. */
12872 return reloc_type
== 22; /* R_S390_64. */
12874 return reloc_type
== 1; /* R_TILEGX_64. */
12876 return reloc_type
== 18; /* R_MIPS_64. */
12882 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12883 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12886 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12888 switch (filedata
->file_header
.e_machine
)
12891 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12893 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12895 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12896 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12898 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12900 return reloc_type
== 44; /* R_PPC64_REL64. */
12901 case EM_SPARC32PLUS
:
12904 return reloc_type
== 46; /* R_SPARC_DISP64. */
12908 return reloc_type
== 24; /* R_X86_64_PC64. */
12911 return reloc_type
== 23; /* R_S390_PC64. */
12913 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12919 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12920 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12923 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12925 switch (filedata
->file_header
.e_machine
)
12927 case EM_CYGNUS_MN10200
:
12929 return reloc_type
== 4; /* R_MN10200_24. */
12931 return reloc_type
== 5; /* R_FT32_20. */
12933 return reloc_type
== 5; /* R_Z80_24. */
12939 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12940 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12943 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12945 /* Please keep this table alpha-sorted for ease of visual lookup. */
12946 switch (filedata
->file_header
.e_machine
)
12949 case EM_ARC_COMPACT
:
12950 case EM_ARC_COMPACT2
:
12951 return reloc_type
== 2; /* R_ARC_16. */
12952 case EM_ADAPTEVA_EPIPHANY
:
12953 return reloc_type
== 5;
12956 return reloc_type
== 4; /* R_AVR_16. */
12957 case EM_CYGNUS_D10V
:
12959 return reloc_type
== 3; /* R_D10V_16. */
12961 return reloc_type
== 2; /* R_FT32_16. */
12965 return reloc_type
== R_H8_DIR16
;
12968 return reloc_type
== 1; /* R_IP2K_16. */
12971 return reloc_type
== 1; /* R_M32C_16 */
12972 case EM_CYGNUS_MN10200
:
12974 return reloc_type
== 2; /* R_MN10200_16. */
12975 case EM_CYGNUS_MN10300
:
12977 return reloc_type
== 2; /* R_MN10300_16. */
12979 if (uses_msp430x_relocs (filedata
))
12980 return reloc_type
== 2; /* R_MSP430_ABS16. */
12981 /* Fall through. */
12982 case EM_MSP430_OLD
:
12983 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12985 return reloc_type
== 19; /* R_NDS32_RELA. */
12986 case EM_ALTERA_NIOS2
:
12987 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12989 return reloc_type
== 9; /* R_NIOS_16. */
12991 return reloc_type
== 2; /* R_OR1K_16. */
12993 return reloc_type
== 55; /* R_RISCV_SET16. */
12995 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12997 return reloc_type
== 2; /* R_C6000_ABS16. */
12999 return reloc_type
== 2; /* R_VISIUM_16. */
13002 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13004 return reloc_type
== 3; /* R_XGATE_16. */
13006 return reloc_type
== 4; /* R_Z80_16. */
13012 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13013 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13016 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13018 switch (filedata
->file_header
.e_machine
)
13021 return reloc_type
== 54; /* R_RISCV_SET8. */
13023 return reloc_type
== 1; /* R_Z80_8. */
13029 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13030 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13033 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13035 switch (filedata
->file_header
.e_machine
)
13038 return reloc_type
== 53; /* R_RISCV_SET6. */
13044 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13045 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13048 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13050 /* Please keep this table alpha-sorted for ease of visual lookup. */
13051 switch (filedata
->file_header
.e_machine
)
13054 return reloc_type
== 35; /* R_RISCV_ADD32. */
13060 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13061 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13064 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13066 /* Please keep this table alpha-sorted for ease of visual lookup. */
13067 switch (filedata
->file_header
.e_machine
)
13070 return reloc_type
== 39; /* R_RISCV_SUB32. */
13076 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13077 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13080 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13082 /* Please keep this table alpha-sorted for ease of visual lookup. */
13083 switch (filedata
->file_header
.e_machine
)
13086 return reloc_type
== 36; /* R_RISCV_ADD64. */
13092 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13093 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13096 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13098 /* Please keep this table alpha-sorted for ease of visual lookup. */
13099 switch (filedata
->file_header
.e_machine
)
13102 return reloc_type
== 40; /* R_RISCV_SUB64. */
13108 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13109 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13112 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13114 /* Please keep this table alpha-sorted for ease of visual lookup. */
13115 switch (filedata
->file_header
.e_machine
)
13118 return reloc_type
== 34; /* R_RISCV_ADD16. */
13124 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13125 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13128 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13130 /* Please keep this table alpha-sorted for ease of visual lookup. */
13131 switch (filedata
->file_header
.e_machine
)
13134 return reloc_type
== 38; /* R_RISCV_SUB16. */
13140 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13141 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13144 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13146 /* Please keep this table alpha-sorted for ease of visual lookup. */
13147 switch (filedata
->file_header
.e_machine
)
13150 return reloc_type
== 33; /* R_RISCV_ADD8. */
13156 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13157 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13160 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13162 /* Please keep this table alpha-sorted for ease of visual lookup. */
13163 switch (filedata
->file_header
.e_machine
)
13166 return reloc_type
== 37; /* R_RISCV_SUB8. */
13172 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13173 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13176 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13178 switch (filedata
->file_header
.e_machine
)
13181 return reloc_type
== 52; /* R_RISCV_SUB6. */
13187 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13188 relocation entries (possibly formerly used for SHT_GROUP sections). */
13191 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13193 switch (filedata
->file_header
.e_machine
)
13195 case EM_386
: /* R_386_NONE. */
13196 case EM_68K
: /* R_68K_NONE. */
13197 case EM_ADAPTEVA_EPIPHANY
:
13198 case EM_ALPHA
: /* R_ALPHA_NONE. */
13199 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13200 case EM_ARC
: /* R_ARC_NONE. */
13201 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13202 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13203 case EM_ARM
: /* R_ARM_NONE. */
13204 case EM_C166
: /* R_XC16X_NONE. */
13205 case EM_CRIS
: /* R_CRIS_NONE. */
13206 case EM_FT32
: /* R_FT32_NONE. */
13207 case EM_IA_64
: /* R_IA64_NONE. */
13208 case EM_K1OM
: /* R_X86_64_NONE. */
13209 case EM_L1OM
: /* R_X86_64_NONE. */
13210 case EM_M32R
: /* R_M32R_NONE. */
13211 case EM_MIPS
: /* R_MIPS_NONE. */
13212 case EM_MN10300
: /* R_MN10300_NONE. */
13213 case EM_MOXIE
: /* R_MOXIE_NONE. */
13214 case EM_NIOS32
: /* R_NIOS_NONE. */
13215 case EM_OR1K
: /* R_OR1K_NONE. */
13216 case EM_PARISC
: /* R_PARISC_NONE. */
13217 case EM_PPC64
: /* R_PPC64_NONE. */
13218 case EM_PPC
: /* R_PPC_NONE. */
13219 case EM_RISCV
: /* R_RISCV_NONE. */
13220 case EM_S390
: /* R_390_NONE. */
13222 case EM_SH
: /* R_SH_NONE. */
13223 case EM_SPARC32PLUS
:
13224 case EM_SPARC
: /* R_SPARC_NONE. */
13226 case EM_TILEGX
: /* R_TILEGX_NONE. */
13227 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13228 case EM_TI_C6000
:/* R_C6000_NONE. */
13229 case EM_X86_64
: /* R_X86_64_NONE. */
13231 case EM_Z80
: /* R_Z80_NONE. */
13232 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13233 return reloc_type
== 0;
13236 return reloc_type
== 0 || reloc_type
== 256;
13239 return (reloc_type
== 0 /* R_AVR_NONE. */
13240 || reloc_type
== 30 /* R_AVR_DIFF8. */
13241 || reloc_type
== 31 /* R_AVR_DIFF16. */
13242 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13244 return reloc_type
== 3; /* R_METAG_NONE. */
13246 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13247 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13248 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13249 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13250 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13252 return (reloc_type
== 0 /* R_PRU_NONE. */
13253 || reloc_type
== 65 /* R_PRU_DIFF8. */
13254 || reloc_type
== 66 /* R_PRU_DIFF16. */
13255 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13256 case EM_XTENSA_OLD
:
13258 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13259 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13260 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13261 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13266 /* Returns TRUE if there is a relocation against
13267 section NAME at OFFSET bytes. */
13270 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13272 Elf_Internal_Rela
* relocs
;
13273 Elf_Internal_Rela
* rp
;
13275 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13278 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13280 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13281 if (rp
->r_offset
== offset
)
13287 /* Apply relocations to a section.
13288 Returns TRUE upon success, FALSE otherwise.
13289 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13290 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13291 will be set to the number of relocs loaded.
13293 Note: So far support has been added only for those relocations
13294 which can be found in debug sections. FIXME: Add support for
13295 more relocations ? */
13298 apply_relocations (Filedata
* filedata
,
13299 const Elf_Internal_Shdr
* section
,
13300 unsigned char * start
,
13301 bfd_size_type size
,
13302 void ** relocs_return
,
13303 unsigned long * num_relocs_return
)
13305 Elf_Internal_Shdr
* relsec
;
13306 unsigned char * end
= start
+ size
;
13308 if (relocs_return
!= NULL
)
13310 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13311 * num_relocs_return
= 0;
13314 if (filedata
->file_header
.e_type
!= ET_REL
)
13315 /* No relocs to apply. */
13318 /* Find the reloc section associated with the section. */
13319 for (relsec
= filedata
->section_headers
;
13320 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13323 bfd_boolean is_rela
;
13324 unsigned long num_relocs
;
13325 Elf_Internal_Rela
* relocs
;
13326 Elf_Internal_Rela
* rp
;
13327 Elf_Internal_Shdr
* symsec
;
13328 Elf_Internal_Sym
* symtab
;
13329 unsigned long num_syms
;
13330 Elf_Internal_Sym
* sym
;
13332 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13333 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13334 || filedata
->section_headers
+ relsec
->sh_info
!= section
13335 || relsec
->sh_size
== 0
13336 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13339 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13340 if (symsec
->sh_type
!= SHT_SYMTAB
13341 && symsec
->sh_type
!= SHT_DYNSYM
)
13344 is_rela
= relsec
->sh_type
== SHT_RELA
;
13348 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13349 relsec
->sh_size
, & relocs
, & num_relocs
))
13354 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13355 relsec
->sh_size
, & relocs
, & num_relocs
))
13359 /* SH uses RELA but uses in place value instead of the addend field. */
13360 if (filedata
->file_header
.e_machine
== EM_SH
)
13363 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13365 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13368 unsigned int reloc_type
;
13369 unsigned int reloc_size
;
13370 bfd_boolean reloc_inplace
= FALSE
;
13371 bfd_boolean reloc_subtract
= FALSE
;
13372 unsigned char * rloc
;
13373 unsigned long sym_index
;
13375 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13377 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13379 else if (is_none_reloc (filedata
, reloc_type
))
13381 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13382 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13384 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13385 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13387 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13389 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13391 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13392 || is_6bit_abs_reloc (filedata
, reloc_type
))
13394 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13396 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13399 reloc_inplace
= TRUE
;
13401 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13403 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13406 reloc_inplace
= TRUE
;
13408 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13410 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13413 reloc_inplace
= TRUE
;
13415 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13417 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13420 reloc_inplace
= TRUE
;
13422 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13426 reloc_inplace
= TRUE
;
13430 static unsigned int prev_reloc
= 0;
13432 if (reloc_type
!= prev_reloc
)
13433 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13434 reloc_type
, printable_section_name (filedata
, section
));
13435 prev_reloc
= reloc_type
;
13439 rloc
= start
+ rp
->r_offset
;
13440 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
13442 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13443 (unsigned long) rp
->r_offset
,
13444 printable_section_name (filedata
, section
));
13448 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13449 if (sym_index
>= num_syms
)
13451 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13452 sym_index
, printable_section_name (filedata
, section
));
13455 sym
= symtab
+ sym_index
;
13457 /* If the reloc has a symbol associated with it,
13458 make sure that it is of an appropriate type.
13460 Relocations against symbols without type can happen.
13461 Gcc -feliminate-dwarf2-dups may generate symbols
13462 without type for debug info.
13464 Icc generates relocations against function symbols
13465 instead of local labels.
13467 Relocations against object symbols can happen, eg when
13468 referencing a global array. For an example of this see
13469 the _clz.o binary in libgcc.a. */
13471 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13472 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13474 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13475 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13476 printable_section_name (filedata
, relsec
),
13477 (long int)(rp
- relocs
));
13483 addend
+= rp
->r_addend
;
13484 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13485 partial_inplace. */
13487 || (filedata
->file_header
.e_machine
== EM_XTENSA
13488 && reloc_type
== 1)
13489 || ((filedata
->file_header
.e_machine
== EM_PJ
13490 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13491 && reloc_type
== 1)
13492 || ((filedata
->file_header
.e_machine
== EM_D30V
13493 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13494 && reloc_type
== 12)
13497 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13498 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13500 addend
+= byte_get (rloc
, reloc_size
);
13503 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13504 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13506 /* On HPPA, all pc-relative relocations are biased by 8. */
13507 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13509 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13512 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13513 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13515 if (reloc_subtract
)
13516 addend
-= sym
->st_value
;
13518 addend
+= sym
->st_value
;
13519 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13520 byte_put (rloc
, addend
, reloc_size
);
13522 else if (reloc_subtract
)
13523 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13525 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13529 /* Let the target specific reloc processing code know that
13530 we have finished with these relocs. */
13531 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13535 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13536 * num_relocs_return
= num_relocs
;
13547 #ifdef SUPPORT_DISASSEMBLY
13549 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13551 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13553 /* FIXME: XXX -- to be done --- XXX */
13559 /* Reads in the contents of SECTION from FILE, returning a pointer
13560 to a malloc'ed buffer or NULL if something went wrong. */
13563 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13565 bfd_size_type num_bytes
= section
->sh_size
;
13567 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13569 printf (_("Section '%s' has no data to dump.\n"),
13570 printable_section_name (filedata
, section
));
13574 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13575 _("section contents"));
13578 /* Uncompresses a section that was compressed using zlib, in place. */
13581 uncompress_section_contents (unsigned char ** buffer
,
13582 dwarf_size_type uncompressed_size
,
13583 dwarf_size_type
* size
)
13585 dwarf_size_type compressed_size
= *size
;
13586 unsigned char * compressed_buffer
= *buffer
;
13587 unsigned char * uncompressed_buffer
;
13591 /* It is possible the section consists of several compressed
13592 buffers concatenated together, so we uncompress in a loop. */
13593 /* PR 18313: The state field in the z_stream structure is supposed
13594 to be invisible to the user (ie us), but some compilers will
13595 still complain about it being used without initialisation. So
13596 we first zero the entire z_stream structure and then set the fields
13598 memset (& strm
, 0, sizeof strm
);
13599 strm
.avail_in
= compressed_size
;
13600 strm
.next_in
= (Bytef
*) compressed_buffer
;
13601 strm
.avail_out
= uncompressed_size
;
13602 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13604 rc
= inflateInit (& strm
);
13605 while (strm
.avail_in
> 0)
13609 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13610 + (uncompressed_size
- strm
.avail_out
));
13611 rc
= inflate (&strm
, Z_FINISH
);
13612 if (rc
!= Z_STREAM_END
)
13614 rc
= inflateReset (& strm
);
13616 rc
= inflateEnd (& strm
);
13618 || strm
.avail_out
!= 0)
13621 *buffer
= uncompressed_buffer
;
13622 *size
= uncompressed_size
;
13626 free (uncompressed_buffer
);
13627 /* Indicate decompression failure. */
13633 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13635 Elf_Internal_Shdr
* relsec
;
13636 bfd_size_type num_bytes
;
13637 unsigned char * data
;
13638 unsigned char * end
;
13639 unsigned char * real_start
;
13640 unsigned char * start
;
13641 bfd_boolean some_strings_shown
;
13643 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13645 /* PR 21820: Do not fail if the section was empty. */
13646 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13648 num_bytes
= section
->sh_size
;
13650 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13652 if (decompress_dumps
)
13654 dwarf_size_type new_size
= num_bytes
;
13655 dwarf_size_type uncompressed_size
= 0;
13657 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13659 Elf_Internal_Chdr chdr
;
13660 unsigned int compression_header_size
13661 = get_compression_header (& chdr
, (unsigned char *) start
,
13664 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13666 warn (_("section '%s' has unsupported compress type: %d\n"),
13667 printable_section_name (filedata
, section
), chdr
.ch_type
);
13670 uncompressed_size
= chdr
.ch_size
;
13671 start
+= compression_header_size
;
13672 new_size
-= compression_header_size
;
13674 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13676 /* Read the zlib header. In this case, it should be "ZLIB"
13677 followed by the uncompressed section size, 8 bytes in
13678 big-endian order. */
13679 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13680 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13681 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13682 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13683 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13684 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13685 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13686 uncompressed_size
+= start
[11];
13691 if (uncompressed_size
)
13693 if (uncompress_section_contents (& start
,
13694 uncompressed_size
, & new_size
))
13695 num_bytes
= new_size
;
13698 error (_("Unable to decompress section %s\n"),
13699 printable_section_name (filedata
, section
));
13704 start
= real_start
;
13707 /* If the section being dumped has relocations against it the user might
13708 be expecting these relocations to have been applied. Check for this
13709 case and issue a warning message in order to avoid confusion.
13710 FIXME: Maybe we ought to have an option that dumps a section with
13711 relocs applied ? */
13712 for (relsec
= filedata
->section_headers
;
13713 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13716 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13717 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13718 || filedata
->section_headers
+ relsec
->sh_info
!= section
13719 || relsec
->sh_size
== 0
13720 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13723 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13728 end
= start
+ num_bytes
;
13729 some_strings_shown
= FALSE
;
13733 while (!ISPRINT (* data
))
13734 if (++ data
>= end
)
13739 size_t maxlen
= end
- data
;
13742 /* PR 11128: Use two separate invocations in order to work
13743 around bugs in the Solaris 8 implementation of printf. */
13744 printf (" [%6tx] ", data
- start
);
13746 printf (" [%6Ix] ", (size_t) (data
- start
));
13750 print_symbol ((int) maxlen
, (const char *) data
);
13752 data
+= strnlen ((const char *) data
, maxlen
);
13756 printf (_("<corrupt>\n"));
13759 some_strings_shown
= TRUE
;
13763 if (! some_strings_shown
)
13764 printf (_(" No strings found in this section."));
13773 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13774 Filedata
* filedata
,
13775 bfd_boolean relocate
)
13777 Elf_Internal_Shdr
* relsec
;
13778 bfd_size_type bytes
;
13779 bfd_size_type section_size
;
13781 unsigned char * data
;
13782 unsigned char * real_start
;
13783 unsigned char * start
;
13785 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13787 /* PR 21820: Do not fail if the section was empty. */
13788 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13790 section_size
= section
->sh_size
;
13792 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13794 if (decompress_dumps
)
13796 dwarf_size_type new_size
= section_size
;
13797 dwarf_size_type uncompressed_size
= 0;
13799 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13801 Elf_Internal_Chdr chdr
;
13802 unsigned int compression_header_size
13803 = get_compression_header (& chdr
, start
, section_size
);
13805 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13807 warn (_("section '%s' has unsupported compress type: %d\n"),
13808 printable_section_name (filedata
, section
), chdr
.ch_type
);
13811 uncompressed_size
= chdr
.ch_size
;
13812 start
+= compression_header_size
;
13813 new_size
-= compression_header_size
;
13815 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13817 /* Read the zlib header. In this case, it should be "ZLIB"
13818 followed by the uncompressed section size, 8 bytes in
13819 big-endian order. */
13820 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13821 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13822 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13823 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13824 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13825 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13826 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13827 uncompressed_size
+= start
[11];
13832 if (uncompressed_size
)
13834 if (uncompress_section_contents (& start
, uncompressed_size
,
13837 section_size
= new_size
;
13841 error (_("Unable to decompress section %s\n"),
13842 printable_section_name (filedata
, section
));
13843 /* FIXME: Print the section anyway ? */
13848 start
= real_start
;
13853 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13858 /* If the section being dumped has relocations against it the user might
13859 be expecting these relocations to have been applied. Check for this
13860 case and issue a warning message in order to avoid confusion.
13861 FIXME: Maybe we ought to have an option that dumps a section with
13862 relocs applied ? */
13863 for (relsec
= filedata
->section_headers
;
13864 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13867 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13868 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13869 || filedata
->section_headers
+ relsec
->sh_info
!= section
13870 || relsec
->sh_size
== 0
13871 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13874 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13879 addr
= section
->sh_addr
;
13880 bytes
= section_size
;
13889 lbytes
= (bytes
> 16 ? 16 : bytes
);
13891 printf (" 0x%8.8lx ", (unsigned long) addr
);
13893 for (j
= 0; j
< 16; j
++)
13896 printf ("%2.2x", data
[j
]);
13904 for (j
= 0; j
< lbytes
; j
++)
13907 if (k
>= ' ' && k
< 0x7f)
13926 static ctf_sect_t
*
13927 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
13929 buf
->cts_name
= SECTION_NAME (shdr
);
13930 buf
->cts_size
= shdr
->sh_size
;
13931 buf
->cts_entsize
= shdr
->sh_entsize
;
13936 /* Formatting callback function passed to ctf_dump. Returns either the pointer
13937 it is passed, or a pointer to newly-allocated storage, in which case
13938 dump_ctf() will free it when it no longer needs it. */
13940 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
13941 char *s
, void *arg
)
13943 const char *blanks
= arg
;
13946 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
13952 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13954 Elf_Internal_Shdr
* parent_sec
= NULL
;
13955 Elf_Internal_Shdr
* symtab_sec
= NULL
;
13956 Elf_Internal_Shdr
* strtab_sec
= NULL
;
13957 void * data
= NULL
;
13958 void * symdata
= NULL
;
13959 void * strdata
= NULL
;
13960 void * parentdata
= NULL
;
13961 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
13962 ctf_sect_t
* symsectp
= NULL
;
13963 ctf_sect_t
* strsectp
= NULL
;
13964 ctf_file_t
* ctf
= NULL
;
13965 ctf_file_t
* parent
= NULL
;
13967 const char *things
[] = {"Header", "Labels", "Data objects",
13968 "Function objects", "Variables", "Types", "Strings",
13970 const char **thing
;
13972 bfd_boolean ret
= FALSE
;
13975 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
13976 data
= get_section_contents (section
, filedata
);
13977 ctfsect
.cts_data
= data
;
13979 if (!dump_ctf_symtab_name
)
13980 dump_ctf_symtab_name
= strdup (".symtab");
13982 if (!dump_ctf_strtab_name
)
13983 dump_ctf_strtab_name
= strdup (".strtab");
13985 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
13987 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
13989 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
13992 if ((symdata
= (void *) get_data (NULL
, filedata
,
13993 symtab_sec
->sh_offset
, 1,
13994 symtab_sec
->sh_size
,
13995 _("symbols"))) == NULL
)
13997 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
13998 symsect
.cts_data
= symdata
;
14000 if (dump_ctf_strtab_name
&& dump_ctf_symtab_name
[0] != 0)
14002 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14004 error (_("No string table section named %s\n"),
14005 dump_ctf_strtab_name
);
14008 if ((strdata
= (void *) get_data (NULL
, filedata
,
14009 strtab_sec
->sh_offset
, 1,
14010 strtab_sec
->sh_size
,
14011 _("strings"))) == NULL
)
14013 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14014 strsect
.cts_data
= strdata
;
14016 if (dump_ctf_parent_name
)
14018 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14020 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14023 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14024 parent_sec
->sh_offset
, 1,
14025 parent_sec
->sh_size
,
14026 _("CTF parent"))) == NULL
)
14028 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14029 parentsect
.cts_data
= parentdata
;
14032 /* Load the CTF file and dump it. */
14034 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14036 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14042 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
14044 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14048 ctf_import (ctf
, parent
);
14053 printf (_("\nDump of CTF section '%s':\n"),
14054 printable_section_name (filedata
, section
));
14056 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14058 ctf_dump_state_t
*s
= NULL
;
14061 printf ("\n %s:\n", *thing
);
14062 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14063 (void *) " ")) != NULL
)
14065 printf ("%s\n", item
);
14069 if (ctf_errno (ctf
))
14071 error (_("Iteration failed: %s, %s\n"), *thing
,
14072 ctf_errmsg (ctf_errno (ctf
)));
14078 ctf_file_close (ctf
);
14079 ctf_file_close (parent
);
14088 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14089 const Elf_Internal_Shdr
* sec
,
14092 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14094 Filedata
* filedata
= (Filedata
*) data
;
14096 if (section
->start
!= NULL
)
14098 /* If it is already loaded, do nothing. */
14099 if (streq (section
->filename
, filedata
->file_name
))
14101 free (section
->start
);
14104 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14105 section
->address
= sec
->sh_addr
;
14106 section
->user_data
= NULL
;
14107 section
->filename
= filedata
->file_name
;
14108 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14110 sec
->sh_size
, buf
);
14111 if (section
->start
== NULL
)
14115 unsigned char *start
= section
->start
;
14116 dwarf_size_type size
= sec
->sh_size
;
14117 dwarf_size_type uncompressed_size
= 0;
14119 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14121 Elf_Internal_Chdr chdr
;
14122 unsigned int compression_header_size
;
14124 if (size
< (is_32bit_elf
14125 ? sizeof (Elf32_External_Chdr
)
14126 : sizeof (Elf64_External_Chdr
)))
14128 warn (_("compressed section %s is too small to contain a compression header\n"),
14133 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14135 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14137 warn (_("section '%s' has unsupported compress type: %d\n"),
14138 section
->name
, chdr
.ch_type
);
14141 uncompressed_size
= chdr
.ch_size
;
14142 start
+= compression_header_size
;
14143 size
-= compression_header_size
;
14145 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14147 /* Read the zlib header. In this case, it should be "ZLIB"
14148 followed by the uncompressed section size, 8 bytes in
14149 big-endian order. */
14150 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14151 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14152 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14153 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14154 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14155 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14156 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14157 uncompressed_size
+= start
[11];
14162 if (uncompressed_size
)
14164 if (uncompress_section_contents (&start
, uncompressed_size
,
14167 /* Free the compressed buffer, update the section buffer
14168 and the section size if uncompress is successful. */
14169 free (section
->start
);
14170 section
->start
= start
;
14174 error (_("Unable to decompress section %s\n"),
14175 printable_section_name (filedata
, sec
));
14180 section
->size
= size
;
14183 if (section
->start
== NULL
)
14186 if (debug_displays
[debug
].relocate
)
14188 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14189 & section
->reloc_info
, & section
->num_relocs
))
14194 section
->reloc_info
= NULL
;
14195 section
->num_relocs
= 0;
14201 #if HAVE_LIBDEBUGINFOD
14202 /* Return a hex string representation of the build-id. */
14204 get_build_id (void * data
)
14206 Filedata
* filedata
= (Filedata
*)data
;
14207 Elf_Internal_Shdr
* shdr
;
14210 /* Iterate through notes to find note.gnu.build-id.
14211 FIXME: Only the first note in any note section is examined. */
14212 for (i
= 0, shdr
= filedata
->section_headers
;
14213 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14216 if (shdr
->sh_type
!= SHT_NOTE
)
14221 size_t data_remaining
;
14223 Elf_External_Note
* enote
;
14224 Elf_Internal_Note inote
;
14226 bfd_vma offset
= shdr
->sh_offset
;
14227 bfd_vma align
= shdr
->sh_addralign
;
14228 bfd_vma length
= shdr
->sh_size
;
14230 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14236 else if (align
!= 4 && align
!= 8)
14239 end
= (char *) enote
+ length
;
14240 data_remaining
= end
- (char *) enote
;
14242 if (!is_ia64_vms (filedata
))
14244 min_notesz
= offsetof (Elf_External_Note
, name
);
14245 if (data_remaining
< min_notesz
)
14248 malformed note encountered in section %s whilst scanning for build-id note\n"),
14249 printable_section_name (filedata
, shdr
));
14252 data_remaining
-= min_notesz
;
14254 inote
.type
= BYTE_GET (enote
->type
);
14255 inote
.namesz
= BYTE_GET (enote
->namesz
);
14256 inote
.namedata
= enote
->name
;
14257 inote
.descsz
= BYTE_GET (enote
->descsz
);
14258 inote
.descdata
= ((char *) enote
14259 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
14260 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14261 next
= ((char *) enote
14262 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
14266 Elf64_External_VMS_Note
*vms_enote
;
14268 /* PR binutils/15191
14269 Make sure that there is enough data to read. */
14270 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
14271 if (data_remaining
< min_notesz
)
14274 malformed note encountered in section %s whilst scanning for build-id note\n"),
14275 printable_section_name (filedata
, shdr
));
14278 data_remaining
-= min_notesz
;
14280 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
14281 inote
.type
= BYTE_GET (vms_enote
->type
);
14282 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
14283 inote
.namedata
= vms_enote
->name
;
14284 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
14285 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
14286 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
14287 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
14290 /* Skip malformed notes. */
14291 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
14292 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
14293 || (size_t) (next
- inote
.descdata
) < inote
.descsz
14294 || ((size_t) (next
- inote
.descdata
)
14295 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
14298 malformed note encountered in section %s whilst scanning for build-id note\n"),
14299 printable_section_name (filedata
, shdr
));
14303 /* Check if this is the build-id note. If so then convert the build-id
14304 bytes to a hex string. */
14305 if (inote
.namesz
> 0
14306 && const_strneq (inote
.namedata
, "GNU")
14307 && inote
.type
== NT_GNU_BUILD_ID
)
14312 build_id
= malloc (inote
.descsz
* 2 + 1);
14313 if (build_id
== NULL
)
14316 for (j
= 0; j
< inote
.descsz
; ++j
)
14317 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
14318 build_id
[inote
.descsz
* 2] = '\0';
14320 return (unsigned char *) build_id
;
14326 #endif /* HAVE_LIBDEBUGINFOD */
14328 /* If this is not NULL, load_debug_section will only look for sections
14329 within the list of sections given here. */
14330 static unsigned int * section_subset
= NULL
;
14333 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14335 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14336 Elf_Internal_Shdr
* sec
;
14337 Filedata
* filedata
= (Filedata
*) data
;
14339 /* Without section headers we cannot find any sections. */
14340 if (filedata
->section_headers
== NULL
)
14343 if (filedata
->string_table
== NULL
14344 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14345 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14347 Elf_Internal_Shdr
* strs
;
14349 /* Read in the string table, so that we have section names to scan. */
14350 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14352 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14354 filedata
->string_table
14355 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14356 1, strs
->sh_size
, _("string table"));
14358 filedata
->string_table_length
14359 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14363 /* Locate the debug section. */
14364 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14366 section
->name
= section
->uncompressed_name
;
14369 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14371 section
->name
= section
->compressed_name
;
14376 /* If we're loading from a subset of sections, and we've loaded
14377 a section matching this name before, it's likely that it's a
14379 if (section_subset
!= NULL
)
14380 free_debug_section (debug
);
14382 return load_specific_debug_section (debug
, sec
, data
);
14386 free_debug_section (enum dwarf_section_display_enum debug
)
14388 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14390 if (section
->start
== NULL
)
14393 free ((char *) section
->start
);
14394 section
->start
= NULL
;
14395 section
->address
= 0;
14398 if (section
->reloc_info
!= NULL
)
14400 free (section
->reloc_info
);
14401 section
->reloc_info
= NULL
;
14402 section
->num_relocs
= 0;
14407 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14409 char * name
= SECTION_NAME (section
);
14410 const char * print_name
= printable_section_name (filedata
, section
);
14411 bfd_size_type length
;
14412 bfd_boolean result
= TRUE
;
14415 length
= section
->sh_size
;
14418 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14421 if (section
->sh_type
== SHT_NOBITS
)
14423 /* There is no point in dumping the contents of a debugging section
14424 which has the NOBITS type - the bits in the file will be random.
14425 This can happen when a file containing a .eh_frame section is
14426 stripped with the --only-keep-debug command line option. */
14427 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14432 if (const_strneq (name
, ".gnu.linkonce.wi."))
14433 name
= ".debug_info";
14435 /* See if we know how to display the contents of this section. */
14436 for (i
= 0; i
< max
; i
++)
14438 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14439 struct dwarf_section_display
* display
= debug_displays
+ i
;
14440 struct dwarf_section
* sec
= & display
->section
;
14442 if (streq (sec
->uncompressed_name
, name
)
14443 || (id
== line
&& const_strneq (name
, ".debug_line."))
14444 || streq (sec
->compressed_name
, name
))
14446 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14449 free_debug_section (id
);
14451 if (i
== line
&& const_strneq (name
, ".debug_line."))
14453 else if (streq (sec
->uncompressed_name
, name
))
14454 sec
->name
= sec
->uncompressed_name
;
14456 sec
->name
= sec
->compressed_name
;
14458 if (load_specific_debug_section (id
, section
, filedata
))
14460 /* If this debug section is part of a CU/TU set in a .dwp file,
14461 restrict load_debug_section to the sections in that set. */
14462 section_subset
= find_cu_tu_set (filedata
, shndx
);
14464 result
&= display
->display (sec
, filedata
);
14466 section_subset
= NULL
;
14468 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14469 free_debug_section (id
);
14477 printf (_("Unrecognized debug section: %s\n"), print_name
);
14484 /* Set DUMP_SECTS for all sections where dumps were requested
14485 based on section name. */
14488 initialise_dumps_byname (Filedata
* filedata
)
14490 struct dump_list_entry
* cur
;
14492 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14495 bfd_boolean any
= FALSE
;
14497 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14498 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14500 request_dump_bynumber (filedata
, i
, cur
->type
);
14505 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14511 process_section_contents (Filedata
* filedata
)
14513 Elf_Internal_Shdr
* section
;
14515 bfd_boolean res
= TRUE
;
14520 initialise_dumps_byname (filedata
);
14522 for (i
= 0, section
= filedata
->section_headers
;
14523 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14526 dump_type dump
= filedata
->dump_sects
[i
];
14528 #ifdef SUPPORT_DISASSEMBLY
14529 if (dump
& DISASS_DUMP
)
14531 if (! disassemble_section (section
, filedata
))
14535 if (dump
& HEX_DUMP
)
14537 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14541 if (dump
& RELOC_DUMP
)
14543 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14547 if (dump
& STRING_DUMP
)
14549 if (! dump_section_as_strings (section
, filedata
))
14553 if (dump
& DEBUG_DUMP
)
14555 if (! display_debug_section (i
, section
, filedata
))
14559 if (dump
& CTF_DUMP
)
14561 if (! dump_section_as_ctf (section
, filedata
))
14566 /* Check to see if the user requested a
14567 dump of a section that does not exist. */
14568 while (i
< filedata
->num_dump_sects
)
14570 if (filedata
->dump_sects
[i
])
14572 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14582 process_mips_fpe_exception (int mask
)
14586 bfd_boolean first
= TRUE
;
14588 if (mask
& OEX_FPU_INEX
)
14589 fputs ("INEX", stdout
), first
= FALSE
;
14590 if (mask
& OEX_FPU_UFLO
)
14591 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14592 if (mask
& OEX_FPU_OFLO
)
14593 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14594 if (mask
& OEX_FPU_DIV0
)
14595 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14596 if (mask
& OEX_FPU_INVAL
)
14597 printf ("%sINVAL", first
? "" : "|");
14600 fputs ("0", stdout
);
14603 /* Display's the value of TAG at location P. If TAG is
14604 greater than 0 it is assumed to be an unknown tag, and
14605 a message is printed to this effect. Otherwise it is
14606 assumed that a message has already been printed.
14608 If the bottom bit of TAG is set it assumed to have a
14609 string value, otherwise it is assumed to have an integer
14612 Returns an updated P pointing to the first unread byte
14613 beyond the end of TAG's value.
14615 Reads at or beyond END will not be made. */
14617 static unsigned char *
14618 display_tag_value (signed int tag
,
14620 const unsigned char * const end
)
14625 printf (" Tag_unknown_%d: ", tag
);
14629 warn (_("<corrupt tag>\n"));
14633 /* PR 17531 file: 027-19978-0.004. */
14634 size_t maxlen
= (end
- p
) - 1;
14639 print_symbol ((int) maxlen
, (const char *) p
);
14640 p
+= strnlen ((char *) p
, maxlen
) + 1;
14644 printf (_("<corrupt string tag>"));
14645 p
= (unsigned char *) end
;
14651 READ_ULEB (val
, p
, end
);
14652 printf ("%ld (0x%lx)\n", val
, val
);
14659 /* ARC ABI attributes section. */
14661 static unsigned char *
14662 display_arc_attribute (unsigned char * p
,
14663 const unsigned char * const end
)
14668 READ_ULEB (tag
, p
, end
);
14672 case Tag_ARC_PCS_config
:
14673 READ_ULEB (val
, p
, end
);
14674 printf (" Tag_ARC_PCS_config: ");
14678 printf (_("Absent/Non standard\n"));
14681 printf (_("Bare metal/mwdt\n"));
14684 printf (_("Bare metal/newlib\n"));
14687 printf (_("Linux/uclibc\n"));
14690 printf (_("Linux/glibc\n"));
14693 printf (_("Unknown\n"));
14698 case Tag_ARC_CPU_base
:
14699 READ_ULEB (val
, p
, end
);
14700 printf (" Tag_ARC_CPU_base: ");
14705 printf (_("Absent\n"));
14707 case TAG_CPU_ARC6xx
:
14708 printf ("ARC6xx\n");
14710 case TAG_CPU_ARC7xx
:
14711 printf ("ARC7xx\n");
14713 case TAG_CPU_ARCEM
:
14714 printf ("ARCEM\n");
14716 case TAG_CPU_ARCHS
:
14717 printf ("ARCHS\n");
14722 case Tag_ARC_CPU_variation
:
14723 READ_ULEB (val
, p
, end
);
14724 printf (" Tag_ARC_CPU_variation: ");
14728 if (val
> 0 && val
< 16)
14729 printf ("Core%d\n", val
);
14731 printf ("Unknown\n");
14735 printf (_("Absent\n"));
14740 case Tag_ARC_CPU_name
:
14741 printf (" Tag_ARC_CPU_name: ");
14742 p
= display_tag_value (-1, p
, end
);
14745 case Tag_ARC_ABI_rf16
:
14746 READ_ULEB (val
, p
, end
);
14747 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14750 case Tag_ARC_ABI_osver
:
14751 READ_ULEB (val
, p
, end
);
14752 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14755 case Tag_ARC_ABI_pic
:
14756 case Tag_ARC_ABI_sda
:
14757 READ_ULEB (val
, p
, end
);
14758 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14759 : " Tag_ARC_ABI_pic: ");
14763 printf (_("Absent\n"));
14772 printf (_("Unknown\n"));
14777 case Tag_ARC_ABI_tls
:
14778 READ_ULEB (val
, p
, end
);
14779 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14782 case Tag_ARC_ABI_enumsize
:
14783 READ_ULEB (val
, p
, end
);
14784 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14788 case Tag_ARC_ABI_exceptions
:
14789 READ_ULEB (val
, p
, end
);
14790 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14794 case Tag_ARC_ABI_double_size
:
14795 READ_ULEB (val
, p
, end
);
14796 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14799 case Tag_ARC_ISA_config
:
14800 printf (" Tag_ARC_ISA_config: ");
14801 p
= display_tag_value (-1, p
, end
);
14804 case Tag_ARC_ISA_apex
:
14805 printf (" Tag_ARC_ISA_apex: ");
14806 p
= display_tag_value (-1, p
, end
);
14809 case Tag_ARC_ISA_mpy_option
:
14810 READ_ULEB (val
, p
, end
);
14811 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14814 case Tag_ARC_ATR_version
:
14815 READ_ULEB (val
, p
, end
);
14816 printf (" Tag_ARC_ATR_version: %d\n", val
);
14820 return display_tag_value (tag
& 1, p
, end
);
14826 /* ARM EABI attributes section. */
14831 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14833 const char ** table
;
14834 } arm_attr_public_tag
;
14836 static const char * arm_attr_tag_CPU_arch
[] =
14837 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14838 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14839 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14840 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14841 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14842 {"No", "Thumb-1", "Thumb-2", "Yes"};
14843 static const char * arm_attr_tag_FP_arch
[] =
14844 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14845 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14846 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14847 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14848 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14849 "NEON for ARMv8.1"};
14850 static const char * arm_attr_tag_PCS_config
[] =
14851 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14852 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14853 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14854 {"V6", "SB", "TLS", "Unused"};
14855 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14856 {"Absolute", "PC-relative", "SB-relative", "None"};
14857 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14858 {"Absolute", "PC-relative", "None"};
14859 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14860 {"None", "direct", "GOT-indirect"};
14861 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14862 {"None", "??? 1", "2", "??? 3", "4"};
14863 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14864 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14865 {"Unused", "Needed", "Sign only"};
14866 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14867 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14868 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14869 {"Unused", "Finite", "RTABI", "IEEE 754"};
14870 static const char * arm_attr_tag_ABI_enum_size
[] =
14871 {"Unused", "small", "int", "forced to int"};
14872 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14873 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14874 static const char * arm_attr_tag_ABI_VFP_args
[] =
14875 {"AAPCS", "VFP registers", "custom", "compatible"};
14876 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14877 {"AAPCS", "WMMX registers", "custom"};
14878 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14879 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14880 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14881 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14882 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14883 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14884 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14885 static const char * arm_attr_tag_FP_HP_extension
[] =
14886 {"Not Allowed", "Allowed"};
14887 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14888 {"None", "IEEE 754", "Alternative Format"};
14889 static const char * arm_attr_tag_DSP_extension
[] =
14890 {"Follow architecture", "Allowed"};
14891 static const char * arm_attr_tag_MPextension_use
[] =
14892 {"Not Allowed", "Allowed"};
14893 static const char * arm_attr_tag_DIV_use
[] =
14894 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14895 "Allowed in v7-A with integer division extension"};
14896 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14897 static const char * arm_attr_tag_Virtualization_use
[] =
14898 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14899 "TrustZone and Virtualization Extensions"};
14900 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14901 {"Not Allowed", "Allowed"};
14903 static const char * arm_attr_tag_MVE_arch
[] =
14904 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14906 #define LOOKUP(id, name) \
14907 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14908 static arm_attr_public_tag arm_attr_public_tags
[] =
14910 {4, "CPU_raw_name", 1, NULL
},
14911 {5, "CPU_name", 1, NULL
},
14912 LOOKUP(6, CPU_arch
),
14913 {7, "CPU_arch_profile", 0, NULL
},
14914 LOOKUP(8, ARM_ISA_use
),
14915 LOOKUP(9, THUMB_ISA_use
),
14916 LOOKUP(10, FP_arch
),
14917 LOOKUP(11, WMMX_arch
),
14918 LOOKUP(12, Advanced_SIMD_arch
),
14919 LOOKUP(13, PCS_config
),
14920 LOOKUP(14, ABI_PCS_R9_use
),
14921 LOOKUP(15, ABI_PCS_RW_data
),
14922 LOOKUP(16, ABI_PCS_RO_data
),
14923 LOOKUP(17, ABI_PCS_GOT_use
),
14924 LOOKUP(18, ABI_PCS_wchar_t
),
14925 LOOKUP(19, ABI_FP_rounding
),
14926 LOOKUP(20, ABI_FP_denormal
),
14927 LOOKUP(21, ABI_FP_exceptions
),
14928 LOOKUP(22, ABI_FP_user_exceptions
),
14929 LOOKUP(23, ABI_FP_number_model
),
14930 {24, "ABI_align_needed", 0, NULL
},
14931 {25, "ABI_align_preserved", 0, NULL
},
14932 LOOKUP(26, ABI_enum_size
),
14933 LOOKUP(27, ABI_HardFP_use
),
14934 LOOKUP(28, ABI_VFP_args
),
14935 LOOKUP(29, ABI_WMMX_args
),
14936 LOOKUP(30, ABI_optimization_goals
),
14937 LOOKUP(31, ABI_FP_optimization_goals
),
14938 {32, "compatibility", 0, NULL
},
14939 LOOKUP(34, CPU_unaligned_access
),
14940 LOOKUP(36, FP_HP_extension
),
14941 LOOKUP(38, ABI_FP_16bit_format
),
14942 LOOKUP(42, MPextension_use
),
14943 LOOKUP(44, DIV_use
),
14944 LOOKUP(46, DSP_extension
),
14945 LOOKUP(48, MVE_arch
),
14946 {64, "nodefaults", 0, NULL
},
14947 {65, "also_compatible_with", 0, NULL
},
14948 LOOKUP(66, T2EE_use
),
14949 {67, "conformance", 1, NULL
},
14950 LOOKUP(68, Virtualization_use
),
14951 LOOKUP(70, MPextension_use_legacy
)
14955 static unsigned char *
14956 display_arm_attribute (unsigned char * p
,
14957 const unsigned char * const end
)
14961 arm_attr_public_tag
* attr
;
14965 READ_ULEB (tag
, p
, end
);
14967 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14969 if (arm_attr_public_tags
[i
].tag
== tag
)
14971 attr
= &arm_attr_public_tags
[i
];
14978 printf (" Tag_%s: ", attr
->name
);
14979 switch (attr
->type
)
14984 case 7: /* Tag_CPU_arch_profile. */
14985 READ_ULEB (val
, p
, end
);
14988 case 0: printf (_("None\n")); break;
14989 case 'A': printf (_("Application\n")); break;
14990 case 'R': printf (_("Realtime\n")); break;
14991 case 'M': printf (_("Microcontroller\n")); break;
14992 case 'S': printf (_("Application or Realtime\n")); break;
14993 default: printf ("??? (%d)\n", val
); break;
14997 case 24: /* Tag_align_needed. */
14998 READ_ULEB (val
, p
, end
);
15001 case 0: printf (_("None\n")); break;
15002 case 1: printf (_("8-byte\n")); break;
15003 case 2: printf (_("4-byte\n")); break;
15004 case 3: printf ("??? 3\n"); break;
15007 printf (_("8-byte and up to %d-byte extended\n"),
15010 printf ("??? (%d)\n", val
);
15015 case 25: /* Tag_align_preserved. */
15016 READ_ULEB (val
, p
, end
);
15019 case 0: printf (_("None\n")); break;
15020 case 1: printf (_("8-byte, except leaf SP\n")); break;
15021 case 2: printf (_("8-byte\n")); break;
15022 case 3: printf ("??? 3\n"); break;
15025 printf (_("8-byte and up to %d-byte extended\n"),
15028 printf ("??? (%d)\n", val
);
15033 case 32: /* Tag_compatibility. */
15035 READ_ULEB (val
, p
, end
);
15036 printf (_("flag = %d, vendor = "), val
);
15039 size_t maxlen
= (end
- p
) - 1;
15041 print_symbol ((int) maxlen
, (const char *) p
);
15042 p
+= strnlen ((char *) p
, maxlen
) + 1;
15046 printf (_("<corrupt>"));
15047 p
= (unsigned char *) end
;
15053 case 64: /* Tag_nodefaults. */
15054 /* PR 17531: file: 001-505008-0.01. */
15057 printf (_("True\n"));
15060 case 65: /* Tag_also_compatible_with. */
15061 READ_ULEB (val
, p
, end
);
15062 if (val
== 6 /* Tag_CPU_arch. */)
15064 READ_ULEB (val
, p
, end
);
15065 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15066 printf ("??? (%d)\n", val
);
15068 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15072 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15077 printf (_("<unknown: %d>\n"), tag
);
15083 return display_tag_value (-1, p
, end
);
15085 return display_tag_value (0, p
, end
);
15088 assert (attr
->type
& 0x80);
15089 READ_ULEB (val
, p
, end
);
15090 type
= attr
->type
& 0x7f;
15092 printf ("??? (%d)\n", val
);
15094 printf ("%s\n", attr
->table
[val
]);
15099 return display_tag_value (tag
, p
, end
);
15102 static unsigned char *
15103 display_gnu_attribute (unsigned char * p
,
15104 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15105 const unsigned char * const end
)
15110 READ_ULEB (tag
, p
, end
);
15112 /* Tag_compatibility is the only generic GNU attribute defined at
15116 READ_ULEB (val
, p
, end
);
15118 printf (_("flag = %d, vendor = "), val
);
15121 printf (_("<corrupt>\n"));
15122 warn (_("corrupt vendor attribute\n"));
15128 size_t maxlen
= (end
- p
) - 1;
15130 print_symbol ((int) maxlen
, (const char *) p
);
15131 p
+= strnlen ((char *) p
, maxlen
) + 1;
15135 printf (_("<corrupt>"));
15136 p
= (unsigned char *) end
;
15143 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15144 return display_proc_gnu_attribute (p
, tag
, end
);
15146 return display_tag_value (tag
, p
, end
);
15149 static unsigned char *
15150 display_power_gnu_attribute (unsigned char * p
,
15152 const unsigned char * const end
)
15156 if (tag
== Tag_GNU_Power_ABI_FP
)
15158 printf (" Tag_GNU_Power_ABI_FP: ");
15161 printf (_("<corrupt>\n"));
15164 READ_ULEB (val
, p
, end
);
15167 printf ("(%#x), ", val
);
15172 printf (_("unspecified hard/soft float, "));
15175 printf (_("hard float, "));
15178 printf (_("soft float, "));
15181 printf (_("single-precision hard float, "));
15188 printf (_("unspecified long double\n"));
15191 printf (_("128-bit IBM long double\n"));
15194 printf (_("64-bit long double\n"));
15197 printf (_("128-bit IEEE long double\n"));
15203 if (tag
== Tag_GNU_Power_ABI_Vector
)
15205 printf (" Tag_GNU_Power_ABI_Vector: ");
15208 printf (_("<corrupt>\n"));
15211 READ_ULEB (val
, p
, end
);
15214 printf ("(%#x), ", val
);
15219 printf (_("unspecified\n"));
15222 printf (_("generic\n"));
15225 printf ("AltiVec\n");
15234 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15236 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15239 printf (_("<corrupt>\n"));
15242 READ_ULEB (val
, p
, end
);
15245 printf ("(%#x), ", val
);
15250 printf (_("unspecified\n"));
15253 printf ("r3/r4\n");
15256 printf (_("memory\n"));
15265 return display_tag_value (tag
& 1, p
, end
);
15268 static unsigned char *
15269 display_s390_gnu_attribute (unsigned char * p
,
15271 const unsigned char * const end
)
15275 if (tag
== Tag_GNU_S390_ABI_Vector
)
15277 printf (" Tag_GNU_S390_ABI_Vector: ");
15278 READ_ULEB (val
, p
, end
);
15283 printf (_("any\n"));
15286 printf (_("software\n"));
15289 printf (_("hardware\n"));
15292 printf ("??? (%d)\n", val
);
15298 return display_tag_value (tag
& 1, p
, end
);
15302 display_sparc_hwcaps (unsigned int mask
)
15306 bfd_boolean first
= TRUE
;
15308 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15309 fputs ("mul32", stdout
), first
= FALSE
;
15310 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15311 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15312 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15313 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15314 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15315 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15316 if (mask
& ELF_SPARC_HWCAP_POPC
)
15317 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15318 if (mask
& ELF_SPARC_HWCAP_VIS
)
15319 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15320 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15321 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15322 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15323 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15324 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15325 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15326 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15327 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15328 if (mask
& ELF_SPARC_HWCAP_HPC
)
15329 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15330 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15331 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15332 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15333 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15334 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15335 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15336 if (mask
& ELF_SPARC_HWCAP_IMA
)
15337 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15338 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15339 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15342 fputc ('0', stdout
);
15343 fputc ('\n', stdout
);
15347 display_sparc_hwcaps2 (unsigned int mask
)
15351 bfd_boolean first
= TRUE
;
15353 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15354 fputs ("fjathplus", stdout
), first
= FALSE
;
15355 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15356 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15357 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15358 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15359 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15360 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15361 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15362 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15363 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15364 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15365 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15366 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15367 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15368 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15369 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15370 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15371 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15372 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15373 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15374 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15377 fputc ('0', stdout
);
15378 fputc ('\n', stdout
);
15381 static unsigned char *
15382 display_sparc_gnu_attribute (unsigned char * p
,
15384 const unsigned char * const end
)
15388 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15390 READ_ULEB (val
, p
, end
);
15391 printf (" Tag_GNU_Sparc_HWCAPS: ");
15392 display_sparc_hwcaps (val
);
15395 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15397 READ_ULEB (val
, p
, end
);
15398 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15399 display_sparc_hwcaps2 (val
);
15403 return display_tag_value (tag
, p
, end
);
15407 print_mips_fp_abi_value (unsigned int val
)
15411 case Val_GNU_MIPS_ABI_FP_ANY
:
15412 printf (_("Hard or soft float\n"));
15414 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15415 printf (_("Hard float (double precision)\n"));
15417 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15418 printf (_("Hard float (single precision)\n"));
15420 case Val_GNU_MIPS_ABI_FP_SOFT
:
15421 printf (_("Soft float\n"));
15423 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15424 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15426 case Val_GNU_MIPS_ABI_FP_XX
:
15427 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15429 case Val_GNU_MIPS_ABI_FP_64
:
15430 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15432 case Val_GNU_MIPS_ABI_FP_64A
:
15433 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15435 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15436 printf (_("NaN 2008 compatibility\n"));
15439 printf ("??? (%d)\n", val
);
15444 static unsigned char *
15445 display_mips_gnu_attribute (unsigned char * p
,
15447 const unsigned char * const end
)
15449 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15453 printf (" Tag_GNU_MIPS_ABI_FP: ");
15454 READ_ULEB (val
, p
, end
);
15455 print_mips_fp_abi_value (val
);
15459 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15463 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15464 READ_ULEB (val
, p
, end
);
15468 case Val_GNU_MIPS_ABI_MSA_ANY
:
15469 printf (_("Any MSA or not\n"));
15471 case Val_GNU_MIPS_ABI_MSA_128
:
15472 printf (_("128-bit MSA\n"));
15475 printf ("??? (%d)\n", val
);
15481 return display_tag_value (tag
& 1, p
, end
);
15484 static unsigned char *
15485 display_tic6x_attribute (unsigned char * p
,
15486 const unsigned char * const end
)
15491 READ_ULEB (tag
, p
, end
);
15496 printf (" Tag_ISA: ");
15497 READ_ULEB (val
, p
, end
);
15501 case C6XABI_Tag_ISA_none
:
15502 printf (_("None\n"));
15504 case C6XABI_Tag_ISA_C62X
:
15507 case C6XABI_Tag_ISA_C67X
:
15510 case C6XABI_Tag_ISA_C67XP
:
15511 printf ("C67x+\n");
15513 case C6XABI_Tag_ISA_C64X
:
15516 case C6XABI_Tag_ISA_C64XP
:
15517 printf ("C64x+\n");
15519 case C6XABI_Tag_ISA_C674X
:
15520 printf ("C674x\n");
15523 printf ("??? (%d)\n", val
);
15528 case Tag_ABI_wchar_t
:
15529 printf (" Tag_ABI_wchar_t: ");
15530 READ_ULEB (val
, p
, end
);
15534 printf (_("Not used\n"));
15537 printf (_("2 bytes\n"));
15540 printf (_("4 bytes\n"));
15543 printf ("??? (%d)\n", val
);
15548 case Tag_ABI_stack_align_needed
:
15549 printf (" Tag_ABI_stack_align_needed: ");
15550 READ_ULEB (val
, p
, end
);
15554 printf (_("8-byte\n"));
15557 printf (_("16-byte\n"));
15560 printf ("??? (%d)\n", val
);
15565 case Tag_ABI_stack_align_preserved
:
15566 READ_ULEB (val
, p
, end
);
15567 printf (" Tag_ABI_stack_align_preserved: ");
15571 printf (_("8-byte\n"));
15574 printf (_("16-byte\n"));
15577 printf ("??? (%d)\n", val
);
15583 READ_ULEB (val
, p
, end
);
15584 printf (" Tag_ABI_DSBT: ");
15588 printf (_("DSBT addressing not used\n"));
15591 printf (_("DSBT addressing used\n"));
15594 printf ("??? (%d)\n", val
);
15600 READ_ULEB (val
, p
, end
);
15601 printf (" Tag_ABI_PID: ");
15605 printf (_("Data addressing position-dependent\n"));
15608 printf (_("Data addressing position-independent, GOT near DP\n"));
15611 printf (_("Data addressing position-independent, GOT far from DP\n"));
15614 printf ("??? (%d)\n", val
);
15620 READ_ULEB (val
, p
, end
);
15621 printf (" Tag_ABI_PIC: ");
15625 printf (_("Code addressing position-dependent\n"));
15628 printf (_("Code addressing position-independent\n"));
15631 printf ("??? (%d)\n", val
);
15636 case Tag_ABI_array_object_alignment
:
15637 READ_ULEB (val
, p
, end
);
15638 printf (" Tag_ABI_array_object_alignment: ");
15642 printf (_("8-byte\n"));
15645 printf (_("4-byte\n"));
15648 printf (_("16-byte\n"));
15651 printf ("??? (%d)\n", val
);
15656 case Tag_ABI_array_object_align_expected
:
15657 READ_ULEB (val
, p
, end
);
15658 printf (" Tag_ABI_array_object_align_expected: ");
15662 printf (_("8-byte\n"));
15665 printf (_("4-byte\n"));
15668 printf (_("16-byte\n"));
15671 printf ("??? (%d)\n", val
);
15676 case Tag_ABI_compatibility
:
15678 READ_ULEB (val
, p
, end
);
15679 printf (" Tag_ABI_compatibility: ");
15680 printf (_("flag = %d, vendor = "), val
);
15683 size_t maxlen
= (end
- p
) - 1;
15685 print_symbol ((int) maxlen
, (const char *) p
);
15686 p
+= strnlen ((char *) p
, maxlen
) + 1;
15690 printf (_("<corrupt>"));
15691 p
= (unsigned char *) end
;
15697 case Tag_ABI_conformance
:
15699 printf (" Tag_ABI_conformance: \"");
15702 size_t maxlen
= (end
- p
) - 1;
15704 print_symbol ((int) maxlen
, (const char *) p
);
15705 p
+= strnlen ((char *) p
, maxlen
) + 1;
15709 printf (_("<corrupt>"));
15710 p
= (unsigned char *) end
;
15717 return display_tag_value (tag
, p
, end
);
15721 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15723 unsigned long addr
= 0;
15724 size_t bytes
= end
- p
;
15731 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15733 printf (" 0x%8.8lx ", addr
);
15735 for (j
= 0; j
< 16; j
++)
15738 printf ("%2.2x", p
[j
]);
15746 for (j
= 0; j
< lbytes
; j
++)
15749 if (k
>= ' ' && k
< 0x7f)
15765 static unsigned char *
15766 display_msp430x_attribute (unsigned char * p
,
15767 const unsigned char * const end
)
15772 READ_ULEB (tag
, p
, end
);
15776 case OFBA_MSPABI_Tag_ISA
:
15777 printf (" Tag_ISA: ");
15778 READ_ULEB (val
, p
, end
);
15781 case 0: printf (_("None\n")); break;
15782 case 1: printf (_("MSP430\n")); break;
15783 case 2: printf (_("MSP430X\n")); break;
15784 default: printf ("??? (%d)\n", val
); break;
15788 case OFBA_MSPABI_Tag_Code_Model
:
15789 printf (" Tag_Code_Model: ");
15790 READ_ULEB (val
, p
, end
);
15793 case 0: printf (_("None\n")); break;
15794 case 1: printf (_("Small\n")); break;
15795 case 2: printf (_("Large\n")); break;
15796 default: printf ("??? (%d)\n", val
); break;
15800 case OFBA_MSPABI_Tag_Data_Model
:
15801 printf (" Tag_Data_Model: ");
15802 READ_ULEB (val
, p
, end
);
15805 case 0: printf (_("None\n")); break;
15806 case 1: printf (_("Small\n")); break;
15807 case 2: printf (_("Large\n")); break;
15808 case 3: printf (_("Restricted Large\n")); break;
15809 default: printf ("??? (%d)\n", val
); break;
15814 printf (_(" <unknown tag %d>: "), tag
);
15821 size_t maxlen
= (end
- p
) - 1;
15823 print_symbol ((int) maxlen
, (const char *) p
);
15824 p
+= strnlen ((char *) p
, maxlen
) + 1;
15828 printf (_("<corrupt>"));
15829 p
= (unsigned char *) end
;
15835 READ_ULEB (val
, p
, end
);
15836 printf ("%d (0x%x)\n", val
, val
);
15845 static unsigned char *
15846 display_msp430_gnu_attribute (unsigned char * p
,
15848 const unsigned char * const end
)
15850 if (tag
== Tag_GNU_MSP430_Data_Region
)
15854 printf (" Tag_GNU_MSP430_Data_Region: ");
15855 READ_ULEB (val
, p
, end
);
15859 case Val_GNU_MSP430_Data_Region_Any
:
15860 printf (_("Any Region\n"));
15862 case Val_GNU_MSP430_Data_Region_Lower
:
15863 printf (_("Lower Region Only\n"));
15866 printf ("??? (%u)\n", val
);
15870 return display_tag_value (tag
& 1, p
, end
);
15873 struct riscv_attr_tag_t
{
15878 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15880 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15883 T(priv_spec_minor
),
15884 T(priv_spec_revision
),
15885 T(unaligned_access
),
15890 static unsigned char *
15891 display_riscv_attribute (unsigned char *p
,
15892 const unsigned char * const end
)
15896 struct riscv_attr_tag_t
*attr
= NULL
;
15899 READ_ULEB (tag
, p
, end
);
15901 /* Find the name of attribute. */
15902 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
15904 if (riscv_attr_tag
[i
].tag
== tag
)
15906 attr
= &riscv_attr_tag
[i
];
15912 printf (" %s: ", attr
->name
);
15914 return display_tag_value (tag
, p
, end
);
15918 case Tag_RISCV_priv_spec
:
15919 case Tag_RISCV_priv_spec_minor
:
15920 case Tag_RISCV_priv_spec_revision
:
15921 READ_ULEB (val
, p
, end
);
15922 printf (_("%u\n"), val
);
15924 case Tag_RISCV_unaligned_access
:
15925 READ_ULEB (val
, p
, end
);
15929 printf (_("No unaligned access\n"));
15932 printf (_("Unaligned access\n"));
15936 case Tag_RISCV_stack_align
:
15937 READ_ULEB (val
, p
, end
);
15938 printf (_("%u-bytes\n"), val
);
15940 case Tag_RISCV_arch
:
15941 p
= display_tag_value (-1, p
, end
);
15944 return display_tag_value (tag
, p
, end
);
15951 process_attributes (Filedata
* filedata
,
15952 const char * public_name
,
15953 unsigned int proc_type
,
15954 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15955 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15957 Elf_Internal_Shdr
* sect
;
15959 bfd_boolean res
= TRUE
;
15961 /* Find the section header so that we get the size. */
15962 for (i
= 0, sect
= filedata
->section_headers
;
15963 i
< filedata
->file_header
.e_shnum
;
15966 unsigned char * contents
;
15969 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15972 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15973 sect
->sh_size
, _("attributes"));
15974 if (contents
== NULL
)
15981 /* The first character is the version of the attributes.
15982 Currently only version 1, (aka 'A') is recognised here. */
15985 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15990 bfd_vma section_len
;
15992 section_len
= sect
->sh_size
- 1;
15995 while (section_len
> 0)
15998 unsigned int namelen
;
15999 bfd_boolean public_section
;
16000 bfd_boolean gnu_section
;
16002 if (section_len
<= 4)
16004 error (_("Tag section ends prematurely\n"));
16008 attr_len
= byte_get (p
, 4);
16011 if (attr_len
> section_len
)
16013 error (_("Bad attribute length (%u > %u)\n"),
16014 (unsigned) attr_len
, (unsigned) section_len
);
16015 attr_len
= section_len
;
16018 /* PR 17531: file: 001-101425-0.004 */
16019 else if (attr_len
< 5)
16021 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16026 section_len
-= attr_len
;
16029 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16030 if (namelen
== 0 || namelen
>= attr_len
)
16032 error (_("Corrupt attribute section name\n"));
16037 printf (_("Attribute Section: "));
16038 print_symbol (INT_MAX
, (const char *) p
);
16041 if (public_name
&& streq ((char *) p
, public_name
))
16042 public_section
= TRUE
;
16044 public_section
= FALSE
;
16046 if (streq ((char *) p
, "gnu"))
16047 gnu_section
= TRUE
;
16049 gnu_section
= FALSE
;
16052 attr_len
-= namelen
;
16054 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16059 unsigned char * end
;
16061 /* PR binutils/17531: Safe handling of corrupt files. */
16064 error (_("Unused bytes at end of section\n"));
16071 size
= byte_get (p
, 4);
16072 if (size
> attr_len
)
16074 error (_("Bad subsection length (%u > %u)\n"),
16075 (unsigned) size
, (unsigned) attr_len
);
16079 /* PR binutils/17531: Safe handling of corrupt files. */
16082 error (_("Bad subsection length (%u < 6)\n"),
16090 end
= p
+ size
- 1;
16091 assert (end
<= contents
+ sect
->sh_size
);
16097 printf (_("File Attributes\n"));
16100 printf (_("Section Attributes:"));
16103 printf (_("Symbol Attributes:"));
16104 /* Fall through. */
16108 READ_ULEB (val
, p
, end
);
16111 printf (" %d", val
);
16116 printf (_("Unknown tag: %d\n"), tag
);
16117 public_section
= FALSE
;
16121 if (public_section
&& display_pub_attribute
!= NULL
)
16124 p
= display_pub_attribute (p
, end
);
16127 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
16130 p
= display_gnu_attribute (p
,
16131 display_proc_gnu_attribute
,
16137 printf (_(" Unknown attribute:\n"));
16138 display_raw_attribute (p
, end
);
16153 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16154 Print the Address, Access and Initial fields of an entry at VMA ADDR
16155 and return the VMA of the next entry, or -1 if there was a problem.
16156 Does not read from DATA_END or beyond. */
16159 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
16160 unsigned char * data_end
)
16163 print_vma (addr
, LONG_HEX
);
16165 if (addr
< pltgot
+ 0xfff0)
16166 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
16168 printf ("%10s", "");
16171 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16175 unsigned char * from
= data
+ addr
- pltgot
;
16177 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16179 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16180 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16181 return (bfd_vma
) -1;
16185 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16186 print_vma (entry
, LONG_HEX
);
16189 return addr
+ (is_32bit_elf
? 4 : 8);
16192 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16193 PLTGOT. Print the Address and Initial fields of an entry at VMA
16194 ADDR and return the VMA of the next entry. */
16197 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16200 print_vma (addr
, LONG_HEX
);
16203 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16208 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16209 print_vma (entry
, LONG_HEX
);
16211 return addr
+ (is_32bit_elf
? 4 : 8);
16215 print_mips_ases (unsigned int mask
)
16217 if (mask
& AFL_ASE_DSP
)
16218 fputs ("\n\tDSP ASE", stdout
);
16219 if (mask
& AFL_ASE_DSPR2
)
16220 fputs ("\n\tDSP R2 ASE", stdout
);
16221 if (mask
& AFL_ASE_DSPR3
)
16222 fputs ("\n\tDSP R3 ASE", stdout
);
16223 if (mask
& AFL_ASE_EVA
)
16224 fputs ("\n\tEnhanced VA Scheme", stdout
);
16225 if (mask
& AFL_ASE_MCU
)
16226 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16227 if (mask
& AFL_ASE_MDMX
)
16228 fputs ("\n\tMDMX ASE", stdout
);
16229 if (mask
& AFL_ASE_MIPS3D
)
16230 fputs ("\n\tMIPS-3D ASE", stdout
);
16231 if (mask
& AFL_ASE_MT
)
16232 fputs ("\n\tMT ASE", stdout
);
16233 if (mask
& AFL_ASE_SMARTMIPS
)
16234 fputs ("\n\tSmartMIPS ASE", stdout
);
16235 if (mask
& AFL_ASE_VIRT
)
16236 fputs ("\n\tVZ ASE", stdout
);
16237 if (mask
& AFL_ASE_MSA
)
16238 fputs ("\n\tMSA ASE", stdout
);
16239 if (mask
& AFL_ASE_MIPS16
)
16240 fputs ("\n\tMIPS16 ASE", stdout
);
16241 if (mask
& AFL_ASE_MICROMIPS
)
16242 fputs ("\n\tMICROMIPS ASE", stdout
);
16243 if (mask
& AFL_ASE_XPA
)
16244 fputs ("\n\tXPA ASE", stdout
);
16245 if (mask
& AFL_ASE_MIPS16E2
)
16246 fputs ("\n\tMIPS16e2 ASE", stdout
);
16247 if (mask
& AFL_ASE_CRC
)
16248 fputs ("\n\tCRC ASE", stdout
);
16249 if (mask
& AFL_ASE_GINV
)
16250 fputs ("\n\tGINV ASE", stdout
);
16251 if (mask
& AFL_ASE_LOONGSON_MMI
)
16252 fputs ("\n\tLoongson MMI ASE", stdout
);
16253 if (mask
& AFL_ASE_LOONGSON_CAM
)
16254 fputs ("\n\tLoongson CAM ASE", stdout
);
16255 if (mask
& AFL_ASE_LOONGSON_EXT
)
16256 fputs ("\n\tLoongson EXT ASE", stdout
);
16257 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16258 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16260 fprintf (stdout
, "\n\t%s", _("None"));
16261 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16262 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16266 print_mips_isa_ext (unsigned int isa_ext
)
16271 fputs (_("None"), stdout
);
16274 fputs ("RMI XLR", stdout
);
16276 case AFL_EXT_OCTEON3
:
16277 fputs ("Cavium Networks Octeon3", stdout
);
16279 case AFL_EXT_OCTEON2
:
16280 fputs ("Cavium Networks Octeon2", stdout
);
16282 case AFL_EXT_OCTEONP
:
16283 fputs ("Cavium Networks OcteonP", stdout
);
16285 case AFL_EXT_OCTEON
:
16286 fputs ("Cavium Networks Octeon", stdout
);
16289 fputs ("Toshiba R5900", stdout
);
16292 fputs ("MIPS R4650", stdout
);
16295 fputs ("LSI R4010", stdout
);
16298 fputs ("NEC VR4100", stdout
);
16301 fputs ("Toshiba R3900", stdout
);
16303 case AFL_EXT_10000
:
16304 fputs ("MIPS R10000", stdout
);
16307 fputs ("Broadcom SB-1", stdout
);
16310 fputs ("NEC VR4111/VR4181", stdout
);
16313 fputs ("NEC VR4120", stdout
);
16316 fputs ("NEC VR5400", stdout
);
16319 fputs ("NEC VR5500", stdout
);
16321 case AFL_EXT_LOONGSON_2E
:
16322 fputs ("ST Microelectronics Loongson 2E", stdout
);
16324 case AFL_EXT_LOONGSON_2F
:
16325 fputs ("ST Microelectronics Loongson 2F", stdout
);
16327 case AFL_EXT_INTERAPTIV_MR2
:
16328 fputs ("Imagination interAptiv MR2", stdout
);
16331 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16336 get_mips_reg_size (int reg_size
)
16338 return (reg_size
== AFL_REG_NONE
) ? 0
16339 : (reg_size
== AFL_REG_32
) ? 32
16340 : (reg_size
== AFL_REG_64
) ? 64
16341 : (reg_size
== AFL_REG_128
) ? 128
16346 process_mips_specific (Filedata
* filedata
)
16348 Elf_Internal_Dyn
* entry
;
16349 Elf_Internal_Shdr
*sect
= NULL
;
16350 size_t liblist_offset
= 0;
16351 size_t liblistno
= 0;
16352 size_t conflictsno
= 0;
16353 size_t options_offset
= 0;
16354 size_t conflicts_offset
= 0;
16355 size_t pltrelsz
= 0;
16357 bfd_vma pltgot
= 0;
16358 bfd_vma mips_pltgot
= 0;
16359 bfd_vma jmprel
= 0;
16360 bfd_vma local_gotno
= 0;
16361 bfd_vma gotsym
= 0;
16362 bfd_vma symtabno
= 0;
16363 bfd_boolean res
= TRUE
;
16365 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16366 display_mips_gnu_attribute
))
16369 sect
= find_section (filedata
, ".MIPS.abiflags");
16373 Elf_External_ABIFlags_v0
*abiflags_ext
;
16374 Elf_Internal_ABIFlags_v0 abiflags_in
;
16376 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16378 error (_("Corrupt MIPS ABI Flags section.\n"));
16383 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16384 sect
->sh_size
, _("MIPS ABI Flags section"));
16387 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16388 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16389 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16390 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16391 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16392 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16393 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16394 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16395 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16396 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16397 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16399 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16400 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16401 if (abiflags_in
.isa_rev
> 1)
16402 printf ("r%d", abiflags_in
.isa_rev
);
16403 printf ("\nGPR size: %d",
16404 get_mips_reg_size (abiflags_in
.gpr_size
));
16405 printf ("\nCPR1 size: %d",
16406 get_mips_reg_size (abiflags_in
.cpr1_size
));
16407 printf ("\nCPR2 size: %d",
16408 get_mips_reg_size (abiflags_in
.cpr2_size
));
16409 fputs ("\nFP ABI: ", stdout
);
16410 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16411 fputs ("ISA Extension: ", stdout
);
16412 print_mips_isa_ext (abiflags_in
.isa_ext
);
16413 fputs ("\nASEs:", stdout
);
16414 print_mips_ases (abiflags_in
.ases
);
16415 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16416 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16417 fputc ('\n', stdout
);
16418 free (abiflags_ext
);
16423 /* We have a lot of special sections. Thanks SGI! */
16424 if (dynamic_section
== NULL
)
16426 /* No dynamic information available. See if there is static GOT. */
16427 sect
= find_section (filedata
, ".got");
16430 unsigned char *data_end
;
16431 unsigned char *data
;
16435 pltgot
= sect
->sh_addr
;
16438 addr_size
= (is_32bit_elf
? 4 : 8);
16439 end
= pltgot
+ sect
->sh_size
;
16441 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16443 _("Global Offset Table data"));
16444 /* PR 12855: Null data is handled gracefully throughout. */
16445 data_end
= data
+ (end
- pltgot
);
16447 printf (_("\nStatic GOT:\n"));
16448 printf (_(" Canonical gp value: "));
16449 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16452 /* In a dynamic binary GOT[0] is reserved for the dynamic
16453 loader to store the lazy resolver pointer, however in
16454 a static binary it may well have been omitted and GOT
16455 reduced to a table of addresses.
16456 PR 21344: Check for the entry being fully available
16457 before fetching it. */
16459 && data
+ ent
- pltgot
+ addr_size
<= data_end
16460 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16462 printf (_(" Reserved entries:\n"));
16463 printf (_(" %*s %10s %*s\n"),
16464 addr_size
* 2, _("Address"), _("Access"),
16465 addr_size
* 2, _("Value"));
16466 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16468 if (ent
== (bfd_vma
) -1)
16469 goto sgot_print_fail
;
16471 /* Check for the MSB of GOT[1] being set, identifying a
16472 GNU object. This entry will be used by some runtime
16473 loaders, to store the module pointer. Otherwise this
16474 is an ordinary local entry.
16475 PR 21344: Check for the entry being fully available
16476 before fetching it. */
16478 && data
+ ent
- pltgot
+ addr_size
<= data_end
16479 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16480 >> (addr_size
* 8 - 1)) != 0)
16482 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16484 if (ent
== (bfd_vma
) -1)
16485 goto sgot_print_fail
;
16490 if (data
!= NULL
&& ent
< end
)
16492 printf (_(" Local entries:\n"));
16493 printf (" %*s %10s %*s\n",
16494 addr_size
* 2, _("Address"), _("Access"),
16495 addr_size
* 2, _("Value"));
16498 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16500 if (ent
== (bfd_vma
) -1)
16501 goto sgot_print_fail
;
16513 for (entry
= dynamic_section
;
16514 /* PR 17531 file: 012-50589-0.004. */
16515 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16517 switch (entry
->d_tag
)
16519 case DT_MIPS_LIBLIST
:
16521 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16522 liblistno
* sizeof (Elf32_External_Lib
));
16524 case DT_MIPS_LIBLISTNO
:
16525 liblistno
= entry
->d_un
.d_val
;
16527 case DT_MIPS_OPTIONS
:
16528 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16530 case DT_MIPS_CONFLICT
:
16532 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16533 conflictsno
* sizeof (Elf32_External_Conflict
));
16535 case DT_MIPS_CONFLICTNO
:
16536 conflictsno
= entry
->d_un
.d_val
;
16539 pltgot
= entry
->d_un
.d_ptr
;
16541 case DT_MIPS_LOCAL_GOTNO
:
16542 local_gotno
= entry
->d_un
.d_val
;
16544 case DT_MIPS_GOTSYM
:
16545 gotsym
= entry
->d_un
.d_val
;
16547 case DT_MIPS_SYMTABNO
:
16548 symtabno
= entry
->d_un
.d_val
;
16550 case DT_MIPS_PLTGOT
:
16551 mips_pltgot
= entry
->d_un
.d_ptr
;
16554 pltrel
= entry
->d_un
.d_val
;
16557 pltrelsz
= entry
->d_un
.d_val
;
16560 jmprel
= entry
->d_un
.d_ptr
;
16566 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16568 Elf32_External_Lib
* elib
;
16571 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16573 sizeof (Elf32_External_Lib
),
16574 _("liblist section data"));
16577 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16578 "\nSection '.liblist' contains %lu entries:\n",
16579 (unsigned long) liblistno
),
16580 (unsigned long) liblistno
);
16581 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16584 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16591 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16592 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16593 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16594 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16595 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16597 tmp
= gmtime (&atime
);
16598 snprintf (timebuf
, sizeof (timebuf
),
16599 "%04u-%02u-%02uT%02u:%02u:%02u",
16600 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16601 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16603 printf ("%3lu: ", (unsigned long) cnt
);
16604 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16605 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16607 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16608 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16609 liblist
.l_version
);
16611 if (liblist
.l_flags
== 0)
16615 static const struct
16622 { " EXACT_MATCH", LL_EXACT_MATCH
},
16623 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16624 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16625 { " EXPORTS", LL_EXPORTS
},
16626 { " DELAY_LOAD", LL_DELAY_LOAD
},
16627 { " DELTA", LL_DELTA
}
16629 int flags
= liblist
.l_flags
;
16632 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16633 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16635 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16636 flags
^= l_flags_vals
[fcnt
].bit
;
16639 printf (" %#x", (unsigned int) flags
);
16651 if (options_offset
!= 0)
16653 Elf_External_Options
* eopt
;
16656 sect
= filedata
->section_headers
;
16658 /* Find the section header so that we get the size. */
16659 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16660 /* PR 17533 file: 012-277276-0.004. */
16663 error (_("No MIPS_OPTIONS header found\n"));
16667 if (sect
->sh_size
< sizeof (* eopt
))
16669 error (_("The MIPS options section is too small.\n"));
16673 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16674 sect
->sh_size
, _("options"));
16677 Elf_Internal_Options
* iopt
;
16678 Elf_Internal_Options
* option
;
16679 Elf_Internal_Options
* iopt_end
;
16681 iopt
= (Elf_Internal_Options
*)
16682 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16685 error (_("Out of memory allocating space for MIPS options\n"));
16691 iopt_end
= iopt
+ (sect
->sh_size
/ sizeof (eopt
));
16693 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16695 Elf_External_Options
* eoption
;
16697 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16699 option
->kind
= BYTE_GET (eoption
->kind
);
16700 option
->size
= BYTE_GET (eoption
->size
);
16701 option
->section
= BYTE_GET (eoption
->section
);
16702 option
->info
= BYTE_GET (eoption
->info
);
16704 /* PR 17531: file: ffa0fa3b. */
16705 if (option
->size
< sizeof (* eopt
)
16706 || offset
+ option
->size
> sect
->sh_size
)
16708 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16711 offset
+= option
->size
;
16717 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16718 "\nSection '%s' contains %d entries:\n",
16720 printable_section_name (filedata
, sect
), cnt
);
16729 switch (option
->kind
)
16732 /* This shouldn't happen. */
16733 printf (" NULL %d %lx", option
->section
, option
->info
);
16737 printf (" REGINFO ");
16738 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16740 Elf32_External_RegInfo
* ereg
;
16741 Elf32_RegInfo reginfo
;
16744 if (option
+ 2 > iopt_end
)
16746 printf (_("<corrupt>\n"));
16747 error (_("Truncated MIPS REGINFO option\n"));
16752 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16754 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16755 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16756 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16757 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16758 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16759 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16761 printf ("GPR %08lx GP 0x%lx\n",
16762 reginfo
.ri_gprmask
,
16763 (unsigned long) reginfo
.ri_gp_value
);
16764 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16765 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16766 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16771 Elf64_External_RegInfo
* ereg
;
16772 Elf64_Internal_RegInfo reginfo
;
16774 if (option
+ 2 > iopt_end
)
16776 printf (_("<corrupt>\n"));
16777 error (_("Truncated MIPS REGINFO option\n"));
16782 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16783 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16784 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16785 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16786 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16787 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16788 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16790 printf ("GPR %08lx GP 0x",
16791 reginfo
.ri_gprmask
);
16792 printf_vma (reginfo
.ri_gp_value
);
16795 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16796 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16797 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16802 case ODK_EXCEPTIONS
:
16803 fputs (" EXCEPTIONS fpe_min(", stdout
);
16804 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16805 fputs (") fpe_max(", stdout
);
16806 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16807 fputs (")", stdout
);
16809 if (option
->info
& OEX_PAGE0
)
16810 fputs (" PAGE0", stdout
);
16811 if (option
->info
& OEX_SMM
)
16812 fputs (" SMM", stdout
);
16813 if (option
->info
& OEX_FPDBUG
)
16814 fputs (" FPDBUG", stdout
);
16815 if (option
->info
& OEX_DISMISS
)
16816 fputs (" DISMISS", stdout
);
16820 fputs (" PAD ", stdout
);
16821 if (option
->info
& OPAD_PREFIX
)
16822 fputs (" PREFIX", stdout
);
16823 if (option
->info
& OPAD_POSTFIX
)
16824 fputs (" POSTFIX", stdout
);
16825 if (option
->info
& OPAD_SYMBOL
)
16826 fputs (" SYMBOL", stdout
);
16830 fputs (" HWPATCH ", stdout
);
16831 if (option
->info
& OHW_R4KEOP
)
16832 fputs (" R4KEOP", stdout
);
16833 if (option
->info
& OHW_R8KPFETCH
)
16834 fputs (" R8KPFETCH", stdout
);
16835 if (option
->info
& OHW_R5KEOP
)
16836 fputs (" R5KEOP", stdout
);
16837 if (option
->info
& OHW_R5KCVTL
)
16838 fputs (" R5KCVTL", stdout
);
16842 fputs (" FILL ", stdout
);
16843 /* XXX Print content of info word? */
16847 fputs (" TAGS ", stdout
);
16848 /* XXX Print content of info word? */
16852 fputs (" HWAND ", stdout
);
16853 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16854 fputs (" R4KEOP_CHECKED", stdout
);
16855 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16856 fputs (" R4KEOP_CLEAN", stdout
);
16860 fputs (" HWOR ", stdout
);
16861 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16862 fputs (" R4KEOP_CHECKED", stdout
);
16863 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16864 fputs (" R4KEOP_CLEAN", stdout
);
16868 printf (" GP_GROUP %#06lx self-contained %#06lx",
16869 option
->info
& OGP_GROUP
,
16870 (option
->info
& OGP_SELF
) >> 16);
16874 printf (" IDENT %#06lx self-contained %#06lx",
16875 option
->info
& OGP_GROUP
,
16876 (option
->info
& OGP_SELF
) >> 16);
16880 /* This shouldn't happen. */
16881 printf (" %3d ??? %d %lx",
16882 option
->kind
, option
->section
, option
->info
);
16886 len
= sizeof (* eopt
);
16887 while (len
< option
->size
)
16889 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16891 if (ISPRINT (datum
))
16892 printf ("%c", datum
);
16894 printf ("\\%03o", datum
);
16897 fputs ("\n", stdout
);
16899 offset
+= option
->size
;
16909 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16911 Elf32_Conflict
* iconf
;
16914 if (dynamic_symbols
== NULL
)
16916 error (_("conflict list found without a dynamic symbol table\n"));
16920 /* PR 21345 - print a slightly more helpful error message
16921 if we are sure that the cmalloc will fail. */
16922 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16924 error (_("Overlarge number of conflicts detected: %lx\n"),
16925 (long) conflictsno
);
16929 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16932 error (_("Out of memory allocating space for dynamic conflicts\n"));
16938 Elf32_External_Conflict
* econf32
;
16940 econf32
= (Elf32_External_Conflict
*)
16941 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16942 sizeof (* econf32
), _("conflict"));
16946 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16947 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16953 Elf64_External_Conflict
* econf64
;
16955 econf64
= (Elf64_External_Conflict
*)
16956 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16957 sizeof (* econf64
), _("conflict"));
16961 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16962 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16967 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16968 "\nSection '.conflict' contains %lu entries:\n",
16969 (unsigned long) conflictsno
),
16970 (unsigned long) conflictsno
);
16971 puts (_(" Num: Index Value Name"));
16973 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16975 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16977 if (iconf
[cnt
] >= num_dynamic_syms
)
16978 printf (_("<corrupt symbol index>"));
16981 Elf_Internal_Sym
* psym
;
16983 psym
= & dynamic_symbols
[iconf
[cnt
]];
16984 print_vma (psym
->st_value
, FULL_HEX
);
16986 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16987 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16989 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16997 if (pltgot
!= 0 && local_gotno
!= 0)
16999 bfd_vma ent
, local_end
, global_end
;
17001 unsigned char * data
;
17002 unsigned char * data_end
;
17006 addr_size
= (is_32bit_elf
? 4 : 8);
17007 local_end
= pltgot
+ local_gotno
* addr_size
;
17009 /* PR binutils/17533 file: 012-111227-0.004 */
17010 if (symtabno
< gotsym
)
17012 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17013 (unsigned long) gotsym
, (unsigned long) symtabno
);
17017 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17018 /* PR 17531: file: 54c91a34. */
17019 if (global_end
< local_end
)
17021 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17025 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17026 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17027 global_end
- pltgot
, 1,
17028 _("Global Offset Table data"));
17029 /* PR 12855: Null data is handled gracefully throughout. */
17030 data_end
= data
+ (global_end
- pltgot
);
17032 printf (_("\nPrimary GOT:\n"));
17033 printf (_(" Canonical gp value: "));
17034 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17037 printf (_(" Reserved entries:\n"));
17038 printf (_(" %*s %10s %*s Purpose\n"),
17039 addr_size
* 2, _("Address"), _("Access"),
17040 addr_size
* 2, _("Initial"));
17041 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17042 printf (_(" Lazy resolver\n"));
17043 if (ent
== (bfd_vma
) -1)
17044 goto got_print_fail
;
17046 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17047 This entry will be used by some runtime loaders, to store the
17048 module pointer. Otherwise this is an ordinary local entry.
17049 PR 21344: Check for the entry being fully available before
17052 && data
+ ent
- pltgot
+ addr_size
<= data_end
17053 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17054 >> (addr_size
* 8 - 1)) != 0)
17056 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17057 printf (_(" Module pointer (GNU extension)\n"));
17058 if (ent
== (bfd_vma
) -1)
17059 goto got_print_fail
;
17063 if (data
!= NULL
&& ent
< local_end
)
17065 printf (_(" Local entries:\n"));
17066 printf (" %*s %10s %*s\n",
17067 addr_size
* 2, _("Address"), _("Access"),
17068 addr_size
* 2, _("Initial"));
17069 while (ent
< local_end
)
17071 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17073 if (ent
== (bfd_vma
) -1)
17074 goto got_print_fail
;
17079 if (data
!= NULL
&& gotsym
< symtabno
)
17083 printf (_(" Global entries:\n"));
17084 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17085 addr_size
* 2, _("Address"),
17087 addr_size
* 2, _("Initial"),
17088 addr_size
* 2, _("Sym.Val."),
17090 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17091 _("Ndx"), _("Name"));
17093 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17095 for (i
= gotsym
; i
< symtabno
; i
++)
17097 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17100 if (dynamic_symbols
== NULL
)
17101 printf (_("<no dynamic symbols>"));
17102 else if (i
< num_dynamic_syms
)
17104 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
17106 print_vma (psym
->st_value
, LONG_HEX
);
17107 printf (" %-7s %3s ",
17108 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17109 get_symbol_index_type (filedata
, psym
->st_shndx
));
17111 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17112 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17114 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17117 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17118 (unsigned long) i
);
17121 if (ent
== (bfd_vma
) -1)
17132 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
17135 size_t offset
, rel_offset
;
17136 unsigned long count
, i
;
17137 unsigned char * data
;
17138 int addr_size
, sym_width
;
17139 Elf_Internal_Rela
* rels
;
17141 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
17142 if (pltrel
== DT_RELA
)
17144 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17149 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
17154 addr_size
= (is_32bit_elf
? 4 : 8);
17155 end
= mips_pltgot
+ (2 + count
) * addr_size
;
17157 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
17158 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
17159 1, _("Procedure Linkage Table data"));
17163 printf ("\nPLT GOT:\n\n");
17164 printf (_(" Reserved entries:\n"));
17165 printf (_(" %*s %*s Purpose\n"),
17166 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
17167 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17168 printf (_(" PLT lazy resolver\n"));
17169 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17170 printf (_(" Module pointer\n"));
17173 printf (_(" Entries:\n"));
17174 printf (" %*s %*s %*s %-7s %3s %s\n",
17175 addr_size
* 2, _("Address"),
17176 addr_size
* 2, _("Initial"),
17177 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17178 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
17179 for (i
= 0; i
< count
; i
++)
17181 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
17183 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
17186 if (idx
>= num_dynamic_syms
)
17187 printf (_("<corrupt symbol index: %lu>"), idx
);
17190 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
17192 print_vma (psym
->st_value
, LONG_HEX
);
17193 printf (" %-7s %3s ",
17194 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
17195 get_symbol_index_type (filedata
, psym
->st_shndx
));
17196 if (VALID_DYNAMIC_NAME (psym
->st_name
))
17197 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
17199 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17214 process_nds32_specific (Filedata
* filedata
)
17216 Elf_Internal_Shdr
*sect
= NULL
;
17218 sect
= find_section (filedata
, ".nds32_e_flags");
17221 unsigned int *flag
;
17223 printf ("\nNDS32 elf flags section:\n");
17224 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17225 sect
->sh_size
, _("NDS32 elf flags section"));
17230 switch ((*flag
) & 0x3)
17233 printf ("(VEC_SIZE):\tNo entry.\n");
17236 printf ("(VEC_SIZE):\t4 bytes\n");
17239 printf ("(VEC_SIZE):\t16 bytes\n");
17242 printf ("(VEC_SIZE):\treserved\n");
17251 process_gnu_liblist (Filedata
* filedata
)
17253 Elf_Internal_Shdr
* section
;
17254 Elf_Internal_Shdr
* string_sec
;
17255 Elf32_External_Lib
* elib
;
17257 size_t strtab_size
;
17259 unsigned long num_liblist
;
17261 bfd_boolean res
= TRUE
;
17266 for (i
= 0, section
= filedata
->section_headers
;
17267 i
< filedata
->file_header
.e_shnum
;
17270 switch (section
->sh_type
)
17272 case SHT_GNU_LIBLIST
:
17273 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17276 elib
= (Elf32_External_Lib
*)
17277 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17278 _("liblist section data"));
17286 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17287 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17288 string_sec
->sh_size
,
17289 _("liblist string table"));
17291 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17298 strtab_size
= string_sec
->sh_size
;
17300 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17301 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17302 "\nLibrary list section '%s' contains %lu entries:\n",
17304 printable_section_name (filedata
, section
),
17307 puts (_(" Library Time Stamp Checksum Version Flags"));
17309 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17317 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17318 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17319 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17320 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17321 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17323 tmp
= gmtime (&atime
);
17324 snprintf (timebuf
, sizeof (timebuf
),
17325 "%04u-%02u-%02uT%02u:%02u:%02u",
17326 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17327 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17329 printf ("%3lu: ", (unsigned long) cnt
);
17331 printf ("%-20s", liblist
.l_name
< strtab_size
17332 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17334 printf ("%-20.20s", liblist
.l_name
< strtab_size
17335 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17336 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17337 liblist
.l_version
, liblist
.l_flags
);
17348 static const char *
17349 get_note_type (Filedata
* filedata
, unsigned e_type
)
17351 static char buff
[64];
17353 if (filedata
->file_header
.e_type
== ET_CORE
)
17357 return _("NT_AUXV (auxiliary vector)");
17359 return _("NT_PRSTATUS (prstatus structure)");
17361 return _("NT_FPREGSET (floating point registers)");
17363 return _("NT_PRPSINFO (prpsinfo structure)");
17364 case NT_TASKSTRUCT
:
17365 return _("NT_TASKSTRUCT (task structure)");
17367 return _("NT_PRXFPREG (user_xfpregs structure)");
17369 return _("NT_PPC_VMX (ppc Altivec registers)");
17371 return _("NT_PPC_VSX (ppc VSX registers)");
17373 return _("NT_PPC_TAR (ppc TAR register)");
17375 return _("NT_PPC_PPR (ppc PPR register)");
17377 return _("NT_PPC_DSCR (ppc DSCR register)");
17379 return _("NT_PPC_EBB (ppc EBB registers)");
17381 return _("NT_PPC_PMU (ppc PMU registers)");
17382 case NT_PPC_TM_CGPR
:
17383 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17384 case NT_PPC_TM_CFPR
:
17385 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17386 case NT_PPC_TM_CVMX
:
17387 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17388 case NT_PPC_TM_CVSX
:
17389 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17390 case NT_PPC_TM_SPR
:
17391 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17392 case NT_PPC_TM_CTAR
:
17393 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17394 case NT_PPC_TM_CPPR
:
17395 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17396 case NT_PPC_TM_CDSCR
:
17397 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17399 return _("NT_386_TLS (x86 TLS information)");
17400 case NT_386_IOPERM
:
17401 return _("NT_386_IOPERM (x86 I/O permissions)");
17402 case NT_X86_XSTATE
:
17403 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17404 case NT_S390_HIGH_GPRS
:
17405 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17406 case NT_S390_TIMER
:
17407 return _("NT_S390_TIMER (s390 timer register)");
17408 case NT_S390_TODCMP
:
17409 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17410 case NT_S390_TODPREG
:
17411 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17413 return _("NT_S390_CTRS (s390 control registers)");
17414 case NT_S390_PREFIX
:
17415 return _("NT_S390_PREFIX (s390 prefix register)");
17416 case NT_S390_LAST_BREAK
:
17417 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17418 case NT_S390_SYSTEM_CALL
:
17419 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17421 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17422 case NT_S390_VXRS_LOW
:
17423 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17424 case NT_S390_VXRS_HIGH
:
17425 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17426 case NT_S390_GS_CB
:
17427 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17428 case NT_S390_GS_BC
:
17429 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17431 return _("NT_ARM_VFP (arm VFP registers)");
17433 return _("NT_ARM_TLS (AArch TLS registers)");
17434 case NT_ARM_HW_BREAK
:
17435 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17436 case NT_ARM_HW_WATCH
:
17437 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17439 return _("NT_PSTATUS (pstatus structure)");
17441 return _("NT_FPREGS (floating point registers)");
17443 return _("NT_PSINFO (psinfo structure)");
17445 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17447 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17448 case NT_WIN32PSTATUS
:
17449 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17451 return _("NT_SIGINFO (siginfo_t data)");
17453 return _("NT_FILE (mapped files)");
17461 return _("NT_VERSION (version)");
17463 return _("NT_ARCH (architecture)");
17464 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17466 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17472 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17477 print_core_note (Elf_Internal_Note
*pnote
)
17479 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17480 bfd_vma count
, page_size
;
17481 unsigned char *descdata
, *filenames
, *descend
;
17483 if (pnote
->type
!= NT_FILE
)
17493 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17494 /* Still "successful". */
17499 if (pnote
->descsz
< 2 * addr_size
)
17501 error (_(" Malformed note - too short for header\n"));
17505 descdata
= (unsigned char *) pnote
->descdata
;
17506 descend
= descdata
+ pnote
->descsz
;
17508 if (descdata
[pnote
->descsz
- 1] != '\0')
17510 error (_(" Malformed note - does not end with \\0\n"));
17514 count
= byte_get (descdata
, addr_size
);
17515 descdata
+= addr_size
;
17517 page_size
= byte_get (descdata
, addr_size
);
17518 descdata
+= addr_size
;
17520 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17521 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17523 error (_(" Malformed note - too short for supplied file count\n"));
17527 printf (_(" Page size: "));
17528 print_vma (page_size
, DEC
);
17531 printf (_(" %*s%*s%*s\n"),
17532 (int) (2 + 2 * addr_size
), _("Start"),
17533 (int) (4 + 2 * addr_size
), _("End"),
17534 (int) (4 + 2 * addr_size
), _("Page Offset"));
17535 filenames
= descdata
+ count
* 3 * addr_size
;
17536 while (count
-- > 0)
17538 bfd_vma start
, end
, file_ofs
;
17540 if (filenames
== descend
)
17542 error (_(" Malformed note - filenames end too early\n"));
17546 start
= byte_get (descdata
, addr_size
);
17547 descdata
+= addr_size
;
17548 end
= byte_get (descdata
, addr_size
);
17549 descdata
+= addr_size
;
17550 file_ofs
= byte_get (descdata
, addr_size
);
17551 descdata
+= addr_size
;
17554 print_vma (start
, FULL_HEX
);
17556 print_vma (end
, FULL_HEX
);
17558 print_vma (file_ofs
, FULL_HEX
);
17559 printf ("\n %s\n", filenames
);
17561 filenames
+= 1 + strlen ((char *) filenames
);
17567 static const char *
17568 get_gnu_elf_note_type (unsigned e_type
)
17570 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17573 case NT_GNU_ABI_TAG
:
17574 return _("NT_GNU_ABI_TAG (ABI version tag)");
17576 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17577 case NT_GNU_BUILD_ID
:
17578 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17579 case NT_GNU_GOLD_VERSION
:
17580 return _("NT_GNU_GOLD_VERSION (gold version)");
17581 case NT_GNU_PROPERTY_TYPE_0
:
17582 return _("NT_GNU_PROPERTY_TYPE_0");
17583 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17584 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17585 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17586 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17589 static char buff
[64];
17591 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17598 decode_x86_compat_isa (unsigned int bitmask
)
17602 unsigned int bit
= bitmask
& (- bitmask
);
17607 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17610 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17613 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17616 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17619 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17622 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17625 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17628 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17631 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17634 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17637 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17640 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17641 printf ("AVX512F");
17643 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17644 printf ("AVX512CD");
17646 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17647 printf ("AVX512ER");
17649 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17650 printf ("AVX512PF");
17652 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17653 printf ("AVX512VL");
17655 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17656 printf ("AVX512DQ");
17658 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17659 printf ("AVX512BW");
17662 printf (_("<unknown: %x>"), bit
);
17671 decode_x86_isa (unsigned int bitmask
)
17675 printf (_("<None>"));
17681 unsigned int bit
= bitmask
& (- bitmask
);
17686 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17689 case GNU_PROPERTY_X86_ISA_1_SSE
:
17692 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17695 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17698 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17701 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17704 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17707 case GNU_PROPERTY_X86_ISA_1_AVX
:
17710 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17713 case GNU_PROPERTY_X86_ISA_1_FMA
:
17716 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17717 printf ("AVX512F");
17719 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17720 printf ("AVX512CD");
17722 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17723 printf ("AVX512ER");
17725 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17726 printf ("AVX512PF");
17728 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17729 printf ("AVX512VL");
17731 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17732 printf ("AVX512DQ");
17734 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17735 printf ("AVX512BW");
17737 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17738 printf ("AVX512_4FMAPS");
17740 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17741 printf ("AVX512_4VNNIW");
17743 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17744 printf ("AVX512_BITALG");
17746 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17747 printf ("AVX512_IFMA");
17749 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17750 printf ("AVX512_VBMI");
17752 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17753 printf ("AVX512_VBMI2");
17755 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17756 printf ("AVX512_VNNI");
17758 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17759 printf ("AVX512_BF16");
17762 printf (_("<unknown: %x>"), bit
);
17771 decode_x86_feature_1 (unsigned int bitmask
)
17775 printf (_("<None>"));
17781 unsigned int bit
= bitmask
& (- bitmask
);
17786 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17789 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17793 printf (_("<unknown: %x>"), bit
);
17802 decode_x86_feature_2 (unsigned int bitmask
)
17806 printf (_("<None>"));
17812 unsigned int bit
= bitmask
& (- bitmask
);
17817 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17820 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17823 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17826 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17829 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17832 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17835 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17838 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17841 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17842 printf ("XSAVEOPT");
17844 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17848 printf (_("<unknown: %x>"), bit
);
17857 decode_aarch64_feature_1_and (unsigned int bitmask
)
17861 unsigned int bit
= bitmask
& (- bitmask
);
17866 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17870 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17875 printf (_("<unknown: %x>"), bit
);
17884 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17886 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17887 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17888 unsigned int size
= is_32bit_elf
? 4 : 8;
17890 printf (_(" Properties: "));
17892 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17894 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17898 while (ptr
< ptr_end
)
17902 unsigned int datasz
;
17904 if ((size_t) (ptr_end
- ptr
) < 8)
17906 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17910 type
= byte_get (ptr
, 4);
17911 datasz
= byte_get (ptr
+ 4, 4);
17915 if (datasz
> (size_t) (ptr_end
- ptr
))
17917 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17922 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17924 if (filedata
->file_header
.e_machine
== EM_X86_64
17925 || filedata
->file_header
.e_machine
== EM_IAMCU
17926 || filedata
->file_header
.e_machine
== EM_386
)
17928 unsigned int bitmask
;
17931 bitmask
= byte_get (ptr
, 4);
17937 case GNU_PROPERTY_X86_ISA_1_USED
:
17939 printf (_("x86 ISA used: <corrupt length: %#x> "),
17943 printf ("x86 ISA used: ");
17944 decode_x86_isa (bitmask
);
17948 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17950 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17954 printf ("x86 ISA needed: ");
17955 decode_x86_isa (bitmask
);
17959 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17961 printf (_("x86 feature: <corrupt length: %#x> "),
17965 printf ("x86 feature: ");
17966 decode_x86_feature_1 (bitmask
);
17970 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17972 printf (_("x86 feature used: <corrupt length: %#x> "),
17976 printf ("x86 feature used: ");
17977 decode_x86_feature_2 (bitmask
);
17981 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17983 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17986 printf ("x86 feature needed: ");
17987 decode_x86_feature_2 (bitmask
);
17991 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17993 printf (_("x86 ISA used: <corrupt length: %#x> "),
17997 printf ("x86 ISA used: ");
17998 decode_x86_compat_isa (bitmask
);
18002 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18004 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18008 printf ("x86 ISA needed: ");
18009 decode_x86_compat_isa (bitmask
);
18017 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18019 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18021 printf ("AArch64 feature: ");
18023 printf (_("<corrupt length: %#x> "), datasz
);
18025 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18034 case GNU_PROPERTY_STACK_SIZE
:
18035 printf (_("stack size: "));
18036 if (datasz
!= size
)
18037 printf (_("<corrupt length: %#x> "), datasz
);
18039 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
18042 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
18043 printf ("no copy on protected ");
18045 printf (_("<corrupt length: %#x> "), datasz
);
18053 if (type
< GNU_PROPERTY_LOPROC
)
18054 printf (_("<unknown type %#x data: "), type
);
18055 else if (type
< GNU_PROPERTY_LOUSER
)
18056 printf (_("<procesor-specific type %#x data: "), type
);
18058 printf (_("<application-specific type %#x data: "), type
);
18059 for (j
= 0; j
< datasz
; ++j
)
18060 printf ("%02x ", ptr
[j
] & 0xff);
18064 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
18065 if (ptr
== ptr_end
)
18078 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
18080 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18081 switch (pnote
->type
)
18083 case NT_GNU_BUILD_ID
:
18087 printf (_(" Build ID: "));
18088 for (i
= 0; i
< pnote
->descsz
; ++i
)
18089 printf ("%02x", pnote
->descdata
[i
] & 0xff);
18094 case NT_GNU_ABI_TAG
:
18096 unsigned long os
, major
, minor
, subminor
;
18097 const char *osname
;
18099 /* PR 17531: file: 030-599401-0.004. */
18100 if (pnote
->descsz
< 16)
18102 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18106 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18107 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18108 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
18109 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
18113 case GNU_ABI_TAG_LINUX
:
18116 case GNU_ABI_TAG_HURD
:
18119 case GNU_ABI_TAG_SOLARIS
:
18120 osname
= "Solaris";
18122 case GNU_ABI_TAG_FREEBSD
:
18123 osname
= "FreeBSD";
18125 case GNU_ABI_TAG_NETBSD
:
18128 case GNU_ABI_TAG_SYLLABLE
:
18129 osname
= "Syllable";
18131 case GNU_ABI_TAG_NACL
:
18135 osname
= "Unknown";
18139 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
18140 major
, minor
, subminor
);
18144 case NT_GNU_GOLD_VERSION
:
18148 printf (_(" Version: "));
18149 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
18150 printf ("%c", pnote
->descdata
[i
]);
18157 unsigned long num_entries
, mask
;
18159 /* Hardware capabilities information. Word 0 is the number of entries.
18160 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18161 is a series of entries, where each entry is a single byte followed
18162 by a nul terminated string. The byte gives the bit number to test
18163 if enabled in the bitmask. */
18164 printf (_(" Hardware Capabilities: "));
18165 if (pnote
->descsz
< 8)
18167 error (_("<corrupt GNU_HWCAP>\n"));
18170 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18171 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18172 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
18173 /* FIXME: Add code to display the entries... */
18177 case NT_GNU_PROPERTY_TYPE_0
:
18178 print_gnu_property_note (filedata
, pnote
);
18182 /* Handle unrecognised types. An error message should have already been
18183 created by get_gnu_elf_note_type(), so all that we need to do is to
18184 display the data. */
18188 printf (_(" Description data: "));
18189 for (i
= 0; i
< pnote
->descsz
; ++i
)
18190 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
18199 static const char *
18200 get_v850_elf_note_type (enum v850_notes n_type
)
18202 static char buff
[64];
18206 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
18207 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
18208 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18209 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18210 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18211 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18213 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18219 print_v850_note (Elf_Internal_Note
* pnote
)
18223 if (pnote
->descsz
!= 4)
18226 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18230 printf (_("not set\n"));
18234 switch (pnote
->type
)
18236 case V850_NOTE_ALIGNMENT
:
18239 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18240 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18244 case V850_NOTE_DATA_SIZE
:
18247 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18248 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18252 case V850_NOTE_FPU_INFO
:
18255 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18256 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18260 case V850_NOTE_MMU_INFO
:
18261 case V850_NOTE_CACHE_INFO
:
18262 case V850_NOTE_SIMD_INFO
:
18263 if (val
== EF_RH850_SIMD
)
18265 printf (_("yes\n"));
18271 /* An 'unknown note type' message will already have been displayed. */
18275 printf (_("unknown value: %x\n"), val
);
18280 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18282 unsigned int version
;
18284 switch (pnote
->type
)
18286 case NT_NETBSD_IDENT
:
18287 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18288 if ((version
/ 10000) % 100)
18289 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18290 version
, version
/ 100000000, (version
/ 1000000) % 100,
18291 (version
/ 10000) % 100 > 26 ? "Z" : "",
18292 'A' + (version
/ 10000) % 26);
18294 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18295 version
, version
/ 100000000, (version
/ 1000000) % 100,
18296 (version
/ 100) % 100);
18299 case NT_NETBSD_MARCH
:
18300 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18304 #ifdef NT_NETBSD_PAX
18305 case NT_NETBSD_PAX
:
18306 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18307 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18308 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18309 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18310 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18311 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18312 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18313 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18318 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
18324 static const char *
18325 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18329 case NT_FREEBSD_THRMISC
:
18330 return _("NT_THRMISC (thrmisc structure)");
18331 case NT_FREEBSD_PROCSTAT_PROC
:
18332 return _("NT_PROCSTAT_PROC (proc data)");
18333 case NT_FREEBSD_PROCSTAT_FILES
:
18334 return _("NT_PROCSTAT_FILES (files data)");
18335 case NT_FREEBSD_PROCSTAT_VMMAP
:
18336 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18337 case NT_FREEBSD_PROCSTAT_GROUPS
:
18338 return _("NT_PROCSTAT_GROUPS (groups data)");
18339 case NT_FREEBSD_PROCSTAT_UMASK
:
18340 return _("NT_PROCSTAT_UMASK (umask data)");
18341 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18342 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18343 case NT_FREEBSD_PROCSTAT_OSREL
:
18344 return _("NT_PROCSTAT_OSREL (osreldate data)");
18345 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18346 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18347 case NT_FREEBSD_PROCSTAT_AUXV
:
18348 return _("NT_PROCSTAT_AUXV (auxv data)");
18349 case NT_FREEBSD_PTLWPINFO
:
18350 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18352 return get_note_type (filedata
, e_type
);
18355 static const char *
18356 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18358 static char buff
[64];
18362 case NT_NETBSDCORE_PROCINFO
:
18363 /* NetBSD core "procinfo" structure. */
18364 return _("NetBSD procinfo structure");
18366 #ifdef NT_NETBSDCORE_AUXV
18367 case NT_NETBSDCORE_AUXV
:
18368 return _("NetBSD ELF auxiliary vector data");
18372 /* As of Jan 2002 there are no other machine-independent notes
18373 defined for NetBSD core files. If the note type is less
18374 than the start of the machine-dependent note types, we don't
18377 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18379 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18385 switch (filedata
->file_header
.e_machine
)
18387 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18388 and PT_GETFPREGS == mach+2. */
18393 case EM_SPARC32PLUS
:
18397 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18398 return _("PT_GETREGS (reg structure)");
18399 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18400 return _("PT_GETFPREGS (fpreg structure)");
18406 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18407 There's also old PT___GETREGS40 == mach + 1 for old reg
18408 structure which lacks GBR. */
18412 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18413 return _("PT___GETREGS40 (old reg structure)");
18414 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18415 return _("PT_GETREGS (reg structure)");
18416 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18417 return _("PT_GETFPREGS (fpreg structure)");
18423 /* On all other arch's, PT_GETREGS == mach+1 and
18424 PT_GETFPREGS == mach+3. */
18428 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18429 return _("PT_GETREGS (reg structure)");
18430 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18431 return _("PT_GETFPREGS (fpreg structure)");
18437 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18438 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18442 static const char *
18443 get_stapsdt_note_type (unsigned e_type
)
18445 static char buff
[64];
18450 return _("NT_STAPSDT (SystemTap probe descriptors)");
18456 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18461 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18463 size_t len
, maxlen
;
18464 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18465 char *data
= pnote
->descdata
;
18466 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18467 bfd_vma pc
, base_addr
, semaphore
;
18468 char *provider
, *probe
, *arg_fmt
;
18470 if (pnote
->descsz
< (addr_size
* 3))
18471 goto stapdt_note_too_small
;
18473 pc
= byte_get ((unsigned char *) data
, addr_size
);
18476 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18479 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18482 if (data
>= data_end
)
18483 goto stapdt_note_too_small
;
18484 maxlen
= data_end
- data
;
18485 len
= strnlen (data
, maxlen
);
18492 goto stapdt_note_too_small
;
18494 if (data
>= data_end
)
18495 goto stapdt_note_too_small
;
18496 maxlen
= data_end
- data
;
18497 len
= strnlen (data
, maxlen
);
18504 goto stapdt_note_too_small
;
18506 if (data
>= data_end
)
18507 goto stapdt_note_too_small
;
18508 maxlen
= data_end
- data
;
18509 len
= strnlen (data
, maxlen
);
18516 goto stapdt_note_too_small
;
18518 printf (_(" Provider: %s\n"), provider
);
18519 printf (_(" Name: %s\n"), probe
);
18520 printf (_(" Location: "));
18521 print_vma (pc
, FULL_HEX
);
18522 printf (_(", Base: "));
18523 print_vma (base_addr
, FULL_HEX
);
18524 printf (_(", Semaphore: "));
18525 print_vma (semaphore
, FULL_HEX
);
18527 printf (_(" Arguments: %s\n"), arg_fmt
);
18529 return data
== data_end
;
18531 stapdt_note_too_small
:
18532 printf (_(" <corrupt - note is too small>\n"));
18533 error (_("corrupt stapdt note - the data size is too small\n"));
18537 static const char *
18538 get_ia64_vms_note_type (unsigned e_type
)
18540 static char buff
[64];
18545 return _("NT_VMS_MHD (module header)");
18547 return _("NT_VMS_LNM (language name)");
18549 return _("NT_VMS_SRC (source files)");
18551 return "NT_VMS_TITLE";
18553 return _("NT_VMS_EIDC (consistency check)");
18554 case NT_VMS_FPMODE
:
18555 return _("NT_VMS_FPMODE (FP mode)");
18556 case NT_VMS_LINKTIME
:
18557 return "NT_VMS_LINKTIME";
18558 case NT_VMS_IMGNAM
:
18559 return _("NT_VMS_IMGNAM (image name)");
18561 return _("NT_VMS_IMGID (image id)");
18562 case NT_VMS_LINKID
:
18563 return _("NT_VMS_LINKID (link id)");
18564 case NT_VMS_IMGBID
:
18565 return _("NT_VMS_IMGBID (build id)");
18566 case NT_VMS_GSTNAM
:
18567 return _("NT_VMS_GSTNAM (sym table name)");
18568 case NT_VMS_ORIG_DYN
:
18569 return "NT_VMS_ORIG_DYN";
18570 case NT_VMS_PATCHTIME
:
18571 return "NT_VMS_PATCHTIME";
18573 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18579 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18581 int maxlen
= pnote
->descsz
;
18583 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18584 goto desc_size_fail
;
18586 switch (pnote
->type
)
18590 goto desc_size_fail
;
18592 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18594 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18595 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18596 if (l
+ 34 < maxlen
)
18598 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18599 if (l
+ 35 < maxlen
)
18600 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18602 printf (_(" Module version : <missing>\n"));
18606 printf (_(" Module name : <missing>\n"));
18607 printf (_(" Module version : <missing>\n"));
18612 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18616 case NT_VMS_FPMODE
:
18617 printf (_(" Floating Point mode: "));
18619 goto desc_size_fail
;
18620 /* FIXME: Generate an error if descsz > 8 ? */
18622 printf ("0x%016" BFD_VMA_FMT
"x\n",
18623 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18626 case NT_VMS_LINKTIME
:
18627 printf (_(" Link time: "));
18629 goto desc_size_fail
;
18630 /* FIXME: Generate an error if descsz > 8 ? */
18633 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18637 case NT_VMS_PATCHTIME
:
18638 printf (_(" Patch time: "));
18640 goto desc_size_fail
;
18641 /* FIXME: Generate an error if descsz > 8 ? */
18644 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18648 case NT_VMS_ORIG_DYN
:
18650 goto desc_size_fail
;
18652 printf (_(" Major id: %u, minor id: %u\n"),
18653 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18654 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18655 printf (_(" Last modified : "));
18657 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18658 printf (_("\n Link flags : "));
18659 printf ("0x%016" BFD_VMA_FMT
"x\n",
18660 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18661 printf (_(" Header flags: 0x%08x\n"),
18662 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18663 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18667 case NT_VMS_IMGNAM
:
18668 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18671 case NT_VMS_GSTNAM
:
18672 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18676 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18679 case NT_VMS_LINKID
:
18680 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18690 printf (_(" <corrupt - data size is too small>\n"));
18691 error (_("corrupt IA64 note: data size is too small\n"));
18695 /* Find the symbol associated with a build attribute that is attached
18696 to address OFFSET. If PNAME is non-NULL then store the name of
18697 the symbol (if found) in the provided pointer, Returns NULL if a
18698 symbol could not be found. */
18700 static Elf_Internal_Sym
*
18701 get_symbol_for_build_attribute (Filedata
* filedata
,
18702 unsigned long offset
,
18703 bfd_boolean is_open_attr
,
18704 const char ** pname
)
18706 static Filedata
* saved_filedata
= NULL
;
18707 static char * strtab
;
18708 static unsigned long strtablen
;
18709 static Elf_Internal_Sym
* symtab
;
18710 static unsigned long nsyms
;
18711 Elf_Internal_Sym
* saved_sym
= NULL
;
18712 Elf_Internal_Sym
* sym
;
18714 if (filedata
->section_headers
!= NULL
18715 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
18717 Elf_Internal_Shdr
* symsec
;
18719 /* Load the symbol and string sections. */
18720 for (symsec
= filedata
->section_headers
;
18721 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18724 if (symsec
->sh_type
== SHT_SYMTAB
)
18726 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
18728 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18730 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
18732 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18733 1, strtab_sec
->sh_size
,
18734 _("string table"));
18735 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
18739 saved_filedata
= filedata
;
18742 if (symtab
== NULL
|| strtab
== NULL
)
18745 /* Find a symbol whose value matches offset. */
18746 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
18747 if (sym
->st_value
== offset
)
18749 if (sym
->st_name
>= strtablen
)
18750 /* Huh ? This should not happen. */
18753 if (strtab
[sym
->st_name
] == 0)
18756 /* The AArch64 and ARM architectures define mapping symbols
18757 (eg $d, $x, $t) which we want to ignore. */
18758 if (strtab
[sym
->st_name
] == '$'
18759 && strtab
[sym
->st_name
+ 1] != 0
18760 && strtab
[sym
->st_name
+ 2] == 0)
18765 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18766 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18767 FUNC symbols entirely. */
18768 switch (ELF_ST_TYPE (sym
->st_info
))
18775 /* If the symbol has a size associated
18776 with it then we can stop searching. */
18777 sym
= symtab
+ nsyms
;
18782 /* Ignore function symbols. */
18789 switch (ELF_ST_BIND (sym
->st_info
))
18792 if (saved_sym
== NULL
18793 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18798 if (saved_sym
== NULL
)
18808 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18816 if (saved_sym
&& pname
)
18817 * pname
= strtab
+ saved_sym
->st_name
;
18822 /* Returns true iff addr1 and addr2 are in the same section. */
18825 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18827 Elf_Internal_Shdr
* a1
;
18828 Elf_Internal_Shdr
* a2
;
18830 a1
= find_section_by_address (filedata
, addr1
);
18831 a2
= find_section_by_address (filedata
, addr2
);
18833 return a1
== a2
&& a1
!= NULL
;
18837 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18838 Filedata
* filedata
)
18840 static unsigned long global_offset
= 0;
18841 static unsigned long global_end
= 0;
18842 static unsigned long func_offset
= 0;
18843 static unsigned long func_end
= 0;
18845 Elf_Internal_Sym
* sym
;
18847 unsigned long start
;
18849 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18851 switch (pnote
->descsz
)
18854 /* A zero-length description means that the range of
18855 the previous note of the same type should be used. */
18858 if (global_end
> global_offset
)
18859 printf (_(" Applies to region from %#lx to %#lx\n"),
18860 global_offset
, global_end
);
18862 printf (_(" Applies to region from %#lx\n"), global_offset
);
18866 if (func_end
> func_offset
)
18867 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18869 printf (_(" Applies to region from %#lx\n"), func_offset
);
18874 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18881 /* FIXME: We should check that version 3+ notes are being used here... */
18882 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18883 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18887 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18893 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18894 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18898 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18899 printf (_(" <invalid descsz>"));
18904 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18905 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18906 in order to avoid them being confused with the start address of the
18907 first function in the file... */
18908 if (sym
== NULL
&& is_open_attr
)
18909 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18912 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18913 end
= start
+ sym
->st_size
;
18917 /* FIXME: Need to properly allow for section alignment.
18918 16 is just the alignment used on x86_64. */
18920 && start
> BFD_ALIGN (global_end
, 16)
18921 /* Build notes are not guaranteed to be organised in order of
18922 increasing address, but we should find the all of the notes
18923 for one section in the same place. */
18924 && same_section (filedata
, start
, global_end
))
18925 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18926 global_end
+ 1, start
- 1);
18928 printf (_(" Applies to region from %#lx"), start
);
18929 global_offset
= start
;
18933 printf (_(" to %#lx"), end
);
18939 printf (_(" Applies to region from %#lx"), start
);
18940 func_offset
= start
;
18944 printf (_(" to %#lx"), end
);
18950 printf (_(" (%s)"), name
);
18957 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18959 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18960 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18961 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18963 char name_attribute
;
18964 const char * expected_types
;
18965 const char * name
= pnote
->namedata
;
18969 if (name
== NULL
|| pnote
->namesz
< 2)
18971 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18972 print_symbol (-20, _(" <corrupt name>"));
18981 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18982 if (name
[0] == 'G' && name
[1] == 'A')
18984 if (pnote
->namesz
< 4)
18986 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18987 print_symbol (-20, _(" <corrupt name>"));
18996 switch ((name_type
= * name
))
18998 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18999 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19000 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19001 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19002 printf ("%c", * name
);
19006 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19007 print_symbol (-20, _("<unknown name type>"));
19014 switch ((name_attribute
= * name
))
19016 case GNU_BUILD_ATTRIBUTE_VERSION
:
19017 text
= _("<version>");
19018 expected_types
= string_expected
;
19021 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19022 text
= _("<stack prot>");
19023 expected_types
= "!+*";
19026 case GNU_BUILD_ATTRIBUTE_RELRO
:
19027 text
= _("<relro>");
19028 expected_types
= bool_expected
;
19031 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
19032 text
= _("<stack size>");
19033 expected_types
= number_expected
;
19036 case GNU_BUILD_ATTRIBUTE_TOOL
:
19037 text
= _("<tool>");
19038 expected_types
= string_expected
;
19041 case GNU_BUILD_ATTRIBUTE_ABI
:
19043 expected_types
= "$*";
19046 case GNU_BUILD_ATTRIBUTE_PIC
:
19048 expected_types
= number_expected
;
19051 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
19052 text
= _("<short enum>");
19053 expected_types
= bool_expected
;
19057 if (ISPRINT (* name
))
19059 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
19061 if (len
> left
&& ! do_wide
)
19063 printf ("%.*s:", len
, name
);
19069 static char tmpbuf
[128];
19071 error (_("unrecognised byte in name field: %d\n"), * name
);
19072 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
19076 expected_types
= "*$!+";
19081 left
-= printf ("%s", text
);
19083 if (strchr (expected_types
, name_type
) == NULL
)
19084 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
19086 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
19088 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19089 (unsigned long) pnote
->namesz
,
19090 (long) (name
- pnote
->namedata
));
19094 if (left
< 1 && ! do_wide
)
19099 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19101 unsigned int bytes
;
19102 unsigned long long val
= 0;
19103 unsigned int shift
= 0;
19104 char * decoded
= NULL
;
19106 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
19108 /* The -1 is because the name field is always 0 terminated, and we
19109 want to be able to ensure that the shift in the while loop below
19110 will not overflow. */
19113 if (bytes
> sizeof (val
))
19115 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19117 bytes
= sizeof (val
);
19119 /* We do not bother to warn if bytes == 0 as this can
19120 happen with some early versions of the gcc plugin. */
19124 unsigned long byte
= (* name
++) & 0xff;
19126 val
|= byte
<< shift
;
19130 switch (name_attribute
)
19132 case GNU_BUILD_ATTRIBUTE_PIC
:
19135 case 0: decoded
= "static"; break;
19136 case 1: decoded
= "pic"; break;
19137 case 2: decoded
= "PIC"; break;
19138 case 3: decoded
= "pie"; break;
19139 case 4: decoded
= "PIE"; break;
19143 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19146 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19147 case 0: decoded
= "off"; break;
19148 case 1: decoded
= "on"; break;
19149 case 2: decoded
= "all"; break;
19150 case 3: decoded
= "strong"; break;
19151 case 4: decoded
= "explicit"; break;
19159 if (decoded
!= NULL
)
19161 print_symbol (-left
, decoded
);
19172 left
-= printf ("0x%llx", val
);
19174 left
-= printf ("0x%-.*llx", left
, val
);
19178 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19179 left
-= print_symbol (- left
, name
);
19181 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19182 left
-= print_symbol (- left
, "true");
19184 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19185 left
-= print_symbol (- left
, "false");
19189 if (do_wide
&& left
> 0)
19190 printf ("%-*s", left
, " ");
19195 /* Note that by the ELF standard, the name field is already null byte
19196 terminated, and namesz includes the terminating null byte.
19197 I.E. the value of namesz for the name "FSF" is 4.
19199 If the value of namesz is zero, there is no name present. */
19202 process_note (Elf_Internal_Note
* pnote
,
19203 Filedata
* filedata
)
19205 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
19208 if (pnote
->namesz
== 0)
19209 /* If there is no note name, then use the default set of
19210 note type strings. */
19211 nt
= get_note_type (filedata
, pnote
->type
);
19213 else if (const_strneq (pnote
->namedata
, "GNU"))
19214 /* GNU-specific object file notes. */
19215 nt
= get_gnu_elf_note_type (pnote
->type
);
19217 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19218 /* FreeBSD-specific core file notes. */
19219 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19221 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19222 /* NetBSD-specific core file notes. */
19223 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19225 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19226 /* NetBSD-specific core file notes. */
19227 return process_netbsd_elf_note (pnote
);
19229 else if (const_strneq (pnote
->namedata
, "PaX"))
19230 /* NetBSD-specific core file notes. */
19231 return process_netbsd_elf_note (pnote
);
19233 else if (strneq (pnote
->namedata
, "SPU/", 4))
19235 /* SPU-specific core file notes. */
19236 nt
= pnote
->namedata
+ 4;
19240 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19241 /* VMS/ia64-specific file notes. */
19242 nt
= get_ia64_vms_note_type (pnote
->type
);
19244 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19245 nt
= get_stapsdt_note_type (pnote
->type
);
19248 /* Don't recognize this note name; just use the default set of
19249 note type strings. */
19250 nt
= get_note_type (filedata
, pnote
->type
);
19254 if (((const_strneq (pnote
->namedata
, "GA")
19255 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19256 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19257 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19258 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19259 print_gnu_build_attribute_name (pnote
);
19261 print_symbol (-20, name
);
19264 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19266 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19268 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19269 return print_ia64_vms_note (pnote
);
19270 else if (const_strneq (pnote
->namedata
, "GNU"))
19271 return print_gnu_note (filedata
, pnote
);
19272 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19273 return print_stapsdt_note (pnote
);
19274 else if (const_strneq (pnote
->namedata
, "CORE"))
19275 return print_core_note (pnote
);
19276 else if (((const_strneq (pnote
->namedata
, "GA")
19277 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19278 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19279 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19280 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19281 return print_gnu_build_attribute_description (pnote
, filedata
);
19287 printf (_(" description data: "));
19288 for (i
= 0; i
< pnote
->descsz
; i
++)
19289 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19301 process_notes_at (Filedata
* filedata
,
19302 Elf_Internal_Shdr
* section
,
19307 Elf_External_Note
* pnotes
;
19308 Elf_External_Note
* external
;
19310 bfd_boolean res
= TRUE
;
19317 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19320 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19325 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19328 if (pnotes
== NULL
)
19334 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19336 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19337 (unsigned long) offset
, (unsigned long) length
);
19339 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19340 specifies that notes should be aligned to 4 bytes in 32-bit
19341 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19342 we also support 4 byte alignment in 64-bit objects. If section
19343 alignment is less than 4, we treate alignment as 4 bytes. */
19346 else if (align
!= 4 && align
!= 8)
19348 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19354 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19356 end
= (char *) pnotes
+ length
;
19357 while ((char *) external
< end
)
19359 Elf_Internal_Note inote
;
19362 char * temp
= NULL
;
19363 size_t data_remaining
= end
- (char *) external
;
19365 if (!is_ia64_vms (filedata
))
19367 /* PR binutils/15191
19368 Make sure that there is enough data to read. */
19369 min_notesz
= offsetof (Elf_External_Note
, name
);
19370 if (data_remaining
< min_notesz
)
19372 warn (ngettext ("Corrupt note: only %ld byte remains, "
19373 "not enough for a full note\n",
19374 "Corrupt note: only %ld bytes remain, "
19375 "not enough for a full note\n",
19377 (long) data_remaining
);
19380 data_remaining
-= min_notesz
;
19382 inote
.type
= BYTE_GET (external
->type
);
19383 inote
.namesz
= BYTE_GET (external
->namesz
);
19384 inote
.namedata
= external
->name
;
19385 inote
.descsz
= BYTE_GET (external
->descsz
);
19386 inote
.descdata
= ((char *) external
19387 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19388 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19389 next
= ((char *) external
19390 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19394 Elf64_External_VMS_Note
*vms_external
;
19396 /* PR binutils/15191
19397 Make sure that there is enough data to read. */
19398 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19399 if (data_remaining
< min_notesz
)
19401 warn (ngettext ("Corrupt note: only %ld byte remains, "
19402 "not enough for a full note\n",
19403 "Corrupt note: only %ld bytes remain, "
19404 "not enough for a full note\n",
19406 (long) data_remaining
);
19409 data_remaining
-= min_notesz
;
19411 vms_external
= (Elf64_External_VMS_Note
*) external
;
19412 inote
.type
= BYTE_GET (vms_external
->type
);
19413 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19414 inote
.namedata
= vms_external
->name
;
19415 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19416 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19417 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19418 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19421 /* PR 17531: file: 3443835e. */
19422 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19423 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19424 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19425 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19426 || ((size_t) (next
- inote
.descdata
)
19427 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19429 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19430 (unsigned long) ((char *) external
- (char *) pnotes
));
19431 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19432 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19436 external
= (Elf_External_Note
*) next
;
19438 /* Verify that name is null terminated. It appears that at least
19439 one version of Linux (RedHat 6.0) generates corefiles that don't
19440 comply with the ELF spec by failing to include the null byte in
19442 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19444 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19446 temp
= (char *) malloc (inote
.namesz
+ 1);
19449 error (_("Out of memory allocating space for inote name\n"));
19454 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19455 inote
.namedata
= temp
;
19457 inote
.namedata
[inote
.namesz
] = 0;
19460 if (! process_note (& inote
, filedata
))
19476 process_corefile_note_segments (Filedata
* filedata
)
19478 Elf_Internal_Phdr
* segment
;
19480 bfd_boolean res
= TRUE
;
19482 if (! get_program_headers (filedata
))
19485 for (i
= 0, segment
= filedata
->program_headers
;
19486 i
< filedata
->file_header
.e_phnum
;
19489 if (segment
->p_type
== PT_NOTE
)
19490 if (! process_notes_at (filedata
, NULL
,
19491 (bfd_vma
) segment
->p_offset
,
19492 (bfd_vma
) segment
->p_filesz
,
19493 (bfd_vma
) segment
->p_align
))
19501 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19503 Elf_External_Note
* pnotes
;
19504 Elf_External_Note
* external
;
19506 bfd_boolean res
= TRUE
;
19511 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19513 if (pnotes
== NULL
)
19517 end
= (char*) pnotes
+ length
;
19519 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19520 (unsigned long) offset
, (unsigned long) length
);
19522 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19524 Elf_External_Note
* next
;
19525 Elf_Internal_Note inote
;
19527 inote
.type
= BYTE_GET (external
->type
);
19528 inote
.namesz
= BYTE_GET (external
->namesz
);
19529 inote
.namedata
= external
->name
;
19530 inote
.descsz
= BYTE_GET (external
->descsz
);
19531 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19532 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19534 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19536 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19537 inote
.descdata
= inote
.namedata
;
19541 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19543 if ( ((char *) next
> end
)
19544 || ((char *) next
< (char *) pnotes
))
19546 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19547 (unsigned long) ((char *) external
- (char *) pnotes
));
19548 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19549 inote
.type
, inote
.namesz
, inote
.descsz
);
19555 /* Prevent out-of-bounds indexing. */
19556 if ( inote
.namedata
+ inote
.namesz
> end
19557 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19559 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19560 (unsigned long) ((char *) external
- (char *) pnotes
));
19561 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19562 inote
.type
, inote
.namesz
, inote
.descsz
);
19566 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19568 if (! print_v850_note (& inote
))
19571 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19572 inote
.namesz
, inote
.descsz
);
19582 process_note_sections (Filedata
* filedata
)
19584 Elf_Internal_Shdr
* section
;
19586 unsigned int n
= 0;
19587 bfd_boolean res
= TRUE
;
19589 for (i
= 0, section
= filedata
->section_headers
;
19590 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19593 if (section
->sh_type
== SHT_NOTE
)
19595 if (! process_notes_at (filedata
, section
,
19596 (bfd_vma
) section
->sh_offset
,
19597 (bfd_vma
) section
->sh_size
,
19598 (bfd_vma
) section
->sh_addralign
))
19603 if (( filedata
->file_header
.e_machine
== EM_V800
19604 || filedata
->file_header
.e_machine
== EM_V850
19605 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19606 && section
->sh_type
== SHT_RENESAS_INFO
)
19608 if (! process_v850_notes (filedata
,
19609 (bfd_vma
) section
->sh_offset
,
19610 (bfd_vma
) section
->sh_size
))
19617 /* Try processing NOTE segments instead. */
19618 return process_corefile_note_segments (filedata
);
19624 process_notes (Filedata
* filedata
)
19626 /* If we have not been asked to display the notes then do nothing. */
19630 if (filedata
->file_header
.e_type
!= ET_CORE
)
19631 return process_note_sections (filedata
);
19633 /* No program headers means no NOTE segment. */
19634 if (filedata
->file_header
.e_phnum
> 0)
19635 return process_corefile_note_segments (filedata
);
19637 printf (_("No note segments present in the core file.\n"));
19641 static unsigned char *
19642 display_public_gnu_attributes (unsigned char * start
,
19643 const unsigned char * const end
)
19645 printf (_(" Unknown GNU attribute: %s\n"), start
);
19647 start
+= strnlen ((char *) start
, end
- start
);
19648 display_raw_attribute (start
, end
);
19650 return (unsigned char *) end
;
19653 static unsigned char *
19654 display_generic_attribute (unsigned char * start
,
19656 const unsigned char * const end
)
19659 return (unsigned char *) end
;
19661 return display_tag_value (tag
, start
, end
);
19665 process_arch_specific (Filedata
* filedata
)
19670 switch (filedata
->file_header
.e_machine
)
19673 case EM_ARC_COMPACT
:
19674 case EM_ARC_COMPACT2
:
19675 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19676 display_arc_attribute
,
19677 display_generic_attribute
);
19679 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19680 display_arm_attribute
,
19681 display_generic_attribute
);
19684 case EM_MIPS_RS3_LE
:
19685 return process_mips_specific (filedata
);
19688 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19689 display_msp430x_attribute
,
19690 display_msp430_gnu_attribute
);
19693 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19694 display_riscv_attribute
,
19695 display_generic_attribute
);
19698 return process_nds32_specific (filedata
);
19702 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19703 display_power_gnu_attribute
);
19707 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19708 display_s390_gnu_attribute
);
19711 case EM_SPARC32PLUS
:
19713 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19714 display_sparc_gnu_attribute
);
19717 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19718 display_tic6x_attribute
,
19719 display_generic_attribute
);
19722 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19723 display_public_gnu_attributes
,
19724 display_generic_attribute
);
19729 get_file_header (Filedata
* filedata
)
19731 /* Read in the identity array. */
19732 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19735 /* Determine how to read the rest of the header. */
19736 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19741 byte_get
= byte_get_little_endian
;
19742 byte_put
= byte_put_little_endian
;
19745 byte_get
= byte_get_big_endian
;
19746 byte_put
= byte_put_big_endian
;
19750 /* For now we only support 32 bit and 64 bit ELF files. */
19751 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19753 /* Read in the rest of the header. */
19756 Elf32_External_Ehdr ehdr32
;
19758 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19761 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19762 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19763 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19764 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19765 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19766 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19767 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19768 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19769 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19770 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19771 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19772 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19773 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19777 Elf64_External_Ehdr ehdr64
;
19779 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19780 we will not be able to cope with the 64bit data found in
19781 64 ELF files. Detect this now and abort before we start
19782 overwriting things. */
19783 if (sizeof (bfd_vma
) < 8)
19785 error (_("This instance of readelf has been built without support for a\n\
19786 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19790 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19793 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19794 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19795 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19796 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19797 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19798 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19799 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19800 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19801 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19802 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19803 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19804 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19805 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19808 if (filedata
->file_header
.e_shoff
)
19810 /* There may be some extensions in the first section header. Don't
19811 bomb if we can't read it. */
19813 get_32bit_section_headers (filedata
, TRUE
);
19815 get_64bit_section_headers (filedata
, TRUE
);
19822 close_file (Filedata
* filedata
)
19826 if (filedata
->handle
)
19827 fclose (filedata
->handle
);
19833 close_debug_file (void * data
)
19835 close_file ((Filedata
*) data
);
19839 open_file (const char * pathname
)
19841 struct stat statbuf
;
19842 Filedata
* filedata
= NULL
;
19844 if (stat (pathname
, & statbuf
) < 0
19845 || ! S_ISREG (statbuf
.st_mode
))
19848 filedata
= calloc (1, sizeof * filedata
);
19849 if (filedata
== NULL
)
19852 filedata
->handle
= fopen (pathname
, "rb");
19853 if (filedata
->handle
== NULL
)
19856 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19857 filedata
->file_name
= pathname
;
19859 if (! get_file_header (filedata
))
19862 if (filedata
->file_header
.e_shoff
)
19866 /* Read the section headers again, this time for real. */
19868 res
= get_32bit_section_headers (filedata
, FALSE
);
19870 res
= get_64bit_section_headers (filedata
, FALSE
);
19881 if (filedata
->handle
)
19882 fclose (filedata
->handle
);
19889 open_debug_file (const char * pathname
)
19891 return open_file (pathname
);
19894 /* Process one ELF object file according to the command line options.
19895 This file may actually be stored in an archive. The file is
19896 positioned at the start of the ELF object. Returns TRUE if no
19897 problems were encountered, FALSE otherwise. */
19900 process_object (Filedata
* filedata
)
19902 bfd_boolean have_separate_files
;
19904 bfd_boolean res
= TRUE
;
19906 if (! get_file_header (filedata
))
19908 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19912 /* Initialise per file variables. */
19913 for (i
= ARRAY_SIZE (version_info
); i
--;)
19914 version_info
[i
] = 0;
19916 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19917 dynamic_info
[i
] = 0;
19918 dynamic_info_DT_GNU_HASH
= 0;
19919 dynamic_info_DT_MIPS_XHASH
= 0;
19921 /* Process the file. */
19923 printf (_("\nFile: %s\n"), filedata
->file_name
);
19925 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19926 Note we do this even if cmdline_dump_sects is empty because we
19927 must make sure that the dump_sets array is zeroed out before each
19928 object file is processed. */
19929 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19930 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19932 if (cmdline
.num_dump_sects
> 0)
19934 if (filedata
->num_dump_sects
== 0)
19935 /* A sneaky way of allocating the dump_sects array. */
19936 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19938 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19939 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19940 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19943 if (! process_file_header (filedata
))
19946 if (! process_section_headers (filedata
))
19948 /* Without loaded section headers we cannot process lots of things. */
19949 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19951 if (! do_using_dynamic
)
19952 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19955 if (! process_section_groups (filedata
))
19956 /* Without loaded section groups we cannot process unwind. */
19959 if (process_program_headers (filedata
))
19960 process_dynamic_section (filedata
);
19964 if (! process_relocs (filedata
))
19967 if (! process_unwind (filedata
))
19970 if (! process_symbol_table (filedata
))
19973 if (! process_syminfo (filedata
))
19976 if (! process_version_sections (filedata
))
19979 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19980 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
19982 have_separate_files
= FALSE
;
19984 if (! process_section_contents (filedata
))
19987 if (have_separate_files
)
19991 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
19993 if (! process_section_headers (d
->handle
))
19995 else if (! process_section_contents (d
->handle
))
19999 /* The file handles are closed by the call to free_debug_memory() below. */
20002 if (! process_notes (filedata
))
20005 if (! process_gnu_liblist (filedata
))
20008 if (! process_arch_specific (filedata
))
20011 free (filedata
->program_headers
);
20012 filedata
->program_headers
= NULL
;
20014 free (filedata
->section_headers
);
20015 filedata
->section_headers
= NULL
;
20017 free (filedata
->string_table
);
20018 filedata
->string_table
= NULL
;
20019 filedata
->string_table_length
= 0;
20021 if (filedata
->dump_sects
!= NULL
)
20023 free (filedata
->dump_sects
);
20024 filedata
->dump_sects
= NULL
;
20025 filedata
->num_dump_sects
= 0;
20028 if (dynamic_strings
)
20030 free (dynamic_strings
);
20031 dynamic_strings
= NULL
;
20032 dynamic_strings_length
= 0;
20035 if (dynamic_symbols
)
20037 free (dynamic_symbols
);
20038 dynamic_symbols
= NULL
;
20039 num_dynamic_syms
= 0;
20042 if (dynamic_syminfo
)
20044 free (dynamic_syminfo
);
20045 dynamic_syminfo
= NULL
;
20048 if (dynamic_section
)
20050 free (dynamic_section
);
20051 dynamic_section
= NULL
;
20054 if (section_headers_groups
)
20056 free (section_headers_groups
);
20057 section_headers_groups
= NULL
;
20060 if (section_groups
)
20062 struct group_list
* g
;
20063 struct group_list
* next
;
20065 for (i
= 0; i
< group_count
; i
++)
20067 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
20074 free (section_groups
);
20075 section_groups
= NULL
;
20078 free_debug_memory ();
20083 /* Process an ELF archive.
20084 On entry the file is positioned just after the ARMAG string.
20085 Returns TRUE upon success, FALSE otherwise. */
20088 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
20090 struct archive_info arch
;
20091 struct archive_info nested_arch
;
20093 bfd_boolean ret
= TRUE
;
20097 /* The ARCH structure is used to hold information about this archive. */
20098 arch
.file_name
= NULL
;
20100 arch
.index_array
= NULL
;
20101 arch
.sym_table
= NULL
;
20102 arch
.longnames
= NULL
;
20104 /* The NESTED_ARCH structure is used as a single-item cache of information
20105 about a nested archive (when members of a thin archive reside within
20106 another regular archive file). */
20107 nested_arch
.file_name
= NULL
;
20108 nested_arch
.file
= NULL
;
20109 nested_arch
.index_array
= NULL
;
20110 nested_arch
.sym_table
= NULL
;
20111 nested_arch
.longnames
= NULL
;
20113 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
20114 is_thin_archive
, do_archive_index
) != 0)
20120 if (do_archive_index
)
20122 if (arch
.sym_table
== NULL
)
20123 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
20126 unsigned long i
, l
;
20127 unsigned long current_pos
;
20129 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20130 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
20132 current_pos
= ftell (filedata
->handle
);
20134 for (i
= l
= 0; i
< arch
.index_num
; i
++)
20136 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
20138 char * member_name
;
20140 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
20142 if (member_name
!= NULL
)
20144 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
20146 if (qualified_name
!= NULL
)
20148 printf (_("Contents of binary %s at offset "), qualified_name
);
20149 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
20151 free (qualified_name
);
20156 if (l
>= arch
.sym_size
)
20158 error (_("%s: end of the symbol table reached before the end of the index\n"),
20159 filedata
->file_name
);
20163 /* PR 17531: file: 0b6630b2. */
20164 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
20165 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
20168 if (arch
.uses_64bit_indices
)
20173 if (l
< arch
.sym_size
)
20175 error (ngettext ("%s: %ld byte remains in the symbol table, "
20176 "but without corresponding entries in "
20177 "the index table\n",
20178 "%s: %ld bytes remain in the symbol table, "
20179 "but without corresponding entries in "
20180 "the index table\n",
20181 arch
.sym_size
- l
),
20182 filedata
->file_name
, arch
.sym_size
- l
);
20186 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
20188 error (_("%s: failed to seek back to start of object files in the archive\n"),
20189 filedata
->file_name
);
20195 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
20196 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
20197 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
20198 && !do_section_groups
&& !do_dyn_syms
)
20200 ret
= TRUE
; /* Archive index only. */
20209 char * qualified_name
;
20211 /* Read the next archive header. */
20212 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
20214 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
20217 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20218 if (got
!= sizeof arch
.arhdr
)
20222 /* PR 24049 - we cannot use filedata->file_name as this will
20223 have already been freed. */
20224 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20229 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20231 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
20236 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20238 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20239 if (archive_file_size
& 01)
20240 ++archive_file_size
;
20242 name
= get_archive_member_name (&arch
, &nested_arch
);
20245 error (_("%s: bad archive file name\n"), arch
.file_name
);
20249 namelen
= strlen (name
);
20251 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20252 if (qualified_name
== NULL
)
20254 error (_("%s: bad archive file name\n"), arch
.file_name
);
20259 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20261 /* This is a proxy for an external member of a thin archive. */
20262 Filedata
* member_filedata
;
20263 char * member_file_name
= adjust_relative_path
20264 (filedata
->file_name
, name
, namelen
);
20266 if (member_file_name
== NULL
)
20272 member_filedata
= open_file (member_file_name
);
20273 if (member_filedata
== NULL
)
20275 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20276 free (member_file_name
);
20281 archive_file_offset
= arch
.nested_member_origin
;
20282 member_filedata
->file_name
= qualified_name
;
20284 if (! process_object (member_filedata
))
20287 close_file (member_filedata
);
20288 free (member_file_name
);
20290 else if (is_thin_archive
)
20292 Filedata thin_filedata
;
20294 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20296 /* PR 15140: Allow for corrupt thin archives. */
20297 if (nested_arch
.file
== NULL
)
20299 error (_("%s: contains corrupt thin archive: %s\n"),
20300 qualified_name
, name
);
20305 /* This is a proxy for a member of a nested archive. */
20306 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20308 /* The nested archive file will have been opened and setup by
20309 get_archive_member_name. */
20310 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20312 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
20317 thin_filedata
.handle
= nested_arch
.file
;
20318 thin_filedata
.file_name
= qualified_name
;
20320 if (! process_object (& thin_filedata
))
20325 archive_file_offset
= arch
.next_arhdr_offset
;
20326 arch
.next_arhdr_offset
+= archive_file_size
;
20328 filedata
->file_name
= qualified_name
;
20329 if (! process_object (filedata
))
20333 free (qualified_name
);
20337 if (nested_arch
.file
!= NULL
)
20338 fclose (nested_arch
.file
);
20339 release_archive (&nested_arch
);
20340 release_archive (&arch
);
20346 process_file (char * file_name
)
20348 Filedata
* filedata
= NULL
;
20349 struct stat statbuf
;
20350 char armag
[SARMAG
];
20351 bfd_boolean ret
= TRUE
;
20353 if (stat (file_name
, &statbuf
) < 0)
20355 if (errno
== ENOENT
)
20356 error (_("'%s': No such file\n"), file_name
);
20358 error (_("Could not locate '%s'. System error message: %s\n"),
20359 file_name
, strerror (errno
));
20363 if (! S_ISREG (statbuf
.st_mode
))
20365 error (_("'%s' is not an ordinary file\n"), file_name
);
20369 filedata
= calloc (1, sizeof * filedata
);
20370 if (filedata
== NULL
)
20372 error (_("Out of memory allocating file data structure\n"));
20376 filedata
->file_name
= file_name
;
20377 filedata
->handle
= fopen (file_name
, "rb");
20378 if (filedata
->handle
== NULL
)
20380 error (_("Input file '%s' is not readable.\n"), file_name
);
20385 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20387 error (_("%s: Failed to read file's magic number\n"), file_name
);
20388 fclose (filedata
->handle
);
20393 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20395 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20397 if (! process_archive (filedata
, FALSE
))
20400 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20402 if ( ! process_archive (filedata
, TRUE
))
20407 if (do_archive_index
)
20408 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20411 rewind (filedata
->handle
);
20412 archive_file_size
= archive_file_offset
= 0;
20414 if (! process_object (filedata
))
20418 fclose (filedata
->handle
);
20424 #ifdef SUPPORT_DISASSEMBLY
20425 /* Needed by the i386 disassembler. For extra credit, someone could
20426 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20430 print_address (unsigned int addr
, FILE * outfile
)
20432 fprintf (outfile
,"0x%8.8x", addr
);
20435 /* Needed by the i386 disassembler. */
20438 db_task_printsym (unsigned int addr
)
20440 print_address (addr
, stderr
);
20445 main (int argc
, char ** argv
)
20449 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20450 setlocale (LC_MESSAGES
, "");
20452 #if defined (HAVE_SETLOCALE)
20453 setlocale (LC_CTYPE
, "");
20455 bindtextdomain (PACKAGE
, LOCALEDIR
);
20456 textdomain (PACKAGE
);
20458 expandargv (&argc
, &argv
);
20460 cmdline
.file_name
= "<cmdline>";
20461 parse_args (& cmdline
, argc
, argv
);
20463 if (optind
< (argc
- 1))
20465 else if (optind
>= argc
)
20467 warn (_("Nothing to do.\n"));
20472 while (optind
< argc
)
20473 if (! process_file (argv
[optind
++]))
20476 if (cmdline
.dump_sects
!= NULL
)
20477 free (cmdline
.dump_sects
);
20479 free (dump_ctf_symtab_name
);
20480 free (dump_ctf_strtab_name
);
20481 free (dump_ctf_parent_name
);
20483 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;