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 INDICES";
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
);
5337 for (i
= 0, internal
= filedata
->section_headers
;
5341 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5342 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5343 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5344 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5345 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5346 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5347 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5348 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5349 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5350 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5351 if (!probe
&& internal
->sh_link
> num
)
5352 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5353 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5354 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5361 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5364 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5366 Elf64_External_Shdr
* shdrs
;
5367 Elf_Internal_Shdr
* internal
;
5369 unsigned int size
= filedata
->file_header
.e_shentsize
;
5370 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5372 /* PR binutils/17531: Cope with unexpected section header sizes. */
5373 if (size
== 0 || num
== 0)
5376 if (size
< sizeof * shdrs
)
5379 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5383 if (! probe
&& size
> sizeof * shdrs
)
5384 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5386 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5387 filedata
->file_header
.e_shoff
,
5389 probe
? NULL
: _("section headers"));
5393 free (filedata
->section_headers
);
5394 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5395 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5396 if (filedata
->section_headers
== NULL
)
5399 error (_("Out of memory reading %u section headers\n"), num
);
5404 for (i
= 0, internal
= filedata
->section_headers
;
5408 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5409 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5410 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5411 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5412 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5413 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5414 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5415 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5416 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5417 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5418 if (!probe
&& internal
->sh_link
> num
)
5419 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5420 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5421 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5428 static Elf_Internal_Sym
*
5429 get_32bit_elf_symbols (Filedata
* filedata
,
5430 Elf_Internal_Shdr
* section
,
5431 unsigned long * num_syms_return
)
5433 unsigned long number
= 0;
5434 Elf32_External_Sym
* esyms
= NULL
;
5435 Elf_External_Sym_Shndx
* shndx
= NULL
;
5436 Elf_Internal_Sym
* isyms
= NULL
;
5437 Elf_Internal_Sym
* psym
;
5439 elf_section_list
* entry
;
5441 if (section
->sh_size
== 0)
5443 if (num_syms_return
!= NULL
)
5444 * num_syms_return
= 0;
5448 /* Run some sanity checks first. */
5449 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5451 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5452 printable_section_name (filedata
, section
),
5453 (unsigned long) section
->sh_entsize
);
5457 if (section
->sh_size
> filedata
->file_size
)
5459 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5460 printable_section_name (filedata
, section
),
5461 (unsigned long) section
->sh_size
);
5465 number
= section
->sh_size
/ section
->sh_entsize
;
5467 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5469 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5470 (unsigned long) section
->sh_size
,
5471 printable_section_name (filedata
, section
),
5472 (unsigned long) section
->sh_entsize
);
5476 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5477 section
->sh_size
, _("symbols"));
5482 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5484 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5489 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5493 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5494 entry
->hdr
->sh_offset
,
5495 1, entry
->hdr
->sh_size
,
5496 _("symbol table section indices"));
5500 /* PR17531: file: heap-buffer-overflow */
5501 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5503 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5504 printable_section_name (filedata
, entry
->hdr
),
5505 (unsigned long) entry
->hdr
->sh_size
,
5506 (unsigned long) section
->sh_size
);
5511 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5515 error (_("Out of memory reading %lu symbols\n"),
5516 (unsigned long) number
);
5520 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5522 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5523 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5524 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5525 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5526 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5528 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5529 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5530 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5531 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5532 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5539 if (num_syms_return
!= NULL
)
5540 * num_syms_return
= isyms
== NULL
? 0 : number
;
5545 static Elf_Internal_Sym
*
5546 get_64bit_elf_symbols (Filedata
* filedata
,
5547 Elf_Internal_Shdr
* section
,
5548 unsigned long * num_syms_return
)
5550 unsigned long number
= 0;
5551 Elf64_External_Sym
* esyms
= NULL
;
5552 Elf_External_Sym_Shndx
* shndx
= NULL
;
5553 Elf_Internal_Sym
* isyms
= NULL
;
5554 Elf_Internal_Sym
* psym
;
5556 elf_section_list
* entry
;
5558 if (section
->sh_size
== 0)
5560 if (num_syms_return
!= NULL
)
5561 * num_syms_return
= 0;
5565 /* Run some sanity checks first. */
5566 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5568 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5569 printable_section_name (filedata
, section
),
5570 (unsigned long) section
->sh_entsize
);
5574 if (section
->sh_size
> filedata
->file_size
)
5576 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5577 printable_section_name (filedata
, section
),
5578 (unsigned long) section
->sh_size
);
5582 number
= section
->sh_size
/ section
->sh_entsize
;
5584 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5586 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5587 (unsigned long) section
->sh_size
,
5588 printable_section_name (filedata
, section
),
5589 (unsigned long) section
->sh_entsize
);
5593 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5594 section
->sh_size
, _("symbols"));
5599 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5601 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5606 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5610 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5611 entry
->hdr
->sh_offset
,
5612 1, entry
->hdr
->sh_size
,
5613 _("symbol table section indices"));
5617 /* PR17531: file: heap-buffer-overflow */
5618 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5620 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5621 printable_section_name (filedata
, entry
->hdr
),
5622 (unsigned long) entry
->hdr
->sh_size
,
5623 (unsigned long) section
->sh_size
);
5628 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5632 error (_("Out of memory reading %lu symbols\n"),
5633 (unsigned long) number
);
5637 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5639 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5640 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5641 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5642 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5644 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5646 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5647 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5648 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5650 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5651 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5658 if (num_syms_return
!= NULL
)
5659 * num_syms_return
= isyms
== NULL
? 0 : number
;
5665 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5667 static char buff
[1024];
5669 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5671 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5672 bfd_vma os_flags
= 0;
5673 bfd_vma proc_flags
= 0;
5674 bfd_vma unknown_flags
= 0;
5682 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5683 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5684 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5685 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5686 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5687 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5688 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5689 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5690 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5691 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5692 /* IA-64 specific. */
5693 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5694 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5695 /* IA-64 OpenVMS specific. */
5696 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5697 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5698 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5699 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5700 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5701 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5703 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5704 /* SPARC specific. */
5705 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5706 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5708 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5709 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5710 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5712 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5714 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5717 if (do_section_details
)
5719 sprintf (buff
, "[%*.*lx]: ",
5720 field_size
, field_size
, (unsigned long) sh_flags
);
5721 p
+= field_size
+ 4;
5728 flag
= sh_flags
& - sh_flags
;
5731 if (do_section_details
)
5735 case SHF_WRITE
: sindex
= 0; break;
5736 case SHF_ALLOC
: sindex
= 1; break;
5737 case SHF_EXECINSTR
: sindex
= 2; break;
5738 case SHF_MERGE
: sindex
= 3; break;
5739 case SHF_STRINGS
: sindex
= 4; break;
5740 case SHF_INFO_LINK
: sindex
= 5; break;
5741 case SHF_LINK_ORDER
: sindex
= 6; break;
5742 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5743 case SHF_GROUP
: sindex
= 8; break;
5744 case SHF_TLS
: sindex
= 9; break;
5745 case SHF_EXCLUDE
: sindex
= 18; break;
5746 case SHF_COMPRESSED
: sindex
= 20; break;
5747 case SHF_GNU_MBIND
: sindex
= 24; break;
5751 switch (filedata
->file_header
.e_machine
)
5754 if (flag
== SHF_IA_64_SHORT
)
5756 else if (flag
== SHF_IA_64_NORECOV
)
5759 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5762 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5763 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5764 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5765 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5766 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5767 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5778 case EM_OLD_SPARCV9
:
5779 case EM_SPARC32PLUS
:
5782 if (flag
== SHF_ORDERED
)
5789 case SHF_ENTRYSECT
: sindex
= 21; break;
5790 case SHF_ARM_PURECODE
: sindex
= 22; break;
5791 case SHF_COMDEF
: sindex
= 23; break;
5796 if (flag
== SHF_PPC_VLE
)
5807 if (p
!= buff
+ field_size
+ 4)
5809 if (size
< (10 + 2))
5811 warn (_("Internal error: not enough buffer room for section flag info"));
5812 return _("<unknown>");
5819 size
-= flags
[sindex
].len
;
5820 p
= stpcpy (p
, flags
[sindex
].str
);
5822 else if (flag
& SHF_MASKOS
)
5824 else if (flag
& SHF_MASKPROC
)
5827 unknown_flags
|= flag
;
5833 case SHF_WRITE
: *p
= 'W'; break;
5834 case SHF_ALLOC
: *p
= 'A'; break;
5835 case SHF_EXECINSTR
: *p
= 'X'; break;
5836 case SHF_MERGE
: *p
= 'M'; break;
5837 case SHF_STRINGS
: *p
= 'S'; break;
5838 case SHF_INFO_LINK
: *p
= 'I'; break;
5839 case SHF_LINK_ORDER
: *p
= 'L'; break;
5840 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5841 case SHF_GROUP
: *p
= 'G'; break;
5842 case SHF_TLS
: *p
= 'T'; break;
5843 case SHF_EXCLUDE
: *p
= 'E'; break;
5844 case SHF_COMPRESSED
: *p
= 'C'; break;
5845 case SHF_GNU_MBIND
: *p
= 'D'; break;
5848 if ((filedata
->file_header
.e_machine
== EM_X86_64
5849 || filedata
->file_header
.e_machine
== EM_L1OM
5850 || filedata
->file_header
.e_machine
== EM_K1OM
)
5851 && flag
== SHF_X86_64_LARGE
)
5853 else if (filedata
->file_header
.e_machine
== EM_ARM
5854 && flag
== SHF_ARM_PURECODE
)
5856 else if (filedata
->file_header
.e_machine
== EM_PPC
5857 && flag
== SHF_PPC_VLE
)
5859 else if (flag
& SHF_MASKOS
)
5862 sh_flags
&= ~ SHF_MASKOS
;
5864 else if (flag
& SHF_MASKPROC
)
5867 sh_flags
&= ~ SHF_MASKPROC
;
5877 if (do_section_details
)
5881 size
-= 5 + field_size
;
5882 if (p
!= buff
+ field_size
+ 4)
5886 warn (_("Internal error: not enough buffer room for section flag info"));
5887 return _("<unknown>");
5893 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5894 (unsigned long) os_flags
);
5895 p
+= 5 + field_size
;
5899 size
-= 7 + field_size
;
5900 if (p
!= buff
+ field_size
+ 4)
5904 warn (_("Internal error: not enough buffer room for section flag info"));
5905 return _("<unknown>");
5911 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5912 (unsigned long) proc_flags
);
5913 p
+= 7 + field_size
;
5917 size
-= 10 + field_size
;
5918 if (p
!= buff
+ field_size
+ 4)
5922 warn (_("Internal error: not enough buffer room for section flag info"));
5923 return _("<unknown>");
5929 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5930 (unsigned long) unknown_flags
);
5931 p
+= 10 + field_size
;
5940 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5944 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5946 if (size
< sizeof (* echdr
))
5948 error (_("Compressed section is too small even for a compression header\n"));
5952 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5953 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5954 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5955 return sizeof (*echdr
);
5959 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5961 if (size
< sizeof (* echdr
))
5963 error (_("Compressed section is too small even for a compression header\n"));
5967 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5968 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5969 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5970 return sizeof (*echdr
);
5975 process_section_headers (Filedata
* filedata
)
5977 Elf_Internal_Shdr
* section
;
5980 filedata
->section_headers
= NULL
;
5982 if (filedata
->file_header
.e_shnum
== 0)
5984 /* PR binutils/12467. */
5985 if (filedata
->file_header
.e_shoff
!= 0)
5987 warn (_("possibly corrupt ELF file header - it has a non-zero"
5988 " section header offset, but no section headers\n"));
5991 else if (do_sections
)
5992 printf (_("\nThere are no sections in this file.\n"));
5997 if (do_sections
&& !do_header
)
5998 printf (ngettext ("There is %d section header, "
5999 "starting at offset 0x%lx:\n",
6000 "There are %d section headers, "
6001 "starting at offset 0x%lx:\n",
6002 filedata
->file_header
.e_shnum
),
6003 filedata
->file_header
.e_shnum
,
6004 (unsigned long) filedata
->file_header
.e_shoff
);
6008 if (! get_32bit_section_headers (filedata
, FALSE
))
6013 if (! get_64bit_section_headers (filedata
, FALSE
))
6017 /* Read in the string table, so that we have names to display. */
6018 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6019 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6021 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6023 if (section
->sh_size
!= 0)
6025 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6026 1, section
->sh_size
,
6029 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6033 /* Scan the sections for the dynamic symbol table
6034 and dynamic string table and debug sections. */
6035 dynamic_symbols
= NULL
;
6036 dynamic_strings
= NULL
;
6037 dynamic_syminfo
= NULL
;
6038 symtab_shndx_list
= NULL
;
6040 eh_addr_size
= is_32bit_elf
? 4 : 8;
6041 switch (filedata
->file_header
.e_machine
)
6044 case EM_MIPS_RS3_LE
:
6045 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6046 FDE addresses. However, the ABI also has a semi-official ILP32
6047 variant for which the normal FDE address size rules apply.
6049 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6050 section, where XX is the size of longs in bits. Unfortunately,
6051 earlier compilers provided no way of distinguishing ILP32 objects
6052 from LP64 objects, so if there's any doubt, we should assume that
6053 the official LP64 form is being used. */
6054 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6055 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6061 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6063 case E_H8_MACH_H8300
:
6064 case E_H8_MACH_H8300HN
:
6065 case E_H8_MACH_H8300SN
:
6066 case E_H8_MACH_H8300SXN
:
6069 case E_H8_MACH_H8300H
:
6070 case E_H8_MACH_H8300S
:
6071 case E_H8_MACH_H8300SX
:
6079 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6081 case EF_M32C_CPU_M16C
:
6088 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6091 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6092 if (section->sh_entsize != expected_entsize) \
6095 sprintf_vma (buf, section->sh_entsize); \
6096 /* Note: coded this way so that there is a single string for \
6098 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6099 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6100 (unsigned) expected_entsize); \
6101 section->sh_entsize = expected_entsize; \
6106 #define CHECK_ENTSIZE(section, i, type) \
6107 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6108 sizeof (Elf64_External_##type))
6110 for (i
= 0, section
= filedata
->section_headers
;
6111 i
< filedata
->file_header
.e_shnum
;
6114 char * name
= SECTION_NAME (section
);
6116 if (section
->sh_type
== SHT_DYNSYM
)
6118 if (dynamic_symbols
!= NULL
)
6120 error (_("File contains multiple dynamic symbol tables\n"));
6124 CHECK_ENTSIZE (section
, i
, Sym
);
6125 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6127 else if (section
->sh_type
== SHT_STRTAB
6128 && streq (name
, ".dynstr"))
6130 if (dynamic_strings
!= NULL
)
6132 error (_("File contains multiple dynamic string tables\n"));
6136 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6137 1, section
->sh_size
,
6138 _("dynamic strings"));
6139 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6141 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6143 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6145 entry
->hdr
= section
;
6146 entry
->next
= symtab_shndx_list
;
6147 symtab_shndx_list
= entry
;
6149 else if (section
->sh_type
== SHT_SYMTAB
)
6150 CHECK_ENTSIZE (section
, i
, Sym
);
6151 else if (section
->sh_type
== SHT_GROUP
)
6152 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6153 else if (section
->sh_type
== SHT_REL
)
6154 CHECK_ENTSIZE (section
, i
, Rel
);
6155 else if (section
->sh_type
== SHT_RELA
)
6156 CHECK_ENTSIZE (section
, i
, Rela
);
6157 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6158 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6159 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6160 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6161 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6162 && (const_strneq (name
, ".debug_")
6163 || const_strneq (name
, ".zdebug_")))
6166 name
+= sizeof (".zdebug_") - 1;
6168 name
+= sizeof (".debug_") - 1;
6171 || (do_debug_info
&& const_strneq (name
, "info"))
6172 || (do_debug_info
&& const_strneq (name
, "types"))
6173 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6174 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6175 || (do_debug_lines
&& const_strneq (name
, "line."))
6176 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6177 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6178 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6179 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6180 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6181 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6182 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6183 || (do_debug_frames
&& const_strneq (name
, "frame"))
6184 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6185 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6186 || (do_debug_str
&& const_strneq (name
, "str"))
6187 || (do_debug_loc
&& const_strneq (name
, "loc"))
6188 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6189 || (do_debug_addr
&& const_strneq (name
, "addr"))
6190 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6191 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6193 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6195 /* Linkonce section to be combined with .debug_info at link time. */
6196 else if ((do_debugging
|| do_debug_info
)
6197 && const_strneq (name
, ".gnu.linkonce.wi."))
6198 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6199 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6200 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6201 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6202 || streq (name
, ".debug_names")))
6203 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6204 /* Trace sections for Itanium VMS. */
6205 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6206 || do_trace_aranges
)
6207 && const_strneq (name
, ".trace_"))
6209 name
+= sizeof (".trace_") - 1;
6212 || (do_trace_info
&& streq (name
, "info"))
6213 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6214 || (do_trace_aranges
&& streq (name
, "aranges"))
6216 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6218 else if ((do_debugging
|| do_debug_links
)
6219 && (const_strneq (name
, ".gnu_debuglink")
6220 || const_strneq (name
, ".gnu_debugaltlink")))
6221 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6227 if (filedata
->file_header
.e_shnum
> 1)
6228 printf (_("\nSection Headers:\n"));
6230 printf (_("\nSection Header:\n"));
6234 if (do_section_details
)
6236 printf (_(" [Nr] Name\n"));
6237 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6241 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6245 if (do_section_details
)
6247 printf (_(" [Nr] Name\n"));
6248 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6252 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6256 if (do_section_details
)
6258 printf (_(" [Nr] Name\n"));
6259 printf (_(" Type Address Offset Link\n"));
6260 printf (_(" Size EntSize Info Align\n"));
6264 printf (_(" [Nr] Name Type Address Offset\n"));
6265 printf (_(" Size EntSize Flags Link Info Align\n"));
6269 if (do_section_details
)
6270 printf (_(" Flags\n"));
6272 for (i
= 0, section
= filedata
->section_headers
;
6273 i
< filedata
->file_header
.e_shnum
;
6276 /* Run some sanity checks on the section header. */
6278 /* Check the sh_link field. */
6279 switch (section
->sh_type
)
6281 case SHT_SYMTAB_SHNDX
:
6285 case SHT_GNU_versym
:
6288 if (section
->sh_link
< 1
6289 || section
->sh_link
>= filedata
->file_header
.e_shnum
6290 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6291 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6292 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6293 i
, section
->sh_link
);
6299 case SHT_GNU_verneed
:
6300 case SHT_GNU_verdef
:
6301 case SHT_GNU_LIBLIST
:
6302 if (section
->sh_link
< 1
6303 || section
->sh_link
>= filedata
->file_header
.e_shnum
6304 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6305 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6306 i
, section
->sh_link
);
6309 case SHT_INIT_ARRAY
:
6310 case SHT_FINI_ARRAY
:
6311 case SHT_PREINIT_ARRAY
:
6312 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6313 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6314 i
, section
->sh_link
);
6318 /* FIXME: Add support for target specific section types. */
6319 #if 0 /* Currently we do not check other section types as there are too
6320 many special cases. Stab sections for example have a type
6321 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6323 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6324 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6325 i
, section
->sh_link
);
6330 /* Check the sh_info field. */
6331 switch (section
->sh_type
)
6335 if (section
->sh_info
< 1
6336 || section
->sh_info
>= filedata
->file_header
.e_shnum
6337 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6338 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6339 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6340 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6341 /* FIXME: Are other section types valid ? */
6342 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6344 if (section
->sh_info
== 0
6345 && (filedata
->file_header
.e_type
== ET_EXEC
6346 || filedata
->file_header
.e_type
== ET_DYN
6347 /* These next two tests may be redundant, but
6348 they have been left in for paranoia's sake. */
6349 || streq (SECTION_NAME (section
), ".rel.dyn")
6350 || streq (SECTION_NAME (section
), ".rela.dyn")))
6351 /* Dynamic relocations apply to segments, not sections, so
6352 they do not need an sh_info value. */
6355 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6356 i
, section
->sh_info
);
6362 case SHT_SYMTAB_SHNDX
:
6363 case SHT_INIT_ARRAY
:
6364 case SHT_FINI_ARRAY
:
6365 case SHT_PREINIT_ARRAY
:
6366 if (section
->sh_info
!= 0)
6367 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6368 i
, section
->sh_info
);
6374 /* A symbol index - we assume that it is valid. */
6378 /* FIXME: Add support for target specific section types. */
6379 if (section
->sh_type
== SHT_NOBITS
)
6380 /* NOBITS section headers with non-zero sh_info fields can be
6381 created when a binary is stripped of everything but its debug
6382 information. The stripped sections have their headers
6383 preserved but their types set to SHT_NOBITS. So do not check
6384 this type of section. */
6386 else if (section
->sh_flags
& SHF_INFO_LINK
)
6388 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6389 warn (_("[%2u]: Expected link to another section in info field"), i
);
6391 else if (section
->sh_type
< SHT_LOOS
6392 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6393 && section
->sh_info
!= 0)
6394 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6395 i
, section
->sh_info
);
6399 /* Check the sh_size field. */
6400 if (section
->sh_size
> filedata
->file_size
6401 && section
->sh_type
!= SHT_NOBITS
6402 && section
->sh_type
!= SHT_NULL
6403 && section
->sh_type
< SHT_LOOS
)
6404 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6406 printf (" [%2u] ", i
);
6407 if (do_section_details
)
6408 printf ("%s\n ", printable_section_name (filedata
, section
));
6410 print_symbol (-17, SECTION_NAME (section
));
6412 printf (do_wide
? " %-15s " : " %-15.15s ",
6413 get_section_type_name (filedata
, section
->sh_type
));
6417 const char * link_too_big
= NULL
;
6419 print_vma (section
->sh_addr
, LONG_HEX
);
6421 printf ( " %6.6lx %6.6lx %2.2lx",
6422 (unsigned long) section
->sh_offset
,
6423 (unsigned long) section
->sh_size
,
6424 (unsigned long) section
->sh_entsize
);
6426 if (do_section_details
)
6427 fputs (" ", stdout
);
6429 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6431 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6434 /* The sh_link value is out of range. Normally this indicates
6435 an error but it can have special values in Solaris binaries. */
6436 switch (filedata
->file_header
.e_machine
)
6443 case EM_OLD_SPARCV9
:
6444 case EM_SPARC32PLUS
:
6447 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6448 link_too_big
= "BEFORE";
6449 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6450 link_too_big
= "AFTER";
6457 if (do_section_details
)
6459 if (link_too_big
!= NULL
&& * link_too_big
)
6460 printf ("<%s> ", link_too_big
);
6462 printf ("%2u ", section
->sh_link
);
6463 printf ("%3u %2lu\n", section
->sh_info
,
6464 (unsigned long) section
->sh_addralign
);
6467 printf ("%2u %3u %2lu\n",
6470 (unsigned long) section
->sh_addralign
);
6472 if (link_too_big
&& ! * link_too_big
)
6473 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6474 i
, section
->sh_link
);
6478 print_vma (section
->sh_addr
, LONG_HEX
);
6480 if ((long) section
->sh_offset
== section
->sh_offset
)
6481 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6485 print_vma (section
->sh_offset
, LONG_HEX
);
6488 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6489 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6493 print_vma (section
->sh_size
, LONG_HEX
);
6496 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6497 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6501 print_vma (section
->sh_entsize
, LONG_HEX
);
6504 if (do_section_details
)
6505 fputs (" ", stdout
);
6507 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6509 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6511 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6512 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6515 print_vma (section
->sh_addralign
, DEC
);
6519 else if (do_section_details
)
6522 print_vma (section
->sh_addr
, LONG_HEX
);
6523 if ((long) section
->sh_offset
== section
->sh_offset
)
6524 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6528 print_vma (section
->sh_offset
, LONG_HEX
);
6530 printf (" %u\n ", section
->sh_link
);
6531 print_vma (section
->sh_size
, LONG_HEX
);
6533 print_vma (section
->sh_entsize
, LONG_HEX
);
6535 printf (" %-16u %lu\n",
6537 (unsigned long) section
->sh_addralign
);
6542 print_vma (section
->sh_addr
, LONG_HEX
);
6543 if ((long) section
->sh_offset
== section
->sh_offset
)
6544 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6548 print_vma (section
->sh_offset
, LONG_HEX
);
6551 print_vma (section
->sh_size
, LONG_HEX
);
6553 print_vma (section
->sh_entsize
, LONG_HEX
);
6555 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6557 printf (" %2u %3u %lu\n",
6560 (unsigned long) section
->sh_addralign
);
6563 if (do_section_details
)
6565 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6566 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6568 /* Minimum section size is 12 bytes for 32-bit compression
6569 header + 12 bytes for compressed data header. */
6570 unsigned char buf
[24];
6572 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6573 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6574 sizeof (buf
), _("compression header")))
6576 Elf_Internal_Chdr chdr
;
6578 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6580 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6583 printf (_(" [<unknown>: 0x%x], "),
6585 print_vma (chdr
.ch_size
, LONG_HEX
);
6586 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6592 if (!do_section_details
)
6594 /* The ordering of the letters shown here matches the ordering of the
6595 corresponding SHF_xxx values, and hence the order in which these
6596 letters will be displayed to the user. */
6597 printf (_("Key to Flags:\n\
6598 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6599 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6600 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6601 if (filedata
->file_header
.e_machine
== EM_X86_64
6602 || filedata
->file_header
.e_machine
== EM_L1OM
6603 || filedata
->file_header
.e_machine
== EM_K1OM
)
6604 printf (_("l (large), "));
6605 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6606 printf (_("y (purecode), "));
6607 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6608 printf (_("v (VLE), "));
6609 printf ("p (processor specific)\n");
6616 get_group_flags (unsigned int flags
)
6618 static char buff
[128];
6622 else if (flags
== GRP_COMDAT
)
6625 snprintf (buff
, 14, _("[0x%x: "), flags
);
6627 flags
&= ~ GRP_COMDAT
;
6628 if (flags
& GRP_MASKOS
)
6630 strcat (buff
, "<OS specific>");
6631 flags
&= ~ GRP_MASKOS
;
6634 if (flags
& GRP_MASKPROC
)
6636 strcat (buff
, "<PROC specific>");
6637 flags
&= ~ GRP_MASKPROC
;
6641 strcat (buff
, "<unknown>");
6648 process_section_groups (Filedata
* filedata
)
6650 Elf_Internal_Shdr
* section
;
6652 struct group
* group
;
6653 Elf_Internal_Shdr
* symtab_sec
;
6654 Elf_Internal_Shdr
* strtab_sec
;
6655 Elf_Internal_Sym
* symtab
;
6656 unsigned long num_syms
;
6660 /* Don't process section groups unless needed. */
6661 if (!do_unwind
&& !do_section_groups
)
6664 if (filedata
->file_header
.e_shnum
== 0)
6666 if (do_section_groups
)
6667 printf (_("\nThere are no sections to group in this file.\n"));
6672 if (filedata
->section_headers
== NULL
)
6674 error (_("Section headers are not available!\n"));
6675 /* PR 13622: This can happen with a corrupt ELF header. */
6679 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6680 sizeof (struct group
*));
6682 if (section_headers_groups
== NULL
)
6684 error (_("Out of memory reading %u section group headers\n"),
6685 filedata
->file_header
.e_shnum
);
6689 /* Scan the sections for the group section. */
6691 for (i
= 0, section
= filedata
->section_headers
;
6692 i
< filedata
->file_header
.e_shnum
;
6694 if (section
->sh_type
== SHT_GROUP
)
6697 if (group_count
== 0)
6699 if (do_section_groups
)
6700 printf (_("\nThere are no section groups in this file.\n"));
6705 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6707 if (section_groups
== NULL
)
6709 error (_("Out of memory reading %lu groups\n"),
6710 (unsigned long) group_count
);
6720 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6721 i
< filedata
->file_header
.e_shnum
;
6724 if (section
->sh_type
== SHT_GROUP
)
6726 const char * name
= printable_section_name (filedata
, section
);
6727 const char * group_name
;
6728 unsigned char * start
;
6729 unsigned char * indices
;
6730 unsigned int entry
, j
, size
;
6731 Elf_Internal_Shdr
* sec
;
6732 Elf_Internal_Sym
* sym
;
6734 /* Get the symbol table. */
6735 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6736 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6739 error (_("Bad sh_link in group section `%s'\n"), name
);
6743 if (symtab_sec
!= sec
)
6748 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6753 error (_("Corrupt header in group section `%s'\n"), name
);
6757 if (section
->sh_info
>= num_syms
)
6759 error (_("Bad sh_info in group section `%s'\n"), name
);
6763 sym
= symtab
+ section
->sh_info
;
6765 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6767 if (sym
->st_shndx
== 0
6768 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6770 error (_("Bad sh_info in group section `%s'\n"), name
);
6774 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6783 /* Get the string table. */
6784 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6793 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6799 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6800 1, strtab_sec
->sh_size
,
6802 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6804 group_name
= sym
->st_name
< strtab_size
6805 ? strtab
+ sym
->st_name
: _("<corrupt>");
6808 /* PR 17531: file: loop. */
6809 if (section
->sh_entsize
> section
->sh_size
)
6811 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6812 printable_section_name (filedata
, section
),
6813 (unsigned long) section
->sh_entsize
,
6814 (unsigned long) section
->sh_size
);
6818 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6819 1, section
->sh_size
,
6825 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6826 entry
= byte_get (indices
, 4);
6829 if (do_section_groups
)
6831 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6832 get_group_flags (entry
), i
, name
, group_name
, size
);
6834 printf (_(" [Index] Name\n"));
6837 group
->group_index
= i
;
6839 for (j
= 0; j
< size
; j
++)
6841 struct group_list
* g
;
6843 entry
= byte_get (indices
, 4);
6846 if (entry
>= filedata
->file_header
.e_shnum
)
6848 static unsigned num_group_errors
= 0;
6850 if (num_group_errors
++ < 10)
6852 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6853 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6854 if (num_group_errors
== 10)
6855 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6860 if (section_headers_groups
[entry
] != NULL
)
6864 static unsigned num_errs
= 0;
6866 if (num_errs
++ < 10)
6868 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6870 section_headers_groups
[entry
]->group_index
);
6872 warn (_("Further error messages about already contained group sections suppressed\n"));
6878 /* Intel C/C++ compiler may put section 0 in a
6879 section group. We just warn it the first time
6880 and ignore it afterwards. */
6881 static bfd_boolean warned
= FALSE
;
6884 error (_("section 0 in group section [%5u]\n"),
6885 section_headers_groups
[entry
]->group_index
);
6891 section_headers_groups
[entry
] = group
;
6893 if (do_section_groups
)
6895 sec
= filedata
->section_headers
+ entry
;
6896 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6899 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6900 g
->section_index
= entry
;
6901 g
->next
= group
->root
;
6919 /* Data used to display dynamic fixups. */
6921 struct ia64_vms_dynfixup
6923 bfd_vma needed_ident
; /* Library ident number. */
6924 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6925 bfd_vma fixup_needed
; /* Index of the library. */
6926 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6927 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6930 /* Data used to display dynamic relocations. */
6932 struct ia64_vms_dynimgrela
6934 bfd_vma img_rela_cnt
; /* Number of relocations. */
6935 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6938 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6942 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6943 struct ia64_vms_dynfixup
* fixup
,
6944 const char * strtab
,
6945 unsigned int strtab_sz
)
6947 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6949 const char * lib_name
;
6951 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6952 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6953 _("dynamic section image fixups"));
6957 if (fixup
->needed
< strtab_sz
)
6958 lib_name
= strtab
+ fixup
->needed
;
6961 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6962 (unsigned long) fixup
->needed
);
6965 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6966 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6968 (_("Seg Offset Type SymVec DataType\n"));
6970 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6975 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6976 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6977 type
= BYTE_GET (imfs
[i
].type
);
6978 rtype
= elf_ia64_reloc_type (type
);
6980 printf (" 0x%08x ", type
);
6982 printf (" %-32s ", rtype
);
6983 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6984 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6991 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6994 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
6996 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6999 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7000 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7001 _("dynamic section image relocations"));
7005 printf (_("\nImage relocs\n"));
7007 (_("Seg Offset Type Addend Seg Sym Off\n"));
7009 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7014 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7015 printf ("%08" BFD_VMA_FMT
"x ",
7016 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7017 type
= BYTE_GET (imrs
[i
].type
);
7018 rtype
= elf_ia64_reloc_type (type
);
7020 printf ("0x%08x ", type
);
7022 printf ("%-31s ", rtype
);
7023 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7024 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7025 printf ("%08" BFD_VMA_FMT
"x\n",
7026 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7033 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7036 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7038 struct ia64_vms_dynfixup fixup
;
7039 struct ia64_vms_dynimgrela imgrela
;
7040 Elf_Internal_Dyn
*entry
;
7041 bfd_vma strtab_off
= 0;
7042 bfd_vma strtab_sz
= 0;
7043 char *strtab
= NULL
;
7044 bfd_boolean res
= TRUE
;
7046 memset (&fixup
, 0, sizeof (fixup
));
7047 memset (&imgrela
, 0, sizeof (imgrela
));
7049 /* Note: the order of the entries is specified by the OpenVMS specs. */
7050 for (entry
= dynamic_section
;
7051 entry
< dynamic_section
+ dynamic_nent
;
7054 switch (entry
->d_tag
)
7056 case DT_IA_64_VMS_STRTAB_OFFSET
:
7057 strtab_off
= entry
->d_un
.d_val
;
7060 strtab_sz
= entry
->d_un
.d_val
;
7062 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7063 1, strtab_sz
, _("dynamic string section"));
7066 case DT_IA_64_VMS_NEEDED_IDENT
:
7067 fixup
.needed_ident
= entry
->d_un
.d_val
;
7070 fixup
.needed
= entry
->d_un
.d_val
;
7072 case DT_IA_64_VMS_FIXUP_NEEDED
:
7073 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7075 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7076 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7078 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7079 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7080 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7083 case DT_IA_64_VMS_IMG_RELA_CNT
:
7084 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7086 case DT_IA_64_VMS_IMG_RELA_OFF
:
7087 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7088 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7110 dynamic_relocations
[] =
7112 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7113 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7114 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7117 /* Process the reloc section. */
7120 process_relocs (Filedata
* filedata
)
7122 unsigned long rel_size
;
7123 unsigned long rel_offset
;
7128 if (do_using_dynamic
)
7132 bfd_boolean has_dynamic_reloc
;
7135 has_dynamic_reloc
= FALSE
;
7137 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7139 is_rela
= dynamic_relocations
[i
].rela
;
7140 name
= dynamic_relocations
[i
].name
;
7141 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7142 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7145 has_dynamic_reloc
= TRUE
;
7147 if (is_rela
== UNKNOWN
)
7149 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7150 switch (dynamic_info
[DT_PLTREL
])
7164 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7165 name
, rel_offset
, rel_size
);
7167 dump_relocations (filedata
,
7168 offset_from_vma (filedata
, rel_offset
, rel_size
),
7170 dynamic_symbols
, num_dynamic_syms
,
7171 dynamic_strings
, dynamic_strings_length
,
7172 is_rela
, TRUE
/* is_dynamic */);
7176 if (is_ia64_vms (filedata
))
7177 if (process_ia64_vms_dynamic_relocs (filedata
))
7178 has_dynamic_reloc
= TRUE
;
7180 if (! has_dynamic_reloc
)
7181 printf (_("\nThere are no dynamic relocations in this file.\n"));
7185 Elf_Internal_Shdr
* section
;
7187 bfd_boolean found
= FALSE
;
7189 for (i
= 0, section
= filedata
->section_headers
;
7190 i
< filedata
->file_header
.e_shnum
;
7193 if ( section
->sh_type
!= SHT_RELA
7194 && section
->sh_type
!= SHT_REL
)
7197 rel_offset
= section
->sh_offset
;
7198 rel_size
= section
->sh_size
;
7202 Elf_Internal_Shdr
* strsec
;
7204 unsigned long num_rela
;
7206 printf (_("\nRelocation section "));
7208 if (filedata
->string_table
== NULL
)
7209 printf ("%d", section
->sh_name
);
7211 printf ("'%s'", printable_section_name (filedata
, section
));
7213 num_rela
= rel_size
/ section
->sh_entsize
;
7214 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7215 " at offset 0x%lx contains %lu entries:\n",
7217 rel_offset
, num_rela
);
7219 is_rela
= section
->sh_type
== SHT_RELA
;
7221 if (section
->sh_link
!= 0
7222 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7224 Elf_Internal_Shdr
* symsec
;
7225 Elf_Internal_Sym
* symtab
;
7226 unsigned long nsyms
;
7227 unsigned long strtablen
= 0;
7228 char * strtab
= NULL
;
7230 symsec
= filedata
->section_headers
+ section
->sh_link
;
7231 if (symsec
->sh_type
!= SHT_SYMTAB
7232 && symsec
->sh_type
!= SHT_DYNSYM
)
7235 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7240 if (symsec
->sh_link
!= 0
7241 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7243 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7245 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7248 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7251 dump_relocations (filedata
, rel_offset
, rel_size
,
7252 symtab
, nsyms
, strtab
, strtablen
,
7254 symsec
->sh_type
== SHT_DYNSYM
);
7260 dump_relocations (filedata
, rel_offset
, rel_size
,
7261 NULL
, 0, NULL
, 0, is_rela
,
7262 FALSE
/* is_dynamic */);
7270 /* Users sometimes forget the -D option, so try to be helpful. */
7271 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7273 if (dynamic_info
[dynamic_relocations
[i
].size
])
7275 printf (_("\nThere are no static relocations in this file."));
7276 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7281 if (i
== ARRAY_SIZE (dynamic_relocations
))
7282 printf (_("\nThere are no relocations in this file.\n"));
7289 /* An absolute address consists of a section and an offset. If the
7290 section is NULL, the offset itself is the address, otherwise, the
7291 address equals to LOAD_ADDRESS(section) + offset. */
7295 unsigned short section
;
7299 #define ABSADDR(a) \
7301 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7304 /* Find the nearest symbol at or below ADDR. Returns the symbol
7305 name, if found, and the offset from the symbol to ADDR. */
7308 find_symbol_for_address (Filedata
* filedata
,
7309 Elf_Internal_Sym
* symtab
,
7310 unsigned long nsyms
,
7311 const char * strtab
,
7312 unsigned long strtab_size
,
7313 struct absaddr addr
,
7314 const char ** symname
,
7317 bfd_vma dist
= 0x100000;
7318 Elf_Internal_Sym
* sym
;
7319 Elf_Internal_Sym
* beg
;
7320 Elf_Internal_Sym
* end
;
7321 Elf_Internal_Sym
* best
= NULL
;
7323 REMOVE_ARCH_BITS (addr
.offset
);
7325 end
= symtab
+ nsyms
;
7331 sym
= beg
+ (end
- beg
) / 2;
7333 value
= sym
->st_value
;
7334 REMOVE_ARCH_BITS (value
);
7336 if (sym
->st_name
!= 0
7337 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7338 && addr
.offset
>= value
7339 && addr
.offset
- value
< dist
)
7342 dist
= addr
.offset
- value
;
7347 if (addr
.offset
< value
)
7355 *symname
= (best
->st_name
>= strtab_size
7356 ? _("<corrupt>") : strtab
+ best
->st_name
);
7362 *offset
= addr
.offset
;
7365 static /* signed */ int
7366 symcmp (const void *p
, const void *q
)
7368 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7369 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7371 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7374 /* Process the unwind section. */
7376 #include "unwind-ia64.h"
7378 struct ia64_unw_table_entry
7380 struct absaddr start
;
7382 struct absaddr info
;
7385 struct ia64_unw_aux_info
7387 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7388 unsigned long table_len
; /* Length of unwind table. */
7389 unsigned char * info
; /* Unwind info. */
7390 unsigned long info_size
; /* Size of unwind info. */
7391 bfd_vma info_addr
; /* Starting address of unwind info. */
7392 bfd_vma seg_base
; /* Starting address of segment. */
7393 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7394 unsigned long nsyms
; /* Number of symbols. */
7395 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7396 unsigned long nfuns
; /* Number of entries in funtab. */
7397 char * strtab
; /* The string table. */
7398 unsigned long strtab_size
; /* Size of string table. */
7402 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7404 struct ia64_unw_table_entry
* tp
;
7405 unsigned long j
, nfuns
;
7407 bfd_boolean res
= TRUE
;
7409 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7410 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7411 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7412 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7414 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7416 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7420 const unsigned char * dp
;
7421 const unsigned char * head
;
7422 const unsigned char * end
;
7423 const char * procname
;
7425 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7426 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7428 fputs ("\n<", stdout
);
7432 fputs (procname
, stdout
);
7435 printf ("+%lx", (unsigned long) offset
);
7438 fputs (">: [", stdout
);
7439 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7440 fputc ('-', stdout
);
7441 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7442 printf ("], info at +0x%lx\n",
7443 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7445 /* PR 17531: file: 86232b32. */
7446 if (aux
->info
== NULL
)
7449 /* PR 17531: file: 0997b4d1. */
7450 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7452 warn (_("Invalid offset %lx in table entry %ld\n"),
7453 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7458 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7459 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7461 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7462 (unsigned) UNW_VER (stamp
),
7463 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7464 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7465 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7466 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7468 if (UNW_VER (stamp
) != 1)
7470 printf (_("\tUnknown version.\n"));
7475 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7476 /* PR 17531: file: 16ceda89. */
7477 if (end
> aux
->info
+ aux
->info_size
)
7478 end
= aux
->info
+ aux
->info_size
;
7479 for (dp
= head
+ 8; dp
< end
;)
7480 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7489 slurp_ia64_unwind_table (Filedata
* filedata
,
7490 struct ia64_unw_aux_info
* aux
,
7491 Elf_Internal_Shdr
* sec
)
7493 unsigned long size
, nrelas
, i
;
7494 Elf_Internal_Phdr
* seg
;
7495 struct ia64_unw_table_entry
* tep
;
7496 Elf_Internal_Shdr
* relsec
;
7497 Elf_Internal_Rela
* rela
;
7498 Elf_Internal_Rela
* rp
;
7499 unsigned char * table
;
7501 Elf_Internal_Sym
* sym
;
7502 const char * relname
;
7506 /* First, find the starting address of the segment that includes
7509 if (filedata
->file_header
.e_phnum
)
7511 if (! get_program_headers (filedata
))
7514 for (seg
= filedata
->program_headers
;
7515 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7518 if (seg
->p_type
!= PT_LOAD
)
7521 if (sec
->sh_addr
>= seg
->p_vaddr
7522 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7524 aux
->seg_base
= seg
->p_vaddr
;
7530 /* Second, build the unwind table from the contents of the unwind section: */
7531 size
= sec
->sh_size
;
7532 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7537 aux
->table_len
= size
/ (3 * eh_addr_size
);
7538 aux
->table
= (struct ia64_unw_table_entry
*)
7539 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7542 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7544 tep
->start
.section
= SHN_UNDEF
;
7545 tep
->end
.section
= SHN_UNDEF
;
7546 tep
->info
.section
= SHN_UNDEF
;
7547 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7548 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7549 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7550 tep
->start
.offset
+= aux
->seg_base
;
7551 tep
->end
.offset
+= aux
->seg_base
;
7552 tep
->info
.offset
+= aux
->seg_base
;
7556 /* Third, apply any relocations to the unwind table: */
7557 for (relsec
= filedata
->section_headers
;
7558 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7561 if (relsec
->sh_type
!= SHT_RELA
7562 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7563 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7566 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7575 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7577 relname
= elf_ia64_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7578 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7580 /* PR 17531: file: 9fa67536. */
7581 if (relname
== NULL
)
7583 warn (_("Skipping unknown relocation type: %u\n"),
7584 get_reloc_type (filedata
, rp
->r_info
));
7588 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7590 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7594 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7596 /* PR 17531: file: 5bc8d9bf. */
7597 if (i
>= aux
->table_len
)
7599 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7603 switch (rp
->r_offset
/ eh_addr_size
% 3)
7606 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7607 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7610 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7611 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7614 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7615 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7629 ia64_process_unwind (Filedata
* filedata
)
7631 Elf_Internal_Shdr
* sec
;
7632 Elf_Internal_Shdr
* unwsec
= NULL
;
7633 Elf_Internal_Shdr
* strsec
;
7634 unsigned long i
, unwcount
= 0, unwstart
= 0;
7635 struct ia64_unw_aux_info aux
;
7636 bfd_boolean res
= TRUE
;
7638 memset (& aux
, 0, sizeof (aux
));
7640 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7642 if (sec
->sh_type
== SHT_SYMTAB
7643 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7645 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7647 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7648 if (aux
.strtab
!= NULL
)
7650 error (_("Multiple auxillary string tables encountered\n"));
7654 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7657 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7659 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7664 printf (_("\nThere are no unwind sections in this file.\n"));
7666 while (unwcount
-- > 0)
7671 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7672 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7673 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7678 /* We have already counted the number of SHT_IA64_UNWIND
7679 sections so the loop above should never fail. */
7680 assert (unwsec
!= NULL
);
7683 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7685 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7687 /* We need to find which section group it is in. */
7688 struct group_list
* g
;
7690 if (section_headers_groups
== NULL
7691 || section_headers_groups
[i
] == NULL
)
7692 i
= filedata
->file_header
.e_shnum
;
7695 g
= section_headers_groups
[i
]->root
;
7697 for (; g
!= NULL
; g
= g
->next
)
7699 sec
= filedata
->section_headers
+ g
->section_index
;
7701 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7706 i
= filedata
->file_header
.e_shnum
;
7709 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7711 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7712 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7713 suffix
= SECTION_NAME (unwsec
) + len
;
7714 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7716 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7717 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7722 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7723 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7724 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7725 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7727 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7728 suffix
= SECTION_NAME (unwsec
) + len
;
7729 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7731 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7732 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7736 if (i
== filedata
->file_header
.e_shnum
)
7738 printf (_("\nCould not find unwind info section for "));
7740 if (filedata
->string_table
== NULL
)
7741 printf ("%d", unwsec
->sh_name
);
7743 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7747 aux
.info_addr
= sec
->sh_addr
;
7748 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7751 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7753 printf (_("\nUnwind section "));
7755 if (filedata
->string_table
== NULL
)
7756 printf ("%d", unwsec
->sh_name
);
7758 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7760 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7761 (unsigned long) unwsec
->sh_offset
,
7762 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7764 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7765 && aux
.table_len
> 0)
7766 dump_ia64_unwind (filedata
, & aux
);
7769 free ((char *) aux
.table
);
7771 free ((char *) aux
.info
);
7780 free ((char *) aux
.strtab
);
7785 struct hppa_unw_table_entry
7787 struct absaddr start
;
7789 unsigned int Cannot_unwind
:1; /* 0 */
7790 unsigned int Millicode
:1; /* 1 */
7791 unsigned int Millicode_save_sr0
:1; /* 2 */
7792 unsigned int Region_description
:2; /* 3..4 */
7793 unsigned int reserved1
:1; /* 5 */
7794 unsigned int Entry_SR
:1; /* 6 */
7795 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7796 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7797 unsigned int Args_stored
:1; /* 16 */
7798 unsigned int Variable_Frame
:1; /* 17 */
7799 unsigned int Separate_Package_Body
:1; /* 18 */
7800 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7801 unsigned int Stack_Overflow_Check
:1; /* 20 */
7802 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7803 unsigned int Ada_Region
:1; /* 22 */
7804 unsigned int cxx_info
:1; /* 23 */
7805 unsigned int cxx_try_catch
:1; /* 24 */
7806 unsigned int sched_entry_seq
:1; /* 25 */
7807 unsigned int reserved2
:1; /* 26 */
7808 unsigned int Save_SP
:1; /* 27 */
7809 unsigned int Save_RP
:1; /* 28 */
7810 unsigned int Save_MRP_in_frame
:1; /* 29 */
7811 unsigned int extn_ptr_defined
:1; /* 30 */
7812 unsigned int Cleanup_defined
:1; /* 31 */
7814 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7815 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7816 unsigned int Large_frame
:1; /* 2 */
7817 unsigned int Pseudo_SP_Set
:1; /* 3 */
7818 unsigned int reserved4
:1; /* 4 */
7819 unsigned int Total_frame_size
:27; /* 5..31 */
7822 struct hppa_unw_aux_info
7824 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7825 unsigned long table_len
; /* Length of unwind table. */
7826 bfd_vma seg_base
; /* Starting address of segment. */
7827 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7828 unsigned long nsyms
; /* Number of symbols. */
7829 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7830 unsigned long nfuns
; /* Number of entries in funtab. */
7831 char * strtab
; /* The string table. */
7832 unsigned long strtab_size
; /* Size of string table. */
7836 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7838 struct hppa_unw_table_entry
* tp
;
7839 unsigned long j
, nfuns
;
7840 bfd_boolean res
= TRUE
;
7842 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7843 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7844 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7845 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7847 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7849 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7852 const char * procname
;
7854 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7855 aux
->strtab_size
, tp
->start
, &procname
,
7858 fputs ("\n<", stdout
);
7862 fputs (procname
, stdout
);
7865 printf ("+%lx", (unsigned long) offset
);
7868 fputs (">: [", stdout
);
7869 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7870 fputc ('-', stdout
);
7871 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7874 #define PF(_m) if (tp->_m) printf (#_m " ");
7875 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7878 PF(Millicode_save_sr0
);
7879 /* PV(Region_description); */
7885 PF(Separate_Package_Body
);
7886 PF(Frame_Extension_Millicode
);
7887 PF(Stack_Overflow_Check
);
7888 PF(Two_Instruction_SP_Increment
);
7892 PF(sched_entry_seq
);
7895 PF(Save_MRP_in_frame
);
7896 PF(extn_ptr_defined
);
7897 PF(Cleanup_defined
);
7898 PF(MPE_XL_interrupt_marker
);
7899 PF(HP_UX_interrupt_marker
);
7902 PV(Total_frame_size
);
7915 slurp_hppa_unwind_table (Filedata
* filedata
,
7916 struct hppa_unw_aux_info
* aux
,
7917 Elf_Internal_Shdr
* sec
)
7919 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7920 Elf_Internal_Phdr
* seg
;
7921 struct hppa_unw_table_entry
* tep
;
7922 Elf_Internal_Shdr
* relsec
;
7923 Elf_Internal_Rela
* rela
;
7924 Elf_Internal_Rela
* rp
;
7925 unsigned char * table
;
7927 Elf_Internal_Sym
* sym
;
7928 const char * relname
;
7930 /* First, find the starting address of the segment that includes
7932 if (filedata
->file_header
.e_phnum
)
7934 if (! get_program_headers (filedata
))
7937 for (seg
= filedata
->program_headers
;
7938 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7941 if (seg
->p_type
!= PT_LOAD
)
7944 if (sec
->sh_addr
>= seg
->p_vaddr
7945 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7947 aux
->seg_base
= seg
->p_vaddr
;
7953 /* Second, build the unwind table from the contents of the unwind
7955 size
= sec
->sh_size
;
7956 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7962 nentries
= size
/ unw_ent_size
;
7963 size
= unw_ent_size
* nentries
;
7965 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7966 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7968 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7970 unsigned int tmp1
, tmp2
;
7972 tep
->start
.section
= SHN_UNDEF
;
7973 tep
->end
.section
= SHN_UNDEF
;
7975 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7976 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7977 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7978 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7980 tep
->start
.offset
+= aux
->seg_base
;
7981 tep
->end
.offset
+= aux
->seg_base
;
7983 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7984 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7985 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7986 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7987 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7988 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7989 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7990 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7991 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7992 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7993 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7994 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7995 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7996 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7997 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7998 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7999 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8000 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8001 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8002 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8003 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8004 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8005 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8006 tep
->Cleanup_defined
= tmp1
& 0x1;
8008 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8009 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8010 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8011 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8012 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8013 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8017 /* Third, apply any relocations to the unwind table. */
8018 for (relsec
= filedata
->section_headers
;
8019 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8022 if (relsec
->sh_type
!= SHT_RELA
8023 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8024 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8027 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8031 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8033 relname
= elf_hppa_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
8034 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
8036 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8037 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8039 warn (_("Skipping unexpected relocation type %s\n"), relname
);
8043 i
= rp
->r_offset
/ unw_ent_size
;
8045 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
8048 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8049 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8052 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8053 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8063 aux
->table_len
= nentries
;
8069 hppa_process_unwind (Filedata
* filedata
)
8071 struct hppa_unw_aux_info aux
;
8072 Elf_Internal_Shdr
* unwsec
= NULL
;
8073 Elf_Internal_Shdr
* strsec
;
8074 Elf_Internal_Shdr
* sec
;
8076 bfd_boolean res
= TRUE
;
8078 if (filedata
->string_table
== NULL
)
8081 memset (& aux
, 0, sizeof (aux
));
8083 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8085 if (sec
->sh_type
== SHT_SYMTAB
8086 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8088 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8090 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8091 if (aux
.strtab
!= NULL
)
8093 error (_("Multiple auxillary string tables encountered\n"));
8097 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8100 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8102 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8107 printf (_("\nThere are no unwind sections in this file.\n"));
8109 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8111 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8113 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8115 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8116 "contains %lu entry:\n",
8117 "\nUnwind section '%s' at offset 0x%lx "
8118 "contains %lu entries:\n",
8120 printable_section_name (filedata
, sec
),
8121 (unsigned long) sec
->sh_offset
,
8124 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8127 if (aux
.table_len
> 0)
8129 if (! dump_hppa_unwind (filedata
, &aux
))
8134 free ((char *) aux
.table
);
8142 free ((char *) aux
.strtab
);
8149 unsigned char * data
; /* The unwind data. */
8150 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8151 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8152 unsigned long nrelas
; /* The number of relocations. */
8153 unsigned int rel_type
; /* REL or RELA ? */
8154 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8157 struct arm_unw_aux_info
8159 Filedata
* filedata
; /* The file containing the unwind sections. */
8160 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8161 unsigned long nsyms
; /* Number of symbols. */
8162 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8163 unsigned long nfuns
; /* Number of these symbols. */
8164 char * strtab
; /* The file's string table. */
8165 unsigned long strtab_size
; /* Size of string table. */
8169 arm_print_vma_and_name (Filedata
* filedata
,
8170 struct arm_unw_aux_info
* aux
,
8172 struct absaddr addr
)
8174 const char *procname
;
8177 if (addr
.section
== SHN_UNDEF
)
8180 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8181 aux
->strtab_size
, addr
, &procname
,
8184 print_vma (fn
, PREFIX_HEX
);
8188 fputs (" <", stdout
);
8189 fputs (procname
, stdout
);
8192 printf ("+0x%lx", (unsigned long) sym_offset
);
8193 fputc ('>', stdout
);
8200 arm_free_section (struct arm_section
*arm_sec
)
8202 if (arm_sec
->data
!= NULL
)
8203 free (arm_sec
->data
);
8205 if (arm_sec
->rela
!= NULL
)
8206 free (arm_sec
->rela
);
8209 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8210 cached section and install SEC instead.
8211 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8212 and return its valued in * WORDP, relocating if necessary.
8213 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8214 relocation's offset in ADDR.
8215 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8216 into the string table of the symbol associated with the reloc. If no
8217 reloc was applied store -1 there.
8218 5) Return TRUE upon success, FALSE otherwise. */
8221 get_unwind_section_word (Filedata
* filedata
,
8222 struct arm_unw_aux_info
* aux
,
8223 struct arm_section
* arm_sec
,
8224 Elf_Internal_Shdr
* sec
,
8225 bfd_vma word_offset
,
8226 unsigned int * wordp
,
8227 struct absaddr
* addr
,
8230 Elf_Internal_Rela
*rp
;
8231 Elf_Internal_Sym
*sym
;
8232 const char * relname
;
8234 bfd_boolean wrapped
;
8236 if (sec
== NULL
|| arm_sec
== NULL
)
8239 addr
->section
= SHN_UNDEF
;
8242 if (sym_name
!= NULL
)
8243 *sym_name
= (bfd_vma
) -1;
8245 /* If necessary, update the section cache. */
8246 if (sec
!= arm_sec
->sec
)
8248 Elf_Internal_Shdr
*relsec
;
8250 arm_free_section (arm_sec
);
8253 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8254 sec
->sh_size
, _("unwind data"));
8255 arm_sec
->rela
= NULL
;
8256 arm_sec
->nrelas
= 0;
8258 for (relsec
= filedata
->section_headers
;
8259 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8262 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8263 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8264 /* PR 15745: Check the section type as well. */
8265 || (relsec
->sh_type
!= SHT_REL
8266 && relsec
->sh_type
!= SHT_RELA
))
8269 arm_sec
->rel_type
= relsec
->sh_type
;
8270 if (relsec
->sh_type
== SHT_REL
)
8272 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8274 & arm_sec
->rela
, & arm_sec
->nrelas
))
8277 else /* relsec->sh_type == SHT_RELA */
8279 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8281 & arm_sec
->rela
, & arm_sec
->nrelas
))
8287 arm_sec
->next_rela
= arm_sec
->rela
;
8290 /* If there is no unwind data we can do nothing. */
8291 if (arm_sec
->data
== NULL
)
8294 /* If the offset is invalid then fail. */
8295 if (/* PR 21343 *//* PR 18879 */
8297 || word_offset
> (sec
->sh_size
- 4)
8298 || ((bfd_signed_vma
) word_offset
) < 0)
8301 /* Get the word at the required offset. */
8302 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8304 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8305 if (arm_sec
->rela
== NULL
)
8311 /* Look through the relocs to find the one that applies to the provided offset. */
8313 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8315 bfd_vma prelval
, offset
;
8317 if (rp
->r_offset
> word_offset
&& !wrapped
)
8322 if (rp
->r_offset
> word_offset
)
8325 if (rp
->r_offset
& 3)
8327 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8328 (unsigned long) rp
->r_offset
);
8332 if (rp
->r_offset
< word_offset
)
8335 /* PR 17531: file: 027-161405-0.004 */
8336 if (aux
->symtab
== NULL
)
8339 if (arm_sec
->rel_type
== SHT_REL
)
8341 offset
= word
& 0x7fffffff;
8342 if (offset
& 0x40000000)
8343 offset
|= ~ (bfd_vma
) 0x7fffffff;
8345 else if (arm_sec
->rel_type
== SHT_RELA
)
8346 offset
= rp
->r_addend
;
8349 error (_("Unknown section relocation type %d encountered\n"),
8354 /* PR 17531 file: 027-1241568-0.004. */
8355 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8357 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8358 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8362 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8363 offset
+= sym
->st_value
;
8364 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8366 /* Check that we are processing the expected reloc type. */
8367 if (filedata
->file_header
.e_machine
== EM_ARM
)
8369 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8370 if (relname
== NULL
)
8372 warn (_("Skipping unknown ARM relocation type: %d\n"),
8373 (int) ELF32_R_TYPE (rp
->r_info
));
8377 if (streq (relname
, "R_ARM_NONE"))
8380 if (! streq (relname
, "R_ARM_PREL31"))
8382 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8386 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8388 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8389 if (relname
== NULL
)
8391 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8392 (int) ELF32_R_TYPE (rp
->r_info
));
8396 if (streq (relname
, "R_C6000_NONE"))
8399 if (! streq (relname
, "R_C6000_PREL31"))
8401 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8409 /* This function currently only supports ARM and TI unwinders. */
8410 warn (_("Only TI and ARM unwinders are currently supported\n"));
8414 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8415 addr
->section
= sym
->st_shndx
;
8416 addr
->offset
= offset
;
8419 * sym_name
= sym
->st_name
;
8424 arm_sec
->next_rela
= rp
;
8429 static const char *tic6x_unwind_regnames
[16] =
8431 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8432 "A14", "A13", "A12", "A11", "A10",
8433 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8437 decode_tic6x_unwind_regmask (unsigned int mask
)
8441 for (i
= 12; mask
; mask
>>= 1, i
--)
8445 fputs (tic6x_unwind_regnames
[i
], stdout
);
8447 fputs (", ", stdout
);
8453 if (remaining == 0 && more_words) \
8456 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8457 data_offset, & word, & addr, NULL)) \
8463 #define GET_OP(OP) \
8468 (OP) = word >> 24; \
8473 printf (_("[Truncated opcode]\n")); \
8476 printf ("0x%02x ", OP)
8479 decode_arm_unwind_bytecode (Filedata
* filedata
,
8480 struct arm_unw_aux_info
* aux
,
8482 unsigned int remaining
,
8483 unsigned int more_words
,
8484 bfd_vma data_offset
,
8485 Elf_Internal_Shdr
* data_sec
,
8486 struct arm_section
* data_arm_sec
)
8488 struct absaddr addr
;
8489 bfd_boolean res
= TRUE
;
8491 /* Decode the unwinding instructions. */
8494 unsigned int op
, op2
;
8503 printf (" 0x%02x ", op
);
8505 if ((op
& 0xc0) == 0x00)
8507 int offset
= ((op
& 0x3f) << 2) + 4;
8509 printf (" vsp = vsp + %d", offset
);
8511 else if ((op
& 0xc0) == 0x40)
8513 int offset
= ((op
& 0x3f) << 2) + 4;
8515 printf (" vsp = vsp - %d", offset
);
8517 else if ((op
& 0xf0) == 0x80)
8520 if (op
== 0x80 && op2
== 0)
8521 printf (_("Refuse to unwind"));
8524 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8525 bfd_boolean first
= TRUE
;
8529 for (i
= 0; i
< 12; i
++)
8530 if (mask
& (1 << i
))
8536 printf ("r%d", 4 + i
);
8541 else if ((op
& 0xf0) == 0x90)
8543 if (op
== 0x9d || op
== 0x9f)
8544 printf (_(" [Reserved]"));
8546 printf (" vsp = r%d", op
& 0x0f);
8548 else if ((op
& 0xf0) == 0xa0)
8550 int end
= 4 + (op
& 0x07);
8551 bfd_boolean first
= TRUE
;
8555 for (i
= 4; i
<= end
; i
++)
8571 else if (op
== 0xb0)
8572 printf (_(" finish"));
8573 else if (op
== 0xb1)
8576 if (op2
== 0 || (op2
& 0xf0) != 0)
8577 printf (_("[Spare]"));
8580 unsigned int mask
= op2
& 0x0f;
8581 bfd_boolean first
= TRUE
;
8585 for (i
= 0; i
< 12; i
++)
8586 if (mask
& (1 << i
))
8597 else if (op
== 0xb2)
8599 unsigned char buf
[9];
8600 unsigned int i
, len
;
8601 unsigned long offset
;
8603 for (i
= 0; i
< sizeof (buf
); i
++)
8606 if ((buf
[i
] & 0x80) == 0)
8609 if (i
== sizeof (buf
))
8611 error (_("corrupt change to vsp"));
8616 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8617 assert (len
== i
+ 1);
8618 offset
= offset
* 4 + 0x204;
8619 printf ("vsp = vsp + %ld", offset
);
8622 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8624 unsigned int first
, last
;
8631 printf ("pop {D%d", first
);
8633 printf ("-D%d", first
+ last
);
8636 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8638 unsigned int count
= op
& 0x07;
8642 printf ("-D%d", 8 + count
);
8645 else if (op
>= 0xc0 && op
<= 0xc5)
8647 unsigned int count
= op
& 0x07;
8649 printf (" pop {wR10");
8651 printf ("-wR%d", 10 + count
);
8654 else if (op
== 0xc6)
8656 unsigned int first
, last
;
8661 printf ("pop {wR%d", first
);
8663 printf ("-wR%d", first
+ last
);
8666 else if (op
== 0xc7)
8669 if (op2
== 0 || (op2
& 0xf0) != 0)
8670 printf (_("[Spare]"));
8673 unsigned int mask
= op2
& 0x0f;
8674 bfd_boolean first
= TRUE
;
8678 for (i
= 0; i
< 4; i
++)
8679 if (mask
& (1 << i
))
8685 printf ("wCGR%d", i
);
8692 printf (_(" [unsupported opcode]"));
8703 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8704 struct arm_unw_aux_info
* aux
,
8706 unsigned int remaining
,
8707 unsigned int more_words
,
8708 bfd_vma data_offset
,
8709 Elf_Internal_Shdr
* data_sec
,
8710 struct arm_section
* data_arm_sec
)
8712 struct absaddr addr
;
8714 /* Decode the unwinding instructions. */
8717 unsigned int op
, op2
;
8726 printf (" 0x%02x ", op
);
8728 if ((op
& 0xc0) == 0x00)
8730 int offset
= ((op
& 0x3f) << 3) + 8;
8731 printf (" sp = sp + %d", offset
);
8733 else if ((op
& 0xc0) == 0x80)
8736 if (op
== 0x80 && op2
== 0)
8737 printf (_("Refuse to unwind"));
8740 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8742 printf ("pop compact {");
8746 decode_tic6x_unwind_regmask (mask
);
8750 else if ((op
& 0xf0) == 0xc0)
8758 unsigned int offset
;
8762 /* Scan entire instruction first so that GET_OP output is not
8763 interleaved with disassembly. */
8765 for (i
= 0; nregs
< (op
& 0xf); i
++)
8771 regpos
[nregs
].offset
= i
* 2;
8772 regpos
[nregs
].reg
= reg
;
8779 regpos
[nregs
].offset
= i
* 2 + 1;
8780 regpos
[nregs
].reg
= reg
;
8785 printf (_("pop frame {"));
8787 for (i
= i
* 2; i
> 0; i
--)
8789 if (regpos
[reg
].offset
== i
- 1)
8791 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8798 fputs (name
, stdout
);
8805 else if (op
== 0xd0)
8806 printf (" MOV FP, SP");
8807 else if (op
== 0xd1)
8808 printf (" __c6xabi_pop_rts");
8809 else if (op
== 0xd2)
8811 unsigned char buf
[9];
8812 unsigned int i
, len
;
8813 unsigned long offset
;
8815 for (i
= 0; i
< sizeof (buf
); i
++)
8818 if ((buf
[i
] & 0x80) == 0)
8821 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8822 if (i
== sizeof (buf
))
8824 warn (_("Corrupt stack pointer adjustment detected\n"));
8828 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8829 assert (len
== i
+ 1);
8830 offset
= offset
* 8 + 0x408;
8831 printf (_("sp = sp + %ld"), offset
);
8833 else if ((op
& 0xf0) == 0xe0)
8835 if ((op
& 0x0f) == 7)
8838 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8842 printf (_(" [unsupported opcode]"));
8851 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8855 offset
= word
& 0x7fffffff;
8856 if (offset
& 0x40000000)
8857 offset
|= ~ (bfd_vma
) 0x7fffffff;
8859 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8862 return offset
+ where
;
8866 decode_arm_unwind (Filedata
* filedata
,
8867 struct arm_unw_aux_info
* aux
,
8869 unsigned int remaining
,
8870 bfd_vma data_offset
,
8871 Elf_Internal_Shdr
* data_sec
,
8872 struct arm_section
* data_arm_sec
)
8875 unsigned int more_words
= 0;
8876 struct absaddr addr
;
8877 bfd_vma sym_name
= (bfd_vma
) -1;
8878 bfd_boolean res
= TRUE
;
8882 /* Fetch the first word.
8883 Note - when decoding an object file the address extracted
8884 here will always be 0. So we also pass in the sym_name
8885 parameter so that we can find the symbol associated with
8886 the personality routine. */
8887 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8888 & word
, & addr
, & sym_name
))
8894 if ((word
& 0x80000000) == 0)
8896 /* Expand prel31 for personality routine. */
8898 const char *procname
;
8900 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8901 printf (_(" Personality routine: "));
8903 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8904 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8906 procname
= aux
->strtab
+ sym_name
;
8907 print_vma (fn
, PREFIX_HEX
);
8910 fputs (" <", stdout
);
8911 fputs (procname
, stdout
);
8912 fputc ('>', stdout
);
8916 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8917 fputc ('\n', stdout
);
8919 /* The GCC personality routines use the standard compact
8920 encoding, starting with one byte giving the number of
8922 if (procname
!= NULL
8923 && (const_strneq (procname
, "__gcc_personality_v0")
8924 || const_strneq (procname
, "__gxx_personality_v0")
8925 || const_strneq (procname
, "__gcj_personality_v0")
8926 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8933 printf (_(" [Truncated data]\n"));
8936 more_words
= word
>> 24;
8946 /* ARM EHABI Section 6.3:
8948 An exception-handling table entry for the compact model looks like:
8952 1 0 index Data for personalityRoutine[index] */
8954 if (filedata
->file_header
.e_machine
== EM_ARM
8955 && (word
& 0x70000000))
8957 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8961 per_index
= (word
>> 24) & 0x7f;
8962 printf (_(" Compact model index: %d\n"), per_index
);
8969 else if (per_index
< 3)
8971 more_words
= (word
>> 16) & 0xff;
8977 switch (filedata
->file_header
.e_machine
)
8982 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8983 data_offset
, data_sec
, data_arm_sec
))
8988 warn (_("Unknown ARM compact model index encountered\n"));
8989 printf (_(" [reserved]\n"));
8997 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8998 data_offset
, data_sec
, data_arm_sec
))
9001 else if (per_index
< 5)
9003 if (((word
>> 17) & 0x7f) == 0x7f)
9004 printf (_(" Restore stack from frame pointer\n"));
9006 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9007 printf (_(" Registers restored: "));
9009 printf (" (compact) ");
9010 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9012 printf (_(" Return register: %s\n"),
9013 tic6x_unwind_regnames
[word
& 0xf]);
9016 printf (_(" [reserved (%d)]\n"), per_index
);
9020 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9021 filedata
->file_header
.e_machine
);
9025 /* Decode the descriptors. Not implemented. */
9031 dump_arm_unwind (Filedata
* filedata
,
9032 struct arm_unw_aux_info
* aux
,
9033 Elf_Internal_Shdr
* exidx_sec
)
9035 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9036 unsigned int i
, exidx_len
;
9037 unsigned long j
, nfuns
;
9038 bfd_boolean res
= TRUE
;
9040 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9041 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9042 exidx_len
= exidx_sec
->sh_size
/ 8;
9044 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9045 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9046 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9047 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9049 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9051 for (i
= 0; i
< exidx_len
; i
++)
9053 unsigned int exidx_fn
, exidx_entry
;
9054 struct absaddr fn_addr
, entry_addr
;
9057 fputc ('\n', stdout
);
9059 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9060 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9061 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9062 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9065 arm_free_section (& exidx_arm_sec
);
9066 arm_free_section (& extab_arm_sec
);
9070 /* ARM EHABI, Section 5:
9071 An index table entry consists of 2 words.
9072 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9073 if (exidx_fn
& 0x80000000)
9075 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9079 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9081 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9082 fputs (": ", stdout
);
9084 if (exidx_entry
== 1)
9086 print_vma (exidx_entry
, PREFIX_HEX
);
9087 fputs (" [cantunwind]\n", stdout
);
9089 else if (exidx_entry
& 0x80000000)
9091 print_vma (exidx_entry
, PREFIX_HEX
);
9092 fputc ('\n', stdout
);
9093 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9097 bfd_vma table
, table_offset
= 0;
9098 Elf_Internal_Shdr
*table_sec
;
9100 fputs ("@", stdout
);
9101 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9102 print_vma (table
, PREFIX_HEX
);
9105 /* Locate the matching .ARM.extab. */
9106 if (entry_addr
.section
!= SHN_UNDEF
9107 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9109 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9110 table_offset
= entry_addr
.offset
;
9112 if (table_offset
> table_sec
->sh_size
9113 || ((bfd_signed_vma
) table_offset
) < 0)
9115 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9116 (unsigned long) table_offset
,
9117 printable_section_name (filedata
, table_sec
));
9124 table_sec
= find_section_by_address (filedata
, table
);
9125 if (table_sec
!= NULL
)
9126 table_offset
= table
- table_sec
->sh_addr
;
9129 if (table_sec
== NULL
)
9131 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9132 (unsigned long) table
);
9137 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9146 arm_free_section (&exidx_arm_sec
);
9147 arm_free_section (&extab_arm_sec
);
9152 /* Used for both ARM and C6X unwinding tables. */
9155 arm_process_unwind (Filedata
* filedata
)
9157 struct arm_unw_aux_info aux
;
9158 Elf_Internal_Shdr
*unwsec
= NULL
;
9159 Elf_Internal_Shdr
*strsec
;
9160 Elf_Internal_Shdr
*sec
;
9162 unsigned int sec_type
;
9163 bfd_boolean res
= TRUE
;
9165 switch (filedata
->file_header
.e_machine
)
9168 sec_type
= SHT_ARM_EXIDX
;
9172 sec_type
= SHT_C6000_UNWIND
;
9176 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9177 filedata
->file_header
.e_machine
);
9181 if (filedata
->string_table
== NULL
)
9184 memset (& aux
, 0, sizeof (aux
));
9185 aux
.filedata
= filedata
;
9187 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9189 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9191 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9193 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9195 /* PR binutils/17531 file: 011-12666-0.004. */
9196 if (aux
.strtab
!= NULL
)
9198 error (_("Multiple string tables found in file.\n"));
9202 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9203 1, strsec
->sh_size
, _("string table"));
9204 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9206 else if (sec
->sh_type
== sec_type
)
9211 printf (_("\nThere are no unwind sections in this file.\n"));
9213 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9215 if (sec
->sh_type
== sec_type
)
9217 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9218 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9219 "contains %lu entry:\n",
9220 "\nUnwind section '%s' at offset 0x%lx "
9221 "contains %lu entries:\n",
9223 printable_section_name (filedata
, sec
),
9224 (unsigned long) sec
->sh_offset
,
9227 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9235 free ((char *) aux
.strtab
);
9241 process_unwind (Filedata
* filedata
)
9243 struct unwind_handler
9245 unsigned int machtype
;
9246 bfd_boolean (* handler
)(Filedata
*);
9249 { EM_ARM
, arm_process_unwind
},
9250 { EM_IA_64
, ia64_process_unwind
},
9251 { EM_PARISC
, hppa_process_unwind
},
9252 { EM_TI_C6000
, arm_process_unwind
},
9260 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9261 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9262 return handlers
[i
].handler (filedata
);
9264 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9265 get_machine_name (filedata
->file_header
.e_machine
));
9270 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9272 switch (entry
->d_tag
)
9275 if (entry
->d_un
.d_val
== 0)
9279 static const char * opts
[] =
9281 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9282 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9283 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9284 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9288 bfd_boolean first
= TRUE
;
9290 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9291 if (entry
->d_un
.d_val
& (1 << cnt
))
9293 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9299 case DT_MIPS_IVERSION
:
9300 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9301 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9305 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9306 /* Note: coded this way so that there is a single string for translation. */
9307 printf (_("<corrupt: %s>"), buf
);
9311 case DT_MIPS_TIME_STAMP
:
9315 time_t atime
= entry
->d_un
.d_val
;
9317 tmp
= gmtime (&atime
);
9318 /* PR 17531: file: 6accc532. */
9320 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9322 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9323 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9324 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9325 printf (_("Time Stamp: %s"), timebuf
);
9329 case DT_MIPS_RLD_VERSION
:
9330 case DT_MIPS_LOCAL_GOTNO
:
9331 case DT_MIPS_CONFLICTNO
:
9332 case DT_MIPS_LIBLISTNO
:
9333 case DT_MIPS_SYMTABNO
:
9334 case DT_MIPS_UNREFEXTNO
:
9335 case DT_MIPS_HIPAGENO
:
9336 case DT_MIPS_DELTA_CLASS_NO
:
9337 case DT_MIPS_DELTA_INSTANCE_NO
:
9338 case DT_MIPS_DELTA_RELOC_NO
:
9339 case DT_MIPS_DELTA_SYM_NO
:
9340 case DT_MIPS_DELTA_CLASSSYM_NO
:
9341 case DT_MIPS_COMPACT_SIZE
:
9342 print_vma (entry
->d_un
.d_val
, DEC
);
9346 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9352 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9354 switch (entry
->d_tag
)
9356 case DT_HP_DLD_FLAGS
:
9365 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9366 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9367 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9368 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9369 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9370 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9371 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9372 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9373 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9374 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9375 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9376 { DT_HP_GST
, "HP_GST" },
9377 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9378 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9379 { DT_HP_NODELETE
, "HP_NODELETE" },
9380 { DT_HP_GROUP
, "HP_GROUP" },
9381 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9383 bfd_boolean first
= TRUE
;
9385 bfd_vma val
= entry
->d_un
.d_val
;
9387 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9388 if (val
& flags
[cnt
].bit
)
9392 fputs (flags
[cnt
].str
, stdout
);
9394 val
^= flags
[cnt
].bit
;
9397 if (val
!= 0 || first
)
9401 print_vma (val
, HEX
);
9407 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9415 /* VMS vs Unix time offset and factor. */
9417 #define VMS_EPOCH_OFFSET 35067168000000000LL
9418 #define VMS_GRANULARITY_FACTOR 10000000
9420 /* Display a VMS time in a human readable format. */
9423 print_vms_time (bfd_int64_t vmstime
)
9428 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9429 tm
= gmtime (&unxtime
);
9430 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9431 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9432 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9437 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9439 switch (entry
->d_tag
)
9441 case DT_IA_64_PLT_RESERVE
:
9442 /* First 3 slots reserved. */
9443 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9445 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9448 case DT_IA_64_VMS_LINKTIME
:
9450 print_vms_time (entry
->d_un
.d_val
);
9454 case DT_IA_64_VMS_LNKFLAGS
:
9455 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9456 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9457 printf (" CALL_DEBUG");
9458 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9459 printf (" NOP0BUFS");
9460 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9461 printf (" P0IMAGE");
9462 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9463 printf (" MKTHREADS");
9464 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9465 printf (" UPCALLS");
9466 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9468 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9469 printf (" INITIALIZE");
9470 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9472 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9473 printf (" EXE_INIT");
9474 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9475 printf (" TBK_IN_IMG");
9476 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9477 printf (" DBG_IN_IMG");
9478 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9479 printf (" TBK_IN_DSF");
9480 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9481 printf (" DBG_IN_DSF");
9482 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9483 printf (" SIGNATURES");
9484 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9485 printf (" REL_SEG_OFF");
9489 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9496 get_32bit_dynamic_section (Filedata
* filedata
)
9498 Elf32_External_Dyn
* edyn
;
9499 Elf32_External_Dyn
* ext
;
9500 Elf_Internal_Dyn
* entry
;
9502 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9503 dynamic_size
, _("dynamic section"));
9507 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9508 might not have the luxury of section headers. Look for the DT_NULL
9509 terminator to determine the number of entries. */
9510 for (ext
= edyn
, dynamic_nent
= 0;
9511 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9515 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9519 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9521 if (dynamic_section
== NULL
)
9523 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9524 (unsigned long) dynamic_nent
);
9529 for (ext
= edyn
, entry
= dynamic_section
;
9530 entry
< dynamic_section
+ dynamic_nent
;
9533 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9534 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9543 get_64bit_dynamic_section (Filedata
* filedata
)
9545 Elf64_External_Dyn
* edyn
;
9546 Elf64_External_Dyn
* ext
;
9547 Elf_Internal_Dyn
* entry
;
9549 /* Read in the data. */
9550 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9551 dynamic_size
, _("dynamic section"));
9555 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9556 might not have the luxury of section headers. Look for the DT_NULL
9557 terminator to determine the number of entries. */
9558 for (ext
= edyn
, dynamic_nent
= 0;
9559 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9560 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9564 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9568 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9570 if (dynamic_section
== NULL
)
9572 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9573 (unsigned long) dynamic_nent
);
9578 /* Convert from external to internal formats. */
9579 for (ext
= edyn
, entry
= dynamic_section
;
9580 entry
< dynamic_section
+ dynamic_nent
;
9583 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9584 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9593 print_dynamic_flags (bfd_vma flags
)
9595 bfd_boolean first
= TRUE
;
9601 flag
= flags
& - flags
;
9611 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9612 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9613 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9614 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9615 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9616 default: fputs (_("unknown"), stdout
); break;
9622 /* Parse and display the contents of the dynamic section. */
9625 process_dynamic_section (Filedata
* filedata
)
9627 Elf_Internal_Dyn
* entry
;
9629 if (dynamic_size
== 0)
9632 printf (_("\nThere is no dynamic section in this file.\n"));
9639 if (! get_32bit_dynamic_section (filedata
))
9644 if (! get_64bit_dynamic_section (filedata
))
9648 /* Find the appropriate symbol table. */
9649 if (dynamic_symbols
== NULL
)
9651 for (entry
= dynamic_section
;
9652 entry
< dynamic_section
+ dynamic_nent
;
9655 Elf_Internal_Shdr section
;
9657 if (entry
->d_tag
!= DT_SYMTAB
)
9660 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9662 /* Since we do not know how big the symbol table is,
9663 we default to reading in the entire file (!) and
9664 processing that. This is overkill, I know, but it
9666 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9667 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9669 /* See PR 21379 for a reproducer. */
9670 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9674 if (archive_file_offset
!= 0)
9675 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9677 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9680 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9682 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9683 section
.sh_name
= filedata
->string_table_length
;
9685 if (dynamic_symbols
!= NULL
)
9687 error (_("Multiple dynamic symbol table sections found\n"));
9688 free (dynamic_symbols
);
9690 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9691 if (num_dynamic_syms
< 1)
9693 error (_("Unable to determine the number of symbols to load\n"));
9699 /* Similarly find a string table. */
9700 if (dynamic_strings
== NULL
)
9702 for (entry
= dynamic_section
;
9703 entry
< dynamic_section
+ dynamic_nent
;
9706 unsigned long offset
;
9709 if (entry
->d_tag
!= DT_STRTAB
)
9712 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9714 /* Since we do not know how big the string table is,
9715 we default to reading in the entire file (!) and
9716 processing that. This is overkill, I know, but it
9719 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9721 if (archive_file_offset
!= 0)
9722 str_tab_len
= archive_file_size
- offset
;
9724 str_tab_len
= filedata
->file_size
- offset
;
9726 if (str_tab_len
< 1)
9729 (_("Unable to determine the length of the dynamic string table\n"));
9733 if (dynamic_strings
!= NULL
)
9735 error (_("Multiple dynamic string tables found\n"));
9736 free (dynamic_strings
);
9739 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9741 _("dynamic string table"));
9742 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9746 /* And find the syminfo section if available. */
9747 if (dynamic_syminfo
== NULL
)
9749 unsigned long syminsz
= 0;
9751 for (entry
= dynamic_section
;
9752 entry
< dynamic_section
+ dynamic_nent
;
9755 if (entry
->d_tag
== DT_SYMINENT
)
9757 /* Note: these braces are necessary to avoid a syntax
9758 error from the SunOS4 C compiler. */
9759 /* PR binutils/17531: A corrupt file can trigger this test.
9760 So do not use an assert, instead generate an error message. */
9761 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9762 error (_("Bad value (%d) for SYMINENT entry\n"),
9763 (int) entry
->d_un
.d_val
);
9765 else if (entry
->d_tag
== DT_SYMINSZ
)
9766 syminsz
= entry
->d_un
.d_val
;
9767 else if (entry
->d_tag
== DT_SYMINFO
)
9768 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9772 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9774 Elf_External_Syminfo
* extsyminfo
;
9775 Elf_External_Syminfo
* extsym
;
9776 Elf_Internal_Syminfo
* syminfo
;
9778 /* There is a syminfo section. Read the data. */
9779 extsyminfo
= (Elf_External_Syminfo
*)
9780 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9781 _("symbol information"));
9785 if (dynamic_syminfo
!= NULL
)
9787 error (_("Multiple dynamic symbol information sections found\n"));
9788 free (dynamic_syminfo
);
9790 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9791 if (dynamic_syminfo
== NULL
)
9793 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9794 (unsigned long) syminsz
);
9798 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9799 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9800 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9801 ++syminfo
, ++extsym
)
9803 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9804 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9811 if (do_dynamic
&& dynamic_addr
)
9812 printf (ngettext ("\nDynamic section at offset 0x%lx "
9813 "contains %lu entry:\n",
9814 "\nDynamic section at offset 0x%lx "
9815 "contains %lu entries:\n",
9817 dynamic_addr
, (unsigned long) dynamic_nent
);
9819 printf (_(" Tag Type Name/Value\n"));
9821 for (entry
= dynamic_section
;
9822 entry
< dynamic_section
+ dynamic_nent
;
9830 print_vma (entry
->d_tag
, FULL_HEX
);
9831 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9832 printf (" (%s)%*s", dtype
,
9833 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9836 switch (entry
->d_tag
)
9840 print_dynamic_flags (entry
->d_un
.d_val
);
9850 switch (entry
->d_tag
)
9853 printf (_("Auxiliary library"));
9857 printf (_("Filter library"));
9861 printf (_("Configuration file"));
9865 printf (_("Dependency audit library"));
9869 printf (_("Audit library"));
9873 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9874 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9878 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9887 printf (_("Flags:"));
9889 if (entry
->d_un
.d_val
== 0)
9890 printf (_(" None\n"));
9893 unsigned long int val
= entry
->d_un
.d_val
;
9895 if (val
& DTF_1_PARINIT
)
9897 printf (" PARINIT");
9898 val
^= DTF_1_PARINIT
;
9900 if (val
& DTF_1_CONFEXP
)
9902 printf (" CONFEXP");
9903 val
^= DTF_1_CONFEXP
;
9906 printf (" %lx", val
);
9915 printf (_("Flags:"));
9917 if (entry
->d_un
.d_val
== 0)
9918 printf (_(" None\n"));
9921 unsigned long int val
= entry
->d_un
.d_val
;
9923 if (val
& DF_P1_LAZYLOAD
)
9925 printf (" LAZYLOAD");
9926 val
^= DF_P1_LAZYLOAD
;
9928 if (val
& DF_P1_GROUPPERM
)
9930 printf (" GROUPPERM");
9931 val
^= DF_P1_GROUPPERM
;
9934 printf (" %lx", val
);
9943 printf (_("Flags:"));
9944 if (entry
->d_un
.d_val
== 0)
9945 printf (_(" None\n"));
9948 unsigned long int val
= entry
->d_un
.d_val
;
9955 if (val
& DF_1_GLOBAL
)
9960 if (val
& DF_1_GROUP
)
9965 if (val
& DF_1_NODELETE
)
9967 printf (" NODELETE");
9968 val
^= DF_1_NODELETE
;
9970 if (val
& DF_1_LOADFLTR
)
9972 printf (" LOADFLTR");
9973 val
^= DF_1_LOADFLTR
;
9975 if (val
& DF_1_INITFIRST
)
9977 printf (" INITFIRST");
9978 val
^= DF_1_INITFIRST
;
9980 if (val
& DF_1_NOOPEN
)
9985 if (val
& DF_1_ORIGIN
)
9990 if (val
& DF_1_DIRECT
)
9995 if (val
& DF_1_TRANS
)
10000 if (val
& DF_1_INTERPOSE
)
10002 printf (" INTERPOSE");
10003 val
^= DF_1_INTERPOSE
;
10005 if (val
& DF_1_NODEFLIB
)
10007 printf (" NODEFLIB");
10008 val
^= DF_1_NODEFLIB
;
10010 if (val
& DF_1_NODUMP
)
10012 printf (" NODUMP");
10013 val
^= DF_1_NODUMP
;
10015 if (val
& DF_1_CONFALT
)
10017 printf (" CONFALT");
10018 val
^= DF_1_CONFALT
;
10020 if (val
& DF_1_ENDFILTEE
)
10022 printf (" ENDFILTEE");
10023 val
^= DF_1_ENDFILTEE
;
10025 if (val
& DF_1_DISPRELDNE
)
10027 printf (" DISPRELDNE");
10028 val
^= DF_1_DISPRELDNE
;
10030 if (val
& DF_1_DISPRELPND
)
10032 printf (" DISPRELPND");
10033 val
^= DF_1_DISPRELPND
;
10035 if (val
& DF_1_NODIRECT
)
10037 printf (" NODIRECT");
10038 val
^= DF_1_NODIRECT
;
10040 if (val
& DF_1_IGNMULDEF
)
10042 printf (" IGNMULDEF");
10043 val
^= DF_1_IGNMULDEF
;
10045 if (val
& DF_1_NOKSYMS
)
10047 printf (" NOKSYMS");
10048 val
^= DF_1_NOKSYMS
;
10050 if (val
& DF_1_NOHDR
)
10055 if (val
& DF_1_EDITED
)
10057 printf (" EDITED");
10058 val
^= DF_1_EDITED
;
10060 if (val
& DF_1_NORELOC
)
10062 printf (" NORELOC");
10063 val
^= DF_1_NORELOC
;
10065 if (val
& DF_1_SYMINTPOSE
)
10067 printf (" SYMINTPOSE");
10068 val
^= DF_1_SYMINTPOSE
;
10070 if (val
& DF_1_GLOBAUDIT
)
10072 printf (" GLOBAUDIT");
10073 val
^= DF_1_GLOBAUDIT
;
10075 if (val
& DF_1_SINGLETON
)
10077 printf (" SINGLETON");
10078 val
^= DF_1_SINGLETON
;
10080 if (val
& DF_1_STUB
)
10085 if (val
& DF_1_PIE
)
10090 if (val
& DF_1_KMOD
)
10095 if (val
& DF_1_WEAKFILTER
)
10097 printf (" WEAKFILTER");
10098 val
^= DF_1_WEAKFILTER
;
10100 if (val
& DF_1_NOCOMMON
)
10102 printf (" NOCOMMON");
10103 val
^= DF_1_NOCOMMON
;
10106 printf (" %lx", val
);
10113 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10115 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10135 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10141 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10142 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10148 switch (entry
->d_tag
)
10151 printf (_("Shared library: [%s]"), name
);
10153 if (streq (name
, program_interpreter
))
10154 printf (_(" program interpreter"));
10158 printf (_("Library soname: [%s]"), name
);
10162 printf (_("Library rpath: [%s]"), name
);
10166 printf (_("Library runpath: [%s]"), name
);
10170 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10175 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10188 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10189 /* Fall through. */
10193 case DT_INIT_ARRAYSZ
:
10194 case DT_FINI_ARRAYSZ
:
10195 case DT_GNU_CONFLICTSZ
:
10196 case DT_GNU_LIBLISTSZ
:
10199 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10200 printf (_(" (bytes)\n"));
10205 case DT_VERNEEDNUM
:
10210 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10219 case DT_INIT_ARRAY
:
10220 case DT_FINI_ARRAY
:
10223 if (entry
->d_tag
== DT_USED
10224 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10226 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10230 printf (_("Not needed object: [%s]\n"), name
);
10235 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10241 /* The value of this entry is ignored. */
10246 case DT_GNU_PRELINKED
:
10250 time_t atime
= entry
->d_un
.d_val
;
10252 tmp
= gmtime (&atime
);
10253 /* PR 17533 file: 041-1244816-0.004. */
10255 printf (_("<corrupt time val: %lx"),
10256 (unsigned long) atime
);
10258 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10259 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10260 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10266 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10269 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10275 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10276 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10281 switch (filedata
->file_header
.e_machine
)
10284 case EM_MIPS_RS3_LE
:
10285 dynamic_section_mips_val (entry
);
10288 dynamic_section_parisc_val (entry
);
10291 dynamic_section_ia64_val (entry
);
10294 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10306 get_ver_flags (unsigned int flags
)
10308 static char buff
[128];
10315 if (flags
& VER_FLG_BASE
)
10316 strcat (buff
, "BASE");
10318 if (flags
& VER_FLG_WEAK
)
10320 if (flags
& VER_FLG_BASE
)
10321 strcat (buff
, " | ");
10323 strcat (buff
, "WEAK");
10326 if (flags
& VER_FLG_INFO
)
10328 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10329 strcat (buff
, " | ");
10331 strcat (buff
, "INFO");
10334 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10336 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10337 strcat (buff
, " | ");
10339 strcat (buff
, _("<unknown>"));
10345 /* Display the contents of the version sections. */
10348 process_version_sections (Filedata
* filedata
)
10350 Elf_Internal_Shdr
* section
;
10352 bfd_boolean found
= FALSE
;
10357 for (i
= 0, section
= filedata
->section_headers
;
10358 i
< filedata
->file_header
.e_shnum
;
10361 switch (section
->sh_type
)
10363 case SHT_GNU_verdef
:
10365 Elf_External_Verdef
* edefs
;
10372 printf (ngettext ("\nVersion definition section '%s' "
10373 "contains %u entry:\n",
10374 "\nVersion definition section '%s' "
10375 "contains %u entries:\n",
10377 printable_section_name (filedata
, section
),
10380 printf (_(" Addr: 0x"));
10381 printf_vma (section
->sh_addr
);
10382 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10383 (unsigned long) section
->sh_offset
, section
->sh_link
,
10384 printable_section_name_from_index (filedata
, section
->sh_link
));
10386 edefs
= (Elf_External_Verdef
*)
10387 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10388 _("version definition section"));
10391 endbuf
= (char *) edefs
+ section
->sh_size
;
10393 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10396 Elf_External_Verdef
* edef
;
10397 Elf_Internal_Verdef ent
;
10398 Elf_External_Verdaux
* eaux
;
10399 Elf_Internal_Verdaux aux
;
10400 unsigned long isum
;
10403 vstart
= ((char *) edefs
) + idx
;
10404 if (vstart
+ sizeof (*edef
) > endbuf
)
10407 edef
= (Elf_External_Verdef
*) vstart
;
10409 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10410 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10411 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10412 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10413 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10414 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10415 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10417 printf (_(" %#06lx: Rev: %d Flags: %s"),
10418 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10420 printf (_(" Index: %d Cnt: %d "),
10421 ent
.vd_ndx
, ent
.vd_cnt
);
10423 /* Check for overflow. */
10424 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10427 vstart
+= ent
.vd_aux
;
10429 if (vstart
+ sizeof (*eaux
) > endbuf
)
10431 eaux
= (Elf_External_Verdaux
*) vstart
;
10433 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10434 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10436 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10437 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10439 printf (_("Name index: %ld\n"), aux
.vda_name
);
10441 isum
= idx
+ ent
.vd_aux
;
10443 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10445 if (aux
.vda_next
< sizeof (*eaux
)
10446 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10448 warn (_("Invalid vda_next field of %lx\n"),
10453 /* Check for overflow. */
10454 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10457 isum
+= aux
.vda_next
;
10458 vstart
+= aux
.vda_next
;
10460 if (vstart
+ sizeof (*eaux
) > endbuf
)
10462 eaux
= (Elf_External_Verdaux
*) vstart
;
10464 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10465 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10467 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10468 printf (_(" %#06lx: Parent %d: %s\n"),
10469 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10471 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10472 isum
, j
, aux
.vda_name
);
10475 if (j
< ent
.vd_cnt
)
10476 printf (_(" Version def aux past end of section\n"));
10479 file: id:000001,src:000172+005151,op:splice,rep:2. */
10480 if (ent
.vd_next
< sizeof (*edef
)
10481 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10483 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10484 cnt
= section
->sh_info
;
10487 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10490 idx
+= ent
.vd_next
;
10493 if (cnt
< section
->sh_info
)
10494 printf (_(" Version definition past end of section\n"));
10500 case SHT_GNU_verneed
:
10502 Elf_External_Verneed
* eneed
;
10509 printf (ngettext ("\nVersion needs section '%s' "
10510 "contains %u entry:\n",
10511 "\nVersion needs section '%s' "
10512 "contains %u entries:\n",
10514 printable_section_name (filedata
, section
), section
->sh_info
);
10516 printf (_(" Addr: 0x"));
10517 printf_vma (section
->sh_addr
);
10518 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10519 (unsigned long) section
->sh_offset
, section
->sh_link
,
10520 printable_section_name_from_index (filedata
, section
->sh_link
));
10522 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10523 section
->sh_offset
, 1,
10525 _("Version Needs section"));
10528 endbuf
= (char *) eneed
+ section
->sh_size
;
10530 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10532 Elf_External_Verneed
* entry
;
10533 Elf_Internal_Verneed ent
;
10534 unsigned long isum
;
10538 vstart
= ((char *) eneed
) + idx
;
10539 if (vstart
+ sizeof (*entry
) > endbuf
)
10542 entry
= (Elf_External_Verneed
*) vstart
;
10544 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10545 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10546 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10547 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10548 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10550 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10552 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10553 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10555 printf (_(" File: %lx"), ent
.vn_file
);
10557 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10559 /* Check for overflow. */
10560 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10562 vstart
+= ent
.vn_aux
;
10564 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10566 Elf_External_Vernaux
* eaux
;
10567 Elf_Internal_Vernaux aux
;
10569 if (vstart
+ sizeof (*eaux
) > endbuf
)
10571 eaux
= (Elf_External_Vernaux
*) vstart
;
10573 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10574 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10575 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10576 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10577 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10579 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10580 printf (_(" %#06lx: Name: %s"),
10581 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10583 printf (_(" %#06lx: Name index: %lx"),
10584 isum
, aux
.vna_name
);
10586 printf (_(" Flags: %s Version: %d\n"),
10587 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10589 if (aux
.vna_next
< sizeof (*eaux
)
10590 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10592 warn (_("Invalid vna_next field of %lx\n"),
10597 /* Check for overflow. */
10598 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10600 isum
+= aux
.vna_next
;
10601 vstart
+= aux
.vna_next
;
10604 if (j
< ent
.vn_cnt
)
10605 warn (_("Missing Version Needs auxillary information\n"));
10607 if (ent
.vn_next
< sizeof (*entry
)
10608 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10610 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10611 cnt
= section
->sh_info
;
10614 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10616 idx
+= ent
.vn_next
;
10619 if (cnt
< section
->sh_info
)
10620 warn (_("Missing Version Needs information\n"));
10626 case SHT_GNU_versym
:
10628 Elf_Internal_Shdr
* link_section
;
10631 unsigned char * edata
;
10632 unsigned short * data
;
10634 Elf_Internal_Sym
* symbols
;
10635 Elf_Internal_Shdr
* string_sec
;
10636 unsigned long num_syms
;
10639 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10642 link_section
= filedata
->section_headers
+ section
->sh_link
;
10643 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10645 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10650 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10651 if (symbols
== NULL
)
10654 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10656 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10657 string_sec
->sh_size
,
10658 _("version string table"));
10665 printf (ngettext ("\nVersion symbols section '%s' "
10666 "contains %lu entry:\n",
10667 "\nVersion symbols section '%s' "
10668 "contains %lu entries:\n",
10670 printable_section_name (filedata
, section
), (unsigned long) total
);
10672 printf (_(" Addr: "));
10673 printf_vma (section
->sh_addr
);
10674 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10675 (unsigned long) section
->sh_offset
, section
->sh_link
,
10676 printable_section_name (filedata
, link_section
));
10678 off
= offset_from_vma (filedata
,
10679 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10680 total
* sizeof (short));
10681 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10683 _("version symbol data"));
10691 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10693 for (cnt
= total
; cnt
--;)
10694 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10699 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10703 char *invalid
= _("*invalid*");
10705 printf (" %03x:", cnt
);
10707 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10708 switch (data
[cnt
+ j
])
10711 fputs (_(" 0 (*local*) "), stdout
);
10715 fputs (_(" 1 (*global*) "), stdout
);
10719 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10720 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10722 /* If this index value is greater than the size of the symbols
10723 array, break to avoid an out-of-bounds read. */
10724 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10726 warn (_("invalid index into symbol array\n"));
10731 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10733 Elf_Internal_Verneed ivn
;
10734 unsigned long offset
;
10736 offset
= offset_from_vma
10737 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10738 sizeof (Elf_External_Verneed
));
10742 Elf_Internal_Vernaux ivna
;
10743 Elf_External_Verneed evn
;
10744 Elf_External_Vernaux evna
;
10745 unsigned long a_off
;
10747 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10748 _("version need")) == NULL
)
10751 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10752 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10754 a_off
= offset
+ ivn
.vn_aux
;
10758 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10759 1, _("version need aux (2)")) == NULL
)
10762 ivna
.vna_other
= 0;
10766 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10767 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10770 a_off
+= ivna
.vna_next
;
10772 while (ivna
.vna_other
!= data
[cnt
+ j
]
10773 && ivna
.vna_next
!= 0);
10775 if (ivna
.vna_other
== data
[cnt
+ j
])
10777 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10779 if (ivna
.vna_name
>= string_sec
->sh_size
)
10782 name
= strtab
+ ivna
.vna_name
;
10786 offset
+= ivn
.vn_next
;
10788 while (ivn
.vn_next
);
10791 if (data
[cnt
+ j
] != 0x8001
10792 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10794 Elf_Internal_Verdef ivd
;
10795 Elf_External_Verdef evd
;
10796 unsigned long offset
;
10798 offset
= offset_from_vma
10799 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10804 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10805 _("version def")) == NULL
)
10808 /* PR 17531: file: 046-1082287-0.004. */
10809 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10814 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10815 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10818 offset
+= ivd
.vd_next
;
10820 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10821 && ivd
.vd_next
!= 0);
10823 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10825 Elf_External_Verdaux evda
;
10826 Elf_Internal_Verdaux ivda
;
10828 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10830 if (get_data (&evda
, filedata
,
10831 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10833 _("version def aux")) == NULL
)
10836 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10838 if (ivda
.vda_name
>= string_sec
->sh_size
)
10840 else if (name
!= NULL
&& name
!= invalid
)
10841 name
= _("*both*");
10843 name
= strtab
+ ivda
.vda_name
;
10847 nn
+= printf ("(%s%-*s",
10849 12 - (int) strlen (name
),
10853 printf ("%*c", 18 - nn
, ' ');
10871 printf (_("\nNo version information found in this file.\n"));
10876 static const char *
10877 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10879 static char buff
[32];
10883 case STB_LOCAL
: return "LOCAL";
10884 case STB_GLOBAL
: return "GLOBAL";
10885 case STB_WEAK
: return "WEAK";
10887 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10888 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10890 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10892 if (binding
== STB_GNU_UNIQUE
10893 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10894 /* GNU is still using the default value 0. */
10895 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10897 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10900 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10905 static const char *
10906 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10908 static char buff
[32];
10912 case STT_NOTYPE
: return "NOTYPE";
10913 case STT_OBJECT
: return "OBJECT";
10914 case STT_FUNC
: return "FUNC";
10915 case STT_SECTION
: return "SECTION";
10916 case STT_FILE
: return "FILE";
10917 case STT_COMMON
: return "COMMON";
10918 case STT_TLS
: return "TLS";
10919 case STT_RELC
: return "RELC";
10920 case STT_SRELC
: return "SRELC";
10922 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10924 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10925 return "THUMB_FUNC";
10927 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10930 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10931 return "PARISC_MILLI";
10933 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10935 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10937 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10939 if (type
== STT_HP_OPAQUE
)
10940 return "HP_OPAQUE";
10941 if (type
== STT_HP_STUB
)
10945 if (type
== STT_GNU_IFUNC
10946 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10947 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10948 /* GNU is still using the default value 0. */
10949 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10952 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10955 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10960 static const char *
10961 get_symbol_visibility (unsigned int visibility
)
10963 switch (visibility
)
10965 case STV_DEFAULT
: return "DEFAULT";
10966 case STV_INTERNAL
: return "INTERNAL";
10967 case STV_HIDDEN
: return "HIDDEN";
10968 case STV_PROTECTED
: return "PROTECTED";
10970 error (_("Unrecognized visibility value: %u"), visibility
);
10971 return _("<unknown>");
10975 static const char *
10976 get_solaris_symbol_visibility (unsigned int visibility
)
10978 switch (visibility
)
10980 case 4: return "EXPORTED";
10981 case 5: return "SINGLETON";
10982 case 6: return "ELIMINATE";
10983 default: return get_symbol_visibility (visibility
);
10987 static const char *
10988 get_mips_symbol_other (unsigned int other
)
10992 case STO_OPTIONAL
: return "OPTIONAL";
10993 case STO_MIPS_PLT
: return "MIPS PLT";
10994 case STO_MIPS_PIC
: return "MIPS PIC";
10995 case STO_MICROMIPS
: return "MICROMIPS";
10996 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10997 case STO_MIPS16
: return "MIPS16";
10998 default: return NULL
;
11002 static const char *
11003 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11005 if (is_ia64_vms (filedata
))
11007 static char res
[32];
11011 /* Function types is for images and .STB files only. */
11012 switch (filedata
->file_header
.e_type
)
11016 switch (VMS_ST_FUNC_TYPE (other
))
11018 case VMS_SFT_CODE_ADDR
:
11019 strcat (res
, " CA");
11021 case VMS_SFT_SYMV_IDX
:
11022 strcat (res
, " VEC");
11025 strcat (res
, " FD");
11027 case VMS_SFT_RESERVE
:
11028 strcat (res
, " RSV");
11031 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11032 VMS_ST_FUNC_TYPE (other
));
11033 strcat (res
, " <unknown>");
11040 switch (VMS_ST_LINKAGE (other
))
11042 case VMS_STL_IGNORE
:
11043 strcat (res
, " IGN");
11045 case VMS_STL_RESERVE
:
11046 strcat (res
, " RSV");
11049 strcat (res
, " STD");
11052 strcat (res
, " LNK");
11055 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11056 VMS_ST_LINKAGE (other
));
11057 strcat (res
, " <unknown>");
11069 static const char *
11070 get_ppc64_symbol_other (unsigned int other
)
11072 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
11074 static char buf
[32];
11075 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
11076 PPC64_LOCAL_ENTRY_OFFSET (other
));
11082 static const char *
11083 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11085 const char * result
= NULL
;
11086 static char buff
[32];
11091 switch (filedata
->file_header
.e_machine
)
11094 result
= get_mips_symbol_other (other
);
11097 result
= get_ia64_symbol_other (filedata
, other
);
11100 result
= get_ppc64_symbol_other (other
);
11110 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11114 static const char *
11115 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11117 static char buff
[32];
11121 case SHN_UNDEF
: return "UND";
11122 case SHN_ABS
: return "ABS";
11123 case SHN_COMMON
: return "COM";
11125 if (type
== SHN_IA_64_ANSI_COMMON
11126 && filedata
->file_header
.e_machine
== EM_IA_64
11127 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11129 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11130 || filedata
->file_header
.e_machine
== EM_L1OM
11131 || filedata
->file_header
.e_machine
== EM_K1OM
)
11132 && type
== SHN_X86_64_LCOMMON
)
11133 return "LARGE_COM";
11134 else if ((type
== SHN_MIPS_SCOMMON
11135 && filedata
->file_header
.e_machine
== EM_MIPS
)
11136 || (type
== SHN_TIC6X_SCOMMON
11137 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11139 else if (type
== SHN_MIPS_SUNDEFINED
11140 && filedata
->file_header
.e_machine
== EM_MIPS
)
11142 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11143 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11144 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11145 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11146 else if (type
>= SHN_LORESERVE
)
11147 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11148 else if (type
>= filedata
->file_header
.e_shnum
)
11149 sprintf (buff
, _("bad section index[%3d]"), type
);
11151 sprintf (buff
, "%3d", type
);
11159 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11161 unsigned char * e_data
;
11164 /* If the size_t type is smaller than the bfd_size_type, eg because
11165 you are building a 32-bit tool on a 64-bit host, then make sure
11166 that when (number) is cast to (size_t) no information is lost. */
11167 if (sizeof (size_t) < sizeof (bfd_size_type
)
11168 && (bfd_size_type
) ((size_t) number
) != number
)
11170 error (_("Size truncation prevents reading %s elements of size %u\n"),
11171 bfd_vmatoa ("u", number
), ent_size
);
11175 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11176 attempting to allocate memory when the read is bound to fail. */
11177 if (ent_size
* number
> filedata
->file_size
)
11179 error (_("Invalid number of dynamic entries: %s\n"),
11180 bfd_vmatoa ("u", number
));
11184 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11185 if (e_data
== NULL
)
11187 error (_("Out of memory reading %s dynamic entries\n"),
11188 bfd_vmatoa ("u", number
));
11192 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11194 error (_("Unable to read in %s bytes of dynamic data\n"),
11195 bfd_vmatoa ("u", number
* ent_size
));
11200 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11201 if (i_data
== NULL
)
11203 error (_("Out of memory allocating space for %s dynamic entries\n"),
11204 bfd_vmatoa ("u", number
));
11210 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11218 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11220 Elf_Internal_Sym
* psym
;
11223 n
= print_vma (si
, DEC_5
);
11225 fputs (&" "[n
], stdout
);
11226 printf (" %3lu: ", hn
);
11228 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11230 printf (_("<No info available for dynamic symbol number %lu>\n"),
11231 (unsigned long) si
);
11235 psym
= dynamic_symbols
+ si
;
11236 print_vma (psym
->st_value
, LONG_HEX
);
11238 print_vma (psym
->st_size
, DEC_5
);
11240 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11241 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11243 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11244 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11247 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11249 printf (" %-7s", get_symbol_visibility (vis
));
11250 /* Check to see if any other bits in the st_other field are set.
11251 Note - displaying this information disrupts the layout of the
11252 table being generated, but for the moment this case is very
11254 if (psym
->st_other
^ vis
)
11255 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11258 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11259 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11260 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11262 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11266 static const char *
11267 get_symbol_version_string (Filedata
* filedata
,
11268 bfd_boolean is_dynsym
,
11269 const char * strtab
,
11270 unsigned long int strtab_size
,
11272 Elf_Internal_Sym
* psym
,
11273 enum versioned_symbol_info
* sym_info
,
11274 unsigned short * vna_other
)
11276 unsigned char data
[2];
11277 unsigned short vers_data
;
11278 unsigned long offset
;
11281 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11284 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11285 sizeof data
+ si
* sizeof (vers_data
));
11287 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11288 sizeof (data
), 1, _("version data")) == NULL
)
11291 vers_data
= byte_get (data
, 2);
11293 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11296 /* Usually we'd only see verdef for defined symbols, and verneed for
11297 undefined symbols. However, symbols defined by the linker in
11298 .dynbss for variables copied from a shared library in order to
11299 avoid text relocations are defined yet have verneed. We could
11300 use a heuristic to detect the special case, for example, check
11301 for verneed first on symbols defined in SHT_NOBITS sections, but
11302 it is simpler and more reliable to just look for both verdef and
11303 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11305 if (psym
->st_shndx
!= SHN_UNDEF
11306 && vers_data
!= 0x8001
11307 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11309 Elf_Internal_Verdef ivd
;
11310 Elf_Internal_Verdaux ivda
;
11311 Elf_External_Verdaux evda
;
11314 off
= offset_from_vma (filedata
,
11315 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11316 sizeof (Elf_External_Verdef
));
11320 Elf_External_Verdef evd
;
11322 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11323 _("version def")) == NULL
)
11332 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11333 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11334 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11335 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11338 off
+= ivd
.vd_next
;
11340 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11342 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11344 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11347 off
-= ivd
.vd_next
;
11350 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11351 _("version def aux")) != NULL
)
11353 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11355 if (psym
->st_name
!= ivda
.vda_name
)
11357 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11358 ? symbol_hidden
: symbol_public
);
11359 return (ivda
.vda_name
< strtab_size
11360 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11366 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11368 Elf_External_Verneed evn
;
11369 Elf_Internal_Verneed ivn
;
11370 Elf_Internal_Vernaux ivna
;
11372 offset
= offset_from_vma (filedata
,
11373 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11377 unsigned long vna_off
;
11379 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11380 _("version need")) == NULL
)
11383 ivna
.vna_other
= 0;
11388 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11389 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11391 vna_off
= offset
+ ivn
.vn_aux
;
11395 Elf_External_Vernaux evna
;
11397 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11398 _("version need aux (3)")) == NULL
)
11401 ivna
.vna_other
= 0;
11406 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11407 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11408 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11411 vna_off
+= ivna
.vna_next
;
11413 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11415 if (ivna
.vna_other
== vers_data
)
11418 offset
+= ivn
.vn_next
;
11420 while (ivn
.vn_next
!= 0);
11422 if (ivna
.vna_other
== vers_data
)
11424 *sym_info
= symbol_undefined
;
11425 *vna_other
= ivna
.vna_other
;
11426 return (ivna
.vna_name
< strtab_size
11427 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11433 /* Dump the symbol table. */
11435 process_symbol_table (Filedata
* filedata
)
11437 Elf_Internal_Shdr
* section
;
11438 bfd_size_type nbuckets
= 0;
11439 bfd_size_type nchains
= 0;
11440 bfd_vma
* buckets
= NULL
;
11441 bfd_vma
* chains
= NULL
;
11442 bfd_vma ngnubuckets
= 0;
11443 bfd_vma
* gnubuckets
= NULL
;
11444 bfd_vma
* gnuchains
= NULL
;
11445 bfd_vma gnusymidx
= 0;
11446 bfd_size_type ngnuchains
= 0;
11448 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11451 if (dynamic_info
[DT_HASH
]
11453 || (do_using_dynamic
11455 && dynamic_strings
!= NULL
)))
11457 unsigned char nb
[8];
11458 unsigned char nc
[8];
11459 unsigned int hash_ent_size
= 4;
11461 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11462 || filedata
->file_header
.e_machine
== EM_S390
11463 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11464 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11467 if (fseek (filedata
->handle
,
11468 (archive_file_offset
11469 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11470 sizeof nb
+ sizeof nc
)),
11473 error (_("Unable to seek to start of dynamic information\n"));
11477 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11479 error (_("Failed to read in number of buckets\n"));
11483 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11485 error (_("Failed to read in number of chains\n"));
11489 nbuckets
= byte_get (nb
, hash_ent_size
);
11490 nchains
= byte_get (nc
, hash_ent_size
);
11492 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11493 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11496 if (buckets
== NULL
|| chains
== NULL
)
11498 if (do_using_dynamic
)
11509 if (dynamic_info_DT_GNU_HASH
11511 || (do_using_dynamic
11513 && dynamic_strings
!= NULL
)))
11515 unsigned char nb
[16];
11516 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11517 bfd_vma buckets_vma
;
11519 if (fseek (filedata
->handle
,
11520 (archive_file_offset
11521 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11525 error (_("Unable to seek to start of dynamic information\n"));
11529 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11531 error (_("Failed to read in number of buckets\n"));
11535 ngnubuckets
= byte_get (nb
, 4);
11536 gnusymidx
= byte_get (nb
+ 4, 4);
11537 bitmaskwords
= byte_get (nb
+ 8, 4);
11538 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11540 buckets_vma
+= bitmaskwords
* 4;
11542 buckets_vma
+= bitmaskwords
* 8;
11544 if (fseek (filedata
->handle
,
11545 (archive_file_offset
11546 + offset_from_vma (filedata
, buckets_vma
, 4)),
11549 error (_("Unable to seek to start of dynamic information\n"));
11553 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11555 if (gnubuckets
== NULL
)
11558 for (i
= 0; i
< ngnubuckets
; i
++)
11559 if (gnubuckets
[i
] != 0)
11561 if (gnubuckets
[i
] < gnusymidx
)
11564 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11565 maxchain
= gnubuckets
[i
];
11568 if (maxchain
== 0xffffffff)
11571 maxchain
-= gnusymidx
;
11573 if (fseek (filedata
->handle
,
11574 (archive_file_offset
11575 + offset_from_vma (filedata
, buckets_vma
11576 + 4 * (ngnubuckets
+ maxchain
), 4)),
11579 error (_("Unable to seek to start of dynamic information\n"));
11585 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11587 error (_("Failed to determine last chain length\n"));
11591 if (maxchain
+ 1 == 0)
11596 while ((byte_get (nb
, 4) & 1) == 0);
11598 if (fseek (filedata
->handle
,
11599 (archive_file_offset
11600 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11603 error (_("Unable to seek to start of dynamic information\n"));
11607 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11608 ngnuchains
= maxchain
;
11611 if (gnuchains
== NULL
)
11616 if (do_using_dynamic
)
11621 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11623 && do_using_dynamic
11624 && dynamic_strings
!= NULL
11625 && dynamic_symbols
!= NULL
)
11629 if (dynamic_info
[DT_HASH
])
11634 printf (_("\nSymbol table for image:\n"));
11636 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11638 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11640 visited
= xcmalloc (nchains
, 1);
11641 memset (visited
, 0, nchains
);
11642 for (hn
= 0; hn
< nbuckets
; hn
++)
11644 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11646 print_dynamic_symbol (filedata
, si
, hn
);
11647 if (si
>= nchains
|| visited
[si
])
11649 error (_("histogram chain is corrupt\n"));
11658 if (dynamic_info_DT_GNU_HASH
)
11660 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11662 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11664 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11666 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11667 if (gnubuckets
[hn
] != 0)
11669 bfd_vma si
= gnubuckets
[hn
];
11670 bfd_vma off
= si
- gnusymidx
;
11674 print_dynamic_symbol (filedata
, si
, hn
);
11677 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11681 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11682 && filedata
->section_headers
!= NULL
)
11686 for (i
= 0, section
= filedata
->section_headers
;
11687 i
< filedata
->file_header
.e_shnum
;
11691 char * strtab
= NULL
;
11692 unsigned long int strtab_size
= 0;
11693 Elf_Internal_Sym
* symtab
;
11694 Elf_Internal_Sym
* psym
;
11695 unsigned long num_syms
;
11697 if ((section
->sh_type
!= SHT_SYMTAB
11698 && section
->sh_type
!= SHT_DYNSYM
)
11700 && section
->sh_type
== SHT_SYMTAB
))
11703 if (section
->sh_entsize
== 0)
11705 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11706 printable_section_name (filedata
, section
));
11710 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11711 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11712 "\nSymbol table '%s' contains %lu entries:\n",
11714 printable_section_name (filedata
, section
),
11718 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11720 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11722 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11723 if (symtab
== NULL
)
11726 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11728 strtab
= filedata
->string_table
;
11729 strtab_size
= filedata
->string_table_length
;
11731 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11733 Elf_Internal_Shdr
* string_sec
;
11735 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11737 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11738 1, string_sec
->sh_size
,
11739 _("string table"));
11740 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11743 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11745 const char *version_string
;
11746 enum versioned_symbol_info sym_info
;
11747 unsigned short vna_other
;
11749 printf ("%6d: ", si
);
11750 print_vma (psym
->st_value
, LONG_HEX
);
11752 print_vma (psym
->st_size
, DEC_5
);
11753 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11754 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11755 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11756 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11759 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11761 printf (" %-7s", get_symbol_visibility (vis
));
11762 /* Check to see if any other bits in the st_other field are set.
11763 Note - displaying this information disrupts the layout of the
11764 table being generated, but for the moment this case is very rare. */
11765 if (psym
->st_other
^ vis
)
11766 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11768 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11769 print_symbol (25, psym
->st_name
< strtab_size
11770 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11773 = get_symbol_version_string (filedata
,
11774 section
->sh_type
== SHT_DYNSYM
,
11775 strtab
, strtab_size
, si
,
11776 psym
, &sym_info
, &vna_other
);
11777 if (version_string
)
11779 if (sym_info
== symbol_undefined
)
11780 printf ("@%s (%d)", version_string
, vna_other
);
11782 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11788 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11789 && si
>= section
->sh_info
11790 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11791 && filedata
->file_header
.e_machine
!= EM_MIPS
11792 /* Solaris binaries have been found to violate this requirement as
11793 well. Not sure if this is a bug or an ABI requirement. */
11794 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11795 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11796 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11800 if (strtab
!= filedata
->string_table
)
11806 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11808 if (do_histogram
&& buckets
!= NULL
)
11810 unsigned long * lengths
;
11811 unsigned long * counts
;
11814 unsigned long maxlength
= 0;
11815 unsigned long nzero_counts
= 0;
11816 unsigned long nsyms
= 0;
11819 printf (ngettext ("\nHistogram for bucket list length "
11820 "(total of %lu bucket):\n",
11821 "\nHistogram for bucket list length "
11822 "(total of %lu buckets):\n",
11823 (unsigned long) nbuckets
),
11824 (unsigned long) nbuckets
);
11826 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11827 if (lengths
== NULL
)
11829 error (_("Out of memory allocating space for histogram buckets\n"));
11832 visited
= xcmalloc (nchains
, 1);
11833 memset (visited
, 0, nchains
);
11835 printf (_(" Length Number %% of total Coverage\n"));
11836 for (hn
= 0; hn
< nbuckets
; ++hn
)
11838 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11841 if (maxlength
< ++lengths
[hn
])
11843 if (si
>= nchains
|| visited
[si
])
11845 error (_("histogram chain is corrupt\n"));
11853 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11854 if (counts
== NULL
)
11857 error (_("Out of memory allocating space for histogram counts\n"));
11861 for (hn
= 0; hn
< nbuckets
; ++hn
)
11862 ++counts
[lengths
[hn
]];
11867 printf (" 0 %-10lu (%5.1f%%)\n",
11868 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11869 for (i
= 1; i
<= maxlength
; ++i
)
11871 nzero_counts
+= counts
[i
] * i
;
11872 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11873 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11874 (nzero_counts
* 100.0) / nsyms
);
11882 if (buckets
!= NULL
)
11888 if (do_histogram
&& gnubuckets
!= NULL
)
11890 unsigned long * lengths
;
11891 unsigned long * counts
;
11893 unsigned long maxlength
= 0;
11894 unsigned long nzero_counts
= 0;
11895 unsigned long nsyms
= 0;
11897 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11898 "(total of %lu bucket):\n",
11899 "\nHistogram for `.gnu.hash' bucket list length "
11900 "(total of %lu buckets):\n",
11901 (unsigned long) ngnubuckets
),
11902 (unsigned long) ngnubuckets
);
11904 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11905 if (lengths
== NULL
)
11907 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11911 printf (_(" Length Number %% of total Coverage\n"));
11913 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11914 if (gnubuckets
[hn
] != 0)
11916 bfd_vma off
, length
= 1;
11918 for (off
= gnubuckets
[hn
] - gnusymidx
;
11919 /* PR 17531 file: 010-77222-0.004. */
11920 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11923 lengths
[hn
] = length
;
11924 if (length
> maxlength
)
11925 maxlength
= length
;
11929 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11930 if (counts
== NULL
)
11933 error (_("Out of memory allocating space for gnu histogram counts\n"));
11937 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11938 ++counts
[lengths
[hn
]];
11940 if (ngnubuckets
> 0)
11943 printf (" 0 %-10lu (%5.1f%%)\n",
11944 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11945 for (j
= 1; j
<= maxlength
; ++j
)
11947 nzero_counts
+= counts
[j
] * j
;
11948 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11949 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11950 (nzero_counts
* 100.0) / nsyms
);
11964 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
11968 if (dynamic_syminfo
== NULL
11970 /* No syminfo, this is ok. */
11973 /* There better should be a dynamic symbol section. */
11974 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11978 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11979 "contains %d entry:\n",
11980 "\nDynamic info segment at offset 0x%lx "
11981 "contains %d entries:\n",
11982 dynamic_syminfo_nent
),
11983 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11985 printf (_(" Num: Name BoundTo Flags\n"));
11986 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11988 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11990 printf ("%4d: ", i
);
11991 if (i
>= num_dynamic_syms
)
11992 printf (_("<corrupt index>"));
11993 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11994 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11996 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11999 switch (dynamic_syminfo
[i
].si_boundto
)
12001 case SYMINFO_BT_SELF
:
12002 fputs ("SELF ", stdout
);
12004 case SYMINFO_BT_PARENT
:
12005 fputs ("PARENT ", stdout
);
12008 if (dynamic_syminfo
[i
].si_boundto
> 0
12009 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12010 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12012 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12016 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12020 if (flags
& SYMINFO_FLG_DIRECT
)
12021 printf (" DIRECT");
12022 if (flags
& SYMINFO_FLG_PASSTHRU
)
12023 printf (" PASSTHRU");
12024 if (flags
& SYMINFO_FLG_COPY
)
12026 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12027 printf (" LAZYLOAD");
12035 #define IN_RANGE(START,END,ADDR,OFF) \
12036 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12038 /* Check to see if the given reloc needs to be handled in a target specific
12039 manner. If so then process the reloc and return TRUE otherwise return
12042 If called with reloc == NULL, then this is a signal that reloc processing
12043 for the current section has finished, and any saved state should be
12047 target_specific_reloc_handling (Filedata
* filedata
,
12048 Elf_Internal_Rela
* reloc
,
12049 unsigned char * start
,
12050 unsigned char * end
,
12051 Elf_Internal_Sym
* symtab
,
12052 unsigned long num_syms
)
12054 unsigned int reloc_type
= 0;
12055 unsigned long sym_index
= 0;
12059 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12060 sym_index
= get_reloc_symindex (reloc
->r_info
);
12063 switch (filedata
->file_header
.e_machine
)
12066 case EM_MSP430_OLD
:
12068 static Elf_Internal_Sym
* saved_sym
= NULL
;
12076 switch (reloc_type
)
12078 case 10: /* R_MSP430_SYM_DIFF */
12079 if (uses_msp430x_relocs (filedata
))
12081 /* Fall through. */
12082 case 21: /* R_MSP430X_SYM_DIFF */
12084 if (sym_index
>= num_syms
)
12085 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12088 saved_sym
= symtab
+ sym_index
;
12091 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12092 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12093 goto handle_sym_diff
;
12095 case 5: /* R_MSP430_16_BYTE */
12096 case 9: /* R_MSP430_8 */
12097 if (uses_msp430x_relocs (filedata
))
12099 goto handle_sym_diff
;
12101 case 2: /* R_MSP430_ABS16 */
12102 case 15: /* R_MSP430X_ABS16 */
12103 if (! uses_msp430x_relocs (filedata
))
12105 goto handle_sym_diff
;
12108 if (saved_sym
!= NULL
)
12110 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12113 if (sym_index
>= num_syms
)
12114 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12118 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12119 - saved_sym
->st_value
);
12121 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12122 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12125 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12126 (long) reloc
->r_offset
);
12135 if (saved_sym
!= NULL
)
12136 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12143 case EM_CYGNUS_MN10300
:
12145 static Elf_Internal_Sym
* saved_sym
= NULL
;
12153 switch (reloc_type
)
12155 case 34: /* R_MN10300_ALIGN */
12157 case 33: /* R_MN10300_SYM_DIFF */
12158 if (sym_index
>= num_syms
)
12159 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12162 saved_sym
= symtab
+ sym_index
;
12165 case 1: /* R_MN10300_32 */
12166 case 2: /* R_MN10300_16 */
12167 if (saved_sym
!= NULL
)
12169 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12172 if (sym_index
>= num_syms
)
12173 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12177 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12178 - saved_sym
->st_value
);
12180 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12181 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12183 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12184 (long) reloc
->r_offset
);
12192 if (saved_sym
!= NULL
)
12193 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12201 static bfd_vma saved_sym1
= 0;
12202 static bfd_vma saved_sym2
= 0;
12203 static bfd_vma value
;
12207 saved_sym1
= saved_sym2
= 0;
12211 switch (reloc_type
)
12213 case 0x80: /* R_RL78_SYM. */
12214 saved_sym1
= saved_sym2
;
12215 if (sym_index
>= num_syms
)
12216 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12220 saved_sym2
= symtab
[sym_index
].st_value
;
12221 saved_sym2
+= reloc
->r_addend
;
12225 case 0x83: /* R_RL78_OPsub. */
12226 value
= saved_sym1
- saved_sym2
;
12227 saved_sym2
= saved_sym1
= 0;
12231 case 0x41: /* R_RL78_ABS32. */
12232 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12233 byte_put (start
+ reloc
->r_offset
, value
, 4);
12235 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12236 (long) reloc
->r_offset
);
12240 case 0x43: /* R_RL78_ABS16. */
12241 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12242 byte_put (start
+ reloc
->r_offset
, value
, 2);
12244 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12245 (long) reloc
->r_offset
);
12259 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12260 DWARF debug sections. This is a target specific test. Note - we do not
12261 go through the whole including-target-headers-multiple-times route, (as
12262 we have already done with <elf/h8.h>) because this would become very
12263 messy and even then this function would have to contain target specific
12264 information (the names of the relocs instead of their numeric values).
12265 FIXME: This is not the correct way to solve this problem. The proper way
12266 is to have target specific reloc sizing and typing functions created by
12267 the reloc-macros.h header, in the same way that it already creates the
12268 reloc naming functions. */
12271 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12273 /* Please keep this table alpha-sorted for ease of visual lookup. */
12274 switch (filedata
->file_header
.e_machine
)
12278 return reloc_type
== 1; /* R_386_32. */
12280 return reloc_type
== 1; /* R_68K_32. */
12282 return reloc_type
== 1; /* R_860_32. */
12284 return reloc_type
== 2; /* R_960_32. */
12286 return (reloc_type
== 258
12287 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12288 case EM_ADAPTEVA_EPIPHANY
:
12289 return reloc_type
== 3;
12291 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12293 return reloc_type
== 1; /* R_ARC_32. */
12294 case EM_ARC_COMPACT
:
12295 case EM_ARC_COMPACT2
:
12296 return reloc_type
== 4; /* R_ARC_32. */
12298 return reloc_type
== 2; /* R_ARM_ABS32 */
12301 return reloc_type
== 1;
12303 return reloc_type
== 0x12; /* R_byte4_data. */
12305 return reloc_type
== 3; /* R_CRIS_32. */
12307 return reloc_type
== 3; /* R_CR16_NUM32. */
12309 return reloc_type
== 15; /* R_CRX_NUM32. */
12310 case EM_CYGNUS_FRV
:
12311 return reloc_type
== 1;
12312 case EM_CYGNUS_D10V
:
12314 return reloc_type
== 6; /* R_D10V_32. */
12315 case EM_CYGNUS_D30V
:
12317 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12319 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12320 case EM_CYGNUS_FR30
:
12322 return reloc_type
== 3; /* R_FR30_32. */
12324 return reloc_type
== 1; /* R_FT32_32. */
12328 return reloc_type
== 1; /* R_H8_DIR32. */
12330 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12331 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12332 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12333 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12336 return reloc_type
== 2; /* R_IP2K_32. */
12338 return reloc_type
== 2; /* R_IQ2000_32. */
12339 case EM_LATTICEMICO32
:
12340 return reloc_type
== 3; /* R_LM32_32. */
12343 return reloc_type
== 3; /* R_M32C_32. */
12345 return reloc_type
== 34; /* R_M32R_32_RELA. */
12348 return reloc_type
== 6; /* R_M68HC11_32. */
12350 return reloc_type
== 6; /* R_S12Z_EXT32. */
12352 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12353 case EM_CYGNUS_MEP
:
12354 return reloc_type
== 4; /* R_MEP_32. */
12356 return reloc_type
== 2; /* R_METAG_ADDR32. */
12357 case EM_MICROBLAZE
:
12358 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12360 return reloc_type
== 2; /* R_MIPS_32. */
12362 return reloc_type
== 4; /* R_MMIX_32. */
12363 case EM_CYGNUS_MN10200
:
12365 return reloc_type
== 1; /* R_MN10200_32. */
12366 case EM_CYGNUS_MN10300
:
12368 return reloc_type
== 1; /* R_MN10300_32. */
12370 return reloc_type
== 1; /* R_MOXIE_32. */
12371 case EM_MSP430_OLD
:
12373 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12375 return reloc_type
== 2; /* R_MT_32. */
12377 return reloc_type
== 20; /* R_NDS32_RELA. */
12378 case EM_ALTERA_NIOS2
:
12379 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12381 return reloc_type
== 1; /* R_NIOS_32. */
12383 return reloc_type
== 1; /* R_OR1K_32. */
12385 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12386 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12387 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12390 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12392 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12394 return reloc_type
== 1; /* R_PPC_ADDR32. */
12396 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12398 return reloc_type
== 1; /* R_RISCV_32. */
12400 return reloc_type
== 1; /* R_RL78_DIR32. */
12402 return reloc_type
== 1; /* R_RX_DIR32. */
12404 return reloc_type
== 1; /* R_I370_ADDR31. */
12407 return reloc_type
== 4; /* R_S390_32. */
12409 return reloc_type
== 8; /* R_SCORE_ABS32. */
12411 return reloc_type
== 1; /* R_SH_DIR32. */
12412 case EM_SPARC32PLUS
:
12415 return reloc_type
== 3 /* R_SPARC_32. */
12416 || reloc_type
== 23; /* R_SPARC_UA32. */
12418 return reloc_type
== 6; /* R_SPU_ADDR32 */
12420 return reloc_type
== 1; /* R_C6000_ABS32. */
12422 return reloc_type
== 2; /* R_TILEGX_32. */
12424 return reloc_type
== 1; /* R_TILEPRO_32. */
12425 case EM_CYGNUS_V850
:
12427 return reloc_type
== 6; /* R_V850_ABS32. */
12429 return reloc_type
== 0x33; /* R_V810_WORD. */
12431 return reloc_type
== 1; /* R_VAX_32. */
12433 return reloc_type
== 3; /* R_VISIUM_32. */
12434 case EM_WEBASSEMBLY
:
12435 return reloc_type
== 1; /* R_WASM32_32. */
12439 return reloc_type
== 10; /* R_X86_64_32. */
12442 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12444 return reloc_type
== 4; /* R_XGATE_32. */
12446 return reloc_type
== 1; /* R_XSTROMY16_32. */
12447 case EM_XTENSA_OLD
:
12449 return reloc_type
== 1; /* R_XTENSA_32. */
12452 static unsigned int prev_warn
= 0;
12454 /* Avoid repeating the same warning multiple times. */
12455 if (prev_warn
!= filedata
->file_header
.e_machine
)
12456 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12457 filedata
->file_header
.e_machine
);
12458 prev_warn
= filedata
->file_header
.e_machine
;
12464 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12465 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12468 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12470 switch (filedata
->file_header
.e_machine
)
12471 /* Please keep this table alpha-sorted for ease of visual lookup. */
12475 return reloc_type
== 2; /* R_386_PC32. */
12477 return reloc_type
== 4; /* R_68K_PC32. */
12479 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12480 case EM_ADAPTEVA_EPIPHANY
:
12481 return reloc_type
== 6;
12483 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12484 case EM_ARC_COMPACT
:
12485 case EM_ARC_COMPACT2
:
12486 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12488 return reloc_type
== 3; /* R_ARM_REL32 */
12491 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12492 case EM_MICROBLAZE
:
12493 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12495 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12497 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12499 return reloc_type
== 26; /* R_PPC_REL32. */
12501 return reloc_type
== 26; /* R_PPC64_REL32. */
12504 return reloc_type
== 5; /* R_390_PC32. */
12506 return reloc_type
== 2; /* R_SH_REL32. */
12507 case EM_SPARC32PLUS
:
12510 return reloc_type
== 6; /* R_SPARC_DISP32. */
12512 return reloc_type
== 13; /* R_SPU_REL32. */
12514 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12516 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12518 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12522 return reloc_type
== 2; /* R_X86_64_PC32. */
12523 case EM_XTENSA_OLD
:
12525 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12527 /* Do not abort or issue an error message here. Not all targets use
12528 pc-relative 32-bit relocs in their DWARF debug information and we
12529 have already tested for target coverage in is_32bit_abs_reloc. A
12530 more helpful warning message will be generated by apply_relocations
12531 anyway, so just return. */
12536 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12537 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12540 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12542 switch (filedata
->file_header
.e_machine
)
12545 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12547 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12549 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12550 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12552 return reloc_type
== 80; /* R_PARISC_DIR64. */
12554 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12556 return reloc_type
== 2; /* R_RISCV_64. */
12557 case EM_SPARC32PLUS
:
12560 return reloc_type
== 32 /* R_SPARC_64. */
12561 || reloc_type
== 54; /* R_SPARC_UA64. */
12565 return reloc_type
== 1; /* R_X86_64_64. */
12568 return reloc_type
== 22; /* R_S390_64. */
12570 return reloc_type
== 1; /* R_TILEGX_64. */
12572 return reloc_type
== 18; /* R_MIPS_64. */
12578 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12579 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12582 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12584 switch (filedata
->file_header
.e_machine
)
12587 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12589 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12591 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12592 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12594 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12596 return reloc_type
== 44; /* R_PPC64_REL64. */
12597 case EM_SPARC32PLUS
:
12600 return reloc_type
== 46; /* R_SPARC_DISP64. */
12604 return reloc_type
== 24; /* R_X86_64_PC64. */
12607 return reloc_type
== 23; /* R_S390_PC64. */
12609 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12615 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12616 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12619 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12621 switch (filedata
->file_header
.e_machine
)
12623 case EM_CYGNUS_MN10200
:
12625 return reloc_type
== 4; /* R_MN10200_24. */
12627 return reloc_type
== 5; /* R_FT32_20. */
12633 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12634 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12637 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12639 /* Please keep this table alpha-sorted for ease of visual lookup. */
12640 switch (filedata
->file_header
.e_machine
)
12643 case EM_ARC_COMPACT
:
12644 case EM_ARC_COMPACT2
:
12645 return reloc_type
== 2; /* R_ARC_16. */
12646 case EM_ADAPTEVA_EPIPHANY
:
12647 return reloc_type
== 5;
12650 return reloc_type
== 4; /* R_AVR_16. */
12651 case EM_CYGNUS_D10V
:
12653 return reloc_type
== 3; /* R_D10V_16. */
12655 return reloc_type
== 2; /* R_FT32_16. */
12659 return reloc_type
== R_H8_DIR16
;
12662 return reloc_type
== 1; /* R_IP2K_16. */
12665 return reloc_type
== 1; /* R_M32C_16 */
12666 case EM_CYGNUS_MN10200
:
12668 return reloc_type
== 2; /* R_MN10200_16. */
12669 case EM_CYGNUS_MN10300
:
12671 return reloc_type
== 2; /* R_MN10300_16. */
12673 if (uses_msp430x_relocs (filedata
))
12674 return reloc_type
== 2; /* R_MSP430_ABS16. */
12675 /* Fall through. */
12676 case EM_MSP430_OLD
:
12677 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12679 return reloc_type
== 19; /* R_NDS32_RELA. */
12680 case EM_ALTERA_NIOS2
:
12681 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12683 return reloc_type
== 9; /* R_NIOS_16. */
12685 return reloc_type
== 2; /* R_OR1K_16. */
12687 return reloc_type
== 55; /* R_RISCV_SET16. */
12689 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12691 return reloc_type
== 2; /* R_C6000_ABS16. */
12693 return reloc_type
== 2; /* R_VISIUM_16. */
12696 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12698 return reloc_type
== 3; /* R_XGATE_16. */
12704 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12705 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12708 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12710 switch (filedata
->file_header
.e_machine
)
12713 return reloc_type
== 54; /* R_RISCV_SET8. */
12719 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12720 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12723 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12725 switch (filedata
->file_header
.e_machine
)
12728 return reloc_type
== 53; /* R_RISCV_SET6. */
12734 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12735 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12738 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12740 /* Please keep this table alpha-sorted for ease of visual lookup. */
12741 switch (filedata
->file_header
.e_machine
)
12744 return reloc_type
== 35; /* R_RISCV_ADD32. */
12750 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12751 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12754 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12756 /* Please keep this table alpha-sorted for ease of visual lookup. */
12757 switch (filedata
->file_header
.e_machine
)
12760 return reloc_type
== 39; /* R_RISCV_SUB32. */
12766 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12767 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12770 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12772 /* Please keep this table alpha-sorted for ease of visual lookup. */
12773 switch (filedata
->file_header
.e_machine
)
12776 return reloc_type
== 36; /* R_RISCV_ADD64. */
12782 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12783 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12786 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12788 /* Please keep this table alpha-sorted for ease of visual lookup. */
12789 switch (filedata
->file_header
.e_machine
)
12792 return reloc_type
== 40; /* R_RISCV_SUB64. */
12798 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12799 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12802 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12804 /* Please keep this table alpha-sorted for ease of visual lookup. */
12805 switch (filedata
->file_header
.e_machine
)
12808 return reloc_type
== 34; /* R_RISCV_ADD16. */
12814 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12815 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12818 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12820 /* Please keep this table alpha-sorted for ease of visual lookup. */
12821 switch (filedata
->file_header
.e_machine
)
12824 return reloc_type
== 38; /* R_RISCV_SUB16. */
12830 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12831 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12834 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12836 /* Please keep this table alpha-sorted for ease of visual lookup. */
12837 switch (filedata
->file_header
.e_machine
)
12840 return reloc_type
== 33; /* R_RISCV_ADD8. */
12846 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12847 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12850 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12852 /* Please keep this table alpha-sorted for ease of visual lookup. */
12853 switch (filedata
->file_header
.e_machine
)
12856 return reloc_type
== 37; /* R_RISCV_SUB8. */
12862 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12863 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12866 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12868 switch (filedata
->file_header
.e_machine
)
12871 return reloc_type
== 52; /* R_RISCV_SUB6. */
12877 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12878 relocation entries (possibly formerly used for SHT_GROUP sections). */
12881 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12883 switch (filedata
->file_header
.e_machine
)
12885 case EM_386
: /* R_386_NONE. */
12886 case EM_68K
: /* R_68K_NONE. */
12887 case EM_ADAPTEVA_EPIPHANY
:
12888 case EM_ALPHA
: /* R_ALPHA_NONE. */
12889 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12890 case EM_ARC
: /* R_ARC_NONE. */
12891 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12892 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12893 case EM_ARM
: /* R_ARM_NONE. */
12894 case EM_C166
: /* R_XC16X_NONE. */
12895 case EM_CRIS
: /* R_CRIS_NONE. */
12896 case EM_FT32
: /* R_FT32_NONE. */
12897 case EM_IA_64
: /* R_IA64_NONE. */
12898 case EM_K1OM
: /* R_X86_64_NONE. */
12899 case EM_L1OM
: /* R_X86_64_NONE. */
12900 case EM_M32R
: /* R_M32R_NONE. */
12901 case EM_MIPS
: /* R_MIPS_NONE. */
12902 case EM_MN10300
: /* R_MN10300_NONE. */
12903 case EM_MOXIE
: /* R_MOXIE_NONE. */
12904 case EM_NIOS32
: /* R_NIOS_NONE. */
12905 case EM_OR1K
: /* R_OR1K_NONE. */
12906 case EM_PARISC
: /* R_PARISC_NONE. */
12907 case EM_PPC64
: /* R_PPC64_NONE. */
12908 case EM_PPC
: /* R_PPC_NONE. */
12909 case EM_RISCV
: /* R_RISCV_NONE. */
12910 case EM_S390
: /* R_390_NONE. */
12912 case EM_SH
: /* R_SH_NONE. */
12913 case EM_SPARC32PLUS
:
12914 case EM_SPARC
: /* R_SPARC_NONE. */
12916 case EM_TILEGX
: /* R_TILEGX_NONE. */
12917 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12918 case EM_TI_C6000
:/* R_C6000_NONE. */
12919 case EM_X86_64
: /* R_X86_64_NONE. */
12921 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12922 return reloc_type
== 0;
12925 return reloc_type
== 0 || reloc_type
== 256;
12928 return (reloc_type
== 0 /* R_AVR_NONE. */
12929 || reloc_type
== 30 /* R_AVR_DIFF8. */
12930 || reloc_type
== 31 /* R_AVR_DIFF16. */
12931 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12933 return reloc_type
== 3; /* R_METAG_NONE. */
12935 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12936 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12937 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12938 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12939 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12941 return (reloc_type
== 0 /* R_PRU_NONE. */
12942 || reloc_type
== 65 /* R_PRU_DIFF8. */
12943 || reloc_type
== 66 /* R_PRU_DIFF16. */
12944 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12945 case EM_XTENSA_OLD
:
12947 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12948 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12949 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12950 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12955 /* Returns TRUE if there is a relocation against
12956 section NAME at OFFSET bytes. */
12959 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12961 Elf_Internal_Rela
* relocs
;
12962 Elf_Internal_Rela
* rp
;
12964 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12967 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12969 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12970 if (rp
->r_offset
== offset
)
12976 /* Apply relocations to a section.
12977 Returns TRUE upon success, FALSE otherwise.
12978 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12979 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12980 will be set to the number of relocs loaded.
12982 Note: So far support has been added only for those relocations
12983 which can be found in debug sections. FIXME: Add support for
12984 more relocations ? */
12987 apply_relocations (Filedata
* filedata
,
12988 const Elf_Internal_Shdr
* section
,
12989 unsigned char * start
,
12990 bfd_size_type size
,
12991 void ** relocs_return
,
12992 unsigned long * num_relocs_return
)
12994 Elf_Internal_Shdr
* relsec
;
12995 unsigned char * end
= start
+ size
;
12996 bfd_boolean res
= TRUE
;
12998 if (relocs_return
!= NULL
)
13000 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13001 * num_relocs_return
= 0;
13004 if (filedata
->file_header
.e_type
!= ET_REL
)
13005 /* No relocs to apply. */
13008 /* Find the reloc section associated with the section. */
13009 for (relsec
= filedata
->section_headers
;
13010 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13013 bfd_boolean is_rela
;
13014 unsigned long num_relocs
;
13015 Elf_Internal_Rela
* relocs
;
13016 Elf_Internal_Rela
* rp
;
13017 Elf_Internal_Shdr
* symsec
;
13018 Elf_Internal_Sym
* symtab
;
13019 unsigned long num_syms
;
13020 Elf_Internal_Sym
* sym
;
13022 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13023 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13024 || filedata
->section_headers
+ relsec
->sh_info
!= section
13025 || relsec
->sh_size
== 0
13026 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13029 is_rela
= relsec
->sh_type
== SHT_RELA
;
13033 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13034 relsec
->sh_size
, & relocs
, & num_relocs
))
13039 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13040 relsec
->sh_size
, & relocs
, & num_relocs
))
13044 /* SH uses RELA but uses in place value instead of the addend field. */
13045 if (filedata
->file_header
.e_machine
== EM_SH
)
13048 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13049 if (symsec
->sh_type
!= SHT_SYMTAB
13050 && symsec
->sh_type
!= SHT_DYNSYM
)
13052 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13054 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13057 unsigned int reloc_type
;
13058 unsigned int reloc_size
;
13059 bfd_boolean reloc_inplace
= FALSE
;
13060 bfd_boolean reloc_subtract
= FALSE
;
13061 unsigned char * rloc
;
13062 unsigned long sym_index
;
13064 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13066 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13068 else if (is_none_reloc (filedata
, reloc_type
))
13070 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13071 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13073 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13074 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13076 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13078 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13080 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13081 || is_6bit_abs_reloc (filedata
, reloc_type
))
13083 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13085 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13088 reloc_inplace
= TRUE
;
13090 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13092 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13095 reloc_inplace
= TRUE
;
13097 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13099 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13102 reloc_inplace
= TRUE
;
13104 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13106 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13109 reloc_inplace
= TRUE
;
13111 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13115 reloc_inplace
= TRUE
;
13119 static unsigned int prev_reloc
= 0;
13121 if (reloc_type
!= prev_reloc
)
13122 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13123 reloc_type
, printable_section_name (filedata
, section
));
13124 prev_reloc
= reloc_type
;
13129 rloc
= start
+ rp
->r_offset
;
13130 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
13132 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13133 (unsigned long) rp
->r_offset
,
13134 printable_section_name (filedata
, section
));
13139 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13140 if (sym_index
>= num_syms
)
13142 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13143 sym_index
, printable_section_name (filedata
, section
));
13147 sym
= symtab
+ sym_index
;
13149 /* If the reloc has a symbol associated with it,
13150 make sure that it is of an appropriate type.
13152 Relocations against symbols without type can happen.
13153 Gcc -feliminate-dwarf2-dups may generate symbols
13154 without type for debug info.
13156 Icc generates relocations against function symbols
13157 instead of local labels.
13159 Relocations against object symbols can happen, eg when
13160 referencing a global array. For an example of this see
13161 the _clz.o binary in libgcc.a. */
13163 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13164 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13166 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13167 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13168 printable_section_name (filedata
, relsec
),
13169 (long int)(rp
- relocs
));
13176 addend
+= rp
->r_addend
;
13177 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13178 partial_inplace. */
13180 || (filedata
->file_header
.e_machine
== EM_XTENSA
13181 && reloc_type
== 1)
13182 || ((filedata
->file_header
.e_machine
== EM_PJ
13183 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13184 && reloc_type
== 1)
13185 || ((filedata
->file_header
.e_machine
== EM_D30V
13186 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13187 && reloc_type
== 12)
13190 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13191 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13193 addend
+= byte_get (rloc
, reloc_size
);
13196 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13197 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13199 /* On HPPA, all pc-relative relocations are biased by 8. */
13200 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13202 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13205 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13206 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13208 if (reloc_subtract
)
13209 addend
-= sym
->st_value
;
13211 addend
+= sym
->st_value
;
13212 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13213 byte_put (rloc
, addend
, reloc_size
);
13215 else if (reloc_subtract
)
13216 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13218 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13222 /* Let the target specific reloc processing code know that
13223 we have finished with these relocs. */
13224 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13228 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13229 * num_relocs_return
= num_relocs
;
13240 #ifdef SUPPORT_DISASSEMBLY
13242 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13244 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13246 /* FIXME: XXX -- to be done --- XXX */
13252 /* Reads in the contents of SECTION from FILE, returning a pointer
13253 to a malloc'ed buffer or NULL if something went wrong. */
13256 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13258 bfd_size_type num_bytes
= section
->sh_size
;
13260 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13262 printf (_("Section '%s' has no data to dump.\n"),
13263 printable_section_name (filedata
, section
));
13267 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13268 _("section contents"));
13271 /* Uncompresses a section that was compressed using zlib, in place. */
13274 uncompress_section_contents (unsigned char ** buffer
,
13275 dwarf_size_type uncompressed_size
,
13276 dwarf_size_type
* size
)
13278 dwarf_size_type compressed_size
= *size
;
13279 unsigned char * compressed_buffer
= *buffer
;
13280 unsigned char * uncompressed_buffer
;
13284 /* It is possible the section consists of several compressed
13285 buffers concatenated together, so we uncompress in a loop. */
13286 /* PR 18313: The state field in the z_stream structure is supposed
13287 to be invisible to the user (ie us), but some compilers will
13288 still complain about it being used without initialisation. So
13289 we first zero the entire z_stream structure and then set the fields
13291 memset (& strm
, 0, sizeof strm
);
13292 strm
.avail_in
= compressed_size
;
13293 strm
.next_in
= (Bytef
*) compressed_buffer
;
13294 strm
.avail_out
= uncompressed_size
;
13295 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13297 rc
= inflateInit (& strm
);
13298 while (strm
.avail_in
> 0)
13302 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13303 + (uncompressed_size
- strm
.avail_out
));
13304 rc
= inflate (&strm
, Z_FINISH
);
13305 if (rc
!= Z_STREAM_END
)
13307 rc
= inflateReset (& strm
);
13309 rc
= inflateEnd (& strm
);
13311 || strm
.avail_out
!= 0)
13314 *buffer
= uncompressed_buffer
;
13315 *size
= uncompressed_size
;
13319 free (uncompressed_buffer
);
13320 /* Indicate decompression failure. */
13326 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13328 Elf_Internal_Shdr
* relsec
;
13329 bfd_size_type num_bytes
;
13330 unsigned char * data
;
13331 unsigned char * end
;
13332 unsigned char * real_start
;
13333 unsigned char * start
;
13334 bfd_boolean some_strings_shown
;
13336 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13338 /* PR 21820: Do not fail if the section was empty. */
13339 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13341 num_bytes
= section
->sh_size
;
13343 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13345 if (decompress_dumps
)
13347 dwarf_size_type new_size
= num_bytes
;
13348 dwarf_size_type uncompressed_size
= 0;
13350 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13352 Elf_Internal_Chdr chdr
;
13353 unsigned int compression_header_size
13354 = get_compression_header (& chdr
, (unsigned char *) start
,
13357 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13359 warn (_("section '%s' has unsupported compress type: %d\n"),
13360 printable_section_name (filedata
, section
), chdr
.ch_type
);
13363 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13365 warn (_("compressed section '%s' is corrupted\n"),
13366 printable_section_name (filedata
, section
));
13369 uncompressed_size
= chdr
.ch_size
;
13370 start
+= compression_header_size
;
13371 new_size
-= compression_header_size
;
13373 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13375 /* Read the zlib header. In this case, it should be "ZLIB"
13376 followed by the uncompressed section size, 8 bytes in
13377 big-endian order. */
13378 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13379 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13380 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13381 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13382 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13383 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13384 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13385 uncompressed_size
+= start
[11];
13390 if (uncompressed_size
)
13392 if (uncompress_section_contents (& start
,
13393 uncompressed_size
, & new_size
))
13394 num_bytes
= new_size
;
13397 error (_("Unable to decompress section %s\n"),
13398 printable_section_name (filedata
, section
));
13403 start
= real_start
;
13406 /* If the section being dumped has relocations against it the user might
13407 be expecting these relocations to have been applied. Check for this
13408 case and issue a warning message in order to avoid confusion.
13409 FIXME: Maybe we ought to have an option that dumps a section with
13410 relocs applied ? */
13411 for (relsec
= filedata
->section_headers
;
13412 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13415 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13416 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13417 || filedata
->section_headers
+ relsec
->sh_info
!= section
13418 || relsec
->sh_size
== 0
13419 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13422 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13427 end
= start
+ num_bytes
;
13428 some_strings_shown
= FALSE
;
13432 while (!ISPRINT (* data
))
13433 if (++ data
>= end
)
13438 size_t maxlen
= end
- data
;
13441 /* PR 11128: Use two separate invocations in order to work
13442 around bugs in the Solaris 8 implementation of printf. */
13443 printf (" [%6tx] ", data
- start
);
13445 printf (" [%6Ix] ", (size_t) (data
- start
));
13449 print_symbol ((int) maxlen
, (const char *) data
);
13451 data
+= strnlen ((const char *) data
, maxlen
);
13455 printf (_("<corrupt>\n"));
13458 some_strings_shown
= TRUE
;
13462 if (! some_strings_shown
)
13463 printf (_(" No strings found in this section."));
13472 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13473 Filedata
* filedata
,
13474 bfd_boolean relocate
)
13476 Elf_Internal_Shdr
* relsec
;
13477 bfd_size_type bytes
;
13478 bfd_size_type section_size
;
13480 unsigned char * data
;
13481 unsigned char * real_start
;
13482 unsigned char * start
;
13484 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13486 /* PR 21820: Do not fail if the section was empty. */
13487 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13489 section_size
= section
->sh_size
;
13491 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13493 if (decompress_dumps
)
13495 dwarf_size_type new_size
= section_size
;
13496 dwarf_size_type uncompressed_size
= 0;
13498 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13500 Elf_Internal_Chdr chdr
;
13501 unsigned int compression_header_size
13502 = get_compression_header (& chdr
, start
, section_size
);
13504 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13506 warn (_("section '%s' has unsupported compress type: %d\n"),
13507 printable_section_name (filedata
, section
), chdr
.ch_type
);
13510 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13512 warn (_("compressed section '%s' is corrupted\n"),
13513 printable_section_name (filedata
, section
));
13516 uncompressed_size
= chdr
.ch_size
;
13517 start
+= compression_header_size
;
13518 new_size
-= compression_header_size
;
13520 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13522 /* Read the zlib header. In this case, it should be "ZLIB"
13523 followed by the uncompressed section size, 8 bytes in
13524 big-endian order. */
13525 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13526 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13527 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13528 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13529 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13530 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13531 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13532 uncompressed_size
+= start
[11];
13537 if (uncompressed_size
)
13539 if (uncompress_section_contents (& start
, uncompressed_size
,
13542 section_size
= new_size
;
13546 error (_("Unable to decompress section %s\n"),
13547 printable_section_name (filedata
, section
));
13548 /* FIXME: Print the section anyway ? */
13553 start
= real_start
;
13558 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13563 /* If the section being dumped has relocations against it the user might
13564 be expecting these relocations to have been applied. Check for this
13565 case and issue a warning message in order to avoid confusion.
13566 FIXME: Maybe we ought to have an option that dumps a section with
13567 relocs applied ? */
13568 for (relsec
= filedata
->section_headers
;
13569 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13572 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13573 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13574 || filedata
->section_headers
+ relsec
->sh_info
!= section
13575 || relsec
->sh_size
== 0
13576 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13579 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13584 addr
= section
->sh_addr
;
13585 bytes
= section_size
;
13594 lbytes
= (bytes
> 16 ? 16 : bytes
);
13596 printf (" 0x%8.8lx ", (unsigned long) addr
);
13598 for (j
= 0; j
< 16; j
++)
13601 printf ("%2.2x", data
[j
]);
13609 for (j
= 0; j
< lbytes
; j
++)
13612 if (k
>= ' ' && k
< 0x7f)
13632 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13633 const Elf_Internal_Shdr
* sec
,
13636 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13638 Filedata
* filedata
= (Filedata
*) data
;
13640 if (section
->start
!= NULL
)
13642 /* If it is already loaded, do nothing. */
13643 if (streq (section
->filename
, filedata
->file_name
))
13645 free (section
->start
);
13648 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13649 section
->address
= sec
->sh_addr
;
13650 section
->user_data
= NULL
;
13651 section
->filename
= filedata
->file_name
;
13652 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13654 sec
->sh_size
, buf
);
13655 if (section
->start
== NULL
)
13659 unsigned char *start
= section
->start
;
13660 dwarf_size_type size
= sec
->sh_size
;
13661 dwarf_size_type uncompressed_size
= 0;
13663 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13665 Elf_Internal_Chdr chdr
;
13666 unsigned int compression_header_size
;
13668 if (size
< (is_32bit_elf
13669 ? sizeof (Elf32_External_Chdr
)
13670 : sizeof (Elf64_External_Chdr
)))
13672 warn (_("compressed section %s is too small to contain a compression header"),
13677 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13679 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13681 warn (_("section '%s' has unsupported compress type: %d\n"),
13682 section
->name
, chdr
.ch_type
);
13685 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13687 warn (_("compressed section '%s' is corrupted\n"),
13691 uncompressed_size
= chdr
.ch_size
;
13692 start
+= compression_header_size
;
13693 size
-= compression_header_size
;
13695 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13697 /* Read the zlib header. In this case, it should be "ZLIB"
13698 followed by the uncompressed section size, 8 bytes in
13699 big-endian order. */
13700 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13701 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13702 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13703 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13704 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13705 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13706 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13707 uncompressed_size
+= start
[11];
13712 if (uncompressed_size
)
13714 if (uncompress_section_contents (&start
, uncompressed_size
,
13717 /* Free the compressed buffer, update the section buffer
13718 and the section size if uncompress is successful. */
13719 free (section
->start
);
13720 section
->start
= start
;
13724 error (_("Unable to decompress section %s\n"),
13725 printable_section_name (filedata
, sec
));
13730 section
->size
= size
;
13733 if (section
->start
== NULL
)
13736 if (debug_displays
[debug
].relocate
)
13738 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13739 & section
->reloc_info
, & section
->num_relocs
))
13744 section
->reloc_info
= NULL
;
13745 section
->num_relocs
= 0;
13751 /* If this is not NULL, load_debug_section will only look for sections
13752 within the list of sections given here. */
13753 static unsigned int * section_subset
= NULL
;
13756 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13758 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13759 Elf_Internal_Shdr
* sec
;
13760 Filedata
* filedata
= (Filedata
*) data
;
13762 /* Without section headers we cannot find any sections. */
13763 if (filedata
->section_headers
== NULL
)
13766 if (filedata
->string_table
== NULL
13767 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13768 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13770 Elf_Internal_Shdr
* strs
;
13772 /* Read in the string table, so that we have section names to scan. */
13773 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13775 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13777 filedata
->string_table
13778 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13779 1, strs
->sh_size
, _("string table"));
13781 filedata
->string_table_length
13782 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13786 /* Locate the debug section. */
13787 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13789 section
->name
= section
->uncompressed_name
;
13792 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13794 section
->name
= section
->compressed_name
;
13799 /* If we're loading from a subset of sections, and we've loaded
13800 a section matching this name before, it's likely that it's a
13802 if (section_subset
!= NULL
)
13803 free_debug_section (debug
);
13805 return load_specific_debug_section (debug
, sec
, data
);
13809 free_debug_section (enum dwarf_section_display_enum debug
)
13811 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13813 if (section
->start
== NULL
)
13816 free ((char *) section
->start
);
13817 section
->start
= NULL
;
13818 section
->address
= 0;
13823 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13825 char * name
= SECTION_NAME (section
);
13826 const char * print_name
= printable_section_name (filedata
, section
);
13827 bfd_size_type length
;
13828 bfd_boolean result
= TRUE
;
13831 length
= section
->sh_size
;
13834 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13837 if (section
->sh_type
== SHT_NOBITS
)
13839 /* There is no point in dumping the contents of a debugging section
13840 which has the NOBITS type - the bits in the file will be random.
13841 This can happen when a file containing a .eh_frame section is
13842 stripped with the --only-keep-debug command line option. */
13843 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13848 if (const_strneq (name
, ".gnu.linkonce.wi."))
13849 name
= ".debug_info";
13851 /* See if we know how to display the contents of this section. */
13852 for (i
= 0; i
< max
; i
++)
13854 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13855 struct dwarf_section_display
* display
= debug_displays
+ i
;
13856 struct dwarf_section
* sec
= & display
->section
;
13858 if (streq (sec
->uncompressed_name
, name
)
13859 || (id
== line
&& const_strneq (name
, ".debug_line."))
13860 || streq (sec
->compressed_name
, name
))
13862 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13865 free_debug_section (id
);
13867 if (i
== line
&& const_strneq (name
, ".debug_line."))
13869 else if (streq (sec
->uncompressed_name
, name
))
13870 sec
->name
= sec
->uncompressed_name
;
13872 sec
->name
= sec
->compressed_name
;
13874 if (load_specific_debug_section (id
, section
, filedata
))
13876 /* If this debug section is part of a CU/TU set in a .dwp file,
13877 restrict load_debug_section to the sections in that set. */
13878 section_subset
= find_cu_tu_set (filedata
, shndx
);
13880 result
&= display
->display (sec
, filedata
);
13882 section_subset
= NULL
;
13884 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13885 free_debug_section (id
);
13893 printf (_("Unrecognized debug section: %s\n"), print_name
);
13900 /* Set DUMP_SECTS for all sections where dumps were requested
13901 based on section name. */
13904 initialise_dumps_byname (Filedata
* filedata
)
13906 struct dump_list_entry
* cur
;
13908 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13911 bfd_boolean any
= FALSE
;
13913 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13914 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13916 request_dump_bynumber (filedata
, i
, cur
->type
);
13921 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13927 process_section_contents (Filedata
* filedata
)
13929 Elf_Internal_Shdr
* section
;
13931 bfd_boolean res
= TRUE
;
13936 initialise_dumps_byname (filedata
);
13938 for (i
= 0, section
= filedata
->section_headers
;
13939 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13942 dump_type dump
= filedata
->dump_sects
[i
];
13944 #ifdef SUPPORT_DISASSEMBLY
13945 if (dump
& DISASS_DUMP
)
13947 if (! disassemble_section (section
, filedata
))
13951 if (dump
& HEX_DUMP
)
13953 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13957 if (dump
& RELOC_DUMP
)
13959 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13963 if (dump
& STRING_DUMP
)
13965 if (! dump_section_as_strings (section
, filedata
))
13969 if (dump
& DEBUG_DUMP
)
13971 if (! display_debug_section (i
, section
, filedata
))
13976 /* Check to see if the user requested a
13977 dump of a section that does not exist. */
13978 while (i
< filedata
->num_dump_sects
)
13980 if (filedata
->dump_sects
[i
])
13982 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13992 process_mips_fpe_exception (int mask
)
13996 bfd_boolean first
= TRUE
;
13998 if (mask
& OEX_FPU_INEX
)
13999 fputs ("INEX", stdout
), first
= FALSE
;
14000 if (mask
& OEX_FPU_UFLO
)
14001 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14002 if (mask
& OEX_FPU_OFLO
)
14003 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14004 if (mask
& OEX_FPU_DIV0
)
14005 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14006 if (mask
& OEX_FPU_INVAL
)
14007 printf ("%sINVAL", first
? "" : "|");
14010 fputs ("0", stdout
);
14013 /* Display's the value of TAG at location P. If TAG is
14014 greater than 0 it is assumed to be an unknown tag, and
14015 a message is printed to this effect. Otherwise it is
14016 assumed that a message has already been printed.
14018 If the bottom bit of TAG is set it assumed to have a
14019 string value, otherwise it is assumed to have an integer
14022 Returns an updated P pointing to the first unread byte
14023 beyond the end of TAG's value.
14025 Reads at or beyond END will not be made. */
14027 static unsigned char *
14028 display_tag_value (signed int tag
,
14030 const unsigned char * const end
)
14035 printf (" Tag_unknown_%d: ", tag
);
14039 warn (_("<corrupt tag>\n"));
14043 /* PR 17531 file: 027-19978-0.004. */
14044 size_t maxlen
= (end
- p
) - 1;
14049 print_symbol ((int) maxlen
, (const char *) p
);
14050 p
+= strnlen ((char *) p
, maxlen
) + 1;
14054 printf (_("<corrupt string tag>"));
14055 p
= (unsigned char *) end
;
14063 val
= read_uleb128 (p
, &len
, end
);
14065 printf ("%ld (0x%lx)\n", val
, val
);
14072 /* ARC ABI attributes section. */
14074 static unsigned char *
14075 display_arc_attribute (unsigned char * p
,
14076 const unsigned char * const end
)
14082 tag
= read_uleb128 (p
, &len
, end
);
14087 case Tag_ARC_PCS_config
:
14088 val
= read_uleb128 (p
, &len
, end
);
14090 printf (" Tag_ARC_PCS_config: ");
14094 printf (_("Absent/Non standard\n"));
14097 printf (_("Bare metal/mwdt\n"));
14100 printf (_("Bare metal/newlib\n"));
14103 printf (_("Linux/uclibc\n"));
14106 printf (_("Linux/glibc\n"));
14109 printf (_("Unknown\n"));
14114 case Tag_ARC_CPU_base
:
14115 val
= read_uleb128 (p
, &len
, end
);
14117 printf (" Tag_ARC_CPU_base: ");
14122 printf (_("Absent\n"));
14124 case TAG_CPU_ARC6xx
:
14125 printf ("ARC6xx\n");
14127 case TAG_CPU_ARC7xx
:
14128 printf ("ARC7xx\n");
14130 case TAG_CPU_ARCEM
:
14131 printf ("ARCEM\n");
14133 case TAG_CPU_ARCHS
:
14134 printf ("ARCHS\n");
14139 case Tag_ARC_CPU_variation
:
14140 val
= read_uleb128 (p
, &len
, end
);
14142 printf (" Tag_ARC_CPU_variation: ");
14146 if (val
> 0 && val
< 16)
14147 printf ("Core%d\n", val
);
14149 printf ("Unknown\n");
14153 printf (_("Absent\n"));
14158 case Tag_ARC_CPU_name
:
14159 printf (" Tag_ARC_CPU_name: ");
14160 p
= display_tag_value (-1, p
, end
);
14163 case Tag_ARC_ABI_rf16
:
14164 val
= read_uleb128 (p
, &len
, end
);
14166 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14169 case Tag_ARC_ABI_osver
:
14170 val
= read_uleb128 (p
, &len
, end
);
14172 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14175 case Tag_ARC_ABI_pic
:
14176 case Tag_ARC_ABI_sda
:
14177 val
= read_uleb128 (p
, &len
, end
);
14179 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14180 : " Tag_ARC_ABI_pic: ");
14184 printf (_("Absent\n"));
14193 printf (_("Unknown\n"));
14198 case Tag_ARC_ABI_tls
:
14199 val
= read_uleb128 (p
, &len
, end
);
14201 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14204 case Tag_ARC_ABI_enumsize
:
14205 val
= read_uleb128 (p
, &len
, end
);
14207 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14211 case Tag_ARC_ABI_exceptions
:
14212 val
= read_uleb128 (p
, &len
, end
);
14214 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14218 case Tag_ARC_ABI_double_size
:
14219 val
= read_uleb128 (p
, &len
, end
);
14221 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14224 case Tag_ARC_ISA_config
:
14225 printf (" Tag_ARC_ISA_config: ");
14226 p
= display_tag_value (-1, p
, end
);
14229 case Tag_ARC_ISA_apex
:
14230 printf (" Tag_ARC_ISA_apex: ");
14231 p
= display_tag_value (-1, p
, end
);
14234 case Tag_ARC_ISA_mpy_option
:
14235 val
= read_uleb128 (p
, &len
, end
);
14237 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14241 return display_tag_value (tag
& 1, p
, end
);
14247 /* ARM EABI attributes section. */
14252 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14254 const char ** table
;
14255 } arm_attr_public_tag
;
14257 static const char * arm_attr_tag_CPU_arch
[] =
14258 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14259 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14261 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14262 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14263 {"No", "Thumb-1", "Thumb-2", "Yes"};
14264 static const char * arm_attr_tag_FP_arch
[] =
14265 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14266 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14267 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14268 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14269 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14270 "NEON for ARMv8.1"};
14271 static const char * arm_attr_tag_PCS_config
[] =
14272 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14273 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14274 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14275 {"V6", "SB", "TLS", "Unused"};
14276 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14277 {"Absolute", "PC-relative", "SB-relative", "None"};
14278 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14279 {"Absolute", "PC-relative", "None"};
14280 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14281 {"None", "direct", "GOT-indirect"};
14282 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14283 {"None", "??? 1", "2", "??? 3", "4"};
14284 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14285 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14286 {"Unused", "Needed", "Sign only"};
14287 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14288 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14289 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14290 {"Unused", "Finite", "RTABI", "IEEE 754"};
14291 static const char * arm_attr_tag_ABI_enum_size
[] =
14292 {"Unused", "small", "int", "forced to int"};
14293 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14294 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14295 static const char * arm_attr_tag_ABI_VFP_args
[] =
14296 {"AAPCS", "VFP registers", "custom", "compatible"};
14297 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14298 {"AAPCS", "WMMX registers", "custom"};
14299 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14300 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14301 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14302 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14303 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14304 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14305 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14306 static const char * arm_attr_tag_FP_HP_extension
[] =
14307 {"Not Allowed", "Allowed"};
14308 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14309 {"None", "IEEE 754", "Alternative Format"};
14310 static const char * arm_attr_tag_DSP_extension
[] =
14311 {"Follow architecture", "Allowed"};
14312 static const char * arm_attr_tag_MPextension_use
[] =
14313 {"Not Allowed", "Allowed"};
14314 static const char * arm_attr_tag_DIV_use
[] =
14315 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14316 "Allowed in v7-A with integer division extension"};
14317 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14318 static const char * arm_attr_tag_Virtualization_use
[] =
14319 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14320 "TrustZone and Virtualization Extensions"};
14321 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14322 {"Not Allowed", "Allowed"};
14324 #define LOOKUP(id, name) \
14325 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14326 static arm_attr_public_tag arm_attr_public_tags
[] =
14328 {4, "CPU_raw_name", 1, NULL
},
14329 {5, "CPU_name", 1, NULL
},
14330 LOOKUP(6, CPU_arch
),
14331 {7, "CPU_arch_profile", 0, NULL
},
14332 LOOKUP(8, ARM_ISA_use
),
14333 LOOKUP(9, THUMB_ISA_use
),
14334 LOOKUP(10, FP_arch
),
14335 LOOKUP(11, WMMX_arch
),
14336 LOOKUP(12, Advanced_SIMD_arch
),
14337 LOOKUP(13, PCS_config
),
14338 LOOKUP(14, ABI_PCS_R9_use
),
14339 LOOKUP(15, ABI_PCS_RW_data
),
14340 LOOKUP(16, ABI_PCS_RO_data
),
14341 LOOKUP(17, ABI_PCS_GOT_use
),
14342 LOOKUP(18, ABI_PCS_wchar_t
),
14343 LOOKUP(19, ABI_FP_rounding
),
14344 LOOKUP(20, ABI_FP_denormal
),
14345 LOOKUP(21, ABI_FP_exceptions
),
14346 LOOKUP(22, ABI_FP_user_exceptions
),
14347 LOOKUP(23, ABI_FP_number_model
),
14348 {24, "ABI_align_needed", 0, NULL
},
14349 {25, "ABI_align_preserved", 0, NULL
},
14350 LOOKUP(26, ABI_enum_size
),
14351 LOOKUP(27, ABI_HardFP_use
),
14352 LOOKUP(28, ABI_VFP_args
),
14353 LOOKUP(29, ABI_WMMX_args
),
14354 LOOKUP(30, ABI_optimization_goals
),
14355 LOOKUP(31, ABI_FP_optimization_goals
),
14356 {32, "compatibility", 0, NULL
},
14357 LOOKUP(34, CPU_unaligned_access
),
14358 LOOKUP(36, FP_HP_extension
),
14359 LOOKUP(38, ABI_FP_16bit_format
),
14360 LOOKUP(42, MPextension_use
),
14361 LOOKUP(44, DIV_use
),
14362 LOOKUP(46, DSP_extension
),
14363 {64, "nodefaults", 0, NULL
},
14364 {65, "also_compatible_with", 0, NULL
},
14365 LOOKUP(66, T2EE_use
),
14366 {67, "conformance", 1, NULL
},
14367 LOOKUP(68, Virtualization_use
),
14368 LOOKUP(70, MPextension_use_legacy
)
14372 static unsigned char *
14373 display_arm_attribute (unsigned char * p
,
14374 const unsigned char * const end
)
14379 arm_attr_public_tag
* attr
;
14383 tag
= read_uleb128 (p
, &len
, end
);
14386 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14388 if (arm_attr_public_tags
[i
].tag
== tag
)
14390 attr
= &arm_attr_public_tags
[i
];
14397 printf (" Tag_%s: ", attr
->name
);
14398 switch (attr
->type
)
14403 case 7: /* Tag_CPU_arch_profile. */
14404 val
= read_uleb128 (p
, &len
, end
);
14408 case 0: printf (_("None\n")); break;
14409 case 'A': printf (_("Application\n")); break;
14410 case 'R': printf (_("Realtime\n")); break;
14411 case 'M': printf (_("Microcontroller\n")); break;
14412 case 'S': printf (_("Application or Realtime\n")); break;
14413 default: printf ("??? (%d)\n", val
); break;
14417 case 24: /* Tag_align_needed. */
14418 val
= read_uleb128 (p
, &len
, end
);
14422 case 0: printf (_("None\n")); break;
14423 case 1: printf (_("8-byte\n")); break;
14424 case 2: printf (_("4-byte\n")); break;
14425 case 3: printf ("??? 3\n"); break;
14428 printf (_("8-byte and up to %d-byte extended\n"),
14431 printf ("??? (%d)\n", val
);
14436 case 25: /* Tag_align_preserved. */
14437 val
= read_uleb128 (p
, &len
, end
);
14441 case 0: printf (_("None\n")); break;
14442 case 1: printf (_("8-byte, except leaf SP\n")); break;
14443 case 2: printf (_("8-byte\n")); break;
14444 case 3: printf ("??? 3\n"); break;
14447 printf (_("8-byte and up to %d-byte extended\n"),
14450 printf ("??? (%d)\n", val
);
14455 case 32: /* Tag_compatibility. */
14457 val
= read_uleb128 (p
, &len
, end
);
14459 printf (_("flag = %d, vendor = "), val
);
14462 size_t maxlen
= (end
- p
) - 1;
14464 print_symbol ((int) maxlen
, (const char *) p
);
14465 p
+= strnlen ((char *) p
, maxlen
) + 1;
14469 printf (_("<corrupt>"));
14470 p
= (unsigned char *) end
;
14476 case 64: /* Tag_nodefaults. */
14477 /* PR 17531: file: 001-505008-0.01. */
14480 printf (_("True\n"));
14483 case 65: /* Tag_also_compatible_with. */
14484 val
= read_uleb128 (p
, &len
, end
);
14486 if (val
== 6 /* Tag_CPU_arch. */)
14488 val
= read_uleb128 (p
, &len
, end
);
14490 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14491 printf ("??? (%d)\n", val
);
14493 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14497 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14502 printf (_("<unknown: %d>\n"), tag
);
14508 return display_tag_value (-1, p
, end
);
14510 return display_tag_value (0, p
, end
);
14513 assert (attr
->type
& 0x80);
14514 val
= read_uleb128 (p
, &len
, end
);
14516 type
= attr
->type
& 0x7f;
14518 printf ("??? (%d)\n", val
);
14520 printf ("%s\n", attr
->table
[val
]);
14525 return display_tag_value (tag
, p
, end
);
14528 static unsigned char *
14529 display_gnu_attribute (unsigned char * p
,
14530 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14531 const unsigned char * const end
)
14537 tag
= read_uleb128 (p
, &len
, end
);
14540 /* Tag_compatibility is the only generic GNU attribute defined at
14544 val
= read_uleb128 (p
, &len
, end
);
14547 printf (_("flag = %d, vendor = "), val
);
14550 printf (_("<corrupt>\n"));
14551 warn (_("corrupt vendor attribute\n"));
14557 size_t maxlen
= (end
- p
) - 1;
14559 print_symbol ((int) maxlen
, (const char *) p
);
14560 p
+= strnlen ((char *) p
, maxlen
) + 1;
14564 printf (_("<corrupt>"));
14565 p
= (unsigned char *) end
;
14572 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14573 return display_proc_gnu_attribute (p
, tag
, end
);
14575 return display_tag_value (tag
, p
, end
);
14578 static unsigned char *
14579 display_power_gnu_attribute (unsigned char * p
,
14581 const unsigned char * const end
)
14586 if (tag
== Tag_GNU_Power_ABI_FP
)
14588 val
= read_uleb128 (p
, &len
, end
);
14590 printf (" Tag_GNU_Power_ABI_FP: ");
14593 printf (_("<corrupt>\n"));
14598 printf ("(%#x), ", val
);
14603 printf (_("unspecified hard/soft float, "));
14606 printf (_("hard float, "));
14609 printf (_("soft float, "));
14612 printf (_("single-precision hard float, "));
14619 printf (_("unspecified long double\n"));
14622 printf (_("128-bit IBM long double\n"));
14625 printf (_("64-bit long double\n"));
14628 printf (_("128-bit IEEE long double\n"));
14634 if (tag
== Tag_GNU_Power_ABI_Vector
)
14636 val
= read_uleb128 (p
, &len
, end
);
14638 printf (" Tag_GNU_Power_ABI_Vector: ");
14641 printf (_("<corrupt>\n"));
14646 printf ("(%#x), ", val
);
14651 printf (_("unspecified\n"));
14654 printf (_("generic\n"));
14657 printf ("AltiVec\n");
14666 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14668 val
= read_uleb128 (p
, &len
, end
);
14670 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14673 printf (_("<corrupt>\n"));
14678 printf ("(%#x), ", val
);
14683 printf (_("unspecified\n"));
14686 printf ("r3/r4\n");
14689 printf (_("memory\n"));
14698 return display_tag_value (tag
& 1, p
, end
);
14701 static unsigned char *
14702 display_s390_gnu_attribute (unsigned char * p
,
14704 const unsigned char * const end
)
14709 if (tag
== Tag_GNU_S390_ABI_Vector
)
14711 val
= read_uleb128 (p
, &len
, end
);
14713 printf (" Tag_GNU_S390_ABI_Vector: ");
14718 printf (_("any\n"));
14721 printf (_("software\n"));
14724 printf (_("hardware\n"));
14727 printf ("??? (%d)\n", val
);
14733 return display_tag_value (tag
& 1, p
, end
);
14737 display_sparc_hwcaps (unsigned int mask
)
14741 bfd_boolean first
= TRUE
;
14743 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14744 fputs ("mul32", stdout
), first
= FALSE
;
14745 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14746 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14747 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14748 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14749 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14750 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14751 if (mask
& ELF_SPARC_HWCAP_POPC
)
14752 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14753 if (mask
& ELF_SPARC_HWCAP_VIS
)
14754 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14755 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14756 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14757 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14758 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14759 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14760 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14761 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14762 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14763 if (mask
& ELF_SPARC_HWCAP_HPC
)
14764 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14765 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14766 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14767 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14768 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14769 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14770 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14771 if (mask
& ELF_SPARC_HWCAP_IMA
)
14772 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14773 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14774 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14777 fputc ('0', stdout
);
14778 fputc ('\n', stdout
);
14782 display_sparc_hwcaps2 (unsigned int mask
)
14786 bfd_boolean first
= TRUE
;
14788 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14789 fputs ("fjathplus", stdout
), first
= FALSE
;
14790 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14791 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14792 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14793 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14794 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14795 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14796 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14797 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14798 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14799 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14800 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14801 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14802 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14803 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14804 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14805 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14806 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14807 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14808 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14809 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14812 fputc ('0', stdout
);
14813 fputc ('\n', stdout
);
14816 static unsigned char *
14817 display_sparc_gnu_attribute (unsigned char * p
,
14819 const unsigned char * const end
)
14824 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14826 val
= read_uleb128 (p
, &len
, end
);
14828 printf (" Tag_GNU_Sparc_HWCAPS: ");
14829 display_sparc_hwcaps (val
);
14832 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14834 val
= read_uleb128 (p
, &len
, end
);
14836 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14837 display_sparc_hwcaps2 (val
);
14841 return display_tag_value (tag
, p
, end
);
14845 print_mips_fp_abi_value (unsigned int val
)
14849 case Val_GNU_MIPS_ABI_FP_ANY
:
14850 printf (_("Hard or soft float\n"));
14852 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14853 printf (_("Hard float (double precision)\n"));
14855 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14856 printf (_("Hard float (single precision)\n"));
14858 case Val_GNU_MIPS_ABI_FP_SOFT
:
14859 printf (_("Soft float\n"));
14861 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14862 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14864 case Val_GNU_MIPS_ABI_FP_XX
:
14865 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14867 case Val_GNU_MIPS_ABI_FP_64
:
14868 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14870 case Val_GNU_MIPS_ABI_FP_64A
:
14871 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14873 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14874 printf (_("NaN 2008 compatibility\n"));
14877 printf ("??? (%d)\n", val
);
14882 static unsigned char *
14883 display_mips_gnu_attribute (unsigned char * p
,
14885 const unsigned char * const end
)
14887 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14892 val
= read_uleb128 (p
, &len
, end
);
14894 printf (" Tag_GNU_MIPS_ABI_FP: ");
14896 print_mips_fp_abi_value (val
);
14901 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14906 val
= read_uleb128 (p
, &len
, end
);
14908 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14912 case Val_GNU_MIPS_ABI_MSA_ANY
:
14913 printf (_("Any MSA or not\n"));
14915 case Val_GNU_MIPS_ABI_MSA_128
:
14916 printf (_("128-bit MSA\n"));
14919 printf ("??? (%d)\n", val
);
14925 return display_tag_value (tag
& 1, p
, end
);
14928 static unsigned char *
14929 display_tic6x_attribute (unsigned char * p
,
14930 const unsigned char * const end
)
14936 tag
= read_uleb128 (p
, &len
, end
);
14942 val
= read_uleb128 (p
, &len
, end
);
14944 printf (" Tag_ISA: ");
14948 case C6XABI_Tag_ISA_none
:
14949 printf (_("None\n"));
14951 case C6XABI_Tag_ISA_C62X
:
14954 case C6XABI_Tag_ISA_C67X
:
14957 case C6XABI_Tag_ISA_C67XP
:
14958 printf ("C67x+\n");
14960 case C6XABI_Tag_ISA_C64X
:
14963 case C6XABI_Tag_ISA_C64XP
:
14964 printf ("C64x+\n");
14966 case C6XABI_Tag_ISA_C674X
:
14967 printf ("C674x\n");
14970 printf ("??? (%d)\n", val
);
14975 case Tag_ABI_wchar_t
:
14976 val
= read_uleb128 (p
, &len
, end
);
14978 printf (" Tag_ABI_wchar_t: ");
14982 printf (_("Not used\n"));
14985 printf (_("2 bytes\n"));
14988 printf (_("4 bytes\n"));
14991 printf ("??? (%d)\n", val
);
14996 case Tag_ABI_stack_align_needed
:
14997 val
= read_uleb128 (p
, &len
, end
);
14999 printf (" Tag_ABI_stack_align_needed: ");
15003 printf (_("8-byte\n"));
15006 printf (_("16-byte\n"));
15009 printf ("??? (%d)\n", val
);
15014 case Tag_ABI_stack_align_preserved
:
15015 val
= read_uleb128 (p
, &len
, end
);
15017 printf (" Tag_ABI_stack_align_preserved: ");
15021 printf (_("8-byte\n"));
15024 printf (_("16-byte\n"));
15027 printf ("??? (%d)\n", val
);
15033 val
= read_uleb128 (p
, &len
, end
);
15035 printf (" Tag_ABI_DSBT: ");
15039 printf (_("DSBT addressing not used\n"));
15042 printf (_("DSBT addressing used\n"));
15045 printf ("??? (%d)\n", val
);
15051 val
= read_uleb128 (p
, &len
, end
);
15053 printf (" Tag_ABI_PID: ");
15057 printf (_("Data addressing position-dependent\n"));
15060 printf (_("Data addressing position-independent, GOT near DP\n"));
15063 printf (_("Data addressing position-independent, GOT far from DP\n"));
15066 printf ("??? (%d)\n", val
);
15072 val
= read_uleb128 (p
, &len
, end
);
15074 printf (" Tag_ABI_PIC: ");
15078 printf (_("Code addressing position-dependent\n"));
15081 printf (_("Code addressing position-independent\n"));
15084 printf ("??? (%d)\n", val
);
15089 case Tag_ABI_array_object_alignment
:
15090 val
= read_uleb128 (p
, &len
, end
);
15092 printf (" Tag_ABI_array_object_alignment: ");
15096 printf (_("8-byte\n"));
15099 printf (_("4-byte\n"));
15102 printf (_("16-byte\n"));
15105 printf ("??? (%d)\n", val
);
15110 case Tag_ABI_array_object_align_expected
:
15111 val
= read_uleb128 (p
, &len
, end
);
15113 printf (" Tag_ABI_array_object_align_expected: ");
15117 printf (_("8-byte\n"));
15120 printf (_("4-byte\n"));
15123 printf (_("16-byte\n"));
15126 printf ("??? (%d)\n", val
);
15131 case Tag_ABI_compatibility
:
15133 val
= read_uleb128 (p
, &len
, end
);
15135 printf (" Tag_ABI_compatibility: ");
15136 printf (_("flag = %d, vendor = "), val
);
15139 size_t maxlen
= (end
- p
) - 1;
15141 print_symbol ((int) maxlen
, (const char *) p
);
15142 p
+= strnlen ((char *) p
, maxlen
) + 1;
15146 printf (_("<corrupt>"));
15147 p
= (unsigned char *) end
;
15153 case Tag_ABI_conformance
:
15155 printf (" Tag_ABI_conformance: \"");
15158 size_t maxlen
= (end
- p
) - 1;
15160 print_symbol ((int) maxlen
, (const char *) p
);
15161 p
+= strnlen ((char *) p
, maxlen
) + 1;
15165 printf (_("<corrupt>"));
15166 p
= (unsigned char *) end
;
15173 return display_tag_value (tag
, p
, end
);
15177 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15179 unsigned long addr
= 0;
15180 size_t bytes
= end
- p
;
15187 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15189 printf (" 0x%8.8lx ", addr
);
15191 for (j
= 0; j
< 16; j
++)
15194 printf ("%2.2x", p
[j
]);
15202 for (j
= 0; j
< lbytes
; j
++)
15205 if (k
>= ' ' && k
< 0x7f)
15221 static unsigned char *
15222 display_msp430x_attribute (unsigned char * p
,
15223 const unsigned char * const end
)
15229 tag
= read_uleb128 (p
, & len
, end
);
15234 case OFBA_MSPABI_Tag_ISA
:
15235 val
= read_uleb128 (p
, &len
, end
);
15237 printf (" Tag_ISA: ");
15240 case 0: printf (_("None\n")); break;
15241 case 1: printf (_("MSP430\n")); break;
15242 case 2: printf (_("MSP430X\n")); break;
15243 default: printf ("??? (%d)\n", val
); break;
15247 case OFBA_MSPABI_Tag_Code_Model
:
15248 val
= read_uleb128 (p
, &len
, end
);
15250 printf (" Tag_Code_Model: ");
15253 case 0: printf (_("None\n")); break;
15254 case 1: printf (_("Small\n")); break;
15255 case 2: printf (_("Large\n")); break;
15256 default: printf ("??? (%d)\n", val
); break;
15260 case OFBA_MSPABI_Tag_Data_Model
:
15261 val
= read_uleb128 (p
, &len
, end
);
15263 printf (" Tag_Data_Model: ");
15266 case 0: printf (_("None\n")); break;
15267 case 1: printf (_("Small\n")); break;
15268 case 2: printf (_("Large\n")); break;
15269 case 3: printf (_("Restricted Large\n")); break;
15270 default: printf ("??? (%d)\n", val
); break;
15275 printf (_(" <unknown tag %d>: "), tag
);
15282 size_t maxlen
= (end
- p
) - 1;
15284 print_symbol ((int) maxlen
, (const char *) p
);
15285 p
+= strnlen ((char *) p
, maxlen
) + 1;
15289 printf (_("<corrupt>"));
15290 p
= (unsigned char *) end
;
15296 val
= read_uleb128 (p
, &len
, end
);
15298 printf ("%d (0x%x)\n", val
, val
);
15308 process_attributes (Filedata
* filedata
,
15309 const char * public_name
,
15310 unsigned int proc_type
,
15311 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15312 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15314 Elf_Internal_Shdr
* sect
;
15316 bfd_boolean res
= TRUE
;
15318 /* Find the section header so that we get the size. */
15319 for (i
= 0, sect
= filedata
->section_headers
;
15320 i
< filedata
->file_header
.e_shnum
;
15323 unsigned char * contents
;
15326 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15329 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15330 sect
->sh_size
, _("attributes"));
15331 if (contents
== NULL
)
15338 /* The first character is the version of the attributes.
15339 Currently only version 1, (aka 'A') is recognised here. */
15342 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15347 bfd_vma section_len
;
15349 section_len
= sect
->sh_size
- 1;
15352 while (section_len
> 0)
15355 unsigned int namelen
;
15356 bfd_boolean public_section
;
15357 bfd_boolean gnu_section
;
15359 if (section_len
<= 4)
15361 error (_("Tag section ends prematurely\n"));
15365 attr_len
= byte_get (p
, 4);
15368 if (attr_len
> section_len
)
15370 error (_("Bad attribute length (%u > %u)\n"),
15371 (unsigned) attr_len
, (unsigned) section_len
);
15372 attr_len
= section_len
;
15375 /* PR 17531: file: 001-101425-0.004 */
15376 else if (attr_len
< 5)
15378 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15383 section_len
-= attr_len
;
15386 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15387 if (namelen
== 0 || namelen
>= attr_len
)
15389 error (_("Corrupt attribute section name\n"));
15394 printf (_("Attribute Section: "));
15395 print_symbol (INT_MAX
, (const char *) p
);
15398 if (public_name
&& streq ((char *) p
, public_name
))
15399 public_section
= TRUE
;
15401 public_section
= FALSE
;
15403 if (streq ((char *) p
, "gnu"))
15404 gnu_section
= TRUE
;
15406 gnu_section
= FALSE
;
15409 attr_len
-= namelen
;
15411 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15416 unsigned char * end
;
15418 /* PR binutils/17531: Safe handling of corrupt files. */
15421 error (_("Unused bytes at end of section\n"));
15428 size
= byte_get (p
, 4);
15429 if (size
> attr_len
)
15431 error (_("Bad subsection length (%u > %u)\n"),
15432 (unsigned) size
, (unsigned) attr_len
);
15436 /* PR binutils/17531: Safe handling of corrupt files. */
15439 error (_("Bad subsection length (%u < 6)\n"),
15447 end
= p
+ size
- 1;
15448 assert (end
<= contents
+ sect
->sh_size
);
15454 printf (_("File Attributes\n"));
15457 printf (_("Section Attributes:"));
15460 printf (_("Symbol Attributes:"));
15461 /* Fall through. */
15467 val
= read_uleb128 (p
, &j
, end
);
15471 printf (" %d", val
);
15476 printf (_("Unknown tag: %d\n"), tag
);
15477 public_section
= FALSE
;
15481 if (public_section
&& display_pub_attribute
!= NULL
)
15484 p
= display_pub_attribute (p
, end
);
15487 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15490 p
= display_gnu_attribute (p
,
15491 display_proc_gnu_attribute
,
15497 printf (_(" Unknown attribute:\n"));
15498 display_raw_attribute (p
, end
);
15513 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15514 Print the Address, Access and Initial fields of an entry at VMA ADDR
15515 and return the VMA of the next entry, or -1 if there was a problem.
15516 Does not read from DATA_END or beyond. */
15519 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15520 unsigned char * data_end
)
15523 print_vma (addr
, LONG_HEX
);
15525 if (addr
< pltgot
+ 0xfff0)
15526 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15528 printf ("%10s", "");
15531 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15535 unsigned char * from
= data
+ addr
- pltgot
;
15537 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15539 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15540 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15541 return (bfd_vma
) -1;
15545 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15546 print_vma (entry
, LONG_HEX
);
15549 return addr
+ (is_32bit_elf
? 4 : 8);
15552 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15553 PLTGOT. Print the Address and Initial fields of an entry at VMA
15554 ADDR and return the VMA of the next entry. */
15557 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15560 print_vma (addr
, LONG_HEX
);
15563 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15568 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15569 print_vma (entry
, LONG_HEX
);
15571 return addr
+ (is_32bit_elf
? 4 : 8);
15575 print_mips_ases (unsigned int mask
)
15577 if (mask
& AFL_ASE_DSP
)
15578 fputs ("\n\tDSP ASE", stdout
);
15579 if (mask
& AFL_ASE_DSPR2
)
15580 fputs ("\n\tDSP R2 ASE", stdout
);
15581 if (mask
& AFL_ASE_DSPR3
)
15582 fputs ("\n\tDSP R3 ASE", stdout
);
15583 if (mask
& AFL_ASE_EVA
)
15584 fputs ("\n\tEnhanced VA Scheme", stdout
);
15585 if (mask
& AFL_ASE_MCU
)
15586 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15587 if (mask
& AFL_ASE_MDMX
)
15588 fputs ("\n\tMDMX ASE", stdout
);
15589 if (mask
& AFL_ASE_MIPS3D
)
15590 fputs ("\n\tMIPS-3D ASE", stdout
);
15591 if (mask
& AFL_ASE_MT
)
15592 fputs ("\n\tMT ASE", stdout
);
15593 if (mask
& AFL_ASE_SMARTMIPS
)
15594 fputs ("\n\tSmartMIPS ASE", stdout
);
15595 if (mask
& AFL_ASE_VIRT
)
15596 fputs ("\n\tVZ ASE", stdout
);
15597 if (mask
& AFL_ASE_MSA
)
15598 fputs ("\n\tMSA ASE", stdout
);
15599 if (mask
& AFL_ASE_MIPS16
)
15600 fputs ("\n\tMIPS16 ASE", stdout
);
15601 if (mask
& AFL_ASE_MICROMIPS
)
15602 fputs ("\n\tMICROMIPS ASE", stdout
);
15603 if (mask
& AFL_ASE_XPA
)
15604 fputs ("\n\tXPA ASE", stdout
);
15605 if (mask
& AFL_ASE_MIPS16E2
)
15606 fputs ("\n\tMIPS16e2 ASE", stdout
);
15607 if (mask
& AFL_ASE_CRC
)
15608 fputs ("\n\tCRC ASE", stdout
);
15609 if (mask
& AFL_ASE_GINV
)
15610 fputs ("\n\tGINV ASE", stdout
);
15611 if (mask
& AFL_ASE_LOONGSON_MMI
)
15612 fputs ("\n\tLoongson MMI ASE", stdout
);
15614 fprintf (stdout
, "\n\t%s", _("None"));
15615 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15616 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15620 print_mips_isa_ext (unsigned int isa_ext
)
15625 fputs (_("None"), stdout
);
15628 fputs ("RMI XLR", stdout
);
15630 case AFL_EXT_OCTEON3
:
15631 fputs ("Cavium Networks Octeon3", stdout
);
15633 case AFL_EXT_OCTEON2
:
15634 fputs ("Cavium Networks Octeon2", stdout
);
15636 case AFL_EXT_OCTEONP
:
15637 fputs ("Cavium Networks OcteonP", stdout
);
15639 case AFL_EXT_LOONGSON_3A
:
15640 fputs ("Loongson 3A", stdout
);
15642 case AFL_EXT_OCTEON
:
15643 fputs ("Cavium Networks Octeon", stdout
);
15646 fputs ("Toshiba R5900", stdout
);
15649 fputs ("MIPS R4650", stdout
);
15652 fputs ("LSI R4010", stdout
);
15655 fputs ("NEC VR4100", stdout
);
15658 fputs ("Toshiba R3900", stdout
);
15660 case AFL_EXT_10000
:
15661 fputs ("MIPS R10000", stdout
);
15664 fputs ("Broadcom SB-1", stdout
);
15667 fputs ("NEC VR4111/VR4181", stdout
);
15670 fputs ("NEC VR4120", stdout
);
15673 fputs ("NEC VR5400", stdout
);
15676 fputs ("NEC VR5500", stdout
);
15678 case AFL_EXT_LOONGSON_2E
:
15679 fputs ("ST Microelectronics Loongson 2E", stdout
);
15681 case AFL_EXT_LOONGSON_2F
:
15682 fputs ("ST Microelectronics Loongson 2F", stdout
);
15684 case AFL_EXT_INTERAPTIV_MR2
:
15685 fputs ("Imagination interAptiv MR2", stdout
);
15688 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15693 get_mips_reg_size (int reg_size
)
15695 return (reg_size
== AFL_REG_NONE
) ? 0
15696 : (reg_size
== AFL_REG_32
) ? 32
15697 : (reg_size
== AFL_REG_64
) ? 64
15698 : (reg_size
== AFL_REG_128
) ? 128
15703 process_mips_specific (Filedata
* filedata
)
15705 Elf_Internal_Dyn
* entry
;
15706 Elf_Internal_Shdr
*sect
= NULL
;
15707 size_t liblist_offset
= 0;
15708 size_t liblistno
= 0;
15709 size_t conflictsno
= 0;
15710 size_t options_offset
= 0;
15711 size_t conflicts_offset
= 0;
15712 size_t pltrelsz
= 0;
15714 bfd_vma pltgot
= 0;
15715 bfd_vma mips_pltgot
= 0;
15716 bfd_vma jmprel
= 0;
15717 bfd_vma local_gotno
= 0;
15718 bfd_vma gotsym
= 0;
15719 bfd_vma symtabno
= 0;
15720 bfd_boolean res
= TRUE
;
15722 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15723 display_mips_gnu_attribute
))
15726 sect
= find_section (filedata
, ".MIPS.abiflags");
15730 Elf_External_ABIFlags_v0
*abiflags_ext
;
15731 Elf_Internal_ABIFlags_v0 abiflags_in
;
15733 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15735 error (_("Corrupt MIPS ABI Flags section.\n"));
15740 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15741 sect
->sh_size
, _("MIPS ABI Flags section"));
15744 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15745 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15746 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15747 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15748 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15749 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15750 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15751 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15752 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15753 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15754 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15756 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15757 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15758 if (abiflags_in
.isa_rev
> 1)
15759 printf ("r%d", abiflags_in
.isa_rev
);
15760 printf ("\nGPR size: %d",
15761 get_mips_reg_size (abiflags_in
.gpr_size
));
15762 printf ("\nCPR1 size: %d",
15763 get_mips_reg_size (abiflags_in
.cpr1_size
));
15764 printf ("\nCPR2 size: %d",
15765 get_mips_reg_size (abiflags_in
.cpr2_size
));
15766 fputs ("\nFP ABI: ", stdout
);
15767 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15768 fputs ("ISA Extension: ", stdout
);
15769 print_mips_isa_ext (abiflags_in
.isa_ext
);
15770 fputs ("\nASEs:", stdout
);
15771 print_mips_ases (abiflags_in
.ases
);
15772 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15773 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15774 fputc ('\n', stdout
);
15775 free (abiflags_ext
);
15780 /* We have a lot of special sections. Thanks SGI! */
15781 if (dynamic_section
== NULL
)
15783 /* No dynamic information available. See if there is static GOT. */
15784 sect
= find_section (filedata
, ".got");
15787 unsigned char *data_end
;
15788 unsigned char *data
;
15792 pltgot
= sect
->sh_addr
;
15795 addr_size
= (is_32bit_elf
? 4 : 8);
15796 end
= pltgot
+ sect
->sh_size
;
15798 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15800 _("Global Offset Table data"));
15801 /* PR 12855: Null data is handled gracefully throughout. */
15802 data_end
= data
+ (end
- pltgot
);
15804 printf (_("\nStatic GOT:\n"));
15805 printf (_(" Canonical gp value: "));
15806 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15809 /* In a dynamic binary GOT[0] is reserved for the dynamic
15810 loader to store the lazy resolver pointer, however in
15811 a static binary it may well have been omitted and GOT
15812 reduced to a table of addresses.
15813 PR 21344: Check for the entry being fully available
15814 before fetching it. */
15816 && data
+ ent
- pltgot
+ addr_size
<= data_end
15817 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15819 printf (_(" Reserved entries:\n"));
15820 printf (_(" %*s %10s %*s\n"),
15821 addr_size
* 2, _("Address"), _("Access"),
15822 addr_size
* 2, _("Value"));
15823 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15825 if (ent
== (bfd_vma
) -1)
15826 goto sgot_print_fail
;
15828 /* Check for the MSB of GOT[1] being set, identifying a
15829 GNU object. This entry will be used by some runtime
15830 loaders, to store the module pointer. Otherwise this
15831 is an ordinary local entry.
15832 PR 21344: Check for the entry being fully available
15833 before fetching it. */
15835 && data
+ ent
- pltgot
+ addr_size
<= data_end
15836 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15837 >> (addr_size
* 8 - 1)) != 0)
15839 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15841 if (ent
== (bfd_vma
) -1)
15842 goto sgot_print_fail
;
15847 if (data
!= NULL
&& ent
< end
)
15849 printf (_(" Local entries:\n"));
15850 printf (" %*s %10s %*s\n",
15851 addr_size
* 2, _("Address"), _("Access"),
15852 addr_size
* 2, _("Value"));
15855 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15857 if (ent
== (bfd_vma
) -1)
15858 goto sgot_print_fail
;
15870 for (entry
= dynamic_section
;
15871 /* PR 17531 file: 012-50589-0.004. */
15872 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15874 switch (entry
->d_tag
)
15876 case DT_MIPS_LIBLIST
:
15878 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15879 liblistno
* sizeof (Elf32_External_Lib
));
15881 case DT_MIPS_LIBLISTNO
:
15882 liblistno
= entry
->d_un
.d_val
;
15884 case DT_MIPS_OPTIONS
:
15885 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15887 case DT_MIPS_CONFLICT
:
15889 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15890 conflictsno
* sizeof (Elf32_External_Conflict
));
15892 case DT_MIPS_CONFLICTNO
:
15893 conflictsno
= entry
->d_un
.d_val
;
15896 pltgot
= entry
->d_un
.d_ptr
;
15898 case DT_MIPS_LOCAL_GOTNO
:
15899 local_gotno
= entry
->d_un
.d_val
;
15901 case DT_MIPS_GOTSYM
:
15902 gotsym
= entry
->d_un
.d_val
;
15904 case DT_MIPS_SYMTABNO
:
15905 symtabno
= entry
->d_un
.d_val
;
15907 case DT_MIPS_PLTGOT
:
15908 mips_pltgot
= entry
->d_un
.d_ptr
;
15911 pltrel
= entry
->d_un
.d_val
;
15914 pltrelsz
= entry
->d_un
.d_val
;
15917 jmprel
= entry
->d_un
.d_ptr
;
15923 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15925 Elf32_External_Lib
* elib
;
15928 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15930 sizeof (Elf32_External_Lib
),
15931 _("liblist section data"));
15934 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15935 "\nSection '.liblist' contains %lu entries:\n",
15936 (unsigned long) liblistno
),
15937 (unsigned long) liblistno
);
15938 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15941 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15948 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15949 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15950 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15951 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15952 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15954 tmp
= gmtime (&atime
);
15955 snprintf (timebuf
, sizeof (timebuf
),
15956 "%04u-%02u-%02uT%02u:%02u:%02u",
15957 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15958 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15960 printf ("%3lu: ", (unsigned long) cnt
);
15961 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15962 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15964 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15965 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15966 liblist
.l_version
);
15968 if (liblist
.l_flags
== 0)
15972 static const struct
15979 { " EXACT_MATCH", LL_EXACT_MATCH
},
15980 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15981 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15982 { " EXPORTS", LL_EXPORTS
},
15983 { " DELAY_LOAD", LL_DELAY_LOAD
},
15984 { " DELTA", LL_DELTA
}
15986 int flags
= liblist
.l_flags
;
15989 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15990 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15992 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15993 flags
^= l_flags_vals
[fcnt
].bit
;
15996 printf (" %#x", (unsigned int) flags
);
16008 if (options_offset
!= 0)
16010 Elf_External_Options
* eopt
;
16011 Elf_Internal_Options
* iopt
;
16012 Elf_Internal_Options
* option
;
16015 sect
= filedata
->section_headers
;
16017 /* Find the section header so that we get the size. */
16018 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16019 /* PR 17533 file: 012-277276-0.004. */
16022 error (_("No MIPS_OPTIONS header found\n"));
16026 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16027 sect
->sh_size
, _("options"));
16030 iopt
= (Elf_Internal_Options
*)
16031 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16034 error (_("Out of memory allocating space for MIPS options\n"));
16041 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16043 Elf_External_Options
* eoption
;
16045 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16047 option
->kind
= BYTE_GET (eoption
->kind
);
16048 option
->size
= BYTE_GET (eoption
->size
);
16049 option
->section
= BYTE_GET (eoption
->section
);
16050 option
->info
= BYTE_GET (eoption
->info
);
16052 /* PR 17531: file: ffa0fa3b. */
16053 if (option
->size
< sizeof (* eopt
)
16054 || offset
+ option
->size
> sect
->sh_size
)
16056 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16059 offset
+= option
->size
;
16065 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16066 "\nSection '%s' contains %d entries:\n",
16068 printable_section_name (filedata
, sect
), cnt
);
16077 switch (option
->kind
)
16080 /* This shouldn't happen. */
16081 printf (" NULL %d %lx", option
->section
, option
->info
);
16084 printf (" REGINFO ");
16085 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16088 Elf32_External_RegInfo
* ereg
;
16089 Elf32_RegInfo reginfo
;
16091 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16092 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16093 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16094 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16095 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16096 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16097 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16099 printf ("GPR %08lx GP 0x%lx\n",
16100 reginfo
.ri_gprmask
,
16101 (unsigned long) reginfo
.ri_gp_value
);
16102 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16103 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16104 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16109 Elf64_External_RegInfo
* ereg
;
16110 Elf64_Internal_RegInfo reginfo
;
16112 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16113 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16114 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16115 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16116 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16117 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16118 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16120 printf ("GPR %08lx GP 0x",
16121 reginfo
.ri_gprmask
);
16122 printf_vma (reginfo
.ri_gp_value
);
16125 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16126 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16127 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16131 case ODK_EXCEPTIONS
:
16132 fputs (" EXCEPTIONS fpe_min(", stdout
);
16133 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16134 fputs (") fpe_max(", stdout
);
16135 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16136 fputs (")", stdout
);
16138 if (option
->info
& OEX_PAGE0
)
16139 fputs (" PAGE0", stdout
);
16140 if (option
->info
& OEX_SMM
)
16141 fputs (" SMM", stdout
);
16142 if (option
->info
& OEX_FPDBUG
)
16143 fputs (" FPDBUG", stdout
);
16144 if (option
->info
& OEX_DISMISS
)
16145 fputs (" DISMISS", stdout
);
16148 fputs (" PAD ", stdout
);
16149 if (option
->info
& OPAD_PREFIX
)
16150 fputs (" PREFIX", stdout
);
16151 if (option
->info
& OPAD_POSTFIX
)
16152 fputs (" POSTFIX", stdout
);
16153 if (option
->info
& OPAD_SYMBOL
)
16154 fputs (" SYMBOL", stdout
);
16157 fputs (" HWPATCH ", stdout
);
16158 if (option
->info
& OHW_R4KEOP
)
16159 fputs (" R4KEOP", stdout
);
16160 if (option
->info
& OHW_R8KPFETCH
)
16161 fputs (" R8KPFETCH", stdout
);
16162 if (option
->info
& OHW_R5KEOP
)
16163 fputs (" R5KEOP", stdout
);
16164 if (option
->info
& OHW_R5KCVTL
)
16165 fputs (" R5KCVTL", stdout
);
16168 fputs (" FILL ", stdout
);
16169 /* XXX Print content of info word? */
16172 fputs (" TAGS ", stdout
);
16173 /* XXX Print content of info word? */
16176 fputs (" HWAND ", stdout
);
16177 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16178 fputs (" R4KEOP_CHECKED", stdout
);
16179 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16180 fputs (" R4KEOP_CLEAN", stdout
);
16183 fputs (" HWOR ", stdout
);
16184 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16185 fputs (" R4KEOP_CHECKED", stdout
);
16186 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16187 fputs (" R4KEOP_CLEAN", stdout
);
16190 printf (" GP_GROUP %#06lx self-contained %#06lx",
16191 option
->info
& OGP_GROUP
,
16192 (option
->info
& OGP_SELF
) >> 16);
16195 printf (" IDENT %#06lx self-contained %#06lx",
16196 option
->info
& OGP_GROUP
,
16197 (option
->info
& OGP_SELF
) >> 16);
16200 /* This shouldn't happen. */
16201 printf (" %3d ??? %d %lx",
16202 option
->kind
, option
->section
, option
->info
);
16206 len
= sizeof (* eopt
);
16207 while (len
< option
->size
)
16209 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16211 if (ISPRINT (datum
))
16212 printf ("%c", datum
);
16214 printf ("\\%03o", datum
);
16217 fputs ("\n", stdout
);
16219 offset
+= option
->size
;
16229 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16231 Elf32_Conflict
* iconf
;
16234 if (dynamic_symbols
== NULL
)
16236 error (_("conflict list found without a dynamic symbol table\n"));
16240 /* PR 21345 - print a slightly more helpful error message
16241 if we are sure that the cmalloc will fail. */
16242 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16244 error (_("Overlarge number of conflicts detected: %lx\n"),
16245 (long) conflictsno
);
16249 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16252 error (_("Out of memory allocating space for dynamic conflicts\n"));
16258 Elf32_External_Conflict
* econf32
;
16260 econf32
= (Elf32_External_Conflict
*)
16261 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16262 sizeof (* econf32
), _("conflict"));
16266 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16267 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16273 Elf64_External_Conflict
* econf64
;
16275 econf64
= (Elf64_External_Conflict
*)
16276 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16277 sizeof (* econf64
), _("conflict"));
16281 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16282 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16287 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16288 "\nSection '.conflict' contains %lu entries:\n",
16289 (unsigned long) conflictsno
),
16290 (unsigned long) conflictsno
);
16291 puts (_(" Num: Index Value Name"));
16293 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16295 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16297 if (iconf
[cnt
] >= num_dynamic_syms
)
16298 printf (_("<corrupt symbol index>"));
16301 Elf_Internal_Sym
* psym
;
16303 psym
= & dynamic_symbols
[iconf
[cnt
]];
16304 print_vma (psym
->st_value
, FULL_HEX
);
16306 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16307 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16309 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16317 if (pltgot
!= 0 && local_gotno
!= 0)
16319 bfd_vma ent
, local_end
, global_end
;
16321 unsigned char * data
;
16322 unsigned char * data_end
;
16326 addr_size
= (is_32bit_elf
? 4 : 8);
16327 local_end
= pltgot
+ local_gotno
* addr_size
;
16329 /* PR binutils/17533 file: 012-111227-0.004 */
16330 if (symtabno
< gotsym
)
16332 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16333 (unsigned long) gotsym
, (unsigned long) symtabno
);
16337 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16338 /* PR 17531: file: 54c91a34. */
16339 if (global_end
< local_end
)
16341 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16345 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16346 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16347 global_end
- pltgot
, 1,
16348 _("Global Offset Table data"));
16349 /* PR 12855: Null data is handled gracefully throughout. */
16350 data_end
= data
+ (global_end
- pltgot
);
16352 printf (_("\nPrimary GOT:\n"));
16353 printf (_(" Canonical gp value: "));
16354 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16357 printf (_(" Reserved entries:\n"));
16358 printf (_(" %*s %10s %*s Purpose\n"),
16359 addr_size
* 2, _("Address"), _("Access"),
16360 addr_size
* 2, _("Initial"));
16361 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16362 printf (_(" Lazy resolver\n"));
16363 if (ent
== (bfd_vma
) -1)
16364 goto got_print_fail
;
16366 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16367 This entry will be used by some runtime loaders, to store the
16368 module pointer. Otherwise this is an ordinary local entry.
16369 PR 21344: Check for the entry being fully available before
16372 && data
+ ent
- pltgot
+ addr_size
<= data_end
16373 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16374 >> (addr_size
* 8 - 1)) != 0)
16376 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16377 printf (_(" Module pointer (GNU extension)\n"));
16378 if (ent
== (bfd_vma
) -1)
16379 goto got_print_fail
;
16383 if (data
!= NULL
&& ent
< local_end
)
16385 printf (_(" Local entries:\n"));
16386 printf (" %*s %10s %*s\n",
16387 addr_size
* 2, _("Address"), _("Access"),
16388 addr_size
* 2, _("Initial"));
16389 while (ent
< local_end
)
16391 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16393 if (ent
== (bfd_vma
) -1)
16394 goto got_print_fail
;
16399 if (data
!= NULL
&& gotsym
< symtabno
)
16403 printf (_(" Global entries:\n"));
16404 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16405 addr_size
* 2, _("Address"),
16407 addr_size
* 2, _("Initial"),
16408 addr_size
* 2, _("Sym.Val."),
16410 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16411 _("Ndx"), _("Name"));
16413 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16415 for (i
= gotsym
; i
< symtabno
; i
++)
16417 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16420 if (dynamic_symbols
== NULL
)
16421 printf (_("<no dynamic symbols>"));
16422 else if (i
< num_dynamic_syms
)
16424 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16426 print_vma (psym
->st_value
, LONG_HEX
);
16427 printf (" %-7s %3s ",
16428 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16429 get_symbol_index_type (filedata
, psym
->st_shndx
));
16431 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16432 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16434 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16437 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16438 (unsigned long) i
);
16441 if (ent
== (bfd_vma
) -1)
16452 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16455 size_t offset
, rel_offset
;
16456 unsigned long count
, i
;
16457 unsigned char * data
;
16458 int addr_size
, sym_width
;
16459 Elf_Internal_Rela
* rels
;
16461 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16462 if (pltrel
== DT_RELA
)
16464 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16469 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16474 addr_size
= (is_32bit_elf
? 4 : 8);
16475 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16477 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16478 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16479 1, _("Procedure Linkage Table data"));
16483 printf ("\nPLT GOT:\n\n");
16484 printf (_(" Reserved entries:\n"));
16485 printf (_(" %*s %*s Purpose\n"),
16486 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16487 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16488 printf (_(" PLT lazy resolver\n"));
16489 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16490 printf (_(" Module pointer\n"));
16493 printf (_(" Entries:\n"));
16494 printf (" %*s %*s %*s %-7s %3s %s\n",
16495 addr_size
* 2, _("Address"),
16496 addr_size
* 2, _("Initial"),
16497 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16498 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16499 for (i
= 0; i
< count
; i
++)
16501 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16503 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16506 if (idx
>= num_dynamic_syms
)
16507 printf (_("<corrupt symbol index: %lu>"), idx
);
16510 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16512 print_vma (psym
->st_value
, LONG_HEX
);
16513 printf (" %-7s %3s ",
16514 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16515 get_symbol_index_type (filedata
, psym
->st_shndx
));
16516 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16517 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16519 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16534 process_nds32_specific (Filedata
* filedata
)
16536 Elf_Internal_Shdr
*sect
= NULL
;
16538 sect
= find_section (filedata
, ".nds32_e_flags");
16541 unsigned int *flag
;
16543 printf ("\nNDS32 elf flags section:\n");
16544 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16545 sect
->sh_size
, _("NDS32 elf flags section"));
16550 switch ((*flag
) & 0x3)
16553 printf ("(VEC_SIZE):\tNo entry.\n");
16556 printf ("(VEC_SIZE):\t4 bytes\n");
16559 printf ("(VEC_SIZE):\t16 bytes\n");
16562 printf ("(VEC_SIZE):\treserved\n");
16571 process_gnu_liblist (Filedata
* filedata
)
16573 Elf_Internal_Shdr
* section
;
16574 Elf_Internal_Shdr
* string_sec
;
16575 Elf32_External_Lib
* elib
;
16577 size_t strtab_size
;
16579 unsigned long num_liblist
;
16581 bfd_boolean res
= TRUE
;
16586 for (i
= 0, section
= filedata
->section_headers
;
16587 i
< filedata
->file_header
.e_shnum
;
16590 switch (section
->sh_type
)
16592 case SHT_GNU_LIBLIST
:
16593 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16596 elib
= (Elf32_External_Lib
*)
16597 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16598 _("liblist section data"));
16606 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16607 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16608 string_sec
->sh_size
,
16609 _("liblist string table"));
16611 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16618 strtab_size
= string_sec
->sh_size
;
16620 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16621 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16622 "\nLibrary list section '%s' contains %lu entries:\n",
16624 printable_section_name (filedata
, section
),
16627 puts (_(" Library Time Stamp Checksum Version Flags"));
16629 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16637 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16638 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16639 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16640 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16641 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16643 tmp
= gmtime (&atime
);
16644 snprintf (timebuf
, sizeof (timebuf
),
16645 "%04u-%02u-%02uT%02u:%02u:%02u",
16646 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16647 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16649 printf ("%3lu: ", (unsigned long) cnt
);
16651 printf ("%-20s", liblist
.l_name
< strtab_size
16652 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16654 printf ("%-20.20s", liblist
.l_name
< strtab_size
16655 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16656 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16657 liblist
.l_version
, liblist
.l_flags
);
16668 static const char *
16669 get_note_type (Filedata
* filedata
, unsigned e_type
)
16671 static char buff
[64];
16673 if (filedata
->file_header
.e_type
== ET_CORE
)
16677 return _("NT_AUXV (auxiliary vector)");
16679 return _("NT_PRSTATUS (prstatus structure)");
16681 return _("NT_FPREGSET (floating point registers)");
16683 return _("NT_PRPSINFO (prpsinfo structure)");
16684 case NT_TASKSTRUCT
:
16685 return _("NT_TASKSTRUCT (task structure)");
16687 return _("NT_PRXFPREG (user_xfpregs structure)");
16689 return _("NT_PPC_VMX (ppc Altivec registers)");
16691 return _("NT_PPC_VSX (ppc VSX registers)");
16693 return _("NT_PPC_TAR (ppc TAR register)");
16695 return _("NT_PPC_PPR (ppc PPR register)");
16697 return _("NT_PPC_DSCR (ppc DSCR register)");
16699 return _("NT_PPC_EBB (ppc EBB registers)");
16701 return _("NT_PPC_PMU (ppc PMU registers)");
16702 case NT_PPC_TM_CGPR
:
16703 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16704 case NT_PPC_TM_CFPR
:
16705 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16706 case NT_PPC_TM_CVMX
:
16707 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16708 case NT_PPC_TM_CVSX
:
16709 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16710 case NT_PPC_TM_SPR
:
16711 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16712 case NT_PPC_TM_CTAR
:
16713 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16714 case NT_PPC_TM_CPPR
:
16715 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16716 case NT_PPC_TM_CDSCR
:
16717 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16719 return _("NT_386_TLS (x86 TLS information)");
16720 case NT_386_IOPERM
:
16721 return _("NT_386_IOPERM (x86 I/O permissions)");
16722 case NT_X86_XSTATE
:
16723 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16724 case NT_S390_HIGH_GPRS
:
16725 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16726 case NT_S390_TIMER
:
16727 return _("NT_S390_TIMER (s390 timer register)");
16728 case NT_S390_TODCMP
:
16729 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16730 case NT_S390_TODPREG
:
16731 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16733 return _("NT_S390_CTRS (s390 control registers)");
16734 case NT_S390_PREFIX
:
16735 return _("NT_S390_PREFIX (s390 prefix register)");
16736 case NT_S390_LAST_BREAK
:
16737 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16738 case NT_S390_SYSTEM_CALL
:
16739 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16741 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16742 case NT_S390_VXRS_LOW
:
16743 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16744 case NT_S390_VXRS_HIGH
:
16745 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16746 case NT_S390_GS_CB
:
16747 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16748 case NT_S390_GS_BC
:
16749 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16751 return _("NT_ARM_VFP (arm VFP registers)");
16753 return _("NT_ARM_TLS (AArch TLS registers)");
16754 case NT_ARM_HW_BREAK
:
16755 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16756 case NT_ARM_HW_WATCH
:
16757 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16759 return _("NT_PSTATUS (pstatus structure)");
16761 return _("NT_FPREGS (floating point registers)");
16763 return _("NT_PSINFO (psinfo structure)");
16765 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16767 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16768 case NT_WIN32PSTATUS
:
16769 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16771 return _("NT_SIGINFO (siginfo_t data)");
16773 return _("NT_FILE (mapped files)");
16781 return _("NT_VERSION (version)");
16783 return _("NT_ARCH (architecture)");
16784 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16786 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16792 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16797 print_core_note (Elf_Internal_Note
*pnote
)
16799 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16800 bfd_vma count
, page_size
;
16801 unsigned char *descdata
, *filenames
, *descend
;
16803 if (pnote
->type
!= NT_FILE
)
16813 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16814 /* Still "successful". */
16819 if (pnote
->descsz
< 2 * addr_size
)
16821 error (_(" Malformed note - too short for header\n"));
16825 descdata
= (unsigned char *) pnote
->descdata
;
16826 descend
= descdata
+ pnote
->descsz
;
16828 if (descdata
[pnote
->descsz
- 1] != '\0')
16830 error (_(" Malformed note - does not end with \\0\n"));
16834 count
= byte_get (descdata
, addr_size
);
16835 descdata
+= addr_size
;
16837 page_size
= byte_get (descdata
, addr_size
);
16838 descdata
+= addr_size
;
16840 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16841 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16843 error (_(" Malformed note - too short for supplied file count\n"));
16847 printf (_(" Page size: "));
16848 print_vma (page_size
, DEC
);
16851 printf (_(" %*s%*s%*s\n"),
16852 (int) (2 + 2 * addr_size
), _("Start"),
16853 (int) (4 + 2 * addr_size
), _("End"),
16854 (int) (4 + 2 * addr_size
), _("Page Offset"));
16855 filenames
= descdata
+ count
* 3 * addr_size
;
16856 while (count
-- > 0)
16858 bfd_vma start
, end
, file_ofs
;
16860 if (filenames
== descend
)
16862 error (_(" Malformed note - filenames end too early\n"));
16866 start
= byte_get (descdata
, addr_size
);
16867 descdata
+= addr_size
;
16868 end
= byte_get (descdata
, addr_size
);
16869 descdata
+= addr_size
;
16870 file_ofs
= byte_get (descdata
, addr_size
);
16871 descdata
+= addr_size
;
16874 print_vma (start
, FULL_HEX
);
16876 print_vma (end
, FULL_HEX
);
16878 print_vma (file_ofs
, FULL_HEX
);
16879 printf ("\n %s\n", filenames
);
16881 filenames
+= 1 + strlen ((char *) filenames
);
16887 static const char *
16888 get_gnu_elf_note_type (unsigned e_type
)
16890 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16893 case NT_GNU_ABI_TAG
:
16894 return _("NT_GNU_ABI_TAG (ABI version tag)");
16896 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16897 case NT_GNU_BUILD_ID
:
16898 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16899 case NT_GNU_GOLD_VERSION
:
16900 return _("NT_GNU_GOLD_VERSION (gold version)");
16901 case NT_GNU_PROPERTY_TYPE_0
:
16902 return _("NT_GNU_PROPERTY_TYPE_0");
16903 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16904 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16905 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16906 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16909 static char buff
[64];
16911 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16918 decode_x86_isa (unsigned int bitmask
)
16922 unsigned int bit
= bitmask
& (- bitmask
);
16927 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16928 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16929 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16930 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16931 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16932 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16933 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16934 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16935 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16936 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16937 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16938 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16939 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16940 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16941 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16942 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16943 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16944 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16945 default: printf (_("<unknown: %x>"), bit
); break;
16953 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16957 unsigned int bit
= bitmask
& (- bitmask
);
16962 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16965 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16969 /* This should never happen. */
16973 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16976 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16980 /* This should never happen. */
16985 printf (_("<unknown: %x>"), bit
);
16994 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
16996 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16997 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16998 unsigned int size
= is_32bit_elf
? 4 : 8;
17000 printf (_(" Properties: "));
17002 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17004 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17008 while (ptr
< ptr_end
)
17012 unsigned int datasz
;
17014 if ((size_t) (ptr_end
- ptr
) < 8)
17016 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17020 type
= byte_get (ptr
, 4);
17021 datasz
= byte_get (ptr
+ 4, 4);
17025 if (datasz
> (size_t) (ptr_end
- ptr
))
17027 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17032 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17034 if (filedata
->file_header
.e_machine
== EM_X86_64
17035 || filedata
->file_header
.e_machine
== EM_IAMCU
17036 || filedata
->file_header
.e_machine
== EM_386
)
17040 case GNU_PROPERTY_X86_ISA_1_USED
:
17041 printf ("x86 ISA used: ");
17043 printf (_("<corrupt length: %#x> "), datasz
);
17045 decode_x86_isa (byte_get (ptr
, 4));
17048 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17049 printf ("x86 ISA needed: ");
17051 printf (_("<corrupt length: %#x> "), datasz
);
17053 decode_x86_isa (byte_get (ptr
, 4));
17056 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17057 printf ("x86 feature: ");
17059 printf (_("<corrupt length: %#x> "), datasz
);
17061 decode_x86_feature (type
, byte_get (ptr
, 4));
17073 case GNU_PROPERTY_STACK_SIZE
:
17074 printf (_("stack size: "));
17075 if (datasz
!= size
)
17076 printf (_("<corrupt length: %#x> "), datasz
);
17078 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17081 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17082 printf ("no copy on protected ");
17084 printf (_("<corrupt length: %#x> "), datasz
);
17092 if (type
< GNU_PROPERTY_LOPROC
)
17093 printf (_("<unknown type %#x data: "), type
);
17094 else if (type
< GNU_PROPERTY_LOUSER
)
17095 printf (_("<procesor-specific type %#x data: "), type
);
17097 printf (_("<application-specific type %#x data: "), type
);
17098 for (j
= 0; j
< datasz
; ++j
)
17099 printf ("%02x ", ptr
[j
] & 0xff);
17103 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17104 if (ptr
== ptr_end
)
17117 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17119 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17120 switch (pnote
->type
)
17122 case NT_GNU_BUILD_ID
:
17126 printf (_(" Build ID: "));
17127 for (i
= 0; i
< pnote
->descsz
; ++i
)
17128 printf ("%02x", pnote
->descdata
[i
] & 0xff);
17133 case NT_GNU_ABI_TAG
:
17135 unsigned long os
, major
, minor
, subminor
;
17136 const char *osname
;
17138 /* PR 17531: file: 030-599401-0.004. */
17139 if (pnote
->descsz
< 16)
17141 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17145 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17146 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17147 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
17148 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
17152 case GNU_ABI_TAG_LINUX
:
17155 case GNU_ABI_TAG_HURD
:
17158 case GNU_ABI_TAG_SOLARIS
:
17159 osname
= "Solaris";
17161 case GNU_ABI_TAG_FREEBSD
:
17162 osname
= "FreeBSD";
17164 case GNU_ABI_TAG_NETBSD
:
17167 case GNU_ABI_TAG_SYLLABLE
:
17168 osname
= "Syllable";
17170 case GNU_ABI_TAG_NACL
:
17174 osname
= "Unknown";
17178 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17179 major
, minor
, subminor
);
17183 case NT_GNU_GOLD_VERSION
:
17187 printf (_(" Version: "));
17188 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17189 printf ("%c", pnote
->descdata
[i
]);
17196 unsigned long num_entries
, mask
;
17198 /* Hardware capabilities information. Word 0 is the number of entries.
17199 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17200 is a series of entries, where each entry is a single byte followed
17201 by a nul terminated string. The byte gives the bit number to test
17202 if enabled in the bitmask. */
17203 printf (_(" Hardware Capabilities: "));
17204 if (pnote
->descsz
< 8)
17206 error (_("<corrupt GNU_HWCAP>\n"));
17209 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17210 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17211 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17212 /* FIXME: Add code to display the entries... */
17216 case NT_GNU_PROPERTY_TYPE_0
:
17217 print_gnu_property_note (filedata
, pnote
);
17221 /* Handle unrecognised types. An error message should have already been
17222 created by get_gnu_elf_note_type(), so all that we need to do is to
17223 display the data. */
17227 printf (_(" Description data: "));
17228 for (i
= 0; i
< pnote
->descsz
; ++i
)
17229 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17238 static const char *
17239 get_v850_elf_note_type (enum v850_notes n_type
)
17241 static char buff
[64];
17245 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17246 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17247 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17248 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17249 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17250 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17252 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17258 print_v850_note (Elf_Internal_Note
* pnote
)
17262 if (pnote
->descsz
!= 4)
17265 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17269 printf (_("not set\n"));
17273 switch (pnote
->type
)
17275 case V850_NOTE_ALIGNMENT
:
17278 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17279 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17283 case V850_NOTE_DATA_SIZE
:
17286 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17287 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17291 case V850_NOTE_FPU_INFO
:
17294 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17295 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17299 case V850_NOTE_MMU_INFO
:
17300 case V850_NOTE_CACHE_INFO
:
17301 case V850_NOTE_SIMD_INFO
:
17302 if (val
== EF_RH850_SIMD
)
17304 printf (_("yes\n"));
17310 /* An 'unknown note type' message will already have been displayed. */
17314 printf (_("unknown value: %x\n"), val
);
17319 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17321 unsigned int version
;
17323 switch (pnote
->type
)
17325 case NT_NETBSD_IDENT
:
17326 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17327 if ((version
/ 10000) % 100)
17328 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17329 version
, version
/ 100000000, (version
/ 1000000) % 100,
17330 (version
/ 10000) % 100 > 26 ? "Z" : "",
17331 'A' + (version
/ 10000) % 26);
17333 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17334 version
, version
/ 100000000, (version
/ 1000000) % 100,
17335 (version
/ 100) % 100);
17338 case NT_NETBSD_MARCH
:
17339 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17344 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17350 static const char *
17351 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17355 case NT_FREEBSD_THRMISC
:
17356 return _("NT_THRMISC (thrmisc structure)");
17357 case NT_FREEBSD_PROCSTAT_PROC
:
17358 return _("NT_PROCSTAT_PROC (proc data)");
17359 case NT_FREEBSD_PROCSTAT_FILES
:
17360 return _("NT_PROCSTAT_FILES (files data)");
17361 case NT_FREEBSD_PROCSTAT_VMMAP
:
17362 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17363 case NT_FREEBSD_PROCSTAT_GROUPS
:
17364 return _("NT_PROCSTAT_GROUPS (groups data)");
17365 case NT_FREEBSD_PROCSTAT_UMASK
:
17366 return _("NT_PROCSTAT_UMASK (umask data)");
17367 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17368 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17369 case NT_FREEBSD_PROCSTAT_OSREL
:
17370 return _("NT_PROCSTAT_OSREL (osreldate data)");
17371 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17372 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17373 case NT_FREEBSD_PROCSTAT_AUXV
:
17374 return _("NT_PROCSTAT_AUXV (auxv data)");
17375 case NT_FREEBSD_PTLWPINFO
:
17376 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17378 return get_note_type (filedata
, e_type
);
17381 static const char *
17382 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17384 static char buff
[64];
17386 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17387 return _("NetBSD procinfo structure");
17389 /* As of Jan 2002 there are no other machine-independent notes
17390 defined for NetBSD core files. If the note type is less
17391 than the start of the machine-dependent note types, we don't
17394 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17396 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17400 switch (filedata
->file_header
.e_machine
)
17402 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17403 and PT_GETFPREGS == mach+2. */
17408 case EM_SPARC32PLUS
:
17412 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17413 return _("PT_GETREGS (reg structure)");
17414 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17415 return _("PT_GETFPREGS (fpreg structure)");
17421 /* On all other arch's, PT_GETREGS == mach+1 and
17422 PT_GETFPREGS == mach+3. */
17426 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17427 return _("PT_GETREGS (reg structure)");
17428 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17429 return _("PT_GETFPREGS (fpreg structure)");
17435 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17436 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17440 static const char *
17441 get_stapsdt_note_type (unsigned e_type
)
17443 static char buff
[64];
17448 return _("NT_STAPSDT (SystemTap probe descriptors)");
17454 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17459 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17461 int addr_size
= is_32bit_elf
? 4 : 8;
17462 char *data
= pnote
->descdata
;
17463 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17464 bfd_vma pc
, base_addr
, semaphore
;
17465 char *provider
, *probe
, *arg_fmt
;
17467 pc
= byte_get ((unsigned char *) data
, addr_size
);
17469 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17471 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17475 data
+= strlen (data
) + 1;
17477 data
+= strlen (data
) + 1;
17479 data
+= strlen (data
) + 1;
17481 printf (_(" Provider: %s\n"), provider
);
17482 printf (_(" Name: %s\n"), probe
);
17483 printf (_(" Location: "));
17484 print_vma (pc
, FULL_HEX
);
17485 printf (_(", Base: "));
17486 print_vma (base_addr
, FULL_HEX
);
17487 printf (_(", Semaphore: "));
17488 print_vma (semaphore
, FULL_HEX
);
17490 printf (_(" Arguments: %s\n"), arg_fmt
);
17492 return data
== data_end
;
17495 static const char *
17496 get_ia64_vms_note_type (unsigned e_type
)
17498 static char buff
[64];
17503 return _("NT_VMS_MHD (module header)");
17505 return _("NT_VMS_LNM (language name)");
17507 return _("NT_VMS_SRC (source files)");
17509 return "NT_VMS_TITLE";
17511 return _("NT_VMS_EIDC (consistency check)");
17512 case NT_VMS_FPMODE
:
17513 return _("NT_VMS_FPMODE (FP mode)");
17514 case NT_VMS_LINKTIME
:
17515 return "NT_VMS_LINKTIME";
17516 case NT_VMS_IMGNAM
:
17517 return _("NT_VMS_IMGNAM (image name)");
17519 return _("NT_VMS_IMGID (image id)");
17520 case NT_VMS_LINKID
:
17521 return _("NT_VMS_LINKID (link id)");
17522 case NT_VMS_IMGBID
:
17523 return _("NT_VMS_IMGBID (build id)");
17524 case NT_VMS_GSTNAM
:
17525 return _("NT_VMS_GSTNAM (sym table name)");
17526 case NT_VMS_ORIG_DYN
:
17527 return "NT_VMS_ORIG_DYN";
17528 case NT_VMS_PATCHTIME
:
17529 return "NT_VMS_PATCHTIME";
17531 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17537 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17539 switch (pnote
->type
)
17542 if (pnote
->descsz
> 36)
17544 size_t l
= strlen (pnote
->descdata
+ 34);
17545 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17546 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17547 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17548 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17551 printf (_(" Invalid size\n"));
17554 printf (_(" Language: %s\n"), pnote
->descdata
);
17557 case NT_VMS_FPMODE
:
17558 printf (_(" Floating Point mode: "));
17559 printf ("0x%016" BFD_VMA_FMT
"x\n",
17560 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17562 case NT_VMS_LINKTIME
:
17563 printf (_(" Link time: "));
17565 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17568 case NT_VMS_PATCHTIME
:
17569 printf (_(" Patch time: "));
17571 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17574 case NT_VMS_ORIG_DYN
:
17575 printf (_(" Major id: %u, minor id: %u\n"),
17576 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17577 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17578 printf (_(" Last modified : "));
17580 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17581 printf (_("\n Link flags : "));
17582 printf ("0x%016" BFD_VMA_FMT
"x\n",
17583 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17584 printf (_(" Header flags: 0x%08x\n"),
17585 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17586 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17589 case NT_VMS_IMGNAM
:
17590 printf (_(" Image name: %s\n"), pnote
->descdata
);
17592 case NT_VMS_GSTNAM
:
17593 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17596 printf (_(" Image id: %s\n"), pnote
->descdata
);
17598 case NT_VMS_LINKID
:
17599 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17607 /* Find the symbol associated with a build attribute that is attached
17608 to address OFFSET. If PNAME is non-NULL then store the name of
17609 the symbol (if found) in the provided pointer, Returns NULL if a
17610 symbol could not be found. */
17612 static Elf_Internal_Sym
*
17613 get_symbol_for_build_attribute (Filedata
* filedata
,
17614 unsigned long offset
,
17615 bfd_boolean is_open_attr
,
17616 const char ** pname
)
17618 static Filedata
* saved_filedata
= NULL
;
17619 static char * strtab
;
17620 static unsigned long strtablen
;
17621 static Elf_Internal_Sym
* symtab
;
17622 static unsigned long nsyms
;
17623 Elf_Internal_Sym
* saved_sym
= NULL
;
17624 Elf_Internal_Sym
* sym
;
17626 if (filedata
->section_headers
!= NULL
17627 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17629 Elf_Internal_Shdr
* symsec
;
17631 /* Load the symbol and string sections. */
17632 for (symsec
= filedata
->section_headers
;
17633 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17636 if (symsec
->sh_type
== SHT_SYMTAB
)
17638 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17640 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17642 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17644 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17645 1, strtab_sec
->sh_size
,
17646 _("string table"));
17647 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17651 saved_filedata
= filedata
;
17654 if (symtab
== NULL
|| strtab
== NULL
)
17657 /* Find a symbol whose value matches offset. */
17658 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17659 if (sym
->st_value
== offset
)
17661 if (sym
->st_name
>= strtablen
)
17662 /* Huh ? This should not happen. */
17665 if (strtab
[sym
->st_name
] == 0)
17668 /* The AArch64 and ARM architectures define mapping symbols
17669 (eg $d, $x, $t) which we want to ignore. */
17670 if (strtab
[sym
->st_name
] == '$'
17671 && strtab
[sym
->st_name
+ 1] != 0
17672 && strtab
[sym
->st_name
+ 2] == 0)
17677 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17678 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17679 FUNC symbols entirely. */
17680 switch (ELF_ST_TYPE (sym
->st_info
))
17687 /* If the symbol has a size associated
17688 with it then we can stop searching. */
17689 sym
= symtab
+ nsyms
;
17694 /* Ignore function symbols. */
17701 switch (ELF_ST_BIND (sym
->st_info
))
17704 if (saved_sym
== NULL
17705 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17710 if (saved_sym
== NULL
)
17720 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17728 if (saved_sym
&& pname
)
17729 * pname
= strtab
+ saved_sym
->st_name
;
17734 /* Returns true iff addr1 and addr2 are in the same section. */
17737 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
17739 Elf_Internal_Shdr
* a1
;
17740 Elf_Internal_Shdr
* a2
;
17742 a1
= find_section_by_address (filedata
, addr1
);
17743 a2
= find_section_by_address (filedata
, addr2
);
17745 return a1
== a2
&& a1
!= NULL
;
17749 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17750 Filedata
* filedata
)
17752 static unsigned long global_offset
= 0;
17753 static unsigned long global_end
= 0;
17754 static unsigned long func_offset
= 0;
17755 static unsigned long func_end
= 0;
17757 Elf_Internal_Sym
* sym
;
17759 unsigned long start
;
17761 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17763 switch (pnote
->descsz
)
17766 /* A zero-length description means that the range of
17767 the previous note of the same type should be used. */
17770 if (global_end
> global_offset
)
17771 printf (_(" Applies to region from %#lx to %#lx\n"),
17772 global_offset
, global_end
);
17774 printf (_(" Applies to region from %#lx\n"), global_offset
);
17778 if (func_end
> func_offset
)
17779 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
17781 printf (_(" Applies to region from %#lx\n"), func_offset
);
17786 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17793 /* FIXME: We should check that version 3+ notes are being used here... */
17794 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17795 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17799 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17805 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17806 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
17810 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17811 printf (_(" <invalid descsz>"));
17816 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
17817 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17818 in order to avoid them being confused with the start address of the
17819 first function in the file... */
17820 if (sym
== NULL
&& is_open_attr
)
17821 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
17824 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
17825 end
= start
+ sym
->st_size
;
17829 /* FIXME: Need to properly allow for section alignment.
17830 16 is just the alignment used on x86_64. */
17832 && start
> BFD_ALIGN (global_end
, 16)
17833 /* Build notes are not guaranteed to be organised in order of
17834 increasing address, but we should find the all of the notes
17835 for one section in the same place. */
17836 && same_section (filedata
, start
, global_end
))
17837 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17838 global_end
+ 1, start
- 1);
17840 printf (_(" Applies to region from %#lx"), start
);
17841 global_offset
= start
;
17845 printf (_(" to %#lx"), end
);
17851 printf (_(" Applies to region from %#lx"), start
);
17852 func_offset
= start
;
17856 printf (_(" to %#lx"), end
);
17862 printf (_(" (%s)"), name
);
17869 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17871 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17872 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17873 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17875 char name_attribute
;
17876 const char * expected_types
;
17877 const char * name
= pnote
->namedata
;
17881 if (name
== NULL
|| pnote
->namesz
< 2)
17883 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17884 print_symbol (-20, _(" <corrupt name>"));
17893 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17894 if (name
[0] == 'G' && name
[1] == 'A')
17896 if (pnote
->namesz
< 4)
17898 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17899 print_symbol (-20, _(" <corrupt name>"));
17908 switch ((name_type
= * name
))
17910 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17911 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17912 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17913 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17914 printf ("%c", * name
);
17918 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17919 print_symbol (-20, _("<unknown name type>"));
17926 switch ((name_attribute
= * name
))
17928 case GNU_BUILD_ATTRIBUTE_VERSION
:
17929 text
= _("<version>");
17930 expected_types
= string_expected
;
17933 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17934 text
= _("<stack prot>");
17935 expected_types
= "!+*";
17938 case GNU_BUILD_ATTRIBUTE_RELRO
:
17939 text
= _("<relro>");
17940 expected_types
= bool_expected
;
17943 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17944 text
= _("<stack size>");
17945 expected_types
= number_expected
;
17948 case GNU_BUILD_ATTRIBUTE_TOOL
:
17949 text
= _("<tool>");
17950 expected_types
= string_expected
;
17953 case GNU_BUILD_ATTRIBUTE_ABI
:
17955 expected_types
= "$*";
17958 case GNU_BUILD_ATTRIBUTE_PIC
:
17960 expected_types
= number_expected
;
17963 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17964 text
= _("<short enum>");
17965 expected_types
= bool_expected
;
17969 if (ISPRINT (* name
))
17971 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17973 if (len
> left
&& ! do_wide
)
17975 printf ("%.*s:", len
, name
);
17981 static char tmpbuf
[128];
17983 error (_("unrecognised byte in name field: %d\n"), * name
);
17984 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17988 expected_types
= "*$!+";
17993 left
-= printf ("%s", text
);
17995 if (strchr (expected_types
, name_type
) == NULL
)
17996 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17998 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
18000 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18001 (unsigned long) pnote
->namesz
,
18002 (long) (name
- pnote
->namedata
));
18006 if (left
< 1 && ! do_wide
)
18011 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18013 unsigned int bytes
;
18014 unsigned long long val
= 0;
18015 unsigned int shift
= 0;
18016 char * decoded
= NULL
;
18018 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
18020 /* The -1 is because the name field is always 0 terminated, and we
18021 want to be able to ensure that the shift in the while loop below
18022 will not overflow. */
18025 if (bytes
> sizeof (val
))
18027 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18029 bytes
= sizeof (val
);
18031 /* We do not bother to warn if bytes == 0 as this can
18032 happen with some early versions of the gcc plugin. */
18036 unsigned long byte
= (* name
++) & 0xff;
18038 val
|= byte
<< shift
;
18042 switch (name_attribute
)
18044 case GNU_BUILD_ATTRIBUTE_PIC
:
18047 case 0: decoded
= "static"; break;
18048 case 1: decoded
= "pic"; break;
18049 case 2: decoded
= "PIC"; break;
18050 case 3: decoded
= "pie"; break;
18051 case 4: decoded
= "PIE"; break;
18055 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18058 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18059 case 0: decoded
= "off"; break;
18060 case 1: decoded
= "on"; break;
18061 case 2: decoded
= "all"; break;
18062 case 3: decoded
= "strong"; break;
18063 case 4: decoded
= "explicit"; break;
18071 if (decoded
!= NULL
)
18073 print_symbol (-left
, decoded
);
18084 left
-= printf ("0x%llx", val
);
18086 left
-= printf ("0x%-.*llx", left
, val
);
18090 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18091 left
-= print_symbol (- left
, name
);
18093 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18094 left
-= print_symbol (- left
, "true");
18096 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18097 left
-= print_symbol (- left
, "false");
18101 if (do_wide
&& left
> 0)
18102 printf ("%-*s", left
, " ");
18107 /* Note that by the ELF standard, the name field is already null byte
18108 terminated, and namesz includes the terminating null byte.
18109 I.E. the value of namesz for the name "FSF" is 4.
18111 If the value of namesz is zero, there is no name present. */
18114 process_note (Elf_Internal_Note
* pnote
,
18115 Filedata
* filedata
)
18117 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
18120 if (pnote
->namesz
== 0)
18121 /* If there is no note name, then use the default set of
18122 note type strings. */
18123 nt
= get_note_type (filedata
, pnote
->type
);
18125 else if (const_strneq (pnote
->namedata
, "GNU"))
18126 /* GNU-specific object file notes. */
18127 nt
= get_gnu_elf_note_type (pnote
->type
);
18129 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
18130 /* FreeBSD-specific core file notes. */
18131 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
18133 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
18134 /* NetBSD-specific core file notes. */
18135 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
18137 else if (const_strneq (pnote
->namedata
, "NetBSD"))
18138 /* NetBSD-specific core file notes. */
18139 return process_netbsd_elf_note (pnote
);
18141 else if (strneq (pnote
->namedata
, "SPU/", 4))
18143 /* SPU-specific core file notes. */
18144 nt
= pnote
->namedata
+ 4;
18148 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18149 /* VMS/ia64-specific file notes. */
18150 nt
= get_ia64_vms_note_type (pnote
->type
);
18152 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18153 nt
= get_stapsdt_note_type (pnote
->type
);
18156 /* Don't recognize this note name; just use the default set of
18157 note type strings. */
18158 nt
= get_note_type (filedata
, pnote
->type
);
18162 if (((const_strneq (pnote
->namedata
, "GA")
18163 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18164 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18165 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18166 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18167 print_gnu_build_attribute_name (pnote
);
18169 print_symbol (-20, name
);
18172 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
18174 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
18176 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18177 return print_ia64_vms_note (pnote
);
18178 else if (const_strneq (pnote
->namedata
, "GNU"))
18179 return print_gnu_note (filedata
, pnote
);
18180 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18181 return print_stapsdt_note (pnote
);
18182 else if (const_strneq (pnote
->namedata
, "CORE"))
18183 return print_core_note (pnote
);
18184 else if (((const_strneq (pnote
->namedata
, "GA")
18185 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18186 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18187 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18188 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18189 return print_gnu_build_attribute_description (pnote
, filedata
);
18195 printf (_(" description data: "));
18196 for (i
= 0; i
< pnote
->descsz
; i
++)
18197 printf ("%02x ", pnote
->descdata
[i
]);
18209 process_notes_at (Filedata
* filedata
,
18210 Elf_Internal_Shdr
* section
,
18215 Elf_External_Note
* pnotes
;
18216 Elf_External_Note
* external
;
18218 bfd_boolean res
= TRUE
;
18225 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18228 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18233 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18236 if (pnotes
== NULL
)
18242 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18244 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18245 (unsigned long) offset
, (unsigned long) length
);
18247 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18248 specifies that notes should be aligned to 4 bytes in 32-bit
18249 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18250 we also support 4 byte alignment in 64-bit objects. If section
18251 alignment is less than 4, we treate alignment as 4 bytes. */
18254 else if (align
!= 4 && align
!= 8)
18256 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18261 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18263 end
= (char *) pnotes
+ length
;
18264 while ((char *) external
< end
)
18266 Elf_Internal_Note inote
;
18269 char * temp
= NULL
;
18270 size_t data_remaining
= end
- (char *) external
;
18272 if (!is_ia64_vms (filedata
))
18274 /* PR binutils/15191
18275 Make sure that there is enough data to read. */
18276 min_notesz
= offsetof (Elf_External_Note
, name
);
18277 if (data_remaining
< min_notesz
)
18279 warn (ngettext ("Corrupt note: only %ld byte remains, "
18280 "not enough for a full note\n",
18281 "Corrupt note: only %ld bytes remain, "
18282 "not enough for a full note\n",
18284 (long) data_remaining
);
18287 data_remaining
-= min_notesz
;
18289 inote
.type
= BYTE_GET (external
->type
);
18290 inote
.namesz
= BYTE_GET (external
->namesz
);
18291 inote
.namedata
= external
->name
;
18292 inote
.descsz
= BYTE_GET (external
->descsz
);
18293 inote
.descdata
= ((char *) external
18294 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18295 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18296 next
= ((char *) external
18297 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18301 Elf64_External_VMS_Note
*vms_external
;
18303 /* PR binutils/15191
18304 Make sure that there is enough data to read. */
18305 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18306 if (data_remaining
< min_notesz
)
18308 warn (ngettext ("Corrupt note: only %ld byte remains, "
18309 "not enough for a full note\n",
18310 "Corrupt note: only %ld bytes remain, "
18311 "not enough for a full note\n",
18313 (long) data_remaining
);
18316 data_remaining
-= min_notesz
;
18318 vms_external
= (Elf64_External_VMS_Note
*) external
;
18319 inote
.type
= BYTE_GET (vms_external
->type
);
18320 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18321 inote
.namedata
= vms_external
->name
;
18322 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18323 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18324 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18325 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18328 /* PR 17531: file: 3443835e. */
18329 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18330 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18331 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18332 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18333 || ((size_t) (next
- inote
.descdata
)
18334 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18336 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18337 (unsigned long) ((char *) external
- (char *) pnotes
));
18338 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18339 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18343 external
= (Elf_External_Note
*) next
;
18345 /* Verify that name is null terminated. It appears that at least
18346 one version of Linux (RedHat 6.0) generates corefiles that don't
18347 comply with the ELF spec by failing to include the null byte in
18349 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18351 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18353 temp
= (char *) malloc (inote
.namesz
+ 1);
18356 error (_("Out of memory allocating space for inote name\n"));
18361 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18362 inote
.namedata
= temp
;
18364 inote
.namedata
[inote
.namesz
] = 0;
18367 if (! process_note (& inote
, filedata
))
18383 process_corefile_note_segments (Filedata
* filedata
)
18385 Elf_Internal_Phdr
* segment
;
18387 bfd_boolean res
= TRUE
;
18389 if (! get_program_headers (filedata
))
18392 for (i
= 0, segment
= filedata
->program_headers
;
18393 i
< filedata
->file_header
.e_phnum
;
18396 if (segment
->p_type
== PT_NOTE
)
18397 if (! process_notes_at (filedata
, NULL
,
18398 (bfd_vma
) segment
->p_offset
,
18399 (bfd_vma
) segment
->p_filesz
,
18400 (bfd_vma
) segment
->p_align
))
18408 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18410 Elf_External_Note
* pnotes
;
18411 Elf_External_Note
* external
;
18413 bfd_boolean res
= TRUE
;
18418 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18420 if (pnotes
== NULL
)
18424 end
= (char*) pnotes
+ length
;
18426 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18427 (unsigned long) offset
, (unsigned long) length
);
18429 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18431 Elf_External_Note
* next
;
18432 Elf_Internal_Note inote
;
18434 inote
.type
= BYTE_GET (external
->type
);
18435 inote
.namesz
= BYTE_GET (external
->namesz
);
18436 inote
.namedata
= external
->name
;
18437 inote
.descsz
= BYTE_GET (external
->descsz
);
18438 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18439 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18441 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18443 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18444 inote
.descdata
= inote
.namedata
;
18448 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18450 if ( ((char *) next
> end
)
18451 || ((char *) next
< (char *) pnotes
))
18453 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18454 (unsigned long) ((char *) external
- (char *) pnotes
));
18455 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18456 inote
.type
, inote
.namesz
, inote
.descsz
);
18462 /* Prevent out-of-bounds indexing. */
18463 if ( inote
.namedata
+ inote
.namesz
> end
18464 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18466 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18467 (unsigned long) ((char *) external
- (char *) pnotes
));
18468 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18469 inote
.type
, inote
.namesz
, inote
.descsz
);
18473 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18475 if (! print_v850_note (& inote
))
18478 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18479 inote
.namesz
, inote
.descsz
);
18489 process_note_sections (Filedata
* filedata
)
18491 Elf_Internal_Shdr
* section
;
18493 unsigned int n
= 0;
18494 bfd_boolean res
= TRUE
;
18496 for (i
= 0, section
= filedata
->section_headers
;
18497 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18500 if (section
->sh_type
== SHT_NOTE
)
18502 if (! process_notes_at (filedata
, section
,
18503 (bfd_vma
) section
->sh_offset
,
18504 (bfd_vma
) section
->sh_size
,
18505 (bfd_vma
) section
->sh_addralign
))
18510 if (( filedata
->file_header
.e_machine
== EM_V800
18511 || filedata
->file_header
.e_machine
== EM_V850
18512 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18513 && section
->sh_type
== SHT_RENESAS_INFO
)
18515 if (! process_v850_notes (filedata
,
18516 (bfd_vma
) section
->sh_offset
,
18517 (bfd_vma
) section
->sh_size
))
18524 /* Try processing NOTE segments instead. */
18525 return process_corefile_note_segments (filedata
);
18531 process_notes (Filedata
* filedata
)
18533 /* If we have not been asked to display the notes then do nothing. */
18537 if (filedata
->file_header
.e_type
!= ET_CORE
)
18538 return process_note_sections (filedata
);
18540 /* No program headers means no NOTE segment. */
18541 if (filedata
->file_header
.e_phnum
> 0)
18542 return process_corefile_note_segments (filedata
);
18544 printf (_("No note segments present in the core file.\n"));
18548 static unsigned char *
18549 display_public_gnu_attributes (unsigned char * start
,
18550 const unsigned char * const end
)
18552 printf (_(" Unknown GNU attribute: %s\n"), start
);
18554 start
+= strnlen ((char *) start
, end
- start
);
18555 display_raw_attribute (start
, end
);
18557 return (unsigned char *) end
;
18560 static unsigned char *
18561 display_generic_attribute (unsigned char * start
,
18563 const unsigned char * const end
)
18566 return (unsigned char *) end
;
18568 return display_tag_value (tag
, start
, end
);
18572 process_arch_specific (Filedata
* filedata
)
18577 switch (filedata
->file_header
.e_machine
)
18580 case EM_ARC_COMPACT
:
18581 case EM_ARC_COMPACT2
:
18582 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18583 display_arc_attribute
,
18584 display_generic_attribute
);
18586 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18587 display_arm_attribute
,
18588 display_generic_attribute
);
18591 case EM_MIPS_RS3_LE
:
18592 return process_mips_specific (filedata
);
18595 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18596 display_msp430x_attribute
,
18597 display_generic_attribute
);
18600 return process_nds32_specific (filedata
);
18604 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18605 display_power_gnu_attribute
);
18609 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18610 display_s390_gnu_attribute
);
18613 case EM_SPARC32PLUS
:
18615 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18616 display_sparc_gnu_attribute
);
18619 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18620 display_tic6x_attribute
,
18621 display_generic_attribute
);
18624 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18625 display_public_gnu_attributes
,
18626 display_generic_attribute
);
18631 get_file_header (Filedata
* filedata
)
18633 /* Read in the identity array. */
18634 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18637 /* Determine how to read the rest of the header. */
18638 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18643 byte_get
= byte_get_little_endian
;
18644 byte_put
= byte_put_little_endian
;
18647 byte_get
= byte_get_big_endian
;
18648 byte_put
= byte_put_big_endian
;
18652 /* For now we only support 32 bit and 64 bit ELF files. */
18653 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18655 /* Read in the rest of the header. */
18658 Elf32_External_Ehdr ehdr32
;
18660 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18663 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18664 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18665 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18666 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18667 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18668 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18669 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18670 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18671 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18672 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18673 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18674 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18675 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18679 Elf64_External_Ehdr ehdr64
;
18681 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18682 we will not be able to cope with the 64bit data found in
18683 64 ELF files. Detect this now and abort before we start
18684 overwriting things. */
18685 if (sizeof (bfd_vma
) < 8)
18687 error (_("This instance of readelf has been built without support for a\n\
18688 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18692 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18695 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18696 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18697 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18698 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18699 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18700 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18701 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18702 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18703 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18704 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18705 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18706 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18707 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18710 if (filedata
->file_header
.e_shoff
)
18712 /* There may be some extensions in the first section header. Don't
18713 bomb if we can't read it. */
18715 get_32bit_section_headers (filedata
, TRUE
);
18717 get_64bit_section_headers (filedata
, TRUE
);
18724 close_file (Filedata
* filedata
)
18728 if (filedata
->handle
)
18729 fclose (filedata
->handle
);
18735 close_debug_file (void * data
)
18737 close_file ((Filedata
*) data
);
18741 open_file (const char * pathname
)
18743 struct stat statbuf
;
18744 Filedata
* filedata
= NULL
;
18746 if (stat (pathname
, & statbuf
) < 0
18747 || ! S_ISREG (statbuf
.st_mode
))
18750 filedata
= calloc (1, sizeof * filedata
);
18751 if (filedata
== NULL
)
18754 filedata
->handle
= fopen (pathname
, "rb");
18755 if (filedata
->handle
== NULL
)
18758 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
18759 filedata
->file_name
= pathname
;
18761 if (! get_file_header (filedata
))
18764 if (filedata
->file_header
.e_shoff
)
18768 /* Read the section headers again, this time for real. */
18770 res
= get_32bit_section_headers (filedata
, FALSE
);
18772 res
= get_64bit_section_headers (filedata
, FALSE
);
18783 if (filedata
->handle
)
18784 fclose (filedata
->handle
);
18791 open_debug_file (const char * pathname
)
18793 return open_file (pathname
);
18796 /* Process one ELF object file according to the command line options.
18797 This file may actually be stored in an archive. The file is
18798 positioned at the start of the ELF object. Returns TRUE if no
18799 problems were encountered, FALSE otherwise. */
18802 process_object (Filedata
* filedata
)
18804 Filedata
* separates
;
18806 bfd_boolean res
= TRUE
;
18808 if (! get_file_header (filedata
))
18810 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
18814 /* Initialise per file variables. */
18815 for (i
= ARRAY_SIZE (version_info
); i
--;)
18816 version_info
[i
] = 0;
18818 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18819 dynamic_info
[i
] = 0;
18820 dynamic_info_DT_GNU_HASH
= 0;
18822 /* Process the file. */
18824 printf (_("\nFile: %s\n"), filedata
->file_name
);
18826 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18827 Note we do this even if cmdline_dump_sects is empty because we
18828 must make sure that the dump_sets array is zeroed out before each
18829 object file is processed. */
18830 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
18831 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
18833 if (cmdline
.num_dump_sects
> 0)
18835 if (filedata
->num_dump_sects
== 0)
18836 /* A sneaky way of allocating the dump_sects array. */
18837 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
18839 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
18840 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
18841 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
18844 if (! process_file_header (filedata
))
18847 if (! process_section_headers (filedata
))
18849 /* Without loaded section headers we cannot process lots of things. */
18850 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18852 if (! do_using_dynamic
)
18853 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18856 if (! process_section_groups (filedata
))
18857 /* Without loaded section groups we cannot process unwind. */
18860 if (process_program_headers (filedata
))
18861 process_dynamic_section (filedata
);
18865 if (! process_relocs (filedata
))
18868 if (! process_unwind (filedata
))
18871 if (! process_symbol_table (filedata
))
18874 if (! process_syminfo (filedata
))
18877 if (! process_version_sections (filedata
))
18880 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
18881 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
18885 if (! process_section_contents (filedata
))
18890 if (! process_section_headers (separates
))
18892 else if (! process_section_contents (separates
))
18896 if (! process_notes (filedata
))
18899 if (! process_gnu_liblist (filedata
))
18902 if (! process_arch_specific (filedata
))
18905 free (filedata
->program_headers
);
18906 filedata
->program_headers
= NULL
;
18908 free (filedata
->section_headers
);
18909 filedata
->section_headers
= NULL
;
18911 free (filedata
->string_table
);
18912 filedata
->string_table
= NULL
;
18913 filedata
->string_table_length
= 0;
18915 if (dynamic_strings
)
18917 free (dynamic_strings
);
18918 dynamic_strings
= NULL
;
18919 dynamic_strings_length
= 0;
18922 if (dynamic_symbols
)
18924 free (dynamic_symbols
);
18925 dynamic_symbols
= NULL
;
18926 num_dynamic_syms
= 0;
18929 if (dynamic_syminfo
)
18931 free (dynamic_syminfo
);
18932 dynamic_syminfo
= NULL
;
18935 if (dynamic_section
)
18937 free (dynamic_section
);
18938 dynamic_section
= NULL
;
18941 if (section_headers_groups
)
18943 free (section_headers_groups
);
18944 section_headers_groups
= NULL
;
18947 if (section_groups
)
18949 struct group_list
* g
;
18950 struct group_list
* next
;
18952 for (i
= 0; i
< group_count
; i
++)
18954 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18961 free (section_groups
);
18962 section_groups
= NULL
;
18965 free_debug_memory ();
18970 /* Process an ELF archive.
18971 On entry the file is positioned just after the ARMAG string.
18972 Returns TRUE upon success, FALSE otherwise. */
18975 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
18977 struct archive_info arch
;
18978 struct archive_info nested_arch
;
18980 bfd_boolean ret
= TRUE
;
18984 /* The ARCH structure is used to hold information about this archive. */
18985 arch
.file_name
= NULL
;
18987 arch
.index_array
= NULL
;
18988 arch
.sym_table
= NULL
;
18989 arch
.longnames
= NULL
;
18991 /* The NESTED_ARCH structure is used as a single-item cache of information
18992 about a nested archive (when members of a thin archive reside within
18993 another regular archive file). */
18994 nested_arch
.file_name
= NULL
;
18995 nested_arch
.file
= NULL
;
18996 nested_arch
.index_array
= NULL
;
18997 nested_arch
.sym_table
= NULL
;
18998 nested_arch
.longnames
= NULL
;
19000 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
19001 is_thin_archive
, do_archive_index
) != 0)
19007 if (do_archive_index
)
19009 if (arch
.sym_table
== NULL
)
19010 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
19013 unsigned long i
, l
;
19014 unsigned long current_pos
;
19016 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19017 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
19019 current_pos
= ftell (filedata
->handle
);
19021 for (i
= l
= 0; i
< arch
.index_num
; i
++)
19023 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
19025 char * member_name
;
19027 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
19029 if (member_name
!= NULL
)
19031 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
19033 if (qualified_name
!= NULL
)
19035 printf (_("Contents of binary %s at offset "), qualified_name
);
19036 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
19038 free (qualified_name
);
19043 if (l
>= arch
.sym_size
)
19045 error (_("%s: end of the symbol table reached before the end of the index\n"),
19046 filedata
->file_name
);
19050 /* PR 17531: file: 0b6630b2. */
19051 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
19052 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
19055 if (arch
.uses_64bit_indices
)
19060 if (l
< arch
.sym_size
)
19062 error (ngettext ("%s: %ld byte remains in the symbol table, "
19063 "but without corresponding entries in "
19064 "the index table\n",
19065 "%s: %ld bytes remain in the symbol table, "
19066 "but without corresponding entries in "
19067 "the index table\n",
19068 arch
.sym_size
- l
),
19069 filedata
->file_name
, arch
.sym_size
- l
);
19073 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
19075 error (_("%s: failed to seek back to start of object files in the archive\n"),
19076 filedata
->file_name
);
19082 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
19083 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
19084 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
19085 && !do_section_groups
&& !do_dyn_syms
)
19087 ret
= TRUE
; /* Archive index only. */
19096 char * qualified_name
;
19098 /* Read the next archive header. */
19099 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
19101 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
19104 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
19105 if (got
!= sizeof arch
.arhdr
)
19109 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
19113 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
19115 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
19120 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
19122 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
19123 if (archive_file_size
& 01)
19124 ++archive_file_size
;
19126 name
= get_archive_member_name (&arch
, &nested_arch
);
19129 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19133 namelen
= strlen (name
);
19135 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
19136 if (qualified_name
== NULL
)
19138 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19143 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
19145 /* This is a proxy for an external member of a thin archive. */
19146 Filedata
* member_filedata
;
19147 char * member_file_name
= adjust_relative_path
19148 (filedata
->file_name
, name
, namelen
);
19150 if (member_file_name
== NULL
)
19156 member_filedata
= open_file (member_file_name
);
19157 if (member_filedata
== NULL
)
19159 error (_("Input file '%s' is not readable.\n"), member_file_name
);
19160 free (member_file_name
);
19165 archive_file_offset
= arch
.nested_member_origin
;
19166 member_filedata
->file_name
= qualified_name
;
19168 if (! process_object (member_filedata
))
19171 close_file (member_filedata
);
19172 free (member_file_name
);
19174 else if (is_thin_archive
)
19176 Filedata thin_filedata
;
19178 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
19180 /* PR 15140: Allow for corrupt thin archives. */
19181 if (nested_arch
.file
== NULL
)
19183 error (_("%s: contains corrupt thin archive: %s\n"),
19184 filedata
->file_name
, name
);
19189 /* This is a proxy for a member of a nested archive. */
19190 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19192 /* The nested archive file will have been opened and setup by
19193 get_archive_member_name. */
19194 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19196 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19201 thin_filedata
.handle
= nested_arch
.file
;
19202 thin_filedata
.file_name
= qualified_name
;
19204 if (! process_object (& thin_filedata
))
19209 archive_file_offset
= arch
.next_arhdr_offset
;
19210 arch
.next_arhdr_offset
+= archive_file_size
;
19212 filedata
->file_name
= qualified_name
;
19213 if (! process_object (filedata
))
19217 if (filedata
->dump_sects
!= NULL
)
19219 free (filedata
->dump_sects
);
19220 filedata
->dump_sects
= NULL
;
19221 filedata
->num_dump_sects
= 0;
19224 free (qualified_name
);
19228 if (nested_arch
.file
!= NULL
)
19229 fclose (nested_arch
.file
);
19230 release_archive (&nested_arch
);
19231 release_archive (&arch
);
19237 process_file (char * file_name
)
19239 Filedata
* filedata
= NULL
;
19240 struct stat statbuf
;
19241 char armag
[SARMAG
];
19242 bfd_boolean ret
= TRUE
;
19244 if (stat (file_name
, &statbuf
) < 0)
19246 if (errno
== ENOENT
)
19247 error (_("'%s': No such file\n"), file_name
);
19249 error (_("Could not locate '%s'. System error message: %s\n"),
19250 file_name
, strerror (errno
));
19254 if (! S_ISREG (statbuf
.st_mode
))
19256 error (_("'%s' is not an ordinary file\n"), file_name
);
19260 filedata
= calloc (1, sizeof * filedata
);
19261 if (filedata
== NULL
)
19263 error (_("Out of memory allocating file data structure\n"));
19267 filedata
->file_name
= file_name
;
19268 filedata
->handle
= fopen (file_name
, "rb");
19269 if (filedata
->handle
== NULL
)
19271 error (_("Input file '%s' is not readable.\n"), file_name
);
19276 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19278 error (_("%s: Failed to read file's magic number\n"), file_name
);
19279 fclose (filedata
->handle
);
19284 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19286 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19288 if (! process_archive (filedata
, FALSE
))
19291 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19293 if ( ! process_archive (filedata
, TRUE
))
19298 if (do_archive_index
)
19299 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19302 rewind (filedata
->handle
);
19303 archive_file_size
= archive_file_offset
= 0;
19305 if (! process_object (filedata
))
19309 fclose (filedata
->handle
);
19315 #ifdef SUPPORT_DISASSEMBLY
19316 /* Needed by the i386 disassembler. For extra credit, someone could
19317 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19321 print_address (unsigned int addr
, FILE * outfile
)
19323 fprintf (outfile
,"0x%8.8x", addr
);
19326 /* Needed by the i386 disassembler. */
19329 db_task_printsym (unsigned int addr
)
19331 print_address (addr
, stderr
);
19336 main (int argc
, char ** argv
)
19340 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19341 setlocale (LC_MESSAGES
, "");
19343 #if defined (HAVE_SETLOCALE)
19344 setlocale (LC_CTYPE
, "");
19346 bindtextdomain (PACKAGE
, LOCALEDIR
);
19347 textdomain (PACKAGE
);
19349 expandargv (&argc
, &argv
);
19351 cmdline
.file_name
= "<cmdline>";
19352 parse_args (& cmdline
, argc
, argv
);
19354 if (optind
< (argc
- 1))
19356 else if (optind
>= argc
)
19358 warn (_("Nothing to do.\n"));
19363 while (optind
< argc
)
19364 if (! process_file (argv
[optind
++]))
19367 if (cmdline
.dump_sects
!= NULL
)
19368 free (cmdline
.dump_sects
);
19370 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;