1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2018 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. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/s12z.h"
123 #include "elf/mcore.h"
125 #include "elf/metag.h"
126 #include "elf/microblaze.h"
127 #include "elf/mips.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
136 #include "elf/nios2.h"
137 #include "elf/or1k.h"
140 #include "elf/ppc64.h"
142 #include "elf/riscv.h"
143 #include "elf/rl78.h"
145 #include "elf/s390.h"
146 #include "elf/score.h"
148 #include "elf/sparc.h"
150 #include "elf/tic6x.h"
151 #include "elf/tilegx.h"
152 #include "elf/tilepro.h"
153 #include "elf/v850.h"
155 #include "elf/visium.h"
156 #include "elf/wasm32.h"
157 #include "elf/x86-64.h"
158 #include "elf/xc16x.h"
159 #include "elf/xgate.h"
160 #include "elf/xstormy16.h"
161 #include "elf/xtensa.h"
164 #include "libiberty.h"
165 #include "safe-ctype.h"
166 #include "filenames.h"
169 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
172 typedef struct elf_section_list
174 Elf_Internal_Shdr
* hdr
;
175 struct elf_section_list
* next
;
178 /* Flag bits indicating particular types of dump. */
179 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
180 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
181 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
182 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
183 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
185 typedef unsigned char dump_type
;
187 /* A linked list of the section names for which dumps were requested. */
188 struct dump_list_entry
192 struct dump_list_entry
* next
;
195 typedef struct filedata
197 const char * file_name
;
199 bfd_size_type file_size
;
200 Elf_Internal_Ehdr file_header
;
201 Elf_Internal_Shdr
* section_headers
;
202 Elf_Internal_Phdr
* program_headers
;
204 unsigned long string_table_length
;
205 /* A dynamic array of flags indicating for which sections a dump of
206 some kind has been requested. It is reset on a per-object file
207 basis and then initialised from the cmdline_dump_sects array,
208 the results of interpreting the -w switch, and the
209 dump_sects_byname list. */
210 dump_type
* dump_sects
;
211 unsigned int num_dump_sects
;
214 char * program_name
= "readelf";
216 static unsigned long archive_file_offset
;
217 static unsigned long archive_file_size
;
218 static unsigned long dynamic_addr
;
219 static bfd_size_type dynamic_size
;
220 static size_t dynamic_nent
;
221 static char * dynamic_strings
;
222 static unsigned long dynamic_strings_length
;
223 static unsigned long num_dynamic_syms
;
224 static Elf_Internal_Sym
* dynamic_symbols
;
225 static Elf_Internal_Syminfo
* dynamic_syminfo
;
226 static unsigned long dynamic_syminfo_offset
;
227 static unsigned int dynamic_syminfo_nent
;
228 static char program_interpreter
[PATH_MAX
];
229 static bfd_vma dynamic_info
[DT_ENCODING
];
230 static bfd_vma dynamic_info_DT_GNU_HASH
;
231 static bfd_vma version_info
[16];
232 static Elf_Internal_Dyn
* dynamic_section
;
233 static elf_section_list
* symtab_shndx_list
;
234 static bfd_boolean show_name
= FALSE
;
235 static bfd_boolean do_dynamic
= FALSE
;
236 static bfd_boolean do_syms
= FALSE
;
237 static bfd_boolean do_dyn_syms
= FALSE
;
238 static bfd_boolean do_reloc
= FALSE
;
239 static bfd_boolean do_sections
= FALSE
;
240 static bfd_boolean do_section_groups
= FALSE
;
241 static bfd_boolean do_section_details
= FALSE
;
242 static bfd_boolean do_segments
= FALSE
;
243 static bfd_boolean do_unwind
= FALSE
;
244 static bfd_boolean do_using_dynamic
= FALSE
;
245 static bfd_boolean do_header
= FALSE
;
246 static bfd_boolean do_dump
= FALSE
;
247 static bfd_boolean do_version
= FALSE
;
248 static bfd_boolean do_histogram
= FALSE
;
249 static bfd_boolean do_debugging
= FALSE
;
250 static bfd_boolean do_arch
= FALSE
;
251 static bfd_boolean do_notes
= FALSE
;
252 static bfd_boolean do_archive_index
= FALSE
;
253 static bfd_boolean is_32bit_elf
= FALSE
;
254 static bfd_boolean decompress_dumps
= FALSE
;
258 struct group_list
* next
;
259 unsigned int section_index
;
264 struct group_list
* root
;
265 unsigned int group_index
;
268 static size_t group_count
;
269 static struct group
* section_groups
;
270 static struct group
** section_headers_groups
;
272 /* A dynamic array of flags indicating for which sections a dump
273 has been requested via command line switches. */
274 static Filedata cmdline
;
276 static struct dump_list_entry
* dump_sects_byname
;
278 /* How to print a vma value. */
279 typedef enum print_mode
291 /* Versioned symbol info. */
292 enum versioned_symbol_info
299 static const char * get_symbol_version_string
300 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
301 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
305 #define SECTION_NAME(X) \
306 ((X) == NULL ? _("<none>") \
307 : filedata->string_table == NULL ? _("<no-strings>") \
308 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
309 : filedata->string_table + (X)->sh_name))
311 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
313 #define GET_ELF_SYMBOLS(file, section, sym_count) \
314 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
315 : get_64bit_elf_symbols (file, section, sym_count))
317 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
318 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
319 already been called and verified that the string exists. */
320 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
322 #define REMOVE_ARCH_BITS(ADDR) \
325 if (filedata->file_header.e_machine == EM_ARM) \
330 /* Print a BFD_VMA to an internal buffer, for use in error messages.
331 BFD_FMA_FMT can't be used in translated strings. */
334 bfd_vmatoa (char *fmtch
, bfd_vma value
)
336 /* bfd_vmatoa is used more then once in a printf call for output.
337 Cycle through an array of buffers. */
338 static int buf_pos
= 0;
339 static struct bfd_vmatoa_buf
346 ret
= buf
[buf_pos
++].place
;
347 buf_pos
%= ARRAY_SIZE (buf
);
349 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
350 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
354 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
355 OFFSET + the offset of the current archive member, if we are examining an
356 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
357 allocate a buffer using malloc and fill that. In either case return the
358 pointer to the start of the retrieved data or NULL if something went wrong.
359 If something does go wrong and REASON is not NULL then emit an error
360 message using REASON as part of the context. */
363 get_data (void * var
,
365 unsigned long offset
,
371 bfd_size_type amt
= size
* nmemb
;
373 if (size
== 0 || nmemb
== 0)
376 /* If the size_t type is smaller than the bfd_size_type, eg because
377 you are building a 32-bit tool on a 64-bit host, then make sure
378 that when the sizes are cast to (size_t) no information is lost. */
379 if (sizeof (size_t) < sizeof (bfd_size_type
)
380 && ( (bfd_size_type
) ((size_t) size
) != size
381 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
384 error (_("Size truncation prevents reading %s"
385 " elements of size %s for %s\n"),
386 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
390 /* Check for size overflow. */
394 error (_("Size overflow prevents reading %s"
395 " elements of size %s for %s\n"),
396 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
400 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
401 attempting to allocate memory when the read is bound to fail. */
402 if (amt
> filedata
->file_size
403 || offset
+ archive_file_offset
+ amt
> filedata
->file_size
)
406 error (_("Reading %s bytes extends past end of file for %s\n"),
407 bfd_vmatoa ("u", amt
), reason
);
411 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
414 error (_("Unable to seek to 0x%lx for %s\n"),
415 archive_file_offset
+ offset
, reason
);
422 /* Check for overflow. */
423 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
424 /* + 1 so that we can '\0' terminate invalid string table sections. */
425 mvar
= malloc ((size_t) amt
+ 1);
430 error (_("Out of memory allocating %s bytes for %s\n"),
431 bfd_vmatoa ("u", amt
), reason
);
435 ((char *) mvar
)[amt
] = '\0';
438 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
441 error (_("Unable to read in %s bytes of %s\n"),
442 bfd_vmatoa ("u", amt
), reason
);
451 /* Print a VMA value in the MODE specified.
452 Returns the number of characters displayed. */
455 print_vma (bfd_vma vma
, print_mode mode
)
467 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
474 return printf ("%5" BFD_VMA_FMT
"d", vma
);
480 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
483 return printf ("%" BFD_VMA_FMT
"d", vma
);
486 return printf ("%" BFD_VMA_FMT
"u", vma
);
489 /* FIXME: Report unrecognised mode ? */
494 /* Display a symbol on stdout. Handles the display of control characters and
495 multibye characters (assuming the host environment supports them).
497 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
499 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
500 padding as necessary.
502 Returns the number of emitted characters. */
505 print_symbol (signed int width
, const char *symbol
)
507 bfd_boolean extra_padding
= FALSE
;
508 signed int num_printed
= 0;
509 #ifdef HAVE_MBSTATE_T
512 unsigned int width_remaining
;
516 /* Keep the width positive. This helps the code below. */
518 extra_padding
= TRUE
;
524 /* Set the remaining width to a very large value.
525 This simplifies the code below. */
526 width_remaining
= INT_MAX
;
528 width_remaining
= width
;
530 #ifdef HAVE_MBSTATE_T
531 /* Initialise the multibyte conversion state. */
532 memset (& state
, 0, sizeof (state
));
535 while (width_remaining
)
538 const char c
= *symbol
++;
543 /* Do not print control characters directly as they can affect terminal
544 settings. Such characters usually appear in the names generated
545 by the assembler for local labels. */
548 if (width_remaining
< 2)
551 printf ("^%c", c
+ 0x40);
552 width_remaining
-= 2;
555 else if (ISPRINT (c
))
563 #ifdef HAVE_MBSTATE_T
566 /* Let printf do the hard work of displaying multibyte characters. */
567 printf ("%.1s", symbol
- 1);
571 #ifdef HAVE_MBSTATE_T
572 /* Try to find out how many bytes made up the character that was
573 just printed. Advance the symbol pointer past the bytes that
575 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
579 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
584 if (extra_padding
&& num_printed
< width
)
586 /* Fill in the remaining spaces. */
587 printf ("%-*s", width
- num_printed
, " ");
594 /* Returns a pointer to a static buffer containing a printable version of
595 the given section's name. Like print_symbol, except that it does not try
596 to print multibyte characters, it just interprets them as hex values. */
599 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
601 #define MAX_PRINT_SEC_NAME_LEN 128
602 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
603 const char * name
= SECTION_NAME (sec
);
604 char * buf
= sec_name_buf
;
606 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
608 while ((c
= * name
++) != 0)
619 else if (ISPRINT (c
))
626 static char hex
[17] = "0123456789ABCDEF";
631 * buf
++ = hex
[(c
& 0xf0) >> 4];
632 * buf
++ = hex
[c
& 0x0f];
646 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
648 if (ndx
>= filedata
->file_header
.e_shnum
)
649 return _("<corrupt>");
651 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
654 /* Return a pointer to section NAME, or NULL if no such section exists. */
656 static Elf_Internal_Shdr
*
657 find_section (Filedata
* filedata
, const char * name
)
661 if (filedata
->section_headers
== NULL
)
664 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
665 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
666 return filedata
->section_headers
+ i
;
671 /* Return a pointer to a section containing ADDR, or NULL if no such
674 static Elf_Internal_Shdr
*
675 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
679 if (filedata
->section_headers
== NULL
)
682 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
684 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
686 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
693 static Elf_Internal_Shdr
*
694 find_section_by_type (Filedata
* filedata
, unsigned int type
)
698 if (filedata
->section_headers
== NULL
)
701 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
703 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
705 if (sec
->sh_type
== type
)
712 /* Return a pointer to section NAME, or NULL if no such section exists,
713 restricted to the list of sections given in SET. */
715 static Elf_Internal_Shdr
*
716 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
720 if (filedata
->section_headers
== NULL
)
725 while ((i
= *set
++) > 0)
727 /* See PR 21156 for a reproducer. */
728 if (i
>= filedata
->file_header
.e_shnum
)
729 continue; /* FIXME: Should we issue an error message ? */
731 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
732 return filedata
->section_headers
+ i
;
736 return find_section (filedata
, name
);
739 /* Read an unsigned LEB128 encoded value from DATA.
740 Set *LENGTH_RETURN to the number of bytes read. */
742 static inline unsigned long
743 read_uleb128 (unsigned char * data
,
744 unsigned int * length_return
,
745 const unsigned char * const end
)
747 return read_leb128 (data
, length_return
, FALSE
, end
);
750 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
751 This OS has so many departures from the ELF standard that we test it at
754 static inline bfd_boolean
755 is_ia64_vms (Filedata
* filedata
)
757 return filedata
->file_header
.e_machine
== EM_IA_64
758 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
761 /* Guess the relocation size commonly used by the specific machines. */
764 guess_is_rela (unsigned int e_machine
)
768 /* Targets that use REL relocations. */
784 /* Targets that use RELA relocations. */
788 case EM_ADAPTEVA_EPIPHANY
:
790 case EM_ALTERA_NIOS2
:
793 case EM_ARC_COMPACT2
:
813 case EM_LATTICEMICO32
:
822 case EM_CYGNUS_MN10200
:
824 case EM_CYGNUS_MN10300
:
860 case EM_MICROBLAZE_OLD
:
882 warn (_("Don't know about relocations on this machine architecture\n"));
887 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
888 Returns TRUE upon success, FALSE otherwise. If successful then a
889 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
890 and the number of relocs loaded is placed in *NRELASP. It is the caller's
891 responsibility to free the allocated buffer. */
894 slurp_rela_relocs (Filedata
* filedata
,
895 unsigned long rel_offset
,
896 unsigned long rel_size
,
897 Elf_Internal_Rela
** relasp
,
898 unsigned long * nrelasp
)
900 Elf_Internal_Rela
* relas
;
906 Elf32_External_Rela
* erelas
;
908 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
909 rel_size
, _("32-bit relocation data"));
913 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
915 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
916 sizeof (Elf_Internal_Rela
));
921 error (_("out of memory parsing relocs\n"));
925 for (i
= 0; i
< nrelas
; i
++)
927 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
928 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
929 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
936 Elf64_External_Rela
* erelas
;
938 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
939 rel_size
, _("64-bit relocation data"));
943 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
945 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
946 sizeof (Elf_Internal_Rela
));
951 error (_("out of memory parsing relocs\n"));
955 for (i
= 0; i
< nrelas
; i
++)
957 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
958 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
959 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
961 /* The #ifdef BFD64 below is to prevent a compile time
962 warning. We know that if we do not have a 64 bit data
963 type that we will never execute this code anyway. */
965 if (filedata
->file_header
.e_machine
== EM_MIPS
966 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
968 /* In little-endian objects, r_info isn't really a
969 64-bit little-endian value: it has a 32-bit
970 little-endian symbol index followed by four
971 individual byte fields. Reorder INFO
973 bfd_vma inf
= relas
[i
].r_info
;
974 inf
= (((inf
& 0xffffffff) << 32)
975 | ((inf
>> 56) & 0xff)
976 | ((inf
>> 40) & 0xff00)
977 | ((inf
>> 24) & 0xff0000)
978 | ((inf
>> 8) & 0xff000000));
979 relas
[i
].r_info
= inf
;
992 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
993 Returns TRUE upon success, FALSE otherwise. If successful then a
994 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
995 and the number of relocs loaded is placed in *NRELSP. It is the caller's
996 responsibility to free the allocated buffer. */
999 slurp_rel_relocs (Filedata
* filedata
,
1000 unsigned long rel_offset
,
1001 unsigned long rel_size
,
1002 Elf_Internal_Rela
** relsp
,
1003 unsigned long * nrelsp
)
1005 Elf_Internal_Rela
* rels
;
1011 Elf32_External_Rel
* erels
;
1013 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1014 rel_size
, _("32-bit relocation data"));
1018 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1020 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1025 error (_("out of memory parsing relocs\n"));
1029 for (i
= 0; i
< nrels
; i
++)
1031 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1032 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1033 rels
[i
].r_addend
= 0;
1040 Elf64_External_Rel
* erels
;
1042 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1043 rel_size
, _("64-bit relocation data"));
1047 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1049 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1054 error (_("out of memory parsing relocs\n"));
1058 for (i
= 0; i
< nrels
; i
++)
1060 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1061 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1062 rels
[i
].r_addend
= 0;
1064 /* The #ifdef BFD64 below is to prevent a compile time
1065 warning. We know that if we do not have a 64 bit data
1066 type that we will never execute this code anyway. */
1068 if (filedata
->file_header
.e_machine
== EM_MIPS
1069 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1071 /* In little-endian objects, r_info isn't really a
1072 64-bit little-endian value: it has a 32-bit
1073 little-endian symbol index followed by four
1074 individual byte fields. Reorder INFO
1076 bfd_vma inf
= rels
[i
].r_info
;
1077 inf
= (((inf
& 0xffffffff) << 32)
1078 | ((inf
>> 56) & 0xff)
1079 | ((inf
>> 40) & 0xff00)
1080 | ((inf
>> 24) & 0xff0000)
1081 | ((inf
>> 8) & 0xff000000));
1082 rels
[i
].r_info
= inf
;
1095 /* Returns the reloc type extracted from the reloc info field. */
1098 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1101 return ELF32_R_TYPE (reloc_info
);
1103 switch (filedata
->file_header
.e_machine
)
1106 /* Note: We assume that reloc_info has already been adjusted for us. */
1107 return ELF64_MIPS_R_TYPE (reloc_info
);
1110 return ELF64_R_TYPE_ID (reloc_info
);
1113 return ELF64_R_TYPE (reloc_info
);
1117 /* Return the symbol index extracted from the reloc info field. */
1120 get_reloc_symindex (bfd_vma reloc_info
)
1122 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1125 static inline bfd_boolean
1126 uses_msp430x_relocs (Filedata
* filedata
)
1129 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1130 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1131 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1132 /* TI compiler uses ELFOSABI_NONE. */
1133 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1136 /* Display the contents of the relocation data found at the specified
1140 dump_relocations (Filedata
* filedata
,
1141 unsigned long rel_offset
,
1142 unsigned long rel_size
,
1143 Elf_Internal_Sym
* symtab
,
1144 unsigned long nsyms
,
1146 unsigned long strtablen
,
1148 bfd_boolean is_dynsym
)
1151 Elf_Internal_Rela
* rels
;
1152 bfd_boolean res
= TRUE
;
1154 if (is_rela
== UNKNOWN
)
1155 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1159 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1164 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1173 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1175 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1180 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1182 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1190 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1192 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1197 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1199 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1203 for (i
= 0; i
< rel_size
; i
++)
1208 bfd_vma symtab_index
;
1211 offset
= rels
[i
].r_offset
;
1212 inf
= rels
[i
].r_info
;
1214 type
= get_reloc_type (filedata
, inf
);
1215 symtab_index
= get_reloc_symindex (inf
);
1219 printf ("%8.8lx %8.8lx ",
1220 (unsigned long) offset
& 0xffffffff,
1221 (unsigned long) inf
& 0xffffffff);
1225 #if BFD_HOST_64BIT_LONG
1227 ? "%16.16lx %16.16lx "
1228 : "%12.12lx %12.12lx ",
1230 #elif BFD_HOST_64BIT_LONG_LONG
1233 ? "%16.16llx %16.16llx "
1234 : "%12.12llx %12.12llx ",
1238 ? "%16.16I64x %16.16I64x "
1239 : "%12.12I64x %12.12I64x ",
1244 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1245 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1246 _bfd_int64_high (offset
),
1247 _bfd_int64_low (offset
),
1248 _bfd_int64_high (inf
),
1249 _bfd_int64_low (inf
));
1253 switch (filedata
->file_header
.e_machine
)
1260 rtype
= elf_aarch64_reloc_type (type
);
1264 case EM_CYGNUS_M32R
:
1265 rtype
= elf_m32r_reloc_type (type
);
1270 rtype
= elf_i386_reloc_type (type
);
1275 rtype
= elf_m68hc11_reloc_type (type
);
1279 rtype
= elf_s12z_reloc_type (type
);
1283 rtype
= elf_m68k_reloc_type (type
);
1287 rtype
= elf_i960_reloc_type (type
);
1292 rtype
= elf_avr_reloc_type (type
);
1295 case EM_OLD_SPARCV9
:
1296 case EM_SPARC32PLUS
:
1299 rtype
= elf_sparc_reloc_type (type
);
1303 rtype
= elf_spu_reloc_type (type
);
1307 rtype
= v800_reloc_type (type
);
1310 case EM_CYGNUS_V850
:
1311 rtype
= v850_reloc_type (type
);
1315 case EM_CYGNUS_D10V
:
1316 rtype
= elf_d10v_reloc_type (type
);
1320 case EM_CYGNUS_D30V
:
1321 rtype
= elf_d30v_reloc_type (type
);
1325 rtype
= elf_dlx_reloc_type (type
);
1329 rtype
= elf_sh_reloc_type (type
);
1333 case EM_CYGNUS_MN10300
:
1334 rtype
= elf_mn10300_reloc_type (type
);
1338 case EM_CYGNUS_MN10200
:
1339 rtype
= elf_mn10200_reloc_type (type
);
1343 case EM_CYGNUS_FR30
:
1344 rtype
= elf_fr30_reloc_type (type
);
1348 rtype
= elf_frv_reloc_type (type
);
1352 rtype
= elf_ft32_reloc_type (type
);
1356 rtype
= elf_mcore_reloc_type (type
);
1360 rtype
= elf_mmix_reloc_type (type
);
1364 rtype
= elf_moxie_reloc_type (type
);
1368 if (uses_msp430x_relocs (filedata
))
1370 rtype
= elf_msp430x_reloc_type (type
);
1375 rtype
= elf_msp430_reloc_type (type
);
1379 rtype
= elf_nds32_reloc_type (type
);
1383 rtype
= elf_ppc_reloc_type (type
);
1387 rtype
= elf_ppc64_reloc_type (type
);
1391 case EM_MIPS_RS3_LE
:
1392 rtype
= elf_mips_reloc_type (type
);
1396 rtype
= elf_riscv_reloc_type (type
);
1400 rtype
= elf_alpha_reloc_type (type
);
1404 rtype
= elf_arm_reloc_type (type
);
1408 case EM_ARC_COMPACT
:
1409 case EM_ARC_COMPACT2
:
1410 rtype
= elf_arc_reloc_type (type
);
1414 rtype
= elf_hppa_reloc_type (type
);
1420 rtype
= elf_h8_reloc_type (type
);
1424 rtype
= elf_or1k_reloc_type (type
);
1429 rtype
= elf_pj_reloc_type (type
);
1432 rtype
= elf_ia64_reloc_type (type
);
1436 rtype
= elf_cris_reloc_type (type
);
1440 rtype
= elf_i860_reloc_type (type
);
1446 rtype
= elf_x86_64_reloc_type (type
);
1450 rtype
= i370_reloc_type (type
);
1455 rtype
= elf_s390_reloc_type (type
);
1459 rtype
= elf_score_reloc_type (type
);
1463 rtype
= elf_xstormy16_reloc_type (type
);
1467 rtype
= elf_crx_reloc_type (type
);
1471 rtype
= elf_vax_reloc_type (type
);
1475 rtype
= elf_visium_reloc_type (type
);
1478 case EM_ADAPTEVA_EPIPHANY
:
1479 rtype
= elf_epiphany_reloc_type (type
);
1484 rtype
= elf_ip2k_reloc_type (type
);
1488 rtype
= elf_iq2000_reloc_type (type
);
1493 rtype
= elf_xtensa_reloc_type (type
);
1496 case EM_LATTICEMICO32
:
1497 rtype
= elf_lm32_reloc_type (type
);
1502 rtype
= elf_m32c_reloc_type (type
);
1506 rtype
= elf_mt_reloc_type (type
);
1510 rtype
= elf_bfin_reloc_type (type
);
1514 rtype
= elf_mep_reloc_type (type
);
1518 rtype
= elf_cr16_reloc_type (type
);
1522 case EM_MICROBLAZE_OLD
:
1523 rtype
= elf_microblaze_reloc_type (type
);
1527 rtype
= elf_rl78_reloc_type (type
);
1531 rtype
= elf_rx_reloc_type (type
);
1535 rtype
= elf_metag_reloc_type (type
);
1540 rtype
= elf_xc16x_reloc_type (type
);
1544 rtype
= elf_tic6x_reloc_type (type
);
1548 rtype
= elf_tilegx_reloc_type (type
);
1552 rtype
= elf_tilepro_reloc_type (type
);
1555 case EM_WEBASSEMBLY
:
1556 rtype
= elf_wasm32_reloc_type (type
);
1560 rtype
= elf_xgate_reloc_type (type
);
1563 case EM_ALTERA_NIOS2
:
1564 rtype
= elf_nios2_reloc_type (type
);
1568 rtype
= elf_pru_reloc_type (type
);
1572 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1573 rtype
= elf_nfp3200_reloc_type (type
);
1575 rtype
= elf_nfp_reloc_type (type
);
1580 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1582 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1584 if (filedata
->file_header
.e_machine
== EM_ALPHA
1586 && streq (rtype
, "R_ALPHA_LITUSE")
1589 switch (rels
[i
].r_addend
)
1591 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1592 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1593 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1594 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1595 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1596 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1597 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1598 default: rtype
= NULL
;
1602 printf (" (%s)", rtype
);
1606 printf (_("<unknown addend: %lx>"),
1607 (unsigned long) rels
[i
].r_addend
);
1611 else if (symtab_index
)
1613 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1615 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1620 Elf_Internal_Sym
* psym
;
1621 const char * version_string
;
1622 enum versioned_symbol_info sym_info
;
1623 unsigned short vna_other
;
1625 psym
= symtab
+ symtab_index
;
1628 = get_symbol_version_string (filedata
, is_dynsym
,
1637 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1641 unsigned int width
= is_32bit_elf
? 8 : 14;
1643 /* Relocations against GNU_IFUNC symbols do not use the value
1644 of the symbol as the address to relocate against. Instead
1645 they invoke the function named by the symbol and use its
1646 result as the address for relocation.
1648 To indicate this to the user, do not display the value of
1649 the symbol in the "Symbols's Value" field. Instead show
1650 its name followed by () as a hint that the symbol is
1654 || psym
->st_name
== 0
1655 || psym
->st_name
>= strtablen
)
1658 name
= strtab
+ psym
->st_name
;
1660 len
= print_symbol (width
, name
);
1662 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1664 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1668 print_vma (psym
->st_value
, LONG_HEX
);
1670 printf (is_32bit_elf
? " " : " ");
1673 if (psym
->st_name
== 0)
1675 const char * sec_name
= "<null>";
1678 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1680 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1681 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1682 else if (psym
->st_shndx
== SHN_ABS
)
1684 else if (psym
->st_shndx
== SHN_COMMON
)
1685 sec_name
= "COMMON";
1686 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1687 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1688 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1689 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1690 sec_name
= "SCOMMON";
1691 else if (filedata
->file_header
.e_machine
== EM_MIPS
1692 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1693 sec_name
= "SUNDEF";
1694 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1695 || filedata
->file_header
.e_machine
== EM_L1OM
1696 || filedata
->file_header
.e_machine
== EM_K1OM
)
1697 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1698 sec_name
= "LARGE_COMMON";
1699 else if (filedata
->file_header
.e_machine
== EM_IA_64
1700 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1701 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1702 sec_name
= "ANSI_COM";
1703 else if (is_ia64_vms (filedata
)
1704 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1705 sec_name
= "VMS_SYMVEC";
1708 sprintf (name_buf
, "<section 0x%x>",
1709 (unsigned int) psym
->st_shndx
);
1710 sec_name
= name_buf
;
1713 print_symbol (22, sec_name
);
1715 else if (strtab
== NULL
)
1716 printf (_("<string table index: %3ld>"), psym
->st_name
);
1717 else if (psym
->st_name
>= strtablen
)
1719 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1724 print_symbol (22, strtab
+ psym
->st_name
);
1726 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1732 bfd_vma off
= rels
[i
].r_addend
;
1734 if ((bfd_signed_vma
) off
< 0)
1735 printf (" - %" BFD_VMA_FMT
"x", - off
);
1737 printf (" + %" BFD_VMA_FMT
"x", off
);
1743 bfd_vma off
= rels
[i
].r_addend
;
1745 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1746 if ((bfd_signed_vma
) off
< 0)
1747 printf ("-%" BFD_VMA_FMT
"x", - off
);
1749 printf ("%" BFD_VMA_FMT
"x", off
);
1752 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1754 && streq (rtype
, "R_SPARC_OLO10"))
1755 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1760 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1762 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1763 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1764 const char * rtype2
= elf_mips_reloc_type (type2
);
1765 const char * rtype3
= elf_mips_reloc_type (type3
);
1767 printf (" Type2: ");
1770 printf (_("unrecognized: %-7lx"),
1771 (unsigned long) type2
& 0xffffffff);
1773 printf ("%-17.17s", rtype2
);
1775 printf ("\n Type3: ");
1778 printf (_("unrecognized: %-7lx"),
1779 (unsigned long) type3
& 0xffffffff);
1781 printf ("%-17.17s", rtype3
);
1794 get_mips_dynamic_type (unsigned long type
)
1798 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1799 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1800 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1801 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1802 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1803 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1804 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1805 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1806 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1807 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1808 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1809 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1810 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1811 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1812 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1813 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1814 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1815 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1816 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1817 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1818 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1819 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1820 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1821 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1822 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1823 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1824 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1825 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1826 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1827 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1828 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1829 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1830 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1831 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1832 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1833 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1834 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1835 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1836 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1837 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1838 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1839 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1840 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1841 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1842 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1843 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1850 get_sparc64_dynamic_type (unsigned long type
)
1854 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1861 get_ppc_dynamic_type (unsigned long type
)
1865 case DT_PPC_GOT
: return "PPC_GOT";
1866 case DT_PPC_OPT
: return "PPC_OPT";
1873 get_ppc64_dynamic_type (unsigned long type
)
1877 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1878 case DT_PPC64_OPD
: return "PPC64_OPD";
1879 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1880 case DT_PPC64_OPT
: return "PPC64_OPT";
1887 get_parisc_dynamic_type (unsigned long type
)
1891 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1892 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1893 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1894 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1895 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1896 case DT_HP_PREINIT
: return "HP_PREINIT";
1897 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1898 case DT_HP_NEEDED
: return "HP_NEEDED";
1899 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1900 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1901 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1902 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1903 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1904 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1905 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1906 case DT_HP_FILTERED
: return "HP_FILTERED";
1907 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1908 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1909 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1910 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1911 case DT_PLT
: return "PLT";
1912 case DT_PLT_SIZE
: return "PLT_SIZE";
1913 case DT_DLT
: return "DLT";
1914 case DT_DLT_SIZE
: return "DLT_SIZE";
1921 get_ia64_dynamic_type (unsigned long type
)
1925 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1926 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1927 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1928 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1929 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1930 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1931 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1932 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1933 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1934 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1935 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1936 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1937 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1938 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1939 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1940 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1941 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1942 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1943 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1944 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1945 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1946 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1947 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1948 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1949 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1950 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1951 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1952 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1953 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1954 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1955 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1962 get_solaris_section_type (unsigned long type
)
1966 case 0x6fffffee: return "SUNW_ancillary";
1967 case 0x6fffffef: return "SUNW_capchain";
1968 case 0x6ffffff0: return "SUNW_capinfo";
1969 case 0x6ffffff1: return "SUNW_symsort";
1970 case 0x6ffffff2: return "SUNW_tlssort";
1971 case 0x6ffffff3: return "SUNW_LDYNSYM";
1972 case 0x6ffffff4: return "SUNW_dof";
1973 case 0x6ffffff5: return "SUNW_cap";
1974 case 0x6ffffff6: return "SUNW_SIGNATURE";
1975 case 0x6ffffff7: return "SUNW_ANNOTATE";
1976 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1977 case 0x6ffffff9: return "SUNW_DEBUG";
1978 case 0x6ffffffa: return "SUNW_move";
1979 case 0x6ffffffb: return "SUNW_COMDAT";
1980 case 0x6ffffffc: return "SUNW_syminfo";
1981 case 0x6ffffffd: return "SUNW_verdef";
1982 case 0x6ffffffe: return "SUNW_verneed";
1983 case 0x6fffffff: return "SUNW_versym";
1984 case 0x70000000: return "SPARC_GOTDATA";
1985 default: return NULL
;
1990 get_alpha_dynamic_type (unsigned long type
)
1994 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1995 default: return NULL
;
2000 get_score_dynamic_type (unsigned long type
)
2004 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2005 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2006 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2007 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2008 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2009 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2010 default: return NULL
;
2015 get_tic6x_dynamic_type (unsigned long type
)
2019 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2020 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2021 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2022 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2023 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2024 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2025 default: return NULL
;
2030 get_nios2_dynamic_type (unsigned long type
)
2034 case DT_NIOS2_GP
: return "NIOS2_GP";
2035 default: return NULL
;
2040 get_solaris_dynamic_type (unsigned long type
)
2044 case 0x6000000d: return "SUNW_AUXILIARY";
2045 case 0x6000000e: return "SUNW_RTLDINF";
2046 case 0x6000000f: return "SUNW_FILTER";
2047 case 0x60000010: return "SUNW_CAP";
2048 case 0x60000011: return "SUNW_SYMTAB";
2049 case 0x60000012: return "SUNW_SYMSZ";
2050 case 0x60000013: return "SUNW_SORTENT";
2051 case 0x60000014: return "SUNW_SYMSORT";
2052 case 0x60000015: return "SUNW_SYMSORTSZ";
2053 case 0x60000016: return "SUNW_TLSSORT";
2054 case 0x60000017: return "SUNW_TLSSORTSZ";
2055 case 0x60000018: return "SUNW_CAPINFO";
2056 case 0x60000019: return "SUNW_STRPAD";
2057 case 0x6000001a: return "SUNW_CAPCHAIN";
2058 case 0x6000001b: return "SUNW_LDMACH";
2059 case 0x6000001d: return "SUNW_CAPCHAINENT";
2060 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2061 case 0x60000021: return "SUNW_PARENT";
2062 case 0x60000023: return "SUNW_ASLR";
2063 case 0x60000025: return "SUNW_RELAX";
2064 case 0x60000029: return "SUNW_NXHEAP";
2065 case 0x6000002b: return "SUNW_NXSTACK";
2067 case 0x70000001: return "SPARC_REGISTER";
2068 case 0x7ffffffd: return "AUXILIARY";
2069 case 0x7ffffffe: return "USED";
2070 case 0x7fffffff: return "FILTER";
2072 default: return NULL
;
2077 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2079 static char buff
[64];
2083 case DT_NULL
: return "NULL";
2084 case DT_NEEDED
: return "NEEDED";
2085 case DT_PLTRELSZ
: return "PLTRELSZ";
2086 case DT_PLTGOT
: return "PLTGOT";
2087 case DT_HASH
: return "HASH";
2088 case DT_STRTAB
: return "STRTAB";
2089 case DT_SYMTAB
: return "SYMTAB";
2090 case DT_RELA
: return "RELA";
2091 case DT_RELASZ
: return "RELASZ";
2092 case DT_RELAENT
: return "RELAENT";
2093 case DT_STRSZ
: return "STRSZ";
2094 case DT_SYMENT
: return "SYMENT";
2095 case DT_INIT
: return "INIT";
2096 case DT_FINI
: return "FINI";
2097 case DT_SONAME
: return "SONAME";
2098 case DT_RPATH
: return "RPATH";
2099 case DT_SYMBOLIC
: return "SYMBOLIC";
2100 case DT_REL
: return "REL";
2101 case DT_RELSZ
: return "RELSZ";
2102 case DT_RELENT
: return "RELENT";
2103 case DT_PLTREL
: return "PLTREL";
2104 case DT_DEBUG
: return "DEBUG";
2105 case DT_TEXTREL
: return "TEXTREL";
2106 case DT_JMPREL
: return "JMPREL";
2107 case DT_BIND_NOW
: return "BIND_NOW";
2108 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2109 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2110 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2111 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2112 case DT_RUNPATH
: return "RUNPATH";
2113 case DT_FLAGS
: return "FLAGS";
2115 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2116 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2117 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2119 case DT_CHECKSUM
: return "CHECKSUM";
2120 case DT_PLTPADSZ
: return "PLTPADSZ";
2121 case DT_MOVEENT
: return "MOVEENT";
2122 case DT_MOVESZ
: return "MOVESZ";
2123 case DT_FEATURE
: return "FEATURE";
2124 case DT_POSFLAG_1
: return "POSFLAG_1";
2125 case DT_SYMINSZ
: return "SYMINSZ";
2126 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2128 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2129 case DT_CONFIG
: return "CONFIG";
2130 case DT_DEPAUDIT
: return "DEPAUDIT";
2131 case DT_AUDIT
: return "AUDIT";
2132 case DT_PLTPAD
: return "PLTPAD";
2133 case DT_MOVETAB
: return "MOVETAB";
2134 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2136 case DT_VERSYM
: return "VERSYM";
2138 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2139 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2140 case DT_RELACOUNT
: return "RELACOUNT";
2141 case DT_RELCOUNT
: return "RELCOUNT";
2142 case DT_FLAGS_1
: return "FLAGS_1";
2143 case DT_VERDEF
: return "VERDEF";
2144 case DT_VERDEFNUM
: return "VERDEFNUM";
2145 case DT_VERNEED
: return "VERNEED";
2146 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2148 case DT_AUXILIARY
: return "AUXILIARY";
2149 case DT_USED
: return "USED";
2150 case DT_FILTER
: return "FILTER";
2152 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2153 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2154 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2155 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2156 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2157 case DT_GNU_HASH
: return "GNU_HASH";
2160 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2162 const char * result
;
2164 switch (filedata
->file_header
.e_machine
)
2167 case EM_MIPS_RS3_LE
:
2168 result
= get_mips_dynamic_type (type
);
2171 result
= get_sparc64_dynamic_type (type
);
2174 result
= get_ppc_dynamic_type (type
);
2177 result
= get_ppc64_dynamic_type (type
);
2180 result
= get_ia64_dynamic_type (type
);
2183 result
= get_alpha_dynamic_type (type
);
2186 result
= get_score_dynamic_type (type
);
2189 result
= get_tic6x_dynamic_type (type
);
2191 case EM_ALTERA_NIOS2
:
2192 result
= get_nios2_dynamic_type (type
);
2195 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2196 result
= get_solaris_dynamic_type (type
);
2205 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2207 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2208 || (filedata
->file_header
.e_machine
== EM_PARISC
2209 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2211 const char * result
;
2213 switch (filedata
->file_header
.e_machine
)
2216 result
= get_parisc_dynamic_type (type
);
2219 result
= get_ia64_dynamic_type (type
);
2222 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2223 result
= get_solaris_dynamic_type (type
);
2232 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2236 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2243 get_file_type (unsigned e_type
)
2245 static char buff
[32];
2249 case ET_NONE
: return _("NONE (None)");
2250 case ET_REL
: return _("REL (Relocatable file)");
2251 case ET_EXEC
: return _("EXEC (Executable file)");
2252 case ET_DYN
: return _("DYN (Shared object file)");
2253 case ET_CORE
: return _("CORE (Core file)");
2256 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2257 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2258 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2259 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2261 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2267 get_machine_name (unsigned e_machine
)
2269 static char buff
[64]; /* XXX */
2273 /* Please keep this switch table sorted by increasing EM_ value. */
2275 case EM_NONE
: return _("None");
2276 case EM_M32
: return "WE32100";
2277 case EM_SPARC
: return "Sparc";
2278 case EM_386
: return "Intel 80386";
2279 case EM_68K
: return "MC68000";
2280 case EM_88K
: return "MC88000";
2281 case EM_IAMCU
: return "Intel MCU";
2282 case EM_860
: return "Intel 80860";
2283 case EM_MIPS
: return "MIPS R3000";
2284 case EM_S370
: return "IBM System/370";
2286 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2287 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2288 case EM_PARISC
: return "HPPA";
2289 case EM_VPP550
: return "Fujitsu VPP500";
2290 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2291 case EM_960
: return "Intel 80960";
2292 case EM_PPC
: return "PowerPC";
2294 case EM_PPC64
: return "PowerPC64";
2296 case EM_S390
: return "IBM S/390";
2297 case EM_SPU
: return "SPU";
2299 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2300 case EM_FR20
: return "Fujitsu FR20";
2301 case EM_RH32
: return "TRW RH32";
2302 case EM_MCORE
: return "MCORE";
2304 case EM_ARM
: return "ARM";
2305 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2306 case EM_SH
: return "Renesas / SuperH SH";
2307 case EM_SPARCV9
: return "Sparc v9";
2308 case EM_TRICORE
: return "Siemens Tricore";
2309 case EM_ARC
: return "ARC";
2310 case EM_H8_300
: return "Renesas H8/300";
2311 case EM_H8_300H
: return "Renesas H8/300H";
2312 case EM_H8S
: return "Renesas H8S";
2313 case EM_H8_500
: return "Renesas H8/500";
2315 case EM_IA_64
: return "Intel IA-64";
2316 case EM_MIPS_X
: return "Stanford MIPS-X";
2317 case EM_COLDFIRE
: return "Motorola Coldfire";
2318 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2319 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2320 case EM_PCP
: return "Siemens PCP";
2321 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2322 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2323 case EM_STARCORE
: return "Motorola Star*Core processor";
2324 case EM_ME16
: return "Toyota ME16 processor";
2326 case EM_ST100
: return "STMicroelectronics ST100 processor";
2327 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2328 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2329 case EM_PDSP
: return "Sony DSP processor";
2330 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2331 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2332 case EM_FX66
: return "Siemens FX66 microcontroller";
2333 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2334 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2335 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2337 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2338 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2339 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2340 case EM_SVX
: return "Silicon Graphics SVx";
2341 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2342 case EM_VAX
: return "Digital VAX";
2343 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2344 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2345 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2346 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2348 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2349 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2350 case EM_PRISM
: return "Vitesse Prism";
2352 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2353 case EM_CYGNUS_FR30
:
2354 case EM_FR30
: return "Fujitsu FR30";
2355 case EM_CYGNUS_D10V
:
2356 case EM_D10V
: return "d10v";
2357 case EM_CYGNUS_D30V
:
2358 case EM_D30V
: return "d30v";
2359 case EM_CYGNUS_V850
:
2360 case EM_V850
: return "Renesas V850";
2361 case EM_CYGNUS_M32R
:
2362 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2363 case EM_CYGNUS_MN10300
:
2364 case EM_MN10300
: return "mn10300";
2366 case EM_CYGNUS_MN10200
:
2367 case EM_MN10200
: return "mn10200";
2368 case EM_PJ
: return "picoJava";
2369 case EM_OR1K
: return "OpenRISC 1000";
2370 case EM_ARC_COMPACT
: return "ARCompact";
2372 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2373 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2374 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2375 case EM_NS32K
: return "National Semiconductor 32000 series";
2376 case EM_TPC
: return "Tenor Network TPC processor";
2377 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2379 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2381 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2382 case EM_MAX
: return "MAX Processor";
2383 case EM_CR
: return "National Semiconductor CompactRISC";
2384 case EM_F2MC16
: return "Fujitsu F2MC16";
2385 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2386 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2387 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2388 case EM_SEP
: return "Sharp embedded microprocessor";
2389 case EM_ARCA
: return "Arca RISC microprocessor";
2391 case EM_UNICORE
: return "Unicore";
2392 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2393 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2394 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2395 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2396 case EM_XGATE
: return "Motorola XGATE embedded processor";
2398 case EM_XC16X
: return "Infineon Technologies xc16x";
2399 case EM_M16C
: return "Renesas M16C series microprocessors";
2400 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2401 case EM_CE
: return "Freescale Communication Engine RISC core";
2403 case EM_M32C
: return "Renesas M32c";
2405 case EM_TSK3000
: return "Altium TSK3000 core";
2406 case EM_RS08
: return "Freescale RS08 embedded processor";
2407 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2408 case EM_SCORE
: return "SUNPLUS S+Core";
2409 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2410 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2411 case EM_LATTICEMICO32
: return "Lattice Mico32";
2412 case EM_SE_C17
: return "Seiko Epson C17 family";
2414 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2415 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2416 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2417 case EM_TI_PRU
: return "TI PRU I/O processor";
2419 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2420 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2421 case EM_R32C
: return "Renesas R32C series microprocessors";
2422 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2423 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2424 case EM_8051
: return "Intel 8051 and variants";
2425 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2426 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2427 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2428 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2430 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2431 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2432 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2433 case EM_RX
: return "Renesas RX";
2434 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2435 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2436 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2439 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2440 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2441 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2443 case EM_L1OM
: return "Intel L1OM";
2444 case EM_K1OM
: return "Intel K1OM";
2445 case EM_INTEL182
: return "Intel (reserved)";
2446 case EM_AARCH64
: return "AArch64";
2447 case EM_ARM184
: return "ARM (reserved)";
2448 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2449 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2450 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2451 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2453 case EM_CUDA
: return "NVIDIA CUDA architecture";
2454 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2455 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2456 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2457 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2458 case EM_ARC_COMPACT2
: return "ARCv2";
2459 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2460 case EM_RL78
: return "Renesas RL78";
2461 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2462 case EM_78K0R
: return "Renesas 78K0R";
2464 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2465 case EM_BA1
: return "Beyond BA1 CPU architecture";
2466 case EM_BA2
: return "Beyond BA2 CPU architecture";
2467 case EM_XCORE
: return "XMOS xCORE processor family";
2468 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2470 case EM_KM32
: return "KM211 KM32 32-bit processor";
2471 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2472 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2473 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2474 case EM_KVARC
: return "KM211 KVARC processor";
2475 case EM_CDP
: return "Paneve CDP architecture family";
2476 case EM_COGE
: return "Cognitive Smart Memory Processor";
2477 case EM_COOL
: return "Bluechip Systems CoolEngine";
2478 case EM_NORC
: return "Nanoradio Optimized RISC";
2479 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2481 case EM_Z80
: return "Zilog Z80";
2482 case EM_VISIUM
: return "CDS VISIUMcore processor";
2483 case EM_FT32
: return "FTDI Chip FT32";
2484 case EM_MOXIE
: return "Moxie";
2485 case EM_AMDGPU
: return "AMD GPU";
2486 case EM_RISCV
: return "RISC-V";
2487 case EM_LANAI
: return "Lanai 32-bit processor";
2488 case EM_BPF
: return "Linux BPF";
2489 case EM_NFP
: return "Netronome Flow Processor";
2491 /* Large numbers... */
2492 case EM_MT
: return "Morpho Techologies MT processor";
2493 case EM_ALPHA
: return "Alpha";
2494 case EM_WEBASSEMBLY
: return "Web Assembly";
2495 case EM_DLX
: return "OpenDLX";
2496 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2497 case EM_IQ2000
: return "Vitesse IQ2000";
2499 case EM_NIOS32
: return "Altera Nios";
2500 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2501 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2502 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2503 case EM_S12Z
: return "Freescale S12Z";
2506 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2512 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2514 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2515 other compilers don't a specific architecture type in the e_flags, and
2516 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2517 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2520 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2521 but also sets a specific architecture type in the e_flags field.
2523 However, when decoding the flags we don't worry if we see an
2524 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2525 ARCEM architecture type. */
2527 switch (e_flags
& EF_ARC_MACH_MSK
)
2529 /* We only expect these to occur for EM_ARC_COMPACT2. */
2530 case EF_ARC_CPU_ARCV2EM
:
2531 strcat (buf
, ", ARC EM");
2533 case EF_ARC_CPU_ARCV2HS
:
2534 strcat (buf
, ", ARC HS");
2537 /* We only expect these to occur for EM_ARC_COMPACT. */
2538 case E_ARC_MACH_ARC600
:
2539 strcat (buf
, ", ARC600");
2541 case E_ARC_MACH_ARC601
:
2542 strcat (buf
, ", ARC601");
2544 case E_ARC_MACH_ARC700
:
2545 strcat (buf
, ", ARC700");
2548 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2549 new ELF with new architecture being read by an old version of
2550 readelf, or (c) An ELF built with non-GNU compiler that does not
2551 set the architecture in the e_flags. */
2553 if (e_machine
== EM_ARC_COMPACT
)
2554 strcat (buf
, ", Unknown ARCompact");
2556 strcat (buf
, ", Unknown ARC");
2560 switch (e_flags
& EF_ARC_OSABI_MSK
)
2562 case E_ARC_OSABI_ORIG
:
2563 strcat (buf
, ", (ABI:legacy)");
2565 case E_ARC_OSABI_V2
:
2566 strcat (buf
, ", (ABI:v2)");
2568 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2569 case E_ARC_OSABI_V3
:
2570 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2572 case E_ARC_OSABI_V4
:
2573 strcat (buf
, ", v4 ABI");
2576 strcat (buf
, ", unrecognised ARC OSABI flag");
2582 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2585 bfd_boolean unknown
= FALSE
;
2587 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2588 e_flags
&= ~ EF_ARM_EABIMASK
;
2590 /* Handle "generic" ARM flags. */
2591 if (e_flags
& EF_ARM_RELEXEC
)
2593 strcat (buf
, ", relocatable executable");
2594 e_flags
&= ~ EF_ARM_RELEXEC
;
2597 if (e_flags
& EF_ARM_PIC
)
2599 strcat (buf
, ", position independent");
2600 e_flags
&= ~ EF_ARM_PIC
;
2603 /* Now handle EABI specific flags. */
2607 strcat (buf
, ", <unrecognized EABI>");
2612 case EF_ARM_EABI_VER1
:
2613 strcat (buf
, ", Version1 EABI");
2618 /* Process flags one bit at a time. */
2619 flag
= e_flags
& - e_flags
;
2624 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2625 strcat (buf
, ", sorted symbol tables");
2635 case EF_ARM_EABI_VER2
:
2636 strcat (buf
, ", Version2 EABI");
2641 /* Process flags one bit at a time. */
2642 flag
= e_flags
& - e_flags
;
2647 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2648 strcat (buf
, ", sorted symbol tables");
2651 case EF_ARM_DYNSYMSUSESEGIDX
:
2652 strcat (buf
, ", dynamic symbols use segment index");
2655 case EF_ARM_MAPSYMSFIRST
:
2656 strcat (buf
, ", mapping symbols precede others");
2666 case EF_ARM_EABI_VER3
:
2667 strcat (buf
, ", Version3 EABI");
2670 case EF_ARM_EABI_VER4
:
2671 strcat (buf
, ", Version4 EABI");
2676 /* Process flags one bit at a time. */
2677 flag
= e_flags
& - e_flags
;
2683 strcat (buf
, ", BE8");
2687 strcat (buf
, ", LE8");
2697 case EF_ARM_EABI_VER5
:
2698 strcat (buf
, ", Version5 EABI");
2703 /* Process flags one bit at a time. */
2704 flag
= e_flags
& - e_flags
;
2710 strcat (buf
, ", BE8");
2714 strcat (buf
, ", LE8");
2717 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2718 strcat (buf
, ", soft-float ABI");
2721 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2722 strcat (buf
, ", hard-float ABI");
2732 case EF_ARM_EABI_UNKNOWN
:
2733 strcat (buf
, ", GNU EABI");
2738 /* Process flags one bit at a time. */
2739 flag
= e_flags
& - e_flags
;
2744 case EF_ARM_INTERWORK
:
2745 strcat (buf
, ", interworking enabled");
2748 case EF_ARM_APCS_26
:
2749 strcat (buf
, ", uses APCS/26");
2752 case EF_ARM_APCS_FLOAT
:
2753 strcat (buf
, ", uses APCS/float");
2757 strcat (buf
, ", position independent");
2761 strcat (buf
, ", 8 bit structure alignment");
2764 case EF_ARM_NEW_ABI
:
2765 strcat (buf
, ", uses new ABI");
2768 case EF_ARM_OLD_ABI
:
2769 strcat (buf
, ", uses old ABI");
2772 case EF_ARM_SOFT_FLOAT
:
2773 strcat (buf
, ", software FP");
2776 case EF_ARM_VFP_FLOAT
:
2777 strcat (buf
, ", VFP");
2780 case EF_ARM_MAVERICK_FLOAT
:
2781 strcat (buf
, ", Maverick FP");
2792 strcat (buf
,_(", <unknown>"));
2796 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2798 --size
; /* Leave space for null terminator. */
2800 switch (e_flags
& EF_AVR_MACH
)
2802 case E_AVR_MACH_AVR1
:
2803 strncat (buf
, ", avr:1", size
);
2805 case E_AVR_MACH_AVR2
:
2806 strncat (buf
, ", avr:2", size
);
2808 case E_AVR_MACH_AVR25
:
2809 strncat (buf
, ", avr:25", size
);
2811 case E_AVR_MACH_AVR3
:
2812 strncat (buf
, ", avr:3", size
);
2814 case E_AVR_MACH_AVR31
:
2815 strncat (buf
, ", avr:31", size
);
2817 case E_AVR_MACH_AVR35
:
2818 strncat (buf
, ", avr:35", size
);
2820 case E_AVR_MACH_AVR4
:
2821 strncat (buf
, ", avr:4", size
);
2823 case E_AVR_MACH_AVR5
:
2824 strncat (buf
, ", avr:5", size
);
2826 case E_AVR_MACH_AVR51
:
2827 strncat (buf
, ", avr:51", size
);
2829 case E_AVR_MACH_AVR6
:
2830 strncat (buf
, ", avr:6", size
);
2832 case E_AVR_MACH_AVRTINY
:
2833 strncat (buf
, ", avr:100", size
);
2835 case E_AVR_MACH_XMEGA1
:
2836 strncat (buf
, ", avr:101", size
);
2838 case E_AVR_MACH_XMEGA2
:
2839 strncat (buf
, ", avr:102", size
);
2841 case E_AVR_MACH_XMEGA3
:
2842 strncat (buf
, ", avr:103", size
);
2844 case E_AVR_MACH_XMEGA4
:
2845 strncat (buf
, ", avr:104", size
);
2847 case E_AVR_MACH_XMEGA5
:
2848 strncat (buf
, ", avr:105", size
);
2850 case E_AVR_MACH_XMEGA6
:
2851 strncat (buf
, ", avr:106", size
);
2853 case E_AVR_MACH_XMEGA7
:
2854 strncat (buf
, ", avr:107", size
);
2857 strncat (buf
, ", avr:<unknown>", size
);
2861 size
-= strlen (buf
);
2862 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2863 strncat (buf
, ", link-relax", size
);
2867 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2873 bfd_boolean has_fpu
= FALSE
;
2876 static const char *ABI_STRINGS
[] =
2878 "ABI v0", /* use r5 as return register; only used in N1213HC */
2879 "ABI v1", /* use r0 as return register */
2880 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2881 "ABI v2fp", /* for FPU */
2885 static const char *VER_STRINGS
[] =
2887 "Andes ELF V1.3 or older",
2891 static const char *ARCH_STRINGS
[] =
2900 abi
= EF_NDS_ABI
& e_flags
;
2901 arch
= EF_NDS_ARCH
& e_flags
;
2902 config
= EF_NDS_INST
& e_flags
;
2903 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2905 memset (buf
, 0, size
);
2912 case E_NDS_ABI_V2FP
:
2913 case E_NDS_ABI_AABI
:
2914 case E_NDS_ABI_V2FP_PLUS
:
2915 /* In case there are holes in the array. */
2916 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2920 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2926 case E_NDS32_ELF_VER_1_2
:
2927 case E_NDS32_ELF_VER_1_3
:
2928 case E_NDS32_ELF_VER_1_4
:
2929 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2933 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2937 if (E_NDS_ABI_V0
== abi
)
2939 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2940 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2941 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2942 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2948 case E_NDS_ARCH_STAR_V1_0
:
2949 case E_NDS_ARCH_STAR_V2_0
:
2950 case E_NDS_ARCH_STAR_V3_0
:
2951 case E_NDS_ARCH_STAR_V3_M
:
2952 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2956 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2957 /* ARCH version determines how the e_flags are interpreted.
2958 If it is unknown, we cannot proceed. */
2962 /* Newer ABI; Now handle architecture specific flags. */
2963 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2965 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2966 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2968 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2969 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2971 if (config
& E_NDS32_HAS_DIV_INST
)
2972 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2974 if (config
& E_NDS32_HAS_16BIT_INST
)
2975 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2979 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2981 if (version
<= E_NDS32_ELF_VER_1_3
)
2982 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2984 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2987 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2988 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2990 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2991 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2993 if (config
& E_NDS32_HAS_16BIT_INST
)
2995 if (version
<= E_NDS32_ELF_VER_1_3
)
2996 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2998 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3002 if (config
& E_NDS32_HAS_EXT_INST
)
3003 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3005 if (config
& E_NDS32_HAS_EXT2_INST
)
3006 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3008 if (config
& E_NDS32_HAS_FPU_INST
)
3011 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3014 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3017 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3020 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3023 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3028 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3030 case E_NDS32_FPU_REG_8SP_4DP
:
3031 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3033 case E_NDS32_FPU_REG_16SP_8DP
:
3034 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3036 case E_NDS32_FPU_REG_32SP_16DP
:
3037 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3039 case E_NDS32_FPU_REG_32SP_32DP
:
3040 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3045 if (config
& E_NDS32_HAS_AUDIO_INST
)
3046 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3048 if (config
& E_NDS32_HAS_STRING_INST
)
3049 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3051 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3052 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3054 if (config
& E_NDS32_HAS_VIDEO_INST
)
3056 if (version
<= E_NDS32_ELF_VER_1_3
)
3057 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3059 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3062 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3063 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3065 if (config
& E_NDS32_HAS_L2C_INST
)
3066 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3070 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3072 static char buf
[1024];
3083 case EM_ARC_COMPACT2
:
3084 case EM_ARC_COMPACT
:
3085 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3089 decode_ARM_machine_flags (e_flags
, buf
);
3093 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3097 if (e_flags
& EF_BFIN_PIC
)
3098 strcat (buf
, ", PIC");
3100 if (e_flags
& EF_BFIN_FDPIC
)
3101 strcat (buf
, ", FDPIC");
3103 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3104 strcat (buf
, ", code in L1");
3106 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3107 strcat (buf
, ", data in L1");
3112 switch (e_flags
& EF_FRV_CPU_MASK
)
3114 case EF_FRV_CPU_GENERIC
:
3118 strcat (buf
, ", fr???");
3121 case EF_FRV_CPU_FR300
:
3122 strcat (buf
, ", fr300");
3125 case EF_FRV_CPU_FR400
:
3126 strcat (buf
, ", fr400");
3128 case EF_FRV_CPU_FR405
:
3129 strcat (buf
, ", fr405");
3132 case EF_FRV_CPU_FR450
:
3133 strcat (buf
, ", fr450");
3136 case EF_FRV_CPU_FR500
:
3137 strcat (buf
, ", fr500");
3139 case EF_FRV_CPU_FR550
:
3140 strcat (buf
, ", fr550");
3143 case EF_FRV_CPU_SIMPLE
:
3144 strcat (buf
, ", simple");
3146 case EF_FRV_CPU_TOMCAT
:
3147 strcat (buf
, ", tomcat");
3153 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3154 strcat (buf
, ", m68000");
3155 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3156 strcat (buf
, ", cpu32");
3157 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3158 strcat (buf
, ", fido_a");
3161 char const * isa
= _("unknown");
3162 char const * mac
= _("unknown mac");
3163 char const * additional
= NULL
;
3165 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3167 case EF_M68K_CF_ISA_A_NODIV
:
3169 additional
= ", nodiv";
3171 case EF_M68K_CF_ISA_A
:
3174 case EF_M68K_CF_ISA_A_PLUS
:
3177 case EF_M68K_CF_ISA_B_NOUSP
:
3179 additional
= ", nousp";
3181 case EF_M68K_CF_ISA_B
:
3184 case EF_M68K_CF_ISA_C
:
3187 case EF_M68K_CF_ISA_C_NODIV
:
3189 additional
= ", nodiv";
3192 strcat (buf
, ", cf, isa ");
3195 strcat (buf
, additional
);
3196 if (e_flags
& EF_M68K_CF_FLOAT
)
3197 strcat (buf
, ", float");
3198 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3203 case EF_M68K_CF_MAC
:
3206 case EF_M68K_CF_EMAC
:
3209 case EF_M68K_CF_EMAC_B
:
3222 switch (e_flags
& EF_MEP_CPU_MASK
)
3224 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3225 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3226 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3227 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3228 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3229 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3230 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3233 switch (e_flags
& EF_MEP_COP_MASK
)
3235 case EF_MEP_COP_NONE
: break;
3236 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3237 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3238 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3239 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3240 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3243 if (e_flags
& EF_MEP_LIBRARY
)
3244 strcat (buf
, ", Built for Library");
3246 if (e_flags
& EF_MEP_INDEX_MASK
)
3247 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3248 e_flags
& EF_MEP_INDEX_MASK
);
3250 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3251 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3252 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3256 if (e_flags
& EF_PPC_EMB
)
3257 strcat (buf
, ", emb");
3259 if (e_flags
& EF_PPC_RELOCATABLE
)
3260 strcat (buf
, _(", relocatable"));
3262 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3263 strcat (buf
, _(", relocatable-lib"));
3267 if (e_flags
& EF_PPC64_ABI
)
3269 char abi
[] = ", abiv0";
3271 abi
[6] += e_flags
& EF_PPC64_ABI
;
3277 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3278 strcat (buf
, ", RH850 ABI");
3280 if (e_flags
& EF_V800_850E3
)
3281 strcat (buf
, ", V3 architecture");
3283 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3284 strcat (buf
, ", FPU not used");
3286 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3287 strcat (buf
, ", regmode: COMMON");
3289 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3290 strcat (buf
, ", r4 not used");
3292 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3293 strcat (buf
, ", r30 not used");
3295 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3296 strcat (buf
, ", r5 not used");
3298 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3299 strcat (buf
, ", r2 not used");
3301 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3303 switch (e_flags
& - e_flags
)
3305 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3306 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3307 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3308 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3309 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3310 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3311 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3312 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3313 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3314 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3315 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3316 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3323 case EM_CYGNUS_V850
:
3324 switch (e_flags
& EF_V850_ARCH
)
3326 case E_V850E3V5_ARCH
:
3327 strcat (buf
, ", v850e3v5");
3329 case E_V850E2V3_ARCH
:
3330 strcat (buf
, ", v850e2v3");
3333 strcat (buf
, ", v850e2");
3336 strcat (buf
, ", v850e1");
3339 strcat (buf
, ", v850e");
3342 strcat (buf
, ", v850");
3345 strcat (buf
, _(", unknown v850 architecture variant"));
3351 case EM_CYGNUS_M32R
:
3352 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3353 strcat (buf
, ", m32r");
3357 case EM_MIPS_RS3_LE
:
3358 if (e_flags
& EF_MIPS_NOREORDER
)
3359 strcat (buf
, ", noreorder");
3361 if (e_flags
& EF_MIPS_PIC
)
3362 strcat (buf
, ", pic");
3364 if (e_flags
& EF_MIPS_CPIC
)
3365 strcat (buf
, ", cpic");
3367 if (e_flags
& EF_MIPS_UCODE
)
3368 strcat (buf
, ", ugen_reserved");
3370 if (e_flags
& EF_MIPS_ABI2
)
3371 strcat (buf
, ", abi2");
3373 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3374 strcat (buf
, ", odk first");
3376 if (e_flags
& EF_MIPS_32BITMODE
)
3377 strcat (buf
, ", 32bitmode");
3379 if (e_flags
& EF_MIPS_NAN2008
)
3380 strcat (buf
, ", nan2008");
3382 if (e_flags
& EF_MIPS_FP64
)
3383 strcat (buf
, ", fp64");
3385 switch ((e_flags
& EF_MIPS_MACH
))
3387 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3388 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3389 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3390 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3391 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3392 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3393 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3394 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3395 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3396 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3397 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3398 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3399 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3400 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3401 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3402 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3403 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3404 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3405 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3407 /* We simply ignore the field in this case to avoid confusion:
3408 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3411 default: strcat (buf
, _(", unknown CPU")); break;
3414 switch ((e_flags
& EF_MIPS_ABI
))
3416 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3417 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3418 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3419 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3421 /* We simply ignore the field in this case to avoid confusion:
3422 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3423 This means it is likely to be an o32 file, but not for
3426 default: strcat (buf
, _(", unknown ABI")); break;
3429 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3430 strcat (buf
, ", mdmx");
3432 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3433 strcat (buf
, ", mips16");
3435 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3436 strcat (buf
, ", micromips");
3438 switch ((e_flags
& EF_MIPS_ARCH
))
3440 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3441 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3442 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3443 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3444 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3445 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3446 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3447 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3448 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3449 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3450 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3451 default: strcat (buf
, _(", unknown ISA")); break;
3456 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3460 switch (EF_NFP_MACH (e_flags
))
3462 case E_NFP_MACH_3200
:
3463 strcat (buf
, ", NFP-32xx");
3465 case E_NFP_MACH_6000
:
3466 strcat (buf
, ", NFP-6xxx");
3472 if (e_flags
& EF_RISCV_RVC
)
3473 strcat (buf
, ", RVC");
3475 if (e_flags
& EF_RISCV_RVE
)
3476 strcat (buf
, ", RVE");
3478 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3480 case EF_RISCV_FLOAT_ABI_SOFT
:
3481 strcat (buf
, ", soft-float ABI");
3484 case EF_RISCV_FLOAT_ABI_SINGLE
:
3485 strcat (buf
, ", single-float ABI");
3488 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3489 strcat (buf
, ", double-float ABI");
3492 case EF_RISCV_FLOAT_ABI_QUAD
:
3493 strcat (buf
, ", quad-float ABI");
3499 switch ((e_flags
& EF_SH_MACH_MASK
))
3501 case EF_SH1
: strcat (buf
, ", sh1"); break;
3502 case EF_SH2
: strcat (buf
, ", sh2"); break;
3503 case EF_SH3
: strcat (buf
, ", sh3"); break;
3504 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3505 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3506 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3507 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3508 case EF_SH4
: strcat (buf
, ", sh4"); break;
3509 case EF_SH5
: strcat (buf
, ", sh5"); break;
3510 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3511 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3512 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3513 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3514 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3515 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3516 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3517 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3518 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3519 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3520 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3521 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3522 default: strcat (buf
, _(", unknown ISA")); break;
3525 if (e_flags
& EF_SH_PIC
)
3526 strcat (buf
, ", pic");
3528 if (e_flags
& EF_SH_FDPIC
)
3529 strcat (buf
, ", fdpic");
3533 if (e_flags
& EF_OR1K_NODELAY
)
3534 strcat (buf
, ", no delay");
3538 if (e_flags
& EF_SPARC_32PLUS
)
3539 strcat (buf
, ", v8+");
3541 if (e_flags
& EF_SPARC_SUN_US1
)
3542 strcat (buf
, ", ultrasparcI");
3544 if (e_flags
& EF_SPARC_SUN_US3
)
3545 strcat (buf
, ", ultrasparcIII");
3547 if (e_flags
& EF_SPARC_HAL_R1
)
3548 strcat (buf
, ", halr1");
3550 if (e_flags
& EF_SPARC_LEDATA
)
3551 strcat (buf
, ", ledata");
3553 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3554 strcat (buf
, ", tso");
3556 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3557 strcat (buf
, ", pso");
3559 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3560 strcat (buf
, ", rmo");
3564 switch (e_flags
& EF_PARISC_ARCH
)
3566 case EFA_PARISC_1_0
:
3567 strcpy (buf
, ", PA-RISC 1.0");
3569 case EFA_PARISC_1_1
:
3570 strcpy (buf
, ", PA-RISC 1.1");
3572 case EFA_PARISC_2_0
:
3573 strcpy (buf
, ", PA-RISC 2.0");
3578 if (e_flags
& EF_PARISC_TRAPNIL
)
3579 strcat (buf
, ", trapnil");
3580 if (e_flags
& EF_PARISC_EXT
)
3581 strcat (buf
, ", ext");
3582 if (e_flags
& EF_PARISC_LSB
)
3583 strcat (buf
, ", lsb");
3584 if (e_flags
& EF_PARISC_WIDE
)
3585 strcat (buf
, ", wide");
3586 if (e_flags
& EF_PARISC_NO_KABP
)
3587 strcat (buf
, ", no kabp");
3588 if (e_flags
& EF_PARISC_LAZYSWAP
)
3589 strcat (buf
, ", lazyswap");
3594 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3595 strcat (buf
, ", new calling convention");
3597 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3598 strcat (buf
, ", gnu calling convention");
3602 if ((e_flags
& EF_IA_64_ABI64
))
3603 strcat (buf
, ", 64-bit");
3605 strcat (buf
, ", 32-bit");
3606 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3607 strcat (buf
, ", reduced fp model");
3608 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3609 strcat (buf
, ", no function descriptors, constant gp");
3610 else if ((e_flags
& EF_IA_64_CONS_GP
))
3611 strcat (buf
, ", constant gp");
3612 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3613 strcat (buf
, ", absolute");
3614 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3616 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3617 strcat (buf
, ", vms_linkages");
3618 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3620 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3622 case EF_IA_64_VMS_COMCOD_WARNING
:
3623 strcat (buf
, ", warning");
3625 case EF_IA_64_VMS_COMCOD_ERROR
:
3626 strcat (buf
, ", error");
3628 case EF_IA_64_VMS_COMCOD_ABORT
:
3629 strcat (buf
, ", abort");
3632 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3633 e_flags
& EF_IA_64_VMS_COMCOD
);
3634 strcat (buf
, ", <unknown>");
3640 if ((e_flags
& EF_VAX_NONPIC
))
3641 strcat (buf
, ", non-PIC");
3642 if ((e_flags
& EF_VAX_DFLOAT
))
3643 strcat (buf
, ", D-Float");
3644 if ((e_flags
& EF_VAX_GFLOAT
))
3645 strcat (buf
, ", G-Float");
3649 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3650 strcat (buf
, ", mcm");
3651 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3652 strcat (buf
, ", mcm24");
3653 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3654 strcat (buf
, ", gr6");
3658 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3660 case E_FLAG_RL78_ANY_CPU
: break;
3661 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3662 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3663 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3665 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3666 strcat (buf
, ", 64-bit doubles");
3670 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3671 strcat (buf
, ", 64-bit doubles");
3672 if (e_flags
& E_FLAG_RX_DSP
)
3673 strcat (buf
, ", dsp");
3674 if (e_flags
& E_FLAG_RX_PID
)
3675 strcat (buf
, ", pid");
3676 if (e_flags
& E_FLAG_RX_ABI
)
3677 strcat (buf
, ", RX ABI");
3678 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3679 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3680 ? ", uses String instructions" : ", bans String instructions");
3681 if (e_flags
& E_FLAG_RX_V2
)
3682 strcat (buf
, ", V2");
3686 if (e_flags
& EF_S390_HIGH_GPRS
)
3687 strcat (buf
, ", highgprs");
3691 if ((e_flags
& EF_C6000_REL
))
3692 strcat (buf
, ", relocatable module");
3696 strcat (buf
, _(": architecture variant: "));
3697 switch (e_flags
& EF_MSP430_MACH
)
3699 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3700 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3701 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3702 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3703 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3704 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3705 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3706 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3707 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3708 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3709 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3710 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3711 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3712 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3713 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3715 strcat (buf
, _(": unknown")); break;
3718 if (e_flags
& ~ EF_MSP430_MACH
)
3719 strcat (buf
, _(": unknown extra flag bits also present"));
3727 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3729 static char buff
[32];
3733 case ELFOSABI_NONE
: return "UNIX - System V";
3734 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3735 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3736 case ELFOSABI_GNU
: return "UNIX - GNU";
3737 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3738 case ELFOSABI_AIX
: return "UNIX - AIX";
3739 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3740 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3741 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3742 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3743 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3744 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3745 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3746 case ELFOSABI_AROS
: return "AROS";
3747 case ELFOSABI_FENIXOS
: return "FenixOS";
3748 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3749 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3752 switch (filedata
->file_header
.e_machine
)
3757 case ELFOSABI_ARM
: return "ARM";
3758 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3769 case ELFOSABI_STANDALONE
: return _("Standalone App");
3778 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3779 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3788 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3794 get_aarch64_segment_type (unsigned long type
)
3798 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3799 default: return NULL
;
3804 get_arm_segment_type (unsigned long type
)
3808 case PT_ARM_EXIDX
: return "EXIDX";
3809 default: return NULL
;
3814 get_s390_segment_type (unsigned long type
)
3818 case PT_S390_PGSTE
: return "S390_PGSTE";
3819 default: return NULL
;
3824 get_mips_segment_type (unsigned long type
)
3828 case PT_MIPS_REGINFO
: return "REGINFO";
3829 case PT_MIPS_RTPROC
: return "RTPROC";
3830 case PT_MIPS_OPTIONS
: return "OPTIONS";
3831 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3832 default: return NULL
;
3837 get_parisc_segment_type (unsigned long type
)
3841 case PT_HP_TLS
: return "HP_TLS";
3842 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3843 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3844 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3845 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3846 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3847 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3848 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3849 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3850 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3851 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3852 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3853 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3854 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3855 case PT_HP_STACK
: return "HP_STACK";
3856 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3857 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3858 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3859 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3860 default: return NULL
;
3865 get_ia64_segment_type (unsigned long type
)
3869 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3870 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3871 case PT_HP_TLS
: return "HP_TLS";
3872 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3873 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3874 case PT_IA_64_HP_STACK
: return "HP_STACK";
3875 default: return NULL
;
3880 get_tic6x_segment_type (unsigned long type
)
3884 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3885 default: return NULL
;
3890 get_solaris_segment_type (unsigned long type
)
3894 case 0x6464e550: return "PT_SUNW_UNWIND";
3895 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3896 case 0x6ffffff7: return "PT_LOSUNW";
3897 case 0x6ffffffa: return "PT_SUNWBSS";
3898 case 0x6ffffffb: return "PT_SUNWSTACK";
3899 case 0x6ffffffc: return "PT_SUNWDTRACE";
3900 case 0x6ffffffd: return "PT_SUNWCAP";
3901 case 0x6fffffff: return "PT_HISUNW";
3902 default: return NULL
;
3907 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3909 static char buff
[32];
3913 case PT_NULL
: return "NULL";
3914 case PT_LOAD
: return "LOAD";
3915 case PT_DYNAMIC
: return "DYNAMIC";
3916 case PT_INTERP
: return "INTERP";
3917 case PT_NOTE
: return "NOTE";
3918 case PT_SHLIB
: return "SHLIB";
3919 case PT_PHDR
: return "PHDR";
3920 case PT_TLS
: return "TLS";
3921 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3922 case PT_GNU_STACK
: return "GNU_STACK";
3923 case PT_GNU_RELRO
: return "GNU_RELRO";
3926 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3928 sprintf (buff
, "GNU_MBIND+%#lx",
3929 p_type
- PT_GNU_MBIND_LO
);
3931 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3933 const char * result
;
3935 switch (filedata
->file_header
.e_machine
)
3938 result
= get_aarch64_segment_type (p_type
);
3941 result
= get_arm_segment_type (p_type
);
3944 case EM_MIPS_RS3_LE
:
3945 result
= get_mips_segment_type (p_type
);
3948 result
= get_parisc_segment_type (p_type
);
3951 result
= get_ia64_segment_type (p_type
);
3954 result
= get_tic6x_segment_type (p_type
);
3958 result
= get_s390_segment_type (p_type
);
3968 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3970 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3972 const char * result
;
3974 switch (filedata
->file_header
.e_machine
)
3977 result
= get_parisc_segment_type (p_type
);
3980 result
= get_ia64_segment_type (p_type
);
3983 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3984 result
= get_solaris_segment_type (p_type
);
3993 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3996 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4003 get_arc_section_type_name (unsigned int sh_type
)
4007 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4015 get_mips_section_type_name (unsigned int sh_type
)
4019 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4020 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4021 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4022 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4023 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4024 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4025 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4026 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4027 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4028 case SHT_MIPS_RELD
: return "MIPS_RELD";
4029 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4030 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4031 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4032 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4033 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4034 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4035 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4036 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4037 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4038 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4039 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4040 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4041 case SHT_MIPS_LINE
: return "MIPS_LINE";
4042 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4043 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4044 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4045 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4046 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4047 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4048 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4049 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4050 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4051 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4052 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4053 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4054 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4055 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4056 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4057 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4058 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4066 get_parisc_section_type_name (unsigned int sh_type
)
4070 case SHT_PARISC_EXT
: return "PARISC_EXT";
4071 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4072 case SHT_PARISC_DOC
: return "PARISC_DOC";
4073 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4074 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4075 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4076 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4077 default: return NULL
;
4082 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4084 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4085 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4086 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4090 case SHT_IA_64_EXT
: return "IA_64_EXT";
4091 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4092 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4093 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4094 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4095 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4096 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4097 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4098 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4099 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4107 get_x86_64_section_type_name (unsigned int sh_type
)
4111 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4112 default: return NULL
;
4117 get_aarch64_section_type_name (unsigned int sh_type
)
4121 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4122 default: return NULL
;
4127 get_arm_section_type_name (unsigned int sh_type
)
4131 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4132 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4133 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4134 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4135 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4136 default: return NULL
;
4141 get_tic6x_section_type_name (unsigned int sh_type
)
4145 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4146 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4147 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4148 case SHT_TI_ICODE
: return "TI_ICODE";
4149 case SHT_TI_XREF
: return "TI_XREF";
4150 case SHT_TI_HANDLER
: return "TI_HANDLER";
4151 case SHT_TI_INITINFO
: return "TI_INITINFO";
4152 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4153 default: return NULL
;
4158 get_msp430x_section_type_name (unsigned int sh_type
)
4162 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4163 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4164 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4165 default: return NULL
;
4170 get_nfp_section_type_name (unsigned int sh_type
)
4174 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4175 case SHT_NFP_INITREG
: return "NFP_INITREG";
4176 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4177 default: return NULL
;
4182 get_v850_section_type_name (unsigned int sh_type
)
4186 case SHT_V850_SCOMMON
: return "V850 Small Common";
4187 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4188 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4189 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4190 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4191 default: return NULL
;
4196 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4198 static char buff
[32];
4199 const char * result
;
4203 case SHT_NULL
: return "NULL";
4204 case SHT_PROGBITS
: return "PROGBITS";
4205 case SHT_SYMTAB
: return "SYMTAB";
4206 case SHT_STRTAB
: return "STRTAB";
4207 case SHT_RELA
: return "RELA";
4208 case SHT_HASH
: return "HASH";
4209 case SHT_DYNAMIC
: return "DYNAMIC";
4210 case SHT_NOTE
: return "NOTE";
4211 case SHT_NOBITS
: return "NOBITS";
4212 case SHT_REL
: return "REL";
4213 case SHT_SHLIB
: return "SHLIB";
4214 case SHT_DYNSYM
: return "DYNSYM";
4215 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4216 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4217 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4218 case SHT_GNU_HASH
: return "GNU_HASH";
4219 case SHT_GROUP
: return "GROUP";
4220 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4221 case SHT_GNU_verdef
: return "VERDEF";
4222 case SHT_GNU_verneed
: return "VERNEED";
4223 case SHT_GNU_versym
: return "VERSYM";
4224 case 0x6ffffff0: return "VERSYM";
4225 case 0x6ffffffc: return "VERDEF";
4226 case 0x7ffffffd: return "AUXILIARY";
4227 case 0x7fffffff: return "FILTER";
4228 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4231 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4233 switch (filedata
->file_header
.e_machine
)
4236 case EM_ARC_COMPACT
:
4237 case EM_ARC_COMPACT2
:
4238 result
= get_arc_section_type_name (sh_type
);
4241 case EM_MIPS_RS3_LE
:
4242 result
= get_mips_section_type_name (sh_type
);
4245 result
= get_parisc_section_type_name (sh_type
);
4248 result
= get_ia64_section_type_name (filedata
, sh_type
);
4253 result
= get_x86_64_section_type_name (sh_type
);
4256 result
= get_aarch64_section_type_name (sh_type
);
4259 result
= get_arm_section_type_name (sh_type
);
4262 result
= get_tic6x_section_type_name (sh_type
);
4265 result
= get_msp430x_section_type_name (sh_type
);
4268 result
= get_nfp_section_type_name (sh_type
);
4272 case EM_CYGNUS_V850
:
4273 result
= get_v850_section_type_name (sh_type
);
4283 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4285 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4287 switch (filedata
->file_header
.e_machine
)
4290 result
= get_ia64_section_type_name (filedata
, sh_type
);
4293 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4294 result
= get_solaris_section_type (sh_type
);
4299 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4300 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4301 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4302 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4314 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4316 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4318 switch (filedata
->file_header
.e_machine
)
4322 case EM_CYGNUS_V850
:
4323 result
= get_v850_section_type_name (sh_type
);
4333 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4336 /* This message is probably going to be displayed in a 15
4337 character wide field, so put the hex value first. */
4338 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4344 #define OPTION_DEBUG_DUMP 512
4345 #define OPTION_DYN_SYMS 513
4346 #define OPTION_DWARF_DEPTH 514
4347 #define OPTION_DWARF_START 515
4348 #define OPTION_DWARF_CHECK 516
4350 static struct option options
[] =
4352 {"all", no_argument
, 0, 'a'},
4353 {"file-header", no_argument
, 0, 'h'},
4354 {"program-headers", no_argument
, 0, 'l'},
4355 {"headers", no_argument
, 0, 'e'},
4356 {"histogram", no_argument
, 0, 'I'},
4357 {"segments", no_argument
, 0, 'l'},
4358 {"sections", no_argument
, 0, 'S'},
4359 {"section-headers", no_argument
, 0, 'S'},
4360 {"section-groups", no_argument
, 0, 'g'},
4361 {"section-details", no_argument
, 0, 't'},
4362 {"full-section-name",no_argument
, 0, 'N'},
4363 {"symbols", no_argument
, 0, 's'},
4364 {"syms", no_argument
, 0, 's'},
4365 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4366 {"relocs", no_argument
, 0, 'r'},
4367 {"notes", no_argument
, 0, 'n'},
4368 {"dynamic", no_argument
, 0, 'd'},
4369 {"arch-specific", no_argument
, 0, 'A'},
4370 {"version-info", no_argument
, 0, 'V'},
4371 {"use-dynamic", no_argument
, 0, 'D'},
4372 {"unwind", no_argument
, 0, 'u'},
4373 {"archive-index", no_argument
, 0, 'c'},
4374 {"hex-dump", required_argument
, 0, 'x'},
4375 {"relocated-dump", required_argument
, 0, 'R'},
4376 {"string-dump", required_argument
, 0, 'p'},
4377 {"decompress", no_argument
, 0, 'z'},
4378 #ifdef SUPPORT_DISASSEMBLY
4379 {"instruction-dump", required_argument
, 0, 'i'},
4381 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4383 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4384 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4385 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4387 {"version", no_argument
, 0, 'v'},
4388 {"wide", no_argument
, 0, 'W'},
4389 {"help", no_argument
, 0, 'H'},
4390 {0, no_argument
, 0, 0}
4394 usage (FILE * stream
)
4396 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4397 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4398 fprintf (stream
, _(" Options are:\n\
4399 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4400 -h --file-header Display the ELF file header\n\
4401 -l --program-headers Display the program headers\n\
4402 --segments An alias for --program-headers\n\
4403 -S --section-headers Display the sections' header\n\
4404 --sections An alias for --section-headers\n\
4405 -g --section-groups Display the section groups\n\
4406 -t --section-details Display the section details\n\
4407 -e --headers Equivalent to: -h -l -S\n\
4408 -s --syms Display the symbol table\n\
4409 --symbols An alias for --syms\n\
4410 --dyn-syms Display the dynamic symbol table\n\
4411 -n --notes Display the core notes (if present)\n\
4412 -r --relocs Display the relocations (if present)\n\
4413 -u --unwind Display the unwind info (if present)\n\
4414 -d --dynamic Display the dynamic section (if present)\n\
4415 -V --version-info Display the version sections (if present)\n\
4416 -A --arch-specific Display architecture specific information (if any)\n\
4417 -c --archive-index Display the symbol/file index in an archive\n\
4418 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4419 -x --hex-dump=<number|name>\n\
4420 Dump the contents of section <number|name> as bytes\n\
4421 -p --string-dump=<number|name>\n\
4422 Dump the contents of section <number|name> as strings\n\
4423 -R --relocated-dump=<number|name>\n\
4424 Dump the contents of section <number|name> as relocated bytes\n\
4425 -z --decompress Decompress section before dumping it\n\
4426 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4427 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4428 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4429 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4430 =addr,=cu_index,=links,=follow-links]\n\
4431 Display the contents of DWARF debug sections\n"));
4432 fprintf (stream
, _("\
4433 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4434 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4436 #ifdef SUPPORT_DISASSEMBLY
4437 fprintf (stream
, _("\
4438 -i --instruction-dump=<number|name>\n\
4439 Disassemble the contents of section <number|name>\n"));
4441 fprintf (stream
, _("\
4442 -I --histogram Display histogram of bucket list lengths\n\
4443 -W --wide Allow output width to exceed 80 characters\n\
4444 @<file> Read options from <file>\n\
4445 -H --help Display this information\n\
4446 -v --version Display the version number of readelf\n"));
4448 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4449 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4451 exit (stream
== stdout
? 0 : 1);
4454 /* Record the fact that the user wants the contents of section number
4455 SECTION to be displayed using the method(s) encoded as flags bits
4456 in TYPE. Note, TYPE can be zero if we are creating the array for
4460 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4462 if (section
>= filedata
->num_dump_sects
)
4464 dump_type
* new_dump_sects
;
4466 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4467 sizeof (* new_dump_sects
));
4469 if (new_dump_sects
== NULL
)
4470 error (_("Out of memory allocating dump request table.\n"));
4473 if (filedata
->dump_sects
)
4475 /* Copy current flag settings. */
4476 memcpy (new_dump_sects
, filedata
->dump_sects
,
4477 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4479 free (filedata
->dump_sects
);
4482 filedata
->dump_sects
= new_dump_sects
;
4483 filedata
->num_dump_sects
= section
+ 1;
4487 if (filedata
->dump_sects
)
4488 filedata
->dump_sects
[section
] |= type
;
4491 /* Request a dump by section name. */
4494 request_dump_byname (const char * section
, dump_type type
)
4496 struct dump_list_entry
* new_request
;
4498 new_request
= (struct dump_list_entry
*)
4499 malloc (sizeof (struct dump_list_entry
));
4501 error (_("Out of memory allocating dump request table.\n"));
4503 new_request
->name
= strdup (section
);
4504 if (!new_request
->name
)
4505 error (_("Out of memory allocating dump request table.\n"));
4507 new_request
->type
= type
;
4509 new_request
->next
= dump_sects_byname
;
4510 dump_sects_byname
= new_request
;
4514 request_dump (Filedata
* filedata
, dump_type type
)
4520 section
= strtoul (optarg
, & cp
, 0);
4522 if (! *cp
&& section
>= 0)
4523 request_dump_bynumber (filedata
, section
, type
);
4525 request_dump_byname (optarg
, type
);
4529 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4536 while ((c
= getopt_long
4537 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4555 do_section_groups
= TRUE
;
4558 do_histogram
= TRUE
;
4563 do_section_groups
= TRUE
;
4568 do_section_details
= TRUE
;
4579 do_using_dynamic
= TRUE
;
4603 do_histogram
= TRUE
;
4609 do_archive_index
= TRUE
;
4612 request_dump (filedata
, HEX_DUMP
);
4615 request_dump (filedata
, STRING_DUMP
);
4618 request_dump (filedata
, RELOC_DUMP
);
4621 decompress_dumps
= TRUE
;
4627 do_debugging
= TRUE
;
4628 dwarf_select_sections_all ();
4632 do_debugging
= FALSE
;
4633 dwarf_select_sections_by_letters (optarg
);
4636 case OPTION_DEBUG_DUMP
:
4639 do_debugging
= TRUE
;
4642 do_debugging
= FALSE
;
4643 dwarf_select_sections_by_names (optarg
);
4646 case OPTION_DWARF_DEPTH
:
4650 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4653 case OPTION_DWARF_START
:
4657 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4660 case OPTION_DWARF_CHECK
:
4663 case OPTION_DYN_SYMS
:
4666 #ifdef SUPPORT_DISASSEMBLY
4668 request_dump (filedata
, DISASS_DUMP
);
4672 print_version (program_name
);
4681 /* xgettext:c-format */
4682 error (_("Invalid option '-%c'\n"), c
);
4689 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4690 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4691 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4692 && !do_section_groups
&& !do_archive_index
4698 get_elf_class (unsigned int elf_class
)
4700 static char buff
[32];
4704 case ELFCLASSNONE
: return _("none");
4705 case ELFCLASS32
: return "ELF32";
4706 case ELFCLASS64
: return "ELF64";
4708 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4714 get_data_encoding (unsigned int encoding
)
4716 static char buff
[32];
4720 case ELFDATANONE
: return _("none");
4721 case ELFDATA2LSB
: return _("2's complement, little endian");
4722 case ELFDATA2MSB
: return _("2's complement, big endian");
4724 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4729 /* Decode the data held in 'filedata->file_header'. */
4732 process_file_header (Filedata
* filedata
)
4734 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4736 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4737 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4738 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4739 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4742 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4746 init_dwarf_regnames (header
->e_machine
);
4752 printf (_("ELF Header:\n"));
4753 printf (_(" Magic: "));
4754 for (i
= 0; i
< EI_NIDENT
; i
++)
4755 printf ("%2.2x ", header
->e_ident
[i
]);
4757 printf (_(" Class: %s\n"),
4758 get_elf_class (header
->e_ident
[EI_CLASS
]));
4759 printf (_(" Data: %s\n"),
4760 get_data_encoding (header
->e_ident
[EI_DATA
]));
4761 printf (_(" Version: %d %s\n"),
4762 header
->e_ident
[EI_VERSION
],
4763 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4765 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4766 ? _("<unknown: %lx>")
4768 printf (_(" OS/ABI: %s\n"),
4769 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4770 printf (_(" ABI Version: %d\n"),
4771 header
->e_ident
[EI_ABIVERSION
]);
4772 printf (_(" Type: %s\n"),
4773 get_file_type (header
->e_type
));
4774 printf (_(" Machine: %s\n"),
4775 get_machine_name (header
->e_machine
));
4776 printf (_(" Version: 0x%lx\n"),
4777 (unsigned long) header
->e_version
);
4779 printf (_(" Entry point address: "));
4780 print_vma ((bfd_vma
) header
->e_entry
, PREFIX_HEX
);
4781 printf (_("\n Start of program headers: "));
4782 print_vma ((bfd_vma
) header
->e_phoff
, DEC
);
4783 printf (_(" (bytes into file)\n Start of section headers: "));
4784 print_vma ((bfd_vma
) header
->e_shoff
, DEC
);
4785 printf (_(" (bytes into file)\n"));
4787 printf (_(" Flags: 0x%lx%s\n"),
4788 (unsigned long) header
->e_flags
,
4789 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4790 printf (_(" Size of this header: %ld (bytes)\n"),
4791 (long) header
->e_ehsize
);
4792 printf (_(" Size of program headers: %ld (bytes)\n"),
4793 (long) header
->e_phentsize
);
4794 printf (_(" Number of program headers: %ld"),
4795 (long) header
->e_phnum
);
4796 if (filedata
->section_headers
!= NULL
4797 && header
->e_phnum
== PN_XNUM
4798 && filedata
->section_headers
[0].sh_info
!= 0)
4799 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_info
);
4800 putc ('\n', stdout
);
4801 printf (_(" Size of section headers: %ld (bytes)\n"),
4802 (long) header
->e_shentsize
);
4803 printf (_(" Number of section headers: %ld"),
4804 (long) header
->e_shnum
);
4805 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4806 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_size
);
4807 putc ('\n', stdout
);
4808 printf (_(" Section header string table index: %ld"),
4809 (long) header
->e_shstrndx
);
4810 if (filedata
->section_headers
!= NULL
4811 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4812 printf (" (%u)", filedata
->section_headers
[0].sh_link
);
4813 else if (header
->e_shstrndx
!= SHN_UNDEF
4814 && header
->e_shstrndx
>= header
->e_shnum
)
4815 printf (_(" <corrupt: out of range>"));
4816 putc ('\n', stdout
);
4819 if (filedata
->section_headers
!= NULL
)
4821 if (header
->e_phnum
== PN_XNUM
4822 && filedata
->section_headers
[0].sh_info
!= 0)
4823 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4824 if (header
->e_shnum
== SHN_UNDEF
)
4825 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4826 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4827 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4828 if (header
->e_shstrndx
>= header
->e_shnum
)
4829 header
->e_shstrndx
= SHN_UNDEF
;
4830 free (filedata
->section_headers
);
4831 filedata
->section_headers
= NULL
;
4837 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4838 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4841 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4843 Elf32_External_Phdr
* phdrs
;
4844 Elf32_External_Phdr
* external
;
4845 Elf_Internal_Phdr
* internal
;
4847 unsigned int size
= filedata
->file_header
.e_phentsize
;
4848 unsigned int num
= filedata
->file_header
.e_phnum
;
4850 /* PR binutils/17531: Cope with unexpected section header sizes. */
4851 if (size
== 0 || num
== 0)
4853 if (size
< sizeof * phdrs
)
4855 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4858 if (size
> sizeof * phdrs
)
4859 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4861 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4862 size
, num
, _("program headers"));
4866 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4867 i
< filedata
->file_header
.e_phnum
;
4868 i
++, internal
++, external
++)
4870 internal
->p_type
= BYTE_GET (external
->p_type
);
4871 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4872 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4873 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4874 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4875 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4876 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4877 internal
->p_align
= BYTE_GET (external
->p_align
);
4884 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4885 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4888 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4890 Elf64_External_Phdr
* phdrs
;
4891 Elf64_External_Phdr
* external
;
4892 Elf_Internal_Phdr
* internal
;
4894 unsigned int size
= filedata
->file_header
.e_phentsize
;
4895 unsigned int num
= filedata
->file_header
.e_phnum
;
4897 /* PR binutils/17531: Cope with unexpected section header sizes. */
4898 if (size
== 0 || num
== 0)
4900 if (size
< sizeof * phdrs
)
4902 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4905 if (size
> sizeof * phdrs
)
4906 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4908 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4909 size
, num
, _("program headers"));
4913 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4914 i
< filedata
->file_header
.e_phnum
;
4915 i
++, internal
++, external
++)
4917 internal
->p_type
= BYTE_GET (external
->p_type
);
4918 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4919 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4920 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4921 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4922 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4923 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4924 internal
->p_align
= BYTE_GET (external
->p_align
);
4931 /* Returns TRUE if the program headers were read into `program_headers'. */
4934 get_program_headers (Filedata
* filedata
)
4936 Elf_Internal_Phdr
* phdrs
;
4938 /* Check cache of prior read. */
4939 if (filedata
->program_headers
!= NULL
)
4942 /* Be kind to memory checkers by looking for
4943 e_phnum values which we know must be invalid. */
4944 if (filedata
->file_header
.e_phnum
4945 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4946 >= filedata
->file_size
)
4948 error (_("Too many program headers - %#x - the file is not that big\n"),
4949 filedata
->file_header
.e_phnum
);
4953 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4954 sizeof (Elf_Internal_Phdr
));
4957 error (_("Out of memory reading %u program headers\n"),
4958 filedata
->file_header
.e_phnum
);
4963 ? get_32bit_program_headers (filedata
, phdrs
)
4964 : get_64bit_program_headers (filedata
, phdrs
))
4966 filedata
->program_headers
= phdrs
;
4974 /* Returns TRUE if the program headers were loaded. */
4977 process_program_headers (Filedata
* filedata
)
4979 Elf_Internal_Phdr
* segment
;
4981 Elf_Internal_Phdr
* previous_load
= NULL
;
4983 if (filedata
->file_header
.e_phnum
== 0)
4985 /* PR binutils/12467. */
4986 if (filedata
->file_header
.e_phoff
!= 0)
4988 warn (_("possibly corrupt ELF header - it has a non-zero program"
4989 " header offset, but no program headers\n"));
4992 else if (do_segments
)
4993 printf (_("\nThere are no program headers in this file.\n"));
4997 if (do_segments
&& !do_header
)
4999 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5000 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5001 printf (ngettext ("There is %d program header, starting at offset %s\n",
5002 "There are %d program headers, starting at offset %s\n",
5003 filedata
->file_header
.e_phnum
),
5004 filedata
->file_header
.e_phnum
,
5005 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5008 if (! get_program_headers (filedata
))
5013 if (filedata
->file_header
.e_phnum
> 1)
5014 printf (_("\nProgram Headers:\n"));
5016 printf (_("\nProgram Headers:\n"));
5020 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5023 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5027 (_(" Type Offset VirtAddr PhysAddr\n"));
5029 (_(" FileSiz MemSiz Flags Align\n"));
5036 for (i
= 0, segment
= filedata
->program_headers
;
5037 i
< filedata
->file_header
.e_phnum
;
5042 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5046 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5047 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5048 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5049 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5050 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5052 (segment
->p_flags
& PF_R
? 'R' : ' '),
5053 (segment
->p_flags
& PF_W
? 'W' : ' '),
5054 (segment
->p_flags
& PF_X
? 'E' : ' '));
5055 printf ("%#lx", (unsigned long) segment
->p_align
);
5059 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5060 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5063 print_vma (segment
->p_offset
, FULL_HEX
);
5067 print_vma (segment
->p_vaddr
, FULL_HEX
);
5069 print_vma (segment
->p_paddr
, FULL_HEX
);
5072 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5073 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5076 print_vma (segment
->p_filesz
, FULL_HEX
);
5080 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5081 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5084 print_vma (segment
->p_memsz
, FULL_HEX
);
5088 (segment
->p_flags
& PF_R
? 'R' : ' '),
5089 (segment
->p_flags
& PF_W
? 'W' : ' '),
5090 (segment
->p_flags
& PF_X
? 'E' : ' '));
5092 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5093 printf ("%#lx", (unsigned long) segment
->p_align
);
5096 print_vma (segment
->p_align
, PREFIX_HEX
);
5101 print_vma (segment
->p_offset
, FULL_HEX
);
5103 print_vma (segment
->p_vaddr
, FULL_HEX
);
5105 print_vma (segment
->p_paddr
, FULL_HEX
);
5107 print_vma (segment
->p_filesz
, FULL_HEX
);
5109 print_vma (segment
->p_memsz
, FULL_HEX
);
5111 (segment
->p_flags
& PF_R
? 'R' : ' '),
5112 (segment
->p_flags
& PF_W
? 'W' : ' '),
5113 (segment
->p_flags
& PF_X
? 'E' : ' '));
5114 print_vma (segment
->p_align
, PREFIX_HEX
);
5117 putc ('\n', stdout
);
5120 switch (segment
->p_type
)
5123 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5124 required by the ELF standard, several programs, including the Linux
5125 kernel, make use of non-ordered segments. */
5127 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5128 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5130 if (segment
->p_memsz
< segment
->p_filesz
)
5131 error (_("the segment's file size is larger than its memory size\n"));
5132 previous_load
= segment
;
5136 /* PR 20815 - Verify that the program header is loaded into memory. */
5137 if (i
> 0 && previous_load
!= NULL
)
5138 error (_("the PHDR segment must occur before any LOAD segment\n"));
5139 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5143 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5144 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5145 && (filedata
->program_headers
[j
].p_vaddr
5146 + filedata
->program_headers
[j
].p_memsz
)
5147 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5149 if (j
== filedata
->file_header
.e_phnum
)
5150 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5156 error (_("more than one dynamic segment\n"));
5158 /* By default, assume that the .dynamic section is the first
5159 section in the DYNAMIC segment. */
5160 dynamic_addr
= segment
->p_offset
;
5161 dynamic_size
= segment
->p_filesz
;
5163 /* Try to locate the .dynamic section. If there is
5164 a section header table, we can easily locate it. */
5165 if (filedata
->section_headers
!= NULL
)
5167 Elf_Internal_Shdr
* sec
;
5169 sec
= find_section (filedata
, ".dynamic");
5170 if (sec
== NULL
|| sec
->sh_size
== 0)
5172 /* A corresponding .dynamic section is expected, but on
5173 IA-64/OpenVMS it is OK for it to be missing. */
5174 if (!is_ia64_vms (filedata
))
5175 error (_("no .dynamic section in the dynamic segment\n"));
5179 if (sec
->sh_type
== SHT_NOBITS
)
5185 dynamic_addr
= sec
->sh_offset
;
5186 dynamic_size
= sec
->sh_size
;
5188 if (dynamic_addr
< segment
->p_offset
5189 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5190 warn (_("the .dynamic section is not contained"
5191 " within the dynamic segment\n"));
5192 else if (dynamic_addr
> segment
->p_offset
)
5193 warn (_("the .dynamic section is not the first section"
5194 " in the dynamic segment.\n"));
5197 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5198 segment. Check this after matching against the section headers
5199 so we don't warn on debuginfo file (which have NOBITS .dynamic
5201 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5203 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5204 dynamic_addr
= dynamic_size
= 0;
5209 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5211 error (_("Unable to find program interpreter name\n"));
5215 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5217 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5218 error (_("Internal error: failed to create format string to display program interpreter\n"));
5220 program_interpreter
[0] = 0;
5221 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5222 error (_("Unable to read program interpreter name\n"));
5225 printf (_(" [Requesting program interpreter: %s]\n"),
5226 program_interpreter
);
5233 && filedata
->section_headers
!= NULL
5234 && filedata
->string_table
!= NULL
)
5236 printf (_("\n Section to Segment mapping:\n"));
5237 printf (_(" Segment Sections...\n"));
5239 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5242 Elf_Internal_Shdr
* section
;
5244 segment
= filedata
->program_headers
+ i
;
5245 section
= filedata
->section_headers
+ 1;
5247 printf (" %2.2d ", i
);
5249 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5251 if (!ELF_TBSS_SPECIAL (section
, segment
)
5252 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5253 printf ("%s ", printable_section_name (filedata
, section
));
5264 /* Find the file offset corresponding to VMA by using the program headers. */
5267 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5269 Elf_Internal_Phdr
* seg
;
5271 if (! get_program_headers (filedata
))
5273 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5277 for (seg
= filedata
->program_headers
;
5278 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5281 if (seg
->p_type
!= PT_LOAD
)
5284 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5285 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5286 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5289 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5290 (unsigned long) vma
);
5295 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5296 If PROBE is true, this is just a probe and we do not generate any error
5297 messages if the load fails. */
5300 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5302 Elf32_External_Shdr
* shdrs
;
5303 Elf_Internal_Shdr
* internal
;
5305 unsigned int size
= filedata
->file_header
.e_shentsize
;
5306 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5308 /* PR binutils/17531: Cope with unexpected section header sizes. */
5309 if (size
== 0 || num
== 0)
5311 if (size
< sizeof * shdrs
)
5314 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5317 if (!probe
&& size
> sizeof * shdrs
)
5318 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5320 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5322 probe
? NULL
: _("section headers"));
5326 free (filedata
->section_headers
);
5327 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5328 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5329 if (filedata
->section_headers
== NULL
)
5332 error (_("Out of memory reading %u section headers\n"), num
);
5336 for (i
= 0, internal
= filedata
->section_headers
;
5340 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5341 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5342 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5343 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5344 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5345 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5346 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5347 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5348 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5349 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5350 if (!probe
&& internal
->sh_link
> num
)
5351 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5352 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5353 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5360 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5363 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5365 Elf64_External_Shdr
* shdrs
;
5366 Elf_Internal_Shdr
* internal
;
5368 unsigned int size
= filedata
->file_header
.e_shentsize
;
5369 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5371 /* PR binutils/17531: Cope with unexpected section header sizes. */
5372 if (size
== 0 || num
== 0)
5375 if (size
< sizeof * shdrs
)
5378 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5382 if (! probe
&& size
> sizeof * shdrs
)
5383 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5385 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5386 filedata
->file_header
.e_shoff
,
5388 probe
? NULL
: _("section headers"));
5392 free (filedata
->section_headers
);
5393 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5394 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5395 if (filedata
->section_headers
== NULL
)
5398 error (_("Out of memory reading %u section headers\n"), num
);
5402 for (i
= 0, internal
= filedata
->section_headers
;
5406 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5407 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5408 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5409 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5410 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5411 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5412 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5413 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5414 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5415 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5416 if (!probe
&& internal
->sh_link
> num
)
5417 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5418 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5419 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5426 static Elf_Internal_Sym
*
5427 get_32bit_elf_symbols (Filedata
* filedata
,
5428 Elf_Internal_Shdr
* section
,
5429 unsigned long * num_syms_return
)
5431 unsigned long number
= 0;
5432 Elf32_External_Sym
* esyms
= NULL
;
5433 Elf_External_Sym_Shndx
* shndx
= NULL
;
5434 Elf_Internal_Sym
* isyms
= NULL
;
5435 Elf_Internal_Sym
* psym
;
5438 if (section
->sh_size
== 0)
5440 if (num_syms_return
!= NULL
)
5441 * num_syms_return
= 0;
5445 /* Run some sanity checks first. */
5446 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5448 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5449 printable_section_name (filedata
, section
),
5450 (unsigned long) section
->sh_entsize
);
5454 if (section
->sh_size
> filedata
->file_size
)
5456 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5457 printable_section_name (filedata
, section
),
5458 (unsigned long) section
->sh_size
);
5462 number
= section
->sh_size
/ section
->sh_entsize
;
5464 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5466 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5467 (unsigned long) section
->sh_size
,
5468 printable_section_name (filedata
, section
),
5469 (unsigned long) section
->sh_entsize
);
5473 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5474 section
->sh_size
, _("symbols"));
5479 elf_section_list
* entry
;
5482 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5483 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5485 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5486 entry
->hdr
->sh_offset
,
5487 1, entry
->hdr
->sh_size
,
5488 _("symbol table section indicies"));
5491 /* PR17531: file: heap-buffer-overflow */
5492 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5494 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5495 printable_section_name (filedata
, entry
->hdr
),
5496 (unsigned long) entry
->hdr
->sh_size
,
5497 (unsigned long) section
->sh_size
);
5503 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5507 error (_("Out of memory reading %lu symbols\n"),
5508 (unsigned long) number
);
5512 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5514 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5515 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5516 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5517 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5518 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5520 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5521 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5522 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5523 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5524 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5533 if (num_syms_return
!= NULL
)
5534 * num_syms_return
= isyms
== NULL
? 0 : number
;
5539 static Elf_Internal_Sym
*
5540 get_64bit_elf_symbols (Filedata
* filedata
,
5541 Elf_Internal_Shdr
* section
,
5542 unsigned long * num_syms_return
)
5544 unsigned long number
= 0;
5545 Elf64_External_Sym
* esyms
= NULL
;
5546 Elf_External_Sym_Shndx
* shndx
= NULL
;
5547 Elf_Internal_Sym
* isyms
= NULL
;
5548 Elf_Internal_Sym
* psym
;
5551 if (section
->sh_size
== 0)
5553 if (num_syms_return
!= NULL
)
5554 * num_syms_return
= 0;
5558 /* Run some sanity checks first. */
5559 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5561 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5562 printable_section_name (filedata
, section
),
5563 (unsigned long) section
->sh_entsize
);
5567 if (section
->sh_size
> filedata
->file_size
)
5569 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5570 printable_section_name (filedata
, section
),
5571 (unsigned long) section
->sh_size
);
5575 number
= section
->sh_size
/ section
->sh_entsize
;
5577 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5579 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5580 (unsigned long) section
->sh_size
,
5581 printable_section_name (filedata
, section
),
5582 (unsigned long) section
->sh_entsize
);
5586 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5587 section
->sh_size
, _("symbols"));
5592 elf_section_list
* entry
;
5595 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5596 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5598 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5599 entry
->hdr
->sh_offset
,
5600 1, entry
->hdr
->sh_size
,
5601 _("symbol table section indicies"));
5604 /* PR17531: file: heap-buffer-overflow */
5605 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5607 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5608 printable_section_name (filedata
, entry
->hdr
),
5609 (unsigned long) entry
->hdr
->sh_size
,
5610 (unsigned long) section
->sh_size
);
5616 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5620 error (_("Out of memory reading %lu symbols\n"),
5621 (unsigned long) number
);
5625 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5627 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5628 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5629 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5630 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5632 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5634 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5635 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5636 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5638 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5639 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5648 if (num_syms_return
!= NULL
)
5649 * num_syms_return
= isyms
== NULL
? 0 : number
;
5655 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5657 static char buff
[1024];
5659 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5661 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5662 bfd_vma os_flags
= 0;
5663 bfd_vma proc_flags
= 0;
5664 bfd_vma unknown_flags
= 0;
5672 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5673 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5674 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5675 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5676 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5677 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5678 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5679 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5680 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5681 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5682 /* IA-64 specific. */
5683 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5684 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5685 /* IA-64 OpenVMS specific. */
5686 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5687 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5688 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5689 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5690 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5691 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5693 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5694 /* SPARC specific. */
5695 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5696 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5698 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5699 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5700 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5702 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5704 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5707 if (do_section_details
)
5709 sprintf (buff
, "[%*.*lx]: ",
5710 field_size
, field_size
, (unsigned long) sh_flags
);
5711 p
+= field_size
+ 4;
5718 flag
= sh_flags
& - sh_flags
;
5721 if (do_section_details
)
5725 case SHF_WRITE
: sindex
= 0; break;
5726 case SHF_ALLOC
: sindex
= 1; break;
5727 case SHF_EXECINSTR
: sindex
= 2; break;
5728 case SHF_MERGE
: sindex
= 3; break;
5729 case SHF_STRINGS
: sindex
= 4; break;
5730 case SHF_INFO_LINK
: sindex
= 5; break;
5731 case SHF_LINK_ORDER
: sindex
= 6; break;
5732 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5733 case SHF_GROUP
: sindex
= 8; break;
5734 case SHF_TLS
: sindex
= 9; break;
5735 case SHF_EXCLUDE
: sindex
= 18; break;
5736 case SHF_COMPRESSED
: sindex
= 20; break;
5737 case SHF_GNU_MBIND
: sindex
= 24; break;
5741 switch (filedata
->file_header
.e_machine
)
5744 if (flag
== SHF_IA_64_SHORT
)
5746 else if (flag
== SHF_IA_64_NORECOV
)
5749 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5752 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5753 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5754 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5755 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5756 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5757 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5768 case EM_OLD_SPARCV9
:
5769 case EM_SPARC32PLUS
:
5772 if (flag
== SHF_ORDERED
)
5779 case SHF_ENTRYSECT
: sindex
= 21; break;
5780 case SHF_ARM_PURECODE
: sindex
= 22; break;
5781 case SHF_COMDEF
: sindex
= 23; break;
5786 if (flag
== SHF_PPC_VLE
)
5797 if (p
!= buff
+ field_size
+ 4)
5799 if (size
< (10 + 2))
5801 warn (_("Internal error: not enough buffer room for section flag info"));
5802 return _("<unknown>");
5809 size
-= flags
[sindex
].len
;
5810 p
= stpcpy (p
, flags
[sindex
].str
);
5812 else if (flag
& SHF_MASKOS
)
5814 else if (flag
& SHF_MASKPROC
)
5817 unknown_flags
|= flag
;
5823 case SHF_WRITE
: *p
= 'W'; break;
5824 case SHF_ALLOC
: *p
= 'A'; break;
5825 case SHF_EXECINSTR
: *p
= 'X'; break;
5826 case SHF_MERGE
: *p
= 'M'; break;
5827 case SHF_STRINGS
: *p
= 'S'; break;
5828 case SHF_INFO_LINK
: *p
= 'I'; break;
5829 case SHF_LINK_ORDER
: *p
= 'L'; break;
5830 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5831 case SHF_GROUP
: *p
= 'G'; break;
5832 case SHF_TLS
: *p
= 'T'; break;
5833 case SHF_EXCLUDE
: *p
= 'E'; break;
5834 case SHF_COMPRESSED
: *p
= 'C'; break;
5835 case SHF_GNU_MBIND
: *p
= 'D'; break;
5838 if ((filedata
->file_header
.e_machine
== EM_X86_64
5839 || filedata
->file_header
.e_machine
== EM_L1OM
5840 || filedata
->file_header
.e_machine
== EM_K1OM
)
5841 && flag
== SHF_X86_64_LARGE
)
5843 else if (filedata
->file_header
.e_machine
== EM_ARM
5844 && flag
== SHF_ARM_PURECODE
)
5846 else if (filedata
->file_header
.e_machine
== EM_PPC
5847 && flag
== SHF_PPC_VLE
)
5849 else if (flag
& SHF_MASKOS
)
5852 sh_flags
&= ~ SHF_MASKOS
;
5854 else if (flag
& SHF_MASKPROC
)
5857 sh_flags
&= ~ SHF_MASKPROC
;
5867 if (do_section_details
)
5871 size
-= 5 + field_size
;
5872 if (p
!= buff
+ field_size
+ 4)
5876 warn (_("Internal error: not enough buffer room for section flag info"));
5877 return _("<unknown>");
5883 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5884 (unsigned long) os_flags
);
5885 p
+= 5 + field_size
;
5889 size
-= 7 + field_size
;
5890 if (p
!= buff
+ field_size
+ 4)
5894 warn (_("Internal error: not enough buffer room for section flag info"));
5895 return _("<unknown>");
5901 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5902 (unsigned long) proc_flags
);
5903 p
+= 7 + field_size
;
5907 size
-= 10 + field_size
;
5908 if (p
!= buff
+ field_size
+ 4)
5912 warn (_("Internal error: not enough buffer room for section flag info"));
5913 return _("<unknown>");
5919 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5920 (unsigned long) unknown_flags
);
5921 p
+= 10 + field_size
;
5930 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5934 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5936 if (size
< sizeof (* echdr
))
5938 error (_("Compressed section is too small even for a compression header\n"));
5942 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5943 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5944 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5945 return sizeof (*echdr
);
5949 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5951 if (size
< sizeof (* echdr
))
5953 error (_("Compressed section is too small even for a compression header\n"));
5957 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5958 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5959 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5960 return sizeof (*echdr
);
5965 process_section_headers (Filedata
* filedata
)
5967 Elf_Internal_Shdr
* section
;
5970 filedata
->section_headers
= NULL
;
5972 if (filedata
->file_header
.e_shnum
== 0)
5974 /* PR binutils/12467. */
5975 if (filedata
->file_header
.e_shoff
!= 0)
5977 warn (_("possibly corrupt ELF file header - it has a non-zero"
5978 " section header offset, but no section headers\n"));
5981 else if (do_sections
)
5982 printf (_("\nThere are no sections in this file.\n"));
5987 if (do_sections
&& !do_header
)
5988 printf (ngettext ("There is %d section header, "
5989 "starting at offset 0x%lx:\n",
5990 "There are %d section headers, "
5991 "starting at offset 0x%lx:\n",
5992 filedata
->file_header
.e_shnum
),
5993 filedata
->file_header
.e_shnum
,
5994 (unsigned long) filedata
->file_header
.e_shoff
);
5998 if (! get_32bit_section_headers (filedata
, FALSE
))
6003 if (! get_64bit_section_headers (filedata
, FALSE
))
6007 /* Read in the string table, so that we have names to display. */
6008 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6009 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6011 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6013 if (section
->sh_size
!= 0)
6015 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6016 1, section
->sh_size
,
6019 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6023 /* Scan the sections for the dynamic symbol table
6024 and dynamic string table and debug sections. */
6025 dynamic_symbols
= NULL
;
6026 dynamic_strings
= NULL
;
6027 dynamic_syminfo
= NULL
;
6028 symtab_shndx_list
= NULL
;
6030 eh_addr_size
= is_32bit_elf
? 4 : 8;
6031 switch (filedata
->file_header
.e_machine
)
6034 case EM_MIPS_RS3_LE
:
6035 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6036 FDE addresses. However, the ABI also has a semi-official ILP32
6037 variant for which the normal FDE address size rules apply.
6039 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6040 section, where XX is the size of longs in bits. Unfortunately,
6041 earlier compilers provided no way of distinguishing ILP32 objects
6042 from LP64 objects, so if there's any doubt, we should assume that
6043 the official LP64 form is being used. */
6044 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6045 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6051 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6053 case E_H8_MACH_H8300
:
6054 case E_H8_MACH_H8300HN
:
6055 case E_H8_MACH_H8300SN
:
6056 case E_H8_MACH_H8300SXN
:
6059 case E_H8_MACH_H8300H
:
6060 case E_H8_MACH_H8300S
:
6061 case E_H8_MACH_H8300SX
:
6069 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6071 case EF_M32C_CPU_M16C
:
6078 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6081 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6082 if (section->sh_entsize != expected_entsize) \
6085 sprintf_vma (buf, section->sh_entsize); \
6086 /* Note: coded this way so that there is a single string for \
6088 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6089 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6090 (unsigned) expected_entsize); \
6091 section->sh_entsize = expected_entsize; \
6096 #define CHECK_ENTSIZE(section, i, type) \
6097 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6098 sizeof (Elf64_External_##type))
6100 for (i
= 0, section
= filedata
->section_headers
;
6101 i
< filedata
->file_header
.e_shnum
;
6104 char * name
= SECTION_NAME (section
);
6106 if (section
->sh_type
== SHT_DYNSYM
)
6108 if (dynamic_symbols
!= NULL
)
6110 error (_("File contains multiple dynamic symbol tables\n"));
6114 CHECK_ENTSIZE (section
, i
, Sym
);
6115 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6117 else if (section
->sh_type
== SHT_STRTAB
6118 && streq (name
, ".dynstr"))
6120 if (dynamic_strings
!= NULL
)
6122 error (_("File contains multiple dynamic string tables\n"));
6126 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6127 1, section
->sh_size
,
6128 _("dynamic strings"));
6129 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6131 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6133 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6135 entry
->hdr
= section
;
6136 entry
->next
= symtab_shndx_list
;
6137 symtab_shndx_list
= entry
;
6139 else if (section
->sh_type
== SHT_SYMTAB
)
6140 CHECK_ENTSIZE (section
, i
, Sym
);
6141 else if (section
->sh_type
== SHT_GROUP
)
6142 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6143 else if (section
->sh_type
== SHT_REL
)
6144 CHECK_ENTSIZE (section
, i
, Rel
);
6145 else if (section
->sh_type
== SHT_RELA
)
6146 CHECK_ENTSIZE (section
, i
, Rela
);
6147 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6148 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6149 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6150 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6151 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6152 && (const_strneq (name
, ".debug_")
6153 || const_strneq (name
, ".zdebug_")))
6156 name
+= sizeof (".zdebug_") - 1;
6158 name
+= sizeof (".debug_") - 1;
6161 || (do_debug_info
&& const_strneq (name
, "info"))
6162 || (do_debug_info
&& const_strneq (name
, "types"))
6163 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6164 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6165 || (do_debug_lines
&& const_strneq (name
, "line."))
6166 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6167 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6168 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6169 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6170 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6171 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6172 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6173 || (do_debug_frames
&& const_strneq (name
, "frame"))
6174 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6175 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6176 || (do_debug_str
&& const_strneq (name
, "str"))
6177 || (do_debug_loc
&& const_strneq (name
, "loc"))
6178 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6179 || (do_debug_addr
&& const_strneq (name
, "addr"))
6180 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6181 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6183 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6185 /* Linkonce section to be combined with .debug_info at link time. */
6186 else if ((do_debugging
|| do_debug_info
)
6187 && const_strneq (name
, ".gnu.linkonce.wi."))
6188 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6189 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6190 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6191 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6192 || streq (name
, ".debug_names")))
6193 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6194 /* Trace sections for Itanium VMS. */
6195 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6196 || do_trace_aranges
)
6197 && const_strneq (name
, ".trace_"))
6199 name
+= sizeof (".trace_") - 1;
6202 || (do_trace_info
&& streq (name
, "info"))
6203 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6204 || (do_trace_aranges
&& streq (name
, "aranges"))
6206 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6208 else if ((do_debugging
|| do_debug_links
)
6209 && (const_strneq (name
, ".gnu_debuglink")
6210 || const_strneq (name
, ".gnu_debugaltlink")))
6211 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6217 if (filedata
->file_header
.e_shnum
> 1)
6218 printf (_("\nSection Headers:\n"));
6220 printf (_("\nSection Header:\n"));
6224 if (do_section_details
)
6226 printf (_(" [Nr] Name\n"));
6227 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6231 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6235 if (do_section_details
)
6237 printf (_(" [Nr] Name\n"));
6238 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6242 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6246 if (do_section_details
)
6248 printf (_(" [Nr] Name\n"));
6249 printf (_(" Type Address Offset Link\n"));
6250 printf (_(" Size EntSize Info Align\n"));
6254 printf (_(" [Nr] Name Type Address Offset\n"));
6255 printf (_(" Size EntSize Flags Link Info Align\n"));
6259 if (do_section_details
)
6260 printf (_(" Flags\n"));
6262 for (i
= 0, section
= filedata
->section_headers
;
6263 i
< filedata
->file_header
.e_shnum
;
6266 /* Run some sanity checks on the section header. */
6268 /* Check the sh_link field. */
6269 switch (section
->sh_type
)
6271 case SHT_SYMTAB_SHNDX
:
6275 case SHT_GNU_versym
:
6278 if (section
->sh_link
< 1
6279 || section
->sh_link
>= filedata
->file_header
.e_shnum
6280 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6281 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6282 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6283 i
, section
->sh_link
);
6289 case SHT_GNU_verneed
:
6290 case SHT_GNU_verdef
:
6291 case SHT_GNU_LIBLIST
:
6292 if (section
->sh_link
< 1
6293 || section
->sh_link
>= filedata
->file_header
.e_shnum
6294 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6295 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6296 i
, section
->sh_link
);
6299 case SHT_INIT_ARRAY
:
6300 case SHT_FINI_ARRAY
:
6301 case SHT_PREINIT_ARRAY
:
6302 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6303 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6304 i
, section
->sh_link
);
6308 /* FIXME: Add support for target specific section types. */
6309 #if 0 /* Currently we do not check other section types as there are too
6310 many special cases. Stab sections for example have a type
6311 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6313 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6314 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6315 i
, section
->sh_link
);
6320 /* Check the sh_info field. */
6321 switch (section
->sh_type
)
6325 if (section
->sh_info
< 1
6326 || section
->sh_info
>= filedata
->file_header
.e_shnum
6327 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6328 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6329 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6330 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6331 /* FIXME: Are other section types valid ? */
6332 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6334 if (section
->sh_info
== 0
6335 && (filedata
->file_header
.e_type
== ET_EXEC
6336 || filedata
->file_header
.e_type
== ET_DYN
6337 /* These next two tests may be redundant, but
6338 they have been left in for paranoia's sake. */
6339 || streq (SECTION_NAME (section
), ".rel.dyn")
6340 || streq (SECTION_NAME (section
), ".rela.dyn")))
6341 /* Dynamic relocations apply to segments, not sections, so
6342 they do not need an sh_info value. */
6345 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6346 i
, section
->sh_info
);
6352 case SHT_SYMTAB_SHNDX
:
6353 case SHT_INIT_ARRAY
:
6354 case SHT_FINI_ARRAY
:
6355 case SHT_PREINIT_ARRAY
:
6356 if (section
->sh_info
!= 0)
6357 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6358 i
, section
->sh_info
);
6364 /* A symbol index - we assume that it is valid. */
6368 /* FIXME: Add support for target specific section types. */
6369 if (section
->sh_type
== SHT_NOBITS
)
6370 /* NOBITS section headers with non-zero sh_info fields can be
6371 created when a binary is stripped of everything but its debug
6372 information. The stripped sections have their headers
6373 preserved but their types set to SHT_NOBITS. So do not check
6374 this type of section. */
6376 else if (section
->sh_flags
& SHF_INFO_LINK
)
6378 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6379 warn (_("[%2u]: Expected link to another section in info field"), i
);
6381 else if (section
->sh_type
< SHT_LOOS
6382 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6383 && section
->sh_info
!= 0)
6384 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6385 i
, section
->sh_info
);
6389 /* Check the sh_size field. */
6390 if (section
->sh_size
> filedata
->file_size
6391 && section
->sh_type
!= SHT_NOBITS
6392 && section
->sh_type
!= SHT_NULL
6393 && section
->sh_type
< SHT_LOOS
)
6394 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6396 printf (" [%2u] ", i
);
6397 if (do_section_details
)
6398 printf ("%s\n ", printable_section_name (filedata
, section
));
6400 print_symbol (-17, SECTION_NAME (section
));
6402 printf (do_wide
? " %-15s " : " %-15.15s ",
6403 get_section_type_name (filedata
, section
->sh_type
));
6407 const char * link_too_big
= NULL
;
6409 print_vma (section
->sh_addr
, LONG_HEX
);
6411 printf ( " %6.6lx %6.6lx %2.2lx",
6412 (unsigned long) section
->sh_offset
,
6413 (unsigned long) section
->sh_size
,
6414 (unsigned long) section
->sh_entsize
);
6416 if (do_section_details
)
6417 fputs (" ", stdout
);
6419 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6421 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6424 /* The sh_link value is out of range. Normally this indicates
6425 an error but it can have special values in Solaris binaries. */
6426 switch (filedata
->file_header
.e_machine
)
6433 case EM_OLD_SPARCV9
:
6434 case EM_SPARC32PLUS
:
6437 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6438 link_too_big
= "BEFORE";
6439 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6440 link_too_big
= "AFTER";
6447 if (do_section_details
)
6449 if (link_too_big
!= NULL
&& * link_too_big
)
6450 printf ("<%s> ", link_too_big
);
6452 printf ("%2u ", section
->sh_link
);
6453 printf ("%3u %2lu\n", section
->sh_info
,
6454 (unsigned long) section
->sh_addralign
);
6457 printf ("%2u %3u %2lu\n",
6460 (unsigned long) section
->sh_addralign
);
6462 if (link_too_big
&& ! * link_too_big
)
6463 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6464 i
, section
->sh_link
);
6468 print_vma (section
->sh_addr
, LONG_HEX
);
6470 if ((long) section
->sh_offset
== section
->sh_offset
)
6471 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6475 print_vma (section
->sh_offset
, LONG_HEX
);
6478 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6479 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6483 print_vma (section
->sh_size
, LONG_HEX
);
6486 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6487 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6491 print_vma (section
->sh_entsize
, LONG_HEX
);
6494 if (do_section_details
)
6495 fputs (" ", stdout
);
6497 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6499 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6501 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6502 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6505 print_vma (section
->sh_addralign
, DEC
);
6509 else if (do_section_details
)
6512 print_vma (section
->sh_addr
, LONG_HEX
);
6513 if ((long) section
->sh_offset
== section
->sh_offset
)
6514 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6518 print_vma (section
->sh_offset
, LONG_HEX
);
6520 printf (" %u\n ", section
->sh_link
);
6521 print_vma (section
->sh_size
, LONG_HEX
);
6523 print_vma (section
->sh_entsize
, LONG_HEX
);
6525 printf (" %-16u %lu\n",
6527 (unsigned long) section
->sh_addralign
);
6532 print_vma (section
->sh_addr
, LONG_HEX
);
6533 if ((long) section
->sh_offset
== section
->sh_offset
)
6534 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6538 print_vma (section
->sh_offset
, LONG_HEX
);
6541 print_vma (section
->sh_size
, LONG_HEX
);
6543 print_vma (section
->sh_entsize
, LONG_HEX
);
6545 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6547 printf (" %2u %3u %lu\n",
6550 (unsigned long) section
->sh_addralign
);
6553 if (do_section_details
)
6555 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6556 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6558 /* Minimum section size is 12 bytes for 32-bit compression
6559 header + 12 bytes for compressed data header. */
6560 unsigned char buf
[24];
6562 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6563 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6564 sizeof (buf
), _("compression header")))
6566 Elf_Internal_Chdr chdr
;
6568 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6570 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6573 printf (_(" [<unknown>: 0x%x], "),
6575 print_vma (chdr
.ch_size
, LONG_HEX
);
6576 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6582 if (!do_section_details
)
6584 /* The ordering of the letters shown here matches the ordering of the
6585 corresponding SHF_xxx values, and hence the order in which these
6586 letters will be displayed to the user. */
6587 printf (_("Key to Flags:\n\
6588 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6589 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6590 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6591 if (filedata
->file_header
.e_machine
== EM_X86_64
6592 || filedata
->file_header
.e_machine
== EM_L1OM
6593 || filedata
->file_header
.e_machine
== EM_K1OM
)
6594 printf (_("l (large), "));
6595 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6596 printf (_("y (purecode), "));
6597 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6598 printf (_("v (VLE), "));
6599 printf ("p (processor specific)\n");
6606 get_group_flags (unsigned int flags
)
6608 static char buff
[128];
6612 else if (flags
== GRP_COMDAT
)
6615 snprintf (buff
, 14, _("[0x%x: "), flags
);
6617 flags
&= ~ GRP_COMDAT
;
6618 if (flags
& GRP_MASKOS
)
6620 strcat (buff
, "<OS specific>");
6621 flags
&= ~ GRP_MASKOS
;
6624 if (flags
& GRP_MASKPROC
)
6626 strcat (buff
, "<PROC specific>");
6627 flags
&= ~ GRP_MASKPROC
;
6631 strcat (buff
, "<unknown>");
6638 process_section_groups (Filedata
* filedata
)
6640 Elf_Internal_Shdr
* section
;
6642 struct group
* group
;
6643 Elf_Internal_Shdr
* symtab_sec
;
6644 Elf_Internal_Shdr
* strtab_sec
;
6645 Elf_Internal_Sym
* symtab
;
6646 unsigned long num_syms
;
6650 /* Don't process section groups unless needed. */
6651 if (!do_unwind
&& !do_section_groups
)
6654 if (filedata
->file_header
.e_shnum
== 0)
6656 if (do_section_groups
)
6657 printf (_("\nThere are no sections to group in this file.\n"));
6662 if (filedata
->section_headers
== NULL
)
6664 error (_("Section headers are not available!\n"));
6665 /* PR 13622: This can happen with a corrupt ELF header. */
6669 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6670 sizeof (struct group
*));
6672 if (section_headers_groups
== NULL
)
6674 error (_("Out of memory reading %u section group headers\n"),
6675 filedata
->file_header
.e_shnum
);
6679 /* Scan the sections for the group section. */
6681 for (i
= 0, section
= filedata
->section_headers
;
6682 i
< filedata
->file_header
.e_shnum
;
6684 if (section
->sh_type
== SHT_GROUP
)
6687 if (group_count
== 0)
6689 if (do_section_groups
)
6690 printf (_("\nThere are no section groups in this file.\n"));
6695 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6697 if (section_groups
== NULL
)
6699 error (_("Out of memory reading %lu groups\n"),
6700 (unsigned long) group_count
);
6710 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6711 i
< filedata
->file_header
.e_shnum
;
6714 if (section
->sh_type
== SHT_GROUP
)
6716 const char * name
= printable_section_name (filedata
, section
);
6717 const char * group_name
;
6718 unsigned char * start
;
6719 unsigned char * indices
;
6720 unsigned int entry
, j
, size
;
6721 Elf_Internal_Shdr
* sec
;
6722 Elf_Internal_Sym
* sym
;
6724 /* Get the symbol table. */
6725 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6726 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6729 error (_("Bad sh_link in group section `%s'\n"), name
);
6733 if (symtab_sec
!= sec
)
6738 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6743 error (_("Corrupt header in group section `%s'\n"), name
);
6747 if (section
->sh_info
>= num_syms
)
6749 error (_("Bad sh_info in group section `%s'\n"), name
);
6753 sym
= symtab
+ section
->sh_info
;
6755 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6757 if (sym
->st_shndx
== 0
6758 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6760 error (_("Bad sh_info in group section `%s'\n"), name
);
6764 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6773 /* Get the string table. */
6774 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6783 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6789 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6790 1, strtab_sec
->sh_size
,
6792 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6794 group_name
= sym
->st_name
< strtab_size
6795 ? strtab
+ sym
->st_name
: _("<corrupt>");
6798 /* PR 17531: file: loop. */
6799 if (section
->sh_entsize
> section
->sh_size
)
6801 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6802 printable_section_name (filedata
, section
),
6803 (unsigned long) section
->sh_entsize
,
6804 (unsigned long) section
->sh_size
);
6808 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6809 1, section
->sh_size
,
6815 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6816 entry
= byte_get (indices
, 4);
6819 if (do_section_groups
)
6821 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6822 get_group_flags (entry
), i
, name
, group_name
, size
);
6824 printf (_(" [Index] Name\n"));
6827 group
->group_index
= i
;
6829 for (j
= 0; j
< size
; j
++)
6831 struct group_list
* g
;
6833 entry
= byte_get (indices
, 4);
6836 if (entry
>= filedata
->file_header
.e_shnum
)
6838 static unsigned num_group_errors
= 0;
6840 if (num_group_errors
++ < 10)
6842 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6843 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6844 if (num_group_errors
== 10)
6845 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6850 if (section_headers_groups
[entry
] != NULL
)
6854 static unsigned num_errs
= 0;
6856 if (num_errs
++ < 10)
6858 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6860 section_headers_groups
[entry
]->group_index
);
6862 warn (_("Further error messages about already contained group sections suppressed\n"));
6868 /* Intel C/C++ compiler may put section 0 in a
6869 section group. We just warn it the first time
6870 and ignore it afterwards. */
6871 static bfd_boolean warned
= FALSE
;
6874 error (_("section 0 in group section [%5u]\n"),
6875 section_headers_groups
[entry
]->group_index
);
6881 section_headers_groups
[entry
] = group
;
6883 if (do_section_groups
)
6885 sec
= filedata
->section_headers
+ entry
;
6886 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6889 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6890 g
->section_index
= entry
;
6891 g
->next
= group
->root
;
6909 /* Data used to display dynamic fixups. */
6911 struct ia64_vms_dynfixup
6913 bfd_vma needed_ident
; /* Library ident number. */
6914 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6915 bfd_vma fixup_needed
; /* Index of the library. */
6916 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6917 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6920 /* Data used to display dynamic relocations. */
6922 struct ia64_vms_dynimgrela
6924 bfd_vma img_rela_cnt
; /* Number of relocations. */
6925 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6928 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6932 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6933 struct ia64_vms_dynfixup
* fixup
,
6934 const char * strtab
,
6935 unsigned int strtab_sz
)
6937 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6939 const char * lib_name
;
6941 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6942 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6943 _("dynamic section image fixups"));
6947 if (fixup
->needed
< strtab_sz
)
6948 lib_name
= strtab
+ fixup
->needed
;
6951 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6952 (unsigned long) fixup
->needed
);
6955 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6956 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6958 (_("Seg Offset Type SymVec DataType\n"));
6960 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6965 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6966 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6967 type
= BYTE_GET (imfs
[i
].type
);
6968 rtype
= elf_ia64_reloc_type (type
);
6970 printf (" 0x%08x ", type
);
6972 printf (" %-32s ", rtype
);
6973 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6974 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6981 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6984 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
6986 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6989 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
6990 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6991 _("dynamic section image relocations"));
6995 printf (_("\nImage relocs\n"));
6997 (_("Seg Offset Type Addend Seg Sym Off\n"));
6999 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7004 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7005 printf ("%08" BFD_VMA_FMT
"x ",
7006 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7007 type
= BYTE_GET (imrs
[i
].type
);
7008 rtype
= elf_ia64_reloc_type (type
);
7010 printf ("0x%08x ", type
);
7012 printf ("%-31s ", rtype
);
7013 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7014 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7015 printf ("%08" BFD_VMA_FMT
"x\n",
7016 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7023 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7026 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7028 struct ia64_vms_dynfixup fixup
;
7029 struct ia64_vms_dynimgrela imgrela
;
7030 Elf_Internal_Dyn
*entry
;
7031 bfd_vma strtab_off
= 0;
7032 bfd_vma strtab_sz
= 0;
7033 char *strtab
= NULL
;
7034 bfd_boolean res
= TRUE
;
7036 memset (&fixup
, 0, sizeof (fixup
));
7037 memset (&imgrela
, 0, sizeof (imgrela
));
7039 /* Note: the order of the entries is specified by the OpenVMS specs. */
7040 for (entry
= dynamic_section
;
7041 entry
< dynamic_section
+ dynamic_nent
;
7044 switch (entry
->d_tag
)
7046 case DT_IA_64_VMS_STRTAB_OFFSET
:
7047 strtab_off
= entry
->d_un
.d_val
;
7050 strtab_sz
= entry
->d_un
.d_val
;
7052 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7053 1, strtab_sz
, _("dynamic string section"));
7056 case DT_IA_64_VMS_NEEDED_IDENT
:
7057 fixup
.needed_ident
= entry
->d_un
.d_val
;
7060 fixup
.needed
= entry
->d_un
.d_val
;
7062 case DT_IA_64_VMS_FIXUP_NEEDED
:
7063 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7065 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7066 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7068 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7069 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7070 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7073 case DT_IA_64_VMS_IMG_RELA_CNT
:
7074 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7076 case DT_IA_64_VMS_IMG_RELA_OFF
:
7077 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7078 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7100 dynamic_relocations
[] =
7102 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7103 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7104 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7107 /* Process the reloc section. */
7110 process_relocs (Filedata
* filedata
)
7112 unsigned long rel_size
;
7113 unsigned long rel_offset
;
7118 if (do_using_dynamic
)
7122 bfd_boolean has_dynamic_reloc
;
7125 has_dynamic_reloc
= FALSE
;
7127 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7129 is_rela
= dynamic_relocations
[i
].rela
;
7130 name
= dynamic_relocations
[i
].name
;
7131 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7132 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7135 has_dynamic_reloc
= TRUE
;
7137 if (is_rela
== UNKNOWN
)
7139 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7140 switch (dynamic_info
[DT_PLTREL
])
7154 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7155 name
, rel_offset
, rel_size
);
7157 dump_relocations (filedata
,
7158 offset_from_vma (filedata
, rel_offset
, rel_size
),
7160 dynamic_symbols
, num_dynamic_syms
,
7161 dynamic_strings
, dynamic_strings_length
,
7162 is_rela
, TRUE
/* is_dynamic */);
7166 if (is_ia64_vms (filedata
))
7167 if (process_ia64_vms_dynamic_relocs (filedata
))
7168 has_dynamic_reloc
= TRUE
;
7170 if (! has_dynamic_reloc
)
7171 printf (_("\nThere are no dynamic relocations in this file.\n"));
7175 Elf_Internal_Shdr
* section
;
7177 bfd_boolean found
= FALSE
;
7179 for (i
= 0, section
= filedata
->section_headers
;
7180 i
< filedata
->file_header
.e_shnum
;
7183 if ( section
->sh_type
!= SHT_RELA
7184 && section
->sh_type
!= SHT_REL
)
7187 rel_offset
= section
->sh_offset
;
7188 rel_size
= section
->sh_size
;
7192 Elf_Internal_Shdr
* strsec
;
7194 unsigned long num_rela
;
7196 printf (_("\nRelocation section "));
7198 if (filedata
->string_table
== NULL
)
7199 printf ("%d", section
->sh_name
);
7201 printf ("'%s'", printable_section_name (filedata
, section
));
7203 num_rela
= rel_size
/ section
->sh_entsize
;
7204 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7205 " at offset 0x%lx contains %lu entries:\n",
7207 rel_offset
, num_rela
);
7209 is_rela
= section
->sh_type
== SHT_RELA
;
7211 if (section
->sh_link
!= 0
7212 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7214 Elf_Internal_Shdr
* symsec
;
7215 Elf_Internal_Sym
* symtab
;
7216 unsigned long nsyms
;
7217 unsigned long strtablen
= 0;
7218 char * strtab
= NULL
;
7220 symsec
= filedata
->section_headers
+ section
->sh_link
;
7221 if (symsec
->sh_type
!= SHT_SYMTAB
7222 && symsec
->sh_type
!= SHT_DYNSYM
)
7225 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7230 if (symsec
->sh_link
!= 0
7231 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7233 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7235 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7238 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7241 dump_relocations (filedata
, rel_offset
, rel_size
,
7242 symtab
, nsyms
, strtab
, strtablen
,
7244 symsec
->sh_type
== SHT_DYNSYM
);
7250 dump_relocations (filedata
, rel_offset
, rel_size
,
7251 NULL
, 0, NULL
, 0, is_rela
,
7252 FALSE
/* is_dynamic */);
7260 /* Users sometimes forget the -D option, so try to be helpful. */
7261 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7263 if (dynamic_info
[dynamic_relocations
[i
].size
])
7265 printf (_("\nThere are no static relocations in this file."));
7266 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7271 if (i
== ARRAY_SIZE (dynamic_relocations
))
7272 printf (_("\nThere are no relocations in this file.\n"));
7279 /* An absolute address consists of a section and an offset. If the
7280 section is NULL, the offset itself is the address, otherwise, the
7281 address equals to LOAD_ADDRESS(section) + offset. */
7285 unsigned short section
;
7289 #define ABSADDR(a) \
7291 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7294 /* Find the nearest symbol at or below ADDR. Returns the symbol
7295 name, if found, and the offset from the symbol to ADDR. */
7298 find_symbol_for_address (Filedata
* filedata
,
7299 Elf_Internal_Sym
* symtab
,
7300 unsigned long nsyms
,
7301 const char * strtab
,
7302 unsigned long strtab_size
,
7303 struct absaddr addr
,
7304 const char ** symname
,
7307 bfd_vma dist
= 0x100000;
7308 Elf_Internal_Sym
* sym
;
7309 Elf_Internal_Sym
* beg
;
7310 Elf_Internal_Sym
* end
;
7311 Elf_Internal_Sym
* best
= NULL
;
7313 REMOVE_ARCH_BITS (addr
.offset
);
7315 end
= symtab
+ nsyms
;
7321 sym
= beg
+ (end
- beg
) / 2;
7323 value
= sym
->st_value
;
7324 REMOVE_ARCH_BITS (value
);
7326 if (sym
->st_name
!= 0
7327 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7328 && addr
.offset
>= value
7329 && addr
.offset
- value
< dist
)
7332 dist
= addr
.offset
- value
;
7337 if (addr
.offset
< value
)
7345 *symname
= (best
->st_name
>= strtab_size
7346 ? _("<corrupt>") : strtab
+ best
->st_name
);
7352 *offset
= addr
.offset
;
7355 static /* signed */ int
7356 symcmp (const void *p
, const void *q
)
7358 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7359 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7361 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7364 /* Process the unwind section. */
7366 #include "unwind-ia64.h"
7368 struct ia64_unw_table_entry
7370 struct absaddr start
;
7372 struct absaddr info
;
7375 struct ia64_unw_aux_info
7377 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7378 unsigned long table_len
; /* Length of unwind table. */
7379 unsigned char * info
; /* Unwind info. */
7380 unsigned long info_size
; /* Size of unwind info. */
7381 bfd_vma info_addr
; /* Starting address of unwind info. */
7382 bfd_vma seg_base
; /* Starting address of segment. */
7383 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7384 unsigned long nsyms
; /* Number of symbols. */
7385 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7386 unsigned long nfuns
; /* Number of entries in funtab. */
7387 char * strtab
; /* The string table. */
7388 unsigned long strtab_size
; /* Size of string table. */
7392 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7394 struct ia64_unw_table_entry
* tp
;
7395 unsigned long j
, nfuns
;
7397 bfd_boolean res
= TRUE
;
7399 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7400 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7401 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7402 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7404 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7406 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7410 const unsigned char * dp
;
7411 const unsigned char * head
;
7412 const unsigned char * end
;
7413 const char * procname
;
7415 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7416 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7418 fputs ("\n<", stdout
);
7422 fputs (procname
, stdout
);
7425 printf ("+%lx", (unsigned long) offset
);
7428 fputs (">: [", stdout
);
7429 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7430 fputc ('-', stdout
);
7431 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7432 printf ("], info at +0x%lx\n",
7433 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7435 /* PR 17531: file: 86232b32. */
7436 if (aux
->info
== NULL
)
7439 /* PR 17531: file: 0997b4d1. */
7440 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7442 warn (_("Invalid offset %lx in table entry %ld\n"),
7443 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7448 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7449 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7451 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7452 (unsigned) UNW_VER (stamp
),
7453 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7454 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7455 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7456 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7458 if (UNW_VER (stamp
) != 1)
7460 printf (_("\tUnknown version.\n"));
7465 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7466 /* PR 17531: file: 16ceda89. */
7467 if (end
> aux
->info
+ aux
->info_size
)
7468 end
= aux
->info
+ aux
->info_size
;
7469 for (dp
= head
+ 8; dp
< end
;)
7470 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7479 slurp_ia64_unwind_table (Filedata
* filedata
,
7480 struct ia64_unw_aux_info
* aux
,
7481 Elf_Internal_Shdr
* sec
)
7483 unsigned long size
, nrelas
, i
;
7484 Elf_Internal_Phdr
* seg
;
7485 struct ia64_unw_table_entry
* tep
;
7486 Elf_Internal_Shdr
* relsec
;
7487 Elf_Internal_Rela
* rela
;
7488 Elf_Internal_Rela
* rp
;
7489 unsigned char * table
;
7491 Elf_Internal_Sym
* sym
;
7492 const char * relname
;
7496 /* First, find the starting address of the segment that includes
7499 if (filedata
->file_header
.e_phnum
)
7501 if (! get_program_headers (filedata
))
7504 for (seg
= filedata
->program_headers
;
7505 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7508 if (seg
->p_type
!= PT_LOAD
)
7511 if (sec
->sh_addr
>= seg
->p_vaddr
7512 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7514 aux
->seg_base
= seg
->p_vaddr
;
7520 /* Second, build the unwind table from the contents of the unwind section: */
7521 size
= sec
->sh_size
;
7522 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7527 aux
->table_len
= size
/ (3 * eh_addr_size
);
7528 aux
->table
= (struct ia64_unw_table_entry
*)
7529 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7532 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7534 tep
->start
.section
= SHN_UNDEF
;
7535 tep
->end
.section
= SHN_UNDEF
;
7536 tep
->info
.section
= SHN_UNDEF
;
7537 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7538 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7539 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7540 tep
->start
.offset
+= aux
->seg_base
;
7541 tep
->end
.offset
+= aux
->seg_base
;
7542 tep
->info
.offset
+= aux
->seg_base
;
7546 /* Third, apply any relocations to the unwind table: */
7547 for (relsec
= filedata
->section_headers
;
7548 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7551 if (relsec
->sh_type
!= SHT_RELA
7552 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7553 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7556 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7565 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7567 relname
= elf_ia64_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7568 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7570 /* PR 17531: file: 9fa67536. */
7571 if (relname
== NULL
)
7573 warn (_("Skipping unknown relocation type: %u\n"),
7574 get_reloc_type (filedata
, rp
->r_info
));
7578 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7580 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7584 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7586 /* PR 17531: file: 5bc8d9bf. */
7587 if (i
>= aux
->table_len
)
7589 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7593 switch (rp
->r_offset
/ eh_addr_size
% 3)
7596 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7597 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7600 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7601 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7604 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7605 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7619 ia64_process_unwind (Filedata
* filedata
)
7621 Elf_Internal_Shdr
* sec
;
7622 Elf_Internal_Shdr
* unwsec
= NULL
;
7623 Elf_Internal_Shdr
* strsec
;
7624 unsigned long i
, unwcount
= 0, unwstart
= 0;
7625 struct ia64_unw_aux_info aux
;
7626 bfd_boolean res
= TRUE
;
7628 memset (& aux
, 0, sizeof (aux
));
7630 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7632 if (sec
->sh_type
== SHT_SYMTAB
7633 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7635 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7637 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7638 if (aux
.strtab
!= NULL
)
7640 error (_("Multiple auxillary string tables encountered\n"));
7644 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7647 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7649 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7654 printf (_("\nThere are no unwind sections in this file.\n"));
7656 while (unwcount
-- > 0)
7661 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7662 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7663 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7668 /* We have already counted the number of SHT_IA64_UNWIND
7669 sections so the loop above should never fail. */
7670 assert (unwsec
!= NULL
);
7673 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7675 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7677 /* We need to find which section group it is in. */
7678 struct group_list
* g
;
7680 if (section_headers_groups
== NULL
7681 || section_headers_groups
[i
] == NULL
)
7682 i
= filedata
->file_header
.e_shnum
;
7685 g
= section_headers_groups
[i
]->root
;
7687 for (; g
!= NULL
; g
= g
->next
)
7689 sec
= filedata
->section_headers
+ g
->section_index
;
7691 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7696 i
= filedata
->file_header
.e_shnum
;
7699 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7701 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7702 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7703 suffix
= SECTION_NAME (unwsec
) + len
;
7704 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7706 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7707 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7712 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7713 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7714 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7715 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7717 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7718 suffix
= SECTION_NAME (unwsec
) + len
;
7719 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7721 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7722 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7726 if (i
== filedata
->file_header
.e_shnum
)
7728 printf (_("\nCould not find unwind info section for "));
7730 if (filedata
->string_table
== NULL
)
7731 printf ("%d", unwsec
->sh_name
);
7733 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7737 aux
.info_addr
= sec
->sh_addr
;
7738 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7741 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7743 printf (_("\nUnwind section "));
7745 if (filedata
->string_table
== NULL
)
7746 printf ("%d", unwsec
->sh_name
);
7748 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7750 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7751 (unsigned long) unwsec
->sh_offset
,
7752 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7754 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7755 && aux
.table_len
> 0)
7756 dump_ia64_unwind (filedata
, & aux
);
7759 free ((char *) aux
.table
);
7761 free ((char *) aux
.info
);
7770 free ((char *) aux
.strtab
);
7775 struct hppa_unw_table_entry
7777 struct absaddr start
;
7779 unsigned int Cannot_unwind
:1; /* 0 */
7780 unsigned int Millicode
:1; /* 1 */
7781 unsigned int Millicode_save_sr0
:1; /* 2 */
7782 unsigned int Region_description
:2; /* 3..4 */
7783 unsigned int reserved1
:1; /* 5 */
7784 unsigned int Entry_SR
:1; /* 6 */
7785 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7786 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7787 unsigned int Args_stored
:1; /* 16 */
7788 unsigned int Variable_Frame
:1; /* 17 */
7789 unsigned int Separate_Package_Body
:1; /* 18 */
7790 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7791 unsigned int Stack_Overflow_Check
:1; /* 20 */
7792 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7793 unsigned int Ada_Region
:1; /* 22 */
7794 unsigned int cxx_info
:1; /* 23 */
7795 unsigned int cxx_try_catch
:1; /* 24 */
7796 unsigned int sched_entry_seq
:1; /* 25 */
7797 unsigned int reserved2
:1; /* 26 */
7798 unsigned int Save_SP
:1; /* 27 */
7799 unsigned int Save_RP
:1; /* 28 */
7800 unsigned int Save_MRP_in_frame
:1; /* 29 */
7801 unsigned int extn_ptr_defined
:1; /* 30 */
7802 unsigned int Cleanup_defined
:1; /* 31 */
7804 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7805 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7806 unsigned int Large_frame
:1; /* 2 */
7807 unsigned int Pseudo_SP_Set
:1; /* 3 */
7808 unsigned int reserved4
:1; /* 4 */
7809 unsigned int Total_frame_size
:27; /* 5..31 */
7812 struct hppa_unw_aux_info
7814 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7815 unsigned long table_len
; /* Length of unwind table. */
7816 bfd_vma seg_base
; /* Starting address of segment. */
7817 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7818 unsigned long nsyms
; /* Number of symbols. */
7819 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7820 unsigned long nfuns
; /* Number of entries in funtab. */
7821 char * strtab
; /* The string table. */
7822 unsigned long strtab_size
; /* Size of string table. */
7826 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7828 struct hppa_unw_table_entry
* tp
;
7829 unsigned long j
, nfuns
;
7830 bfd_boolean res
= TRUE
;
7832 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7833 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7834 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7835 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7837 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7839 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7842 const char * procname
;
7844 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7845 aux
->strtab_size
, tp
->start
, &procname
,
7848 fputs ("\n<", stdout
);
7852 fputs (procname
, stdout
);
7855 printf ("+%lx", (unsigned long) offset
);
7858 fputs (">: [", stdout
);
7859 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7860 fputc ('-', stdout
);
7861 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7864 #define PF(_m) if (tp->_m) printf (#_m " ");
7865 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7868 PF(Millicode_save_sr0
);
7869 /* PV(Region_description); */
7875 PF(Separate_Package_Body
);
7876 PF(Frame_Extension_Millicode
);
7877 PF(Stack_Overflow_Check
);
7878 PF(Two_Instruction_SP_Increment
);
7882 PF(sched_entry_seq
);
7885 PF(Save_MRP_in_frame
);
7886 PF(extn_ptr_defined
);
7887 PF(Cleanup_defined
);
7888 PF(MPE_XL_interrupt_marker
);
7889 PF(HP_UX_interrupt_marker
);
7892 PV(Total_frame_size
);
7905 slurp_hppa_unwind_table (Filedata
* filedata
,
7906 struct hppa_unw_aux_info
* aux
,
7907 Elf_Internal_Shdr
* sec
)
7909 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7910 Elf_Internal_Phdr
* seg
;
7911 struct hppa_unw_table_entry
* tep
;
7912 Elf_Internal_Shdr
* relsec
;
7913 Elf_Internal_Rela
* rela
;
7914 Elf_Internal_Rela
* rp
;
7915 unsigned char * table
;
7917 Elf_Internal_Sym
* sym
;
7918 const char * relname
;
7920 /* First, find the starting address of the segment that includes
7922 if (filedata
->file_header
.e_phnum
)
7924 if (! get_program_headers (filedata
))
7927 for (seg
= filedata
->program_headers
;
7928 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7931 if (seg
->p_type
!= PT_LOAD
)
7934 if (sec
->sh_addr
>= seg
->p_vaddr
7935 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7937 aux
->seg_base
= seg
->p_vaddr
;
7943 /* Second, build the unwind table from the contents of the unwind
7945 size
= sec
->sh_size
;
7946 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7952 nentries
= size
/ unw_ent_size
;
7953 size
= unw_ent_size
* nentries
;
7955 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7956 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7958 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7960 unsigned int tmp1
, tmp2
;
7962 tep
->start
.section
= SHN_UNDEF
;
7963 tep
->end
.section
= SHN_UNDEF
;
7965 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7966 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7967 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7968 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7970 tep
->start
.offset
+= aux
->seg_base
;
7971 tep
->end
.offset
+= aux
->seg_base
;
7973 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7974 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7975 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7976 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7977 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7978 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7979 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7980 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7981 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7982 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7983 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7984 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7985 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7986 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7987 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7988 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7989 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7990 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7991 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7992 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7993 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7994 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7995 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7996 tep
->Cleanup_defined
= tmp1
& 0x1;
7998 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7999 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8000 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8001 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8002 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8003 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8007 /* Third, apply any relocations to the unwind table. */
8008 for (relsec
= filedata
->section_headers
;
8009 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8012 if (relsec
->sh_type
!= SHT_RELA
8013 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8014 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8017 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8021 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8023 relname
= elf_hppa_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
8024 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
8026 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8027 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8029 warn (_("Skipping unexpected relocation type %s\n"), relname
);
8033 i
= rp
->r_offset
/ unw_ent_size
;
8035 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
8038 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8039 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8042 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8043 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8053 aux
->table_len
= nentries
;
8059 hppa_process_unwind (Filedata
* filedata
)
8061 struct hppa_unw_aux_info aux
;
8062 Elf_Internal_Shdr
* unwsec
= NULL
;
8063 Elf_Internal_Shdr
* strsec
;
8064 Elf_Internal_Shdr
* sec
;
8066 bfd_boolean res
= TRUE
;
8068 if (filedata
->string_table
== NULL
)
8071 memset (& aux
, 0, sizeof (aux
));
8073 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8075 if (sec
->sh_type
== SHT_SYMTAB
8076 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8078 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8080 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8081 if (aux
.strtab
!= NULL
)
8083 error (_("Multiple auxillary string tables encountered\n"));
8087 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8090 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8092 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8097 printf (_("\nThere are no unwind sections in this file.\n"));
8099 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8101 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8103 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8105 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8106 "contains %lu entry:\n",
8107 "\nUnwind section '%s' at offset 0x%lx "
8108 "contains %lu entries:\n",
8110 printable_section_name (filedata
, sec
),
8111 (unsigned long) sec
->sh_offset
,
8114 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8117 if (aux
.table_len
> 0)
8119 if (! dump_hppa_unwind (filedata
, &aux
))
8124 free ((char *) aux
.table
);
8132 free ((char *) aux
.strtab
);
8139 unsigned char * data
; /* The unwind data. */
8140 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8141 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8142 unsigned long nrelas
; /* The number of relocations. */
8143 unsigned int rel_type
; /* REL or RELA ? */
8144 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8147 struct arm_unw_aux_info
8149 Filedata
* filedata
; /* The file containing the unwind sections. */
8150 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8151 unsigned long nsyms
; /* Number of symbols. */
8152 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8153 unsigned long nfuns
; /* Number of these symbols. */
8154 char * strtab
; /* The file's string table. */
8155 unsigned long strtab_size
; /* Size of string table. */
8159 arm_print_vma_and_name (Filedata
* filedata
,
8160 struct arm_unw_aux_info
* aux
,
8162 struct absaddr addr
)
8164 const char *procname
;
8167 if (addr
.section
== SHN_UNDEF
)
8170 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8171 aux
->strtab_size
, addr
, &procname
,
8174 print_vma (fn
, PREFIX_HEX
);
8178 fputs (" <", stdout
);
8179 fputs (procname
, stdout
);
8182 printf ("+0x%lx", (unsigned long) sym_offset
);
8183 fputc ('>', stdout
);
8190 arm_free_section (struct arm_section
*arm_sec
)
8192 if (arm_sec
->data
!= NULL
)
8193 free (arm_sec
->data
);
8195 if (arm_sec
->rela
!= NULL
)
8196 free (arm_sec
->rela
);
8199 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8200 cached section and install SEC instead.
8201 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8202 and return its valued in * WORDP, relocating if necessary.
8203 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8204 relocation's offset in ADDR.
8205 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8206 into the string table of the symbol associated with the reloc. If no
8207 reloc was applied store -1 there.
8208 5) Return TRUE upon success, FALSE otherwise. */
8211 get_unwind_section_word (Filedata
* filedata
,
8212 struct arm_unw_aux_info
* aux
,
8213 struct arm_section
* arm_sec
,
8214 Elf_Internal_Shdr
* sec
,
8215 bfd_vma word_offset
,
8216 unsigned int * wordp
,
8217 struct absaddr
* addr
,
8220 Elf_Internal_Rela
*rp
;
8221 Elf_Internal_Sym
*sym
;
8222 const char * relname
;
8224 bfd_boolean wrapped
;
8226 if (sec
== NULL
|| arm_sec
== NULL
)
8229 addr
->section
= SHN_UNDEF
;
8232 if (sym_name
!= NULL
)
8233 *sym_name
= (bfd_vma
) -1;
8235 /* If necessary, update the section cache. */
8236 if (sec
!= arm_sec
->sec
)
8238 Elf_Internal_Shdr
*relsec
;
8240 arm_free_section (arm_sec
);
8243 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8244 sec
->sh_size
, _("unwind data"));
8245 arm_sec
->rela
= NULL
;
8246 arm_sec
->nrelas
= 0;
8248 for (relsec
= filedata
->section_headers
;
8249 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8252 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8253 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8254 /* PR 15745: Check the section type as well. */
8255 || (relsec
->sh_type
!= SHT_REL
8256 && relsec
->sh_type
!= SHT_RELA
))
8259 arm_sec
->rel_type
= relsec
->sh_type
;
8260 if (relsec
->sh_type
== SHT_REL
)
8262 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8264 & arm_sec
->rela
, & arm_sec
->nrelas
))
8267 else /* relsec->sh_type == SHT_RELA */
8269 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8271 & arm_sec
->rela
, & arm_sec
->nrelas
))
8277 arm_sec
->next_rela
= arm_sec
->rela
;
8280 /* If there is no unwind data we can do nothing. */
8281 if (arm_sec
->data
== NULL
)
8284 /* If the offset is invalid then fail. */
8285 if (/* PR 21343 *//* PR 18879 */
8287 || word_offset
> (sec
->sh_size
- 4)
8288 || ((bfd_signed_vma
) word_offset
) < 0)
8291 /* Get the word at the required offset. */
8292 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8294 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8295 if (arm_sec
->rela
== NULL
)
8301 /* Look through the relocs to find the one that applies to the provided offset. */
8303 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8305 bfd_vma prelval
, offset
;
8307 if (rp
->r_offset
> word_offset
&& !wrapped
)
8312 if (rp
->r_offset
> word_offset
)
8315 if (rp
->r_offset
& 3)
8317 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8318 (unsigned long) rp
->r_offset
);
8322 if (rp
->r_offset
< word_offset
)
8325 /* PR 17531: file: 027-161405-0.004 */
8326 if (aux
->symtab
== NULL
)
8329 if (arm_sec
->rel_type
== SHT_REL
)
8331 offset
= word
& 0x7fffffff;
8332 if (offset
& 0x40000000)
8333 offset
|= ~ (bfd_vma
) 0x7fffffff;
8335 else if (arm_sec
->rel_type
== SHT_RELA
)
8336 offset
= rp
->r_addend
;
8339 error (_("Unknown section relocation type %d encountered\n"),
8344 /* PR 17531 file: 027-1241568-0.004. */
8345 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8347 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8348 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8352 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8353 offset
+= sym
->st_value
;
8354 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8356 /* Check that we are processing the expected reloc type. */
8357 if (filedata
->file_header
.e_machine
== EM_ARM
)
8359 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8360 if (relname
== NULL
)
8362 warn (_("Skipping unknown ARM relocation type: %d\n"),
8363 (int) ELF32_R_TYPE (rp
->r_info
));
8367 if (streq (relname
, "R_ARM_NONE"))
8370 if (! streq (relname
, "R_ARM_PREL31"))
8372 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8376 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8378 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8379 if (relname
== NULL
)
8381 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8382 (int) ELF32_R_TYPE (rp
->r_info
));
8386 if (streq (relname
, "R_C6000_NONE"))
8389 if (! streq (relname
, "R_C6000_PREL31"))
8391 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8399 /* This function currently only supports ARM and TI unwinders. */
8400 warn (_("Only TI and ARM unwinders are currently supported\n"));
8404 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8405 addr
->section
= sym
->st_shndx
;
8406 addr
->offset
= offset
;
8409 * sym_name
= sym
->st_name
;
8414 arm_sec
->next_rela
= rp
;
8419 static const char *tic6x_unwind_regnames
[16] =
8421 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8422 "A14", "A13", "A12", "A11", "A10",
8423 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8427 decode_tic6x_unwind_regmask (unsigned int mask
)
8431 for (i
= 12; mask
; mask
>>= 1, i
--)
8435 fputs (tic6x_unwind_regnames
[i
], stdout
);
8437 fputs (", ", stdout
);
8443 if (remaining == 0 && more_words) \
8446 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8447 data_offset, & word, & addr, NULL)) \
8453 #define GET_OP(OP) \
8458 (OP) = word >> 24; \
8463 printf (_("[Truncated opcode]\n")); \
8466 printf ("0x%02x ", OP)
8469 decode_arm_unwind_bytecode (Filedata
* filedata
,
8470 struct arm_unw_aux_info
* aux
,
8472 unsigned int remaining
,
8473 unsigned int more_words
,
8474 bfd_vma data_offset
,
8475 Elf_Internal_Shdr
* data_sec
,
8476 struct arm_section
* data_arm_sec
)
8478 struct absaddr addr
;
8479 bfd_boolean res
= TRUE
;
8481 /* Decode the unwinding instructions. */
8484 unsigned int op
, op2
;
8493 printf (" 0x%02x ", op
);
8495 if ((op
& 0xc0) == 0x00)
8497 int offset
= ((op
& 0x3f) << 2) + 4;
8499 printf (" vsp = vsp + %d", offset
);
8501 else if ((op
& 0xc0) == 0x40)
8503 int offset
= ((op
& 0x3f) << 2) + 4;
8505 printf (" vsp = vsp - %d", offset
);
8507 else if ((op
& 0xf0) == 0x80)
8510 if (op
== 0x80 && op2
== 0)
8511 printf (_("Refuse to unwind"));
8514 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8515 bfd_boolean first
= TRUE
;
8519 for (i
= 0; i
< 12; i
++)
8520 if (mask
& (1 << i
))
8526 printf ("r%d", 4 + i
);
8531 else if ((op
& 0xf0) == 0x90)
8533 if (op
== 0x9d || op
== 0x9f)
8534 printf (_(" [Reserved]"));
8536 printf (" vsp = r%d", op
& 0x0f);
8538 else if ((op
& 0xf0) == 0xa0)
8540 int end
= 4 + (op
& 0x07);
8541 bfd_boolean first
= TRUE
;
8545 for (i
= 4; i
<= end
; i
++)
8561 else if (op
== 0xb0)
8562 printf (_(" finish"));
8563 else if (op
== 0xb1)
8566 if (op2
== 0 || (op2
& 0xf0) != 0)
8567 printf (_("[Spare]"));
8570 unsigned int mask
= op2
& 0x0f;
8571 bfd_boolean first
= TRUE
;
8575 for (i
= 0; i
< 12; i
++)
8576 if (mask
& (1 << i
))
8587 else if (op
== 0xb2)
8589 unsigned char buf
[9];
8590 unsigned int i
, len
;
8591 unsigned long offset
;
8593 for (i
= 0; i
< sizeof (buf
); i
++)
8596 if ((buf
[i
] & 0x80) == 0)
8599 if (i
== sizeof (buf
))
8601 error (_("corrupt change to vsp"));
8606 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8607 assert (len
== i
+ 1);
8608 offset
= offset
* 4 + 0x204;
8609 printf ("vsp = vsp + %ld", offset
);
8612 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8614 unsigned int first
, last
;
8621 printf ("pop {D%d", first
);
8623 printf ("-D%d", first
+ last
);
8626 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8628 unsigned int count
= op
& 0x07;
8632 printf ("-D%d", 8 + count
);
8635 else if (op
>= 0xc0 && op
<= 0xc5)
8637 unsigned int count
= op
& 0x07;
8639 printf (" pop {wR10");
8641 printf ("-wR%d", 10 + count
);
8644 else if (op
== 0xc6)
8646 unsigned int first
, last
;
8651 printf ("pop {wR%d", first
);
8653 printf ("-wR%d", first
+ last
);
8656 else if (op
== 0xc7)
8659 if (op2
== 0 || (op2
& 0xf0) != 0)
8660 printf (_("[Spare]"));
8663 unsigned int mask
= op2
& 0x0f;
8664 bfd_boolean first
= TRUE
;
8668 for (i
= 0; i
< 4; i
++)
8669 if (mask
& (1 << i
))
8675 printf ("wCGR%d", i
);
8682 printf (_(" [unsupported opcode]"));
8693 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8694 struct arm_unw_aux_info
* aux
,
8696 unsigned int remaining
,
8697 unsigned int more_words
,
8698 bfd_vma data_offset
,
8699 Elf_Internal_Shdr
* data_sec
,
8700 struct arm_section
* data_arm_sec
)
8702 struct absaddr addr
;
8704 /* Decode the unwinding instructions. */
8707 unsigned int op
, op2
;
8716 printf (" 0x%02x ", op
);
8718 if ((op
& 0xc0) == 0x00)
8720 int offset
= ((op
& 0x3f) << 3) + 8;
8721 printf (" sp = sp + %d", offset
);
8723 else if ((op
& 0xc0) == 0x80)
8726 if (op
== 0x80 && op2
== 0)
8727 printf (_("Refuse to unwind"));
8730 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8732 printf ("pop compact {");
8736 decode_tic6x_unwind_regmask (mask
);
8740 else if ((op
& 0xf0) == 0xc0)
8748 unsigned int offset
;
8752 /* Scan entire instruction first so that GET_OP output is not
8753 interleaved with disassembly. */
8755 for (i
= 0; nregs
< (op
& 0xf); i
++)
8761 regpos
[nregs
].offset
= i
* 2;
8762 regpos
[nregs
].reg
= reg
;
8769 regpos
[nregs
].offset
= i
* 2 + 1;
8770 regpos
[nregs
].reg
= reg
;
8775 printf (_("pop frame {"));
8777 for (i
= i
* 2; i
> 0; i
--)
8779 if (regpos
[reg
].offset
== i
- 1)
8781 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8788 fputs (name
, stdout
);
8795 else if (op
== 0xd0)
8796 printf (" MOV FP, SP");
8797 else if (op
== 0xd1)
8798 printf (" __c6xabi_pop_rts");
8799 else if (op
== 0xd2)
8801 unsigned char buf
[9];
8802 unsigned int i
, len
;
8803 unsigned long offset
;
8805 for (i
= 0; i
< sizeof (buf
); i
++)
8808 if ((buf
[i
] & 0x80) == 0)
8811 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8812 if (i
== sizeof (buf
))
8814 warn (_("Corrupt stack pointer adjustment detected\n"));
8818 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8819 assert (len
== i
+ 1);
8820 offset
= offset
* 8 + 0x408;
8821 printf (_("sp = sp + %ld"), offset
);
8823 else if ((op
& 0xf0) == 0xe0)
8825 if ((op
& 0x0f) == 7)
8828 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8832 printf (_(" [unsupported opcode]"));
8841 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8845 offset
= word
& 0x7fffffff;
8846 if (offset
& 0x40000000)
8847 offset
|= ~ (bfd_vma
) 0x7fffffff;
8849 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8852 return offset
+ where
;
8856 decode_arm_unwind (Filedata
* filedata
,
8857 struct arm_unw_aux_info
* aux
,
8859 unsigned int remaining
,
8860 bfd_vma data_offset
,
8861 Elf_Internal_Shdr
* data_sec
,
8862 struct arm_section
* data_arm_sec
)
8865 unsigned int more_words
= 0;
8866 struct absaddr addr
;
8867 bfd_vma sym_name
= (bfd_vma
) -1;
8868 bfd_boolean res
= TRUE
;
8872 /* Fetch the first word.
8873 Note - when decoding an object file the address extracted
8874 here will always be 0. So we also pass in the sym_name
8875 parameter so that we can find the symbol associated with
8876 the personality routine. */
8877 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8878 & word
, & addr
, & sym_name
))
8884 if ((word
& 0x80000000) == 0)
8886 /* Expand prel31 for personality routine. */
8888 const char *procname
;
8890 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8891 printf (_(" Personality routine: "));
8893 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8894 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8896 procname
= aux
->strtab
+ sym_name
;
8897 print_vma (fn
, PREFIX_HEX
);
8900 fputs (" <", stdout
);
8901 fputs (procname
, stdout
);
8902 fputc ('>', stdout
);
8906 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8907 fputc ('\n', stdout
);
8909 /* The GCC personality routines use the standard compact
8910 encoding, starting with one byte giving the number of
8912 if (procname
!= NULL
8913 && (const_strneq (procname
, "__gcc_personality_v0")
8914 || const_strneq (procname
, "__gxx_personality_v0")
8915 || const_strneq (procname
, "__gcj_personality_v0")
8916 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8923 printf (_(" [Truncated data]\n"));
8926 more_words
= word
>> 24;
8936 /* ARM EHABI Section 6.3:
8938 An exception-handling table entry for the compact model looks like:
8942 1 0 index Data for personalityRoutine[index] */
8944 if (filedata
->file_header
.e_machine
== EM_ARM
8945 && (word
& 0x70000000))
8947 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8951 per_index
= (word
>> 24) & 0x7f;
8952 printf (_(" Compact model index: %d\n"), per_index
);
8959 else if (per_index
< 3)
8961 more_words
= (word
>> 16) & 0xff;
8967 switch (filedata
->file_header
.e_machine
)
8972 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8973 data_offset
, data_sec
, data_arm_sec
))
8978 warn (_("Unknown ARM compact model index encountered\n"));
8979 printf (_(" [reserved]\n"));
8987 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8988 data_offset
, data_sec
, data_arm_sec
))
8991 else if (per_index
< 5)
8993 if (((word
>> 17) & 0x7f) == 0x7f)
8994 printf (_(" Restore stack from frame pointer\n"));
8996 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8997 printf (_(" Registers restored: "));
8999 printf (" (compact) ");
9000 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9002 printf (_(" Return register: %s\n"),
9003 tic6x_unwind_regnames
[word
& 0xf]);
9006 printf (_(" [reserved (%d)]\n"), per_index
);
9010 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9011 filedata
->file_header
.e_machine
);
9015 /* Decode the descriptors. Not implemented. */
9021 dump_arm_unwind (Filedata
* filedata
,
9022 struct arm_unw_aux_info
* aux
,
9023 Elf_Internal_Shdr
* exidx_sec
)
9025 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9026 unsigned int i
, exidx_len
;
9027 unsigned long j
, nfuns
;
9028 bfd_boolean res
= TRUE
;
9030 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9031 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9032 exidx_len
= exidx_sec
->sh_size
/ 8;
9034 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9035 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9036 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9037 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9039 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9041 for (i
= 0; i
< exidx_len
; i
++)
9043 unsigned int exidx_fn
, exidx_entry
;
9044 struct absaddr fn_addr
, entry_addr
;
9047 fputc ('\n', stdout
);
9049 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9050 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9051 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9052 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9055 arm_free_section (& exidx_arm_sec
);
9056 arm_free_section (& extab_arm_sec
);
9060 /* ARM EHABI, Section 5:
9061 An index table entry consists of 2 words.
9062 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9063 if (exidx_fn
& 0x80000000)
9065 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9069 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9071 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9072 fputs (": ", stdout
);
9074 if (exidx_entry
== 1)
9076 print_vma (exidx_entry
, PREFIX_HEX
);
9077 fputs (" [cantunwind]\n", stdout
);
9079 else if (exidx_entry
& 0x80000000)
9081 print_vma (exidx_entry
, PREFIX_HEX
);
9082 fputc ('\n', stdout
);
9083 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9087 bfd_vma table
, table_offset
= 0;
9088 Elf_Internal_Shdr
*table_sec
;
9090 fputs ("@", stdout
);
9091 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9092 print_vma (table
, PREFIX_HEX
);
9095 /* Locate the matching .ARM.extab. */
9096 if (entry_addr
.section
!= SHN_UNDEF
9097 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9099 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9100 table_offset
= entry_addr
.offset
;
9102 if (table_offset
> table_sec
->sh_size
9103 || ((bfd_signed_vma
) table_offset
) < 0)
9105 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9106 (unsigned long) table_offset
,
9107 printable_section_name (filedata
, table_sec
));
9114 table_sec
= find_section_by_address (filedata
, table
);
9115 if (table_sec
!= NULL
)
9116 table_offset
= table
- table_sec
->sh_addr
;
9119 if (table_sec
== NULL
)
9121 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9122 (unsigned long) table
);
9127 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9136 arm_free_section (&exidx_arm_sec
);
9137 arm_free_section (&extab_arm_sec
);
9142 /* Used for both ARM and C6X unwinding tables. */
9145 arm_process_unwind (Filedata
* filedata
)
9147 struct arm_unw_aux_info aux
;
9148 Elf_Internal_Shdr
*unwsec
= NULL
;
9149 Elf_Internal_Shdr
*strsec
;
9150 Elf_Internal_Shdr
*sec
;
9152 unsigned int sec_type
;
9153 bfd_boolean res
= TRUE
;
9155 switch (filedata
->file_header
.e_machine
)
9158 sec_type
= SHT_ARM_EXIDX
;
9162 sec_type
= SHT_C6000_UNWIND
;
9166 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9167 filedata
->file_header
.e_machine
);
9171 if (filedata
->string_table
== NULL
)
9174 memset (& aux
, 0, sizeof (aux
));
9175 aux
.filedata
= filedata
;
9177 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9179 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9181 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9183 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9185 /* PR binutils/17531 file: 011-12666-0.004. */
9186 if (aux
.strtab
!= NULL
)
9188 error (_("Multiple string tables found in file.\n"));
9192 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9193 1, strsec
->sh_size
, _("string table"));
9194 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9196 else if (sec
->sh_type
== sec_type
)
9201 printf (_("\nThere are no unwind sections in this file.\n"));
9203 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9205 if (sec
->sh_type
== sec_type
)
9207 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9208 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9209 "contains %lu entry:\n",
9210 "\nUnwind section '%s' at offset 0x%lx "
9211 "contains %lu entries:\n",
9213 printable_section_name (filedata
, sec
),
9214 (unsigned long) sec
->sh_offset
,
9217 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9225 free ((char *) aux
.strtab
);
9231 process_unwind (Filedata
* filedata
)
9233 struct unwind_handler
9235 unsigned int machtype
;
9236 bfd_boolean (* handler
)(Filedata
*);
9239 { EM_ARM
, arm_process_unwind
},
9240 { EM_IA_64
, ia64_process_unwind
},
9241 { EM_PARISC
, hppa_process_unwind
},
9242 { EM_TI_C6000
, arm_process_unwind
},
9250 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9251 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9252 return handlers
[i
].handler (filedata
);
9254 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9255 get_machine_name (filedata
->file_header
.e_machine
));
9260 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9262 switch (entry
->d_tag
)
9265 if (entry
->d_un
.d_val
== 0)
9269 static const char * opts
[] =
9271 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9272 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9273 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9274 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9278 bfd_boolean first
= TRUE
;
9280 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9281 if (entry
->d_un
.d_val
& (1 << cnt
))
9283 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9289 case DT_MIPS_IVERSION
:
9290 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9291 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9295 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9296 /* Note: coded this way so that there is a single string for translation. */
9297 printf (_("<corrupt: %s>"), buf
);
9301 case DT_MIPS_TIME_STAMP
:
9305 time_t atime
= entry
->d_un
.d_val
;
9307 tmp
= gmtime (&atime
);
9308 /* PR 17531: file: 6accc532. */
9310 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9312 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9313 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9314 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9315 printf (_("Time Stamp: %s"), timebuf
);
9319 case DT_MIPS_RLD_VERSION
:
9320 case DT_MIPS_LOCAL_GOTNO
:
9321 case DT_MIPS_CONFLICTNO
:
9322 case DT_MIPS_LIBLISTNO
:
9323 case DT_MIPS_SYMTABNO
:
9324 case DT_MIPS_UNREFEXTNO
:
9325 case DT_MIPS_HIPAGENO
:
9326 case DT_MIPS_DELTA_CLASS_NO
:
9327 case DT_MIPS_DELTA_INSTANCE_NO
:
9328 case DT_MIPS_DELTA_RELOC_NO
:
9329 case DT_MIPS_DELTA_SYM_NO
:
9330 case DT_MIPS_DELTA_CLASSSYM_NO
:
9331 case DT_MIPS_COMPACT_SIZE
:
9332 print_vma (entry
->d_un
.d_val
, DEC
);
9336 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9342 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9344 switch (entry
->d_tag
)
9346 case DT_HP_DLD_FLAGS
:
9355 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9356 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9357 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9358 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9359 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9360 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9361 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9362 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9363 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9364 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9365 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9366 { DT_HP_GST
, "HP_GST" },
9367 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9368 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9369 { DT_HP_NODELETE
, "HP_NODELETE" },
9370 { DT_HP_GROUP
, "HP_GROUP" },
9371 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9373 bfd_boolean first
= TRUE
;
9375 bfd_vma val
= entry
->d_un
.d_val
;
9377 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9378 if (val
& flags
[cnt
].bit
)
9382 fputs (flags
[cnt
].str
, stdout
);
9384 val
^= flags
[cnt
].bit
;
9387 if (val
!= 0 || first
)
9391 print_vma (val
, HEX
);
9397 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9405 /* VMS vs Unix time offset and factor. */
9407 #define VMS_EPOCH_OFFSET 35067168000000000LL
9408 #define VMS_GRANULARITY_FACTOR 10000000
9410 /* Display a VMS time in a human readable format. */
9413 print_vms_time (bfd_int64_t vmstime
)
9418 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9419 tm
= gmtime (&unxtime
);
9420 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9421 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9422 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9427 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9429 switch (entry
->d_tag
)
9431 case DT_IA_64_PLT_RESERVE
:
9432 /* First 3 slots reserved. */
9433 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9435 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9438 case DT_IA_64_VMS_LINKTIME
:
9440 print_vms_time (entry
->d_un
.d_val
);
9444 case DT_IA_64_VMS_LNKFLAGS
:
9445 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9446 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9447 printf (" CALL_DEBUG");
9448 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9449 printf (" NOP0BUFS");
9450 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9451 printf (" P0IMAGE");
9452 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9453 printf (" MKTHREADS");
9454 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9455 printf (" UPCALLS");
9456 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9458 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9459 printf (" INITIALIZE");
9460 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9462 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9463 printf (" EXE_INIT");
9464 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9465 printf (" TBK_IN_IMG");
9466 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9467 printf (" DBG_IN_IMG");
9468 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9469 printf (" TBK_IN_DSF");
9470 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9471 printf (" DBG_IN_DSF");
9472 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9473 printf (" SIGNATURES");
9474 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9475 printf (" REL_SEG_OFF");
9479 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9486 get_32bit_dynamic_section (Filedata
* filedata
)
9488 Elf32_External_Dyn
* edyn
;
9489 Elf32_External_Dyn
* ext
;
9490 Elf_Internal_Dyn
* entry
;
9492 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9493 dynamic_size
, _("dynamic section"));
9497 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9498 might not have the luxury of section headers. Look for the DT_NULL
9499 terminator to determine the number of entries. */
9500 for (ext
= edyn
, dynamic_nent
= 0;
9501 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9505 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9509 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9511 if (dynamic_section
== NULL
)
9513 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9514 (unsigned long) dynamic_nent
);
9519 for (ext
= edyn
, entry
= dynamic_section
;
9520 entry
< dynamic_section
+ dynamic_nent
;
9523 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9524 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9533 get_64bit_dynamic_section (Filedata
* filedata
)
9535 Elf64_External_Dyn
* edyn
;
9536 Elf64_External_Dyn
* ext
;
9537 Elf_Internal_Dyn
* entry
;
9539 /* Read in the data. */
9540 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9541 dynamic_size
, _("dynamic section"));
9545 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9546 might not have the luxury of section headers. Look for the DT_NULL
9547 terminator to determine the number of entries. */
9548 for (ext
= edyn
, dynamic_nent
= 0;
9549 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9550 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9554 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9558 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9560 if (dynamic_section
== NULL
)
9562 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9563 (unsigned long) dynamic_nent
);
9568 /* Convert from external to internal formats. */
9569 for (ext
= edyn
, entry
= dynamic_section
;
9570 entry
< dynamic_section
+ dynamic_nent
;
9573 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9574 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9583 print_dynamic_flags (bfd_vma flags
)
9585 bfd_boolean first
= TRUE
;
9591 flag
= flags
& - flags
;
9601 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9602 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9603 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9604 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9605 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9606 default: fputs (_("unknown"), stdout
); break;
9612 /* Parse and display the contents of the dynamic section. */
9615 process_dynamic_section (Filedata
* filedata
)
9617 Elf_Internal_Dyn
* entry
;
9619 if (dynamic_size
== 0)
9622 printf (_("\nThere is no dynamic section in this file.\n"));
9629 if (! get_32bit_dynamic_section (filedata
))
9634 if (! get_64bit_dynamic_section (filedata
))
9638 /* Find the appropriate symbol table. */
9639 if (dynamic_symbols
== NULL
)
9641 for (entry
= dynamic_section
;
9642 entry
< dynamic_section
+ dynamic_nent
;
9645 Elf_Internal_Shdr section
;
9647 if (entry
->d_tag
!= DT_SYMTAB
)
9650 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9652 /* Since we do not know how big the symbol table is,
9653 we default to reading in the entire file (!) and
9654 processing that. This is overkill, I know, but it
9656 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9657 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9659 /* See PR 21379 for a reproducer. */
9660 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9664 if (archive_file_offset
!= 0)
9665 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9667 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9670 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9672 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9673 section
.sh_name
= filedata
->string_table_length
;
9675 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9676 if (num_dynamic_syms
< 1)
9678 error (_("Unable to determine the number of symbols to load\n"));
9684 /* Similarly find a string table. */
9685 if (dynamic_strings
== NULL
)
9687 for (entry
= dynamic_section
;
9688 entry
< dynamic_section
+ dynamic_nent
;
9691 unsigned long offset
;
9694 if (entry
->d_tag
!= DT_STRTAB
)
9697 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9699 /* Since we do not know how big the string table is,
9700 we default to reading in the entire file (!) and
9701 processing that. This is overkill, I know, but it
9704 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9706 if (archive_file_offset
!= 0)
9707 str_tab_len
= archive_file_size
- offset
;
9709 str_tab_len
= filedata
->file_size
- offset
;
9711 if (str_tab_len
< 1)
9714 (_("Unable to determine the length of the dynamic string table\n"));
9718 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9720 _("dynamic string table"));
9721 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9726 /* And find the syminfo section if available. */
9727 if (dynamic_syminfo
== NULL
)
9729 unsigned long syminsz
= 0;
9731 for (entry
= dynamic_section
;
9732 entry
< dynamic_section
+ dynamic_nent
;
9735 if (entry
->d_tag
== DT_SYMINENT
)
9737 /* Note: these braces are necessary to avoid a syntax
9738 error from the SunOS4 C compiler. */
9739 /* PR binutils/17531: A corrupt file can trigger this test.
9740 So do not use an assert, instead generate an error message. */
9741 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9742 error (_("Bad value (%d) for SYMINENT entry\n"),
9743 (int) entry
->d_un
.d_val
);
9745 else if (entry
->d_tag
== DT_SYMINSZ
)
9746 syminsz
= entry
->d_un
.d_val
;
9747 else if (entry
->d_tag
== DT_SYMINFO
)
9748 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9752 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9754 Elf_External_Syminfo
* extsyminfo
;
9755 Elf_External_Syminfo
* extsym
;
9756 Elf_Internal_Syminfo
* syminfo
;
9758 /* There is a syminfo section. Read the data. */
9759 extsyminfo
= (Elf_External_Syminfo
*)
9760 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9761 _("symbol information"));
9765 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9766 if (dynamic_syminfo
== NULL
)
9768 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9769 (unsigned long) syminsz
);
9773 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9774 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9775 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9776 ++syminfo
, ++extsym
)
9778 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9779 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9786 if (do_dynamic
&& dynamic_addr
)
9787 printf (ngettext ("\nDynamic section at offset 0x%lx "
9788 "contains %lu entry:\n",
9789 "\nDynamic section at offset 0x%lx "
9790 "contains %lu entries:\n",
9792 dynamic_addr
, (unsigned long) dynamic_nent
);
9794 printf (_(" Tag Type Name/Value\n"));
9796 for (entry
= dynamic_section
;
9797 entry
< dynamic_section
+ dynamic_nent
;
9805 print_vma (entry
->d_tag
, FULL_HEX
);
9806 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9807 printf (" (%s)%*s", dtype
,
9808 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9811 switch (entry
->d_tag
)
9815 print_dynamic_flags (entry
->d_un
.d_val
);
9825 switch (entry
->d_tag
)
9828 printf (_("Auxiliary library"));
9832 printf (_("Filter library"));
9836 printf (_("Configuration file"));
9840 printf (_("Dependency audit library"));
9844 printf (_("Audit library"));
9848 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9849 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9853 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9862 printf (_("Flags:"));
9864 if (entry
->d_un
.d_val
== 0)
9865 printf (_(" None\n"));
9868 unsigned long int val
= entry
->d_un
.d_val
;
9870 if (val
& DTF_1_PARINIT
)
9872 printf (" PARINIT");
9873 val
^= DTF_1_PARINIT
;
9875 if (val
& DTF_1_CONFEXP
)
9877 printf (" CONFEXP");
9878 val
^= DTF_1_CONFEXP
;
9881 printf (" %lx", val
);
9890 printf (_("Flags:"));
9892 if (entry
->d_un
.d_val
== 0)
9893 printf (_(" None\n"));
9896 unsigned long int val
= entry
->d_un
.d_val
;
9898 if (val
& DF_P1_LAZYLOAD
)
9900 printf (" LAZYLOAD");
9901 val
^= DF_P1_LAZYLOAD
;
9903 if (val
& DF_P1_GROUPPERM
)
9905 printf (" GROUPPERM");
9906 val
^= DF_P1_GROUPPERM
;
9909 printf (" %lx", val
);
9918 printf (_("Flags:"));
9919 if (entry
->d_un
.d_val
== 0)
9920 printf (_(" None\n"));
9923 unsigned long int val
= entry
->d_un
.d_val
;
9930 if (val
& DF_1_GLOBAL
)
9935 if (val
& DF_1_GROUP
)
9940 if (val
& DF_1_NODELETE
)
9942 printf (" NODELETE");
9943 val
^= DF_1_NODELETE
;
9945 if (val
& DF_1_LOADFLTR
)
9947 printf (" LOADFLTR");
9948 val
^= DF_1_LOADFLTR
;
9950 if (val
& DF_1_INITFIRST
)
9952 printf (" INITFIRST");
9953 val
^= DF_1_INITFIRST
;
9955 if (val
& DF_1_NOOPEN
)
9960 if (val
& DF_1_ORIGIN
)
9965 if (val
& DF_1_DIRECT
)
9970 if (val
& DF_1_TRANS
)
9975 if (val
& DF_1_INTERPOSE
)
9977 printf (" INTERPOSE");
9978 val
^= DF_1_INTERPOSE
;
9980 if (val
& DF_1_NODEFLIB
)
9982 printf (" NODEFLIB");
9983 val
^= DF_1_NODEFLIB
;
9985 if (val
& DF_1_NODUMP
)
9990 if (val
& DF_1_CONFALT
)
9992 printf (" CONFALT");
9993 val
^= DF_1_CONFALT
;
9995 if (val
& DF_1_ENDFILTEE
)
9997 printf (" ENDFILTEE");
9998 val
^= DF_1_ENDFILTEE
;
10000 if (val
& DF_1_DISPRELDNE
)
10002 printf (" DISPRELDNE");
10003 val
^= DF_1_DISPRELDNE
;
10005 if (val
& DF_1_DISPRELPND
)
10007 printf (" DISPRELPND");
10008 val
^= DF_1_DISPRELPND
;
10010 if (val
& DF_1_NODIRECT
)
10012 printf (" NODIRECT");
10013 val
^= DF_1_NODIRECT
;
10015 if (val
& DF_1_IGNMULDEF
)
10017 printf (" IGNMULDEF");
10018 val
^= DF_1_IGNMULDEF
;
10020 if (val
& DF_1_NOKSYMS
)
10022 printf (" NOKSYMS");
10023 val
^= DF_1_NOKSYMS
;
10025 if (val
& DF_1_NOHDR
)
10030 if (val
& DF_1_EDITED
)
10032 printf (" EDITED");
10033 val
^= DF_1_EDITED
;
10035 if (val
& DF_1_NORELOC
)
10037 printf (" NORELOC");
10038 val
^= DF_1_NORELOC
;
10040 if (val
& DF_1_SYMINTPOSE
)
10042 printf (" SYMINTPOSE");
10043 val
^= DF_1_SYMINTPOSE
;
10045 if (val
& DF_1_GLOBAUDIT
)
10047 printf (" GLOBAUDIT");
10048 val
^= DF_1_GLOBAUDIT
;
10050 if (val
& DF_1_SINGLETON
)
10052 printf (" SINGLETON");
10053 val
^= DF_1_SINGLETON
;
10055 if (val
& DF_1_STUB
)
10060 if (val
& DF_1_PIE
)
10065 if (val
& DF_1_KMOD
)
10070 if (val
& DF_1_WEAKFILTER
)
10072 printf (" WEAKFILTER");
10073 val
^= DF_1_WEAKFILTER
;
10075 if (val
& DF_1_NOCOMMON
)
10077 printf (" NOCOMMON");
10078 val
^= DF_1_NOCOMMON
;
10081 printf (" %lx", val
);
10088 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10090 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10110 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10116 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10117 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10123 switch (entry
->d_tag
)
10126 printf (_("Shared library: [%s]"), name
);
10128 if (streq (name
, program_interpreter
))
10129 printf (_(" program interpreter"));
10133 printf (_("Library soname: [%s]"), name
);
10137 printf (_("Library rpath: [%s]"), name
);
10141 printf (_("Library runpath: [%s]"), name
);
10145 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10150 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10163 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10164 /* Fall through. */
10168 case DT_INIT_ARRAYSZ
:
10169 case DT_FINI_ARRAYSZ
:
10170 case DT_GNU_CONFLICTSZ
:
10171 case DT_GNU_LIBLISTSZ
:
10174 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10175 printf (_(" (bytes)\n"));
10180 case DT_VERNEEDNUM
:
10185 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10194 case DT_INIT_ARRAY
:
10195 case DT_FINI_ARRAY
:
10198 if (entry
->d_tag
== DT_USED
10199 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10201 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10205 printf (_("Not needed object: [%s]\n"), name
);
10210 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10216 /* The value of this entry is ignored. */
10221 case DT_GNU_PRELINKED
:
10225 time_t atime
= entry
->d_un
.d_val
;
10227 tmp
= gmtime (&atime
);
10228 /* PR 17533 file: 041-1244816-0.004. */
10230 printf (_("<corrupt time val: %lx"),
10231 (unsigned long) atime
);
10233 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10234 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10235 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10241 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10244 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10250 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10251 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10256 switch (filedata
->file_header
.e_machine
)
10259 case EM_MIPS_RS3_LE
:
10260 dynamic_section_mips_val (entry
);
10263 dynamic_section_parisc_val (entry
);
10266 dynamic_section_ia64_val (entry
);
10269 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10281 get_ver_flags (unsigned int flags
)
10283 static char buff
[128];
10290 if (flags
& VER_FLG_BASE
)
10291 strcat (buff
, "BASE");
10293 if (flags
& VER_FLG_WEAK
)
10295 if (flags
& VER_FLG_BASE
)
10296 strcat (buff
, " | ");
10298 strcat (buff
, "WEAK");
10301 if (flags
& VER_FLG_INFO
)
10303 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10304 strcat (buff
, " | ");
10306 strcat (buff
, "INFO");
10309 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10311 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10312 strcat (buff
, " | ");
10314 strcat (buff
, _("<unknown>"));
10320 /* Display the contents of the version sections. */
10323 process_version_sections (Filedata
* filedata
)
10325 Elf_Internal_Shdr
* section
;
10327 bfd_boolean found
= FALSE
;
10332 for (i
= 0, section
= filedata
->section_headers
;
10333 i
< filedata
->file_header
.e_shnum
;
10336 switch (section
->sh_type
)
10338 case SHT_GNU_verdef
:
10340 Elf_External_Verdef
* edefs
;
10347 printf (ngettext ("\nVersion definition section '%s' "
10348 "contains %u entry:\n",
10349 "\nVersion definition section '%s' "
10350 "contains %u entries:\n",
10352 printable_section_name (filedata
, section
),
10355 printf (_(" Addr: 0x"));
10356 printf_vma (section
->sh_addr
);
10357 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10358 (unsigned long) section
->sh_offset
, section
->sh_link
,
10359 printable_section_name_from_index (filedata
, section
->sh_link
));
10361 edefs
= (Elf_External_Verdef
*)
10362 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10363 _("version definition section"));
10366 endbuf
= (char *) edefs
+ section
->sh_size
;
10368 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10371 Elf_External_Verdef
* edef
;
10372 Elf_Internal_Verdef ent
;
10373 Elf_External_Verdaux
* eaux
;
10374 Elf_Internal_Verdaux aux
;
10375 unsigned long isum
;
10378 vstart
= ((char *) edefs
) + idx
;
10379 if (vstart
+ sizeof (*edef
) > endbuf
)
10382 edef
= (Elf_External_Verdef
*) vstart
;
10384 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10385 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10386 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10387 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10388 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10389 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10390 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10392 printf (_(" %#06lx: Rev: %d Flags: %s"),
10393 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10395 printf (_(" Index: %d Cnt: %d "),
10396 ent
.vd_ndx
, ent
.vd_cnt
);
10398 /* Check for overflow. */
10399 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10402 vstart
+= ent
.vd_aux
;
10404 if (vstart
+ sizeof (*eaux
) > endbuf
)
10406 eaux
= (Elf_External_Verdaux
*) vstart
;
10408 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10409 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10411 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10412 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10414 printf (_("Name index: %ld\n"), aux
.vda_name
);
10416 isum
= idx
+ ent
.vd_aux
;
10418 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10420 if (aux
.vda_next
< sizeof (*eaux
)
10421 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10423 warn (_("Invalid vda_next field of %lx\n"),
10428 /* Check for overflow. */
10429 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10432 isum
+= aux
.vda_next
;
10433 vstart
+= aux
.vda_next
;
10435 if (vstart
+ sizeof (*eaux
) > endbuf
)
10437 eaux
= (Elf_External_Verdaux
*) vstart
;
10439 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10440 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10442 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10443 printf (_(" %#06lx: Parent %d: %s\n"),
10444 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10446 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10447 isum
, j
, aux
.vda_name
);
10450 if (j
< ent
.vd_cnt
)
10451 printf (_(" Version def aux past end of section\n"));
10454 file: id:000001,src:000172+005151,op:splice,rep:2. */
10455 if (ent
.vd_next
< sizeof (*edef
)
10456 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10458 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10459 cnt
= section
->sh_info
;
10462 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10465 idx
+= ent
.vd_next
;
10468 if (cnt
< section
->sh_info
)
10469 printf (_(" Version definition past end of section\n"));
10475 case SHT_GNU_verneed
:
10477 Elf_External_Verneed
* eneed
;
10484 printf (ngettext ("\nVersion needs section '%s' "
10485 "contains %u entry:\n",
10486 "\nVersion needs section '%s' "
10487 "contains %u entries:\n",
10489 printable_section_name (filedata
, section
), section
->sh_info
);
10491 printf (_(" Addr: 0x"));
10492 printf_vma (section
->sh_addr
);
10493 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10494 (unsigned long) section
->sh_offset
, section
->sh_link
,
10495 printable_section_name_from_index (filedata
, section
->sh_link
));
10497 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10498 section
->sh_offset
, 1,
10500 _("Version Needs section"));
10503 endbuf
= (char *) eneed
+ section
->sh_size
;
10505 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10507 Elf_External_Verneed
* entry
;
10508 Elf_Internal_Verneed ent
;
10509 unsigned long isum
;
10513 vstart
= ((char *) eneed
) + idx
;
10514 if (vstart
+ sizeof (*entry
) > endbuf
)
10517 entry
= (Elf_External_Verneed
*) vstart
;
10519 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10520 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10521 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10522 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10523 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10525 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10527 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10528 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10530 printf (_(" File: %lx"), ent
.vn_file
);
10532 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10534 /* Check for overflow. */
10535 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10537 vstart
+= ent
.vn_aux
;
10539 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10541 Elf_External_Vernaux
* eaux
;
10542 Elf_Internal_Vernaux aux
;
10544 if (vstart
+ sizeof (*eaux
) > endbuf
)
10546 eaux
= (Elf_External_Vernaux
*) vstart
;
10548 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10549 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10550 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10551 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10552 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10554 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10555 printf (_(" %#06lx: Name: %s"),
10556 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10558 printf (_(" %#06lx: Name index: %lx"),
10559 isum
, aux
.vna_name
);
10561 printf (_(" Flags: %s Version: %d\n"),
10562 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10564 if (aux
.vna_next
< sizeof (*eaux
)
10565 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10567 warn (_("Invalid vna_next field of %lx\n"),
10572 /* Check for overflow. */
10573 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10575 isum
+= aux
.vna_next
;
10576 vstart
+= aux
.vna_next
;
10579 if (j
< ent
.vn_cnt
)
10580 warn (_("Missing Version Needs auxillary information\n"));
10582 if (ent
.vn_next
< sizeof (*entry
)
10583 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10585 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10586 cnt
= section
->sh_info
;
10589 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10591 idx
+= ent
.vn_next
;
10594 if (cnt
< section
->sh_info
)
10595 warn (_("Missing Version Needs information\n"));
10601 case SHT_GNU_versym
:
10603 Elf_Internal_Shdr
* link_section
;
10606 unsigned char * edata
;
10607 unsigned short * data
;
10609 Elf_Internal_Sym
* symbols
;
10610 Elf_Internal_Shdr
* string_sec
;
10611 unsigned long num_syms
;
10614 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10617 link_section
= filedata
->section_headers
+ section
->sh_link
;
10618 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10620 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10625 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10626 if (symbols
== NULL
)
10629 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10631 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10632 string_sec
->sh_size
,
10633 _("version string table"));
10640 printf (ngettext ("\nVersion symbols section '%s' "
10641 "contains %lu entry:\n",
10642 "\nVersion symbols section '%s' "
10643 "contains %lu entries:\n",
10645 printable_section_name (filedata
, section
), (unsigned long) total
);
10647 printf (_(" Addr: "));
10648 printf_vma (section
->sh_addr
);
10649 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10650 (unsigned long) section
->sh_offset
, section
->sh_link
,
10651 printable_section_name (filedata
, link_section
));
10653 off
= offset_from_vma (filedata
,
10654 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10655 total
* sizeof (short));
10656 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10658 _("version symbol data"));
10666 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10668 for (cnt
= total
; cnt
--;)
10669 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10674 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10678 char *invalid
= _("*invalid*");
10680 printf (" %03x:", cnt
);
10682 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10683 switch (data
[cnt
+ j
])
10686 fputs (_(" 0 (*local*) "), stdout
);
10690 fputs (_(" 1 (*global*) "), stdout
);
10694 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10695 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10697 /* If this index value is greater than the size of the symbols
10698 array, break to avoid an out-of-bounds read. */
10699 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10701 warn (_("invalid index into symbol array\n"));
10706 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10708 Elf_Internal_Verneed ivn
;
10709 unsigned long offset
;
10711 offset
= offset_from_vma
10712 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10713 sizeof (Elf_External_Verneed
));
10717 Elf_Internal_Vernaux ivna
;
10718 Elf_External_Verneed evn
;
10719 Elf_External_Vernaux evna
;
10720 unsigned long a_off
;
10722 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10723 _("version need")) == NULL
)
10726 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10727 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10729 a_off
= offset
+ ivn
.vn_aux
;
10733 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10734 1, _("version need aux (2)")) == NULL
)
10737 ivna
.vna_other
= 0;
10741 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10742 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10745 a_off
+= ivna
.vna_next
;
10747 while (ivna
.vna_other
!= data
[cnt
+ j
]
10748 && ivna
.vna_next
!= 0);
10750 if (ivna
.vna_other
== data
[cnt
+ j
])
10752 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10754 if (ivna
.vna_name
>= string_sec
->sh_size
)
10757 name
= strtab
+ ivna
.vna_name
;
10761 offset
+= ivn
.vn_next
;
10763 while (ivn
.vn_next
);
10766 if (data
[cnt
+ j
] != 0x8001
10767 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10769 Elf_Internal_Verdef ivd
;
10770 Elf_External_Verdef evd
;
10771 unsigned long offset
;
10773 offset
= offset_from_vma
10774 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10779 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10780 _("version def")) == NULL
)
10783 /* PR 17531: file: 046-1082287-0.004. */
10784 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10789 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10790 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10793 offset
+= ivd
.vd_next
;
10795 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10796 && ivd
.vd_next
!= 0);
10798 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10800 Elf_External_Verdaux evda
;
10801 Elf_Internal_Verdaux ivda
;
10803 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10805 if (get_data (&evda
, filedata
,
10806 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10808 _("version def aux")) == NULL
)
10811 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10813 if (ivda
.vda_name
>= string_sec
->sh_size
)
10815 else if (name
!= NULL
&& name
!= invalid
)
10816 name
= _("*both*");
10818 name
= strtab
+ ivda
.vda_name
;
10822 nn
+= printf ("(%s%-*s",
10824 12 - (int) strlen (name
),
10828 printf ("%*c", 18 - nn
, ' ');
10846 printf (_("\nNo version information found in this file.\n"));
10851 static const char *
10852 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10854 static char buff
[32];
10858 case STB_LOCAL
: return "LOCAL";
10859 case STB_GLOBAL
: return "GLOBAL";
10860 case STB_WEAK
: return "WEAK";
10862 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10863 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10865 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10867 if (binding
== STB_GNU_UNIQUE
10868 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10869 /* GNU is still using the default value 0. */
10870 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10872 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10875 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10880 static const char *
10881 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10883 static char buff
[32];
10887 case STT_NOTYPE
: return "NOTYPE";
10888 case STT_OBJECT
: return "OBJECT";
10889 case STT_FUNC
: return "FUNC";
10890 case STT_SECTION
: return "SECTION";
10891 case STT_FILE
: return "FILE";
10892 case STT_COMMON
: return "COMMON";
10893 case STT_TLS
: return "TLS";
10894 case STT_RELC
: return "RELC";
10895 case STT_SRELC
: return "SRELC";
10897 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10899 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10900 return "THUMB_FUNC";
10902 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10905 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10906 return "PARISC_MILLI";
10908 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10910 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10912 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10914 if (type
== STT_HP_OPAQUE
)
10915 return "HP_OPAQUE";
10916 if (type
== STT_HP_STUB
)
10920 if (type
== STT_GNU_IFUNC
10921 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10922 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10923 /* GNU is still using the default value 0. */
10924 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10927 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10930 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10935 static const char *
10936 get_symbol_visibility (unsigned int visibility
)
10938 switch (visibility
)
10940 case STV_DEFAULT
: return "DEFAULT";
10941 case STV_INTERNAL
: return "INTERNAL";
10942 case STV_HIDDEN
: return "HIDDEN";
10943 case STV_PROTECTED
: return "PROTECTED";
10945 error (_("Unrecognized visibility value: %u"), visibility
);
10946 return _("<unknown>");
10950 static const char *
10951 get_solaris_symbol_visibility (unsigned int visibility
)
10953 switch (visibility
)
10955 case 4: return "EXPORTED";
10956 case 5: return "SINGLETON";
10957 case 6: return "ELIMINATE";
10958 default: return get_symbol_visibility (visibility
);
10962 static const char *
10963 get_mips_symbol_other (unsigned int other
)
10967 case STO_OPTIONAL
: return "OPTIONAL";
10968 case STO_MIPS_PLT
: return "MIPS PLT";
10969 case STO_MIPS_PIC
: return "MIPS PIC";
10970 case STO_MICROMIPS
: return "MICROMIPS";
10971 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10972 case STO_MIPS16
: return "MIPS16";
10973 default: return NULL
;
10977 static const char *
10978 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
10980 if (is_ia64_vms (filedata
))
10982 static char res
[32];
10986 /* Function types is for images and .STB files only. */
10987 switch (filedata
->file_header
.e_type
)
10991 switch (VMS_ST_FUNC_TYPE (other
))
10993 case VMS_SFT_CODE_ADDR
:
10994 strcat (res
, " CA");
10996 case VMS_SFT_SYMV_IDX
:
10997 strcat (res
, " VEC");
11000 strcat (res
, " FD");
11002 case VMS_SFT_RESERVE
:
11003 strcat (res
, " RSV");
11006 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11007 VMS_ST_FUNC_TYPE (other
));
11008 strcat (res
, " <unknown>");
11015 switch (VMS_ST_LINKAGE (other
))
11017 case VMS_STL_IGNORE
:
11018 strcat (res
, " IGN");
11020 case VMS_STL_RESERVE
:
11021 strcat (res
, " RSV");
11024 strcat (res
, " STD");
11027 strcat (res
, " LNK");
11030 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11031 VMS_ST_LINKAGE (other
));
11032 strcat (res
, " <unknown>");
11044 static const char *
11045 get_ppc64_symbol_other (unsigned int other
)
11047 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
11049 static char buf
[32];
11050 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
11051 PPC64_LOCAL_ENTRY_OFFSET (other
));
11057 static const char *
11058 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11060 const char * result
= NULL
;
11061 static char buff
[32];
11066 switch (filedata
->file_header
.e_machine
)
11069 result
= get_mips_symbol_other (other
);
11072 result
= get_ia64_symbol_other (filedata
, other
);
11075 result
= get_ppc64_symbol_other (other
);
11085 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11089 static const char *
11090 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11092 static char buff
[32];
11096 case SHN_UNDEF
: return "UND";
11097 case SHN_ABS
: return "ABS";
11098 case SHN_COMMON
: return "COM";
11100 if (type
== SHN_IA_64_ANSI_COMMON
11101 && filedata
->file_header
.e_machine
== EM_IA_64
11102 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11104 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11105 || filedata
->file_header
.e_machine
== EM_L1OM
11106 || filedata
->file_header
.e_machine
== EM_K1OM
)
11107 && type
== SHN_X86_64_LCOMMON
)
11108 return "LARGE_COM";
11109 else if ((type
== SHN_MIPS_SCOMMON
11110 && filedata
->file_header
.e_machine
== EM_MIPS
)
11111 || (type
== SHN_TIC6X_SCOMMON
11112 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11114 else if (type
== SHN_MIPS_SUNDEFINED
11115 && filedata
->file_header
.e_machine
== EM_MIPS
)
11117 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11118 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11119 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11120 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11121 else if (type
>= SHN_LORESERVE
)
11122 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11123 else if (type
>= filedata
->file_header
.e_shnum
)
11124 sprintf (buff
, _("bad section index[%3d]"), type
);
11126 sprintf (buff
, "%3d", type
);
11134 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11136 unsigned char * e_data
;
11139 /* If the size_t type is smaller than the bfd_size_type, eg because
11140 you are building a 32-bit tool on a 64-bit host, then make sure
11141 that when (number) is cast to (size_t) no information is lost. */
11142 if (sizeof (size_t) < sizeof (bfd_size_type
)
11143 && (bfd_size_type
) ((size_t) number
) != number
)
11145 error (_("Size truncation prevents reading %s elements of size %u\n"),
11146 bfd_vmatoa ("u", number
), ent_size
);
11150 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11151 attempting to allocate memory when the read is bound to fail. */
11152 if (ent_size
* number
> filedata
->file_size
)
11154 error (_("Invalid number of dynamic entries: %s\n"),
11155 bfd_vmatoa ("u", number
));
11159 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11160 if (e_data
== NULL
)
11162 error (_("Out of memory reading %s dynamic entries\n"),
11163 bfd_vmatoa ("u", number
));
11167 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11169 error (_("Unable to read in %s bytes of dynamic data\n"),
11170 bfd_vmatoa ("u", number
* ent_size
));
11175 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11176 if (i_data
== NULL
)
11178 error (_("Out of memory allocating space for %s dynamic entries\n"),
11179 bfd_vmatoa ("u", number
));
11185 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11193 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11195 Elf_Internal_Sym
* psym
;
11198 n
= print_vma (si
, DEC_5
);
11200 fputs (&" "[n
], stdout
);
11201 printf (" %3lu: ", hn
);
11203 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11205 printf (_("<No info available for dynamic symbol number %lu>\n"),
11206 (unsigned long) si
);
11210 psym
= dynamic_symbols
+ si
;
11211 print_vma (psym
->st_value
, LONG_HEX
);
11213 print_vma (psym
->st_size
, DEC_5
);
11215 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11216 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11218 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11219 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11222 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11224 printf (" %-7s", get_symbol_visibility (vis
));
11225 /* Check to see if any other bits in the st_other field are set.
11226 Note - displaying this information disrupts the layout of the
11227 table being generated, but for the moment this case is very
11229 if (psym
->st_other
^ vis
)
11230 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11233 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11234 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11235 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11237 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11241 static const char *
11242 get_symbol_version_string (Filedata
* filedata
,
11243 bfd_boolean is_dynsym
,
11244 const char * strtab
,
11245 unsigned long int strtab_size
,
11247 Elf_Internal_Sym
* psym
,
11248 enum versioned_symbol_info
* sym_info
,
11249 unsigned short * vna_other
)
11251 unsigned char data
[2];
11252 unsigned short vers_data
;
11253 unsigned long offset
;
11256 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11259 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11260 sizeof data
+ si
* sizeof (vers_data
));
11262 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11263 sizeof (data
), 1, _("version data")) == NULL
)
11266 vers_data
= byte_get (data
, 2);
11268 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11271 /* Usually we'd only see verdef for defined symbols, and verneed for
11272 undefined symbols. However, symbols defined by the linker in
11273 .dynbss for variables copied from a shared library in order to
11274 avoid text relocations are defined yet have verneed. We could
11275 use a heuristic to detect the special case, for example, check
11276 for verneed first on symbols defined in SHT_NOBITS sections, but
11277 it is simpler and more reliable to just look for both verdef and
11278 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11280 if (psym
->st_shndx
!= SHN_UNDEF
11281 && vers_data
!= 0x8001
11282 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11284 Elf_Internal_Verdef ivd
;
11285 Elf_Internal_Verdaux ivda
;
11286 Elf_External_Verdaux evda
;
11289 off
= offset_from_vma (filedata
,
11290 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11291 sizeof (Elf_External_Verdef
));
11295 Elf_External_Verdef evd
;
11297 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11298 _("version def")) == NULL
)
11307 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11308 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11309 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11310 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11313 off
+= ivd
.vd_next
;
11315 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11317 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11319 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11322 off
-= ivd
.vd_next
;
11325 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11326 _("version def aux")) != NULL
)
11328 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11330 if (psym
->st_name
!= ivda
.vda_name
)
11332 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11333 ? symbol_hidden
: symbol_public
);
11334 return (ivda
.vda_name
< strtab_size
11335 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11341 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11343 Elf_External_Verneed evn
;
11344 Elf_Internal_Verneed ivn
;
11345 Elf_Internal_Vernaux ivna
;
11347 offset
= offset_from_vma (filedata
,
11348 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11352 unsigned long vna_off
;
11354 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11355 _("version need")) == NULL
)
11358 ivna
.vna_other
= 0;
11363 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11364 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11366 vna_off
= offset
+ ivn
.vn_aux
;
11370 Elf_External_Vernaux evna
;
11372 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11373 _("version need aux (3)")) == NULL
)
11376 ivna
.vna_other
= 0;
11381 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11382 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11383 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11386 vna_off
+= ivna
.vna_next
;
11388 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11390 if (ivna
.vna_other
== vers_data
)
11393 offset
+= ivn
.vn_next
;
11395 while (ivn
.vn_next
!= 0);
11397 if (ivna
.vna_other
== vers_data
)
11399 *sym_info
= symbol_undefined
;
11400 *vna_other
= ivna
.vna_other
;
11401 return (ivna
.vna_name
< strtab_size
11402 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11408 /* Dump the symbol table. */
11410 process_symbol_table (Filedata
* filedata
)
11412 Elf_Internal_Shdr
* section
;
11413 bfd_size_type nbuckets
= 0;
11414 bfd_size_type nchains
= 0;
11415 bfd_vma
* buckets
= NULL
;
11416 bfd_vma
* chains
= NULL
;
11417 bfd_vma ngnubuckets
= 0;
11418 bfd_vma
* gnubuckets
= NULL
;
11419 bfd_vma
* gnuchains
= NULL
;
11420 bfd_vma gnusymidx
= 0;
11421 bfd_size_type ngnuchains
= 0;
11423 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11426 if (dynamic_info
[DT_HASH
]
11428 || (do_using_dynamic
11430 && dynamic_strings
!= NULL
)))
11432 unsigned char nb
[8];
11433 unsigned char nc
[8];
11434 unsigned int hash_ent_size
= 4;
11436 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11437 || filedata
->file_header
.e_machine
== EM_S390
11438 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11439 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11442 if (fseek (filedata
->handle
,
11443 (archive_file_offset
11444 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11445 sizeof nb
+ sizeof nc
)),
11448 error (_("Unable to seek to start of dynamic information\n"));
11452 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11454 error (_("Failed to read in number of buckets\n"));
11458 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11460 error (_("Failed to read in number of chains\n"));
11464 nbuckets
= byte_get (nb
, hash_ent_size
);
11465 nchains
= byte_get (nc
, hash_ent_size
);
11467 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11468 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11471 if (buckets
== NULL
|| chains
== NULL
)
11473 if (do_using_dynamic
)
11484 if (dynamic_info_DT_GNU_HASH
11486 || (do_using_dynamic
11488 && dynamic_strings
!= NULL
)))
11490 unsigned char nb
[16];
11491 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11492 bfd_vma buckets_vma
;
11494 if (fseek (filedata
->handle
,
11495 (archive_file_offset
11496 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11500 error (_("Unable to seek to start of dynamic information\n"));
11504 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11506 error (_("Failed to read in number of buckets\n"));
11510 ngnubuckets
= byte_get (nb
, 4);
11511 gnusymidx
= byte_get (nb
+ 4, 4);
11512 bitmaskwords
= byte_get (nb
+ 8, 4);
11513 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11515 buckets_vma
+= bitmaskwords
* 4;
11517 buckets_vma
+= bitmaskwords
* 8;
11519 if (fseek (filedata
->handle
,
11520 (archive_file_offset
11521 + offset_from_vma (filedata
, buckets_vma
, 4)),
11524 error (_("Unable to seek to start of dynamic information\n"));
11528 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11530 if (gnubuckets
== NULL
)
11533 for (i
= 0; i
< ngnubuckets
; i
++)
11534 if (gnubuckets
[i
] != 0)
11536 if (gnubuckets
[i
] < gnusymidx
)
11539 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11540 maxchain
= gnubuckets
[i
];
11543 if (maxchain
== 0xffffffff)
11546 maxchain
-= gnusymidx
;
11548 if (fseek (filedata
->handle
,
11549 (archive_file_offset
11550 + offset_from_vma (filedata
, buckets_vma
11551 + 4 * (ngnubuckets
+ maxchain
), 4)),
11554 error (_("Unable to seek to start of dynamic information\n"));
11560 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11562 error (_("Failed to determine last chain length\n"));
11566 if (maxchain
+ 1 == 0)
11571 while ((byte_get (nb
, 4) & 1) == 0);
11573 if (fseek (filedata
->handle
,
11574 (archive_file_offset
11575 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11578 error (_("Unable to seek to start of dynamic information\n"));
11582 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11583 ngnuchains
= maxchain
;
11586 if (gnuchains
== NULL
)
11591 if (do_using_dynamic
)
11596 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11598 && do_using_dynamic
11599 && dynamic_strings
!= NULL
11600 && dynamic_symbols
!= NULL
)
11604 if (dynamic_info
[DT_HASH
])
11609 printf (_("\nSymbol table for image:\n"));
11611 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11613 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11615 visited
= xcmalloc (nchains
, 1);
11616 memset (visited
, 0, nchains
);
11617 for (hn
= 0; hn
< nbuckets
; hn
++)
11619 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11621 print_dynamic_symbol (filedata
, si
, hn
);
11622 if (si
>= nchains
|| visited
[si
])
11624 error (_("histogram chain is corrupt\n"));
11633 if (dynamic_info_DT_GNU_HASH
)
11635 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11637 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11639 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11641 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11642 if (gnubuckets
[hn
] != 0)
11644 bfd_vma si
= gnubuckets
[hn
];
11645 bfd_vma off
= si
- gnusymidx
;
11649 print_dynamic_symbol (filedata
, si
, hn
);
11652 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11656 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11657 && filedata
->section_headers
!= NULL
)
11661 for (i
= 0, section
= filedata
->section_headers
;
11662 i
< filedata
->file_header
.e_shnum
;
11666 char * strtab
= NULL
;
11667 unsigned long int strtab_size
= 0;
11668 Elf_Internal_Sym
* symtab
;
11669 Elf_Internal_Sym
* psym
;
11670 unsigned long num_syms
;
11672 if ((section
->sh_type
!= SHT_SYMTAB
11673 && section
->sh_type
!= SHT_DYNSYM
)
11675 && section
->sh_type
== SHT_SYMTAB
))
11678 if (section
->sh_entsize
== 0)
11680 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11681 printable_section_name (filedata
, section
));
11685 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11686 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11687 "\nSymbol table '%s' contains %lu entries:\n",
11689 printable_section_name (filedata
, section
),
11693 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11695 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11697 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11698 if (symtab
== NULL
)
11701 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11703 strtab
= filedata
->string_table
;
11704 strtab_size
= filedata
->string_table_length
;
11706 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11708 Elf_Internal_Shdr
* string_sec
;
11710 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11712 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11713 1, string_sec
->sh_size
,
11714 _("string table"));
11715 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11718 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11720 const char *version_string
;
11721 enum versioned_symbol_info sym_info
;
11722 unsigned short vna_other
;
11724 printf ("%6d: ", si
);
11725 print_vma (psym
->st_value
, LONG_HEX
);
11727 print_vma (psym
->st_size
, DEC_5
);
11728 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11729 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11730 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11731 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11734 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11736 printf (" %-7s", get_symbol_visibility (vis
));
11737 /* Check to see if any other bits in the st_other field are set.
11738 Note - displaying this information disrupts the layout of the
11739 table being generated, but for the moment this case is very rare. */
11740 if (psym
->st_other
^ vis
)
11741 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11743 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11744 print_symbol (25, psym
->st_name
< strtab_size
11745 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11748 = get_symbol_version_string (filedata
,
11749 section
->sh_type
== SHT_DYNSYM
,
11750 strtab
, strtab_size
, si
,
11751 psym
, &sym_info
, &vna_other
);
11752 if (version_string
)
11754 if (sym_info
== symbol_undefined
)
11755 printf ("@%s (%d)", version_string
, vna_other
);
11757 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11763 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11764 && si
>= section
->sh_info
11765 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11766 && filedata
->file_header
.e_machine
!= EM_MIPS
11767 /* Solaris binaries have been found to violate this requirement as
11768 well. Not sure if this is a bug or an ABI requirement. */
11769 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11770 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11771 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11775 if (strtab
!= filedata
->string_table
)
11781 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11783 if (do_histogram
&& buckets
!= NULL
)
11785 unsigned long * lengths
;
11786 unsigned long * counts
;
11789 unsigned long maxlength
= 0;
11790 unsigned long nzero_counts
= 0;
11791 unsigned long nsyms
= 0;
11794 printf (ngettext ("\nHistogram for bucket list length "
11795 "(total of %lu bucket):\n",
11796 "\nHistogram for bucket list length "
11797 "(total of %lu buckets):\n",
11798 (unsigned long) nbuckets
),
11799 (unsigned long) nbuckets
);
11801 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11802 if (lengths
== NULL
)
11804 error (_("Out of memory allocating space for histogram buckets\n"));
11807 visited
= xcmalloc (nchains
, 1);
11808 memset (visited
, 0, nchains
);
11810 printf (_(" Length Number %% of total Coverage\n"));
11811 for (hn
= 0; hn
< nbuckets
; ++hn
)
11813 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11816 if (maxlength
< ++lengths
[hn
])
11818 if (si
>= nchains
|| visited
[si
])
11820 error (_("histogram chain is corrupt\n"));
11828 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11829 if (counts
== NULL
)
11832 error (_("Out of memory allocating space for histogram counts\n"));
11836 for (hn
= 0; hn
< nbuckets
; ++hn
)
11837 ++counts
[lengths
[hn
]];
11842 printf (" 0 %-10lu (%5.1f%%)\n",
11843 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11844 for (i
= 1; i
<= maxlength
; ++i
)
11846 nzero_counts
+= counts
[i
] * i
;
11847 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11848 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11849 (nzero_counts
* 100.0) / nsyms
);
11857 if (buckets
!= NULL
)
11863 if (do_histogram
&& gnubuckets
!= NULL
)
11865 unsigned long * lengths
;
11866 unsigned long * counts
;
11868 unsigned long maxlength
= 0;
11869 unsigned long nzero_counts
= 0;
11870 unsigned long nsyms
= 0;
11872 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11873 "(total of %lu bucket):\n",
11874 "\nHistogram for `.gnu.hash' bucket list length "
11875 "(total of %lu buckets):\n",
11876 (unsigned long) ngnubuckets
),
11877 (unsigned long) ngnubuckets
);
11879 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11880 if (lengths
== NULL
)
11882 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11886 printf (_(" Length Number %% of total Coverage\n"));
11888 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11889 if (gnubuckets
[hn
] != 0)
11891 bfd_vma off
, length
= 1;
11893 for (off
= gnubuckets
[hn
] - gnusymidx
;
11894 /* PR 17531 file: 010-77222-0.004. */
11895 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11898 lengths
[hn
] = length
;
11899 if (length
> maxlength
)
11900 maxlength
= length
;
11904 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11905 if (counts
== NULL
)
11908 error (_("Out of memory allocating space for gnu histogram counts\n"));
11912 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11913 ++counts
[lengths
[hn
]];
11915 if (ngnubuckets
> 0)
11918 printf (" 0 %-10lu (%5.1f%%)\n",
11919 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11920 for (j
= 1; j
<= maxlength
; ++j
)
11922 nzero_counts
+= counts
[j
] * j
;
11923 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11924 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11925 (nzero_counts
* 100.0) / nsyms
);
11939 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
11943 if (dynamic_syminfo
== NULL
11945 /* No syminfo, this is ok. */
11948 /* There better should be a dynamic symbol section. */
11949 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11953 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11954 "contains %d entry:\n",
11955 "\nDynamic info segment at offset 0x%lx "
11956 "contains %d entries:\n",
11957 dynamic_syminfo_nent
),
11958 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11960 printf (_(" Num: Name BoundTo Flags\n"));
11961 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11963 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11965 printf ("%4d: ", i
);
11966 if (i
>= num_dynamic_syms
)
11967 printf (_("<corrupt index>"));
11968 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11969 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11971 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11974 switch (dynamic_syminfo
[i
].si_boundto
)
11976 case SYMINFO_BT_SELF
:
11977 fputs ("SELF ", stdout
);
11979 case SYMINFO_BT_PARENT
:
11980 fputs ("PARENT ", stdout
);
11983 if (dynamic_syminfo
[i
].si_boundto
> 0
11984 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11985 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11987 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11991 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11995 if (flags
& SYMINFO_FLG_DIRECT
)
11996 printf (" DIRECT");
11997 if (flags
& SYMINFO_FLG_PASSTHRU
)
11998 printf (" PASSTHRU");
11999 if (flags
& SYMINFO_FLG_COPY
)
12001 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12002 printf (" LAZYLOAD");
12010 #define IN_RANGE(START,END,ADDR,OFF) \
12011 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12013 /* Check to see if the given reloc needs to be handled in a target specific
12014 manner. If so then process the reloc and return TRUE otherwise return
12017 If called with reloc == NULL, then this is a signal that reloc processing
12018 for the current section has finished, and any saved state should be
12022 target_specific_reloc_handling (Filedata
* filedata
,
12023 Elf_Internal_Rela
* reloc
,
12024 unsigned char * start
,
12025 unsigned char * end
,
12026 Elf_Internal_Sym
* symtab
,
12027 unsigned long num_syms
)
12029 unsigned int reloc_type
= 0;
12030 unsigned long sym_index
= 0;
12034 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12035 sym_index
= get_reloc_symindex (reloc
->r_info
);
12038 switch (filedata
->file_header
.e_machine
)
12041 case EM_MSP430_OLD
:
12043 static Elf_Internal_Sym
* saved_sym
= NULL
;
12051 switch (reloc_type
)
12053 case 10: /* R_MSP430_SYM_DIFF */
12054 if (uses_msp430x_relocs (filedata
))
12056 /* Fall through. */
12057 case 21: /* R_MSP430X_SYM_DIFF */
12059 if (sym_index
>= num_syms
)
12060 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12063 saved_sym
= symtab
+ sym_index
;
12066 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12067 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12068 goto handle_sym_diff
;
12070 case 5: /* R_MSP430_16_BYTE */
12071 case 9: /* R_MSP430_8 */
12072 if (uses_msp430x_relocs (filedata
))
12074 goto handle_sym_diff
;
12076 case 2: /* R_MSP430_ABS16 */
12077 case 15: /* R_MSP430X_ABS16 */
12078 if (! uses_msp430x_relocs (filedata
))
12080 goto handle_sym_diff
;
12083 if (saved_sym
!= NULL
)
12085 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12088 if (sym_index
>= num_syms
)
12089 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12093 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12094 - saved_sym
->st_value
);
12096 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12097 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12100 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12101 (long) reloc
->r_offset
);
12110 if (saved_sym
!= NULL
)
12111 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12118 case EM_CYGNUS_MN10300
:
12120 static Elf_Internal_Sym
* saved_sym
= NULL
;
12128 switch (reloc_type
)
12130 case 34: /* R_MN10300_ALIGN */
12132 case 33: /* R_MN10300_SYM_DIFF */
12133 if (sym_index
>= num_syms
)
12134 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12137 saved_sym
= symtab
+ sym_index
;
12140 case 1: /* R_MN10300_32 */
12141 case 2: /* R_MN10300_16 */
12142 if (saved_sym
!= NULL
)
12144 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12147 if (sym_index
>= num_syms
)
12148 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12152 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12153 - saved_sym
->st_value
);
12155 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12156 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12158 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12159 (long) reloc
->r_offset
);
12167 if (saved_sym
!= NULL
)
12168 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12176 static bfd_vma saved_sym1
= 0;
12177 static bfd_vma saved_sym2
= 0;
12178 static bfd_vma value
;
12182 saved_sym1
= saved_sym2
= 0;
12186 switch (reloc_type
)
12188 case 0x80: /* R_RL78_SYM. */
12189 saved_sym1
= saved_sym2
;
12190 if (sym_index
>= num_syms
)
12191 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12195 saved_sym2
= symtab
[sym_index
].st_value
;
12196 saved_sym2
+= reloc
->r_addend
;
12200 case 0x83: /* R_RL78_OPsub. */
12201 value
= saved_sym1
- saved_sym2
;
12202 saved_sym2
= saved_sym1
= 0;
12206 case 0x41: /* R_RL78_ABS32. */
12207 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12208 byte_put (start
+ reloc
->r_offset
, value
, 4);
12210 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12211 (long) reloc
->r_offset
);
12215 case 0x43: /* R_RL78_ABS16. */
12216 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12217 byte_put (start
+ reloc
->r_offset
, value
, 2);
12219 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12220 (long) reloc
->r_offset
);
12234 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12235 DWARF debug sections. This is a target specific test. Note - we do not
12236 go through the whole including-target-headers-multiple-times route, (as
12237 we have already done with <elf/h8.h>) because this would become very
12238 messy and even then this function would have to contain target specific
12239 information (the names of the relocs instead of their numeric values).
12240 FIXME: This is not the correct way to solve this problem. The proper way
12241 is to have target specific reloc sizing and typing functions created by
12242 the reloc-macros.h header, in the same way that it already creates the
12243 reloc naming functions. */
12246 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12248 /* Please keep this table alpha-sorted for ease of visual lookup. */
12249 switch (filedata
->file_header
.e_machine
)
12253 return reloc_type
== 1; /* R_386_32. */
12255 return reloc_type
== 1; /* R_68K_32. */
12257 return reloc_type
== 1; /* R_860_32. */
12259 return reloc_type
== 2; /* R_960_32. */
12261 return (reloc_type
== 258
12262 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12263 case EM_ADAPTEVA_EPIPHANY
:
12264 return reloc_type
== 3;
12266 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12268 return reloc_type
== 1; /* R_ARC_32. */
12269 case EM_ARC_COMPACT
:
12270 case EM_ARC_COMPACT2
:
12271 return reloc_type
== 4; /* R_ARC_32. */
12273 return reloc_type
== 2; /* R_ARM_ABS32 */
12276 return reloc_type
== 1;
12278 return reloc_type
== 0x12; /* R_byte4_data. */
12280 return reloc_type
== 3; /* R_CRIS_32. */
12282 return reloc_type
== 3; /* R_CR16_NUM32. */
12284 return reloc_type
== 15; /* R_CRX_NUM32. */
12285 case EM_CYGNUS_FRV
:
12286 return reloc_type
== 1;
12287 case EM_CYGNUS_D10V
:
12289 return reloc_type
== 6; /* R_D10V_32. */
12290 case EM_CYGNUS_D30V
:
12292 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12294 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12295 case EM_CYGNUS_FR30
:
12297 return reloc_type
== 3; /* R_FR30_32. */
12299 return reloc_type
== 1; /* R_FT32_32. */
12303 return reloc_type
== 1; /* R_H8_DIR32. */
12305 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12306 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12307 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12308 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12311 return reloc_type
== 2; /* R_IP2K_32. */
12313 return reloc_type
== 2; /* R_IQ2000_32. */
12314 case EM_LATTICEMICO32
:
12315 return reloc_type
== 3; /* R_LM32_32. */
12318 return reloc_type
== 3; /* R_M32C_32. */
12320 return reloc_type
== 34; /* R_M32R_32_RELA. */
12323 return reloc_type
== 6; /* R_M68HC11_32. */
12325 return reloc_type
== 6; /* R_S12Z_EXT32. */
12327 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12328 case EM_CYGNUS_MEP
:
12329 return reloc_type
== 4; /* R_MEP_32. */
12331 return reloc_type
== 2; /* R_METAG_ADDR32. */
12332 case EM_MICROBLAZE
:
12333 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12335 return reloc_type
== 2; /* R_MIPS_32. */
12337 return reloc_type
== 4; /* R_MMIX_32. */
12338 case EM_CYGNUS_MN10200
:
12340 return reloc_type
== 1; /* R_MN10200_32. */
12341 case EM_CYGNUS_MN10300
:
12343 return reloc_type
== 1; /* R_MN10300_32. */
12345 return reloc_type
== 1; /* R_MOXIE_32. */
12346 case EM_MSP430_OLD
:
12348 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12350 return reloc_type
== 2; /* R_MT_32. */
12352 return reloc_type
== 20; /* R_NDS32_RELA. */
12353 case EM_ALTERA_NIOS2
:
12354 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12356 return reloc_type
== 1; /* R_NIOS_32. */
12358 return reloc_type
== 1; /* R_OR1K_32. */
12360 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12361 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12362 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12365 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12367 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12369 return reloc_type
== 1; /* R_PPC_ADDR32. */
12371 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12373 return reloc_type
== 1; /* R_RISCV_32. */
12375 return reloc_type
== 1; /* R_RL78_DIR32. */
12377 return reloc_type
== 1; /* R_RX_DIR32. */
12379 return reloc_type
== 1; /* R_I370_ADDR31. */
12382 return reloc_type
== 4; /* R_S390_32. */
12384 return reloc_type
== 8; /* R_SCORE_ABS32. */
12386 return reloc_type
== 1; /* R_SH_DIR32. */
12387 case EM_SPARC32PLUS
:
12390 return reloc_type
== 3 /* R_SPARC_32. */
12391 || reloc_type
== 23; /* R_SPARC_UA32. */
12393 return reloc_type
== 6; /* R_SPU_ADDR32 */
12395 return reloc_type
== 1; /* R_C6000_ABS32. */
12397 return reloc_type
== 2; /* R_TILEGX_32. */
12399 return reloc_type
== 1; /* R_TILEPRO_32. */
12400 case EM_CYGNUS_V850
:
12402 return reloc_type
== 6; /* R_V850_ABS32. */
12404 return reloc_type
== 0x33; /* R_V810_WORD. */
12406 return reloc_type
== 1; /* R_VAX_32. */
12408 return reloc_type
== 3; /* R_VISIUM_32. */
12409 case EM_WEBASSEMBLY
:
12410 return reloc_type
== 1; /* R_WASM32_32. */
12414 return reloc_type
== 10; /* R_X86_64_32. */
12417 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12419 return reloc_type
== 4; /* R_XGATE_32. */
12421 return reloc_type
== 1; /* R_XSTROMY16_32. */
12422 case EM_XTENSA_OLD
:
12424 return reloc_type
== 1; /* R_XTENSA_32. */
12427 static unsigned int prev_warn
= 0;
12429 /* Avoid repeating the same warning multiple times. */
12430 if (prev_warn
!= filedata
->file_header
.e_machine
)
12431 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12432 filedata
->file_header
.e_machine
);
12433 prev_warn
= filedata
->file_header
.e_machine
;
12439 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12440 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12443 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12445 switch (filedata
->file_header
.e_machine
)
12446 /* Please keep this table alpha-sorted for ease of visual lookup. */
12450 return reloc_type
== 2; /* R_386_PC32. */
12452 return reloc_type
== 4; /* R_68K_PC32. */
12454 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12455 case EM_ADAPTEVA_EPIPHANY
:
12456 return reloc_type
== 6;
12458 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12459 case EM_ARC_COMPACT
:
12460 case EM_ARC_COMPACT2
:
12461 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12463 return reloc_type
== 3; /* R_ARM_REL32 */
12466 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12467 case EM_MICROBLAZE
:
12468 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12470 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12472 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12474 return reloc_type
== 26; /* R_PPC_REL32. */
12476 return reloc_type
== 26; /* R_PPC64_REL32. */
12479 return reloc_type
== 5; /* R_390_PC32. */
12481 return reloc_type
== 2; /* R_SH_REL32. */
12482 case EM_SPARC32PLUS
:
12485 return reloc_type
== 6; /* R_SPARC_DISP32. */
12487 return reloc_type
== 13; /* R_SPU_REL32. */
12489 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12491 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12493 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12497 return reloc_type
== 2; /* R_X86_64_PC32. */
12498 case EM_XTENSA_OLD
:
12500 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12502 /* Do not abort or issue an error message here. Not all targets use
12503 pc-relative 32-bit relocs in their DWARF debug information and we
12504 have already tested for target coverage in is_32bit_abs_reloc. A
12505 more helpful warning message will be generated by apply_relocations
12506 anyway, so just return. */
12511 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12512 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12515 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12517 switch (filedata
->file_header
.e_machine
)
12520 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12522 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12524 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12525 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12527 return reloc_type
== 80; /* R_PARISC_DIR64. */
12529 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12531 return reloc_type
== 2; /* R_RISCV_64. */
12532 case EM_SPARC32PLUS
:
12535 return reloc_type
== 32 /* R_SPARC_64. */
12536 || reloc_type
== 54; /* R_SPARC_UA64. */
12540 return reloc_type
== 1; /* R_X86_64_64. */
12543 return reloc_type
== 22; /* R_S390_64. */
12545 return reloc_type
== 1; /* R_TILEGX_64. */
12547 return reloc_type
== 18; /* R_MIPS_64. */
12553 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12554 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12557 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12559 switch (filedata
->file_header
.e_machine
)
12562 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12564 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12566 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12567 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12569 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12571 return reloc_type
== 44; /* R_PPC64_REL64. */
12572 case EM_SPARC32PLUS
:
12575 return reloc_type
== 46; /* R_SPARC_DISP64. */
12579 return reloc_type
== 24; /* R_X86_64_PC64. */
12582 return reloc_type
== 23; /* R_S390_PC64. */
12584 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12590 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12591 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12594 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12596 switch (filedata
->file_header
.e_machine
)
12598 case EM_CYGNUS_MN10200
:
12600 return reloc_type
== 4; /* R_MN10200_24. */
12602 return reloc_type
== 5; /* R_FT32_20. */
12608 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12609 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12612 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12614 /* Please keep this table alpha-sorted for ease of visual lookup. */
12615 switch (filedata
->file_header
.e_machine
)
12618 case EM_ARC_COMPACT
:
12619 case EM_ARC_COMPACT2
:
12620 return reloc_type
== 2; /* R_ARC_16. */
12621 case EM_ADAPTEVA_EPIPHANY
:
12622 return reloc_type
== 5;
12625 return reloc_type
== 4; /* R_AVR_16. */
12626 case EM_CYGNUS_D10V
:
12628 return reloc_type
== 3; /* R_D10V_16. */
12630 return reloc_type
== 2; /* R_FT32_16. */
12634 return reloc_type
== R_H8_DIR16
;
12637 return reloc_type
== 1; /* R_IP2K_16. */
12640 return reloc_type
== 1; /* R_M32C_16 */
12641 case EM_CYGNUS_MN10200
:
12643 return reloc_type
== 2; /* R_MN10200_16. */
12644 case EM_CYGNUS_MN10300
:
12646 return reloc_type
== 2; /* R_MN10300_16. */
12648 if (uses_msp430x_relocs (filedata
))
12649 return reloc_type
== 2; /* R_MSP430_ABS16. */
12650 /* Fall through. */
12651 case EM_MSP430_OLD
:
12652 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12654 return reloc_type
== 19; /* R_NDS32_RELA. */
12655 case EM_ALTERA_NIOS2
:
12656 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12658 return reloc_type
== 9; /* R_NIOS_16. */
12660 return reloc_type
== 2; /* R_OR1K_16. */
12662 return reloc_type
== 55; /* R_RISCV_SET16. */
12664 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12666 return reloc_type
== 2; /* R_C6000_ABS16. */
12668 return reloc_type
== 2; /* R_VISIUM_16. */
12671 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12673 return reloc_type
== 3; /* R_XGATE_16. */
12679 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12680 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12683 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12685 switch (filedata
->file_header
.e_machine
)
12688 return reloc_type
== 54; /* R_RISCV_SET8. */
12694 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12695 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12698 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12700 switch (filedata
->file_header
.e_machine
)
12703 return reloc_type
== 53; /* R_RISCV_SET6. */
12709 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12710 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12713 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12715 /* Please keep this table alpha-sorted for ease of visual lookup. */
12716 switch (filedata
->file_header
.e_machine
)
12719 return reloc_type
== 35; /* R_RISCV_ADD32. */
12725 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12726 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12729 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12731 /* Please keep this table alpha-sorted for ease of visual lookup. */
12732 switch (filedata
->file_header
.e_machine
)
12735 return reloc_type
== 39; /* R_RISCV_SUB32. */
12741 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12742 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12745 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12747 /* Please keep this table alpha-sorted for ease of visual lookup. */
12748 switch (filedata
->file_header
.e_machine
)
12751 return reloc_type
== 36; /* R_RISCV_ADD64. */
12757 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12758 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12761 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12763 /* Please keep this table alpha-sorted for ease of visual lookup. */
12764 switch (filedata
->file_header
.e_machine
)
12767 return reloc_type
== 40; /* R_RISCV_SUB64. */
12773 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12774 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12777 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12779 /* Please keep this table alpha-sorted for ease of visual lookup. */
12780 switch (filedata
->file_header
.e_machine
)
12783 return reloc_type
== 34; /* R_RISCV_ADD16. */
12789 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12790 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12793 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12795 /* Please keep this table alpha-sorted for ease of visual lookup. */
12796 switch (filedata
->file_header
.e_machine
)
12799 return reloc_type
== 38; /* R_RISCV_SUB16. */
12805 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12806 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12809 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12811 /* Please keep this table alpha-sorted for ease of visual lookup. */
12812 switch (filedata
->file_header
.e_machine
)
12815 return reloc_type
== 33; /* R_RISCV_ADD8. */
12821 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12822 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12825 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12827 /* Please keep this table alpha-sorted for ease of visual lookup. */
12828 switch (filedata
->file_header
.e_machine
)
12831 return reloc_type
== 37; /* R_RISCV_SUB8. */
12837 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12838 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12841 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12843 switch (filedata
->file_header
.e_machine
)
12846 return reloc_type
== 52; /* R_RISCV_SUB6. */
12852 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12853 relocation entries (possibly formerly used for SHT_GROUP sections). */
12856 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12858 switch (filedata
->file_header
.e_machine
)
12860 case EM_386
: /* R_386_NONE. */
12861 case EM_68K
: /* R_68K_NONE. */
12862 case EM_ADAPTEVA_EPIPHANY
:
12863 case EM_ALPHA
: /* R_ALPHA_NONE. */
12864 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12865 case EM_ARC
: /* R_ARC_NONE. */
12866 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12867 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12868 case EM_ARM
: /* R_ARM_NONE. */
12869 case EM_C166
: /* R_XC16X_NONE. */
12870 case EM_CRIS
: /* R_CRIS_NONE. */
12871 case EM_FT32
: /* R_FT32_NONE. */
12872 case EM_IA_64
: /* R_IA64_NONE. */
12873 case EM_K1OM
: /* R_X86_64_NONE. */
12874 case EM_L1OM
: /* R_X86_64_NONE. */
12875 case EM_M32R
: /* R_M32R_NONE. */
12876 case EM_MIPS
: /* R_MIPS_NONE. */
12877 case EM_MN10300
: /* R_MN10300_NONE. */
12878 case EM_MOXIE
: /* R_MOXIE_NONE. */
12879 case EM_NIOS32
: /* R_NIOS_NONE. */
12880 case EM_OR1K
: /* R_OR1K_NONE. */
12881 case EM_PARISC
: /* R_PARISC_NONE. */
12882 case EM_PPC64
: /* R_PPC64_NONE. */
12883 case EM_PPC
: /* R_PPC_NONE. */
12884 case EM_RISCV
: /* R_RISCV_NONE. */
12885 case EM_S390
: /* R_390_NONE. */
12887 case EM_SH
: /* R_SH_NONE. */
12888 case EM_SPARC32PLUS
:
12889 case EM_SPARC
: /* R_SPARC_NONE. */
12891 case EM_TILEGX
: /* R_TILEGX_NONE. */
12892 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12893 case EM_TI_C6000
:/* R_C6000_NONE. */
12894 case EM_X86_64
: /* R_X86_64_NONE. */
12896 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12897 return reloc_type
== 0;
12900 return reloc_type
== 0 || reloc_type
== 256;
12903 return (reloc_type
== 0 /* R_AVR_NONE. */
12904 || reloc_type
== 30 /* R_AVR_DIFF8. */
12905 || reloc_type
== 31 /* R_AVR_DIFF16. */
12906 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12908 return reloc_type
== 3; /* R_METAG_NONE. */
12910 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12911 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12912 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12913 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12914 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12916 return (reloc_type
== 0 /* R_PRU_NONE. */
12917 || reloc_type
== 65 /* R_PRU_DIFF8. */
12918 || reloc_type
== 66 /* R_PRU_DIFF16. */
12919 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12920 case EM_XTENSA_OLD
:
12922 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12923 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12924 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12925 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12930 /* Returns TRUE if there is a relocation against
12931 section NAME at OFFSET bytes. */
12934 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12936 Elf_Internal_Rela
* relocs
;
12937 Elf_Internal_Rela
* rp
;
12939 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12942 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12944 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12945 if (rp
->r_offset
== offset
)
12951 /* Apply relocations to a section.
12952 Returns TRUE upon success, FALSE otherwise.
12953 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12954 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12955 will be set to the number of relocs loaded.
12957 Note: So far support has been added only for those relocations
12958 which can be found in debug sections. FIXME: Add support for
12959 more relocations ? */
12962 apply_relocations (Filedata
* filedata
,
12963 const Elf_Internal_Shdr
* section
,
12964 unsigned char * start
,
12965 bfd_size_type size
,
12966 void ** relocs_return
,
12967 unsigned long * num_relocs_return
)
12969 Elf_Internal_Shdr
* relsec
;
12970 unsigned char * end
= start
+ size
;
12971 bfd_boolean res
= TRUE
;
12973 if (relocs_return
!= NULL
)
12975 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12976 * num_relocs_return
= 0;
12979 if (filedata
->file_header
.e_type
!= ET_REL
)
12980 /* No relocs to apply. */
12983 /* Find the reloc section associated with the section. */
12984 for (relsec
= filedata
->section_headers
;
12985 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
12988 bfd_boolean is_rela
;
12989 unsigned long num_relocs
;
12990 Elf_Internal_Rela
* relocs
;
12991 Elf_Internal_Rela
* rp
;
12992 Elf_Internal_Shdr
* symsec
;
12993 Elf_Internal_Sym
* symtab
;
12994 unsigned long num_syms
;
12995 Elf_Internal_Sym
* sym
;
12997 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12998 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
12999 || filedata
->section_headers
+ relsec
->sh_info
!= section
13000 || relsec
->sh_size
== 0
13001 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13004 is_rela
= relsec
->sh_type
== SHT_RELA
;
13008 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13009 relsec
->sh_size
, & relocs
, & num_relocs
))
13014 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13015 relsec
->sh_size
, & relocs
, & num_relocs
))
13019 /* SH uses RELA but uses in place value instead of the addend field. */
13020 if (filedata
->file_header
.e_machine
== EM_SH
)
13023 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13024 if (symsec
->sh_type
!= SHT_SYMTAB
13025 && symsec
->sh_type
!= SHT_DYNSYM
)
13027 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13029 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13032 unsigned int reloc_type
;
13033 unsigned int reloc_size
;
13034 bfd_boolean reloc_inplace
= FALSE
;
13035 bfd_boolean reloc_subtract
= FALSE
;
13036 unsigned char * rloc
;
13037 unsigned long sym_index
;
13039 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13041 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13043 else if (is_none_reloc (filedata
, reloc_type
))
13045 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13046 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13048 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13049 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13051 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13053 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13055 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13056 || is_6bit_abs_reloc (filedata
, reloc_type
))
13058 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13060 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13063 reloc_inplace
= TRUE
;
13065 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13067 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13070 reloc_inplace
= TRUE
;
13072 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13074 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13077 reloc_inplace
= TRUE
;
13079 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13081 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13084 reloc_inplace
= TRUE
;
13086 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13090 reloc_inplace
= TRUE
;
13094 static unsigned int prev_reloc
= 0;
13096 if (reloc_type
!= prev_reloc
)
13097 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13098 reloc_type
, printable_section_name (filedata
, section
));
13099 prev_reloc
= reloc_type
;
13104 rloc
= start
+ rp
->r_offset
;
13105 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
13107 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13108 (unsigned long) rp
->r_offset
,
13109 printable_section_name (filedata
, section
));
13114 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13115 if (sym_index
>= num_syms
)
13117 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13118 sym_index
, printable_section_name (filedata
, section
));
13122 sym
= symtab
+ sym_index
;
13124 /* If the reloc has a symbol associated with it,
13125 make sure that it is of an appropriate type.
13127 Relocations against symbols without type can happen.
13128 Gcc -feliminate-dwarf2-dups may generate symbols
13129 without type for debug info.
13131 Icc generates relocations against function symbols
13132 instead of local labels.
13134 Relocations against object symbols can happen, eg when
13135 referencing a global array. For an example of this see
13136 the _clz.o binary in libgcc.a. */
13138 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13139 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13141 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13142 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13143 printable_section_name (filedata
, relsec
),
13144 (long int)(rp
- relocs
));
13151 addend
+= rp
->r_addend
;
13152 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13153 partial_inplace. */
13155 || (filedata
->file_header
.e_machine
== EM_XTENSA
13156 && reloc_type
== 1)
13157 || ((filedata
->file_header
.e_machine
== EM_PJ
13158 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13159 && reloc_type
== 1)
13160 || ((filedata
->file_header
.e_machine
== EM_D30V
13161 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13162 && reloc_type
== 12)
13165 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13166 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13168 addend
+= byte_get (rloc
, reloc_size
);
13171 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13172 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13174 /* On HPPA, all pc-relative relocations are biased by 8. */
13175 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13177 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13180 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13181 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13183 if (reloc_subtract
)
13184 addend
-= sym
->st_value
;
13186 addend
+= sym
->st_value
;
13187 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13188 byte_put (rloc
, addend
, reloc_size
);
13190 else if (reloc_subtract
)
13191 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13193 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13197 /* Let the target specific reloc processing code know that
13198 we have finished with these relocs. */
13199 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13203 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13204 * num_relocs_return
= num_relocs
;
13215 #ifdef SUPPORT_DISASSEMBLY
13217 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13219 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13221 /* FIXME: XXX -- to be done --- XXX */
13227 /* Reads in the contents of SECTION from FILE, returning a pointer
13228 to a malloc'ed buffer or NULL if something went wrong. */
13231 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13233 bfd_size_type num_bytes
= section
->sh_size
;
13235 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13237 printf (_("Section '%s' has no data to dump.\n"),
13238 printable_section_name (filedata
, section
));
13242 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13243 _("section contents"));
13246 /* Uncompresses a section that was compressed using zlib, in place. */
13249 uncompress_section_contents (unsigned char ** buffer
,
13250 dwarf_size_type uncompressed_size
,
13251 dwarf_size_type
* size
)
13253 dwarf_size_type compressed_size
= *size
;
13254 unsigned char * compressed_buffer
= *buffer
;
13255 unsigned char * uncompressed_buffer
;
13259 /* It is possible the section consists of several compressed
13260 buffers concatenated together, so we uncompress in a loop. */
13261 /* PR 18313: The state field in the z_stream structure is supposed
13262 to be invisible to the user (ie us), but some compilers will
13263 still complain about it being used without initialisation. So
13264 we first zero the entire z_stream structure and then set the fields
13266 memset (& strm
, 0, sizeof strm
);
13267 strm
.avail_in
= compressed_size
;
13268 strm
.next_in
= (Bytef
*) compressed_buffer
;
13269 strm
.avail_out
= uncompressed_size
;
13270 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13272 rc
= inflateInit (& strm
);
13273 while (strm
.avail_in
> 0)
13277 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13278 + (uncompressed_size
- strm
.avail_out
));
13279 rc
= inflate (&strm
, Z_FINISH
);
13280 if (rc
!= Z_STREAM_END
)
13282 rc
= inflateReset (& strm
);
13284 rc
= inflateEnd (& strm
);
13286 || strm
.avail_out
!= 0)
13289 *buffer
= uncompressed_buffer
;
13290 *size
= uncompressed_size
;
13294 free (uncompressed_buffer
);
13295 /* Indicate decompression failure. */
13301 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13303 Elf_Internal_Shdr
* relsec
;
13304 bfd_size_type num_bytes
;
13305 unsigned char * data
;
13306 unsigned char * end
;
13307 unsigned char * real_start
;
13308 unsigned char * start
;
13309 bfd_boolean some_strings_shown
;
13311 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13313 /* PR 21820: Do not fail if the section was empty. */
13314 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13316 num_bytes
= section
->sh_size
;
13318 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13320 if (decompress_dumps
)
13322 dwarf_size_type new_size
= num_bytes
;
13323 dwarf_size_type uncompressed_size
= 0;
13325 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13327 Elf_Internal_Chdr chdr
;
13328 unsigned int compression_header_size
13329 = get_compression_header (& chdr
, (unsigned char *) start
,
13332 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13334 warn (_("section '%s' has unsupported compress type: %d\n"),
13335 printable_section_name (filedata
, section
), chdr
.ch_type
);
13338 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13340 warn (_("compressed section '%s' is corrupted\n"),
13341 printable_section_name (filedata
, section
));
13344 uncompressed_size
= chdr
.ch_size
;
13345 start
+= compression_header_size
;
13346 new_size
-= compression_header_size
;
13348 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13350 /* Read the zlib header. In this case, it should be "ZLIB"
13351 followed by the uncompressed section size, 8 bytes in
13352 big-endian order. */
13353 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13354 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13355 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13356 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13357 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13358 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13359 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13360 uncompressed_size
+= start
[11];
13365 if (uncompressed_size
)
13367 if (uncompress_section_contents (& start
,
13368 uncompressed_size
, & new_size
))
13369 num_bytes
= new_size
;
13372 error (_("Unable to decompress section %s\n"),
13373 printable_section_name (filedata
, section
));
13378 start
= real_start
;
13381 /* If the section being dumped has relocations against it the user might
13382 be expecting these relocations to have been applied. Check for this
13383 case and issue a warning message in order to avoid confusion.
13384 FIXME: Maybe we ought to have an option that dumps a section with
13385 relocs applied ? */
13386 for (relsec
= filedata
->section_headers
;
13387 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13390 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13391 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13392 || filedata
->section_headers
+ relsec
->sh_info
!= section
13393 || relsec
->sh_size
== 0
13394 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13397 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13402 end
= start
+ num_bytes
;
13403 some_strings_shown
= FALSE
;
13407 while (!ISPRINT (* data
))
13408 if (++ data
>= end
)
13413 size_t maxlen
= end
- data
;
13416 /* PR 11128: Use two separate invocations in order to work
13417 around bugs in the Solaris 8 implementation of printf. */
13418 printf (" [%6tx] ", data
- start
);
13420 printf (" [%6Ix] ", (size_t) (data
- start
));
13424 print_symbol ((int) maxlen
, (const char *) data
);
13426 data
+= strnlen ((const char *) data
, maxlen
);
13430 printf (_("<corrupt>\n"));
13433 some_strings_shown
= TRUE
;
13437 if (! some_strings_shown
)
13438 printf (_(" No strings found in this section."));
13447 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13448 Filedata
* filedata
,
13449 bfd_boolean relocate
)
13451 Elf_Internal_Shdr
* relsec
;
13452 bfd_size_type bytes
;
13453 bfd_size_type section_size
;
13455 unsigned char * data
;
13456 unsigned char * real_start
;
13457 unsigned char * start
;
13459 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13461 /* PR 21820: Do not fail if the section was empty. */
13462 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13464 section_size
= section
->sh_size
;
13466 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13468 if (decompress_dumps
)
13470 dwarf_size_type new_size
= section_size
;
13471 dwarf_size_type uncompressed_size
= 0;
13473 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13475 Elf_Internal_Chdr chdr
;
13476 unsigned int compression_header_size
13477 = get_compression_header (& chdr
, start
, section_size
);
13479 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13481 warn (_("section '%s' has unsupported compress type: %d\n"),
13482 printable_section_name (filedata
, section
), chdr
.ch_type
);
13485 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13487 warn (_("compressed section '%s' is corrupted\n"),
13488 printable_section_name (filedata
, section
));
13491 uncompressed_size
= chdr
.ch_size
;
13492 start
+= compression_header_size
;
13493 new_size
-= compression_header_size
;
13495 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13497 /* Read the zlib header. In this case, it should be "ZLIB"
13498 followed by the uncompressed section size, 8 bytes in
13499 big-endian order. */
13500 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13501 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13502 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13503 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13504 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13505 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13506 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13507 uncompressed_size
+= start
[11];
13512 if (uncompressed_size
)
13514 if (uncompress_section_contents (& start
, uncompressed_size
,
13517 section_size
= new_size
;
13521 error (_("Unable to decompress section %s\n"),
13522 printable_section_name (filedata
, section
));
13523 /* FIXME: Print the section anyway ? */
13528 start
= real_start
;
13533 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13538 /* If the section being dumped has relocations against it the user might
13539 be expecting these relocations to have been applied. Check for this
13540 case and issue a warning message in order to avoid confusion.
13541 FIXME: Maybe we ought to have an option that dumps a section with
13542 relocs applied ? */
13543 for (relsec
= filedata
->section_headers
;
13544 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13547 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13548 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13549 || filedata
->section_headers
+ relsec
->sh_info
!= section
13550 || relsec
->sh_size
== 0
13551 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13554 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13559 addr
= section
->sh_addr
;
13560 bytes
= section_size
;
13569 lbytes
= (bytes
> 16 ? 16 : bytes
);
13571 printf (" 0x%8.8lx ", (unsigned long) addr
);
13573 for (j
= 0; j
< 16; j
++)
13576 printf ("%2.2x", data
[j
]);
13584 for (j
= 0; j
< lbytes
; j
++)
13587 if (k
>= ' ' && k
< 0x7f)
13607 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13608 const Elf_Internal_Shdr
* sec
,
13611 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13613 Filedata
* filedata
= (Filedata
*) data
;
13615 if (section
->start
!= NULL
)
13617 /* If it is already loaded, do nothing. */
13618 if (streq (section
->filename
, filedata
->file_name
))
13620 free (section
->start
);
13623 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13624 section
->address
= sec
->sh_addr
;
13625 section
->user_data
= NULL
;
13626 section
->filename
= filedata
->file_name
;
13627 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13629 sec
->sh_size
, buf
);
13630 if (section
->start
== NULL
)
13634 unsigned char *start
= section
->start
;
13635 dwarf_size_type size
= sec
->sh_size
;
13636 dwarf_size_type uncompressed_size
= 0;
13638 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13640 Elf_Internal_Chdr chdr
;
13641 unsigned int compression_header_size
;
13643 if (size
< (is_32bit_elf
13644 ? sizeof (Elf32_External_Chdr
)
13645 : sizeof (Elf64_External_Chdr
)))
13647 warn (_("compressed section %s is too small to contain a compression header"),
13652 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13654 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13656 warn (_("section '%s' has unsupported compress type: %d\n"),
13657 section
->name
, chdr
.ch_type
);
13660 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13662 warn (_("compressed section '%s' is corrupted\n"),
13666 uncompressed_size
= chdr
.ch_size
;
13667 start
+= compression_header_size
;
13668 size
-= compression_header_size
;
13670 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13672 /* Read the zlib header. In this case, it should be "ZLIB"
13673 followed by the uncompressed section size, 8 bytes in
13674 big-endian order. */
13675 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13676 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13677 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13678 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13679 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13680 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13681 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13682 uncompressed_size
+= start
[11];
13687 if (uncompressed_size
)
13689 if (uncompress_section_contents (&start
, uncompressed_size
,
13692 /* Free the compressed buffer, update the section buffer
13693 and the section size if uncompress is successful. */
13694 free (section
->start
);
13695 section
->start
= start
;
13699 error (_("Unable to decompress section %s\n"),
13700 printable_section_name (filedata
, sec
));
13705 section
->size
= size
;
13708 if (section
->start
== NULL
)
13711 if (debug_displays
[debug
].relocate
)
13713 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13714 & section
->reloc_info
, & section
->num_relocs
))
13719 section
->reloc_info
= NULL
;
13720 section
->num_relocs
= 0;
13726 /* If this is not NULL, load_debug_section will only look for sections
13727 within the list of sections given here. */
13728 static unsigned int * section_subset
= NULL
;
13731 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13733 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13734 Elf_Internal_Shdr
* sec
;
13735 Filedata
* filedata
= (Filedata
*) data
;
13737 /* Without section headers we cannot find any sections. */
13738 if (filedata
->section_headers
== NULL
)
13741 if (filedata
->string_table
== NULL
13742 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13743 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13745 Elf_Internal_Shdr
* strs
;
13747 /* Read in the string table, so that we have section names to scan. */
13748 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13750 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13752 filedata
->string_table
13753 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13754 1, strs
->sh_size
, _("string table"));
13756 filedata
->string_table_length
13757 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13761 /* Locate the debug section. */
13762 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13764 section
->name
= section
->uncompressed_name
;
13767 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13769 section
->name
= section
->compressed_name
;
13774 /* If we're loading from a subset of sections, and we've loaded
13775 a section matching this name before, it's likely that it's a
13777 if (section_subset
!= NULL
)
13778 free_debug_section (debug
);
13780 return load_specific_debug_section (debug
, sec
, data
);
13784 free_debug_section (enum dwarf_section_display_enum debug
)
13786 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13788 if (section
->start
== NULL
)
13791 free ((char *) section
->start
);
13792 section
->start
= NULL
;
13793 section
->address
= 0;
13798 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13800 char * name
= SECTION_NAME (section
);
13801 const char * print_name
= printable_section_name (filedata
, section
);
13802 bfd_size_type length
;
13803 bfd_boolean result
= TRUE
;
13806 length
= section
->sh_size
;
13809 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13812 if (section
->sh_type
== SHT_NOBITS
)
13814 /* There is no point in dumping the contents of a debugging section
13815 which has the NOBITS type - the bits in the file will be random.
13816 This can happen when a file containing a .eh_frame section is
13817 stripped with the --only-keep-debug command line option. */
13818 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13823 if (const_strneq (name
, ".gnu.linkonce.wi."))
13824 name
= ".debug_info";
13826 /* See if we know how to display the contents of this section. */
13827 for (i
= 0; i
< max
; i
++)
13829 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13830 struct dwarf_section_display
* display
= debug_displays
+ i
;
13831 struct dwarf_section
* sec
= & display
->section
;
13833 if (streq (sec
->uncompressed_name
, name
)
13834 || (id
== line
&& const_strneq (name
, ".debug_line."))
13835 || streq (sec
->compressed_name
, name
))
13837 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13840 free_debug_section (id
);
13842 if (i
== line
&& const_strneq (name
, ".debug_line."))
13844 else if (streq (sec
->uncompressed_name
, name
))
13845 sec
->name
= sec
->uncompressed_name
;
13847 sec
->name
= sec
->compressed_name
;
13849 if (load_specific_debug_section (id
, section
, filedata
))
13851 /* If this debug section is part of a CU/TU set in a .dwp file,
13852 restrict load_debug_section to the sections in that set. */
13853 section_subset
= find_cu_tu_set (filedata
, shndx
);
13855 result
&= display
->display (sec
, filedata
);
13857 section_subset
= NULL
;
13859 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13860 free_debug_section (id
);
13868 printf (_("Unrecognized debug section: %s\n"), print_name
);
13875 /* Set DUMP_SECTS for all sections where dumps were requested
13876 based on section name. */
13879 initialise_dumps_byname (Filedata
* filedata
)
13881 struct dump_list_entry
* cur
;
13883 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13886 bfd_boolean any
= FALSE
;
13888 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13889 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13891 request_dump_bynumber (filedata
, i
, cur
->type
);
13896 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13902 process_section_contents (Filedata
* filedata
)
13904 Elf_Internal_Shdr
* section
;
13906 bfd_boolean res
= TRUE
;
13911 initialise_dumps_byname (filedata
);
13913 for (i
= 0, section
= filedata
->section_headers
;
13914 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13917 dump_type dump
= filedata
->dump_sects
[i
];
13919 #ifdef SUPPORT_DISASSEMBLY
13920 if (dump
& DISASS_DUMP
)
13922 if (! disassemble_section (section
, filedata
))
13926 if (dump
& HEX_DUMP
)
13928 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13932 if (dump
& RELOC_DUMP
)
13934 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13938 if (dump
& STRING_DUMP
)
13940 if (! dump_section_as_strings (section
, filedata
))
13944 if (dump
& DEBUG_DUMP
)
13946 if (! display_debug_section (i
, section
, filedata
))
13951 /* Check to see if the user requested a
13952 dump of a section that does not exist. */
13953 while (i
< filedata
->num_dump_sects
)
13955 if (filedata
->dump_sects
[i
])
13957 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13967 process_mips_fpe_exception (int mask
)
13971 bfd_boolean first
= TRUE
;
13973 if (mask
& OEX_FPU_INEX
)
13974 fputs ("INEX", stdout
), first
= FALSE
;
13975 if (mask
& OEX_FPU_UFLO
)
13976 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13977 if (mask
& OEX_FPU_OFLO
)
13978 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13979 if (mask
& OEX_FPU_DIV0
)
13980 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13981 if (mask
& OEX_FPU_INVAL
)
13982 printf ("%sINVAL", first
? "" : "|");
13985 fputs ("0", stdout
);
13988 /* Display's the value of TAG at location P. If TAG is
13989 greater than 0 it is assumed to be an unknown tag, and
13990 a message is printed to this effect. Otherwise it is
13991 assumed that a message has already been printed.
13993 If the bottom bit of TAG is set it assumed to have a
13994 string value, otherwise it is assumed to have an integer
13997 Returns an updated P pointing to the first unread byte
13998 beyond the end of TAG's value.
14000 Reads at or beyond END will not be made. */
14002 static unsigned char *
14003 display_tag_value (signed int tag
,
14005 const unsigned char * const end
)
14010 printf (" Tag_unknown_%d: ", tag
);
14014 warn (_("<corrupt tag>\n"));
14018 /* PR 17531 file: 027-19978-0.004. */
14019 size_t maxlen
= (end
- p
) - 1;
14024 print_symbol ((int) maxlen
, (const char *) p
);
14025 p
+= strnlen ((char *) p
, maxlen
) + 1;
14029 printf (_("<corrupt string tag>"));
14030 p
= (unsigned char *) end
;
14038 val
= read_uleb128 (p
, &len
, end
);
14040 printf ("%ld (0x%lx)\n", val
, val
);
14047 /* ARC ABI attributes section. */
14049 static unsigned char *
14050 display_arc_attribute (unsigned char * p
,
14051 const unsigned char * const end
)
14057 tag
= read_uleb128 (p
, &len
, end
);
14062 case Tag_ARC_PCS_config
:
14063 val
= read_uleb128 (p
, &len
, end
);
14065 printf (" Tag_ARC_PCS_config: ");
14069 printf (_("Absent/Non standard\n"));
14072 printf (_("Bare metal/mwdt\n"));
14075 printf (_("Bare metal/newlib\n"));
14078 printf (_("Linux/uclibc\n"));
14081 printf (_("Linux/glibc\n"));
14084 printf (_("Unknown\n"));
14089 case Tag_ARC_CPU_base
:
14090 val
= read_uleb128 (p
, &len
, end
);
14092 printf (" Tag_ARC_CPU_base: ");
14097 printf (_("Absent\n"));
14099 case TAG_CPU_ARC6xx
:
14100 printf ("ARC6xx\n");
14102 case TAG_CPU_ARC7xx
:
14103 printf ("ARC7xx\n");
14105 case TAG_CPU_ARCEM
:
14106 printf ("ARCEM\n");
14108 case TAG_CPU_ARCHS
:
14109 printf ("ARCHS\n");
14114 case Tag_ARC_CPU_variation
:
14115 val
= read_uleb128 (p
, &len
, end
);
14117 printf (" Tag_ARC_CPU_variation: ");
14121 if (val
> 0 && val
< 16)
14122 printf ("Core%d\n", val
);
14124 printf ("Unknown\n");
14128 printf (_("Absent\n"));
14133 case Tag_ARC_CPU_name
:
14134 printf (" Tag_ARC_CPU_name: ");
14135 p
= display_tag_value (-1, p
, end
);
14138 case Tag_ARC_ABI_rf16
:
14139 val
= read_uleb128 (p
, &len
, end
);
14141 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14144 case Tag_ARC_ABI_osver
:
14145 val
= read_uleb128 (p
, &len
, end
);
14147 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14150 case Tag_ARC_ABI_pic
:
14151 case Tag_ARC_ABI_sda
:
14152 val
= read_uleb128 (p
, &len
, end
);
14154 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14155 : " Tag_ARC_ABI_pic: ");
14159 printf (_("Absent\n"));
14168 printf (_("Unknown\n"));
14173 case Tag_ARC_ABI_tls
:
14174 val
= read_uleb128 (p
, &len
, end
);
14176 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14179 case Tag_ARC_ABI_enumsize
:
14180 val
= read_uleb128 (p
, &len
, end
);
14182 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14186 case Tag_ARC_ABI_exceptions
:
14187 val
= read_uleb128 (p
, &len
, end
);
14189 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14193 case Tag_ARC_ABI_double_size
:
14194 val
= read_uleb128 (p
, &len
, end
);
14196 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14199 case Tag_ARC_ISA_config
:
14200 printf (" Tag_ARC_ISA_config: ");
14201 p
= display_tag_value (-1, p
, end
);
14204 case Tag_ARC_ISA_apex
:
14205 printf (" Tag_ARC_ISA_apex: ");
14206 p
= display_tag_value (-1, p
, end
);
14209 case Tag_ARC_ISA_mpy_option
:
14210 val
= read_uleb128 (p
, &len
, end
);
14212 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14216 return display_tag_value (tag
& 1, p
, end
);
14222 /* ARM EABI attributes section. */
14227 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14229 const char ** table
;
14230 } arm_attr_public_tag
;
14232 static const char * arm_attr_tag_CPU_arch
[] =
14233 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14234 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14236 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14237 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14238 {"No", "Thumb-1", "Thumb-2", "Yes"};
14239 static const char * arm_attr_tag_FP_arch
[] =
14240 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14241 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14242 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14243 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14244 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14245 "NEON for ARMv8.1"};
14246 static const char * arm_attr_tag_PCS_config
[] =
14247 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14248 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14249 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14250 {"V6", "SB", "TLS", "Unused"};
14251 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14252 {"Absolute", "PC-relative", "SB-relative", "None"};
14253 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14254 {"Absolute", "PC-relative", "None"};
14255 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14256 {"None", "direct", "GOT-indirect"};
14257 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14258 {"None", "??? 1", "2", "??? 3", "4"};
14259 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14260 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14261 {"Unused", "Needed", "Sign only"};
14262 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14263 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14264 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14265 {"Unused", "Finite", "RTABI", "IEEE 754"};
14266 static const char * arm_attr_tag_ABI_enum_size
[] =
14267 {"Unused", "small", "int", "forced to int"};
14268 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14269 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14270 static const char * arm_attr_tag_ABI_VFP_args
[] =
14271 {"AAPCS", "VFP registers", "custom", "compatible"};
14272 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14273 {"AAPCS", "WMMX registers", "custom"};
14274 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14275 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14276 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14277 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14278 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14279 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14280 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14281 static const char * arm_attr_tag_FP_HP_extension
[] =
14282 {"Not Allowed", "Allowed"};
14283 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14284 {"None", "IEEE 754", "Alternative Format"};
14285 static const char * arm_attr_tag_DSP_extension
[] =
14286 {"Follow architecture", "Allowed"};
14287 static const char * arm_attr_tag_MPextension_use
[] =
14288 {"Not Allowed", "Allowed"};
14289 static const char * arm_attr_tag_DIV_use
[] =
14290 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14291 "Allowed in v7-A with integer division extension"};
14292 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14293 static const char * arm_attr_tag_Virtualization_use
[] =
14294 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14295 "TrustZone and Virtualization Extensions"};
14296 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14297 {"Not Allowed", "Allowed"};
14299 #define LOOKUP(id, name) \
14300 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14301 static arm_attr_public_tag arm_attr_public_tags
[] =
14303 {4, "CPU_raw_name", 1, NULL
},
14304 {5, "CPU_name", 1, NULL
},
14305 LOOKUP(6, CPU_arch
),
14306 {7, "CPU_arch_profile", 0, NULL
},
14307 LOOKUP(8, ARM_ISA_use
),
14308 LOOKUP(9, THUMB_ISA_use
),
14309 LOOKUP(10, FP_arch
),
14310 LOOKUP(11, WMMX_arch
),
14311 LOOKUP(12, Advanced_SIMD_arch
),
14312 LOOKUP(13, PCS_config
),
14313 LOOKUP(14, ABI_PCS_R9_use
),
14314 LOOKUP(15, ABI_PCS_RW_data
),
14315 LOOKUP(16, ABI_PCS_RO_data
),
14316 LOOKUP(17, ABI_PCS_GOT_use
),
14317 LOOKUP(18, ABI_PCS_wchar_t
),
14318 LOOKUP(19, ABI_FP_rounding
),
14319 LOOKUP(20, ABI_FP_denormal
),
14320 LOOKUP(21, ABI_FP_exceptions
),
14321 LOOKUP(22, ABI_FP_user_exceptions
),
14322 LOOKUP(23, ABI_FP_number_model
),
14323 {24, "ABI_align_needed", 0, NULL
},
14324 {25, "ABI_align_preserved", 0, NULL
},
14325 LOOKUP(26, ABI_enum_size
),
14326 LOOKUP(27, ABI_HardFP_use
),
14327 LOOKUP(28, ABI_VFP_args
),
14328 LOOKUP(29, ABI_WMMX_args
),
14329 LOOKUP(30, ABI_optimization_goals
),
14330 LOOKUP(31, ABI_FP_optimization_goals
),
14331 {32, "compatibility", 0, NULL
},
14332 LOOKUP(34, CPU_unaligned_access
),
14333 LOOKUP(36, FP_HP_extension
),
14334 LOOKUP(38, ABI_FP_16bit_format
),
14335 LOOKUP(42, MPextension_use
),
14336 LOOKUP(44, DIV_use
),
14337 LOOKUP(46, DSP_extension
),
14338 {64, "nodefaults", 0, NULL
},
14339 {65, "also_compatible_with", 0, NULL
},
14340 LOOKUP(66, T2EE_use
),
14341 {67, "conformance", 1, NULL
},
14342 LOOKUP(68, Virtualization_use
),
14343 LOOKUP(70, MPextension_use_legacy
)
14347 static unsigned char *
14348 display_arm_attribute (unsigned char * p
,
14349 const unsigned char * const end
)
14354 arm_attr_public_tag
* attr
;
14358 tag
= read_uleb128 (p
, &len
, end
);
14361 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14363 if (arm_attr_public_tags
[i
].tag
== tag
)
14365 attr
= &arm_attr_public_tags
[i
];
14372 printf (" Tag_%s: ", attr
->name
);
14373 switch (attr
->type
)
14378 case 7: /* Tag_CPU_arch_profile. */
14379 val
= read_uleb128 (p
, &len
, end
);
14383 case 0: printf (_("None\n")); break;
14384 case 'A': printf (_("Application\n")); break;
14385 case 'R': printf (_("Realtime\n")); break;
14386 case 'M': printf (_("Microcontroller\n")); break;
14387 case 'S': printf (_("Application or Realtime\n")); break;
14388 default: printf ("??? (%d)\n", val
); break;
14392 case 24: /* Tag_align_needed. */
14393 val
= read_uleb128 (p
, &len
, end
);
14397 case 0: printf (_("None\n")); break;
14398 case 1: printf (_("8-byte\n")); break;
14399 case 2: printf (_("4-byte\n")); break;
14400 case 3: printf ("??? 3\n"); break;
14403 printf (_("8-byte and up to %d-byte extended\n"),
14406 printf ("??? (%d)\n", val
);
14411 case 25: /* Tag_align_preserved. */
14412 val
= read_uleb128 (p
, &len
, end
);
14416 case 0: printf (_("None\n")); break;
14417 case 1: printf (_("8-byte, except leaf SP\n")); break;
14418 case 2: printf (_("8-byte\n")); break;
14419 case 3: printf ("??? 3\n"); break;
14422 printf (_("8-byte and up to %d-byte extended\n"),
14425 printf ("??? (%d)\n", val
);
14430 case 32: /* Tag_compatibility. */
14432 val
= read_uleb128 (p
, &len
, end
);
14434 printf (_("flag = %d, vendor = "), val
);
14437 size_t maxlen
= (end
- p
) - 1;
14439 print_symbol ((int) maxlen
, (const char *) p
);
14440 p
+= strnlen ((char *) p
, maxlen
) + 1;
14444 printf (_("<corrupt>"));
14445 p
= (unsigned char *) end
;
14451 case 64: /* Tag_nodefaults. */
14452 /* PR 17531: file: 001-505008-0.01. */
14455 printf (_("True\n"));
14458 case 65: /* Tag_also_compatible_with. */
14459 val
= read_uleb128 (p
, &len
, end
);
14461 if (val
== 6 /* Tag_CPU_arch. */)
14463 val
= read_uleb128 (p
, &len
, end
);
14465 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14466 printf ("??? (%d)\n", val
);
14468 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14472 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14477 printf (_("<unknown: %d>\n"), tag
);
14483 return display_tag_value (-1, p
, end
);
14485 return display_tag_value (0, p
, end
);
14488 assert (attr
->type
& 0x80);
14489 val
= read_uleb128 (p
, &len
, end
);
14491 type
= attr
->type
& 0x7f;
14493 printf ("??? (%d)\n", val
);
14495 printf ("%s\n", attr
->table
[val
]);
14500 return display_tag_value (tag
, p
, end
);
14503 static unsigned char *
14504 display_gnu_attribute (unsigned char * p
,
14505 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14506 const unsigned char * const end
)
14512 tag
= read_uleb128 (p
, &len
, end
);
14515 /* Tag_compatibility is the only generic GNU attribute defined at
14519 val
= read_uleb128 (p
, &len
, end
);
14522 printf (_("flag = %d, vendor = "), val
);
14525 printf (_("<corrupt>\n"));
14526 warn (_("corrupt vendor attribute\n"));
14532 size_t maxlen
= (end
- p
) - 1;
14534 print_symbol ((int) maxlen
, (const char *) p
);
14535 p
+= strnlen ((char *) p
, maxlen
) + 1;
14539 printf (_("<corrupt>"));
14540 p
= (unsigned char *) end
;
14547 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14548 return display_proc_gnu_attribute (p
, tag
, end
);
14550 return display_tag_value (tag
, p
, end
);
14553 static unsigned char *
14554 display_power_gnu_attribute (unsigned char * p
,
14556 const unsigned char * const end
)
14561 if (tag
== Tag_GNU_Power_ABI_FP
)
14563 val
= read_uleb128 (p
, &len
, end
);
14565 printf (" Tag_GNU_Power_ABI_FP: ");
14568 printf (_("<corrupt>\n"));
14573 printf ("(%#x), ", val
);
14578 printf (_("unspecified hard/soft float, "));
14581 printf (_("hard float, "));
14584 printf (_("soft float, "));
14587 printf (_("single-precision hard float, "));
14594 printf (_("unspecified long double\n"));
14597 printf (_("128-bit IBM long double\n"));
14600 printf (_("64-bit long double\n"));
14603 printf (_("128-bit IEEE long double\n"));
14609 if (tag
== Tag_GNU_Power_ABI_Vector
)
14611 val
= read_uleb128 (p
, &len
, end
);
14613 printf (" Tag_GNU_Power_ABI_Vector: ");
14616 printf (_("<corrupt>\n"));
14621 printf ("(%#x), ", val
);
14626 printf (_("unspecified\n"));
14629 printf (_("generic\n"));
14632 printf ("AltiVec\n");
14641 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14643 val
= read_uleb128 (p
, &len
, end
);
14645 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14648 printf (_("<corrupt>\n"));
14653 printf ("(%#x), ", val
);
14658 printf (_("unspecified\n"));
14661 printf ("r3/r4\n");
14664 printf (_("memory\n"));
14673 return display_tag_value (tag
& 1, p
, end
);
14676 static unsigned char *
14677 display_s390_gnu_attribute (unsigned char * p
,
14679 const unsigned char * const end
)
14684 if (tag
== Tag_GNU_S390_ABI_Vector
)
14686 val
= read_uleb128 (p
, &len
, end
);
14688 printf (" Tag_GNU_S390_ABI_Vector: ");
14693 printf (_("any\n"));
14696 printf (_("software\n"));
14699 printf (_("hardware\n"));
14702 printf ("??? (%d)\n", val
);
14708 return display_tag_value (tag
& 1, p
, end
);
14712 display_sparc_hwcaps (unsigned int mask
)
14716 bfd_boolean first
= TRUE
;
14718 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14719 fputs ("mul32", stdout
), first
= FALSE
;
14720 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14721 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14722 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14723 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14724 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14725 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14726 if (mask
& ELF_SPARC_HWCAP_POPC
)
14727 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14728 if (mask
& ELF_SPARC_HWCAP_VIS
)
14729 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14730 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14731 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14732 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14733 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14734 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14735 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14736 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14737 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14738 if (mask
& ELF_SPARC_HWCAP_HPC
)
14739 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14740 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14741 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14742 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14743 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14744 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14745 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14746 if (mask
& ELF_SPARC_HWCAP_IMA
)
14747 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14748 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14749 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14752 fputc ('0', stdout
);
14753 fputc ('\n', stdout
);
14757 display_sparc_hwcaps2 (unsigned int mask
)
14761 bfd_boolean first
= TRUE
;
14763 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14764 fputs ("fjathplus", stdout
), first
= FALSE
;
14765 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14766 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14767 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14768 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14769 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14770 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14771 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14772 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14773 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14774 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14775 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14776 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14777 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14778 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14779 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14780 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14781 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14782 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14783 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14784 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14787 fputc ('0', stdout
);
14788 fputc ('\n', stdout
);
14791 static unsigned char *
14792 display_sparc_gnu_attribute (unsigned char * p
,
14794 const unsigned char * const end
)
14799 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14801 val
= read_uleb128 (p
, &len
, end
);
14803 printf (" Tag_GNU_Sparc_HWCAPS: ");
14804 display_sparc_hwcaps (val
);
14807 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14809 val
= read_uleb128 (p
, &len
, end
);
14811 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14812 display_sparc_hwcaps2 (val
);
14816 return display_tag_value (tag
, p
, end
);
14820 print_mips_fp_abi_value (unsigned int val
)
14824 case Val_GNU_MIPS_ABI_FP_ANY
:
14825 printf (_("Hard or soft float\n"));
14827 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14828 printf (_("Hard float (double precision)\n"));
14830 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14831 printf (_("Hard float (single precision)\n"));
14833 case Val_GNU_MIPS_ABI_FP_SOFT
:
14834 printf (_("Soft float\n"));
14836 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14837 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14839 case Val_GNU_MIPS_ABI_FP_XX
:
14840 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14842 case Val_GNU_MIPS_ABI_FP_64
:
14843 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14845 case Val_GNU_MIPS_ABI_FP_64A
:
14846 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14848 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14849 printf (_("NaN 2008 compatibility\n"));
14852 printf ("??? (%d)\n", val
);
14857 static unsigned char *
14858 display_mips_gnu_attribute (unsigned char * p
,
14860 const unsigned char * const end
)
14862 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14867 val
= read_uleb128 (p
, &len
, end
);
14869 printf (" Tag_GNU_MIPS_ABI_FP: ");
14871 print_mips_fp_abi_value (val
);
14876 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14881 val
= read_uleb128 (p
, &len
, end
);
14883 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14887 case Val_GNU_MIPS_ABI_MSA_ANY
:
14888 printf (_("Any MSA or not\n"));
14890 case Val_GNU_MIPS_ABI_MSA_128
:
14891 printf (_("128-bit MSA\n"));
14894 printf ("??? (%d)\n", val
);
14900 return display_tag_value (tag
& 1, p
, end
);
14903 static unsigned char *
14904 display_tic6x_attribute (unsigned char * p
,
14905 const unsigned char * const end
)
14911 tag
= read_uleb128 (p
, &len
, end
);
14917 val
= read_uleb128 (p
, &len
, end
);
14919 printf (" Tag_ISA: ");
14923 case C6XABI_Tag_ISA_none
:
14924 printf (_("None\n"));
14926 case C6XABI_Tag_ISA_C62X
:
14929 case C6XABI_Tag_ISA_C67X
:
14932 case C6XABI_Tag_ISA_C67XP
:
14933 printf ("C67x+\n");
14935 case C6XABI_Tag_ISA_C64X
:
14938 case C6XABI_Tag_ISA_C64XP
:
14939 printf ("C64x+\n");
14941 case C6XABI_Tag_ISA_C674X
:
14942 printf ("C674x\n");
14945 printf ("??? (%d)\n", val
);
14950 case Tag_ABI_wchar_t
:
14951 val
= read_uleb128 (p
, &len
, end
);
14953 printf (" Tag_ABI_wchar_t: ");
14957 printf (_("Not used\n"));
14960 printf (_("2 bytes\n"));
14963 printf (_("4 bytes\n"));
14966 printf ("??? (%d)\n", val
);
14971 case Tag_ABI_stack_align_needed
:
14972 val
= read_uleb128 (p
, &len
, end
);
14974 printf (" Tag_ABI_stack_align_needed: ");
14978 printf (_("8-byte\n"));
14981 printf (_("16-byte\n"));
14984 printf ("??? (%d)\n", val
);
14989 case Tag_ABI_stack_align_preserved
:
14990 val
= read_uleb128 (p
, &len
, end
);
14992 printf (" Tag_ABI_stack_align_preserved: ");
14996 printf (_("8-byte\n"));
14999 printf (_("16-byte\n"));
15002 printf ("??? (%d)\n", val
);
15008 val
= read_uleb128 (p
, &len
, end
);
15010 printf (" Tag_ABI_DSBT: ");
15014 printf (_("DSBT addressing not used\n"));
15017 printf (_("DSBT addressing used\n"));
15020 printf ("??? (%d)\n", val
);
15026 val
= read_uleb128 (p
, &len
, end
);
15028 printf (" Tag_ABI_PID: ");
15032 printf (_("Data addressing position-dependent\n"));
15035 printf (_("Data addressing position-independent, GOT near DP\n"));
15038 printf (_("Data addressing position-independent, GOT far from DP\n"));
15041 printf ("??? (%d)\n", val
);
15047 val
= read_uleb128 (p
, &len
, end
);
15049 printf (" Tag_ABI_PIC: ");
15053 printf (_("Code addressing position-dependent\n"));
15056 printf (_("Code addressing position-independent\n"));
15059 printf ("??? (%d)\n", val
);
15064 case Tag_ABI_array_object_alignment
:
15065 val
= read_uleb128 (p
, &len
, end
);
15067 printf (" Tag_ABI_array_object_alignment: ");
15071 printf (_("8-byte\n"));
15074 printf (_("4-byte\n"));
15077 printf (_("16-byte\n"));
15080 printf ("??? (%d)\n", val
);
15085 case Tag_ABI_array_object_align_expected
:
15086 val
= read_uleb128 (p
, &len
, end
);
15088 printf (" Tag_ABI_array_object_align_expected: ");
15092 printf (_("8-byte\n"));
15095 printf (_("4-byte\n"));
15098 printf (_("16-byte\n"));
15101 printf ("??? (%d)\n", val
);
15106 case Tag_ABI_compatibility
:
15108 val
= read_uleb128 (p
, &len
, end
);
15110 printf (" Tag_ABI_compatibility: ");
15111 printf (_("flag = %d, vendor = "), val
);
15114 size_t maxlen
= (end
- p
) - 1;
15116 print_symbol ((int) maxlen
, (const char *) p
);
15117 p
+= strnlen ((char *) p
, maxlen
) + 1;
15121 printf (_("<corrupt>"));
15122 p
= (unsigned char *) end
;
15128 case Tag_ABI_conformance
:
15130 printf (" Tag_ABI_conformance: \"");
15133 size_t maxlen
= (end
- p
) - 1;
15135 print_symbol ((int) maxlen
, (const char *) p
);
15136 p
+= strnlen ((char *) p
, maxlen
) + 1;
15140 printf (_("<corrupt>"));
15141 p
= (unsigned char *) end
;
15148 return display_tag_value (tag
, p
, end
);
15152 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15154 unsigned long addr
= 0;
15155 size_t bytes
= end
- p
;
15162 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15164 printf (" 0x%8.8lx ", addr
);
15166 for (j
= 0; j
< 16; j
++)
15169 printf ("%2.2x", p
[j
]);
15177 for (j
= 0; j
< lbytes
; j
++)
15180 if (k
>= ' ' && k
< 0x7f)
15196 static unsigned char *
15197 display_msp430x_attribute (unsigned char * p
,
15198 const unsigned char * const end
)
15204 tag
= read_uleb128 (p
, & len
, end
);
15209 case OFBA_MSPABI_Tag_ISA
:
15210 val
= read_uleb128 (p
, &len
, end
);
15212 printf (" Tag_ISA: ");
15215 case 0: printf (_("None\n")); break;
15216 case 1: printf (_("MSP430\n")); break;
15217 case 2: printf (_("MSP430X\n")); break;
15218 default: printf ("??? (%d)\n", val
); break;
15222 case OFBA_MSPABI_Tag_Code_Model
:
15223 val
= read_uleb128 (p
, &len
, end
);
15225 printf (" Tag_Code_Model: ");
15228 case 0: printf (_("None\n")); break;
15229 case 1: printf (_("Small\n")); break;
15230 case 2: printf (_("Large\n")); break;
15231 default: printf ("??? (%d)\n", val
); break;
15235 case OFBA_MSPABI_Tag_Data_Model
:
15236 val
= read_uleb128 (p
, &len
, end
);
15238 printf (" Tag_Data_Model: ");
15241 case 0: printf (_("None\n")); break;
15242 case 1: printf (_("Small\n")); break;
15243 case 2: printf (_("Large\n")); break;
15244 case 3: printf (_("Restricted Large\n")); break;
15245 default: printf ("??? (%d)\n", val
); break;
15250 printf (_(" <unknown tag %d>: "), tag
);
15257 size_t maxlen
= (end
- p
) - 1;
15259 print_symbol ((int) maxlen
, (const char *) p
);
15260 p
+= strnlen ((char *) p
, maxlen
) + 1;
15264 printf (_("<corrupt>"));
15265 p
= (unsigned char *) end
;
15271 val
= read_uleb128 (p
, &len
, end
);
15273 printf ("%d (0x%x)\n", val
, val
);
15283 process_attributes (Filedata
* filedata
,
15284 const char * public_name
,
15285 unsigned int proc_type
,
15286 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15287 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15289 Elf_Internal_Shdr
* sect
;
15291 bfd_boolean res
= TRUE
;
15293 /* Find the section header so that we get the size. */
15294 for (i
= 0, sect
= filedata
->section_headers
;
15295 i
< filedata
->file_header
.e_shnum
;
15298 unsigned char * contents
;
15301 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15304 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15305 sect
->sh_size
, _("attributes"));
15306 if (contents
== NULL
)
15313 /* The first character is the version of the attributes.
15314 Currently only version 1, (aka 'A') is recognised here. */
15317 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15322 bfd_vma section_len
;
15324 section_len
= sect
->sh_size
- 1;
15327 while (section_len
> 0)
15330 unsigned int namelen
;
15331 bfd_boolean public_section
;
15332 bfd_boolean gnu_section
;
15334 if (section_len
<= 4)
15336 error (_("Tag section ends prematurely\n"));
15340 attr_len
= byte_get (p
, 4);
15343 if (attr_len
> section_len
)
15345 error (_("Bad attribute length (%u > %u)\n"),
15346 (unsigned) attr_len
, (unsigned) section_len
);
15347 attr_len
= section_len
;
15350 /* PR 17531: file: 001-101425-0.004 */
15351 else if (attr_len
< 5)
15353 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15358 section_len
-= attr_len
;
15361 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15362 if (namelen
== 0 || namelen
>= attr_len
)
15364 error (_("Corrupt attribute section name\n"));
15369 printf (_("Attribute Section: "));
15370 print_symbol (INT_MAX
, (const char *) p
);
15373 if (public_name
&& streq ((char *) p
, public_name
))
15374 public_section
= TRUE
;
15376 public_section
= FALSE
;
15378 if (streq ((char *) p
, "gnu"))
15379 gnu_section
= TRUE
;
15381 gnu_section
= FALSE
;
15384 attr_len
-= namelen
;
15386 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15391 unsigned char * end
;
15393 /* PR binutils/17531: Safe handling of corrupt files. */
15396 error (_("Unused bytes at end of section\n"));
15403 size
= byte_get (p
, 4);
15404 if (size
> attr_len
)
15406 error (_("Bad subsection length (%u > %u)\n"),
15407 (unsigned) size
, (unsigned) attr_len
);
15411 /* PR binutils/17531: Safe handling of corrupt files. */
15414 error (_("Bad subsection length (%u < 6)\n"),
15422 end
= p
+ size
- 1;
15423 assert (end
<= contents
+ sect
->sh_size
);
15429 printf (_("File Attributes\n"));
15432 printf (_("Section Attributes:"));
15435 printf (_("Symbol Attributes:"));
15436 /* Fall through. */
15442 val
= read_uleb128 (p
, &j
, end
);
15446 printf (" %d", val
);
15451 printf (_("Unknown tag: %d\n"), tag
);
15452 public_section
= FALSE
;
15456 if (public_section
&& display_pub_attribute
!= NULL
)
15459 p
= display_pub_attribute (p
, end
);
15462 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15465 p
= display_gnu_attribute (p
,
15466 display_proc_gnu_attribute
,
15472 printf (_(" Unknown attribute:\n"));
15473 display_raw_attribute (p
, end
);
15488 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15489 Print the Address, Access and Initial fields of an entry at VMA ADDR
15490 and return the VMA of the next entry, or -1 if there was a problem.
15491 Does not read from DATA_END or beyond. */
15494 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15495 unsigned char * data_end
)
15498 print_vma (addr
, LONG_HEX
);
15500 if (addr
< pltgot
+ 0xfff0)
15501 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15503 printf ("%10s", "");
15506 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15510 unsigned char * from
= data
+ addr
- pltgot
;
15512 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15514 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15515 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15516 return (bfd_vma
) -1;
15520 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15521 print_vma (entry
, LONG_HEX
);
15524 return addr
+ (is_32bit_elf
? 4 : 8);
15527 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15528 PLTGOT. Print the Address and Initial fields of an entry at VMA
15529 ADDR and return the VMA of the next entry. */
15532 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15535 print_vma (addr
, LONG_HEX
);
15538 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15543 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15544 print_vma (entry
, LONG_HEX
);
15546 return addr
+ (is_32bit_elf
? 4 : 8);
15550 print_mips_ases (unsigned int mask
)
15552 if (mask
& AFL_ASE_DSP
)
15553 fputs ("\n\tDSP ASE", stdout
);
15554 if (mask
& AFL_ASE_DSPR2
)
15555 fputs ("\n\tDSP R2 ASE", stdout
);
15556 if (mask
& AFL_ASE_DSPR3
)
15557 fputs ("\n\tDSP R3 ASE", stdout
);
15558 if (mask
& AFL_ASE_EVA
)
15559 fputs ("\n\tEnhanced VA Scheme", stdout
);
15560 if (mask
& AFL_ASE_MCU
)
15561 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15562 if (mask
& AFL_ASE_MDMX
)
15563 fputs ("\n\tMDMX ASE", stdout
);
15564 if (mask
& AFL_ASE_MIPS3D
)
15565 fputs ("\n\tMIPS-3D ASE", stdout
);
15566 if (mask
& AFL_ASE_MT
)
15567 fputs ("\n\tMT ASE", stdout
);
15568 if (mask
& AFL_ASE_SMARTMIPS
)
15569 fputs ("\n\tSmartMIPS ASE", stdout
);
15570 if (mask
& AFL_ASE_VIRT
)
15571 fputs ("\n\tVZ ASE", stdout
);
15572 if (mask
& AFL_ASE_MSA
)
15573 fputs ("\n\tMSA ASE", stdout
);
15574 if (mask
& AFL_ASE_MIPS16
)
15575 fputs ("\n\tMIPS16 ASE", stdout
);
15576 if (mask
& AFL_ASE_MICROMIPS
)
15577 fputs ("\n\tMICROMIPS ASE", stdout
);
15578 if (mask
& AFL_ASE_XPA
)
15579 fputs ("\n\tXPA ASE", stdout
);
15580 if (mask
& AFL_ASE_MIPS16E2
)
15581 fputs ("\n\tMIPS16e2 ASE", stdout
);
15582 if (mask
& AFL_ASE_CRC
)
15583 fputs ("\n\tCRC ASE", stdout
);
15584 if (mask
& AFL_ASE_GINV
)
15585 fputs ("\n\tGINV ASE", stdout
);
15586 if (mask
& AFL_ASE_LOONGSON_MMI
)
15587 fputs ("\n\tLoongson MMI ASE", stdout
);
15589 fprintf (stdout
, "\n\t%s", _("None"));
15590 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15591 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15595 print_mips_isa_ext (unsigned int isa_ext
)
15600 fputs (_("None"), stdout
);
15603 fputs ("RMI XLR", stdout
);
15605 case AFL_EXT_OCTEON3
:
15606 fputs ("Cavium Networks Octeon3", stdout
);
15608 case AFL_EXT_OCTEON2
:
15609 fputs ("Cavium Networks Octeon2", stdout
);
15611 case AFL_EXT_OCTEONP
:
15612 fputs ("Cavium Networks OcteonP", stdout
);
15614 case AFL_EXT_LOONGSON_3A
:
15615 fputs ("Loongson 3A", stdout
);
15617 case AFL_EXT_OCTEON
:
15618 fputs ("Cavium Networks Octeon", stdout
);
15621 fputs ("Toshiba R5900", stdout
);
15624 fputs ("MIPS R4650", stdout
);
15627 fputs ("LSI R4010", stdout
);
15630 fputs ("NEC VR4100", stdout
);
15633 fputs ("Toshiba R3900", stdout
);
15635 case AFL_EXT_10000
:
15636 fputs ("MIPS R10000", stdout
);
15639 fputs ("Broadcom SB-1", stdout
);
15642 fputs ("NEC VR4111/VR4181", stdout
);
15645 fputs ("NEC VR4120", stdout
);
15648 fputs ("NEC VR5400", stdout
);
15651 fputs ("NEC VR5500", stdout
);
15653 case AFL_EXT_LOONGSON_2E
:
15654 fputs ("ST Microelectronics Loongson 2E", stdout
);
15656 case AFL_EXT_LOONGSON_2F
:
15657 fputs ("ST Microelectronics Loongson 2F", stdout
);
15659 case AFL_EXT_INTERAPTIV_MR2
:
15660 fputs ("Imagination interAptiv MR2", stdout
);
15663 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15668 get_mips_reg_size (int reg_size
)
15670 return (reg_size
== AFL_REG_NONE
) ? 0
15671 : (reg_size
== AFL_REG_32
) ? 32
15672 : (reg_size
== AFL_REG_64
) ? 64
15673 : (reg_size
== AFL_REG_128
) ? 128
15678 process_mips_specific (Filedata
* filedata
)
15680 Elf_Internal_Dyn
* entry
;
15681 Elf_Internal_Shdr
*sect
= NULL
;
15682 size_t liblist_offset
= 0;
15683 size_t liblistno
= 0;
15684 size_t conflictsno
= 0;
15685 size_t options_offset
= 0;
15686 size_t conflicts_offset
= 0;
15687 size_t pltrelsz
= 0;
15689 bfd_vma pltgot
= 0;
15690 bfd_vma mips_pltgot
= 0;
15691 bfd_vma jmprel
= 0;
15692 bfd_vma local_gotno
= 0;
15693 bfd_vma gotsym
= 0;
15694 bfd_vma symtabno
= 0;
15695 bfd_boolean res
= TRUE
;
15697 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15698 display_mips_gnu_attribute
))
15701 sect
= find_section (filedata
, ".MIPS.abiflags");
15705 Elf_External_ABIFlags_v0
*abiflags_ext
;
15706 Elf_Internal_ABIFlags_v0 abiflags_in
;
15708 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15710 error (_("Corrupt MIPS ABI Flags section.\n"));
15715 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15716 sect
->sh_size
, _("MIPS ABI Flags section"));
15719 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15720 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15721 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15722 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15723 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15724 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15725 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15726 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15727 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15728 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15729 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15731 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15732 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15733 if (abiflags_in
.isa_rev
> 1)
15734 printf ("r%d", abiflags_in
.isa_rev
);
15735 printf ("\nGPR size: %d",
15736 get_mips_reg_size (abiflags_in
.gpr_size
));
15737 printf ("\nCPR1 size: %d",
15738 get_mips_reg_size (abiflags_in
.cpr1_size
));
15739 printf ("\nCPR2 size: %d",
15740 get_mips_reg_size (abiflags_in
.cpr2_size
));
15741 fputs ("\nFP ABI: ", stdout
);
15742 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15743 fputs ("ISA Extension: ", stdout
);
15744 print_mips_isa_ext (abiflags_in
.isa_ext
);
15745 fputs ("\nASEs:", stdout
);
15746 print_mips_ases (abiflags_in
.ases
);
15747 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15748 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15749 fputc ('\n', stdout
);
15750 free (abiflags_ext
);
15755 /* We have a lot of special sections. Thanks SGI! */
15756 if (dynamic_section
== NULL
)
15758 /* No dynamic information available. See if there is static GOT. */
15759 sect
= find_section (filedata
, ".got");
15762 unsigned char *data_end
;
15763 unsigned char *data
;
15767 pltgot
= sect
->sh_addr
;
15770 addr_size
= (is_32bit_elf
? 4 : 8);
15771 end
= pltgot
+ sect
->sh_size
;
15773 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15775 _("Global Offset Table data"));
15776 /* PR 12855: Null data is handled gracefully throughout. */
15777 data_end
= data
+ (end
- pltgot
);
15779 printf (_("\nStatic GOT:\n"));
15780 printf (_(" Canonical gp value: "));
15781 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15784 /* In a dynamic binary GOT[0] is reserved for the dynamic
15785 loader to store the lazy resolver pointer, however in
15786 a static binary it may well have been omitted and GOT
15787 reduced to a table of addresses.
15788 PR 21344: Check for the entry being fully available
15789 before fetching it. */
15791 && data
+ ent
- pltgot
+ addr_size
<= data_end
15792 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15794 printf (_(" Reserved entries:\n"));
15795 printf (_(" %*s %10s %*s\n"),
15796 addr_size
* 2, _("Address"), _("Access"),
15797 addr_size
* 2, _("Value"));
15798 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15800 if (ent
== (bfd_vma
) -1)
15801 goto sgot_print_fail
;
15803 /* Check for the MSB of GOT[1] being set, identifying a
15804 GNU object. This entry will be used by some runtime
15805 loaders, to store the module pointer. Otherwise this
15806 is an ordinary local entry.
15807 PR 21344: Check for the entry being fully available
15808 before fetching it. */
15810 && data
+ ent
- pltgot
+ addr_size
<= data_end
15811 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15812 >> (addr_size
* 8 - 1)) != 0)
15814 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15816 if (ent
== (bfd_vma
) -1)
15817 goto sgot_print_fail
;
15822 if (data
!= NULL
&& ent
< end
)
15824 printf (_(" Local entries:\n"));
15825 printf (" %*s %10s %*s\n",
15826 addr_size
* 2, _("Address"), _("Access"),
15827 addr_size
* 2, _("Value"));
15830 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15832 if (ent
== (bfd_vma
) -1)
15833 goto sgot_print_fail
;
15845 for (entry
= dynamic_section
;
15846 /* PR 17531 file: 012-50589-0.004. */
15847 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15849 switch (entry
->d_tag
)
15851 case DT_MIPS_LIBLIST
:
15853 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15854 liblistno
* sizeof (Elf32_External_Lib
));
15856 case DT_MIPS_LIBLISTNO
:
15857 liblistno
= entry
->d_un
.d_val
;
15859 case DT_MIPS_OPTIONS
:
15860 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15862 case DT_MIPS_CONFLICT
:
15864 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15865 conflictsno
* sizeof (Elf32_External_Conflict
));
15867 case DT_MIPS_CONFLICTNO
:
15868 conflictsno
= entry
->d_un
.d_val
;
15871 pltgot
= entry
->d_un
.d_ptr
;
15873 case DT_MIPS_LOCAL_GOTNO
:
15874 local_gotno
= entry
->d_un
.d_val
;
15876 case DT_MIPS_GOTSYM
:
15877 gotsym
= entry
->d_un
.d_val
;
15879 case DT_MIPS_SYMTABNO
:
15880 symtabno
= entry
->d_un
.d_val
;
15882 case DT_MIPS_PLTGOT
:
15883 mips_pltgot
= entry
->d_un
.d_ptr
;
15886 pltrel
= entry
->d_un
.d_val
;
15889 pltrelsz
= entry
->d_un
.d_val
;
15892 jmprel
= entry
->d_un
.d_ptr
;
15898 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15900 Elf32_External_Lib
* elib
;
15903 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15905 sizeof (Elf32_External_Lib
),
15906 _("liblist section data"));
15909 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15910 "\nSection '.liblist' contains %lu entries:\n",
15911 (unsigned long) liblistno
),
15912 (unsigned long) liblistno
);
15913 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15916 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15923 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15924 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15925 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15926 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15927 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15929 tmp
= gmtime (&atime
);
15930 snprintf (timebuf
, sizeof (timebuf
),
15931 "%04u-%02u-%02uT%02u:%02u:%02u",
15932 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15933 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15935 printf ("%3lu: ", (unsigned long) cnt
);
15936 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15937 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15939 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15940 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15941 liblist
.l_version
);
15943 if (liblist
.l_flags
== 0)
15947 static const struct
15954 { " EXACT_MATCH", LL_EXACT_MATCH
},
15955 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15956 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15957 { " EXPORTS", LL_EXPORTS
},
15958 { " DELAY_LOAD", LL_DELAY_LOAD
},
15959 { " DELTA", LL_DELTA
}
15961 int flags
= liblist
.l_flags
;
15964 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15965 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15967 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15968 flags
^= l_flags_vals
[fcnt
].bit
;
15971 printf (" %#x", (unsigned int) flags
);
15983 if (options_offset
!= 0)
15985 Elf_External_Options
* eopt
;
15986 Elf_Internal_Options
* iopt
;
15987 Elf_Internal_Options
* option
;
15990 sect
= filedata
->section_headers
;
15992 /* Find the section header so that we get the size. */
15993 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
15994 /* PR 17533 file: 012-277276-0.004. */
15997 error (_("No MIPS_OPTIONS header found\n"));
16001 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16002 sect
->sh_size
, _("options"));
16005 iopt
= (Elf_Internal_Options
*)
16006 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16009 error (_("Out of memory allocating space for MIPS options\n"));
16016 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16018 Elf_External_Options
* eoption
;
16020 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16022 option
->kind
= BYTE_GET (eoption
->kind
);
16023 option
->size
= BYTE_GET (eoption
->size
);
16024 option
->section
= BYTE_GET (eoption
->section
);
16025 option
->info
= BYTE_GET (eoption
->info
);
16027 /* PR 17531: file: ffa0fa3b. */
16028 if (option
->size
< sizeof (* eopt
)
16029 || offset
+ option
->size
> sect
->sh_size
)
16031 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16034 offset
+= option
->size
;
16040 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16041 "\nSection '%s' contains %d entries:\n",
16043 printable_section_name (filedata
, sect
), cnt
);
16052 switch (option
->kind
)
16055 /* This shouldn't happen. */
16056 printf (" NULL %d %lx", option
->section
, option
->info
);
16059 printf (" REGINFO ");
16060 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16063 Elf32_External_RegInfo
* ereg
;
16064 Elf32_RegInfo reginfo
;
16066 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16067 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16068 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16069 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16070 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16071 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16072 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16074 printf ("GPR %08lx GP 0x%lx\n",
16075 reginfo
.ri_gprmask
,
16076 (unsigned long) reginfo
.ri_gp_value
);
16077 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16078 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16079 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16084 Elf64_External_RegInfo
* ereg
;
16085 Elf64_Internal_RegInfo reginfo
;
16087 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16088 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16089 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16090 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16091 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16092 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16093 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16095 printf ("GPR %08lx GP 0x",
16096 reginfo
.ri_gprmask
);
16097 printf_vma (reginfo
.ri_gp_value
);
16100 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16101 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16102 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16106 case ODK_EXCEPTIONS
:
16107 fputs (" EXCEPTIONS fpe_min(", stdout
);
16108 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16109 fputs (") fpe_max(", stdout
);
16110 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16111 fputs (")", stdout
);
16113 if (option
->info
& OEX_PAGE0
)
16114 fputs (" PAGE0", stdout
);
16115 if (option
->info
& OEX_SMM
)
16116 fputs (" SMM", stdout
);
16117 if (option
->info
& OEX_FPDBUG
)
16118 fputs (" FPDBUG", stdout
);
16119 if (option
->info
& OEX_DISMISS
)
16120 fputs (" DISMISS", stdout
);
16123 fputs (" PAD ", stdout
);
16124 if (option
->info
& OPAD_PREFIX
)
16125 fputs (" PREFIX", stdout
);
16126 if (option
->info
& OPAD_POSTFIX
)
16127 fputs (" POSTFIX", stdout
);
16128 if (option
->info
& OPAD_SYMBOL
)
16129 fputs (" SYMBOL", stdout
);
16132 fputs (" HWPATCH ", stdout
);
16133 if (option
->info
& OHW_R4KEOP
)
16134 fputs (" R4KEOP", stdout
);
16135 if (option
->info
& OHW_R8KPFETCH
)
16136 fputs (" R8KPFETCH", stdout
);
16137 if (option
->info
& OHW_R5KEOP
)
16138 fputs (" R5KEOP", stdout
);
16139 if (option
->info
& OHW_R5KCVTL
)
16140 fputs (" R5KCVTL", stdout
);
16143 fputs (" FILL ", stdout
);
16144 /* XXX Print content of info word? */
16147 fputs (" TAGS ", stdout
);
16148 /* XXX Print content of info word? */
16151 fputs (" HWAND ", stdout
);
16152 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16153 fputs (" R4KEOP_CHECKED", stdout
);
16154 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16155 fputs (" R4KEOP_CLEAN", stdout
);
16158 fputs (" HWOR ", stdout
);
16159 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16160 fputs (" R4KEOP_CHECKED", stdout
);
16161 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16162 fputs (" R4KEOP_CLEAN", stdout
);
16165 printf (" GP_GROUP %#06lx self-contained %#06lx",
16166 option
->info
& OGP_GROUP
,
16167 (option
->info
& OGP_SELF
) >> 16);
16170 printf (" IDENT %#06lx self-contained %#06lx",
16171 option
->info
& OGP_GROUP
,
16172 (option
->info
& OGP_SELF
) >> 16);
16175 /* This shouldn't happen. */
16176 printf (" %3d ??? %d %lx",
16177 option
->kind
, option
->section
, option
->info
);
16181 len
= sizeof (* eopt
);
16182 while (len
< option
->size
)
16184 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16186 if (ISPRINT (datum
))
16187 printf ("%c", datum
);
16189 printf ("\\%03o", datum
);
16192 fputs ("\n", stdout
);
16194 offset
+= option
->size
;
16204 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16206 Elf32_Conflict
* iconf
;
16209 if (dynamic_symbols
== NULL
)
16211 error (_("conflict list found without a dynamic symbol table\n"));
16215 /* PR 21345 - print a slightly more helpful error message
16216 if we are sure that the cmalloc will fail. */
16217 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16219 error (_("Overlarge number of conflicts detected: %lx\n"),
16220 (long) conflictsno
);
16224 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16227 error (_("Out of memory allocating space for dynamic conflicts\n"));
16233 Elf32_External_Conflict
* econf32
;
16235 econf32
= (Elf32_External_Conflict
*)
16236 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16237 sizeof (* econf32
), _("conflict"));
16241 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16242 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16248 Elf64_External_Conflict
* econf64
;
16250 econf64
= (Elf64_External_Conflict
*)
16251 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16252 sizeof (* econf64
), _("conflict"));
16256 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16257 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16262 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16263 "\nSection '.conflict' contains %lu entries:\n",
16264 (unsigned long) conflictsno
),
16265 (unsigned long) conflictsno
);
16266 puts (_(" Num: Index Value Name"));
16268 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16270 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16272 if (iconf
[cnt
] >= num_dynamic_syms
)
16273 printf (_("<corrupt symbol index>"));
16276 Elf_Internal_Sym
* psym
;
16278 psym
= & dynamic_symbols
[iconf
[cnt
]];
16279 print_vma (psym
->st_value
, FULL_HEX
);
16281 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16282 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16284 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16292 if (pltgot
!= 0 && local_gotno
!= 0)
16294 bfd_vma ent
, local_end
, global_end
;
16296 unsigned char * data
;
16297 unsigned char * data_end
;
16301 addr_size
= (is_32bit_elf
? 4 : 8);
16302 local_end
= pltgot
+ local_gotno
* addr_size
;
16304 /* PR binutils/17533 file: 012-111227-0.004 */
16305 if (symtabno
< gotsym
)
16307 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16308 (unsigned long) gotsym
, (unsigned long) symtabno
);
16312 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16313 /* PR 17531: file: 54c91a34. */
16314 if (global_end
< local_end
)
16316 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16320 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16321 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16322 global_end
- pltgot
, 1,
16323 _("Global Offset Table data"));
16324 /* PR 12855: Null data is handled gracefully throughout. */
16325 data_end
= data
+ (global_end
- pltgot
);
16327 printf (_("\nPrimary GOT:\n"));
16328 printf (_(" Canonical gp value: "));
16329 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16332 printf (_(" Reserved entries:\n"));
16333 printf (_(" %*s %10s %*s Purpose\n"),
16334 addr_size
* 2, _("Address"), _("Access"),
16335 addr_size
* 2, _("Initial"));
16336 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16337 printf (_(" Lazy resolver\n"));
16338 if (ent
== (bfd_vma
) -1)
16339 goto got_print_fail
;
16341 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16342 This entry will be used by some runtime loaders, to store the
16343 module pointer. Otherwise this is an ordinary local entry.
16344 PR 21344: Check for the entry being fully available before
16347 && data
+ ent
- pltgot
+ addr_size
<= data_end
16348 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16349 >> (addr_size
* 8 - 1)) != 0)
16351 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16352 printf (_(" Module pointer (GNU extension)\n"));
16353 if (ent
== (bfd_vma
) -1)
16354 goto got_print_fail
;
16358 if (data
!= NULL
&& ent
< local_end
)
16360 printf (_(" Local entries:\n"));
16361 printf (" %*s %10s %*s\n",
16362 addr_size
* 2, _("Address"), _("Access"),
16363 addr_size
* 2, _("Initial"));
16364 while (ent
< local_end
)
16366 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16368 if (ent
== (bfd_vma
) -1)
16369 goto got_print_fail
;
16374 if (data
!= NULL
&& gotsym
< symtabno
)
16378 printf (_(" Global entries:\n"));
16379 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16380 addr_size
* 2, _("Address"),
16382 addr_size
* 2, _("Initial"),
16383 addr_size
* 2, _("Sym.Val."),
16385 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16386 _("Ndx"), _("Name"));
16388 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16390 for (i
= gotsym
; i
< symtabno
; i
++)
16392 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16395 if (dynamic_symbols
== NULL
)
16396 printf (_("<no dynamic symbols>"));
16397 else if (i
< num_dynamic_syms
)
16399 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16401 print_vma (psym
->st_value
, LONG_HEX
);
16402 printf (" %-7s %3s ",
16403 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16404 get_symbol_index_type (filedata
, psym
->st_shndx
));
16406 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16407 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16409 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16412 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16413 (unsigned long) i
);
16416 if (ent
== (bfd_vma
) -1)
16427 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16430 size_t offset
, rel_offset
;
16431 unsigned long count
, i
;
16432 unsigned char * data
;
16433 int addr_size
, sym_width
;
16434 Elf_Internal_Rela
* rels
;
16436 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16437 if (pltrel
== DT_RELA
)
16439 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16444 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16449 addr_size
= (is_32bit_elf
? 4 : 8);
16450 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16452 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16453 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16454 1, _("Procedure Linkage Table data"));
16458 printf ("\nPLT GOT:\n\n");
16459 printf (_(" Reserved entries:\n"));
16460 printf (_(" %*s %*s Purpose\n"),
16461 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16462 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16463 printf (_(" PLT lazy resolver\n"));
16464 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16465 printf (_(" Module pointer\n"));
16468 printf (_(" Entries:\n"));
16469 printf (" %*s %*s %*s %-7s %3s %s\n",
16470 addr_size
* 2, _("Address"),
16471 addr_size
* 2, _("Initial"),
16472 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16473 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16474 for (i
= 0; i
< count
; i
++)
16476 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16478 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16481 if (idx
>= num_dynamic_syms
)
16482 printf (_("<corrupt symbol index: %lu>"), idx
);
16485 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16487 print_vma (psym
->st_value
, LONG_HEX
);
16488 printf (" %-7s %3s ",
16489 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16490 get_symbol_index_type (filedata
, psym
->st_shndx
));
16491 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16492 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16494 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16509 process_nds32_specific (Filedata
* filedata
)
16511 Elf_Internal_Shdr
*sect
= NULL
;
16513 sect
= find_section (filedata
, ".nds32_e_flags");
16516 unsigned int *flag
;
16518 printf ("\nNDS32 elf flags section:\n");
16519 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16520 sect
->sh_size
, _("NDS32 elf flags section"));
16525 switch ((*flag
) & 0x3)
16528 printf ("(VEC_SIZE):\tNo entry.\n");
16531 printf ("(VEC_SIZE):\t4 bytes\n");
16534 printf ("(VEC_SIZE):\t16 bytes\n");
16537 printf ("(VEC_SIZE):\treserved\n");
16546 process_gnu_liblist (Filedata
* filedata
)
16548 Elf_Internal_Shdr
* section
;
16549 Elf_Internal_Shdr
* string_sec
;
16550 Elf32_External_Lib
* elib
;
16552 size_t strtab_size
;
16554 unsigned long num_liblist
;
16556 bfd_boolean res
= TRUE
;
16561 for (i
= 0, section
= filedata
->section_headers
;
16562 i
< filedata
->file_header
.e_shnum
;
16565 switch (section
->sh_type
)
16567 case SHT_GNU_LIBLIST
:
16568 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16571 elib
= (Elf32_External_Lib
*)
16572 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16573 _("liblist section data"));
16581 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16582 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16583 string_sec
->sh_size
,
16584 _("liblist string table"));
16586 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16593 strtab_size
= string_sec
->sh_size
;
16595 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16596 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16597 "\nLibrary list section '%s' contains %lu entries:\n",
16599 printable_section_name (filedata
, section
),
16602 puts (_(" Library Time Stamp Checksum Version Flags"));
16604 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16612 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16613 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16614 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16615 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16616 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16618 tmp
= gmtime (&atime
);
16619 snprintf (timebuf
, sizeof (timebuf
),
16620 "%04u-%02u-%02uT%02u:%02u:%02u",
16621 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16622 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16624 printf ("%3lu: ", (unsigned long) cnt
);
16626 printf ("%-20s", liblist
.l_name
< strtab_size
16627 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16629 printf ("%-20.20s", liblist
.l_name
< strtab_size
16630 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16631 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16632 liblist
.l_version
, liblist
.l_flags
);
16643 static const char *
16644 get_note_type (Filedata
* filedata
, unsigned e_type
)
16646 static char buff
[64];
16648 if (filedata
->file_header
.e_type
== ET_CORE
)
16652 return _("NT_AUXV (auxiliary vector)");
16654 return _("NT_PRSTATUS (prstatus structure)");
16656 return _("NT_FPREGSET (floating point registers)");
16658 return _("NT_PRPSINFO (prpsinfo structure)");
16659 case NT_TASKSTRUCT
:
16660 return _("NT_TASKSTRUCT (task structure)");
16662 return _("NT_PRXFPREG (user_xfpregs structure)");
16664 return _("NT_PPC_VMX (ppc Altivec registers)");
16666 return _("NT_PPC_VSX (ppc VSX registers)");
16668 return _("NT_PPC_TAR (ppc TAR register)");
16670 return _("NT_PPC_PPR (ppc PPR register)");
16672 return _("NT_PPC_DSCR (ppc DSCR register)");
16674 return _("NT_PPC_EBB (ppc EBB registers)");
16676 return _("NT_PPC_PMU (ppc PMU registers)");
16677 case NT_PPC_TM_CGPR
:
16678 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16679 case NT_PPC_TM_CFPR
:
16680 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16681 case NT_PPC_TM_CVMX
:
16682 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16683 case NT_PPC_TM_CVSX
:
16684 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16685 case NT_PPC_TM_SPR
:
16686 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16687 case NT_PPC_TM_CTAR
:
16688 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16689 case NT_PPC_TM_CPPR
:
16690 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16691 case NT_PPC_TM_CDSCR
:
16692 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16694 return _("NT_386_TLS (x86 TLS information)");
16695 case NT_386_IOPERM
:
16696 return _("NT_386_IOPERM (x86 I/O permissions)");
16697 case NT_X86_XSTATE
:
16698 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16699 case NT_S390_HIGH_GPRS
:
16700 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16701 case NT_S390_TIMER
:
16702 return _("NT_S390_TIMER (s390 timer register)");
16703 case NT_S390_TODCMP
:
16704 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16705 case NT_S390_TODPREG
:
16706 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16708 return _("NT_S390_CTRS (s390 control registers)");
16709 case NT_S390_PREFIX
:
16710 return _("NT_S390_PREFIX (s390 prefix register)");
16711 case NT_S390_LAST_BREAK
:
16712 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16713 case NT_S390_SYSTEM_CALL
:
16714 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16716 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16717 case NT_S390_VXRS_LOW
:
16718 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16719 case NT_S390_VXRS_HIGH
:
16720 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16721 case NT_S390_GS_CB
:
16722 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16723 case NT_S390_GS_BC
:
16724 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16726 return _("NT_ARM_VFP (arm VFP registers)");
16728 return _("NT_ARM_TLS (AArch TLS registers)");
16729 case NT_ARM_HW_BREAK
:
16730 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16731 case NT_ARM_HW_WATCH
:
16732 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16734 return _("NT_PSTATUS (pstatus structure)");
16736 return _("NT_FPREGS (floating point registers)");
16738 return _("NT_PSINFO (psinfo structure)");
16740 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16742 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16743 case NT_WIN32PSTATUS
:
16744 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16746 return _("NT_SIGINFO (siginfo_t data)");
16748 return _("NT_FILE (mapped files)");
16756 return _("NT_VERSION (version)");
16758 return _("NT_ARCH (architecture)");
16759 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16761 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16767 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16772 print_core_note (Elf_Internal_Note
*pnote
)
16774 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16775 bfd_vma count
, page_size
;
16776 unsigned char *descdata
, *filenames
, *descend
;
16778 if (pnote
->type
!= NT_FILE
)
16788 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16789 /* Still "successful". */
16794 if (pnote
->descsz
< 2 * addr_size
)
16796 error (_(" Malformed note - too short for header\n"));
16800 descdata
= (unsigned char *) pnote
->descdata
;
16801 descend
= descdata
+ pnote
->descsz
;
16803 if (descdata
[pnote
->descsz
- 1] != '\0')
16805 error (_(" Malformed note - does not end with \\0\n"));
16809 count
= byte_get (descdata
, addr_size
);
16810 descdata
+= addr_size
;
16812 page_size
= byte_get (descdata
, addr_size
);
16813 descdata
+= addr_size
;
16815 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16816 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16818 error (_(" Malformed note - too short for supplied file count\n"));
16822 printf (_(" Page size: "));
16823 print_vma (page_size
, DEC
);
16826 printf (_(" %*s%*s%*s\n"),
16827 (int) (2 + 2 * addr_size
), _("Start"),
16828 (int) (4 + 2 * addr_size
), _("End"),
16829 (int) (4 + 2 * addr_size
), _("Page Offset"));
16830 filenames
= descdata
+ count
* 3 * addr_size
;
16831 while (count
-- > 0)
16833 bfd_vma start
, end
, file_ofs
;
16835 if (filenames
== descend
)
16837 error (_(" Malformed note - filenames end too early\n"));
16841 start
= byte_get (descdata
, addr_size
);
16842 descdata
+= addr_size
;
16843 end
= byte_get (descdata
, addr_size
);
16844 descdata
+= addr_size
;
16845 file_ofs
= byte_get (descdata
, addr_size
);
16846 descdata
+= addr_size
;
16849 print_vma (start
, FULL_HEX
);
16851 print_vma (end
, FULL_HEX
);
16853 print_vma (file_ofs
, FULL_HEX
);
16854 printf ("\n %s\n", filenames
);
16856 filenames
+= 1 + strlen ((char *) filenames
);
16862 static const char *
16863 get_gnu_elf_note_type (unsigned e_type
)
16865 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16868 case NT_GNU_ABI_TAG
:
16869 return _("NT_GNU_ABI_TAG (ABI version tag)");
16871 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16872 case NT_GNU_BUILD_ID
:
16873 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16874 case NT_GNU_GOLD_VERSION
:
16875 return _("NT_GNU_GOLD_VERSION (gold version)");
16876 case NT_GNU_PROPERTY_TYPE_0
:
16877 return _("NT_GNU_PROPERTY_TYPE_0");
16878 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16879 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16880 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16881 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16884 static char buff
[64];
16886 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16893 decode_x86_isa (unsigned int bitmask
)
16897 unsigned int bit
= bitmask
& (- bitmask
);
16902 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16903 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16904 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16905 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16906 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16907 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16908 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16909 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16910 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16911 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16912 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16913 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16914 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16915 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16916 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16917 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16918 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16919 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16920 default: printf (_("<unknown: %x>"), bit
); break;
16928 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16932 unsigned int bit
= bitmask
& (- bitmask
);
16937 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16940 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16944 /* This should never happen. */
16948 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16951 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16955 /* This should never happen. */
16960 printf (_("<unknown: %x>"), bit
);
16969 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
16971 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16972 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16973 unsigned int size
= is_32bit_elf
? 4 : 8;
16975 printf (_(" Properties: "));
16977 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16979 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16983 while (ptr
< ptr_end
)
16987 unsigned int datasz
;
16989 if ((size_t) (ptr_end
- ptr
) < 8)
16991 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16995 type
= byte_get (ptr
, 4);
16996 datasz
= byte_get (ptr
+ 4, 4);
17000 if (datasz
> (size_t) (ptr_end
- ptr
))
17002 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17007 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17009 if (filedata
->file_header
.e_machine
== EM_X86_64
17010 || filedata
->file_header
.e_machine
== EM_IAMCU
17011 || filedata
->file_header
.e_machine
== EM_386
)
17015 case GNU_PROPERTY_X86_ISA_1_USED
:
17016 printf ("x86 ISA used: ");
17018 printf (_("<corrupt length: %#x> "), datasz
);
17020 decode_x86_isa (byte_get (ptr
, 4));
17023 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17024 printf ("x86 ISA needed: ");
17026 printf (_("<corrupt length: %#x> "), datasz
);
17028 decode_x86_isa (byte_get (ptr
, 4));
17031 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17032 printf ("x86 feature: ");
17034 printf (_("<corrupt length: %#x> "), datasz
);
17036 decode_x86_feature (type
, byte_get (ptr
, 4));
17048 case GNU_PROPERTY_STACK_SIZE
:
17049 printf (_("stack size: "));
17050 if (datasz
!= size
)
17051 printf (_("<corrupt length: %#x> "), datasz
);
17053 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17056 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17057 printf ("no copy on protected ");
17059 printf (_("<corrupt length: %#x> "), datasz
);
17067 if (type
< GNU_PROPERTY_LOPROC
)
17068 printf (_("<unknown type %#x data: "), type
);
17069 else if (type
< GNU_PROPERTY_LOUSER
)
17070 printf (_("<procesor-specific type %#x data: "), type
);
17072 printf (_("<application-specific type %#x data: "), type
);
17073 for (j
= 0; j
< datasz
; ++j
)
17074 printf ("%02x ", ptr
[j
] & 0xff);
17078 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17079 if (ptr
== ptr_end
)
17092 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17094 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17095 switch (pnote
->type
)
17097 case NT_GNU_BUILD_ID
:
17101 printf (_(" Build ID: "));
17102 for (i
= 0; i
< pnote
->descsz
; ++i
)
17103 printf ("%02x", pnote
->descdata
[i
] & 0xff);
17108 case NT_GNU_ABI_TAG
:
17110 unsigned long os
, major
, minor
, subminor
;
17111 const char *osname
;
17113 /* PR 17531: file: 030-599401-0.004. */
17114 if (pnote
->descsz
< 16)
17116 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17120 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17121 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17122 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
17123 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
17127 case GNU_ABI_TAG_LINUX
:
17130 case GNU_ABI_TAG_HURD
:
17133 case GNU_ABI_TAG_SOLARIS
:
17134 osname
= "Solaris";
17136 case GNU_ABI_TAG_FREEBSD
:
17137 osname
= "FreeBSD";
17139 case GNU_ABI_TAG_NETBSD
:
17142 case GNU_ABI_TAG_SYLLABLE
:
17143 osname
= "Syllable";
17145 case GNU_ABI_TAG_NACL
:
17149 osname
= "Unknown";
17153 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17154 major
, minor
, subminor
);
17158 case NT_GNU_GOLD_VERSION
:
17162 printf (_(" Version: "));
17163 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17164 printf ("%c", pnote
->descdata
[i
]);
17171 unsigned long num_entries
, mask
;
17173 /* Hardware capabilities information. Word 0 is the number of entries.
17174 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17175 is a series of entries, where each entry is a single byte followed
17176 by a nul terminated string. The byte gives the bit number to test
17177 if enabled in the bitmask. */
17178 printf (_(" Hardware Capabilities: "));
17179 if (pnote
->descsz
< 8)
17181 error (_("<corrupt GNU_HWCAP>\n"));
17184 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17185 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17186 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17187 /* FIXME: Add code to display the entries... */
17191 case NT_GNU_PROPERTY_TYPE_0
:
17192 print_gnu_property_note (filedata
, pnote
);
17196 /* Handle unrecognised types. An error message should have already been
17197 created by get_gnu_elf_note_type(), so all that we need to do is to
17198 display the data. */
17202 printf (_(" Description data: "));
17203 for (i
= 0; i
< pnote
->descsz
; ++i
)
17204 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17213 static const char *
17214 get_v850_elf_note_type (enum v850_notes n_type
)
17216 static char buff
[64];
17220 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17221 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17222 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17223 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17224 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17225 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17227 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17233 print_v850_note (Elf_Internal_Note
* pnote
)
17237 if (pnote
->descsz
!= 4)
17240 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17244 printf (_("not set\n"));
17248 switch (pnote
->type
)
17250 case V850_NOTE_ALIGNMENT
:
17253 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17254 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17258 case V850_NOTE_DATA_SIZE
:
17261 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17262 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17266 case V850_NOTE_FPU_INFO
:
17269 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17270 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17274 case V850_NOTE_MMU_INFO
:
17275 case V850_NOTE_CACHE_INFO
:
17276 case V850_NOTE_SIMD_INFO
:
17277 if (val
== EF_RH850_SIMD
)
17279 printf (_("yes\n"));
17285 /* An 'unknown note type' message will already have been displayed. */
17289 printf (_("unknown value: %x\n"), val
);
17294 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17296 unsigned int version
;
17298 switch (pnote
->type
)
17300 case NT_NETBSD_IDENT
:
17301 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17302 if ((version
/ 10000) % 100)
17303 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17304 version
, version
/ 100000000, (version
/ 1000000) % 100,
17305 (version
/ 10000) % 100 > 26 ? "Z" : "",
17306 'A' + (version
/ 10000) % 26);
17308 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17309 version
, version
/ 100000000, (version
/ 1000000) % 100,
17310 (version
/ 100) % 100);
17313 case NT_NETBSD_MARCH
:
17314 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17319 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17325 static const char *
17326 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17330 case NT_FREEBSD_THRMISC
:
17331 return _("NT_THRMISC (thrmisc structure)");
17332 case NT_FREEBSD_PROCSTAT_PROC
:
17333 return _("NT_PROCSTAT_PROC (proc data)");
17334 case NT_FREEBSD_PROCSTAT_FILES
:
17335 return _("NT_PROCSTAT_FILES (files data)");
17336 case NT_FREEBSD_PROCSTAT_VMMAP
:
17337 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17338 case NT_FREEBSD_PROCSTAT_GROUPS
:
17339 return _("NT_PROCSTAT_GROUPS (groups data)");
17340 case NT_FREEBSD_PROCSTAT_UMASK
:
17341 return _("NT_PROCSTAT_UMASK (umask data)");
17342 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17343 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17344 case NT_FREEBSD_PROCSTAT_OSREL
:
17345 return _("NT_PROCSTAT_OSREL (osreldate data)");
17346 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17347 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17348 case NT_FREEBSD_PROCSTAT_AUXV
:
17349 return _("NT_PROCSTAT_AUXV (auxv data)");
17350 case NT_FREEBSD_PTLWPINFO
:
17351 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17353 return get_note_type (filedata
, e_type
);
17356 static const char *
17357 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17359 static char buff
[64];
17361 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17362 return _("NetBSD procinfo structure");
17364 /* As of Jan 2002 there are no other machine-independent notes
17365 defined for NetBSD core files. If the note type is less
17366 than the start of the machine-dependent note types, we don't
17369 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17371 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17375 switch (filedata
->file_header
.e_machine
)
17377 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17378 and PT_GETFPREGS == mach+2. */
17383 case EM_SPARC32PLUS
:
17387 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17388 return _("PT_GETREGS (reg structure)");
17389 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17390 return _("PT_GETFPREGS (fpreg structure)");
17396 /* On all other arch's, PT_GETREGS == mach+1 and
17397 PT_GETFPREGS == mach+3. */
17401 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17402 return _("PT_GETREGS (reg structure)");
17403 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17404 return _("PT_GETFPREGS (fpreg structure)");
17410 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17411 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17415 static const char *
17416 get_stapsdt_note_type (unsigned e_type
)
17418 static char buff
[64];
17423 return _("NT_STAPSDT (SystemTap probe descriptors)");
17429 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17434 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17436 int addr_size
= is_32bit_elf
? 4 : 8;
17437 char *data
= pnote
->descdata
;
17438 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17439 bfd_vma pc
, base_addr
, semaphore
;
17440 char *provider
, *probe
, *arg_fmt
;
17442 pc
= byte_get ((unsigned char *) data
, addr_size
);
17444 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17446 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17450 data
+= strlen (data
) + 1;
17452 data
+= strlen (data
) + 1;
17454 data
+= strlen (data
) + 1;
17456 printf (_(" Provider: %s\n"), provider
);
17457 printf (_(" Name: %s\n"), probe
);
17458 printf (_(" Location: "));
17459 print_vma (pc
, FULL_HEX
);
17460 printf (_(", Base: "));
17461 print_vma (base_addr
, FULL_HEX
);
17462 printf (_(", Semaphore: "));
17463 print_vma (semaphore
, FULL_HEX
);
17465 printf (_(" Arguments: %s\n"), arg_fmt
);
17467 return data
== data_end
;
17470 static const char *
17471 get_ia64_vms_note_type (unsigned e_type
)
17473 static char buff
[64];
17478 return _("NT_VMS_MHD (module header)");
17480 return _("NT_VMS_LNM (language name)");
17482 return _("NT_VMS_SRC (source files)");
17484 return "NT_VMS_TITLE";
17486 return _("NT_VMS_EIDC (consistency check)");
17487 case NT_VMS_FPMODE
:
17488 return _("NT_VMS_FPMODE (FP mode)");
17489 case NT_VMS_LINKTIME
:
17490 return "NT_VMS_LINKTIME";
17491 case NT_VMS_IMGNAM
:
17492 return _("NT_VMS_IMGNAM (image name)");
17494 return _("NT_VMS_IMGID (image id)");
17495 case NT_VMS_LINKID
:
17496 return _("NT_VMS_LINKID (link id)");
17497 case NT_VMS_IMGBID
:
17498 return _("NT_VMS_IMGBID (build id)");
17499 case NT_VMS_GSTNAM
:
17500 return _("NT_VMS_GSTNAM (sym table name)");
17501 case NT_VMS_ORIG_DYN
:
17502 return "NT_VMS_ORIG_DYN";
17503 case NT_VMS_PATCHTIME
:
17504 return "NT_VMS_PATCHTIME";
17506 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17512 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17514 switch (pnote
->type
)
17517 if (pnote
->descsz
> 36)
17519 size_t l
= strlen (pnote
->descdata
+ 34);
17520 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17521 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17522 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17523 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17526 printf (_(" Invalid size\n"));
17529 printf (_(" Language: %s\n"), pnote
->descdata
);
17532 case NT_VMS_FPMODE
:
17533 printf (_(" Floating Point mode: "));
17534 printf ("0x%016" BFD_VMA_FMT
"x\n",
17535 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17537 case NT_VMS_LINKTIME
:
17538 printf (_(" Link time: "));
17540 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17543 case NT_VMS_PATCHTIME
:
17544 printf (_(" Patch time: "));
17546 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17549 case NT_VMS_ORIG_DYN
:
17550 printf (_(" Major id: %u, minor id: %u\n"),
17551 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17552 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17553 printf (_(" Last modified : "));
17555 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17556 printf (_("\n Link flags : "));
17557 printf ("0x%016" BFD_VMA_FMT
"x\n",
17558 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17559 printf (_(" Header flags: 0x%08x\n"),
17560 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17561 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17564 case NT_VMS_IMGNAM
:
17565 printf (_(" Image name: %s\n"), pnote
->descdata
);
17567 case NT_VMS_GSTNAM
:
17568 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17571 printf (_(" Image id: %s\n"), pnote
->descdata
);
17573 case NT_VMS_LINKID
:
17574 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17582 /* Find the symbol associated with a build attribute that is attached
17583 to address OFFSET. If PNAME is non-NULL then store the name of
17584 the symbol (if found) in the provided pointer, Returns NULL if a
17585 symbol could not be found. */
17587 static Elf_Internal_Sym
*
17588 get_symbol_for_build_attribute (Filedata
* filedata
,
17589 unsigned long offset
,
17590 bfd_boolean is_open_attr
,
17591 const char ** pname
)
17593 static Filedata
* saved_filedata
= NULL
;
17594 static char * strtab
;
17595 static unsigned long strtablen
;
17596 static Elf_Internal_Sym
* symtab
;
17597 static unsigned long nsyms
;
17598 Elf_Internal_Sym
* saved_sym
= NULL
;
17599 Elf_Internal_Sym
* sym
;
17601 if (filedata
->section_headers
!= NULL
17602 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17604 Elf_Internal_Shdr
* symsec
;
17606 /* Load the symbol and string sections. */
17607 for (symsec
= filedata
->section_headers
;
17608 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17611 if (symsec
->sh_type
== SHT_SYMTAB
)
17613 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17615 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17617 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17619 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17620 1, strtab_sec
->sh_size
,
17621 _("string table"));
17622 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17626 saved_filedata
= filedata
;
17629 if (symtab
== NULL
|| strtab
== NULL
)
17632 /* Find a symbol whose value matches offset. */
17633 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17634 if (sym
->st_value
== offset
)
17636 if (sym
->st_name
>= strtablen
)
17637 /* Huh ? This should not happen. */
17640 if (strtab
[sym
->st_name
] == 0)
17643 /* The AArch64 and ARM architectures define mapping symbols
17644 (eg $d, $x, $t) which we want to ignore. */
17645 if (strtab
[sym
->st_name
] == '$'
17646 && strtab
[sym
->st_name
+ 1] != 0
17647 && strtab
[sym
->st_name
+ 2] == 0)
17652 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17653 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17654 FUNC symbols entirely. */
17655 switch (ELF_ST_TYPE (sym
->st_info
))
17662 /* If the symbol has a size associated
17663 with it then we can stop searching. */
17664 sym
= symtab
+ nsyms
;
17669 /* Ignore function symbols. */
17676 switch (ELF_ST_BIND (sym
->st_info
))
17679 if (saved_sym
== NULL
17680 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17685 if (saved_sym
== NULL
)
17695 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17703 if (saved_sym
&& pname
)
17704 * pname
= strtab
+ saved_sym
->st_name
;
17709 /* Returns true iff addr1 and addr2 are in the same section. */
17712 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
17714 Elf_Internal_Shdr
* a1
;
17715 Elf_Internal_Shdr
* a2
;
17717 a1
= find_section_by_address (filedata
, addr1
);
17718 a2
= find_section_by_address (filedata
, addr2
);
17720 return a1
== a2
&& a1
!= NULL
;
17724 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17725 Filedata
* filedata
)
17727 static unsigned long global_offset
= 0;
17728 static unsigned long global_end
= 0;
17729 static unsigned long func_offset
= 0;
17730 static unsigned long func_end
= 0;
17732 Elf_Internal_Sym
* sym
;
17734 unsigned long start
;
17736 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17738 switch (pnote
->descsz
)
17741 /* A zero-length description means that the range of
17742 the previous note of the same type should be used. */
17745 if (global_end
> global_offset
)
17746 printf (_(" Applies to region from %#lx to %#lx\n"),
17747 global_offset
, global_end
);
17749 printf (_(" Applies to region from %#lx\n"), global_offset
);
17753 if (func_end
> func_offset
)
17754 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
17756 printf (_(" Applies to region from %#lx\n"), func_offset
);
17761 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17768 /* FIXME: We should check that version 3+ notes are being used here... */
17769 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17770 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17774 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17780 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17781 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
17785 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17786 printf (_(" <invalid descsz>"));
17791 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
17792 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17793 in order to avoid them being confused with the start address of the
17794 first function in the file... */
17795 if (sym
== NULL
&& is_open_attr
)
17796 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
17799 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
17800 end
= start
+ sym
->st_size
;
17804 /* FIXME: Need to properly allow for section alignment.
17805 16 is just the alignment used on x86_64. */
17807 && start
> BFD_ALIGN (global_end
, 16)
17808 /* Build notes are not guaranteed to be organised in order of
17809 increasing address, but we should find the all of the notes
17810 for one section in the same place. */
17811 && same_section (filedata
, start
, global_end
))
17812 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17813 global_end
+ 1, start
- 1);
17815 printf (_(" Applies to region from %#lx"), start
);
17816 global_offset
= start
;
17820 printf (_(" to %#lx"), end
);
17826 printf (_(" Applies to region from %#lx"), start
);
17827 func_offset
= start
;
17831 printf (_(" to %#lx"), end
);
17837 printf (_(" (%s)"), name
);
17844 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17846 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17847 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17848 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17850 char name_attribute
;
17851 const char * expected_types
;
17852 const char * name
= pnote
->namedata
;
17856 if (name
== NULL
|| pnote
->namesz
< 2)
17858 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17859 print_symbol (-20, _(" <corrupt name>"));
17868 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17869 if (name
[0] == 'G' && name
[1] == 'A')
17871 if (pnote
->namesz
< 4)
17873 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17874 print_symbol (-20, _(" <corrupt name>"));
17883 switch ((name_type
= * name
))
17885 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17886 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17887 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17888 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17889 printf ("%c", * name
);
17893 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17894 print_symbol (-20, _("<unknown name type>"));
17901 switch ((name_attribute
= * name
))
17903 case GNU_BUILD_ATTRIBUTE_VERSION
:
17904 text
= _("<version>");
17905 expected_types
= string_expected
;
17908 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17909 text
= _("<stack prot>");
17910 expected_types
= "!+*";
17913 case GNU_BUILD_ATTRIBUTE_RELRO
:
17914 text
= _("<relro>");
17915 expected_types
= bool_expected
;
17918 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17919 text
= _("<stack size>");
17920 expected_types
= number_expected
;
17923 case GNU_BUILD_ATTRIBUTE_TOOL
:
17924 text
= _("<tool>");
17925 expected_types
= string_expected
;
17928 case GNU_BUILD_ATTRIBUTE_ABI
:
17930 expected_types
= "$*";
17933 case GNU_BUILD_ATTRIBUTE_PIC
:
17935 expected_types
= number_expected
;
17938 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17939 text
= _("<short enum>");
17940 expected_types
= bool_expected
;
17944 if (ISPRINT (* name
))
17946 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17948 if (len
> left
&& ! do_wide
)
17950 printf ("%.*s:", len
, name
);
17956 static char tmpbuf
[128];
17958 error (_("unrecognised byte in name field: %d\n"), * name
);
17959 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17963 expected_types
= "*$!+";
17968 left
-= printf ("%s", text
);
17970 if (strchr (expected_types
, name_type
) == NULL
)
17971 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17973 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17975 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17976 (unsigned long) pnote
->namesz
,
17977 (long) (name
- pnote
->namedata
));
17981 if (left
< 1 && ! do_wide
)
17986 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17988 unsigned int bytes
;
17989 unsigned long long val
= 0;
17990 unsigned int shift
= 0;
17991 char * decoded
= NULL
;
17993 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17995 /* The -1 is because the name field is always 0 terminated, and we
17996 want to be able to ensure that the shift in the while loop below
17997 will not overflow. */
18000 if (bytes
> sizeof (val
))
18002 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18004 bytes
= sizeof (val
);
18006 /* We do not bother to warn if bytes == 0 as this can
18007 happen with some early versions of the gcc plugin. */
18011 unsigned long byte
= (* name
++) & 0xff;
18013 val
|= byte
<< shift
;
18017 switch (name_attribute
)
18019 case GNU_BUILD_ATTRIBUTE_PIC
:
18022 case 0: decoded
= "static"; break;
18023 case 1: decoded
= "pic"; break;
18024 case 2: decoded
= "PIC"; break;
18025 case 3: decoded
= "pie"; break;
18026 case 4: decoded
= "PIE"; break;
18030 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18033 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18034 case 0: decoded
= "off"; break;
18035 case 1: decoded
= "on"; break;
18036 case 2: decoded
= "all"; break;
18037 case 3: decoded
= "strong"; break;
18038 case 4: decoded
= "explicit"; break;
18046 if (decoded
!= NULL
)
18048 print_symbol (-left
, decoded
);
18059 left
-= printf ("0x%llx", val
);
18061 left
-= printf ("0x%-.*llx", left
, val
);
18065 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18066 left
-= print_symbol (- left
, name
);
18068 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18069 left
-= print_symbol (- left
, "true");
18071 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18072 left
-= print_symbol (- left
, "false");
18076 if (do_wide
&& left
> 0)
18077 printf ("%-*s", left
, " ");
18082 /* Note that by the ELF standard, the name field is already null byte
18083 terminated, and namesz includes the terminating null byte.
18084 I.E. the value of namesz for the name "FSF" is 4.
18086 If the value of namesz is zero, there is no name present. */
18089 process_note (Elf_Internal_Note
* pnote
,
18090 Filedata
* filedata
)
18092 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
18095 if (pnote
->namesz
== 0)
18096 /* If there is no note name, then use the default set of
18097 note type strings. */
18098 nt
= get_note_type (filedata
, pnote
->type
);
18100 else if (const_strneq (pnote
->namedata
, "GNU"))
18101 /* GNU-specific object file notes. */
18102 nt
= get_gnu_elf_note_type (pnote
->type
);
18104 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
18105 /* FreeBSD-specific core file notes. */
18106 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
18108 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
18109 /* NetBSD-specific core file notes. */
18110 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
18112 else if (const_strneq (pnote
->namedata
, "NetBSD"))
18113 /* NetBSD-specific core file notes. */
18114 return process_netbsd_elf_note (pnote
);
18116 else if (strneq (pnote
->namedata
, "SPU/", 4))
18118 /* SPU-specific core file notes. */
18119 nt
= pnote
->namedata
+ 4;
18123 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18124 /* VMS/ia64-specific file notes. */
18125 nt
= get_ia64_vms_note_type (pnote
->type
);
18127 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18128 nt
= get_stapsdt_note_type (pnote
->type
);
18131 /* Don't recognize this note name; just use the default set of
18132 note type strings. */
18133 nt
= get_note_type (filedata
, pnote
->type
);
18137 if (((const_strneq (pnote
->namedata
, "GA")
18138 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18139 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18140 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18141 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18142 print_gnu_build_attribute_name (pnote
);
18144 print_symbol (-20, name
);
18147 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
18149 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
18151 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18152 return print_ia64_vms_note (pnote
);
18153 else if (const_strneq (pnote
->namedata
, "GNU"))
18154 return print_gnu_note (filedata
, pnote
);
18155 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18156 return print_stapsdt_note (pnote
);
18157 else if (const_strneq (pnote
->namedata
, "CORE"))
18158 return print_core_note (pnote
);
18159 else if (((const_strneq (pnote
->namedata
, "GA")
18160 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18161 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18162 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18163 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18164 return print_gnu_build_attribute_description (pnote
, filedata
);
18170 printf (_(" description data: "));
18171 for (i
= 0; i
< pnote
->descsz
; i
++)
18172 printf ("%02x ", pnote
->descdata
[i
]);
18184 process_notes_at (Filedata
* filedata
,
18185 Elf_Internal_Shdr
* section
,
18190 Elf_External_Note
* pnotes
;
18191 Elf_External_Note
* external
;
18193 bfd_boolean res
= TRUE
;
18200 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18203 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18208 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18211 if (pnotes
== NULL
)
18217 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18219 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18220 (unsigned long) offset
, (unsigned long) length
);
18222 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18223 specifies that notes should be aligned to 4 bytes in 32-bit
18224 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18225 we also support 4 byte alignment in 64-bit objects. If section
18226 alignment is less than 4, we treate alignment as 4 bytes. */
18229 else if (align
!= 4 && align
!= 8)
18231 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18236 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18238 end
= (char *) pnotes
+ length
;
18239 while ((char *) external
< end
)
18241 Elf_Internal_Note inote
;
18244 char * temp
= NULL
;
18245 size_t data_remaining
= end
- (char *) external
;
18247 if (!is_ia64_vms (filedata
))
18249 /* PR binutils/15191
18250 Make sure that there is enough data to read. */
18251 min_notesz
= offsetof (Elf_External_Note
, name
);
18252 if (data_remaining
< min_notesz
)
18254 warn (ngettext ("Corrupt note: only %ld byte remains, "
18255 "not enough for a full note\n",
18256 "Corrupt note: only %ld bytes remain, "
18257 "not enough for a full note\n",
18259 (long) data_remaining
);
18262 data_remaining
-= min_notesz
;
18264 inote
.type
= BYTE_GET (external
->type
);
18265 inote
.namesz
= BYTE_GET (external
->namesz
);
18266 inote
.namedata
= external
->name
;
18267 inote
.descsz
= BYTE_GET (external
->descsz
);
18268 inote
.descdata
= ((char *) external
18269 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18270 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18271 next
= ((char *) external
18272 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18276 Elf64_External_VMS_Note
*vms_external
;
18278 /* PR binutils/15191
18279 Make sure that there is enough data to read. */
18280 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18281 if (data_remaining
< min_notesz
)
18283 warn (ngettext ("Corrupt note: only %ld byte remains, "
18284 "not enough for a full note\n",
18285 "Corrupt note: only %ld bytes remain, "
18286 "not enough for a full note\n",
18288 (long) data_remaining
);
18291 data_remaining
-= min_notesz
;
18293 vms_external
= (Elf64_External_VMS_Note
*) external
;
18294 inote
.type
= BYTE_GET (vms_external
->type
);
18295 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18296 inote
.namedata
= vms_external
->name
;
18297 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18298 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18299 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18300 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18303 /* PR 17531: file: 3443835e. */
18304 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18305 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18306 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18307 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18308 || ((size_t) (next
- inote
.descdata
)
18309 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18311 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18312 (unsigned long) ((char *) external
- (char *) pnotes
));
18313 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18314 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18318 external
= (Elf_External_Note
*) next
;
18320 /* Verify that name is null terminated. It appears that at least
18321 one version of Linux (RedHat 6.0) generates corefiles that don't
18322 comply with the ELF spec by failing to include the null byte in
18324 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18326 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18328 temp
= (char *) malloc (inote
.namesz
+ 1);
18331 error (_("Out of memory allocating space for inote name\n"));
18336 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18337 inote
.namedata
= temp
;
18339 inote
.namedata
[inote
.namesz
] = 0;
18342 if (! process_note (& inote
, filedata
))
18358 process_corefile_note_segments (Filedata
* filedata
)
18360 Elf_Internal_Phdr
* segment
;
18362 bfd_boolean res
= TRUE
;
18364 if (! get_program_headers (filedata
))
18367 for (i
= 0, segment
= filedata
->program_headers
;
18368 i
< filedata
->file_header
.e_phnum
;
18371 if (segment
->p_type
== PT_NOTE
)
18372 if (! process_notes_at (filedata
, NULL
,
18373 (bfd_vma
) segment
->p_offset
,
18374 (bfd_vma
) segment
->p_filesz
,
18375 (bfd_vma
) segment
->p_align
))
18383 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18385 Elf_External_Note
* pnotes
;
18386 Elf_External_Note
* external
;
18388 bfd_boolean res
= TRUE
;
18393 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18395 if (pnotes
== NULL
)
18399 end
= (char*) pnotes
+ length
;
18401 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18402 (unsigned long) offset
, (unsigned long) length
);
18404 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18406 Elf_External_Note
* next
;
18407 Elf_Internal_Note inote
;
18409 inote
.type
= BYTE_GET (external
->type
);
18410 inote
.namesz
= BYTE_GET (external
->namesz
);
18411 inote
.namedata
= external
->name
;
18412 inote
.descsz
= BYTE_GET (external
->descsz
);
18413 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18414 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18416 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18418 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18419 inote
.descdata
= inote
.namedata
;
18423 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18425 if ( ((char *) next
> end
)
18426 || ((char *) next
< (char *) pnotes
))
18428 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18429 (unsigned long) ((char *) external
- (char *) pnotes
));
18430 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18431 inote
.type
, inote
.namesz
, inote
.descsz
);
18437 /* Prevent out-of-bounds indexing. */
18438 if ( inote
.namedata
+ inote
.namesz
> end
18439 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18441 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18442 (unsigned long) ((char *) external
- (char *) pnotes
));
18443 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18444 inote
.type
, inote
.namesz
, inote
.descsz
);
18448 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18450 if (! print_v850_note (& inote
))
18453 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18454 inote
.namesz
, inote
.descsz
);
18464 process_note_sections (Filedata
* filedata
)
18466 Elf_Internal_Shdr
* section
;
18468 unsigned int n
= 0;
18469 bfd_boolean res
= TRUE
;
18471 for (i
= 0, section
= filedata
->section_headers
;
18472 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18475 if (section
->sh_type
== SHT_NOTE
)
18477 if (! process_notes_at (filedata
, section
,
18478 (bfd_vma
) section
->sh_offset
,
18479 (bfd_vma
) section
->sh_size
,
18480 (bfd_vma
) section
->sh_addralign
))
18485 if (( filedata
->file_header
.e_machine
== EM_V800
18486 || filedata
->file_header
.e_machine
== EM_V850
18487 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18488 && section
->sh_type
== SHT_RENESAS_INFO
)
18490 if (! process_v850_notes (filedata
,
18491 (bfd_vma
) section
->sh_offset
,
18492 (bfd_vma
) section
->sh_size
))
18499 /* Try processing NOTE segments instead. */
18500 return process_corefile_note_segments (filedata
);
18506 process_notes (Filedata
* filedata
)
18508 /* If we have not been asked to display the notes then do nothing. */
18512 if (filedata
->file_header
.e_type
!= ET_CORE
)
18513 return process_note_sections (filedata
);
18515 /* No program headers means no NOTE segment. */
18516 if (filedata
->file_header
.e_phnum
> 0)
18517 return process_corefile_note_segments (filedata
);
18519 printf (_("No note segments present in the core file.\n"));
18523 static unsigned char *
18524 display_public_gnu_attributes (unsigned char * start
,
18525 const unsigned char * const end
)
18527 printf (_(" Unknown GNU attribute: %s\n"), start
);
18529 start
+= strnlen ((char *) start
, end
- start
);
18530 display_raw_attribute (start
, end
);
18532 return (unsigned char *) end
;
18535 static unsigned char *
18536 display_generic_attribute (unsigned char * start
,
18538 const unsigned char * const end
)
18541 return (unsigned char *) end
;
18543 return display_tag_value (tag
, start
, end
);
18547 process_arch_specific (Filedata
* filedata
)
18552 switch (filedata
->file_header
.e_machine
)
18555 case EM_ARC_COMPACT
:
18556 case EM_ARC_COMPACT2
:
18557 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18558 display_arc_attribute
,
18559 display_generic_attribute
);
18561 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18562 display_arm_attribute
,
18563 display_generic_attribute
);
18566 case EM_MIPS_RS3_LE
:
18567 return process_mips_specific (filedata
);
18570 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18571 display_msp430x_attribute
,
18572 display_generic_attribute
);
18575 return process_nds32_specific (filedata
);
18579 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18580 display_power_gnu_attribute
);
18584 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18585 display_s390_gnu_attribute
);
18588 case EM_SPARC32PLUS
:
18590 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18591 display_sparc_gnu_attribute
);
18594 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18595 display_tic6x_attribute
,
18596 display_generic_attribute
);
18599 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18600 display_public_gnu_attributes
,
18601 display_generic_attribute
);
18606 get_file_header (Filedata
* filedata
)
18608 /* Read in the identity array. */
18609 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18612 /* Determine how to read the rest of the header. */
18613 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18618 byte_get
= byte_get_little_endian
;
18619 byte_put
= byte_put_little_endian
;
18622 byte_get
= byte_get_big_endian
;
18623 byte_put
= byte_put_big_endian
;
18627 /* For now we only support 32 bit and 64 bit ELF files. */
18628 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18630 /* Read in the rest of the header. */
18633 Elf32_External_Ehdr ehdr32
;
18635 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18638 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18639 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18640 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18641 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18642 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18643 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18644 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18645 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18646 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18647 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18648 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18649 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18650 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18654 Elf64_External_Ehdr ehdr64
;
18656 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18657 we will not be able to cope with the 64bit data found in
18658 64 ELF files. Detect this now and abort before we start
18659 overwriting things. */
18660 if (sizeof (bfd_vma
) < 8)
18662 error (_("This instance of readelf has been built without support for a\n\
18663 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18667 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18670 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18671 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18672 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18673 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18674 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18675 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18676 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18677 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18678 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18679 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18680 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18681 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18682 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18685 if (filedata
->file_header
.e_shoff
)
18687 /* There may be some extensions in the first section header. Don't
18688 bomb if we can't read it. */
18690 get_32bit_section_headers (filedata
, TRUE
);
18692 get_64bit_section_headers (filedata
, TRUE
);
18699 close_file (Filedata
* filedata
)
18703 if (filedata
->handle
)
18704 fclose (filedata
->handle
);
18710 close_debug_file (void * data
)
18712 close_file ((Filedata
*) data
);
18716 open_file (const char * pathname
)
18718 struct stat statbuf
;
18719 Filedata
* filedata
= NULL
;
18721 if (stat (pathname
, & statbuf
) < 0
18722 || ! S_ISREG (statbuf
.st_mode
))
18725 filedata
= calloc (1, sizeof * filedata
);
18726 if (filedata
== NULL
)
18729 filedata
->handle
= fopen (pathname
, "rb");
18730 if (filedata
->handle
== NULL
)
18733 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
18734 filedata
->file_name
= pathname
;
18736 if (! get_file_header (filedata
))
18739 if (filedata
->file_header
.e_shoff
)
18743 /* Read the section headers again, this time for real. */
18745 res
= get_32bit_section_headers (filedata
, FALSE
);
18747 res
= get_64bit_section_headers (filedata
, FALSE
);
18758 if (filedata
->handle
)
18759 fclose (filedata
->handle
);
18766 open_debug_file (const char * pathname
)
18768 return open_file (pathname
);
18771 /* Process one ELF object file according to the command line options.
18772 This file may actually be stored in an archive. The file is
18773 positioned at the start of the ELF object. Returns TRUE if no
18774 problems were encountered, FALSE otherwise. */
18777 process_object (Filedata
* filedata
)
18779 Filedata
* separates
;
18781 bfd_boolean res
= TRUE
;
18783 if (! get_file_header (filedata
))
18785 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
18789 /* Initialise per file variables. */
18790 for (i
= ARRAY_SIZE (version_info
); i
--;)
18791 version_info
[i
] = 0;
18793 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18794 dynamic_info
[i
] = 0;
18795 dynamic_info_DT_GNU_HASH
= 0;
18797 /* Process the file. */
18799 printf (_("\nFile: %s\n"), filedata
->file_name
);
18801 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18802 Note we do this even if cmdline_dump_sects is empty because we
18803 must make sure that the dump_sets array is zeroed out before each
18804 object file is processed. */
18805 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
18806 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
18808 if (cmdline
.num_dump_sects
> 0)
18810 if (filedata
->num_dump_sects
== 0)
18811 /* A sneaky way of allocating the dump_sects array. */
18812 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
18814 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
18815 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
18816 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
18819 if (! process_file_header (filedata
))
18822 if (! process_section_headers (filedata
))
18824 /* Without loaded section headers we cannot process lots of things. */
18825 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18827 if (! do_using_dynamic
)
18828 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18831 if (! process_section_groups (filedata
))
18832 /* Without loaded section groups we cannot process unwind. */
18835 if (process_program_headers (filedata
))
18836 process_dynamic_section (filedata
);
18840 if (! process_relocs (filedata
))
18843 if (! process_unwind (filedata
))
18846 if (! process_symbol_table (filedata
))
18849 if (! process_syminfo (filedata
))
18852 if (! process_version_sections (filedata
))
18855 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
18856 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
18860 if (! process_section_contents (filedata
))
18865 if (! process_section_headers (separates
))
18867 else if (! process_section_contents (separates
))
18871 if (! process_notes (filedata
))
18874 if (! process_gnu_liblist (filedata
))
18877 if (! process_arch_specific (filedata
))
18880 free (filedata
->program_headers
);
18881 filedata
->program_headers
= NULL
;
18883 free (filedata
->section_headers
);
18884 filedata
->section_headers
= NULL
;
18886 free (filedata
->string_table
);
18887 filedata
->string_table
= NULL
;
18888 filedata
->string_table_length
= 0;
18890 if (dynamic_strings
)
18892 free (dynamic_strings
);
18893 dynamic_strings
= NULL
;
18894 dynamic_strings_length
= 0;
18897 if (dynamic_symbols
)
18899 free (dynamic_symbols
);
18900 dynamic_symbols
= NULL
;
18901 num_dynamic_syms
= 0;
18904 if (dynamic_syminfo
)
18906 free (dynamic_syminfo
);
18907 dynamic_syminfo
= NULL
;
18910 if (dynamic_section
)
18912 free (dynamic_section
);
18913 dynamic_section
= NULL
;
18916 if (section_headers_groups
)
18918 free (section_headers_groups
);
18919 section_headers_groups
= NULL
;
18922 if (section_groups
)
18924 struct group_list
* g
;
18925 struct group_list
* next
;
18927 for (i
= 0; i
< group_count
; i
++)
18929 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18936 free (section_groups
);
18937 section_groups
= NULL
;
18940 free_debug_memory ();
18945 /* Process an ELF archive.
18946 On entry the file is positioned just after the ARMAG string.
18947 Returns TRUE upon success, FALSE otherwise. */
18950 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
18952 struct archive_info arch
;
18953 struct archive_info nested_arch
;
18955 bfd_boolean ret
= TRUE
;
18959 /* The ARCH structure is used to hold information about this archive. */
18960 arch
.file_name
= NULL
;
18962 arch
.index_array
= NULL
;
18963 arch
.sym_table
= NULL
;
18964 arch
.longnames
= NULL
;
18966 /* The NESTED_ARCH structure is used as a single-item cache of information
18967 about a nested archive (when members of a thin archive reside within
18968 another regular archive file). */
18969 nested_arch
.file_name
= NULL
;
18970 nested_arch
.file
= NULL
;
18971 nested_arch
.index_array
= NULL
;
18972 nested_arch
.sym_table
= NULL
;
18973 nested_arch
.longnames
= NULL
;
18975 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
18976 is_thin_archive
, do_archive_index
) != 0)
18982 if (do_archive_index
)
18984 if (arch
.sym_table
== NULL
)
18985 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
18988 unsigned long i
, l
;
18989 unsigned long current_pos
;
18991 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18992 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18994 current_pos
= ftell (filedata
->handle
);
18996 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18998 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
19000 char * member_name
;
19002 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
19004 if (member_name
!= NULL
)
19006 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
19008 if (qualified_name
!= NULL
)
19010 printf (_("Contents of binary %s at offset "), qualified_name
);
19011 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
19013 free (qualified_name
);
19018 if (l
>= arch
.sym_size
)
19020 error (_("%s: end of the symbol table reached before the end of the index\n"),
19021 filedata
->file_name
);
19025 /* PR 17531: file: 0b6630b2. */
19026 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
19027 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
19030 if (arch
.uses_64bit_indicies
)
19035 if (l
< arch
.sym_size
)
19037 error (ngettext ("%s: %ld byte remains in the symbol table, "
19038 "but without corresponding entries in "
19039 "the index table\n",
19040 "%s: %ld bytes remain in the symbol table, "
19041 "but without corresponding entries in "
19042 "the index table\n",
19043 arch
.sym_size
- l
),
19044 filedata
->file_name
, arch
.sym_size
- l
);
19048 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
19050 error (_("%s: failed to seek back to start of object files in the archive\n"),
19051 filedata
->file_name
);
19057 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
19058 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
19059 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
19060 && !do_section_groups
&& !do_dyn_syms
)
19062 ret
= TRUE
; /* Archive index only. */
19071 char * qualified_name
;
19073 /* Read the next archive header. */
19074 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
19076 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
19079 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
19080 if (got
!= sizeof arch
.arhdr
)
19084 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
19088 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
19090 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
19095 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
19097 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
19098 if (archive_file_size
& 01)
19099 ++archive_file_size
;
19101 name
= get_archive_member_name (&arch
, &nested_arch
);
19104 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19108 namelen
= strlen (name
);
19110 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
19111 if (qualified_name
== NULL
)
19113 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19118 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
19120 /* This is a proxy for an external member of a thin archive. */
19121 Filedata
* member_filedata
;
19122 char * member_file_name
= adjust_relative_path
19123 (filedata
->file_name
, name
, namelen
);
19125 if (member_file_name
== NULL
)
19131 member_filedata
= open_file (member_file_name
);
19132 if (member_filedata
== NULL
)
19134 error (_("Input file '%s' is not readable.\n"), member_file_name
);
19135 free (member_file_name
);
19140 archive_file_offset
= arch
.nested_member_origin
;
19141 member_filedata
->file_name
= qualified_name
;
19143 if (! process_object (member_filedata
))
19146 close_file (member_filedata
);
19147 free (member_file_name
);
19149 else if (is_thin_archive
)
19151 Filedata thin_filedata
;
19153 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
19155 /* PR 15140: Allow for corrupt thin archives. */
19156 if (nested_arch
.file
== NULL
)
19158 error (_("%s: contains corrupt thin archive: %s\n"),
19159 filedata
->file_name
, name
);
19164 /* This is a proxy for a member of a nested archive. */
19165 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19167 /* The nested archive file will have been opened and setup by
19168 get_archive_member_name. */
19169 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19171 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19176 thin_filedata
.handle
= nested_arch
.file
;
19177 thin_filedata
.file_name
= qualified_name
;
19179 if (! process_object (& thin_filedata
))
19184 archive_file_offset
= arch
.next_arhdr_offset
;
19185 arch
.next_arhdr_offset
+= archive_file_size
;
19187 filedata
->file_name
= qualified_name
;
19188 if (! process_object (filedata
))
19192 if (filedata
->dump_sects
!= NULL
)
19194 free (filedata
->dump_sects
);
19195 filedata
->dump_sects
= NULL
;
19196 filedata
->num_dump_sects
= 0;
19199 free (qualified_name
);
19203 if (nested_arch
.file
!= NULL
)
19204 fclose (nested_arch
.file
);
19205 release_archive (&nested_arch
);
19206 release_archive (&arch
);
19212 process_file (char * file_name
)
19214 Filedata
* filedata
= NULL
;
19215 struct stat statbuf
;
19216 char armag
[SARMAG
];
19217 bfd_boolean ret
= TRUE
;
19219 if (stat (file_name
, &statbuf
) < 0)
19221 if (errno
== ENOENT
)
19222 error (_("'%s': No such file\n"), file_name
);
19224 error (_("Could not locate '%s'. System error message: %s\n"),
19225 file_name
, strerror (errno
));
19229 if (! S_ISREG (statbuf
.st_mode
))
19231 error (_("'%s' is not an ordinary file\n"), file_name
);
19235 filedata
= calloc (1, sizeof * filedata
);
19236 if (filedata
== NULL
)
19238 error (_("Out of memory allocating file data structure\n"));
19242 filedata
->file_name
= file_name
;
19243 filedata
->handle
= fopen (file_name
, "rb");
19244 if (filedata
->handle
== NULL
)
19246 error (_("Input file '%s' is not readable.\n"), file_name
);
19251 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19253 error (_("%s: Failed to read file's magic number\n"), file_name
);
19254 fclose (filedata
->handle
);
19259 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19261 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19263 if (! process_archive (filedata
, FALSE
))
19266 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19268 if ( ! process_archive (filedata
, TRUE
))
19273 if (do_archive_index
)
19274 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19277 rewind (filedata
->handle
);
19278 archive_file_size
= archive_file_offset
= 0;
19280 if (! process_object (filedata
))
19284 fclose (filedata
->handle
);
19290 #ifdef SUPPORT_DISASSEMBLY
19291 /* Needed by the i386 disassembler. For extra credit, someone could
19292 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19296 print_address (unsigned int addr
, FILE * outfile
)
19298 fprintf (outfile
,"0x%8.8x", addr
);
19301 /* Needed by the i386 disassembler. */
19304 db_task_printsym (unsigned int addr
)
19306 print_address (addr
, stderr
);
19311 main (int argc
, char ** argv
)
19315 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19316 setlocale (LC_MESSAGES
, "");
19318 #if defined (HAVE_SETLOCALE)
19319 setlocale (LC_CTYPE
, "");
19321 bindtextdomain (PACKAGE
, LOCALEDIR
);
19322 textdomain (PACKAGE
);
19324 expandargv (&argc
, &argv
);
19326 cmdline
.file_name
= "<cmdline>";
19327 parse_args (& cmdline
, argc
, argv
);
19329 if (optind
< (argc
- 1))
19331 else if (optind
>= argc
)
19333 warn (_("Nothing to do.\n"));
19338 while (optind
< argc
)
19339 if (! process_file (argv
[optind
++]))
19342 if (cmdline
.dump_sects
!= NULL
)
19343 free (cmdline
.dump_sects
);
19345 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;