1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2019 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/csky.h"
102 #include "elf/d10v.h"
103 #include "elf/d30v.h"
105 #include "elf/epiphany.h"
106 #include "elf/fr30.h"
108 #include "elf/ft32.h"
110 #include "elf/hppa.h"
111 #include "elf/i386.h"
112 #include "elf/i370.h"
113 #include "elf/i860.h"
114 #include "elf/i960.h"
115 #include "elf/ia64.h"
116 #include "elf/ip2k.h"
117 #include "elf/lm32.h"
118 #include "elf/iq2000.h"
119 #include "elf/m32c.h"
120 #include "elf/m32r.h"
121 #include "elf/m68k.h"
122 #include "elf/m68hc11.h"
123 #include "elf/s12z.h"
124 #include "elf/mcore.h"
126 #include "elf/metag.h"
127 #include "elf/microblaze.h"
128 #include "elf/mips.h"
129 #include "elf/mmix.h"
130 #include "elf/mn10200.h"
131 #include "elf/mn10300.h"
132 #include "elf/moxie.h"
134 #include "elf/msp430.h"
135 #include "elf/nds32.h"
137 #include "elf/nios2.h"
138 #include "elf/or1k.h"
141 #include "elf/ppc64.h"
143 #include "elf/riscv.h"
144 #include "elf/rl78.h"
146 #include "elf/s390.h"
147 #include "elf/score.h"
149 #include "elf/sparc.h"
151 #include "elf/tic6x.h"
152 #include "elf/tilegx.h"
153 #include "elf/tilepro.h"
154 #include "elf/v850.h"
156 #include "elf/visium.h"
157 #include "elf/wasm32.h"
158 #include "elf/x86-64.h"
159 #include "elf/xc16x.h"
160 #include "elf/xgate.h"
161 #include "elf/xstormy16.h"
162 #include "elf/xtensa.h"
165 #include "libiberty.h"
166 #include "safe-ctype.h"
167 #include "filenames.h"
170 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
173 typedef struct elf_section_list
175 Elf_Internal_Shdr
* hdr
;
176 struct elf_section_list
* next
;
179 /* Flag bits indicating particular types of dump. */
180 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
181 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
182 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
183 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
184 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
186 typedef unsigned char dump_type
;
188 /* A linked list of the section names for which dumps were requested. */
189 struct dump_list_entry
193 struct dump_list_entry
* next
;
196 typedef struct filedata
198 const char * file_name
;
200 bfd_size_type file_size
;
201 Elf_Internal_Ehdr file_header
;
202 Elf_Internal_Shdr
* section_headers
;
203 Elf_Internal_Phdr
* program_headers
;
205 unsigned long string_table_length
;
206 /* A dynamic array of flags indicating for which sections a dump of
207 some kind has been requested. It is reset on a per-object file
208 basis and then initialised from the cmdline_dump_sects array,
209 the results of interpreting the -w switch, and the
210 dump_sects_byname list. */
211 dump_type
* dump_sects
;
212 unsigned int num_dump_sects
;
215 char * program_name
= "readelf";
217 static unsigned long archive_file_offset
;
218 static unsigned long archive_file_size
;
219 static unsigned long dynamic_addr
;
220 static bfd_size_type dynamic_size
;
221 static size_t dynamic_nent
;
222 static char * dynamic_strings
;
223 static unsigned long dynamic_strings_length
;
224 static unsigned long num_dynamic_syms
;
225 static Elf_Internal_Sym
* dynamic_symbols
;
226 static Elf_Internal_Syminfo
* dynamic_syminfo
;
227 static unsigned long dynamic_syminfo_offset
;
228 static unsigned int dynamic_syminfo_nent
;
229 static char program_interpreter
[PATH_MAX
];
230 static bfd_vma dynamic_info
[DT_ENCODING
];
231 static bfd_vma dynamic_info_DT_GNU_HASH
;
232 static bfd_vma version_info
[16];
233 static Elf_Internal_Dyn
* dynamic_section
;
234 static elf_section_list
* symtab_shndx_list
;
235 static bfd_boolean show_name
= FALSE
;
236 static bfd_boolean do_dynamic
= FALSE
;
237 static bfd_boolean do_syms
= FALSE
;
238 static bfd_boolean do_dyn_syms
= FALSE
;
239 static bfd_boolean do_reloc
= FALSE
;
240 static bfd_boolean do_sections
= FALSE
;
241 static bfd_boolean do_section_groups
= FALSE
;
242 static bfd_boolean do_section_details
= FALSE
;
243 static bfd_boolean do_segments
= FALSE
;
244 static bfd_boolean do_unwind
= FALSE
;
245 static bfd_boolean do_using_dynamic
= FALSE
;
246 static bfd_boolean do_header
= FALSE
;
247 static bfd_boolean do_dump
= FALSE
;
248 static bfd_boolean do_version
= FALSE
;
249 static bfd_boolean do_histogram
= FALSE
;
250 static bfd_boolean do_debugging
= FALSE
;
251 static bfd_boolean do_arch
= FALSE
;
252 static bfd_boolean do_notes
= FALSE
;
253 static bfd_boolean do_archive_index
= FALSE
;
254 static bfd_boolean is_32bit_elf
= FALSE
;
255 static bfd_boolean decompress_dumps
= FALSE
;
259 struct group_list
* next
;
260 unsigned int section_index
;
265 struct group_list
* root
;
266 unsigned int group_index
;
269 static size_t group_count
;
270 static struct group
* section_groups
;
271 static struct group
** section_headers_groups
;
273 /* A dynamic array of flags indicating for which sections a dump
274 has been requested via command line switches. */
275 static Filedata cmdline
;
277 static struct dump_list_entry
* dump_sects_byname
;
279 /* How to print a vma value. */
280 typedef enum print_mode
292 /* Versioned symbol info. */
293 enum versioned_symbol_info
300 static const char * get_symbol_version_string
301 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
302 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
306 #define SECTION_NAME(X) \
307 ((X) == NULL ? _("<none>") \
308 : filedata->string_table == NULL ? _("<no-strings>") \
309 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
310 : filedata->string_table + (X)->sh_name))
312 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
314 #define GET_ELF_SYMBOLS(file, section, sym_count) \
315 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
316 : get_64bit_elf_symbols (file, section, sym_count))
318 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
319 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
320 already been called and verified that the string exists. */
321 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
323 #define REMOVE_ARCH_BITS(ADDR) \
326 if (filedata->file_header.e_machine == EM_ARM) \
331 /* Print a BFD_VMA to an internal buffer, for use in error messages.
332 BFD_FMA_FMT can't be used in translated strings. */
335 bfd_vmatoa (char *fmtch
, bfd_vma value
)
337 /* bfd_vmatoa is used more then once in a printf call for output.
338 Cycle through an array of buffers. */
339 static int buf_pos
= 0;
340 static struct bfd_vmatoa_buf
347 ret
= buf
[buf_pos
++].place
;
348 buf_pos
%= ARRAY_SIZE (buf
);
350 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
351 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
355 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
356 OFFSET + the offset of the current archive member, if we are examining an
357 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
358 allocate a buffer using malloc and fill that. In either case return the
359 pointer to the start of the retrieved data or NULL if something went wrong.
360 If something does go wrong and REASON is not NULL then emit an error
361 message using REASON as part of the context. */
364 get_data (void * var
,
366 unsigned long offset
,
372 bfd_size_type amt
= size
* nmemb
;
374 if (size
== 0 || nmemb
== 0)
377 /* If the size_t type is smaller than the bfd_size_type, eg because
378 you are building a 32-bit tool on a 64-bit host, then make sure
379 that when the sizes are cast to (size_t) no information is lost. */
380 if (sizeof (size_t) < sizeof (bfd_size_type
)
381 && ( (bfd_size_type
) ((size_t) size
) != size
382 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
385 error (_("Size truncation prevents reading %s"
386 " elements of size %s for %s\n"),
387 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
391 /* Check for size overflow. */
395 error (_("Size overflow prevents reading %s"
396 " elements of size %s for %s\n"),
397 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
401 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
402 attempting to allocate memory when the read is bound to fail. */
403 if (archive_file_offset
> filedata
->file_size
404 || offset
> filedata
->file_size
- archive_file_offset
405 || amt
> filedata
->file_size
- archive_file_offset
- offset
)
408 error (_("Reading %s bytes extends past end of file for %s\n"),
409 bfd_vmatoa ("u", amt
), reason
);
413 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
416 error (_("Unable to seek to 0x%lx for %s\n"),
417 archive_file_offset
+ offset
, reason
);
424 /* Check for overflow. */
425 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
426 /* + 1 so that we can '\0' terminate invalid string table sections. */
427 mvar
= malloc ((size_t) amt
+ 1);
432 error (_("Out of memory allocating %s bytes for %s\n"),
433 bfd_vmatoa ("u", amt
), reason
);
437 ((char *) mvar
)[amt
] = '\0';
440 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
443 error (_("Unable to read in %s bytes of %s\n"),
444 bfd_vmatoa ("u", amt
), reason
);
453 /* Print a VMA value in the MODE specified.
454 Returns the number of characters displayed. */
457 print_vma (bfd_vma vma
, print_mode mode
)
469 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
476 return printf ("%5" BFD_VMA_FMT
"d", vma
);
482 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
485 return printf ("%" BFD_VMA_FMT
"d", vma
);
488 return printf ("%" BFD_VMA_FMT
"u", vma
);
491 /* FIXME: Report unrecognised mode ? */
496 /* Display a symbol on stdout. Handles the display of control characters and
497 multibye characters (assuming the host environment supports them).
499 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
501 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
502 padding as necessary.
504 Returns the number of emitted characters. */
507 print_symbol (signed int width
, const char *symbol
)
509 bfd_boolean extra_padding
= FALSE
;
510 signed int num_printed
= 0;
511 #ifdef HAVE_MBSTATE_T
514 unsigned int width_remaining
;
518 /* Keep the width positive. This helps the code below. */
520 extra_padding
= TRUE
;
526 /* Set the remaining width to a very large value.
527 This simplifies the code below. */
528 width_remaining
= INT_MAX
;
530 width_remaining
= width
;
532 #ifdef HAVE_MBSTATE_T
533 /* Initialise the multibyte conversion state. */
534 memset (& state
, 0, sizeof (state
));
537 while (width_remaining
)
540 const char c
= *symbol
++;
545 /* Do not print control characters directly as they can affect terminal
546 settings. Such characters usually appear in the names generated
547 by the assembler for local labels. */
550 if (width_remaining
< 2)
553 printf ("^%c", c
+ 0x40);
554 width_remaining
-= 2;
557 else if (ISPRINT (c
))
565 #ifdef HAVE_MBSTATE_T
568 /* Let printf do the hard work of displaying multibyte characters. */
569 printf ("%.1s", symbol
- 1);
573 #ifdef HAVE_MBSTATE_T
574 /* Try to find out how many bytes made up the character that was
575 just printed. Advance the symbol pointer past the bytes that
577 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
581 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
586 if (extra_padding
&& num_printed
< width
)
588 /* Fill in the remaining spaces. */
589 printf ("%-*s", width
- num_printed
, " ");
596 /* Returns a pointer to a static buffer containing a printable version of
597 the given section's name. Like print_symbol, except that it does not try
598 to print multibyte characters, it just interprets them as hex values. */
601 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
603 #define MAX_PRINT_SEC_NAME_LEN 128
604 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
605 const char * name
= SECTION_NAME (sec
);
606 char * buf
= sec_name_buf
;
608 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
610 while ((c
= * name
++) != 0)
621 else if (ISPRINT (c
))
628 static char hex
[17] = "0123456789ABCDEF";
633 * buf
++ = hex
[(c
& 0xf0) >> 4];
634 * buf
++ = hex
[c
& 0x0f];
648 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
650 if (ndx
>= filedata
->file_header
.e_shnum
)
651 return _("<corrupt>");
653 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
656 /* Return a pointer to section NAME, or NULL if no such section exists. */
658 static Elf_Internal_Shdr
*
659 find_section (Filedata
* filedata
, const char * name
)
663 if (filedata
->section_headers
== NULL
)
666 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
667 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
668 return filedata
->section_headers
+ i
;
673 /* Return a pointer to a section containing ADDR, or NULL if no such
676 static Elf_Internal_Shdr
*
677 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
681 if (filedata
->section_headers
== NULL
)
684 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
686 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
688 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
695 static Elf_Internal_Shdr
*
696 find_section_by_type (Filedata
* filedata
, unsigned int type
)
700 if (filedata
->section_headers
== NULL
)
703 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
705 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
707 if (sec
->sh_type
== type
)
714 /* Return a pointer to section NAME, or NULL if no such section exists,
715 restricted to the list of sections given in SET. */
717 static Elf_Internal_Shdr
*
718 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
722 if (filedata
->section_headers
== NULL
)
727 while ((i
= *set
++) > 0)
729 /* See PR 21156 for a reproducer. */
730 if (i
>= filedata
->file_header
.e_shnum
)
731 continue; /* FIXME: Should we issue an error message ? */
733 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
734 return filedata
->section_headers
+ i
;
738 return find_section (filedata
, name
);
741 /* Read an unsigned LEB128 encoded value from DATA.
742 Set *LENGTH_RETURN to the number of bytes read. */
744 static inline unsigned long
745 read_uleb128 (unsigned char * data
,
746 unsigned int * length_return
,
747 const unsigned char * const end
)
749 return read_leb128 (data
, length_return
, FALSE
, end
);
752 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
753 This OS has so many departures from the ELF standard that we test it at
756 static inline bfd_boolean
757 is_ia64_vms (Filedata
* filedata
)
759 return filedata
->file_header
.e_machine
== EM_IA_64
760 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
763 /* Guess the relocation size commonly used by the specific machines. */
766 guess_is_rela (unsigned int e_machine
)
770 /* Targets that use REL relocations. */
786 /* Targets that use RELA relocations. */
790 case EM_ADAPTEVA_EPIPHANY
:
792 case EM_ALTERA_NIOS2
:
795 case EM_ARC_COMPACT2
:
816 case EM_LATTICEMICO32
:
825 case EM_CYGNUS_MN10200
:
827 case EM_CYGNUS_MN10300
:
863 case EM_MICROBLAZE_OLD
:
885 warn (_("Don't know about relocations on this machine architecture\n"));
890 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
891 Returns TRUE upon success, FALSE otherwise. If successful then a
892 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
893 and the number of relocs loaded is placed in *NRELASP. It is the caller's
894 responsibility to free the allocated buffer. */
897 slurp_rela_relocs (Filedata
* filedata
,
898 unsigned long rel_offset
,
899 unsigned long rel_size
,
900 Elf_Internal_Rela
** relasp
,
901 unsigned long * nrelasp
)
903 Elf_Internal_Rela
* relas
;
909 Elf32_External_Rela
* erelas
;
911 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
912 rel_size
, _("32-bit relocation data"));
916 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
918 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
919 sizeof (Elf_Internal_Rela
));
924 error (_("out of memory parsing relocs\n"));
928 for (i
= 0; i
< nrelas
; i
++)
930 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
931 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
932 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
939 Elf64_External_Rela
* erelas
;
941 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
942 rel_size
, _("64-bit relocation data"));
946 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
948 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
949 sizeof (Elf_Internal_Rela
));
954 error (_("out of memory parsing relocs\n"));
958 for (i
= 0; i
< nrelas
; i
++)
960 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
961 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
962 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
964 /* The #ifdef BFD64 below is to prevent a compile time
965 warning. We know that if we do not have a 64 bit data
966 type that we will never execute this code anyway. */
968 if (filedata
->file_header
.e_machine
== EM_MIPS
969 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
971 /* In little-endian objects, r_info isn't really a
972 64-bit little-endian value: it has a 32-bit
973 little-endian symbol index followed by four
974 individual byte fields. Reorder INFO
976 bfd_vma inf
= relas
[i
].r_info
;
977 inf
= (((inf
& 0xffffffff) << 32)
978 | ((inf
>> 56) & 0xff)
979 | ((inf
>> 40) & 0xff00)
980 | ((inf
>> 24) & 0xff0000)
981 | ((inf
>> 8) & 0xff000000));
982 relas
[i
].r_info
= inf
;
995 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
996 Returns TRUE upon success, FALSE otherwise. If successful then a
997 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
998 and the number of relocs loaded is placed in *NRELSP. It is the caller's
999 responsibility to free the allocated buffer. */
1002 slurp_rel_relocs (Filedata
* filedata
,
1003 unsigned long rel_offset
,
1004 unsigned long rel_size
,
1005 Elf_Internal_Rela
** relsp
,
1006 unsigned long * nrelsp
)
1008 Elf_Internal_Rela
* rels
;
1014 Elf32_External_Rel
* erels
;
1016 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1017 rel_size
, _("32-bit relocation data"));
1021 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1023 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1028 error (_("out of memory parsing relocs\n"));
1032 for (i
= 0; i
< nrels
; i
++)
1034 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1035 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1036 rels
[i
].r_addend
= 0;
1043 Elf64_External_Rel
* erels
;
1045 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1046 rel_size
, _("64-bit relocation data"));
1050 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1052 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1057 error (_("out of memory parsing relocs\n"));
1061 for (i
= 0; i
< nrels
; i
++)
1063 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1064 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1065 rels
[i
].r_addend
= 0;
1067 /* The #ifdef BFD64 below is to prevent a compile time
1068 warning. We know that if we do not have a 64 bit data
1069 type that we will never execute this code anyway. */
1071 if (filedata
->file_header
.e_machine
== EM_MIPS
1072 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1074 /* In little-endian objects, r_info isn't really a
1075 64-bit little-endian value: it has a 32-bit
1076 little-endian symbol index followed by four
1077 individual byte fields. Reorder INFO
1079 bfd_vma inf
= rels
[i
].r_info
;
1080 inf
= (((inf
& 0xffffffff) << 32)
1081 | ((inf
>> 56) & 0xff)
1082 | ((inf
>> 40) & 0xff00)
1083 | ((inf
>> 24) & 0xff0000)
1084 | ((inf
>> 8) & 0xff000000));
1085 rels
[i
].r_info
= inf
;
1098 /* Returns the reloc type extracted from the reloc info field. */
1101 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1104 return ELF32_R_TYPE (reloc_info
);
1106 switch (filedata
->file_header
.e_machine
)
1109 /* Note: We assume that reloc_info has already been adjusted for us. */
1110 return ELF64_MIPS_R_TYPE (reloc_info
);
1113 return ELF64_R_TYPE_ID (reloc_info
);
1116 return ELF64_R_TYPE (reloc_info
);
1120 /* Return the symbol index extracted from the reloc info field. */
1123 get_reloc_symindex (bfd_vma reloc_info
)
1125 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1128 static inline bfd_boolean
1129 uses_msp430x_relocs (Filedata
* filedata
)
1132 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1133 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1134 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1135 /* TI compiler uses ELFOSABI_NONE. */
1136 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1139 /* Display the contents of the relocation data found at the specified
1143 dump_relocations (Filedata
* filedata
,
1144 unsigned long rel_offset
,
1145 unsigned long rel_size
,
1146 Elf_Internal_Sym
* symtab
,
1147 unsigned long nsyms
,
1149 unsigned long strtablen
,
1151 bfd_boolean is_dynsym
)
1154 Elf_Internal_Rela
* rels
;
1155 bfd_boolean res
= TRUE
;
1157 if (is_rela
== UNKNOWN
)
1158 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1162 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1167 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1176 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1178 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1183 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1185 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1193 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1195 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1200 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1202 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1206 for (i
= 0; i
< rel_size
; i
++)
1211 bfd_vma symtab_index
;
1214 offset
= rels
[i
].r_offset
;
1215 inf
= rels
[i
].r_info
;
1217 type
= get_reloc_type (filedata
, inf
);
1218 symtab_index
= get_reloc_symindex (inf
);
1222 printf ("%8.8lx %8.8lx ",
1223 (unsigned long) offset
& 0xffffffff,
1224 (unsigned long) inf
& 0xffffffff);
1228 #if BFD_HOST_64BIT_LONG
1230 ? "%16.16lx %16.16lx "
1231 : "%12.12lx %12.12lx ",
1233 #elif BFD_HOST_64BIT_LONG_LONG
1236 ? "%16.16llx %16.16llx "
1237 : "%12.12llx %12.12llx ",
1241 ? "%16.16I64x %16.16I64x "
1242 : "%12.12I64x %12.12I64x ",
1247 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1248 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1249 _bfd_int64_high (offset
),
1250 _bfd_int64_low (offset
),
1251 _bfd_int64_high (inf
),
1252 _bfd_int64_low (inf
));
1256 switch (filedata
->file_header
.e_machine
)
1263 rtype
= elf_aarch64_reloc_type (type
);
1267 case EM_CYGNUS_M32R
:
1268 rtype
= elf_m32r_reloc_type (type
);
1273 rtype
= elf_i386_reloc_type (type
);
1278 rtype
= elf_m68hc11_reloc_type (type
);
1282 rtype
= elf_s12z_reloc_type (type
);
1286 rtype
= elf_m68k_reloc_type (type
);
1290 rtype
= elf_i960_reloc_type (type
);
1295 rtype
= elf_avr_reloc_type (type
);
1298 case EM_OLD_SPARCV9
:
1299 case EM_SPARC32PLUS
:
1302 rtype
= elf_sparc_reloc_type (type
);
1306 rtype
= elf_spu_reloc_type (type
);
1310 rtype
= v800_reloc_type (type
);
1313 case EM_CYGNUS_V850
:
1314 rtype
= v850_reloc_type (type
);
1318 case EM_CYGNUS_D10V
:
1319 rtype
= elf_d10v_reloc_type (type
);
1323 case EM_CYGNUS_D30V
:
1324 rtype
= elf_d30v_reloc_type (type
);
1328 rtype
= elf_dlx_reloc_type (type
);
1332 rtype
= elf_sh_reloc_type (type
);
1336 case EM_CYGNUS_MN10300
:
1337 rtype
= elf_mn10300_reloc_type (type
);
1341 case EM_CYGNUS_MN10200
:
1342 rtype
= elf_mn10200_reloc_type (type
);
1346 case EM_CYGNUS_FR30
:
1347 rtype
= elf_fr30_reloc_type (type
);
1351 rtype
= elf_frv_reloc_type (type
);
1355 rtype
= elf_csky_reloc_type (type
);
1359 rtype
= elf_ft32_reloc_type (type
);
1363 rtype
= elf_mcore_reloc_type (type
);
1367 rtype
= elf_mmix_reloc_type (type
);
1371 rtype
= elf_moxie_reloc_type (type
);
1375 if (uses_msp430x_relocs (filedata
))
1377 rtype
= elf_msp430x_reloc_type (type
);
1382 rtype
= elf_msp430_reloc_type (type
);
1386 rtype
= elf_nds32_reloc_type (type
);
1390 rtype
= elf_ppc_reloc_type (type
);
1394 rtype
= elf_ppc64_reloc_type (type
);
1398 case EM_MIPS_RS3_LE
:
1399 rtype
= elf_mips_reloc_type (type
);
1403 rtype
= elf_riscv_reloc_type (type
);
1407 rtype
= elf_alpha_reloc_type (type
);
1411 rtype
= elf_arm_reloc_type (type
);
1415 case EM_ARC_COMPACT
:
1416 case EM_ARC_COMPACT2
:
1417 rtype
= elf_arc_reloc_type (type
);
1421 rtype
= elf_hppa_reloc_type (type
);
1427 rtype
= elf_h8_reloc_type (type
);
1431 rtype
= elf_or1k_reloc_type (type
);
1436 rtype
= elf_pj_reloc_type (type
);
1439 rtype
= elf_ia64_reloc_type (type
);
1443 rtype
= elf_cris_reloc_type (type
);
1447 rtype
= elf_i860_reloc_type (type
);
1453 rtype
= elf_x86_64_reloc_type (type
);
1457 rtype
= i370_reloc_type (type
);
1462 rtype
= elf_s390_reloc_type (type
);
1466 rtype
= elf_score_reloc_type (type
);
1470 rtype
= elf_xstormy16_reloc_type (type
);
1474 rtype
= elf_crx_reloc_type (type
);
1478 rtype
= elf_vax_reloc_type (type
);
1482 rtype
= elf_visium_reloc_type (type
);
1485 case EM_ADAPTEVA_EPIPHANY
:
1486 rtype
= elf_epiphany_reloc_type (type
);
1491 rtype
= elf_ip2k_reloc_type (type
);
1495 rtype
= elf_iq2000_reloc_type (type
);
1500 rtype
= elf_xtensa_reloc_type (type
);
1503 case EM_LATTICEMICO32
:
1504 rtype
= elf_lm32_reloc_type (type
);
1509 rtype
= elf_m32c_reloc_type (type
);
1513 rtype
= elf_mt_reloc_type (type
);
1517 rtype
= elf_bfin_reloc_type (type
);
1521 rtype
= elf_mep_reloc_type (type
);
1525 rtype
= elf_cr16_reloc_type (type
);
1529 case EM_MICROBLAZE_OLD
:
1530 rtype
= elf_microblaze_reloc_type (type
);
1534 rtype
= elf_rl78_reloc_type (type
);
1538 rtype
= elf_rx_reloc_type (type
);
1542 rtype
= elf_metag_reloc_type (type
);
1547 rtype
= elf_xc16x_reloc_type (type
);
1551 rtype
= elf_tic6x_reloc_type (type
);
1555 rtype
= elf_tilegx_reloc_type (type
);
1559 rtype
= elf_tilepro_reloc_type (type
);
1562 case EM_WEBASSEMBLY
:
1563 rtype
= elf_wasm32_reloc_type (type
);
1567 rtype
= elf_xgate_reloc_type (type
);
1570 case EM_ALTERA_NIOS2
:
1571 rtype
= elf_nios2_reloc_type (type
);
1575 rtype
= elf_pru_reloc_type (type
);
1579 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1580 rtype
= elf_nfp3200_reloc_type (type
);
1582 rtype
= elf_nfp_reloc_type (type
);
1587 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1589 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1591 if (filedata
->file_header
.e_machine
== EM_ALPHA
1593 && streq (rtype
, "R_ALPHA_LITUSE")
1596 switch (rels
[i
].r_addend
)
1598 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1599 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1600 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1601 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1602 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1603 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1604 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1605 default: rtype
= NULL
;
1609 printf (" (%s)", rtype
);
1613 printf (_("<unknown addend: %lx>"),
1614 (unsigned long) rels
[i
].r_addend
);
1618 else if (symtab_index
)
1620 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1622 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1627 Elf_Internal_Sym
* psym
;
1628 const char * version_string
;
1629 enum versioned_symbol_info sym_info
;
1630 unsigned short vna_other
;
1632 psym
= symtab
+ symtab_index
;
1635 = get_symbol_version_string (filedata
, is_dynsym
,
1644 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1648 unsigned int width
= is_32bit_elf
? 8 : 14;
1650 /* Relocations against GNU_IFUNC symbols do not use the value
1651 of the symbol as the address to relocate against. Instead
1652 they invoke the function named by the symbol and use its
1653 result as the address for relocation.
1655 To indicate this to the user, do not display the value of
1656 the symbol in the "Symbols's Value" field. Instead show
1657 its name followed by () as a hint that the symbol is
1661 || psym
->st_name
== 0
1662 || psym
->st_name
>= strtablen
)
1665 name
= strtab
+ psym
->st_name
;
1667 len
= print_symbol (width
, name
);
1669 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1671 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1675 print_vma (psym
->st_value
, LONG_HEX
);
1677 printf (is_32bit_elf
? " " : " ");
1680 if (psym
->st_name
== 0)
1682 const char * sec_name
= "<null>";
1685 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1687 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1688 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1689 else if (psym
->st_shndx
== SHN_ABS
)
1691 else if (psym
->st_shndx
== SHN_COMMON
)
1692 sec_name
= "COMMON";
1693 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1694 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1695 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1696 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1697 sec_name
= "SCOMMON";
1698 else if (filedata
->file_header
.e_machine
== EM_MIPS
1699 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1700 sec_name
= "SUNDEF";
1701 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1702 || filedata
->file_header
.e_machine
== EM_L1OM
1703 || filedata
->file_header
.e_machine
== EM_K1OM
)
1704 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1705 sec_name
= "LARGE_COMMON";
1706 else if (filedata
->file_header
.e_machine
== EM_IA_64
1707 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1708 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1709 sec_name
= "ANSI_COM";
1710 else if (is_ia64_vms (filedata
)
1711 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1712 sec_name
= "VMS_SYMVEC";
1715 sprintf (name_buf
, "<section 0x%x>",
1716 (unsigned int) psym
->st_shndx
);
1717 sec_name
= name_buf
;
1720 print_symbol (22, sec_name
);
1722 else if (strtab
== NULL
)
1723 printf (_("<string table index: %3ld>"), psym
->st_name
);
1724 else if (psym
->st_name
>= strtablen
)
1726 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1731 print_symbol (22, strtab
+ psym
->st_name
);
1733 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1739 bfd_vma off
= rels
[i
].r_addend
;
1741 if ((bfd_signed_vma
) off
< 0)
1742 printf (" - %" BFD_VMA_FMT
"x", - off
);
1744 printf (" + %" BFD_VMA_FMT
"x", off
);
1750 bfd_vma off
= rels
[i
].r_addend
;
1752 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1753 if ((bfd_signed_vma
) off
< 0)
1754 printf ("-%" BFD_VMA_FMT
"x", - off
);
1756 printf ("%" BFD_VMA_FMT
"x", off
);
1759 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1761 && streq (rtype
, "R_SPARC_OLO10"))
1762 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1767 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1769 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1770 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1771 const char * rtype2
= elf_mips_reloc_type (type2
);
1772 const char * rtype3
= elf_mips_reloc_type (type3
);
1774 printf (" Type2: ");
1777 printf (_("unrecognized: %-7lx"),
1778 (unsigned long) type2
& 0xffffffff);
1780 printf ("%-17.17s", rtype2
);
1782 printf ("\n Type3: ");
1785 printf (_("unrecognized: %-7lx"),
1786 (unsigned long) type3
& 0xffffffff);
1788 printf ("%-17.17s", rtype3
);
1801 get_mips_dynamic_type (unsigned long type
)
1805 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1806 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1807 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1808 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1809 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1810 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1811 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1812 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1813 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1814 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1815 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1816 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1817 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1818 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1819 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1820 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1821 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1822 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1823 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1824 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1825 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1826 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1827 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1828 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1829 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1830 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1831 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1832 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1833 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1834 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1835 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1836 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1837 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1838 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1839 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1840 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1841 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1842 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1843 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1844 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1845 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1846 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1847 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1848 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1849 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1850 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1857 get_sparc64_dynamic_type (unsigned long type
)
1861 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1868 get_ppc_dynamic_type (unsigned long type
)
1872 case DT_PPC_GOT
: return "PPC_GOT";
1873 case DT_PPC_OPT
: return "PPC_OPT";
1880 get_ppc64_dynamic_type (unsigned long type
)
1884 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1885 case DT_PPC64_OPD
: return "PPC64_OPD";
1886 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1887 case DT_PPC64_OPT
: return "PPC64_OPT";
1894 get_parisc_dynamic_type (unsigned long type
)
1898 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1899 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1900 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1901 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1902 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1903 case DT_HP_PREINIT
: return "HP_PREINIT";
1904 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1905 case DT_HP_NEEDED
: return "HP_NEEDED";
1906 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1907 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1908 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1909 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1910 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1911 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1912 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1913 case DT_HP_FILTERED
: return "HP_FILTERED";
1914 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1915 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1916 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1917 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1918 case DT_PLT
: return "PLT";
1919 case DT_PLT_SIZE
: return "PLT_SIZE";
1920 case DT_DLT
: return "DLT";
1921 case DT_DLT_SIZE
: return "DLT_SIZE";
1928 get_ia64_dynamic_type (unsigned long type
)
1932 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1933 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1934 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1935 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1936 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1937 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1938 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1939 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1940 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1941 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1942 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1943 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1944 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1945 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1946 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1947 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1948 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1949 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1950 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1951 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1952 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1953 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1954 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1955 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1956 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1957 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1958 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1959 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1960 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1961 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1962 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1969 get_solaris_section_type (unsigned long type
)
1973 case 0x6fffffee: return "SUNW_ancillary";
1974 case 0x6fffffef: return "SUNW_capchain";
1975 case 0x6ffffff0: return "SUNW_capinfo";
1976 case 0x6ffffff1: return "SUNW_symsort";
1977 case 0x6ffffff2: return "SUNW_tlssort";
1978 case 0x6ffffff3: return "SUNW_LDYNSYM";
1979 case 0x6ffffff4: return "SUNW_dof";
1980 case 0x6ffffff5: return "SUNW_cap";
1981 case 0x6ffffff6: return "SUNW_SIGNATURE";
1982 case 0x6ffffff7: return "SUNW_ANNOTATE";
1983 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1984 case 0x6ffffff9: return "SUNW_DEBUG";
1985 case 0x6ffffffa: return "SUNW_move";
1986 case 0x6ffffffb: return "SUNW_COMDAT";
1987 case 0x6ffffffc: return "SUNW_syminfo";
1988 case 0x6ffffffd: return "SUNW_verdef";
1989 case 0x6ffffffe: return "SUNW_verneed";
1990 case 0x6fffffff: return "SUNW_versym";
1991 case 0x70000000: return "SPARC_GOTDATA";
1992 default: return NULL
;
1997 get_alpha_dynamic_type (unsigned long type
)
2001 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2002 default: return NULL
;
2007 get_score_dynamic_type (unsigned long type
)
2011 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2012 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2013 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2014 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2015 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2016 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2017 default: return NULL
;
2022 get_tic6x_dynamic_type (unsigned long type
)
2026 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2027 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2028 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2029 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2030 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2031 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2032 default: return NULL
;
2037 get_nios2_dynamic_type (unsigned long type
)
2041 case DT_NIOS2_GP
: return "NIOS2_GP";
2042 default: return NULL
;
2047 get_solaris_dynamic_type (unsigned long type
)
2051 case 0x6000000d: return "SUNW_AUXILIARY";
2052 case 0x6000000e: return "SUNW_RTLDINF";
2053 case 0x6000000f: return "SUNW_FILTER";
2054 case 0x60000010: return "SUNW_CAP";
2055 case 0x60000011: return "SUNW_SYMTAB";
2056 case 0x60000012: return "SUNW_SYMSZ";
2057 case 0x60000013: return "SUNW_SORTENT";
2058 case 0x60000014: return "SUNW_SYMSORT";
2059 case 0x60000015: return "SUNW_SYMSORTSZ";
2060 case 0x60000016: return "SUNW_TLSSORT";
2061 case 0x60000017: return "SUNW_TLSSORTSZ";
2062 case 0x60000018: return "SUNW_CAPINFO";
2063 case 0x60000019: return "SUNW_STRPAD";
2064 case 0x6000001a: return "SUNW_CAPCHAIN";
2065 case 0x6000001b: return "SUNW_LDMACH";
2066 case 0x6000001d: return "SUNW_CAPCHAINENT";
2067 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2068 case 0x60000021: return "SUNW_PARENT";
2069 case 0x60000023: return "SUNW_ASLR";
2070 case 0x60000025: return "SUNW_RELAX";
2071 case 0x60000029: return "SUNW_NXHEAP";
2072 case 0x6000002b: return "SUNW_NXSTACK";
2074 case 0x70000001: return "SPARC_REGISTER";
2075 case 0x7ffffffd: return "AUXILIARY";
2076 case 0x7ffffffe: return "USED";
2077 case 0x7fffffff: return "FILTER";
2079 default: return NULL
;
2084 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2086 static char buff
[64];
2090 case DT_NULL
: return "NULL";
2091 case DT_NEEDED
: return "NEEDED";
2092 case DT_PLTRELSZ
: return "PLTRELSZ";
2093 case DT_PLTGOT
: return "PLTGOT";
2094 case DT_HASH
: return "HASH";
2095 case DT_STRTAB
: return "STRTAB";
2096 case DT_SYMTAB
: return "SYMTAB";
2097 case DT_RELA
: return "RELA";
2098 case DT_RELASZ
: return "RELASZ";
2099 case DT_RELAENT
: return "RELAENT";
2100 case DT_STRSZ
: return "STRSZ";
2101 case DT_SYMENT
: return "SYMENT";
2102 case DT_INIT
: return "INIT";
2103 case DT_FINI
: return "FINI";
2104 case DT_SONAME
: return "SONAME";
2105 case DT_RPATH
: return "RPATH";
2106 case DT_SYMBOLIC
: return "SYMBOLIC";
2107 case DT_REL
: return "REL";
2108 case DT_RELSZ
: return "RELSZ";
2109 case DT_RELENT
: return "RELENT";
2110 case DT_PLTREL
: return "PLTREL";
2111 case DT_DEBUG
: return "DEBUG";
2112 case DT_TEXTREL
: return "TEXTREL";
2113 case DT_JMPREL
: return "JMPREL";
2114 case DT_BIND_NOW
: return "BIND_NOW";
2115 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2116 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2117 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2118 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2119 case DT_RUNPATH
: return "RUNPATH";
2120 case DT_FLAGS
: return "FLAGS";
2122 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2123 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2124 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2126 case DT_CHECKSUM
: return "CHECKSUM";
2127 case DT_PLTPADSZ
: return "PLTPADSZ";
2128 case DT_MOVEENT
: return "MOVEENT";
2129 case DT_MOVESZ
: return "MOVESZ";
2130 case DT_FEATURE
: return "FEATURE";
2131 case DT_POSFLAG_1
: return "POSFLAG_1";
2132 case DT_SYMINSZ
: return "SYMINSZ";
2133 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2135 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2136 case DT_CONFIG
: return "CONFIG";
2137 case DT_DEPAUDIT
: return "DEPAUDIT";
2138 case DT_AUDIT
: return "AUDIT";
2139 case DT_PLTPAD
: return "PLTPAD";
2140 case DT_MOVETAB
: return "MOVETAB";
2141 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2143 case DT_VERSYM
: return "VERSYM";
2145 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2146 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2147 case DT_RELACOUNT
: return "RELACOUNT";
2148 case DT_RELCOUNT
: return "RELCOUNT";
2149 case DT_FLAGS_1
: return "FLAGS_1";
2150 case DT_VERDEF
: return "VERDEF";
2151 case DT_VERDEFNUM
: return "VERDEFNUM";
2152 case DT_VERNEED
: return "VERNEED";
2153 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2155 case DT_AUXILIARY
: return "AUXILIARY";
2156 case DT_USED
: return "USED";
2157 case DT_FILTER
: return "FILTER";
2159 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2160 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2161 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2162 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2163 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2164 case DT_GNU_HASH
: return "GNU_HASH";
2167 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2169 const char * result
;
2171 switch (filedata
->file_header
.e_machine
)
2174 case EM_MIPS_RS3_LE
:
2175 result
= get_mips_dynamic_type (type
);
2178 result
= get_sparc64_dynamic_type (type
);
2181 result
= get_ppc_dynamic_type (type
);
2184 result
= get_ppc64_dynamic_type (type
);
2187 result
= get_ia64_dynamic_type (type
);
2190 result
= get_alpha_dynamic_type (type
);
2193 result
= get_score_dynamic_type (type
);
2196 result
= get_tic6x_dynamic_type (type
);
2198 case EM_ALTERA_NIOS2
:
2199 result
= get_nios2_dynamic_type (type
);
2202 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2203 result
= get_solaris_dynamic_type (type
);
2212 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2214 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2215 || (filedata
->file_header
.e_machine
== EM_PARISC
2216 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2218 const char * result
;
2220 switch (filedata
->file_header
.e_machine
)
2223 result
= get_parisc_dynamic_type (type
);
2226 result
= get_ia64_dynamic_type (type
);
2229 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2230 result
= get_solaris_dynamic_type (type
);
2239 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2243 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2250 get_file_type (unsigned e_type
)
2252 static char buff
[32];
2256 case ET_NONE
: return _("NONE (None)");
2257 case ET_REL
: return _("REL (Relocatable file)");
2258 case ET_EXEC
: return _("EXEC (Executable file)");
2259 case ET_DYN
: return _("DYN (Shared object file)");
2260 case ET_CORE
: return _("CORE (Core file)");
2263 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2264 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2265 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2266 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2268 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2274 get_machine_name (unsigned e_machine
)
2276 static char buff
[64]; /* XXX */
2280 /* Please keep this switch table sorted by increasing EM_ value. */
2282 case EM_NONE
: return _("None");
2283 case EM_M32
: return "WE32100";
2284 case EM_SPARC
: return "Sparc";
2285 case EM_386
: return "Intel 80386";
2286 case EM_68K
: return "MC68000";
2287 case EM_88K
: return "MC88000";
2288 case EM_IAMCU
: return "Intel MCU";
2289 case EM_860
: return "Intel 80860";
2290 case EM_MIPS
: return "MIPS R3000";
2291 case EM_S370
: return "IBM System/370";
2293 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2294 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2295 case EM_PARISC
: return "HPPA";
2296 case EM_VPP550
: return "Fujitsu VPP500";
2297 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2298 case EM_960
: return "Intel 80960";
2299 case EM_PPC
: return "PowerPC";
2301 case EM_PPC64
: return "PowerPC64";
2303 case EM_S390
: return "IBM S/390";
2304 case EM_SPU
: return "SPU";
2306 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2307 case EM_FR20
: return "Fujitsu FR20";
2308 case EM_RH32
: return "TRW RH32";
2309 case EM_MCORE
: return "MCORE";
2311 case EM_ARM
: return "ARM";
2312 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2313 case EM_SH
: return "Renesas / SuperH SH";
2314 case EM_SPARCV9
: return "Sparc v9";
2315 case EM_TRICORE
: return "Siemens Tricore";
2316 case EM_ARC
: return "ARC";
2317 case EM_H8_300
: return "Renesas H8/300";
2318 case EM_H8_300H
: return "Renesas H8/300H";
2319 case EM_H8S
: return "Renesas H8S";
2320 case EM_H8_500
: return "Renesas H8/500";
2322 case EM_IA_64
: return "Intel IA-64";
2323 case EM_MIPS_X
: return "Stanford MIPS-X";
2324 case EM_COLDFIRE
: return "Motorola Coldfire";
2325 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2326 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2327 case EM_PCP
: return "Siemens PCP";
2328 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2329 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2330 case EM_STARCORE
: return "Motorola Star*Core processor";
2331 case EM_ME16
: return "Toyota ME16 processor";
2333 case EM_ST100
: return "STMicroelectronics ST100 processor";
2334 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2335 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2336 case EM_PDSP
: return "Sony DSP processor";
2337 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2338 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2339 case EM_FX66
: return "Siemens FX66 microcontroller";
2340 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2341 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2342 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2344 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2345 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2346 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2347 case EM_SVX
: return "Silicon Graphics SVx";
2348 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2349 case EM_VAX
: return "Digital VAX";
2350 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2351 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2352 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2353 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2355 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2356 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2357 case EM_PRISM
: return "Vitesse Prism";
2359 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2360 case EM_CYGNUS_FR30
:
2361 case EM_FR30
: return "Fujitsu FR30";
2362 case EM_CYGNUS_D10V
:
2363 case EM_D10V
: return "d10v";
2364 case EM_CYGNUS_D30V
:
2365 case EM_D30V
: return "d30v";
2366 case EM_CYGNUS_V850
:
2367 case EM_V850
: return "Renesas V850";
2368 case EM_CYGNUS_M32R
:
2369 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2370 case EM_CYGNUS_MN10300
:
2371 case EM_MN10300
: return "mn10300";
2373 case EM_CYGNUS_MN10200
:
2374 case EM_MN10200
: return "mn10200";
2375 case EM_PJ
: return "picoJava";
2376 case EM_OR1K
: return "OpenRISC 1000";
2377 case EM_ARC_COMPACT
: return "ARCompact";
2379 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2380 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2381 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2382 case EM_NS32K
: return "National Semiconductor 32000 series";
2383 case EM_TPC
: return "Tenor Network TPC processor";
2384 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2386 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2388 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2389 case EM_MAX
: return "MAX Processor";
2390 case EM_CR
: return "National Semiconductor CompactRISC";
2391 case EM_F2MC16
: return "Fujitsu F2MC16";
2392 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2393 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2394 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2395 case EM_SEP
: return "Sharp embedded microprocessor";
2396 case EM_ARCA
: return "Arca RISC microprocessor";
2398 case EM_UNICORE
: return "Unicore";
2399 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2400 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2401 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2402 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2403 case EM_XGATE
: return "Motorola XGATE embedded processor";
2405 case EM_XC16X
: return "Infineon Technologies xc16x";
2406 case EM_M16C
: return "Renesas M16C series microprocessors";
2407 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2408 case EM_CE
: return "Freescale Communication Engine RISC core";
2410 case EM_M32C
: return "Renesas M32c";
2412 case EM_TSK3000
: return "Altium TSK3000 core";
2413 case EM_RS08
: return "Freescale RS08 embedded processor";
2414 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2415 case EM_SCORE
: return "SUNPLUS S+Core";
2416 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2417 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2418 case EM_LATTICEMICO32
: return "Lattice Mico32";
2419 case EM_SE_C17
: return "Seiko Epson C17 family";
2421 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2422 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2423 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2424 case EM_TI_PRU
: return "TI PRU I/O processor";
2426 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2427 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2428 case EM_R32C
: return "Renesas R32C series microprocessors";
2429 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2430 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2431 case EM_8051
: return "Intel 8051 and variants";
2432 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2433 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2434 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2435 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2437 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2438 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2439 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2440 case EM_RX
: return "Renesas RX";
2441 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2442 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2443 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2446 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2447 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2448 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2450 case EM_L1OM
: return "Intel L1OM";
2451 case EM_K1OM
: return "Intel K1OM";
2452 case EM_INTEL182
: return "Intel (reserved)";
2453 case EM_AARCH64
: return "AArch64";
2454 case EM_ARM184
: return "ARM (reserved)";
2455 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2456 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2457 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2458 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2460 case EM_CUDA
: return "NVIDIA CUDA architecture";
2461 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2462 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2463 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2464 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2465 case EM_ARC_COMPACT2
: return "ARCv2";
2466 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2467 case EM_RL78
: return "Renesas RL78";
2468 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2469 case EM_78K0R
: return "Renesas 78K0R";
2471 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2472 case EM_BA1
: return "Beyond BA1 CPU architecture";
2473 case EM_BA2
: return "Beyond BA2 CPU architecture";
2474 case EM_XCORE
: return "XMOS xCORE processor family";
2475 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2477 case EM_KM32
: return "KM211 KM32 32-bit processor";
2478 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2479 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2480 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2481 case EM_KVARC
: return "KM211 KVARC processor";
2482 case EM_CDP
: return "Paneve CDP architecture family";
2483 case EM_COGE
: return "Cognitive Smart Memory Processor";
2484 case EM_COOL
: return "Bluechip Systems CoolEngine";
2485 case EM_NORC
: return "Nanoradio Optimized RISC";
2486 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2488 case EM_Z80
: return "Zilog Z80";
2489 case EM_VISIUM
: return "CDS VISIUMcore processor";
2490 case EM_FT32
: return "FTDI Chip FT32";
2491 case EM_MOXIE
: return "Moxie";
2492 case EM_AMDGPU
: return "AMD GPU";
2493 case EM_RISCV
: return "RISC-V";
2494 case EM_LANAI
: return "Lanai 32-bit processor";
2495 case EM_BPF
: return "Linux BPF";
2496 case EM_NFP
: return "Netronome Flow Processor";
2498 /* Large numbers... */
2499 case EM_MT
: return "Morpho Techologies MT processor";
2500 case EM_ALPHA
: return "Alpha";
2501 case EM_WEBASSEMBLY
: return "Web Assembly";
2502 case EM_DLX
: return "OpenDLX";
2503 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2504 case EM_IQ2000
: return "Vitesse IQ2000";
2506 case EM_NIOS32
: return "Altera Nios";
2507 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2508 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2509 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2510 case EM_S12Z
: return "Freescale S12Z";
2511 case EM_CSKY
: return "C-SKY";
2514 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2520 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2522 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2523 other compilers don't a specific architecture type in the e_flags, and
2524 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2525 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2528 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2529 but also sets a specific architecture type in the e_flags field.
2531 However, when decoding the flags we don't worry if we see an
2532 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2533 ARCEM architecture type. */
2535 switch (e_flags
& EF_ARC_MACH_MSK
)
2537 /* We only expect these to occur for EM_ARC_COMPACT2. */
2538 case EF_ARC_CPU_ARCV2EM
:
2539 strcat (buf
, ", ARC EM");
2541 case EF_ARC_CPU_ARCV2HS
:
2542 strcat (buf
, ", ARC HS");
2545 /* We only expect these to occur for EM_ARC_COMPACT. */
2546 case E_ARC_MACH_ARC600
:
2547 strcat (buf
, ", ARC600");
2549 case E_ARC_MACH_ARC601
:
2550 strcat (buf
, ", ARC601");
2552 case E_ARC_MACH_ARC700
:
2553 strcat (buf
, ", ARC700");
2556 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2557 new ELF with new architecture being read by an old version of
2558 readelf, or (c) An ELF built with non-GNU compiler that does not
2559 set the architecture in the e_flags. */
2561 if (e_machine
== EM_ARC_COMPACT
)
2562 strcat (buf
, ", Unknown ARCompact");
2564 strcat (buf
, ", Unknown ARC");
2568 switch (e_flags
& EF_ARC_OSABI_MSK
)
2570 case E_ARC_OSABI_ORIG
:
2571 strcat (buf
, ", (ABI:legacy)");
2573 case E_ARC_OSABI_V2
:
2574 strcat (buf
, ", (ABI:v2)");
2576 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2577 case E_ARC_OSABI_V3
:
2578 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2580 case E_ARC_OSABI_V4
:
2581 strcat (buf
, ", v4 ABI");
2584 strcat (buf
, ", unrecognised ARC OSABI flag");
2590 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2593 bfd_boolean unknown
= FALSE
;
2595 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2596 e_flags
&= ~ EF_ARM_EABIMASK
;
2598 /* Handle "generic" ARM flags. */
2599 if (e_flags
& EF_ARM_RELEXEC
)
2601 strcat (buf
, ", relocatable executable");
2602 e_flags
&= ~ EF_ARM_RELEXEC
;
2605 if (e_flags
& EF_ARM_PIC
)
2607 strcat (buf
, ", position independent");
2608 e_flags
&= ~ EF_ARM_PIC
;
2611 /* Now handle EABI specific flags. */
2615 strcat (buf
, ", <unrecognized EABI>");
2620 case EF_ARM_EABI_VER1
:
2621 strcat (buf
, ", Version1 EABI");
2626 /* Process flags one bit at a time. */
2627 flag
= e_flags
& - e_flags
;
2632 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2633 strcat (buf
, ", sorted symbol tables");
2643 case EF_ARM_EABI_VER2
:
2644 strcat (buf
, ", Version2 EABI");
2649 /* Process flags one bit at a time. */
2650 flag
= e_flags
& - e_flags
;
2655 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2656 strcat (buf
, ", sorted symbol tables");
2659 case EF_ARM_DYNSYMSUSESEGIDX
:
2660 strcat (buf
, ", dynamic symbols use segment index");
2663 case EF_ARM_MAPSYMSFIRST
:
2664 strcat (buf
, ", mapping symbols precede others");
2674 case EF_ARM_EABI_VER3
:
2675 strcat (buf
, ", Version3 EABI");
2678 case EF_ARM_EABI_VER4
:
2679 strcat (buf
, ", Version4 EABI");
2684 /* Process flags one bit at a time. */
2685 flag
= e_flags
& - e_flags
;
2691 strcat (buf
, ", BE8");
2695 strcat (buf
, ", LE8");
2705 case EF_ARM_EABI_VER5
:
2706 strcat (buf
, ", Version5 EABI");
2711 /* Process flags one bit at a time. */
2712 flag
= e_flags
& - e_flags
;
2718 strcat (buf
, ", BE8");
2722 strcat (buf
, ", LE8");
2725 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2726 strcat (buf
, ", soft-float ABI");
2729 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2730 strcat (buf
, ", hard-float ABI");
2740 case EF_ARM_EABI_UNKNOWN
:
2741 strcat (buf
, ", GNU EABI");
2746 /* Process flags one bit at a time. */
2747 flag
= e_flags
& - e_flags
;
2752 case EF_ARM_INTERWORK
:
2753 strcat (buf
, ", interworking enabled");
2756 case EF_ARM_APCS_26
:
2757 strcat (buf
, ", uses APCS/26");
2760 case EF_ARM_APCS_FLOAT
:
2761 strcat (buf
, ", uses APCS/float");
2765 strcat (buf
, ", position independent");
2769 strcat (buf
, ", 8 bit structure alignment");
2772 case EF_ARM_NEW_ABI
:
2773 strcat (buf
, ", uses new ABI");
2776 case EF_ARM_OLD_ABI
:
2777 strcat (buf
, ", uses old ABI");
2780 case EF_ARM_SOFT_FLOAT
:
2781 strcat (buf
, ", software FP");
2784 case EF_ARM_VFP_FLOAT
:
2785 strcat (buf
, ", VFP");
2788 case EF_ARM_MAVERICK_FLOAT
:
2789 strcat (buf
, ", Maverick FP");
2800 strcat (buf
,_(", <unknown>"));
2804 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2806 --size
; /* Leave space for null terminator. */
2808 switch (e_flags
& EF_AVR_MACH
)
2810 case E_AVR_MACH_AVR1
:
2811 strncat (buf
, ", avr:1", size
);
2813 case E_AVR_MACH_AVR2
:
2814 strncat (buf
, ", avr:2", size
);
2816 case E_AVR_MACH_AVR25
:
2817 strncat (buf
, ", avr:25", size
);
2819 case E_AVR_MACH_AVR3
:
2820 strncat (buf
, ", avr:3", size
);
2822 case E_AVR_MACH_AVR31
:
2823 strncat (buf
, ", avr:31", size
);
2825 case E_AVR_MACH_AVR35
:
2826 strncat (buf
, ", avr:35", size
);
2828 case E_AVR_MACH_AVR4
:
2829 strncat (buf
, ", avr:4", size
);
2831 case E_AVR_MACH_AVR5
:
2832 strncat (buf
, ", avr:5", size
);
2834 case E_AVR_MACH_AVR51
:
2835 strncat (buf
, ", avr:51", size
);
2837 case E_AVR_MACH_AVR6
:
2838 strncat (buf
, ", avr:6", size
);
2840 case E_AVR_MACH_AVRTINY
:
2841 strncat (buf
, ", avr:100", size
);
2843 case E_AVR_MACH_XMEGA1
:
2844 strncat (buf
, ", avr:101", size
);
2846 case E_AVR_MACH_XMEGA2
:
2847 strncat (buf
, ", avr:102", size
);
2849 case E_AVR_MACH_XMEGA3
:
2850 strncat (buf
, ", avr:103", size
);
2852 case E_AVR_MACH_XMEGA4
:
2853 strncat (buf
, ", avr:104", size
);
2855 case E_AVR_MACH_XMEGA5
:
2856 strncat (buf
, ", avr:105", size
);
2858 case E_AVR_MACH_XMEGA6
:
2859 strncat (buf
, ", avr:106", size
);
2861 case E_AVR_MACH_XMEGA7
:
2862 strncat (buf
, ", avr:107", size
);
2865 strncat (buf
, ", avr:<unknown>", size
);
2869 size
-= strlen (buf
);
2870 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2871 strncat (buf
, ", link-relax", size
);
2875 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2881 bfd_boolean has_fpu
= FALSE
;
2884 static const char *ABI_STRINGS
[] =
2886 "ABI v0", /* use r5 as return register; only used in N1213HC */
2887 "ABI v1", /* use r0 as return register */
2888 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2889 "ABI v2fp", /* for FPU */
2893 static const char *VER_STRINGS
[] =
2895 "Andes ELF V1.3 or older",
2899 static const char *ARCH_STRINGS
[] =
2908 abi
= EF_NDS_ABI
& e_flags
;
2909 arch
= EF_NDS_ARCH
& e_flags
;
2910 config
= EF_NDS_INST
& e_flags
;
2911 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2913 memset (buf
, 0, size
);
2920 case E_NDS_ABI_V2FP
:
2921 case E_NDS_ABI_AABI
:
2922 case E_NDS_ABI_V2FP_PLUS
:
2923 /* In case there are holes in the array. */
2924 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2928 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2934 case E_NDS32_ELF_VER_1_2
:
2935 case E_NDS32_ELF_VER_1_3
:
2936 case E_NDS32_ELF_VER_1_4
:
2937 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2941 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2945 if (E_NDS_ABI_V0
== abi
)
2947 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2948 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2949 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2950 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2956 case E_NDS_ARCH_STAR_V1_0
:
2957 case E_NDS_ARCH_STAR_V2_0
:
2958 case E_NDS_ARCH_STAR_V3_0
:
2959 case E_NDS_ARCH_STAR_V3_M
:
2960 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2964 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2965 /* ARCH version determines how the e_flags are interpreted.
2966 If it is unknown, we cannot proceed. */
2970 /* Newer ABI; Now handle architecture specific flags. */
2971 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2973 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2974 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2976 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2977 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2979 if (config
& E_NDS32_HAS_DIV_INST
)
2980 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2982 if (config
& E_NDS32_HAS_16BIT_INST
)
2983 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2987 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2989 if (version
<= E_NDS32_ELF_VER_1_3
)
2990 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2992 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2995 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2996 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2998 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2999 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3001 if (config
& E_NDS32_HAS_16BIT_INST
)
3003 if (version
<= E_NDS32_ELF_VER_1_3
)
3004 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3006 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3010 if (config
& E_NDS32_HAS_EXT_INST
)
3011 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3013 if (config
& E_NDS32_HAS_EXT2_INST
)
3014 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3016 if (config
& E_NDS32_HAS_FPU_INST
)
3019 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3022 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3025 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3028 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3031 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3036 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3038 case E_NDS32_FPU_REG_8SP_4DP
:
3039 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3041 case E_NDS32_FPU_REG_16SP_8DP
:
3042 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3044 case E_NDS32_FPU_REG_32SP_16DP
:
3045 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3047 case E_NDS32_FPU_REG_32SP_32DP
:
3048 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3053 if (config
& E_NDS32_HAS_AUDIO_INST
)
3054 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3056 if (config
& E_NDS32_HAS_STRING_INST
)
3057 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3059 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3060 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3062 if (config
& E_NDS32_HAS_VIDEO_INST
)
3064 if (version
<= E_NDS32_ELF_VER_1_3
)
3065 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3067 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3070 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3071 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3073 if (config
& E_NDS32_HAS_L2C_INST
)
3074 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3078 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3080 static char buf
[1024];
3091 case EM_ARC_COMPACT2
:
3092 case EM_ARC_COMPACT
:
3093 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3097 decode_ARM_machine_flags (e_flags
, buf
);
3101 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3105 if (e_flags
& EF_BFIN_PIC
)
3106 strcat (buf
, ", PIC");
3108 if (e_flags
& EF_BFIN_FDPIC
)
3109 strcat (buf
, ", FDPIC");
3111 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3112 strcat (buf
, ", code in L1");
3114 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3115 strcat (buf
, ", data in L1");
3120 switch (e_flags
& EF_FRV_CPU_MASK
)
3122 case EF_FRV_CPU_GENERIC
:
3126 strcat (buf
, ", fr???");
3129 case EF_FRV_CPU_FR300
:
3130 strcat (buf
, ", fr300");
3133 case EF_FRV_CPU_FR400
:
3134 strcat (buf
, ", fr400");
3136 case EF_FRV_CPU_FR405
:
3137 strcat (buf
, ", fr405");
3140 case EF_FRV_CPU_FR450
:
3141 strcat (buf
, ", fr450");
3144 case EF_FRV_CPU_FR500
:
3145 strcat (buf
, ", fr500");
3147 case EF_FRV_CPU_FR550
:
3148 strcat (buf
, ", fr550");
3151 case EF_FRV_CPU_SIMPLE
:
3152 strcat (buf
, ", simple");
3154 case EF_FRV_CPU_TOMCAT
:
3155 strcat (buf
, ", tomcat");
3161 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3162 strcat (buf
, ", m68000");
3163 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3164 strcat (buf
, ", cpu32");
3165 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3166 strcat (buf
, ", fido_a");
3169 char const * isa
= _("unknown");
3170 char const * mac
= _("unknown mac");
3171 char const * additional
= NULL
;
3173 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3175 case EF_M68K_CF_ISA_A_NODIV
:
3177 additional
= ", nodiv";
3179 case EF_M68K_CF_ISA_A
:
3182 case EF_M68K_CF_ISA_A_PLUS
:
3185 case EF_M68K_CF_ISA_B_NOUSP
:
3187 additional
= ", nousp";
3189 case EF_M68K_CF_ISA_B
:
3192 case EF_M68K_CF_ISA_C
:
3195 case EF_M68K_CF_ISA_C_NODIV
:
3197 additional
= ", nodiv";
3200 strcat (buf
, ", cf, isa ");
3203 strcat (buf
, additional
);
3204 if (e_flags
& EF_M68K_CF_FLOAT
)
3205 strcat (buf
, ", float");
3206 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3211 case EF_M68K_CF_MAC
:
3214 case EF_M68K_CF_EMAC
:
3217 case EF_M68K_CF_EMAC_B
:
3230 switch (e_flags
& EF_MEP_CPU_MASK
)
3232 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3233 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3234 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3235 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3236 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3237 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3238 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3241 switch (e_flags
& EF_MEP_COP_MASK
)
3243 case EF_MEP_COP_NONE
: break;
3244 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3245 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3246 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3247 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3248 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3251 if (e_flags
& EF_MEP_LIBRARY
)
3252 strcat (buf
, ", Built for Library");
3254 if (e_flags
& EF_MEP_INDEX_MASK
)
3255 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3256 e_flags
& EF_MEP_INDEX_MASK
);
3258 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3259 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3260 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3264 if (e_flags
& EF_PPC_EMB
)
3265 strcat (buf
, ", emb");
3267 if (e_flags
& EF_PPC_RELOCATABLE
)
3268 strcat (buf
, _(", relocatable"));
3270 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3271 strcat (buf
, _(", relocatable-lib"));
3275 if (e_flags
& EF_PPC64_ABI
)
3277 char abi
[] = ", abiv0";
3279 abi
[6] += e_flags
& EF_PPC64_ABI
;
3285 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3286 strcat (buf
, ", RH850 ABI");
3288 if (e_flags
& EF_V800_850E3
)
3289 strcat (buf
, ", V3 architecture");
3291 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3292 strcat (buf
, ", FPU not used");
3294 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3295 strcat (buf
, ", regmode: COMMON");
3297 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3298 strcat (buf
, ", r4 not used");
3300 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3301 strcat (buf
, ", r30 not used");
3303 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3304 strcat (buf
, ", r5 not used");
3306 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3307 strcat (buf
, ", r2 not used");
3309 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3311 switch (e_flags
& - e_flags
)
3313 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3314 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3315 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3316 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3317 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3318 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3319 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3320 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3321 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3322 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3323 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3324 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3331 case EM_CYGNUS_V850
:
3332 switch (e_flags
& EF_V850_ARCH
)
3334 case E_V850E3V5_ARCH
:
3335 strcat (buf
, ", v850e3v5");
3337 case E_V850E2V3_ARCH
:
3338 strcat (buf
, ", v850e2v3");
3341 strcat (buf
, ", v850e2");
3344 strcat (buf
, ", v850e1");
3347 strcat (buf
, ", v850e");
3350 strcat (buf
, ", v850");
3353 strcat (buf
, _(", unknown v850 architecture variant"));
3359 case EM_CYGNUS_M32R
:
3360 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3361 strcat (buf
, ", m32r");
3365 case EM_MIPS_RS3_LE
:
3366 if (e_flags
& EF_MIPS_NOREORDER
)
3367 strcat (buf
, ", noreorder");
3369 if (e_flags
& EF_MIPS_PIC
)
3370 strcat (buf
, ", pic");
3372 if (e_flags
& EF_MIPS_CPIC
)
3373 strcat (buf
, ", cpic");
3375 if (e_flags
& EF_MIPS_UCODE
)
3376 strcat (buf
, ", ugen_reserved");
3378 if (e_flags
& EF_MIPS_ABI2
)
3379 strcat (buf
, ", abi2");
3381 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3382 strcat (buf
, ", odk first");
3384 if (e_flags
& EF_MIPS_32BITMODE
)
3385 strcat (buf
, ", 32bitmode");
3387 if (e_flags
& EF_MIPS_NAN2008
)
3388 strcat (buf
, ", nan2008");
3390 if (e_flags
& EF_MIPS_FP64
)
3391 strcat (buf
, ", fp64");
3393 switch ((e_flags
& EF_MIPS_MACH
))
3395 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3396 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3397 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3398 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3399 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3400 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3401 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3402 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3403 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3404 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3405 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3406 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3407 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3408 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3409 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3410 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3411 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3412 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3413 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3414 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3415 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3417 /* We simply ignore the field in this case to avoid confusion:
3418 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3421 default: strcat (buf
, _(", unknown CPU")); break;
3424 switch ((e_flags
& EF_MIPS_ABI
))
3426 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3427 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3428 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3429 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3431 /* We simply ignore the field in this case to avoid confusion:
3432 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3433 This means it is likely to be an o32 file, but not for
3436 default: strcat (buf
, _(", unknown ABI")); break;
3439 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3440 strcat (buf
, ", mdmx");
3442 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3443 strcat (buf
, ", mips16");
3445 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3446 strcat (buf
, ", micromips");
3448 switch ((e_flags
& EF_MIPS_ARCH
))
3450 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3451 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3452 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3453 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3454 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3455 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3456 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3457 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3458 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3459 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3460 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3461 default: strcat (buf
, _(", unknown ISA")); break;
3466 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3470 switch (EF_NFP_MACH (e_flags
))
3472 case E_NFP_MACH_3200
:
3473 strcat (buf
, ", NFP-32xx");
3475 case E_NFP_MACH_6000
:
3476 strcat (buf
, ", NFP-6xxx");
3482 if (e_flags
& EF_RISCV_RVC
)
3483 strcat (buf
, ", RVC");
3485 if (e_flags
& EF_RISCV_RVE
)
3486 strcat (buf
, ", RVE");
3488 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3490 case EF_RISCV_FLOAT_ABI_SOFT
:
3491 strcat (buf
, ", soft-float ABI");
3494 case EF_RISCV_FLOAT_ABI_SINGLE
:
3495 strcat (buf
, ", single-float ABI");
3498 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3499 strcat (buf
, ", double-float ABI");
3502 case EF_RISCV_FLOAT_ABI_QUAD
:
3503 strcat (buf
, ", quad-float ABI");
3509 switch ((e_flags
& EF_SH_MACH_MASK
))
3511 case EF_SH1
: strcat (buf
, ", sh1"); break;
3512 case EF_SH2
: strcat (buf
, ", sh2"); break;
3513 case EF_SH3
: strcat (buf
, ", sh3"); break;
3514 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3515 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3516 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3517 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3518 case EF_SH4
: strcat (buf
, ", sh4"); break;
3519 case EF_SH5
: strcat (buf
, ", sh5"); break;
3520 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3521 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3522 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3523 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3524 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3525 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3526 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3527 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3528 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3529 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3530 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3531 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3532 default: strcat (buf
, _(", unknown ISA")); break;
3535 if (e_flags
& EF_SH_PIC
)
3536 strcat (buf
, ", pic");
3538 if (e_flags
& EF_SH_FDPIC
)
3539 strcat (buf
, ", fdpic");
3543 if (e_flags
& EF_OR1K_NODELAY
)
3544 strcat (buf
, ", no delay");
3548 if (e_flags
& EF_SPARC_32PLUS
)
3549 strcat (buf
, ", v8+");
3551 if (e_flags
& EF_SPARC_SUN_US1
)
3552 strcat (buf
, ", ultrasparcI");
3554 if (e_flags
& EF_SPARC_SUN_US3
)
3555 strcat (buf
, ", ultrasparcIII");
3557 if (e_flags
& EF_SPARC_HAL_R1
)
3558 strcat (buf
, ", halr1");
3560 if (e_flags
& EF_SPARC_LEDATA
)
3561 strcat (buf
, ", ledata");
3563 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3564 strcat (buf
, ", tso");
3566 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3567 strcat (buf
, ", pso");
3569 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3570 strcat (buf
, ", rmo");
3574 switch (e_flags
& EF_PARISC_ARCH
)
3576 case EFA_PARISC_1_0
:
3577 strcpy (buf
, ", PA-RISC 1.0");
3579 case EFA_PARISC_1_1
:
3580 strcpy (buf
, ", PA-RISC 1.1");
3582 case EFA_PARISC_2_0
:
3583 strcpy (buf
, ", PA-RISC 2.0");
3588 if (e_flags
& EF_PARISC_TRAPNIL
)
3589 strcat (buf
, ", trapnil");
3590 if (e_flags
& EF_PARISC_EXT
)
3591 strcat (buf
, ", ext");
3592 if (e_flags
& EF_PARISC_LSB
)
3593 strcat (buf
, ", lsb");
3594 if (e_flags
& EF_PARISC_WIDE
)
3595 strcat (buf
, ", wide");
3596 if (e_flags
& EF_PARISC_NO_KABP
)
3597 strcat (buf
, ", no kabp");
3598 if (e_flags
& EF_PARISC_LAZYSWAP
)
3599 strcat (buf
, ", lazyswap");
3604 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3605 strcat (buf
, ", new calling convention");
3607 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3608 strcat (buf
, ", gnu calling convention");
3612 if ((e_flags
& EF_IA_64_ABI64
))
3613 strcat (buf
, ", 64-bit");
3615 strcat (buf
, ", 32-bit");
3616 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3617 strcat (buf
, ", reduced fp model");
3618 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3619 strcat (buf
, ", no function descriptors, constant gp");
3620 else if ((e_flags
& EF_IA_64_CONS_GP
))
3621 strcat (buf
, ", constant gp");
3622 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3623 strcat (buf
, ", absolute");
3624 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3626 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3627 strcat (buf
, ", vms_linkages");
3628 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3630 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3632 case EF_IA_64_VMS_COMCOD_WARNING
:
3633 strcat (buf
, ", warning");
3635 case EF_IA_64_VMS_COMCOD_ERROR
:
3636 strcat (buf
, ", error");
3638 case EF_IA_64_VMS_COMCOD_ABORT
:
3639 strcat (buf
, ", abort");
3642 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3643 e_flags
& EF_IA_64_VMS_COMCOD
);
3644 strcat (buf
, ", <unknown>");
3650 if ((e_flags
& EF_VAX_NONPIC
))
3651 strcat (buf
, ", non-PIC");
3652 if ((e_flags
& EF_VAX_DFLOAT
))
3653 strcat (buf
, ", D-Float");
3654 if ((e_flags
& EF_VAX_GFLOAT
))
3655 strcat (buf
, ", G-Float");
3659 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3660 strcat (buf
, ", mcm");
3661 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3662 strcat (buf
, ", mcm24");
3663 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3664 strcat (buf
, ", gr6");
3668 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3670 case E_FLAG_RL78_ANY_CPU
: break;
3671 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3672 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3673 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3675 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3676 strcat (buf
, ", 64-bit doubles");
3680 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3681 strcat (buf
, ", 64-bit doubles");
3682 if (e_flags
& E_FLAG_RX_DSP
)
3683 strcat (buf
, ", dsp");
3684 if (e_flags
& E_FLAG_RX_PID
)
3685 strcat (buf
, ", pid");
3686 if (e_flags
& E_FLAG_RX_ABI
)
3687 strcat (buf
, ", RX ABI");
3688 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3689 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3690 ? ", uses String instructions" : ", bans String instructions");
3691 if (e_flags
& E_FLAG_RX_V2
)
3692 strcat (buf
, ", V2");
3693 if (e_flags
& E_FLAG_RX_V3
)
3694 strcat (buf
, ", V3");
3698 if (e_flags
& EF_S390_HIGH_GPRS
)
3699 strcat (buf
, ", highgprs");
3703 if ((e_flags
& EF_C6000_REL
))
3704 strcat (buf
, ", relocatable module");
3708 strcat (buf
, _(": architecture variant: "));
3709 switch (e_flags
& EF_MSP430_MACH
)
3711 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3712 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3713 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3714 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3715 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3716 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3717 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3718 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3719 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3720 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3721 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3722 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3723 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3724 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3725 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3727 strcat (buf
, _(": unknown")); break;
3730 if (e_flags
& ~ EF_MSP430_MACH
)
3731 strcat (buf
, _(": unknown extra flag bits also present"));
3739 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3741 static char buff
[32];
3745 case ELFOSABI_NONE
: return "UNIX - System V";
3746 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3747 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3748 case ELFOSABI_GNU
: return "UNIX - GNU";
3749 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3750 case ELFOSABI_AIX
: return "UNIX - AIX";
3751 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3752 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3753 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3754 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3755 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3756 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3757 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3758 case ELFOSABI_AROS
: return "AROS";
3759 case ELFOSABI_FENIXOS
: return "FenixOS";
3760 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3761 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3764 switch (filedata
->file_header
.e_machine
)
3769 case ELFOSABI_ARM
: return "ARM";
3770 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3781 case ELFOSABI_STANDALONE
: return _("Standalone App");
3790 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3791 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3800 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3806 get_aarch64_segment_type (unsigned long type
)
3810 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3811 default: return NULL
;
3816 get_arm_segment_type (unsigned long type
)
3820 case PT_ARM_EXIDX
: return "EXIDX";
3821 default: return NULL
;
3826 get_s390_segment_type (unsigned long type
)
3830 case PT_S390_PGSTE
: return "S390_PGSTE";
3831 default: return NULL
;
3836 get_mips_segment_type (unsigned long type
)
3840 case PT_MIPS_REGINFO
: return "REGINFO";
3841 case PT_MIPS_RTPROC
: return "RTPROC";
3842 case PT_MIPS_OPTIONS
: return "OPTIONS";
3843 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3844 default: return NULL
;
3849 get_parisc_segment_type (unsigned long type
)
3853 case PT_HP_TLS
: return "HP_TLS";
3854 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3855 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3856 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3857 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3858 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3859 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3860 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3861 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3862 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3863 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3864 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3865 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3866 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3867 case PT_HP_STACK
: return "HP_STACK";
3868 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3869 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3870 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3871 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3872 default: return NULL
;
3877 get_ia64_segment_type (unsigned long type
)
3881 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3882 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3883 case PT_HP_TLS
: return "HP_TLS";
3884 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3885 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3886 case PT_IA_64_HP_STACK
: return "HP_STACK";
3887 default: return NULL
;
3892 get_tic6x_segment_type (unsigned long type
)
3896 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3897 default: return NULL
;
3902 get_solaris_segment_type (unsigned long type
)
3906 case 0x6464e550: return "PT_SUNW_UNWIND";
3907 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3908 case 0x6ffffff7: return "PT_LOSUNW";
3909 case 0x6ffffffa: return "PT_SUNWBSS";
3910 case 0x6ffffffb: return "PT_SUNWSTACK";
3911 case 0x6ffffffc: return "PT_SUNWDTRACE";
3912 case 0x6ffffffd: return "PT_SUNWCAP";
3913 case 0x6fffffff: return "PT_HISUNW";
3914 default: return NULL
;
3919 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3921 static char buff
[32];
3925 case PT_NULL
: return "NULL";
3926 case PT_LOAD
: return "LOAD";
3927 case PT_DYNAMIC
: return "DYNAMIC";
3928 case PT_INTERP
: return "INTERP";
3929 case PT_NOTE
: return "NOTE";
3930 case PT_SHLIB
: return "SHLIB";
3931 case PT_PHDR
: return "PHDR";
3932 case PT_TLS
: return "TLS";
3933 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3934 case PT_GNU_STACK
: return "GNU_STACK";
3935 case PT_GNU_RELRO
: return "GNU_RELRO";
3936 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
3939 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3941 sprintf (buff
, "GNU_MBIND+%#lx",
3942 p_type
- PT_GNU_MBIND_LO
);
3944 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3946 const char * result
;
3948 switch (filedata
->file_header
.e_machine
)
3951 result
= get_aarch64_segment_type (p_type
);
3954 result
= get_arm_segment_type (p_type
);
3957 case EM_MIPS_RS3_LE
:
3958 result
= get_mips_segment_type (p_type
);
3961 result
= get_parisc_segment_type (p_type
);
3964 result
= get_ia64_segment_type (p_type
);
3967 result
= get_tic6x_segment_type (p_type
);
3971 result
= get_s390_segment_type (p_type
);
3981 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3983 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3985 const char * result
;
3987 switch (filedata
->file_header
.e_machine
)
3990 result
= get_parisc_segment_type (p_type
);
3993 result
= get_ia64_segment_type (p_type
);
3996 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3997 result
= get_solaris_segment_type (p_type
);
4006 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4009 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4016 get_arc_section_type_name (unsigned int sh_type
)
4020 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4028 get_mips_section_type_name (unsigned int sh_type
)
4032 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4033 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4034 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4035 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4036 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4037 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4038 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4039 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4040 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4041 case SHT_MIPS_RELD
: return "MIPS_RELD";
4042 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4043 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4044 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4045 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4046 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4047 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4048 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4049 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4050 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4051 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4052 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4053 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4054 case SHT_MIPS_LINE
: return "MIPS_LINE";
4055 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4056 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4057 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4058 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4059 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4060 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4061 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4062 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4063 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4064 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4065 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4066 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4067 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4068 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4069 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4070 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4071 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4079 get_parisc_section_type_name (unsigned int sh_type
)
4083 case SHT_PARISC_EXT
: return "PARISC_EXT";
4084 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4085 case SHT_PARISC_DOC
: return "PARISC_DOC";
4086 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4087 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4088 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4089 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4090 default: return NULL
;
4095 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4097 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4098 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4099 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4103 case SHT_IA_64_EXT
: return "IA_64_EXT";
4104 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4105 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4106 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4107 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4108 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4109 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4110 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4111 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4112 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4120 get_x86_64_section_type_name (unsigned int sh_type
)
4124 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4125 default: return NULL
;
4130 get_aarch64_section_type_name (unsigned int sh_type
)
4134 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4135 default: return NULL
;
4140 get_arm_section_type_name (unsigned int sh_type
)
4144 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4145 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4146 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4147 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4148 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4149 default: return NULL
;
4154 get_tic6x_section_type_name (unsigned int sh_type
)
4158 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4159 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4160 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4161 case SHT_TI_ICODE
: return "TI_ICODE";
4162 case SHT_TI_XREF
: return "TI_XREF";
4163 case SHT_TI_HANDLER
: return "TI_HANDLER";
4164 case SHT_TI_INITINFO
: return "TI_INITINFO";
4165 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4166 default: return NULL
;
4171 get_msp430x_section_type_name (unsigned int sh_type
)
4175 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4176 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4177 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4178 default: return NULL
;
4183 get_nfp_section_type_name (unsigned int sh_type
)
4187 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4188 case SHT_NFP_INITREG
: return "NFP_INITREG";
4189 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4190 default: return NULL
;
4195 get_v850_section_type_name (unsigned int sh_type
)
4199 case SHT_V850_SCOMMON
: return "V850 Small Common";
4200 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4201 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4202 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4203 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4204 default: return NULL
;
4209 get_riscv_section_type_name (unsigned int sh_type
)
4213 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4214 default: return NULL
;
4219 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4221 static char buff
[32];
4222 const char * result
;
4226 case SHT_NULL
: return "NULL";
4227 case SHT_PROGBITS
: return "PROGBITS";
4228 case SHT_SYMTAB
: return "SYMTAB";
4229 case SHT_STRTAB
: return "STRTAB";
4230 case SHT_RELA
: return "RELA";
4231 case SHT_HASH
: return "HASH";
4232 case SHT_DYNAMIC
: return "DYNAMIC";
4233 case SHT_NOTE
: return "NOTE";
4234 case SHT_NOBITS
: return "NOBITS";
4235 case SHT_REL
: return "REL";
4236 case SHT_SHLIB
: return "SHLIB";
4237 case SHT_DYNSYM
: return "DYNSYM";
4238 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4239 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4240 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4241 case SHT_GNU_HASH
: return "GNU_HASH";
4242 case SHT_GROUP
: return "GROUP";
4243 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4244 case SHT_GNU_verdef
: return "VERDEF";
4245 case SHT_GNU_verneed
: return "VERNEED";
4246 case SHT_GNU_versym
: return "VERSYM";
4247 case 0x6ffffff0: return "VERSYM";
4248 case 0x6ffffffc: return "VERDEF";
4249 case 0x7ffffffd: return "AUXILIARY";
4250 case 0x7fffffff: return "FILTER";
4251 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4254 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4256 switch (filedata
->file_header
.e_machine
)
4259 case EM_ARC_COMPACT
:
4260 case EM_ARC_COMPACT2
:
4261 result
= get_arc_section_type_name (sh_type
);
4264 case EM_MIPS_RS3_LE
:
4265 result
= get_mips_section_type_name (sh_type
);
4268 result
= get_parisc_section_type_name (sh_type
);
4271 result
= get_ia64_section_type_name (filedata
, sh_type
);
4276 result
= get_x86_64_section_type_name (sh_type
);
4279 result
= get_aarch64_section_type_name (sh_type
);
4282 result
= get_arm_section_type_name (sh_type
);
4285 result
= get_tic6x_section_type_name (sh_type
);
4288 result
= get_msp430x_section_type_name (sh_type
);
4291 result
= get_nfp_section_type_name (sh_type
);
4295 case EM_CYGNUS_V850
:
4296 result
= get_v850_section_type_name (sh_type
);
4299 result
= get_riscv_section_type_name (sh_type
);
4309 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4311 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4313 switch (filedata
->file_header
.e_machine
)
4316 result
= get_ia64_section_type_name (filedata
, sh_type
);
4319 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4320 result
= get_solaris_section_type (sh_type
);
4325 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4326 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4327 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4328 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4340 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4342 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4344 switch (filedata
->file_header
.e_machine
)
4348 case EM_CYGNUS_V850
:
4349 result
= get_v850_section_type_name (sh_type
);
4359 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4362 /* This message is probably going to be displayed in a 15
4363 character wide field, so put the hex value first. */
4364 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4370 #define OPTION_DEBUG_DUMP 512
4371 #define OPTION_DYN_SYMS 513
4372 #define OPTION_DWARF_DEPTH 514
4373 #define OPTION_DWARF_START 515
4374 #define OPTION_DWARF_CHECK 516
4376 static struct option options
[] =
4378 {"all", no_argument
, 0, 'a'},
4379 {"file-header", no_argument
, 0, 'h'},
4380 {"program-headers", no_argument
, 0, 'l'},
4381 {"headers", no_argument
, 0, 'e'},
4382 {"histogram", no_argument
, 0, 'I'},
4383 {"segments", no_argument
, 0, 'l'},
4384 {"sections", no_argument
, 0, 'S'},
4385 {"section-headers", no_argument
, 0, 'S'},
4386 {"section-groups", no_argument
, 0, 'g'},
4387 {"section-details", no_argument
, 0, 't'},
4388 {"full-section-name",no_argument
, 0, 'N'},
4389 {"symbols", no_argument
, 0, 's'},
4390 {"syms", no_argument
, 0, 's'},
4391 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4392 {"relocs", no_argument
, 0, 'r'},
4393 {"notes", no_argument
, 0, 'n'},
4394 {"dynamic", no_argument
, 0, 'd'},
4395 {"arch-specific", no_argument
, 0, 'A'},
4396 {"version-info", no_argument
, 0, 'V'},
4397 {"use-dynamic", no_argument
, 0, 'D'},
4398 {"unwind", no_argument
, 0, 'u'},
4399 {"archive-index", no_argument
, 0, 'c'},
4400 {"hex-dump", required_argument
, 0, 'x'},
4401 {"relocated-dump", required_argument
, 0, 'R'},
4402 {"string-dump", required_argument
, 0, 'p'},
4403 {"decompress", no_argument
, 0, 'z'},
4404 #ifdef SUPPORT_DISASSEMBLY
4405 {"instruction-dump", required_argument
, 0, 'i'},
4407 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4409 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4410 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4411 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4413 {"version", no_argument
, 0, 'v'},
4414 {"wide", no_argument
, 0, 'W'},
4415 {"help", no_argument
, 0, 'H'},
4416 {0, no_argument
, 0, 0}
4420 usage (FILE * stream
)
4422 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4423 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4424 fprintf (stream
, _(" Options are:\n\
4425 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4426 -h --file-header Display the ELF file header\n\
4427 -l --program-headers Display the program headers\n\
4428 --segments An alias for --program-headers\n\
4429 -S --section-headers Display the sections' header\n\
4430 --sections An alias for --section-headers\n\
4431 -g --section-groups Display the section groups\n\
4432 -t --section-details Display the section details\n\
4433 -e --headers Equivalent to: -h -l -S\n\
4434 -s --syms Display the symbol table\n\
4435 --symbols An alias for --syms\n\
4436 --dyn-syms Display the dynamic symbol table\n\
4437 -n --notes Display the core notes (if present)\n\
4438 -r --relocs Display the relocations (if present)\n\
4439 -u --unwind Display the unwind info (if present)\n\
4440 -d --dynamic Display the dynamic section (if present)\n\
4441 -V --version-info Display the version sections (if present)\n\
4442 -A --arch-specific Display architecture specific information (if any)\n\
4443 -c --archive-index Display the symbol/file index in an archive\n\
4444 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4445 -x --hex-dump=<number|name>\n\
4446 Dump the contents of section <number|name> as bytes\n\
4447 -p --string-dump=<number|name>\n\
4448 Dump the contents of section <number|name> as strings\n\
4449 -R --relocated-dump=<number|name>\n\
4450 Dump the contents of section <number|name> as relocated bytes\n\
4451 -z --decompress Decompress section before dumping it\n\
4452 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4453 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4454 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4455 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4456 =addr,=cu_index,=links,=follow-links]\n\
4457 Display the contents of DWARF debug sections\n"));
4458 fprintf (stream
, _("\
4459 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4460 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4462 #ifdef SUPPORT_DISASSEMBLY
4463 fprintf (stream
, _("\
4464 -i --instruction-dump=<number|name>\n\
4465 Disassemble the contents of section <number|name>\n"));
4467 fprintf (stream
, _("\
4468 -I --histogram Display histogram of bucket list lengths\n\
4469 -W --wide Allow output width to exceed 80 characters\n\
4470 @<file> Read options from <file>\n\
4471 -H --help Display this information\n\
4472 -v --version Display the version number of readelf\n"));
4474 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4475 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4477 exit (stream
== stdout
? 0 : 1);
4480 /* Record the fact that the user wants the contents of section number
4481 SECTION to be displayed using the method(s) encoded as flags bits
4482 in TYPE. Note, TYPE can be zero if we are creating the array for
4486 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4488 if (section
>= filedata
->num_dump_sects
)
4490 dump_type
* new_dump_sects
;
4492 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4493 sizeof (* new_dump_sects
));
4495 if (new_dump_sects
== NULL
)
4496 error (_("Out of memory allocating dump request table.\n"));
4499 if (filedata
->dump_sects
)
4501 /* Copy current flag settings. */
4502 memcpy (new_dump_sects
, filedata
->dump_sects
,
4503 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4505 free (filedata
->dump_sects
);
4508 filedata
->dump_sects
= new_dump_sects
;
4509 filedata
->num_dump_sects
= section
+ 1;
4513 if (filedata
->dump_sects
)
4514 filedata
->dump_sects
[section
] |= type
;
4517 /* Request a dump by section name. */
4520 request_dump_byname (const char * section
, dump_type type
)
4522 struct dump_list_entry
* new_request
;
4524 new_request
= (struct dump_list_entry
*)
4525 malloc (sizeof (struct dump_list_entry
));
4527 error (_("Out of memory allocating dump request table.\n"));
4529 new_request
->name
= strdup (section
);
4530 if (!new_request
->name
)
4531 error (_("Out of memory allocating dump request table.\n"));
4533 new_request
->type
= type
;
4535 new_request
->next
= dump_sects_byname
;
4536 dump_sects_byname
= new_request
;
4540 request_dump (Filedata
* filedata
, dump_type type
)
4546 section
= strtoul (optarg
, & cp
, 0);
4548 if (! *cp
&& section
>= 0)
4549 request_dump_bynumber (filedata
, section
, type
);
4551 request_dump_byname (optarg
, type
);
4555 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4562 while ((c
= getopt_long
4563 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4581 do_section_groups
= TRUE
;
4584 do_histogram
= TRUE
;
4589 do_section_groups
= TRUE
;
4594 do_section_details
= TRUE
;
4605 do_using_dynamic
= TRUE
;
4629 do_histogram
= TRUE
;
4635 do_archive_index
= TRUE
;
4638 request_dump (filedata
, HEX_DUMP
);
4641 request_dump (filedata
, STRING_DUMP
);
4644 request_dump (filedata
, RELOC_DUMP
);
4647 decompress_dumps
= TRUE
;
4653 do_debugging
= TRUE
;
4654 dwarf_select_sections_all ();
4658 do_debugging
= FALSE
;
4659 dwarf_select_sections_by_letters (optarg
);
4662 case OPTION_DEBUG_DUMP
:
4665 do_debugging
= TRUE
;
4668 do_debugging
= FALSE
;
4669 dwarf_select_sections_by_names (optarg
);
4672 case OPTION_DWARF_DEPTH
:
4676 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4679 case OPTION_DWARF_START
:
4683 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4686 case OPTION_DWARF_CHECK
:
4689 case OPTION_DYN_SYMS
:
4692 #ifdef SUPPORT_DISASSEMBLY
4694 request_dump (filedata
, DISASS_DUMP
);
4698 print_version (program_name
);
4707 /* xgettext:c-format */
4708 error (_("Invalid option '-%c'\n"), c
);
4715 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4716 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4717 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4718 && !do_section_groups
&& !do_archive_index
4724 get_elf_class (unsigned int elf_class
)
4726 static char buff
[32];
4730 case ELFCLASSNONE
: return _("none");
4731 case ELFCLASS32
: return "ELF32";
4732 case ELFCLASS64
: return "ELF64";
4734 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4740 get_data_encoding (unsigned int encoding
)
4742 static char buff
[32];
4746 case ELFDATANONE
: return _("none");
4747 case ELFDATA2LSB
: return _("2's complement, little endian");
4748 case ELFDATA2MSB
: return _("2's complement, big endian");
4750 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4755 /* Decode the data held in 'filedata->file_header'. */
4758 process_file_header (Filedata
* filedata
)
4760 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4762 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4763 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4764 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4765 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4768 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4772 init_dwarf_regnames (header
->e_machine
);
4778 printf (_("ELF Header:\n"));
4779 printf (_(" Magic: "));
4780 for (i
= 0; i
< EI_NIDENT
; i
++)
4781 printf ("%2.2x ", header
->e_ident
[i
]);
4783 printf (_(" Class: %s\n"),
4784 get_elf_class (header
->e_ident
[EI_CLASS
]));
4785 printf (_(" Data: %s\n"),
4786 get_data_encoding (header
->e_ident
[EI_DATA
]));
4787 printf (_(" Version: %d%s\n"),
4788 header
->e_ident
[EI_VERSION
],
4789 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4791 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4794 printf (_(" OS/ABI: %s\n"),
4795 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4796 printf (_(" ABI Version: %d\n"),
4797 header
->e_ident
[EI_ABIVERSION
]);
4798 printf (_(" Type: %s\n"),
4799 get_file_type (header
->e_type
));
4800 printf (_(" Machine: %s\n"),
4801 get_machine_name (header
->e_machine
));
4802 printf (_(" Version: 0x%lx\n"),
4805 printf (_(" Entry point address: "));
4806 print_vma (header
->e_entry
, PREFIX_HEX
);
4807 printf (_("\n Start of program headers: "));
4808 print_vma (header
->e_phoff
, DEC
);
4809 printf (_(" (bytes into file)\n Start of section headers: "));
4810 print_vma (header
->e_shoff
, DEC
);
4811 printf (_(" (bytes into file)\n"));
4813 printf (_(" Flags: 0x%lx%s\n"),
4815 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4816 printf (_(" Size of this header: %u (bytes)\n"),
4818 printf (_(" Size of program headers: %u (bytes)\n"),
4819 header
->e_phentsize
);
4820 printf (_(" Number of program headers: %u"),
4822 if (filedata
->section_headers
!= NULL
4823 && header
->e_phnum
== PN_XNUM
4824 && filedata
->section_headers
[0].sh_info
!= 0)
4826 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4827 printf (" (%u)", header
->e_phnum
);
4829 putc ('\n', stdout
);
4830 printf (_(" Size of section headers: %u (bytes)\n"),
4831 header
->e_shentsize
);
4832 printf (_(" Number of section headers: %u"),
4834 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4836 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4837 printf (" (%u)", header
->e_shnum
);
4839 putc ('\n', stdout
);
4840 printf (_(" Section header string table index: %u"),
4841 header
->e_shstrndx
);
4842 if (filedata
->section_headers
!= NULL
4843 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4845 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4846 printf (" (%u)", header
->e_shstrndx
);
4848 if (header
->e_shstrndx
!= SHN_UNDEF
4849 && header
->e_shstrndx
>= header
->e_shnum
)
4851 header
->e_shstrndx
= SHN_UNDEF
;
4852 printf (_(" <corrupt: out of range>"));
4854 putc ('\n', stdout
);
4857 if (filedata
->section_headers
!= NULL
)
4859 if (header
->e_phnum
== PN_XNUM
4860 && filedata
->section_headers
[0].sh_info
!= 0)
4861 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4862 if (header
->e_shnum
== SHN_UNDEF
)
4863 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4864 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4865 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4866 if (header
->e_shstrndx
>= header
->e_shnum
)
4867 header
->e_shstrndx
= SHN_UNDEF
;
4868 free (filedata
->section_headers
);
4869 filedata
->section_headers
= NULL
;
4875 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4876 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4879 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4881 Elf32_External_Phdr
* phdrs
;
4882 Elf32_External_Phdr
* external
;
4883 Elf_Internal_Phdr
* internal
;
4885 unsigned int size
= filedata
->file_header
.e_phentsize
;
4886 unsigned int num
= filedata
->file_header
.e_phnum
;
4888 /* PR binutils/17531: Cope with unexpected section header sizes. */
4889 if (size
== 0 || num
== 0)
4891 if (size
< sizeof * phdrs
)
4893 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4896 if (size
> sizeof * phdrs
)
4897 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4899 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4900 size
, num
, _("program headers"));
4904 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4905 i
< filedata
->file_header
.e_phnum
;
4906 i
++, internal
++, external
++)
4908 internal
->p_type
= BYTE_GET (external
->p_type
);
4909 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4910 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4911 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4912 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4913 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4914 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4915 internal
->p_align
= BYTE_GET (external
->p_align
);
4922 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4923 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4926 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4928 Elf64_External_Phdr
* phdrs
;
4929 Elf64_External_Phdr
* external
;
4930 Elf_Internal_Phdr
* internal
;
4932 unsigned int size
= filedata
->file_header
.e_phentsize
;
4933 unsigned int num
= filedata
->file_header
.e_phnum
;
4935 /* PR binutils/17531: Cope with unexpected section header sizes. */
4936 if (size
== 0 || num
== 0)
4938 if (size
< sizeof * phdrs
)
4940 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4943 if (size
> sizeof * phdrs
)
4944 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4946 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4947 size
, num
, _("program headers"));
4951 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4952 i
< filedata
->file_header
.e_phnum
;
4953 i
++, internal
++, external
++)
4955 internal
->p_type
= BYTE_GET (external
->p_type
);
4956 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4957 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4958 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4959 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4960 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4961 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4962 internal
->p_align
= BYTE_GET (external
->p_align
);
4969 /* Returns TRUE if the program headers were read into `program_headers'. */
4972 get_program_headers (Filedata
* filedata
)
4974 Elf_Internal_Phdr
* phdrs
;
4976 /* Check cache of prior read. */
4977 if (filedata
->program_headers
!= NULL
)
4980 /* Be kind to memory checkers by looking for
4981 e_phnum values which we know must be invalid. */
4982 if (filedata
->file_header
.e_phnum
4983 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4984 >= filedata
->file_size
)
4986 error (_("Too many program headers - %#x - the file is not that big\n"),
4987 filedata
->file_header
.e_phnum
);
4991 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4992 sizeof (Elf_Internal_Phdr
));
4995 error (_("Out of memory reading %u program headers\n"),
4996 filedata
->file_header
.e_phnum
);
5001 ? get_32bit_program_headers (filedata
, phdrs
)
5002 : get_64bit_program_headers (filedata
, phdrs
))
5004 filedata
->program_headers
= phdrs
;
5012 /* Returns TRUE if the program headers were loaded. */
5015 process_program_headers (Filedata
* filedata
)
5017 Elf_Internal_Phdr
* segment
;
5019 Elf_Internal_Phdr
* previous_load
= NULL
;
5021 if (filedata
->file_header
.e_phnum
== 0)
5023 /* PR binutils/12467. */
5024 if (filedata
->file_header
.e_phoff
!= 0)
5026 warn (_("possibly corrupt ELF header - it has a non-zero program"
5027 " header offset, but no program headers\n"));
5030 else if (do_segments
)
5031 printf (_("\nThere are no program headers in this file.\n"));
5035 if (do_segments
&& !do_header
)
5037 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5038 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5039 printf (ngettext ("There is %d program header, starting at offset %s\n",
5040 "There are %d program headers, starting at offset %s\n",
5041 filedata
->file_header
.e_phnum
),
5042 filedata
->file_header
.e_phnum
,
5043 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5046 if (! get_program_headers (filedata
))
5051 if (filedata
->file_header
.e_phnum
> 1)
5052 printf (_("\nProgram Headers:\n"));
5054 printf (_("\nProgram Headers:\n"));
5058 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5061 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5065 (_(" Type Offset VirtAddr PhysAddr\n"));
5067 (_(" FileSiz MemSiz Flags Align\n"));
5074 for (i
= 0, segment
= filedata
->program_headers
;
5075 i
< filedata
->file_header
.e_phnum
;
5080 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5084 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5085 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5086 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5087 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5088 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5090 (segment
->p_flags
& PF_R
? 'R' : ' '),
5091 (segment
->p_flags
& PF_W
? 'W' : ' '),
5092 (segment
->p_flags
& PF_X
? 'E' : ' '));
5093 printf ("%#lx", (unsigned long) segment
->p_align
);
5097 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5098 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5101 print_vma (segment
->p_offset
, FULL_HEX
);
5105 print_vma (segment
->p_vaddr
, FULL_HEX
);
5107 print_vma (segment
->p_paddr
, FULL_HEX
);
5110 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5111 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5114 print_vma (segment
->p_filesz
, FULL_HEX
);
5118 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5119 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5122 print_vma (segment
->p_memsz
, FULL_HEX
);
5126 (segment
->p_flags
& PF_R
? 'R' : ' '),
5127 (segment
->p_flags
& PF_W
? 'W' : ' '),
5128 (segment
->p_flags
& PF_X
? 'E' : ' '));
5130 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5131 printf ("%#lx", (unsigned long) segment
->p_align
);
5134 print_vma (segment
->p_align
, PREFIX_HEX
);
5139 print_vma (segment
->p_offset
, FULL_HEX
);
5141 print_vma (segment
->p_vaddr
, FULL_HEX
);
5143 print_vma (segment
->p_paddr
, FULL_HEX
);
5145 print_vma (segment
->p_filesz
, FULL_HEX
);
5147 print_vma (segment
->p_memsz
, FULL_HEX
);
5149 (segment
->p_flags
& PF_R
? 'R' : ' '),
5150 (segment
->p_flags
& PF_W
? 'W' : ' '),
5151 (segment
->p_flags
& PF_X
? 'E' : ' '));
5152 print_vma (segment
->p_align
, PREFIX_HEX
);
5155 putc ('\n', stdout
);
5158 switch (segment
->p_type
)
5161 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5162 required by the ELF standard, several programs, including the Linux
5163 kernel, make use of non-ordered segments. */
5165 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5166 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5168 if (segment
->p_memsz
< segment
->p_filesz
)
5169 error (_("the segment's file size is larger than its memory size\n"));
5170 previous_load
= segment
;
5174 /* PR 20815 - Verify that the program header is loaded into memory. */
5175 if (i
> 0 && previous_load
!= NULL
)
5176 error (_("the PHDR segment must occur before any LOAD segment\n"));
5177 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5181 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5182 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5183 && (filedata
->program_headers
[j
].p_vaddr
5184 + filedata
->program_headers
[j
].p_memsz
)
5185 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5187 if (j
== filedata
->file_header
.e_phnum
)
5188 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5194 error (_("more than one dynamic segment\n"));
5196 /* By default, assume that the .dynamic section is the first
5197 section in the DYNAMIC segment. */
5198 dynamic_addr
= segment
->p_offset
;
5199 dynamic_size
= segment
->p_filesz
;
5201 /* Try to locate the .dynamic section. If there is
5202 a section header table, we can easily locate it. */
5203 if (filedata
->section_headers
!= NULL
)
5205 Elf_Internal_Shdr
* sec
;
5207 sec
= find_section (filedata
, ".dynamic");
5208 if (sec
== NULL
|| sec
->sh_size
== 0)
5210 /* A corresponding .dynamic section is expected, but on
5211 IA-64/OpenVMS it is OK for it to be missing. */
5212 if (!is_ia64_vms (filedata
))
5213 error (_("no .dynamic section in the dynamic segment\n"));
5217 if (sec
->sh_type
== SHT_NOBITS
)
5223 dynamic_addr
= sec
->sh_offset
;
5224 dynamic_size
= sec
->sh_size
;
5226 if (dynamic_addr
< segment
->p_offset
5227 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5228 warn (_("the .dynamic section is not contained"
5229 " within the dynamic segment\n"));
5230 else if (dynamic_addr
> segment
->p_offset
)
5231 warn (_("the .dynamic section is not the first section"
5232 " in the dynamic segment.\n"));
5235 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5236 segment. Check this after matching against the section headers
5237 so we don't warn on debuginfo file (which have NOBITS .dynamic
5239 if (dynamic_addr
> filedata
->file_size
5240 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5242 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5243 dynamic_addr
= dynamic_size
= 0;
5248 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5250 error (_("Unable to find program interpreter name\n"));
5254 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5256 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5257 error (_("Internal error: failed to create format string to display program interpreter\n"));
5259 program_interpreter
[0] = 0;
5260 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5261 error (_("Unable to read program interpreter name\n"));
5264 printf (_(" [Requesting program interpreter: %s]\n"),
5265 program_interpreter
);
5272 && filedata
->section_headers
!= NULL
5273 && filedata
->string_table
!= NULL
)
5275 printf (_("\n Section to Segment mapping:\n"));
5276 printf (_(" Segment Sections...\n"));
5278 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5281 Elf_Internal_Shdr
* section
;
5283 segment
= filedata
->program_headers
+ i
;
5284 section
= filedata
->section_headers
+ 1;
5286 printf (" %2.2d ", i
);
5288 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5290 if (!ELF_TBSS_SPECIAL (section
, segment
)
5291 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5292 printf ("%s ", printable_section_name (filedata
, section
));
5303 /* Find the file offset corresponding to VMA by using the program headers. */
5306 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5308 Elf_Internal_Phdr
* seg
;
5310 if (! get_program_headers (filedata
))
5312 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5316 for (seg
= filedata
->program_headers
;
5317 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5320 if (seg
->p_type
!= PT_LOAD
)
5323 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5324 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5325 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5328 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5329 (unsigned long) vma
);
5334 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5335 If PROBE is true, this is just a probe and we do not generate any error
5336 messages if the load fails. */
5339 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5341 Elf32_External_Shdr
* shdrs
;
5342 Elf_Internal_Shdr
* internal
;
5344 unsigned int size
= filedata
->file_header
.e_shentsize
;
5345 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5347 /* PR binutils/17531: Cope with unexpected section header sizes. */
5348 if (size
== 0 || num
== 0)
5350 if (size
< sizeof * shdrs
)
5353 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5356 if (!probe
&& size
> sizeof * shdrs
)
5357 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5359 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5361 probe
? NULL
: _("section headers"));
5365 free (filedata
->section_headers
);
5366 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5367 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5368 if (filedata
->section_headers
== NULL
)
5371 error (_("Out of memory reading %u section headers\n"), num
);
5376 for (i
= 0, internal
= filedata
->section_headers
;
5380 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5381 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5382 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5383 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5384 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5385 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5386 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5387 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5388 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5389 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5390 if (!probe
&& internal
->sh_link
> num
)
5391 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5392 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5393 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5400 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5403 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5405 Elf64_External_Shdr
* shdrs
;
5406 Elf_Internal_Shdr
* internal
;
5408 unsigned int size
= filedata
->file_header
.e_shentsize
;
5409 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5411 /* PR binutils/17531: Cope with unexpected section header sizes. */
5412 if (size
== 0 || num
== 0)
5415 if (size
< sizeof * shdrs
)
5418 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5422 if (! probe
&& size
> sizeof * shdrs
)
5423 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5425 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5426 filedata
->file_header
.e_shoff
,
5428 probe
? NULL
: _("section headers"));
5432 free (filedata
->section_headers
);
5433 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5434 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5435 if (filedata
->section_headers
== NULL
)
5438 error (_("Out of memory reading %u section headers\n"), num
);
5443 for (i
= 0, internal
= filedata
->section_headers
;
5447 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5448 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5449 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5450 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5451 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5452 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5453 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5454 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5455 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5456 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5457 if (!probe
&& internal
->sh_link
> num
)
5458 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5459 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5460 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5467 static Elf_Internal_Sym
*
5468 get_32bit_elf_symbols (Filedata
* filedata
,
5469 Elf_Internal_Shdr
* section
,
5470 unsigned long * num_syms_return
)
5472 unsigned long number
= 0;
5473 Elf32_External_Sym
* esyms
= NULL
;
5474 Elf_External_Sym_Shndx
* shndx
= NULL
;
5475 Elf_Internal_Sym
* isyms
= NULL
;
5476 Elf_Internal_Sym
* psym
;
5478 elf_section_list
* entry
;
5480 if (section
->sh_size
== 0)
5482 if (num_syms_return
!= NULL
)
5483 * num_syms_return
= 0;
5487 /* Run some sanity checks first. */
5488 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5490 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5491 printable_section_name (filedata
, section
),
5492 (unsigned long) section
->sh_entsize
);
5496 if (section
->sh_size
> filedata
->file_size
)
5498 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5499 printable_section_name (filedata
, section
),
5500 (unsigned long) section
->sh_size
);
5504 number
= section
->sh_size
/ section
->sh_entsize
;
5506 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5508 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5509 (unsigned long) section
->sh_size
,
5510 printable_section_name (filedata
, section
),
5511 (unsigned long) section
->sh_entsize
);
5515 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5516 section
->sh_size
, _("symbols"));
5521 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5523 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5528 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5532 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5533 entry
->hdr
->sh_offset
,
5534 1, entry
->hdr
->sh_size
,
5535 _("symbol table section indices"));
5539 /* PR17531: file: heap-buffer-overflow */
5540 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5542 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5543 printable_section_name (filedata
, entry
->hdr
),
5544 (unsigned long) entry
->hdr
->sh_size
,
5545 (unsigned long) section
->sh_size
);
5550 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5554 error (_("Out of memory reading %lu symbols\n"),
5555 (unsigned long) number
);
5559 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5561 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5562 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5563 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5564 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5565 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5567 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5568 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5569 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5570 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5571 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5578 if (num_syms_return
!= NULL
)
5579 * num_syms_return
= isyms
== NULL
? 0 : number
;
5584 static Elf_Internal_Sym
*
5585 get_64bit_elf_symbols (Filedata
* filedata
,
5586 Elf_Internal_Shdr
* section
,
5587 unsigned long * num_syms_return
)
5589 unsigned long number
= 0;
5590 Elf64_External_Sym
* esyms
= NULL
;
5591 Elf_External_Sym_Shndx
* shndx
= NULL
;
5592 Elf_Internal_Sym
* isyms
= NULL
;
5593 Elf_Internal_Sym
* psym
;
5595 elf_section_list
* entry
;
5597 if (section
->sh_size
== 0)
5599 if (num_syms_return
!= NULL
)
5600 * num_syms_return
= 0;
5604 /* Run some sanity checks first. */
5605 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5607 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5608 printable_section_name (filedata
, section
),
5609 (unsigned long) section
->sh_entsize
);
5613 if (section
->sh_size
> filedata
->file_size
)
5615 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5616 printable_section_name (filedata
, section
),
5617 (unsigned long) section
->sh_size
);
5621 number
= section
->sh_size
/ section
->sh_entsize
;
5623 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5625 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5626 (unsigned long) section
->sh_size
,
5627 printable_section_name (filedata
, section
),
5628 (unsigned long) section
->sh_entsize
);
5632 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5633 section
->sh_size
, _("symbols"));
5638 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5640 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5645 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5649 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5650 entry
->hdr
->sh_offset
,
5651 1, entry
->hdr
->sh_size
,
5652 _("symbol table section indices"));
5656 /* PR17531: file: heap-buffer-overflow */
5657 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5659 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5660 printable_section_name (filedata
, entry
->hdr
),
5661 (unsigned long) entry
->hdr
->sh_size
,
5662 (unsigned long) section
->sh_size
);
5667 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5671 error (_("Out of memory reading %lu symbols\n"),
5672 (unsigned long) number
);
5676 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5678 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5679 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5680 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5681 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5683 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5685 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5686 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5687 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5689 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5690 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5697 if (num_syms_return
!= NULL
)
5698 * num_syms_return
= isyms
== NULL
? 0 : number
;
5704 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5706 static char buff
[1024];
5708 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5710 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5711 bfd_vma os_flags
= 0;
5712 bfd_vma proc_flags
= 0;
5713 bfd_vma unknown_flags
= 0;
5721 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5722 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5723 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5724 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5725 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5726 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5727 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5728 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5729 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5730 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5731 /* IA-64 specific. */
5732 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5733 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5734 /* IA-64 OpenVMS specific. */
5735 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5736 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5737 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5738 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5739 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5740 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5742 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5743 /* SPARC specific. */
5744 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5745 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5747 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5748 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5749 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5751 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5753 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5756 if (do_section_details
)
5758 sprintf (buff
, "[%*.*lx]: ",
5759 field_size
, field_size
, (unsigned long) sh_flags
);
5760 p
+= field_size
+ 4;
5767 flag
= sh_flags
& - sh_flags
;
5770 if (do_section_details
)
5774 case SHF_WRITE
: sindex
= 0; break;
5775 case SHF_ALLOC
: sindex
= 1; break;
5776 case SHF_EXECINSTR
: sindex
= 2; break;
5777 case SHF_MERGE
: sindex
= 3; break;
5778 case SHF_STRINGS
: sindex
= 4; break;
5779 case SHF_INFO_LINK
: sindex
= 5; break;
5780 case SHF_LINK_ORDER
: sindex
= 6; break;
5781 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5782 case SHF_GROUP
: sindex
= 8; break;
5783 case SHF_TLS
: sindex
= 9; break;
5784 case SHF_EXCLUDE
: sindex
= 18; break;
5785 case SHF_COMPRESSED
: sindex
= 20; break;
5786 case SHF_GNU_MBIND
: sindex
= 24; break;
5790 switch (filedata
->file_header
.e_machine
)
5793 if (flag
== SHF_IA_64_SHORT
)
5795 else if (flag
== SHF_IA_64_NORECOV
)
5798 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5801 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5802 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5803 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5804 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5805 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5806 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5817 case EM_OLD_SPARCV9
:
5818 case EM_SPARC32PLUS
:
5821 if (flag
== SHF_ORDERED
)
5828 case SHF_ENTRYSECT
: sindex
= 21; break;
5829 case SHF_ARM_PURECODE
: sindex
= 22; break;
5830 case SHF_COMDEF
: sindex
= 23; break;
5835 if (flag
== SHF_PPC_VLE
)
5846 if (p
!= buff
+ field_size
+ 4)
5848 if (size
< (10 + 2))
5850 warn (_("Internal error: not enough buffer room for section flag info"));
5851 return _("<unknown>");
5858 size
-= flags
[sindex
].len
;
5859 p
= stpcpy (p
, flags
[sindex
].str
);
5861 else if (flag
& SHF_MASKOS
)
5863 else if (flag
& SHF_MASKPROC
)
5866 unknown_flags
|= flag
;
5872 case SHF_WRITE
: *p
= 'W'; break;
5873 case SHF_ALLOC
: *p
= 'A'; break;
5874 case SHF_EXECINSTR
: *p
= 'X'; break;
5875 case SHF_MERGE
: *p
= 'M'; break;
5876 case SHF_STRINGS
: *p
= 'S'; break;
5877 case SHF_INFO_LINK
: *p
= 'I'; break;
5878 case SHF_LINK_ORDER
: *p
= 'L'; break;
5879 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5880 case SHF_GROUP
: *p
= 'G'; break;
5881 case SHF_TLS
: *p
= 'T'; break;
5882 case SHF_EXCLUDE
: *p
= 'E'; break;
5883 case SHF_COMPRESSED
: *p
= 'C'; break;
5884 case SHF_GNU_MBIND
: *p
= 'D'; break;
5887 if ((filedata
->file_header
.e_machine
== EM_X86_64
5888 || filedata
->file_header
.e_machine
== EM_L1OM
5889 || filedata
->file_header
.e_machine
== EM_K1OM
)
5890 && flag
== SHF_X86_64_LARGE
)
5892 else if (filedata
->file_header
.e_machine
== EM_ARM
5893 && flag
== SHF_ARM_PURECODE
)
5895 else if (filedata
->file_header
.e_machine
== EM_PPC
5896 && flag
== SHF_PPC_VLE
)
5898 else if (flag
& SHF_MASKOS
)
5901 sh_flags
&= ~ SHF_MASKOS
;
5903 else if (flag
& SHF_MASKPROC
)
5906 sh_flags
&= ~ SHF_MASKPROC
;
5916 if (do_section_details
)
5920 size
-= 5 + field_size
;
5921 if (p
!= buff
+ field_size
+ 4)
5925 warn (_("Internal error: not enough buffer room for section flag info"));
5926 return _("<unknown>");
5932 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5933 (unsigned long) os_flags
);
5934 p
+= 5 + field_size
;
5938 size
-= 7 + field_size
;
5939 if (p
!= buff
+ field_size
+ 4)
5943 warn (_("Internal error: not enough buffer room for section flag info"));
5944 return _("<unknown>");
5950 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5951 (unsigned long) proc_flags
);
5952 p
+= 7 + field_size
;
5956 size
-= 10 + field_size
;
5957 if (p
!= buff
+ field_size
+ 4)
5961 warn (_("Internal error: not enough buffer room for section flag info"));
5962 return _("<unknown>");
5968 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5969 (unsigned long) unknown_flags
);
5970 p
+= 10 + field_size
;
5979 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5983 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5985 if (size
< sizeof (* echdr
))
5987 error (_("Compressed section is too small even for a compression header\n"));
5991 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5992 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5993 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5994 return sizeof (*echdr
);
5998 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6000 if (size
< sizeof (* echdr
))
6002 error (_("Compressed section is too small even for a compression header\n"));
6006 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6007 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6008 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6009 return sizeof (*echdr
);
6014 process_section_headers (Filedata
* filedata
)
6016 Elf_Internal_Shdr
* section
;
6019 filedata
->section_headers
= NULL
;
6021 if (filedata
->file_header
.e_shnum
== 0)
6023 /* PR binutils/12467. */
6024 if (filedata
->file_header
.e_shoff
!= 0)
6026 warn (_("possibly corrupt ELF file header - it has a non-zero"
6027 " section header offset, but no section headers\n"));
6030 else if (do_sections
)
6031 printf (_("\nThere are no sections in this file.\n"));
6036 if (do_sections
&& !do_header
)
6037 printf (ngettext ("There is %d section header, "
6038 "starting at offset 0x%lx:\n",
6039 "There are %d section headers, "
6040 "starting at offset 0x%lx:\n",
6041 filedata
->file_header
.e_shnum
),
6042 filedata
->file_header
.e_shnum
,
6043 (unsigned long) filedata
->file_header
.e_shoff
);
6047 if (! get_32bit_section_headers (filedata
, FALSE
))
6052 if (! get_64bit_section_headers (filedata
, FALSE
))
6056 /* Read in the string table, so that we have names to display. */
6057 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6058 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6060 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6062 if (section
->sh_size
!= 0)
6064 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6065 1, section
->sh_size
,
6068 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6072 /* Scan the sections for the dynamic symbol table
6073 and dynamic string table and debug sections. */
6074 dynamic_symbols
= NULL
;
6075 dynamic_strings
= NULL
;
6076 dynamic_syminfo
= NULL
;
6077 symtab_shndx_list
= NULL
;
6079 eh_addr_size
= is_32bit_elf
? 4 : 8;
6080 switch (filedata
->file_header
.e_machine
)
6083 case EM_MIPS_RS3_LE
:
6084 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6085 FDE addresses. However, the ABI also has a semi-official ILP32
6086 variant for which the normal FDE address size rules apply.
6088 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6089 section, where XX is the size of longs in bits. Unfortunately,
6090 earlier compilers provided no way of distinguishing ILP32 objects
6091 from LP64 objects, so if there's any doubt, we should assume that
6092 the official LP64 form is being used. */
6093 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6094 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6100 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6102 case E_H8_MACH_H8300
:
6103 case E_H8_MACH_H8300HN
:
6104 case E_H8_MACH_H8300SN
:
6105 case E_H8_MACH_H8300SXN
:
6108 case E_H8_MACH_H8300H
:
6109 case E_H8_MACH_H8300S
:
6110 case E_H8_MACH_H8300SX
:
6118 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6120 case EF_M32C_CPU_M16C
:
6127 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6130 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6131 if (section->sh_entsize != expected_entsize) \
6134 sprintf_vma (buf, section->sh_entsize); \
6135 /* Note: coded this way so that there is a single string for \
6137 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6138 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6139 (unsigned) expected_entsize); \
6140 section->sh_entsize = expected_entsize; \
6145 #define CHECK_ENTSIZE(section, i, type) \
6146 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6147 sizeof (Elf64_External_##type))
6149 for (i
= 0, section
= filedata
->section_headers
;
6150 i
< filedata
->file_header
.e_shnum
;
6153 char * name
= SECTION_NAME (section
);
6155 if (section
->sh_type
== SHT_DYNSYM
)
6157 if (dynamic_symbols
!= NULL
)
6159 error (_("File contains multiple dynamic symbol tables\n"));
6163 CHECK_ENTSIZE (section
, i
, Sym
);
6164 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6166 else if (section
->sh_type
== SHT_STRTAB
6167 && streq (name
, ".dynstr"))
6169 if (dynamic_strings
!= NULL
)
6171 error (_("File contains multiple dynamic string tables\n"));
6175 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6176 1, section
->sh_size
,
6177 _("dynamic strings"));
6178 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6180 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6182 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6184 entry
->hdr
= section
;
6185 entry
->next
= symtab_shndx_list
;
6186 symtab_shndx_list
= entry
;
6188 else if (section
->sh_type
== SHT_SYMTAB
)
6189 CHECK_ENTSIZE (section
, i
, Sym
);
6190 else if (section
->sh_type
== SHT_GROUP
)
6191 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6192 else if (section
->sh_type
== SHT_REL
)
6193 CHECK_ENTSIZE (section
, i
, Rel
);
6194 else if (section
->sh_type
== SHT_RELA
)
6195 CHECK_ENTSIZE (section
, i
, Rela
);
6196 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6197 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6198 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6199 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6200 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6201 && (const_strneq (name
, ".debug_")
6202 || const_strneq (name
, ".zdebug_")))
6205 name
+= sizeof (".zdebug_") - 1;
6207 name
+= sizeof (".debug_") - 1;
6210 || (do_debug_info
&& const_strneq (name
, "info"))
6211 || (do_debug_info
&& const_strneq (name
, "types"))
6212 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6213 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6214 || (do_debug_lines
&& const_strneq (name
, "line."))
6215 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6216 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6217 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6218 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6219 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6220 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6221 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6222 || (do_debug_frames
&& const_strneq (name
, "frame"))
6223 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6224 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6225 || (do_debug_str
&& const_strneq (name
, "str"))
6226 || (do_debug_loc
&& const_strneq (name
, "loc"))
6227 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6228 || (do_debug_addr
&& const_strneq (name
, "addr"))
6229 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6230 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6232 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6234 /* Linkonce section to be combined with .debug_info at link time. */
6235 else if ((do_debugging
|| do_debug_info
)
6236 && const_strneq (name
, ".gnu.linkonce.wi."))
6237 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6238 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6239 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6240 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6241 || streq (name
, ".debug_names")))
6242 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6243 /* Trace sections for Itanium VMS. */
6244 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6245 || do_trace_aranges
)
6246 && const_strneq (name
, ".trace_"))
6248 name
+= sizeof (".trace_") - 1;
6251 || (do_trace_info
&& streq (name
, "info"))
6252 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6253 || (do_trace_aranges
&& streq (name
, "aranges"))
6255 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6257 else if ((do_debugging
|| do_debug_links
)
6258 && (const_strneq (name
, ".gnu_debuglink")
6259 || const_strneq (name
, ".gnu_debugaltlink")))
6260 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6266 if (filedata
->file_header
.e_shnum
> 1)
6267 printf (_("\nSection Headers:\n"));
6269 printf (_("\nSection Header:\n"));
6273 if (do_section_details
)
6275 printf (_(" [Nr] Name\n"));
6276 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6280 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6284 if (do_section_details
)
6286 printf (_(" [Nr] Name\n"));
6287 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6291 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6295 if (do_section_details
)
6297 printf (_(" [Nr] Name\n"));
6298 printf (_(" Type Address Offset Link\n"));
6299 printf (_(" Size EntSize Info Align\n"));
6303 printf (_(" [Nr] Name Type Address Offset\n"));
6304 printf (_(" Size EntSize Flags Link Info Align\n"));
6308 if (do_section_details
)
6309 printf (_(" Flags\n"));
6311 for (i
= 0, section
= filedata
->section_headers
;
6312 i
< filedata
->file_header
.e_shnum
;
6315 /* Run some sanity checks on the section header. */
6317 /* Check the sh_link field. */
6318 switch (section
->sh_type
)
6322 if (section
->sh_link
== 0
6323 && (filedata
->file_header
.e_type
== ET_EXEC
6324 || filedata
->file_header
.e_type
== ET_DYN
))
6325 /* A dynamic relocation section where all entries use a
6326 zero symbol index need not specify a symtab section. */
6329 case SHT_SYMTAB_SHNDX
:
6333 case SHT_GNU_versym
:
6334 if (section
->sh_link
== 0
6335 || section
->sh_link
>= filedata
->file_header
.e_shnum
6336 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6337 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6338 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6339 i
, section
->sh_link
);
6345 case SHT_GNU_verneed
:
6346 case SHT_GNU_verdef
:
6347 case SHT_GNU_LIBLIST
:
6348 if (section
->sh_link
== 0
6349 || section
->sh_link
>= filedata
->file_header
.e_shnum
6350 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6351 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6352 i
, section
->sh_link
);
6355 case SHT_INIT_ARRAY
:
6356 case SHT_FINI_ARRAY
:
6357 case SHT_PREINIT_ARRAY
:
6358 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6359 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6360 i
, section
->sh_link
);
6364 /* FIXME: Add support for target specific section types. */
6365 #if 0 /* Currently we do not check other section types as there are too
6366 many special cases. Stab sections for example have a type
6367 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6369 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6370 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6371 i
, section
->sh_link
);
6376 /* Check the sh_info field. */
6377 switch (section
->sh_type
)
6381 if (section
->sh_info
== 0
6382 && (filedata
->file_header
.e_type
== ET_EXEC
6383 || filedata
->file_header
.e_type
== ET_DYN
))
6384 /* Dynamic relocations apply to segments, so they do not
6385 need to specify the section they relocate. */
6387 if (section
->sh_info
== 0
6388 || section
->sh_info
>= filedata
->file_header
.e_shnum
6389 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6390 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6391 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6392 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6393 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6394 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6395 /* FIXME: Are other section types valid ? */
6396 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6397 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6398 i
, section
->sh_info
);
6403 case SHT_SYMTAB_SHNDX
:
6404 case SHT_INIT_ARRAY
:
6405 case SHT_FINI_ARRAY
:
6406 case SHT_PREINIT_ARRAY
:
6407 if (section
->sh_info
!= 0)
6408 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6409 i
, section
->sh_info
);
6415 /* A symbol index - we assume that it is valid. */
6419 /* FIXME: Add support for target specific section types. */
6420 if (section
->sh_type
== SHT_NOBITS
)
6421 /* NOBITS section headers with non-zero sh_info fields can be
6422 created when a binary is stripped of everything but its debug
6423 information. The stripped sections have their headers
6424 preserved but their types set to SHT_NOBITS. So do not check
6425 this type of section. */
6427 else if (section
->sh_flags
& SHF_INFO_LINK
)
6429 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6430 warn (_("[%2u]: Expected link to another section in info field"), i
);
6432 else if (section
->sh_type
< SHT_LOOS
6433 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6434 && section
->sh_info
!= 0)
6435 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6436 i
, section
->sh_info
);
6440 /* Check the sh_size field. */
6441 if (section
->sh_size
> filedata
->file_size
6442 && section
->sh_type
!= SHT_NOBITS
6443 && section
->sh_type
!= SHT_NULL
6444 && section
->sh_type
< SHT_LOOS
)
6445 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6447 printf (" [%2u] ", i
);
6448 if (do_section_details
)
6449 printf ("%s\n ", printable_section_name (filedata
, section
));
6451 print_symbol (-17, SECTION_NAME (section
));
6453 printf (do_wide
? " %-15s " : " %-15.15s ",
6454 get_section_type_name (filedata
, section
->sh_type
));
6458 const char * link_too_big
= NULL
;
6460 print_vma (section
->sh_addr
, LONG_HEX
);
6462 printf ( " %6.6lx %6.6lx %2.2lx",
6463 (unsigned long) section
->sh_offset
,
6464 (unsigned long) section
->sh_size
,
6465 (unsigned long) section
->sh_entsize
);
6467 if (do_section_details
)
6468 fputs (" ", stdout
);
6470 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6472 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6475 /* The sh_link value is out of range. Normally this indicates
6476 an error but it can have special values in Solaris binaries. */
6477 switch (filedata
->file_header
.e_machine
)
6484 case EM_OLD_SPARCV9
:
6485 case EM_SPARC32PLUS
:
6488 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6489 link_too_big
= "BEFORE";
6490 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6491 link_too_big
= "AFTER";
6498 if (do_section_details
)
6500 if (link_too_big
!= NULL
&& * link_too_big
)
6501 printf ("<%s> ", link_too_big
);
6503 printf ("%2u ", section
->sh_link
);
6504 printf ("%3u %2lu\n", section
->sh_info
,
6505 (unsigned long) section
->sh_addralign
);
6508 printf ("%2u %3u %2lu\n",
6511 (unsigned long) section
->sh_addralign
);
6513 if (link_too_big
&& ! * link_too_big
)
6514 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6515 i
, section
->sh_link
);
6519 print_vma (section
->sh_addr
, LONG_HEX
);
6521 if ((long) section
->sh_offset
== section
->sh_offset
)
6522 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6526 print_vma (section
->sh_offset
, LONG_HEX
);
6529 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6530 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6534 print_vma (section
->sh_size
, LONG_HEX
);
6537 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6538 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6542 print_vma (section
->sh_entsize
, LONG_HEX
);
6545 if (do_section_details
)
6546 fputs (" ", stdout
);
6548 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6550 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6552 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6553 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6556 print_vma (section
->sh_addralign
, DEC
);
6560 else if (do_section_details
)
6563 print_vma (section
->sh_addr
, LONG_HEX
);
6564 if ((long) section
->sh_offset
== section
->sh_offset
)
6565 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6569 print_vma (section
->sh_offset
, LONG_HEX
);
6571 printf (" %u\n ", section
->sh_link
);
6572 print_vma (section
->sh_size
, LONG_HEX
);
6574 print_vma (section
->sh_entsize
, LONG_HEX
);
6576 printf (" %-16u %lu\n",
6578 (unsigned long) section
->sh_addralign
);
6583 print_vma (section
->sh_addr
, LONG_HEX
);
6584 if ((long) section
->sh_offset
== section
->sh_offset
)
6585 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6589 print_vma (section
->sh_offset
, LONG_HEX
);
6592 print_vma (section
->sh_size
, LONG_HEX
);
6594 print_vma (section
->sh_entsize
, LONG_HEX
);
6596 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6598 printf (" %2u %3u %lu\n",
6601 (unsigned long) section
->sh_addralign
);
6604 if (do_section_details
)
6606 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6607 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6609 /* Minimum section size is 12 bytes for 32-bit compression
6610 header + 12 bytes for compressed data header. */
6611 unsigned char buf
[24];
6613 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6614 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6615 sizeof (buf
), _("compression header")))
6617 Elf_Internal_Chdr chdr
;
6619 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6621 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6624 printf (_(" [<unknown>: 0x%x], "),
6626 print_vma (chdr
.ch_size
, LONG_HEX
);
6627 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6633 if (!do_section_details
)
6635 /* The ordering of the letters shown here matches the ordering of the
6636 corresponding SHF_xxx values, and hence the order in which these
6637 letters will be displayed to the user. */
6638 printf (_("Key to Flags:\n\
6639 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6640 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6641 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6642 if (filedata
->file_header
.e_machine
== EM_X86_64
6643 || filedata
->file_header
.e_machine
== EM_L1OM
6644 || filedata
->file_header
.e_machine
== EM_K1OM
)
6645 printf (_("l (large), "));
6646 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6647 printf (_("y (purecode), "));
6648 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6649 printf (_("v (VLE), "));
6650 printf ("p (processor specific)\n");
6657 get_group_flags (unsigned int flags
)
6659 static char buff
[128];
6663 else if (flags
== GRP_COMDAT
)
6666 snprintf (buff
, 14, _("[0x%x: "), flags
);
6668 flags
&= ~ GRP_COMDAT
;
6669 if (flags
& GRP_MASKOS
)
6671 strcat (buff
, "<OS specific>");
6672 flags
&= ~ GRP_MASKOS
;
6675 if (flags
& GRP_MASKPROC
)
6677 strcat (buff
, "<PROC specific>");
6678 flags
&= ~ GRP_MASKPROC
;
6682 strcat (buff
, "<unknown>");
6689 process_section_groups (Filedata
* filedata
)
6691 Elf_Internal_Shdr
* section
;
6693 struct group
* group
;
6694 Elf_Internal_Shdr
* symtab_sec
;
6695 Elf_Internal_Shdr
* strtab_sec
;
6696 Elf_Internal_Sym
* symtab
;
6697 unsigned long num_syms
;
6701 /* Don't process section groups unless needed. */
6702 if (!do_unwind
&& !do_section_groups
)
6705 if (filedata
->file_header
.e_shnum
== 0)
6707 if (do_section_groups
)
6708 printf (_("\nThere are no sections to group in this file.\n"));
6713 if (filedata
->section_headers
== NULL
)
6715 error (_("Section headers are not available!\n"));
6716 /* PR 13622: This can happen with a corrupt ELF header. */
6720 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6721 sizeof (struct group
*));
6723 if (section_headers_groups
== NULL
)
6725 error (_("Out of memory reading %u section group headers\n"),
6726 filedata
->file_header
.e_shnum
);
6730 /* Scan the sections for the group section. */
6732 for (i
= 0, section
= filedata
->section_headers
;
6733 i
< filedata
->file_header
.e_shnum
;
6735 if (section
->sh_type
== SHT_GROUP
)
6738 if (group_count
== 0)
6740 if (do_section_groups
)
6741 printf (_("\nThere are no section groups in this file.\n"));
6746 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6748 if (section_groups
== NULL
)
6750 error (_("Out of memory reading %lu groups\n"),
6751 (unsigned long) group_count
);
6761 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6762 i
< filedata
->file_header
.e_shnum
;
6765 if (section
->sh_type
== SHT_GROUP
)
6767 const char * name
= printable_section_name (filedata
, section
);
6768 const char * group_name
;
6769 unsigned char * start
;
6770 unsigned char * indices
;
6771 unsigned int entry
, j
, size
;
6772 Elf_Internal_Shdr
* sec
;
6773 Elf_Internal_Sym
* sym
;
6775 /* Get the symbol table. */
6776 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6777 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6780 error (_("Bad sh_link in group section `%s'\n"), name
);
6784 if (symtab_sec
!= sec
)
6789 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6794 error (_("Corrupt header in group section `%s'\n"), name
);
6798 if (section
->sh_info
>= num_syms
)
6800 error (_("Bad sh_info in group section `%s'\n"), name
);
6804 sym
= symtab
+ section
->sh_info
;
6806 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6808 if (sym
->st_shndx
== 0
6809 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6811 error (_("Bad sh_info in group section `%s'\n"), name
);
6815 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6824 /* Get the string table. */
6825 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6834 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6840 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6841 1, strtab_sec
->sh_size
,
6843 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6845 group_name
= sym
->st_name
< strtab_size
6846 ? strtab
+ sym
->st_name
: _("<corrupt>");
6849 /* PR 17531: file: loop. */
6850 if (section
->sh_entsize
> section
->sh_size
)
6852 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6853 printable_section_name (filedata
, section
),
6854 (unsigned long) section
->sh_entsize
,
6855 (unsigned long) section
->sh_size
);
6859 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6860 1, section
->sh_size
,
6866 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6867 entry
= byte_get (indices
, 4);
6870 if (do_section_groups
)
6872 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6873 get_group_flags (entry
), i
, name
, group_name
, size
);
6875 printf (_(" [Index] Name\n"));
6878 group
->group_index
= i
;
6880 for (j
= 0; j
< size
; j
++)
6882 struct group_list
* g
;
6884 entry
= byte_get (indices
, 4);
6887 if (entry
>= filedata
->file_header
.e_shnum
)
6889 static unsigned num_group_errors
= 0;
6891 if (num_group_errors
++ < 10)
6893 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6894 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6895 if (num_group_errors
== 10)
6896 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6901 if (section_headers_groups
[entry
] != NULL
)
6905 static unsigned num_errs
= 0;
6907 if (num_errs
++ < 10)
6909 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6911 section_headers_groups
[entry
]->group_index
);
6913 warn (_("Further error messages about already contained group sections suppressed\n"));
6919 /* Intel C/C++ compiler may put section 0 in a
6920 section group. We just warn it the first time
6921 and ignore it afterwards. */
6922 static bfd_boolean warned
= FALSE
;
6925 error (_("section 0 in group section [%5u]\n"),
6926 section_headers_groups
[entry
]->group_index
);
6932 section_headers_groups
[entry
] = group
;
6934 if (do_section_groups
)
6936 sec
= filedata
->section_headers
+ entry
;
6937 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6940 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6941 g
->section_index
= entry
;
6942 g
->next
= group
->root
;
6960 /* Data used to display dynamic fixups. */
6962 struct ia64_vms_dynfixup
6964 bfd_vma needed_ident
; /* Library ident number. */
6965 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6966 bfd_vma fixup_needed
; /* Index of the library. */
6967 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6968 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6971 /* Data used to display dynamic relocations. */
6973 struct ia64_vms_dynimgrela
6975 bfd_vma img_rela_cnt
; /* Number of relocations. */
6976 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6979 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6983 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6984 struct ia64_vms_dynfixup
* fixup
,
6985 const char * strtab
,
6986 unsigned int strtab_sz
)
6988 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6990 const char * lib_name
;
6992 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6993 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6994 _("dynamic section image fixups"));
6998 if (fixup
->needed
< strtab_sz
)
6999 lib_name
= strtab
+ fixup
->needed
;
7002 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7003 (unsigned long) fixup
->needed
);
7006 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7007 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7009 (_("Seg Offset Type SymVec DataType\n"));
7011 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7016 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7017 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7018 type
= BYTE_GET (imfs
[i
].type
);
7019 rtype
= elf_ia64_reloc_type (type
);
7021 printf (" 0x%08x ", type
);
7023 printf (" %-32s ", rtype
);
7024 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7025 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7032 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7035 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7037 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7040 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7041 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7042 _("dynamic section image relocations"));
7046 printf (_("\nImage relocs\n"));
7048 (_("Seg Offset Type Addend Seg Sym Off\n"));
7050 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7055 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7056 printf ("%08" BFD_VMA_FMT
"x ",
7057 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7058 type
= BYTE_GET (imrs
[i
].type
);
7059 rtype
= elf_ia64_reloc_type (type
);
7061 printf ("0x%08x ", type
);
7063 printf ("%-31s ", rtype
);
7064 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7065 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7066 printf ("%08" BFD_VMA_FMT
"x\n",
7067 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7074 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7077 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7079 struct ia64_vms_dynfixup fixup
;
7080 struct ia64_vms_dynimgrela imgrela
;
7081 Elf_Internal_Dyn
*entry
;
7082 bfd_vma strtab_off
= 0;
7083 bfd_vma strtab_sz
= 0;
7084 char *strtab
= NULL
;
7085 bfd_boolean res
= TRUE
;
7087 memset (&fixup
, 0, sizeof (fixup
));
7088 memset (&imgrela
, 0, sizeof (imgrela
));
7090 /* Note: the order of the entries is specified by the OpenVMS specs. */
7091 for (entry
= dynamic_section
;
7092 entry
< dynamic_section
+ dynamic_nent
;
7095 switch (entry
->d_tag
)
7097 case DT_IA_64_VMS_STRTAB_OFFSET
:
7098 strtab_off
= entry
->d_un
.d_val
;
7101 strtab_sz
= entry
->d_un
.d_val
;
7103 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7104 1, strtab_sz
, _("dynamic string section"));
7107 case DT_IA_64_VMS_NEEDED_IDENT
:
7108 fixup
.needed_ident
= entry
->d_un
.d_val
;
7111 fixup
.needed
= entry
->d_un
.d_val
;
7113 case DT_IA_64_VMS_FIXUP_NEEDED
:
7114 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7116 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7117 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7119 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7120 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7121 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7124 case DT_IA_64_VMS_IMG_RELA_CNT
:
7125 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7127 case DT_IA_64_VMS_IMG_RELA_OFF
:
7128 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7129 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7151 dynamic_relocations
[] =
7153 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7154 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7155 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7158 /* Process the reloc section. */
7161 process_relocs (Filedata
* filedata
)
7163 unsigned long rel_size
;
7164 unsigned long rel_offset
;
7169 if (do_using_dynamic
)
7173 bfd_boolean has_dynamic_reloc
;
7176 has_dynamic_reloc
= FALSE
;
7178 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7180 is_rela
= dynamic_relocations
[i
].rela
;
7181 name
= dynamic_relocations
[i
].name
;
7182 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7183 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7186 has_dynamic_reloc
= TRUE
;
7188 if (is_rela
== UNKNOWN
)
7190 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7191 switch (dynamic_info
[DT_PLTREL
])
7205 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7206 name
, rel_offset
, rel_size
);
7208 dump_relocations (filedata
,
7209 offset_from_vma (filedata
, rel_offset
, rel_size
),
7211 dynamic_symbols
, num_dynamic_syms
,
7212 dynamic_strings
, dynamic_strings_length
,
7213 is_rela
, TRUE
/* is_dynamic */);
7217 if (is_ia64_vms (filedata
))
7218 if (process_ia64_vms_dynamic_relocs (filedata
))
7219 has_dynamic_reloc
= TRUE
;
7221 if (! has_dynamic_reloc
)
7222 printf (_("\nThere are no dynamic relocations in this file.\n"));
7226 Elf_Internal_Shdr
* section
;
7228 bfd_boolean found
= FALSE
;
7230 for (i
= 0, section
= filedata
->section_headers
;
7231 i
< filedata
->file_header
.e_shnum
;
7234 if ( section
->sh_type
!= SHT_RELA
7235 && section
->sh_type
!= SHT_REL
)
7238 rel_offset
= section
->sh_offset
;
7239 rel_size
= section
->sh_size
;
7243 Elf_Internal_Shdr
* strsec
;
7245 unsigned long num_rela
;
7247 printf (_("\nRelocation section "));
7249 if (filedata
->string_table
== NULL
)
7250 printf ("%d", section
->sh_name
);
7252 printf ("'%s'", printable_section_name (filedata
, section
));
7254 num_rela
= rel_size
/ section
->sh_entsize
;
7255 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7256 " at offset 0x%lx contains %lu entries:\n",
7258 rel_offset
, num_rela
);
7260 is_rela
= section
->sh_type
== SHT_RELA
;
7262 if (section
->sh_link
!= 0
7263 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7265 Elf_Internal_Shdr
* symsec
;
7266 Elf_Internal_Sym
* symtab
;
7267 unsigned long nsyms
;
7268 unsigned long strtablen
= 0;
7269 char * strtab
= NULL
;
7271 symsec
= filedata
->section_headers
+ section
->sh_link
;
7272 if (symsec
->sh_type
!= SHT_SYMTAB
7273 && symsec
->sh_type
!= SHT_DYNSYM
)
7276 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7281 if (symsec
->sh_link
!= 0
7282 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7284 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7286 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7289 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7292 dump_relocations (filedata
, rel_offset
, rel_size
,
7293 symtab
, nsyms
, strtab
, strtablen
,
7295 symsec
->sh_type
== SHT_DYNSYM
);
7301 dump_relocations (filedata
, rel_offset
, rel_size
,
7302 NULL
, 0, NULL
, 0, is_rela
,
7303 FALSE
/* is_dynamic */);
7311 /* Users sometimes forget the -D option, so try to be helpful. */
7312 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7314 if (dynamic_info
[dynamic_relocations
[i
].size
])
7316 printf (_("\nThere are no static relocations in this file."));
7317 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7322 if (i
== ARRAY_SIZE (dynamic_relocations
))
7323 printf (_("\nThere are no relocations in this file.\n"));
7330 /* An absolute address consists of a section and an offset. If the
7331 section is NULL, the offset itself is the address, otherwise, the
7332 address equals to LOAD_ADDRESS(section) + offset. */
7336 unsigned short section
;
7340 #define ABSADDR(a) \
7342 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7345 /* Find the nearest symbol at or below ADDR. Returns the symbol
7346 name, if found, and the offset from the symbol to ADDR. */
7349 find_symbol_for_address (Filedata
* filedata
,
7350 Elf_Internal_Sym
* symtab
,
7351 unsigned long nsyms
,
7352 const char * strtab
,
7353 unsigned long strtab_size
,
7354 struct absaddr addr
,
7355 const char ** symname
,
7358 bfd_vma dist
= 0x100000;
7359 Elf_Internal_Sym
* sym
;
7360 Elf_Internal_Sym
* beg
;
7361 Elf_Internal_Sym
* end
;
7362 Elf_Internal_Sym
* best
= NULL
;
7364 REMOVE_ARCH_BITS (addr
.offset
);
7366 end
= symtab
+ nsyms
;
7372 sym
= beg
+ (end
- beg
) / 2;
7374 value
= sym
->st_value
;
7375 REMOVE_ARCH_BITS (value
);
7377 if (sym
->st_name
!= 0
7378 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7379 && addr
.offset
>= value
7380 && addr
.offset
- value
< dist
)
7383 dist
= addr
.offset
- value
;
7388 if (addr
.offset
< value
)
7396 *symname
= (best
->st_name
>= strtab_size
7397 ? _("<corrupt>") : strtab
+ best
->st_name
);
7403 *offset
= addr
.offset
;
7406 static /* signed */ int
7407 symcmp (const void *p
, const void *q
)
7409 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7410 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7412 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7415 /* Process the unwind section. */
7417 #include "unwind-ia64.h"
7419 struct ia64_unw_table_entry
7421 struct absaddr start
;
7423 struct absaddr info
;
7426 struct ia64_unw_aux_info
7428 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7429 unsigned long table_len
; /* Length of unwind table. */
7430 unsigned char * info
; /* Unwind info. */
7431 unsigned long info_size
; /* Size of unwind info. */
7432 bfd_vma info_addr
; /* Starting address of unwind info. */
7433 bfd_vma seg_base
; /* Starting address of segment. */
7434 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7435 unsigned long nsyms
; /* Number of symbols. */
7436 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7437 unsigned long nfuns
; /* Number of entries in funtab. */
7438 char * strtab
; /* The string table. */
7439 unsigned long strtab_size
; /* Size of string table. */
7443 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7445 struct ia64_unw_table_entry
* tp
;
7446 unsigned long j
, nfuns
;
7448 bfd_boolean res
= TRUE
;
7450 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7451 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7452 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7453 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7455 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7457 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7461 const unsigned char * dp
;
7462 const unsigned char * head
;
7463 const unsigned char * end
;
7464 const char * procname
;
7466 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7467 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7469 fputs ("\n<", stdout
);
7473 fputs (procname
, stdout
);
7476 printf ("+%lx", (unsigned long) offset
);
7479 fputs (">: [", stdout
);
7480 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7481 fputc ('-', stdout
);
7482 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7483 printf ("], info at +0x%lx\n",
7484 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7486 /* PR 17531: file: 86232b32. */
7487 if (aux
->info
== NULL
)
7490 /* PR 17531: file: 0997b4d1. */
7491 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7493 warn (_("Invalid offset %lx in table entry %ld\n"),
7494 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7499 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7500 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7502 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7503 (unsigned) UNW_VER (stamp
),
7504 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7505 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7506 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7507 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7509 if (UNW_VER (stamp
) != 1)
7511 printf (_("\tUnknown version.\n"));
7516 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7517 /* PR 17531: file: 16ceda89. */
7518 if (end
> aux
->info
+ aux
->info_size
)
7519 end
= aux
->info
+ aux
->info_size
;
7520 for (dp
= head
+ 8; dp
< end
;)
7521 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7530 slurp_ia64_unwind_table (Filedata
* filedata
,
7531 struct ia64_unw_aux_info
* aux
,
7532 Elf_Internal_Shdr
* sec
)
7534 unsigned long size
, nrelas
, i
;
7535 Elf_Internal_Phdr
* seg
;
7536 struct ia64_unw_table_entry
* tep
;
7537 Elf_Internal_Shdr
* relsec
;
7538 Elf_Internal_Rela
* rela
;
7539 Elf_Internal_Rela
* rp
;
7540 unsigned char * table
;
7542 Elf_Internal_Sym
* sym
;
7543 const char * relname
;
7547 /* First, find the starting address of the segment that includes
7550 if (filedata
->file_header
.e_phnum
)
7552 if (! get_program_headers (filedata
))
7555 for (seg
= filedata
->program_headers
;
7556 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7559 if (seg
->p_type
!= PT_LOAD
)
7562 if (sec
->sh_addr
>= seg
->p_vaddr
7563 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7565 aux
->seg_base
= seg
->p_vaddr
;
7571 /* Second, build the unwind table from the contents of the unwind section: */
7572 size
= sec
->sh_size
;
7573 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7578 aux
->table_len
= size
/ (3 * eh_addr_size
);
7579 aux
->table
= (struct ia64_unw_table_entry
*)
7580 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7583 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7585 tep
->start
.section
= SHN_UNDEF
;
7586 tep
->end
.section
= SHN_UNDEF
;
7587 tep
->info
.section
= SHN_UNDEF
;
7588 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7589 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7590 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7591 tep
->start
.offset
+= aux
->seg_base
;
7592 tep
->end
.offset
+= aux
->seg_base
;
7593 tep
->info
.offset
+= aux
->seg_base
;
7597 /* Third, apply any relocations to the unwind table: */
7598 for (relsec
= filedata
->section_headers
;
7599 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7602 if (relsec
->sh_type
!= SHT_RELA
7603 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7604 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7607 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7616 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7618 unsigned int sym_ndx
;
7619 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7620 relname
= elf_ia64_reloc_type (r_type
);
7622 /* PR 17531: file: 9fa67536. */
7623 if (relname
== NULL
)
7625 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7629 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7631 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7635 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7637 /* PR 17531: file: 5bc8d9bf. */
7638 if (i
>= aux
->table_len
)
7640 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7644 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7645 if (sym_ndx
>= aux
->nsyms
)
7647 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7651 sym
= aux
->symtab
+ sym_ndx
;
7653 switch (rp
->r_offset
/ eh_addr_size
% 3)
7656 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7657 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7660 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7661 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7664 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7665 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7679 ia64_process_unwind (Filedata
* filedata
)
7681 Elf_Internal_Shdr
* sec
;
7682 Elf_Internal_Shdr
* unwsec
= NULL
;
7683 Elf_Internal_Shdr
* strsec
;
7684 unsigned long i
, unwcount
= 0, unwstart
= 0;
7685 struct ia64_unw_aux_info aux
;
7686 bfd_boolean res
= TRUE
;
7688 memset (& aux
, 0, sizeof (aux
));
7690 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7692 if (sec
->sh_type
== SHT_SYMTAB
7693 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7695 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7697 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7698 if (aux
.strtab
!= NULL
)
7700 error (_("Multiple auxillary string tables encountered\n"));
7704 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7707 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7709 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7714 printf (_("\nThere are no unwind sections in this file.\n"));
7716 while (unwcount
-- > 0)
7721 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7722 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7723 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7728 /* We have already counted the number of SHT_IA64_UNWIND
7729 sections so the loop above should never fail. */
7730 assert (unwsec
!= NULL
);
7733 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7735 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7737 /* We need to find which section group it is in. */
7738 struct group_list
* g
;
7740 if (section_headers_groups
== NULL
7741 || section_headers_groups
[i
] == NULL
)
7742 i
= filedata
->file_header
.e_shnum
;
7745 g
= section_headers_groups
[i
]->root
;
7747 for (; g
!= NULL
; g
= g
->next
)
7749 sec
= filedata
->section_headers
+ g
->section_index
;
7751 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7756 i
= filedata
->file_header
.e_shnum
;
7759 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7761 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7762 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7763 suffix
= SECTION_NAME (unwsec
) + len
;
7764 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7766 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7767 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7772 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7773 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7774 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7775 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7777 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7778 suffix
= SECTION_NAME (unwsec
) + len
;
7779 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7781 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7782 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7786 if (i
== filedata
->file_header
.e_shnum
)
7788 printf (_("\nCould not find unwind info section for "));
7790 if (filedata
->string_table
== NULL
)
7791 printf ("%d", unwsec
->sh_name
);
7793 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7797 aux
.info_addr
= sec
->sh_addr
;
7798 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7801 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7803 printf (_("\nUnwind section "));
7805 if (filedata
->string_table
== NULL
)
7806 printf ("%d", unwsec
->sh_name
);
7808 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7810 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7811 (unsigned long) unwsec
->sh_offset
,
7812 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7814 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7815 && aux
.table_len
> 0)
7816 dump_ia64_unwind (filedata
, & aux
);
7819 free ((char *) aux
.table
);
7821 free ((char *) aux
.info
);
7830 free ((char *) aux
.strtab
);
7835 struct hppa_unw_table_entry
7837 struct absaddr start
;
7839 unsigned int Cannot_unwind
:1; /* 0 */
7840 unsigned int Millicode
:1; /* 1 */
7841 unsigned int Millicode_save_sr0
:1; /* 2 */
7842 unsigned int Region_description
:2; /* 3..4 */
7843 unsigned int reserved1
:1; /* 5 */
7844 unsigned int Entry_SR
:1; /* 6 */
7845 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7846 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7847 unsigned int Args_stored
:1; /* 16 */
7848 unsigned int Variable_Frame
:1; /* 17 */
7849 unsigned int Separate_Package_Body
:1; /* 18 */
7850 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7851 unsigned int Stack_Overflow_Check
:1; /* 20 */
7852 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7853 unsigned int Ada_Region
:1; /* 22 */
7854 unsigned int cxx_info
:1; /* 23 */
7855 unsigned int cxx_try_catch
:1; /* 24 */
7856 unsigned int sched_entry_seq
:1; /* 25 */
7857 unsigned int reserved2
:1; /* 26 */
7858 unsigned int Save_SP
:1; /* 27 */
7859 unsigned int Save_RP
:1; /* 28 */
7860 unsigned int Save_MRP_in_frame
:1; /* 29 */
7861 unsigned int extn_ptr_defined
:1; /* 30 */
7862 unsigned int Cleanup_defined
:1; /* 31 */
7864 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7865 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7866 unsigned int Large_frame
:1; /* 2 */
7867 unsigned int Pseudo_SP_Set
:1; /* 3 */
7868 unsigned int reserved4
:1; /* 4 */
7869 unsigned int Total_frame_size
:27; /* 5..31 */
7872 struct hppa_unw_aux_info
7874 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7875 unsigned long table_len
; /* Length of unwind table. */
7876 bfd_vma seg_base
; /* Starting address of segment. */
7877 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7878 unsigned long nsyms
; /* Number of symbols. */
7879 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7880 unsigned long nfuns
; /* Number of entries in funtab. */
7881 char * strtab
; /* The string table. */
7882 unsigned long strtab_size
; /* Size of string table. */
7886 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7888 struct hppa_unw_table_entry
* tp
;
7889 unsigned long j
, nfuns
;
7890 bfd_boolean res
= TRUE
;
7892 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7893 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7894 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7895 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7897 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7899 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7902 const char * procname
;
7904 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7905 aux
->strtab_size
, tp
->start
, &procname
,
7908 fputs ("\n<", stdout
);
7912 fputs (procname
, stdout
);
7915 printf ("+%lx", (unsigned long) offset
);
7918 fputs (">: [", stdout
);
7919 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7920 fputc ('-', stdout
);
7921 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7924 #define PF(_m) if (tp->_m) printf (#_m " ");
7925 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7928 PF(Millicode_save_sr0
);
7929 /* PV(Region_description); */
7935 PF(Separate_Package_Body
);
7936 PF(Frame_Extension_Millicode
);
7937 PF(Stack_Overflow_Check
);
7938 PF(Two_Instruction_SP_Increment
);
7942 PF(sched_entry_seq
);
7945 PF(Save_MRP_in_frame
);
7946 PF(extn_ptr_defined
);
7947 PF(Cleanup_defined
);
7948 PF(MPE_XL_interrupt_marker
);
7949 PF(HP_UX_interrupt_marker
);
7952 PV(Total_frame_size
);
7965 slurp_hppa_unwind_table (Filedata
* filedata
,
7966 struct hppa_unw_aux_info
* aux
,
7967 Elf_Internal_Shdr
* sec
)
7969 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7970 Elf_Internal_Phdr
* seg
;
7971 struct hppa_unw_table_entry
* tep
;
7972 Elf_Internal_Shdr
* relsec
;
7973 Elf_Internal_Rela
* rela
;
7974 Elf_Internal_Rela
* rp
;
7975 unsigned char * table
;
7977 Elf_Internal_Sym
* sym
;
7978 const char * relname
;
7980 /* First, find the starting address of the segment that includes
7982 if (filedata
->file_header
.e_phnum
)
7984 if (! get_program_headers (filedata
))
7987 for (seg
= filedata
->program_headers
;
7988 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7991 if (seg
->p_type
!= PT_LOAD
)
7994 if (sec
->sh_addr
>= seg
->p_vaddr
7995 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7997 aux
->seg_base
= seg
->p_vaddr
;
8003 /* Second, build the unwind table from the contents of the unwind
8005 size
= sec
->sh_size
;
8006 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8012 nentries
= size
/ unw_ent_size
;
8013 size
= unw_ent_size
* nentries
;
8015 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8016 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8018 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8020 unsigned int tmp1
, tmp2
;
8022 tep
->start
.section
= SHN_UNDEF
;
8023 tep
->end
.section
= SHN_UNDEF
;
8025 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8026 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8027 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8028 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8030 tep
->start
.offset
+= aux
->seg_base
;
8031 tep
->end
.offset
+= aux
->seg_base
;
8033 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8034 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8035 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8036 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8037 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8038 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8039 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8040 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8041 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8042 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8043 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8044 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8045 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8046 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8047 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8048 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8049 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8050 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8051 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8052 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8053 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8054 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8055 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8056 tep
->Cleanup_defined
= tmp1
& 0x1;
8058 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8059 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8060 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8061 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8062 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8063 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8067 /* Third, apply any relocations to the unwind table. */
8068 for (relsec
= filedata
->section_headers
;
8069 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8072 if (relsec
->sh_type
!= SHT_RELA
8073 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8074 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8077 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8081 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8083 unsigned int sym_ndx
;
8084 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8085 relname
= elf_hppa_reloc_type (r_type
);
8087 if (relname
== NULL
)
8089 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8093 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8094 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8096 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8100 i
= rp
->r_offset
/ unw_ent_size
;
8101 if (i
>= aux
->table_len
)
8103 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8107 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8108 if (sym_ndx
>= aux
->nsyms
)
8110 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8114 sym
= aux
->symtab
+ sym_ndx
;
8116 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8119 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8120 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8123 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8124 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8134 aux
->table_len
= nentries
;
8140 hppa_process_unwind (Filedata
* filedata
)
8142 struct hppa_unw_aux_info aux
;
8143 Elf_Internal_Shdr
* unwsec
= NULL
;
8144 Elf_Internal_Shdr
* strsec
;
8145 Elf_Internal_Shdr
* sec
;
8147 bfd_boolean res
= TRUE
;
8149 if (filedata
->string_table
== NULL
)
8152 memset (& aux
, 0, sizeof (aux
));
8154 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8156 if (sec
->sh_type
== SHT_SYMTAB
8157 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8159 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8161 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8162 if (aux
.strtab
!= NULL
)
8164 error (_("Multiple auxillary string tables encountered\n"));
8168 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8171 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8173 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8178 printf (_("\nThere are no unwind sections in this file.\n"));
8180 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8182 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8184 unsigned long num_unwind
= sec
->sh_size
/ 16;
8186 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8187 "contains %lu entry:\n",
8188 "\nUnwind section '%s' at offset 0x%lx "
8189 "contains %lu entries:\n",
8191 printable_section_name (filedata
, sec
),
8192 (unsigned long) sec
->sh_offset
,
8195 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8198 if (res
&& aux
.table_len
> 0)
8200 if (! dump_hppa_unwind (filedata
, &aux
))
8205 free ((char *) aux
.table
);
8213 free ((char *) aux
.strtab
);
8220 unsigned char * data
; /* The unwind data. */
8221 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8222 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8223 unsigned long nrelas
; /* The number of relocations. */
8224 unsigned int rel_type
; /* REL or RELA ? */
8225 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8228 struct arm_unw_aux_info
8230 Filedata
* filedata
; /* The file containing the unwind sections. */
8231 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8232 unsigned long nsyms
; /* Number of symbols. */
8233 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8234 unsigned long nfuns
; /* Number of these symbols. */
8235 char * strtab
; /* The file's string table. */
8236 unsigned long strtab_size
; /* Size of string table. */
8240 arm_print_vma_and_name (Filedata
* filedata
,
8241 struct arm_unw_aux_info
* aux
,
8243 struct absaddr addr
)
8245 const char *procname
;
8248 if (addr
.section
== SHN_UNDEF
)
8251 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8252 aux
->strtab_size
, addr
, &procname
,
8255 print_vma (fn
, PREFIX_HEX
);
8259 fputs (" <", stdout
);
8260 fputs (procname
, stdout
);
8263 printf ("+0x%lx", (unsigned long) sym_offset
);
8264 fputc ('>', stdout
);
8271 arm_free_section (struct arm_section
*arm_sec
)
8273 if (arm_sec
->data
!= NULL
)
8274 free (arm_sec
->data
);
8276 if (arm_sec
->rela
!= NULL
)
8277 free (arm_sec
->rela
);
8280 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8281 cached section and install SEC instead.
8282 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8283 and return its valued in * WORDP, relocating if necessary.
8284 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8285 relocation's offset in ADDR.
8286 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8287 into the string table of the symbol associated with the reloc. If no
8288 reloc was applied store -1 there.
8289 5) Return TRUE upon success, FALSE otherwise. */
8292 get_unwind_section_word (Filedata
* filedata
,
8293 struct arm_unw_aux_info
* aux
,
8294 struct arm_section
* arm_sec
,
8295 Elf_Internal_Shdr
* sec
,
8296 bfd_vma word_offset
,
8297 unsigned int * wordp
,
8298 struct absaddr
* addr
,
8301 Elf_Internal_Rela
*rp
;
8302 Elf_Internal_Sym
*sym
;
8303 const char * relname
;
8305 bfd_boolean wrapped
;
8307 if (sec
== NULL
|| arm_sec
== NULL
)
8310 addr
->section
= SHN_UNDEF
;
8313 if (sym_name
!= NULL
)
8314 *sym_name
= (bfd_vma
) -1;
8316 /* If necessary, update the section cache. */
8317 if (sec
!= arm_sec
->sec
)
8319 Elf_Internal_Shdr
*relsec
;
8321 arm_free_section (arm_sec
);
8324 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8325 sec
->sh_size
, _("unwind data"));
8326 arm_sec
->rela
= NULL
;
8327 arm_sec
->nrelas
= 0;
8329 for (relsec
= filedata
->section_headers
;
8330 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8333 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8334 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8335 /* PR 15745: Check the section type as well. */
8336 || (relsec
->sh_type
!= SHT_REL
8337 && relsec
->sh_type
!= SHT_RELA
))
8340 arm_sec
->rel_type
= relsec
->sh_type
;
8341 if (relsec
->sh_type
== SHT_REL
)
8343 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8345 & arm_sec
->rela
, & arm_sec
->nrelas
))
8348 else /* relsec->sh_type == SHT_RELA */
8350 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8352 & arm_sec
->rela
, & arm_sec
->nrelas
))
8358 arm_sec
->next_rela
= arm_sec
->rela
;
8361 /* If there is no unwind data we can do nothing. */
8362 if (arm_sec
->data
== NULL
)
8365 /* If the offset is invalid then fail. */
8366 if (/* PR 21343 *//* PR 18879 */
8368 || word_offset
> (sec
->sh_size
- 4)
8369 || ((bfd_signed_vma
) word_offset
) < 0)
8372 /* Get the word at the required offset. */
8373 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8375 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8376 if (arm_sec
->rela
== NULL
)
8382 /* Look through the relocs to find the one that applies to the provided offset. */
8384 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8386 bfd_vma prelval
, offset
;
8388 if (rp
->r_offset
> word_offset
&& !wrapped
)
8393 if (rp
->r_offset
> word_offset
)
8396 if (rp
->r_offset
& 3)
8398 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8399 (unsigned long) rp
->r_offset
);
8403 if (rp
->r_offset
< word_offset
)
8406 /* PR 17531: file: 027-161405-0.004 */
8407 if (aux
->symtab
== NULL
)
8410 if (arm_sec
->rel_type
== SHT_REL
)
8412 offset
= word
& 0x7fffffff;
8413 if (offset
& 0x40000000)
8414 offset
|= ~ (bfd_vma
) 0x7fffffff;
8416 else if (arm_sec
->rel_type
== SHT_RELA
)
8417 offset
= rp
->r_addend
;
8420 error (_("Unknown section relocation type %d encountered\n"),
8425 /* PR 17531 file: 027-1241568-0.004. */
8426 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8428 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8429 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8433 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8434 offset
+= sym
->st_value
;
8435 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8437 /* Check that we are processing the expected reloc type. */
8438 if (filedata
->file_header
.e_machine
== EM_ARM
)
8440 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8441 if (relname
== NULL
)
8443 warn (_("Skipping unknown ARM relocation type: %d\n"),
8444 (int) ELF32_R_TYPE (rp
->r_info
));
8448 if (streq (relname
, "R_ARM_NONE"))
8451 if (! streq (relname
, "R_ARM_PREL31"))
8453 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8457 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8459 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8460 if (relname
== NULL
)
8462 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8463 (int) ELF32_R_TYPE (rp
->r_info
));
8467 if (streq (relname
, "R_C6000_NONE"))
8470 if (! streq (relname
, "R_C6000_PREL31"))
8472 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8480 /* This function currently only supports ARM and TI unwinders. */
8481 warn (_("Only TI and ARM unwinders are currently supported\n"));
8485 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8486 addr
->section
= sym
->st_shndx
;
8487 addr
->offset
= offset
;
8490 * sym_name
= sym
->st_name
;
8495 arm_sec
->next_rela
= rp
;
8500 static const char *tic6x_unwind_regnames
[16] =
8502 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8503 "A14", "A13", "A12", "A11", "A10",
8504 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8508 decode_tic6x_unwind_regmask (unsigned int mask
)
8512 for (i
= 12; mask
; mask
>>= 1, i
--)
8516 fputs (tic6x_unwind_regnames
[i
], stdout
);
8518 fputs (", ", stdout
);
8524 if (remaining == 0 && more_words) \
8527 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8528 data_offset, & word, & addr, NULL)) \
8534 #define GET_OP(OP) \
8539 (OP) = word >> 24; \
8544 printf (_("[Truncated opcode]\n")); \
8547 printf ("0x%02x ", OP)
8550 decode_arm_unwind_bytecode (Filedata
* filedata
,
8551 struct arm_unw_aux_info
* aux
,
8553 unsigned int remaining
,
8554 unsigned int more_words
,
8555 bfd_vma data_offset
,
8556 Elf_Internal_Shdr
* data_sec
,
8557 struct arm_section
* data_arm_sec
)
8559 struct absaddr addr
;
8560 bfd_boolean res
= TRUE
;
8562 /* Decode the unwinding instructions. */
8565 unsigned int op
, op2
;
8574 printf (" 0x%02x ", op
);
8576 if ((op
& 0xc0) == 0x00)
8578 int offset
= ((op
& 0x3f) << 2) + 4;
8580 printf (" vsp = vsp + %d", offset
);
8582 else if ((op
& 0xc0) == 0x40)
8584 int offset
= ((op
& 0x3f) << 2) + 4;
8586 printf (" vsp = vsp - %d", offset
);
8588 else if ((op
& 0xf0) == 0x80)
8591 if (op
== 0x80 && op2
== 0)
8592 printf (_("Refuse to unwind"));
8595 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8596 bfd_boolean first
= TRUE
;
8600 for (i
= 0; i
< 12; i
++)
8601 if (mask
& (1 << i
))
8607 printf ("r%d", 4 + i
);
8612 else if ((op
& 0xf0) == 0x90)
8614 if (op
== 0x9d || op
== 0x9f)
8615 printf (_(" [Reserved]"));
8617 printf (" vsp = r%d", op
& 0x0f);
8619 else if ((op
& 0xf0) == 0xa0)
8621 int end
= 4 + (op
& 0x07);
8622 bfd_boolean first
= TRUE
;
8626 for (i
= 4; i
<= end
; i
++)
8642 else if (op
== 0xb0)
8643 printf (_(" finish"));
8644 else if (op
== 0xb1)
8647 if (op2
== 0 || (op2
& 0xf0) != 0)
8648 printf (_("[Spare]"));
8651 unsigned int mask
= op2
& 0x0f;
8652 bfd_boolean first
= TRUE
;
8656 for (i
= 0; i
< 12; i
++)
8657 if (mask
& (1 << i
))
8668 else if (op
== 0xb2)
8670 unsigned char buf
[9];
8671 unsigned int i
, len
;
8672 unsigned long offset
;
8674 for (i
= 0; i
< sizeof (buf
); i
++)
8677 if ((buf
[i
] & 0x80) == 0)
8680 if (i
== sizeof (buf
))
8682 error (_("corrupt change to vsp"));
8687 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8688 assert (len
== i
+ 1);
8689 offset
= offset
* 4 + 0x204;
8690 printf ("vsp = vsp + %ld", offset
);
8693 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8695 unsigned int first
, last
;
8702 printf ("pop {D%d", first
);
8704 printf ("-D%d", first
+ last
);
8707 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8709 unsigned int count
= op
& 0x07;
8713 printf ("-D%d", 8 + count
);
8716 else if (op
>= 0xc0 && op
<= 0xc5)
8718 unsigned int count
= op
& 0x07;
8720 printf (" pop {wR10");
8722 printf ("-wR%d", 10 + count
);
8725 else if (op
== 0xc6)
8727 unsigned int first
, last
;
8732 printf ("pop {wR%d", first
);
8734 printf ("-wR%d", first
+ last
);
8737 else if (op
== 0xc7)
8740 if (op2
== 0 || (op2
& 0xf0) != 0)
8741 printf (_("[Spare]"));
8744 unsigned int mask
= op2
& 0x0f;
8745 bfd_boolean first
= TRUE
;
8749 for (i
= 0; i
< 4; i
++)
8750 if (mask
& (1 << i
))
8756 printf ("wCGR%d", i
);
8763 printf (_(" [unsupported opcode]"));
8774 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8775 struct arm_unw_aux_info
* aux
,
8777 unsigned int remaining
,
8778 unsigned int more_words
,
8779 bfd_vma data_offset
,
8780 Elf_Internal_Shdr
* data_sec
,
8781 struct arm_section
* data_arm_sec
)
8783 struct absaddr addr
;
8785 /* Decode the unwinding instructions. */
8788 unsigned int op
, op2
;
8797 printf (" 0x%02x ", op
);
8799 if ((op
& 0xc0) == 0x00)
8801 int offset
= ((op
& 0x3f) << 3) + 8;
8802 printf (" sp = sp + %d", offset
);
8804 else if ((op
& 0xc0) == 0x80)
8807 if (op
== 0x80 && op2
== 0)
8808 printf (_("Refuse to unwind"));
8811 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8813 printf ("pop compact {");
8817 decode_tic6x_unwind_regmask (mask
);
8821 else if ((op
& 0xf0) == 0xc0)
8829 unsigned int offset
;
8833 /* Scan entire instruction first so that GET_OP output is not
8834 interleaved with disassembly. */
8836 for (i
= 0; nregs
< (op
& 0xf); i
++)
8842 regpos
[nregs
].offset
= i
* 2;
8843 regpos
[nregs
].reg
= reg
;
8850 regpos
[nregs
].offset
= i
* 2 + 1;
8851 regpos
[nregs
].reg
= reg
;
8856 printf (_("pop frame {"));
8859 printf (_("*corrupt* - no registers specified"));
8864 for (i
= i
* 2; i
> 0; i
--)
8866 if (regpos
[reg
].offset
== i
- 1)
8868 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8875 fputs (name
, stdout
);
8883 else if (op
== 0xd0)
8884 printf (" MOV FP, SP");
8885 else if (op
== 0xd1)
8886 printf (" __c6xabi_pop_rts");
8887 else if (op
== 0xd2)
8889 unsigned char buf
[9];
8890 unsigned int i
, len
;
8891 unsigned long offset
;
8893 for (i
= 0; i
< sizeof (buf
); i
++)
8896 if ((buf
[i
] & 0x80) == 0)
8899 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8900 if (i
== sizeof (buf
))
8902 warn (_("Corrupt stack pointer adjustment detected\n"));
8906 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8907 assert (len
== i
+ 1);
8908 offset
= offset
* 8 + 0x408;
8909 printf (_("sp = sp + %ld"), offset
);
8911 else if ((op
& 0xf0) == 0xe0)
8913 if ((op
& 0x0f) == 7)
8916 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8920 printf (_(" [unsupported opcode]"));
8929 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8933 offset
= word
& 0x7fffffff;
8934 if (offset
& 0x40000000)
8935 offset
|= ~ (bfd_vma
) 0x7fffffff;
8937 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8940 return offset
+ where
;
8944 decode_arm_unwind (Filedata
* filedata
,
8945 struct arm_unw_aux_info
* aux
,
8947 unsigned int remaining
,
8948 bfd_vma data_offset
,
8949 Elf_Internal_Shdr
* data_sec
,
8950 struct arm_section
* data_arm_sec
)
8953 unsigned int more_words
= 0;
8954 struct absaddr addr
;
8955 bfd_vma sym_name
= (bfd_vma
) -1;
8956 bfd_boolean res
= TRUE
;
8960 /* Fetch the first word.
8961 Note - when decoding an object file the address extracted
8962 here will always be 0. So we also pass in the sym_name
8963 parameter so that we can find the symbol associated with
8964 the personality routine. */
8965 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8966 & word
, & addr
, & sym_name
))
8972 if ((word
& 0x80000000) == 0)
8974 /* Expand prel31 for personality routine. */
8976 const char *procname
;
8978 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8979 printf (_(" Personality routine: "));
8981 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8982 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8984 procname
= aux
->strtab
+ sym_name
;
8985 print_vma (fn
, PREFIX_HEX
);
8988 fputs (" <", stdout
);
8989 fputs (procname
, stdout
);
8990 fputc ('>', stdout
);
8994 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8995 fputc ('\n', stdout
);
8997 /* The GCC personality routines use the standard compact
8998 encoding, starting with one byte giving the number of
9000 if (procname
!= NULL
9001 && (const_strneq (procname
, "__gcc_personality_v0")
9002 || const_strneq (procname
, "__gxx_personality_v0")
9003 || const_strneq (procname
, "__gcj_personality_v0")
9004 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9011 printf (_(" [Truncated data]\n"));
9014 more_words
= word
>> 24;
9024 /* ARM EHABI Section 6.3:
9026 An exception-handling table entry for the compact model looks like:
9030 1 0 index Data for personalityRoutine[index] */
9032 if (filedata
->file_header
.e_machine
== EM_ARM
9033 && (word
& 0x70000000))
9035 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9039 per_index
= (word
>> 24) & 0x7f;
9040 printf (_(" Compact model index: %d\n"), per_index
);
9047 else if (per_index
< 3)
9049 more_words
= (word
>> 16) & 0xff;
9055 switch (filedata
->file_header
.e_machine
)
9060 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9061 data_offset
, data_sec
, data_arm_sec
))
9066 warn (_("Unknown ARM compact model index encountered\n"));
9067 printf (_(" [reserved]\n"));
9075 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9076 data_offset
, data_sec
, data_arm_sec
))
9079 else if (per_index
< 5)
9081 if (((word
>> 17) & 0x7f) == 0x7f)
9082 printf (_(" Restore stack from frame pointer\n"));
9084 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9085 printf (_(" Registers restored: "));
9087 printf (" (compact) ");
9088 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9090 printf (_(" Return register: %s\n"),
9091 tic6x_unwind_regnames
[word
& 0xf]);
9094 printf (_(" [reserved (%d)]\n"), per_index
);
9098 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9099 filedata
->file_header
.e_machine
);
9103 /* Decode the descriptors. Not implemented. */
9109 dump_arm_unwind (Filedata
* filedata
,
9110 struct arm_unw_aux_info
* aux
,
9111 Elf_Internal_Shdr
* exidx_sec
)
9113 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9114 unsigned int i
, exidx_len
;
9115 unsigned long j
, nfuns
;
9116 bfd_boolean res
= TRUE
;
9118 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9119 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9120 exidx_len
= exidx_sec
->sh_size
/ 8;
9122 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9123 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9124 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9125 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9127 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9129 for (i
= 0; i
< exidx_len
; i
++)
9131 unsigned int exidx_fn
, exidx_entry
;
9132 struct absaddr fn_addr
, entry_addr
;
9135 fputc ('\n', stdout
);
9137 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9138 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9139 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9140 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9143 arm_free_section (& exidx_arm_sec
);
9144 arm_free_section (& extab_arm_sec
);
9148 /* ARM EHABI, Section 5:
9149 An index table entry consists of 2 words.
9150 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9151 if (exidx_fn
& 0x80000000)
9153 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9157 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9159 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9160 fputs (": ", stdout
);
9162 if (exidx_entry
== 1)
9164 print_vma (exidx_entry
, PREFIX_HEX
);
9165 fputs (" [cantunwind]\n", stdout
);
9167 else if (exidx_entry
& 0x80000000)
9169 print_vma (exidx_entry
, PREFIX_HEX
);
9170 fputc ('\n', stdout
);
9171 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9175 bfd_vma table
, table_offset
= 0;
9176 Elf_Internal_Shdr
*table_sec
;
9178 fputs ("@", stdout
);
9179 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9180 print_vma (table
, PREFIX_HEX
);
9183 /* Locate the matching .ARM.extab. */
9184 if (entry_addr
.section
!= SHN_UNDEF
9185 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9187 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9188 table_offset
= entry_addr
.offset
;
9190 if (table_offset
> table_sec
->sh_size
9191 || ((bfd_signed_vma
) table_offset
) < 0)
9193 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9194 (unsigned long) table_offset
,
9195 printable_section_name (filedata
, table_sec
));
9202 table_sec
= find_section_by_address (filedata
, table
);
9203 if (table_sec
!= NULL
)
9204 table_offset
= table
- table_sec
->sh_addr
;
9207 if (table_sec
== NULL
)
9209 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9210 (unsigned long) table
);
9215 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9224 arm_free_section (&exidx_arm_sec
);
9225 arm_free_section (&extab_arm_sec
);
9230 /* Used for both ARM and C6X unwinding tables. */
9233 arm_process_unwind (Filedata
* filedata
)
9235 struct arm_unw_aux_info aux
;
9236 Elf_Internal_Shdr
*unwsec
= NULL
;
9237 Elf_Internal_Shdr
*strsec
;
9238 Elf_Internal_Shdr
*sec
;
9240 unsigned int sec_type
;
9241 bfd_boolean res
= TRUE
;
9243 switch (filedata
->file_header
.e_machine
)
9246 sec_type
= SHT_ARM_EXIDX
;
9250 sec_type
= SHT_C6000_UNWIND
;
9254 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9255 filedata
->file_header
.e_machine
);
9259 if (filedata
->string_table
== NULL
)
9262 memset (& aux
, 0, sizeof (aux
));
9263 aux
.filedata
= filedata
;
9265 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9267 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9269 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9271 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9273 /* PR binutils/17531 file: 011-12666-0.004. */
9274 if (aux
.strtab
!= NULL
)
9276 error (_("Multiple string tables found in file.\n"));
9280 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9281 1, strsec
->sh_size
, _("string table"));
9282 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9284 else if (sec
->sh_type
== sec_type
)
9289 printf (_("\nThere are no unwind sections in this file.\n"));
9291 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9293 if (sec
->sh_type
== sec_type
)
9295 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9296 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9297 "contains %lu entry:\n",
9298 "\nUnwind section '%s' at offset 0x%lx "
9299 "contains %lu entries:\n",
9301 printable_section_name (filedata
, sec
),
9302 (unsigned long) sec
->sh_offset
,
9305 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9313 free ((char *) aux
.strtab
);
9319 process_unwind (Filedata
* filedata
)
9321 struct unwind_handler
9323 unsigned int machtype
;
9324 bfd_boolean (* handler
)(Filedata
*);
9327 { EM_ARM
, arm_process_unwind
},
9328 { EM_IA_64
, ia64_process_unwind
},
9329 { EM_PARISC
, hppa_process_unwind
},
9330 { EM_TI_C6000
, arm_process_unwind
},
9338 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9339 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9340 return handlers
[i
].handler (filedata
);
9342 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9343 get_machine_name (filedata
->file_header
.e_machine
));
9348 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9350 switch (entry
->d_tag
)
9353 if (entry
->d_un
.d_val
== 0)
9357 static const char * opts
[] =
9359 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9360 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9361 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9362 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9366 bfd_boolean first
= TRUE
;
9368 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9369 if (entry
->d_un
.d_val
& (1 << cnt
))
9371 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9377 case DT_MIPS_IVERSION
:
9378 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9379 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9383 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9384 /* Note: coded this way so that there is a single string for translation. */
9385 printf (_("<corrupt: %s>"), buf
);
9389 case DT_MIPS_TIME_STAMP
:
9393 time_t atime
= entry
->d_un
.d_val
;
9395 tmp
= gmtime (&atime
);
9396 /* PR 17531: file: 6accc532. */
9398 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9400 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9401 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9402 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9403 printf (_("Time Stamp: %s"), timebuf
);
9407 case DT_MIPS_RLD_VERSION
:
9408 case DT_MIPS_LOCAL_GOTNO
:
9409 case DT_MIPS_CONFLICTNO
:
9410 case DT_MIPS_LIBLISTNO
:
9411 case DT_MIPS_SYMTABNO
:
9412 case DT_MIPS_UNREFEXTNO
:
9413 case DT_MIPS_HIPAGENO
:
9414 case DT_MIPS_DELTA_CLASS_NO
:
9415 case DT_MIPS_DELTA_INSTANCE_NO
:
9416 case DT_MIPS_DELTA_RELOC_NO
:
9417 case DT_MIPS_DELTA_SYM_NO
:
9418 case DT_MIPS_DELTA_CLASSSYM_NO
:
9419 case DT_MIPS_COMPACT_SIZE
:
9420 print_vma (entry
->d_un
.d_val
, DEC
);
9424 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9430 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9432 switch (entry
->d_tag
)
9434 case DT_HP_DLD_FLAGS
:
9443 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9444 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9445 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9446 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9447 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9448 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9449 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9450 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9451 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9452 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9453 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9454 { DT_HP_GST
, "HP_GST" },
9455 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9456 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9457 { DT_HP_NODELETE
, "HP_NODELETE" },
9458 { DT_HP_GROUP
, "HP_GROUP" },
9459 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9461 bfd_boolean first
= TRUE
;
9463 bfd_vma val
= entry
->d_un
.d_val
;
9465 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9466 if (val
& flags
[cnt
].bit
)
9470 fputs (flags
[cnt
].str
, stdout
);
9472 val
^= flags
[cnt
].bit
;
9475 if (val
!= 0 || first
)
9479 print_vma (val
, HEX
);
9485 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9493 /* VMS vs Unix time offset and factor. */
9495 #define VMS_EPOCH_OFFSET 35067168000000000LL
9496 #define VMS_GRANULARITY_FACTOR 10000000
9498 /* Display a VMS time in a human readable format. */
9501 print_vms_time (bfd_int64_t vmstime
)
9506 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9507 tm
= gmtime (&unxtime
);
9508 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9509 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9510 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9515 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9517 switch (entry
->d_tag
)
9519 case DT_IA_64_PLT_RESERVE
:
9520 /* First 3 slots reserved. */
9521 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9523 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9526 case DT_IA_64_VMS_LINKTIME
:
9528 print_vms_time (entry
->d_un
.d_val
);
9532 case DT_IA_64_VMS_LNKFLAGS
:
9533 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9534 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9535 printf (" CALL_DEBUG");
9536 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9537 printf (" NOP0BUFS");
9538 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9539 printf (" P0IMAGE");
9540 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9541 printf (" MKTHREADS");
9542 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9543 printf (" UPCALLS");
9544 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9546 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9547 printf (" INITIALIZE");
9548 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9550 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9551 printf (" EXE_INIT");
9552 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9553 printf (" TBK_IN_IMG");
9554 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9555 printf (" DBG_IN_IMG");
9556 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9557 printf (" TBK_IN_DSF");
9558 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9559 printf (" DBG_IN_DSF");
9560 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9561 printf (" SIGNATURES");
9562 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9563 printf (" REL_SEG_OFF");
9567 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9574 get_32bit_dynamic_section (Filedata
* filedata
)
9576 Elf32_External_Dyn
* edyn
;
9577 Elf32_External_Dyn
* ext
;
9578 Elf_Internal_Dyn
* entry
;
9580 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9581 dynamic_size
, _("dynamic section"));
9585 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9586 might not have the luxury of section headers. Look for the DT_NULL
9587 terminator to determine the number of entries. */
9588 for (ext
= edyn
, dynamic_nent
= 0;
9589 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9593 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9597 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9599 if (dynamic_section
== NULL
)
9601 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9602 (unsigned long) dynamic_nent
);
9607 for (ext
= edyn
, entry
= dynamic_section
;
9608 entry
< dynamic_section
+ dynamic_nent
;
9611 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9612 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9621 get_64bit_dynamic_section (Filedata
* filedata
)
9623 Elf64_External_Dyn
* edyn
;
9624 Elf64_External_Dyn
* ext
;
9625 Elf_Internal_Dyn
* entry
;
9627 /* Read in the data. */
9628 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9629 dynamic_size
, _("dynamic section"));
9633 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9634 might not have the luxury of section headers. Look for the DT_NULL
9635 terminator to determine the number of entries. */
9636 for (ext
= edyn
, dynamic_nent
= 0;
9637 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9638 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9642 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9646 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9648 if (dynamic_section
== NULL
)
9650 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9651 (unsigned long) dynamic_nent
);
9656 /* Convert from external to internal formats. */
9657 for (ext
= edyn
, entry
= dynamic_section
;
9658 entry
< dynamic_section
+ dynamic_nent
;
9661 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9662 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9671 print_dynamic_flags (bfd_vma flags
)
9673 bfd_boolean first
= TRUE
;
9679 flag
= flags
& - flags
;
9689 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9690 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9691 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9692 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9693 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9694 default: fputs (_("unknown"), stdout
); break;
9700 /* Parse and display the contents of the dynamic section. */
9703 process_dynamic_section (Filedata
* filedata
)
9705 Elf_Internal_Dyn
* entry
;
9707 if (dynamic_size
== 0)
9710 printf (_("\nThere is no dynamic section in this file.\n"));
9717 if (! get_32bit_dynamic_section (filedata
))
9722 if (! get_64bit_dynamic_section (filedata
))
9726 /* Find the appropriate symbol table. */
9727 if (dynamic_symbols
== NULL
)
9729 for (entry
= dynamic_section
;
9730 entry
< dynamic_section
+ dynamic_nent
;
9733 Elf_Internal_Shdr section
;
9735 if (entry
->d_tag
!= DT_SYMTAB
)
9738 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9740 /* Since we do not know how big the symbol table is,
9741 we default to reading in the entire file (!) and
9742 processing that. This is overkill, I know, but it
9744 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9745 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9747 /* See PR 21379 for a reproducer. */
9748 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9752 if (archive_file_offset
!= 0)
9753 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9755 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9758 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9760 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9761 section
.sh_name
= filedata
->string_table_length
;
9763 if (dynamic_symbols
!= NULL
)
9765 error (_("Multiple dynamic symbol table sections found\n"));
9766 free (dynamic_symbols
);
9768 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9769 if (num_dynamic_syms
< 1)
9771 error (_("Unable to determine the number of symbols to load\n"));
9777 /* Similarly find a string table. */
9778 if (dynamic_strings
== NULL
)
9780 for (entry
= dynamic_section
;
9781 entry
< dynamic_section
+ dynamic_nent
;
9784 unsigned long offset
;
9787 if (entry
->d_tag
!= DT_STRTAB
)
9790 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9792 /* Since we do not know how big the string table is,
9793 we default to reading in the entire file (!) and
9794 processing that. This is overkill, I know, but it
9797 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9799 if (archive_file_offset
!= 0)
9800 str_tab_len
= archive_file_size
- offset
;
9802 str_tab_len
= filedata
->file_size
- offset
;
9804 if (str_tab_len
< 1)
9807 (_("Unable to determine the length of the dynamic string table\n"));
9811 if (dynamic_strings
!= NULL
)
9813 error (_("Multiple dynamic string tables found\n"));
9814 free (dynamic_strings
);
9817 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9819 _("dynamic string table"));
9820 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9824 /* And find the syminfo section if available. */
9825 if (dynamic_syminfo
== NULL
)
9827 unsigned long syminsz
= 0;
9829 for (entry
= dynamic_section
;
9830 entry
< dynamic_section
+ dynamic_nent
;
9833 if (entry
->d_tag
== DT_SYMINENT
)
9835 /* Note: these braces are necessary to avoid a syntax
9836 error from the SunOS4 C compiler. */
9837 /* PR binutils/17531: A corrupt file can trigger this test.
9838 So do not use an assert, instead generate an error message. */
9839 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9840 error (_("Bad value (%d) for SYMINENT entry\n"),
9841 (int) entry
->d_un
.d_val
);
9843 else if (entry
->d_tag
== DT_SYMINSZ
)
9844 syminsz
= entry
->d_un
.d_val
;
9845 else if (entry
->d_tag
== DT_SYMINFO
)
9846 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9850 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9852 Elf_External_Syminfo
* extsyminfo
;
9853 Elf_External_Syminfo
* extsym
;
9854 Elf_Internal_Syminfo
* syminfo
;
9856 /* There is a syminfo section. Read the data. */
9857 extsyminfo
= (Elf_External_Syminfo
*)
9858 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9859 _("symbol information"));
9863 if (dynamic_syminfo
!= NULL
)
9865 error (_("Multiple dynamic symbol information sections found\n"));
9866 free (dynamic_syminfo
);
9868 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9869 if (dynamic_syminfo
== NULL
)
9871 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9872 (unsigned long) syminsz
);
9876 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9877 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9878 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9879 ++syminfo
, ++extsym
)
9881 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9882 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9889 if (do_dynamic
&& dynamic_addr
)
9890 printf (ngettext ("\nDynamic section at offset 0x%lx "
9891 "contains %lu entry:\n",
9892 "\nDynamic section at offset 0x%lx "
9893 "contains %lu entries:\n",
9895 dynamic_addr
, (unsigned long) dynamic_nent
);
9897 printf (_(" Tag Type Name/Value\n"));
9899 for (entry
= dynamic_section
;
9900 entry
< dynamic_section
+ dynamic_nent
;
9908 print_vma (entry
->d_tag
, FULL_HEX
);
9909 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9910 printf (" (%s)%*s", dtype
,
9911 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9914 switch (entry
->d_tag
)
9918 print_dynamic_flags (entry
->d_un
.d_val
);
9928 switch (entry
->d_tag
)
9931 printf (_("Auxiliary library"));
9935 printf (_("Filter library"));
9939 printf (_("Configuration file"));
9943 printf (_("Dependency audit library"));
9947 printf (_("Audit library"));
9951 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9952 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9956 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9965 printf (_("Flags:"));
9967 if (entry
->d_un
.d_val
== 0)
9968 printf (_(" None\n"));
9971 unsigned long int val
= entry
->d_un
.d_val
;
9973 if (val
& DTF_1_PARINIT
)
9975 printf (" PARINIT");
9976 val
^= DTF_1_PARINIT
;
9978 if (val
& DTF_1_CONFEXP
)
9980 printf (" CONFEXP");
9981 val
^= DTF_1_CONFEXP
;
9984 printf (" %lx", val
);
9993 printf (_("Flags:"));
9995 if (entry
->d_un
.d_val
== 0)
9996 printf (_(" None\n"));
9999 unsigned long int val
= entry
->d_un
.d_val
;
10001 if (val
& DF_P1_LAZYLOAD
)
10003 printf (" LAZYLOAD");
10004 val
^= DF_P1_LAZYLOAD
;
10006 if (val
& DF_P1_GROUPPERM
)
10008 printf (" GROUPPERM");
10009 val
^= DF_P1_GROUPPERM
;
10012 printf (" %lx", val
);
10021 printf (_("Flags:"));
10022 if (entry
->d_un
.d_val
== 0)
10023 printf (_(" None\n"));
10026 unsigned long int val
= entry
->d_un
.d_val
;
10028 if (val
& DF_1_NOW
)
10033 if (val
& DF_1_GLOBAL
)
10035 printf (" GLOBAL");
10036 val
^= DF_1_GLOBAL
;
10038 if (val
& DF_1_GROUP
)
10043 if (val
& DF_1_NODELETE
)
10045 printf (" NODELETE");
10046 val
^= DF_1_NODELETE
;
10048 if (val
& DF_1_LOADFLTR
)
10050 printf (" LOADFLTR");
10051 val
^= DF_1_LOADFLTR
;
10053 if (val
& DF_1_INITFIRST
)
10055 printf (" INITFIRST");
10056 val
^= DF_1_INITFIRST
;
10058 if (val
& DF_1_NOOPEN
)
10060 printf (" NOOPEN");
10061 val
^= DF_1_NOOPEN
;
10063 if (val
& DF_1_ORIGIN
)
10065 printf (" ORIGIN");
10066 val
^= DF_1_ORIGIN
;
10068 if (val
& DF_1_DIRECT
)
10070 printf (" DIRECT");
10071 val
^= DF_1_DIRECT
;
10073 if (val
& DF_1_TRANS
)
10078 if (val
& DF_1_INTERPOSE
)
10080 printf (" INTERPOSE");
10081 val
^= DF_1_INTERPOSE
;
10083 if (val
& DF_1_NODEFLIB
)
10085 printf (" NODEFLIB");
10086 val
^= DF_1_NODEFLIB
;
10088 if (val
& DF_1_NODUMP
)
10090 printf (" NODUMP");
10091 val
^= DF_1_NODUMP
;
10093 if (val
& DF_1_CONFALT
)
10095 printf (" CONFALT");
10096 val
^= DF_1_CONFALT
;
10098 if (val
& DF_1_ENDFILTEE
)
10100 printf (" ENDFILTEE");
10101 val
^= DF_1_ENDFILTEE
;
10103 if (val
& DF_1_DISPRELDNE
)
10105 printf (" DISPRELDNE");
10106 val
^= DF_1_DISPRELDNE
;
10108 if (val
& DF_1_DISPRELPND
)
10110 printf (" DISPRELPND");
10111 val
^= DF_1_DISPRELPND
;
10113 if (val
& DF_1_NODIRECT
)
10115 printf (" NODIRECT");
10116 val
^= DF_1_NODIRECT
;
10118 if (val
& DF_1_IGNMULDEF
)
10120 printf (" IGNMULDEF");
10121 val
^= DF_1_IGNMULDEF
;
10123 if (val
& DF_1_NOKSYMS
)
10125 printf (" NOKSYMS");
10126 val
^= DF_1_NOKSYMS
;
10128 if (val
& DF_1_NOHDR
)
10133 if (val
& DF_1_EDITED
)
10135 printf (" EDITED");
10136 val
^= DF_1_EDITED
;
10138 if (val
& DF_1_NORELOC
)
10140 printf (" NORELOC");
10141 val
^= DF_1_NORELOC
;
10143 if (val
& DF_1_SYMINTPOSE
)
10145 printf (" SYMINTPOSE");
10146 val
^= DF_1_SYMINTPOSE
;
10148 if (val
& DF_1_GLOBAUDIT
)
10150 printf (" GLOBAUDIT");
10151 val
^= DF_1_GLOBAUDIT
;
10153 if (val
& DF_1_SINGLETON
)
10155 printf (" SINGLETON");
10156 val
^= DF_1_SINGLETON
;
10158 if (val
& DF_1_STUB
)
10163 if (val
& DF_1_PIE
)
10168 if (val
& DF_1_KMOD
)
10173 if (val
& DF_1_WEAKFILTER
)
10175 printf (" WEAKFILTER");
10176 val
^= DF_1_WEAKFILTER
;
10178 if (val
& DF_1_NOCOMMON
)
10180 printf (" NOCOMMON");
10181 val
^= DF_1_NOCOMMON
;
10184 printf (" %lx", val
);
10191 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10193 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10213 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10219 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10220 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10226 switch (entry
->d_tag
)
10229 printf (_("Shared library: [%s]"), name
);
10231 if (streq (name
, program_interpreter
))
10232 printf (_(" program interpreter"));
10236 printf (_("Library soname: [%s]"), name
);
10240 printf (_("Library rpath: [%s]"), name
);
10244 printf (_("Library runpath: [%s]"), name
);
10248 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10253 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10266 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10267 /* Fall through. */
10271 case DT_INIT_ARRAYSZ
:
10272 case DT_FINI_ARRAYSZ
:
10273 case DT_GNU_CONFLICTSZ
:
10274 case DT_GNU_LIBLISTSZ
:
10277 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10278 printf (_(" (bytes)\n"));
10283 case DT_VERNEEDNUM
:
10288 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10297 case DT_INIT_ARRAY
:
10298 case DT_FINI_ARRAY
:
10301 if (entry
->d_tag
== DT_USED
10302 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10304 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10308 printf (_("Not needed object: [%s]\n"), name
);
10313 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10319 /* The value of this entry is ignored. */
10324 case DT_GNU_PRELINKED
:
10328 time_t atime
= entry
->d_un
.d_val
;
10330 tmp
= gmtime (&atime
);
10331 /* PR 17533 file: 041-1244816-0.004. */
10333 printf (_("<corrupt time val: %lx"),
10334 (unsigned long) atime
);
10336 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10337 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10338 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10344 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10347 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10353 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10354 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10359 switch (filedata
->file_header
.e_machine
)
10362 case EM_MIPS_RS3_LE
:
10363 dynamic_section_mips_val (entry
);
10366 dynamic_section_parisc_val (entry
);
10369 dynamic_section_ia64_val (entry
);
10372 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10384 get_ver_flags (unsigned int flags
)
10386 static char buff
[128];
10393 if (flags
& VER_FLG_BASE
)
10394 strcat (buff
, "BASE");
10396 if (flags
& VER_FLG_WEAK
)
10398 if (flags
& VER_FLG_BASE
)
10399 strcat (buff
, " | ");
10401 strcat (buff
, "WEAK");
10404 if (flags
& VER_FLG_INFO
)
10406 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10407 strcat (buff
, " | ");
10409 strcat (buff
, "INFO");
10412 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10414 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10415 strcat (buff
, " | ");
10417 strcat (buff
, _("<unknown>"));
10423 /* Display the contents of the version sections. */
10426 process_version_sections (Filedata
* filedata
)
10428 Elf_Internal_Shdr
* section
;
10430 bfd_boolean found
= FALSE
;
10435 for (i
= 0, section
= filedata
->section_headers
;
10436 i
< filedata
->file_header
.e_shnum
;
10439 switch (section
->sh_type
)
10441 case SHT_GNU_verdef
:
10443 Elf_External_Verdef
* edefs
;
10450 printf (ngettext ("\nVersion definition section '%s' "
10451 "contains %u entry:\n",
10452 "\nVersion definition section '%s' "
10453 "contains %u entries:\n",
10455 printable_section_name (filedata
, section
),
10458 printf (_(" Addr: 0x"));
10459 printf_vma (section
->sh_addr
);
10460 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10461 (unsigned long) section
->sh_offset
, section
->sh_link
,
10462 printable_section_name_from_index (filedata
, section
->sh_link
));
10464 edefs
= (Elf_External_Verdef
*)
10465 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10466 _("version definition section"));
10469 endbuf
= (char *) edefs
+ section
->sh_size
;
10471 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10474 Elf_External_Verdef
* edef
;
10475 Elf_Internal_Verdef ent
;
10476 Elf_External_Verdaux
* eaux
;
10477 Elf_Internal_Verdaux aux
;
10478 unsigned long isum
;
10481 vstart
= ((char *) edefs
) + idx
;
10482 if (vstart
+ sizeof (*edef
) > endbuf
)
10485 edef
= (Elf_External_Verdef
*) vstart
;
10487 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10488 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10489 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10490 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10491 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10492 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10493 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10495 printf (_(" %#06lx: Rev: %d Flags: %s"),
10496 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10498 printf (_(" Index: %d Cnt: %d "),
10499 ent
.vd_ndx
, ent
.vd_cnt
);
10501 /* Check for overflow. */
10502 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10505 vstart
+= ent
.vd_aux
;
10507 if (vstart
+ sizeof (*eaux
) > endbuf
)
10509 eaux
= (Elf_External_Verdaux
*) vstart
;
10511 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10512 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10514 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10515 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10517 printf (_("Name index: %ld\n"), aux
.vda_name
);
10519 isum
= idx
+ ent
.vd_aux
;
10521 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10523 if (aux
.vda_next
< sizeof (*eaux
)
10524 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10526 warn (_("Invalid vda_next field of %lx\n"),
10531 /* Check for overflow. */
10532 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10535 isum
+= aux
.vda_next
;
10536 vstart
+= aux
.vda_next
;
10538 if (vstart
+ sizeof (*eaux
) > endbuf
)
10540 eaux
= (Elf_External_Verdaux
*) vstart
;
10542 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10543 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10545 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10546 printf (_(" %#06lx: Parent %d: %s\n"),
10547 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10549 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10550 isum
, j
, aux
.vda_name
);
10553 if (j
< ent
.vd_cnt
)
10554 printf (_(" Version def aux past end of section\n"));
10557 file: id:000001,src:000172+005151,op:splice,rep:2. */
10558 if (ent
.vd_next
< sizeof (*edef
)
10559 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10561 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10562 cnt
= section
->sh_info
;
10565 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10568 idx
+= ent
.vd_next
;
10571 if (cnt
< section
->sh_info
)
10572 printf (_(" Version definition past end of section\n"));
10578 case SHT_GNU_verneed
:
10580 Elf_External_Verneed
* eneed
;
10587 printf (ngettext ("\nVersion needs section '%s' "
10588 "contains %u entry:\n",
10589 "\nVersion needs section '%s' "
10590 "contains %u entries:\n",
10592 printable_section_name (filedata
, section
), section
->sh_info
);
10594 printf (_(" Addr: 0x"));
10595 printf_vma (section
->sh_addr
);
10596 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10597 (unsigned long) section
->sh_offset
, section
->sh_link
,
10598 printable_section_name_from_index (filedata
, section
->sh_link
));
10600 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10601 section
->sh_offset
, 1,
10603 _("Version Needs section"));
10606 endbuf
= (char *) eneed
+ section
->sh_size
;
10608 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10610 Elf_External_Verneed
* entry
;
10611 Elf_Internal_Verneed ent
;
10612 unsigned long isum
;
10616 vstart
= ((char *) eneed
) + idx
;
10617 if (vstart
+ sizeof (*entry
) > endbuf
)
10620 entry
= (Elf_External_Verneed
*) vstart
;
10622 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10623 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10624 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10625 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10626 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10628 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10630 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10631 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10633 printf (_(" File: %lx"), ent
.vn_file
);
10635 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10637 /* Check for overflow. */
10638 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10640 vstart
+= ent
.vn_aux
;
10642 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10644 Elf_External_Vernaux
* eaux
;
10645 Elf_Internal_Vernaux aux
;
10647 if (vstart
+ sizeof (*eaux
) > endbuf
)
10649 eaux
= (Elf_External_Vernaux
*) vstart
;
10651 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10652 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10653 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10654 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10655 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10657 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10658 printf (_(" %#06lx: Name: %s"),
10659 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10661 printf (_(" %#06lx: Name index: %lx"),
10662 isum
, aux
.vna_name
);
10664 printf (_(" Flags: %s Version: %d\n"),
10665 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10667 if (aux
.vna_next
< sizeof (*eaux
)
10668 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10670 warn (_("Invalid vna_next field of %lx\n"),
10675 /* Check for overflow. */
10676 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10678 isum
+= aux
.vna_next
;
10679 vstart
+= aux
.vna_next
;
10682 if (j
< ent
.vn_cnt
)
10683 warn (_("Missing Version Needs auxillary information\n"));
10685 if (ent
.vn_next
< sizeof (*entry
)
10686 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10688 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10689 cnt
= section
->sh_info
;
10692 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10694 idx
+= ent
.vn_next
;
10697 if (cnt
< section
->sh_info
)
10698 warn (_("Missing Version Needs information\n"));
10704 case SHT_GNU_versym
:
10706 Elf_Internal_Shdr
* link_section
;
10709 unsigned char * edata
;
10710 unsigned short * data
;
10712 Elf_Internal_Sym
* symbols
;
10713 Elf_Internal_Shdr
* string_sec
;
10714 unsigned long num_syms
;
10717 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10720 link_section
= filedata
->section_headers
+ section
->sh_link
;
10721 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10723 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10728 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10729 if (symbols
== NULL
)
10732 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10734 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10735 string_sec
->sh_size
,
10736 _("version string table"));
10743 printf (ngettext ("\nVersion symbols section '%s' "
10744 "contains %lu entry:\n",
10745 "\nVersion symbols section '%s' "
10746 "contains %lu entries:\n",
10748 printable_section_name (filedata
, section
), (unsigned long) total
);
10750 printf (_(" Addr: "));
10751 printf_vma (section
->sh_addr
);
10752 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10753 (unsigned long) section
->sh_offset
, section
->sh_link
,
10754 printable_section_name (filedata
, link_section
));
10756 off
= offset_from_vma (filedata
,
10757 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10758 total
* sizeof (short));
10759 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10761 _("version symbol data"));
10769 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10771 for (cnt
= total
; cnt
--;)
10772 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10777 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10781 char *invalid
= _("*invalid*");
10783 printf (" %03x:", cnt
);
10785 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10786 switch (data
[cnt
+ j
])
10789 fputs (_(" 0 (*local*) "), stdout
);
10793 fputs (_(" 1 (*global*) "), stdout
);
10797 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10798 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10800 /* If this index value is greater than the size of the symbols
10801 array, break to avoid an out-of-bounds read. */
10802 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10804 warn (_("invalid index into symbol array\n"));
10809 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10811 Elf_Internal_Verneed ivn
;
10812 unsigned long offset
;
10814 offset
= offset_from_vma
10815 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10816 sizeof (Elf_External_Verneed
));
10820 Elf_Internal_Vernaux ivna
;
10821 Elf_External_Verneed evn
;
10822 Elf_External_Vernaux evna
;
10823 unsigned long a_off
;
10825 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10826 _("version need")) == NULL
)
10829 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10830 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10832 a_off
= offset
+ ivn
.vn_aux
;
10836 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10837 1, _("version need aux (2)")) == NULL
)
10840 ivna
.vna_other
= 0;
10844 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10845 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10848 a_off
+= ivna
.vna_next
;
10850 while (ivna
.vna_other
!= data
[cnt
+ j
]
10851 && ivna
.vna_next
!= 0);
10853 if (ivna
.vna_other
== data
[cnt
+ j
])
10855 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10857 if (ivna
.vna_name
>= string_sec
->sh_size
)
10860 name
= strtab
+ ivna
.vna_name
;
10864 offset
+= ivn
.vn_next
;
10866 while (ivn
.vn_next
);
10869 if (data
[cnt
+ j
] != 0x8001
10870 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10872 Elf_Internal_Verdef ivd
;
10873 Elf_External_Verdef evd
;
10874 unsigned long offset
;
10876 offset
= offset_from_vma
10877 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10882 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10883 _("version def")) == NULL
)
10886 /* PR 17531: file: 046-1082287-0.004. */
10887 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10892 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10893 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10896 offset
+= ivd
.vd_next
;
10898 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10899 && ivd
.vd_next
!= 0);
10901 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10903 Elf_External_Verdaux evda
;
10904 Elf_Internal_Verdaux ivda
;
10906 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10908 if (get_data (&evda
, filedata
,
10909 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10911 _("version def aux")) == NULL
)
10914 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10916 if (ivda
.vda_name
>= string_sec
->sh_size
)
10918 else if (name
!= NULL
&& name
!= invalid
)
10919 name
= _("*both*");
10921 name
= strtab
+ ivda
.vda_name
;
10925 nn
+= printf ("(%s%-*s",
10927 12 - (int) strlen (name
),
10931 printf ("%*c", 18 - nn
, ' ');
10949 printf (_("\nNo version information found in this file.\n"));
10954 static const char *
10955 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10957 static char buff
[32];
10961 case STB_LOCAL
: return "LOCAL";
10962 case STB_GLOBAL
: return "GLOBAL";
10963 case STB_WEAK
: return "WEAK";
10965 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10966 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10968 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10970 if (binding
== STB_GNU_UNIQUE
10971 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10972 /* GNU is still using the default value 0. */
10973 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10975 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10978 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10983 static const char *
10984 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10986 static char buff
[32];
10990 case STT_NOTYPE
: return "NOTYPE";
10991 case STT_OBJECT
: return "OBJECT";
10992 case STT_FUNC
: return "FUNC";
10993 case STT_SECTION
: return "SECTION";
10994 case STT_FILE
: return "FILE";
10995 case STT_COMMON
: return "COMMON";
10996 case STT_TLS
: return "TLS";
10997 case STT_RELC
: return "RELC";
10998 case STT_SRELC
: return "SRELC";
11000 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11002 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11003 return "THUMB_FUNC";
11005 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11008 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11009 return "PARISC_MILLI";
11011 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11013 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11015 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11017 if (type
== STT_HP_OPAQUE
)
11018 return "HP_OPAQUE";
11019 if (type
== STT_HP_STUB
)
11023 if (type
== STT_GNU_IFUNC
11024 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11025 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
11026 /* GNU is still using the default value 0. */
11027 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
11030 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11033 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11038 static const char *
11039 get_symbol_visibility (unsigned int visibility
)
11041 switch (visibility
)
11043 case STV_DEFAULT
: return "DEFAULT";
11044 case STV_INTERNAL
: return "INTERNAL";
11045 case STV_HIDDEN
: return "HIDDEN";
11046 case STV_PROTECTED
: return "PROTECTED";
11048 error (_("Unrecognized visibility value: %u"), visibility
);
11049 return _("<unknown>");
11053 static const char *
11054 get_solaris_symbol_visibility (unsigned int visibility
)
11056 switch (visibility
)
11058 case 4: return "EXPORTED";
11059 case 5: return "SINGLETON";
11060 case 6: return "ELIMINATE";
11061 default: return get_symbol_visibility (visibility
);
11065 static const char *
11066 get_mips_symbol_other (unsigned int other
)
11070 case STO_OPTIONAL
: return "OPTIONAL";
11071 case STO_MIPS_PLT
: return "MIPS PLT";
11072 case STO_MIPS_PIC
: return "MIPS PIC";
11073 case STO_MICROMIPS
: return "MICROMIPS";
11074 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11075 case STO_MIPS16
: return "MIPS16";
11076 default: return NULL
;
11080 static const char *
11081 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11083 if (is_ia64_vms (filedata
))
11085 static char res
[32];
11089 /* Function types is for images and .STB files only. */
11090 switch (filedata
->file_header
.e_type
)
11094 switch (VMS_ST_FUNC_TYPE (other
))
11096 case VMS_SFT_CODE_ADDR
:
11097 strcat (res
, " CA");
11099 case VMS_SFT_SYMV_IDX
:
11100 strcat (res
, " VEC");
11103 strcat (res
, " FD");
11105 case VMS_SFT_RESERVE
:
11106 strcat (res
, " RSV");
11109 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11110 VMS_ST_FUNC_TYPE (other
));
11111 strcat (res
, " <unknown>");
11118 switch (VMS_ST_LINKAGE (other
))
11120 case VMS_STL_IGNORE
:
11121 strcat (res
, " IGN");
11123 case VMS_STL_RESERVE
:
11124 strcat (res
, " RSV");
11127 strcat (res
, " STD");
11130 strcat (res
, " LNK");
11133 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11134 VMS_ST_LINKAGE (other
));
11135 strcat (res
, " <unknown>");
11147 static const char *
11148 get_ppc64_symbol_other (unsigned int other
)
11150 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11153 other
>>= STO_PPC64_LOCAL_BIT
;
11156 static char buf
[32];
11158 other
= ppc64_decode_local_entry (other
);
11159 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11165 static const char *
11166 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11168 const char * result
= NULL
;
11169 static char buff
[32];
11174 switch (filedata
->file_header
.e_machine
)
11177 result
= get_mips_symbol_other (other
);
11180 result
= get_ia64_symbol_other (filedata
, other
);
11183 result
= get_ppc64_symbol_other (other
);
11193 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11197 static const char *
11198 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11200 static char buff
[32];
11204 case SHN_UNDEF
: return "UND";
11205 case SHN_ABS
: return "ABS";
11206 case SHN_COMMON
: return "COM";
11208 if (type
== SHN_IA_64_ANSI_COMMON
11209 && filedata
->file_header
.e_machine
== EM_IA_64
11210 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11212 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11213 || filedata
->file_header
.e_machine
== EM_L1OM
11214 || filedata
->file_header
.e_machine
== EM_K1OM
)
11215 && type
== SHN_X86_64_LCOMMON
)
11216 return "LARGE_COM";
11217 else if ((type
== SHN_MIPS_SCOMMON
11218 && filedata
->file_header
.e_machine
== EM_MIPS
)
11219 || (type
== SHN_TIC6X_SCOMMON
11220 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11222 else if (type
== SHN_MIPS_SUNDEFINED
11223 && filedata
->file_header
.e_machine
== EM_MIPS
)
11225 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11226 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11227 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11228 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11229 else if (type
>= SHN_LORESERVE
)
11230 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11231 else if (type
>= filedata
->file_header
.e_shnum
)
11232 sprintf (buff
, _("bad section index[%3d]"), type
);
11234 sprintf (buff
, "%3d", type
);
11242 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11244 unsigned char * e_data
;
11247 /* If the size_t type is smaller than the bfd_size_type, eg because
11248 you are building a 32-bit tool on a 64-bit host, then make sure
11249 that when (number) is cast to (size_t) no information is lost. */
11250 if (sizeof (size_t) < sizeof (bfd_size_type
)
11251 && (bfd_size_type
) ((size_t) number
) != number
)
11253 error (_("Size truncation prevents reading %s elements of size %u\n"),
11254 bfd_vmatoa ("u", number
), ent_size
);
11258 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11259 attempting to allocate memory when the read is bound to fail. */
11260 if (ent_size
* number
> filedata
->file_size
)
11262 error (_("Invalid number of dynamic entries: %s\n"),
11263 bfd_vmatoa ("u", number
));
11267 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11268 if (e_data
== NULL
)
11270 error (_("Out of memory reading %s dynamic entries\n"),
11271 bfd_vmatoa ("u", number
));
11275 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11277 error (_("Unable to read in %s bytes of dynamic data\n"),
11278 bfd_vmatoa ("u", number
* ent_size
));
11283 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11284 if (i_data
== NULL
)
11286 error (_("Out of memory allocating space for %s dynamic entries\n"),
11287 bfd_vmatoa ("u", number
));
11293 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11301 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11303 Elf_Internal_Sym
* psym
;
11306 n
= print_vma (si
, DEC_5
);
11308 fputs (&" "[n
], stdout
);
11309 printf (" %3lu: ", hn
);
11311 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11313 printf (_("<No info available for dynamic symbol number %lu>\n"),
11314 (unsigned long) si
);
11318 psym
= dynamic_symbols
+ si
;
11319 print_vma (psym
->st_value
, LONG_HEX
);
11321 print_vma (psym
->st_size
, DEC_5
);
11323 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11324 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11326 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11327 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11330 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11332 printf (" %-7s", get_symbol_visibility (vis
));
11333 /* Check to see if any other bits in the st_other field are set.
11334 Note - displaying this information disrupts the layout of the
11335 table being generated, but for the moment this case is very
11337 if (psym
->st_other
^ vis
)
11338 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11341 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11342 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11343 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11345 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11349 static const char *
11350 get_symbol_version_string (Filedata
* filedata
,
11351 bfd_boolean is_dynsym
,
11352 const char * strtab
,
11353 unsigned long int strtab_size
,
11355 Elf_Internal_Sym
* psym
,
11356 enum versioned_symbol_info
* sym_info
,
11357 unsigned short * vna_other
)
11359 unsigned char data
[2];
11360 unsigned short vers_data
;
11361 unsigned long offset
;
11362 unsigned short max_vd_ndx
;
11365 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11368 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11369 sizeof data
+ si
* sizeof (vers_data
));
11371 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11372 sizeof (data
), 1, _("version data")) == NULL
)
11375 vers_data
= byte_get (data
, 2);
11377 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11382 /* Usually we'd only see verdef for defined symbols, and verneed for
11383 undefined symbols. However, symbols defined by the linker in
11384 .dynbss for variables copied from a shared library in order to
11385 avoid text relocations are defined yet have verneed. We could
11386 use a heuristic to detect the special case, for example, check
11387 for verneed first on symbols defined in SHT_NOBITS sections, but
11388 it is simpler and more reliable to just look for both verdef and
11389 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11391 if (psym
->st_shndx
!= SHN_UNDEF
11392 && vers_data
!= 0x8001
11393 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11395 Elf_Internal_Verdef ivd
;
11396 Elf_Internal_Verdaux ivda
;
11397 Elf_External_Verdaux evda
;
11400 off
= offset_from_vma (filedata
,
11401 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11402 sizeof (Elf_External_Verdef
));
11406 Elf_External_Verdef evd
;
11408 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11409 _("version def")) == NULL
)
11418 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11419 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11420 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11421 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11424 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11425 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11427 off
+= ivd
.vd_next
;
11429 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11431 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11433 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11436 off
-= ivd
.vd_next
;
11439 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11440 _("version def aux")) != NULL
)
11442 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11444 if (psym
->st_name
!= ivda
.vda_name
)
11446 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11447 ? symbol_hidden
: symbol_public
);
11448 return (ivda
.vda_name
< strtab_size
11449 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11455 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11457 Elf_External_Verneed evn
;
11458 Elf_Internal_Verneed ivn
;
11459 Elf_Internal_Vernaux ivna
;
11461 offset
= offset_from_vma (filedata
,
11462 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11466 unsigned long vna_off
;
11468 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11469 _("version need")) == NULL
)
11472 ivna
.vna_other
= 0;
11477 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11478 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11480 vna_off
= offset
+ ivn
.vn_aux
;
11484 Elf_External_Vernaux evna
;
11486 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11487 _("version need aux (3)")) == NULL
)
11490 ivna
.vna_other
= 0;
11495 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11496 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11497 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11500 vna_off
+= ivna
.vna_next
;
11502 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11504 if (ivna
.vna_other
== vers_data
)
11507 offset
+= ivn
.vn_next
;
11509 while (ivn
.vn_next
!= 0);
11511 if (ivna
.vna_other
== vers_data
)
11513 *sym_info
= symbol_undefined
;
11514 *vna_other
= ivna
.vna_other
;
11515 return (ivna
.vna_name
< strtab_size
11516 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11518 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11519 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11520 return _("<corrupt>");
11525 /* Dump the symbol table. */
11527 process_symbol_table (Filedata
* filedata
)
11529 Elf_Internal_Shdr
* section
;
11530 bfd_size_type nbuckets
= 0;
11531 bfd_size_type nchains
= 0;
11532 bfd_vma
* buckets
= NULL
;
11533 bfd_vma
* chains
= NULL
;
11534 bfd_vma ngnubuckets
= 0;
11535 bfd_vma
* gnubuckets
= NULL
;
11536 bfd_vma
* gnuchains
= NULL
;
11537 bfd_vma gnusymidx
= 0;
11538 bfd_size_type ngnuchains
= 0;
11540 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11543 if (dynamic_info
[DT_HASH
]
11545 || (do_using_dynamic
11547 && dynamic_strings
!= NULL
)))
11549 unsigned char nb
[8];
11550 unsigned char nc
[8];
11551 unsigned int hash_ent_size
= 4;
11553 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11554 || filedata
->file_header
.e_machine
== EM_S390
11555 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11556 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11559 if (fseek (filedata
->handle
,
11560 (archive_file_offset
11561 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11562 sizeof nb
+ sizeof nc
)),
11565 error (_("Unable to seek to start of dynamic information\n"));
11569 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11571 error (_("Failed to read in number of buckets\n"));
11575 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11577 error (_("Failed to read in number of chains\n"));
11581 nbuckets
= byte_get (nb
, hash_ent_size
);
11582 nchains
= byte_get (nc
, hash_ent_size
);
11584 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11585 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11588 if (buckets
== NULL
|| chains
== NULL
)
11590 if (do_using_dynamic
)
11601 if (dynamic_info_DT_GNU_HASH
11603 || (do_using_dynamic
11605 && dynamic_strings
!= NULL
)))
11607 unsigned char nb
[16];
11608 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11609 bfd_vma buckets_vma
;
11611 if (fseek (filedata
->handle
,
11612 (archive_file_offset
11613 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11617 error (_("Unable to seek to start of dynamic information\n"));
11621 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11623 error (_("Failed to read in number of buckets\n"));
11627 ngnubuckets
= byte_get (nb
, 4);
11628 gnusymidx
= byte_get (nb
+ 4, 4);
11629 bitmaskwords
= byte_get (nb
+ 8, 4);
11630 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11632 buckets_vma
+= bitmaskwords
* 4;
11634 buckets_vma
+= bitmaskwords
* 8;
11636 if (fseek (filedata
->handle
,
11637 (archive_file_offset
11638 + offset_from_vma (filedata
, buckets_vma
, 4)),
11641 error (_("Unable to seek to start of dynamic information\n"));
11645 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11647 if (gnubuckets
== NULL
)
11650 for (i
= 0; i
< ngnubuckets
; i
++)
11651 if (gnubuckets
[i
] != 0)
11653 if (gnubuckets
[i
] < gnusymidx
)
11656 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11657 maxchain
= gnubuckets
[i
];
11660 if (maxchain
== 0xffffffff)
11663 maxchain
-= gnusymidx
;
11665 if (fseek (filedata
->handle
,
11666 (archive_file_offset
11667 + offset_from_vma (filedata
, buckets_vma
11668 + 4 * (ngnubuckets
+ maxchain
), 4)),
11671 error (_("Unable to seek to start of dynamic information\n"));
11677 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11679 error (_("Failed to determine last chain length\n"));
11683 if (maxchain
+ 1 == 0)
11688 while ((byte_get (nb
, 4) & 1) == 0);
11690 if (fseek (filedata
->handle
,
11691 (archive_file_offset
11692 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11695 error (_("Unable to seek to start of dynamic information\n"));
11699 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11700 ngnuchains
= maxchain
;
11703 if (gnuchains
== NULL
)
11708 if (do_using_dynamic
)
11713 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11715 && do_using_dynamic
11716 && dynamic_strings
!= NULL
11717 && dynamic_symbols
!= NULL
)
11721 if (dynamic_info
[DT_HASH
])
11726 printf (_("\nSymbol table for image:\n"));
11728 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11730 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11732 visited
= xcmalloc (nchains
, 1);
11733 memset (visited
, 0, nchains
);
11734 for (hn
= 0; hn
< nbuckets
; hn
++)
11736 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11738 print_dynamic_symbol (filedata
, si
, hn
);
11739 if (si
>= nchains
|| visited
[si
])
11741 error (_("histogram chain is corrupt\n"));
11750 if (dynamic_info_DT_GNU_HASH
)
11752 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11754 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11756 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11758 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11759 if (gnubuckets
[hn
] != 0)
11761 bfd_vma si
= gnubuckets
[hn
];
11762 bfd_vma off
= si
- gnusymidx
;
11766 print_dynamic_symbol (filedata
, si
, hn
);
11769 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11773 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11774 && filedata
->section_headers
!= NULL
)
11778 for (i
= 0, section
= filedata
->section_headers
;
11779 i
< filedata
->file_header
.e_shnum
;
11783 char * strtab
= NULL
;
11784 unsigned long int strtab_size
= 0;
11785 Elf_Internal_Sym
* symtab
;
11786 Elf_Internal_Sym
* psym
;
11787 unsigned long num_syms
;
11789 if ((section
->sh_type
!= SHT_SYMTAB
11790 && section
->sh_type
!= SHT_DYNSYM
)
11792 && section
->sh_type
== SHT_SYMTAB
))
11795 if (section
->sh_entsize
== 0)
11797 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11798 printable_section_name (filedata
, section
));
11802 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11803 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11804 "\nSymbol table '%s' contains %lu entries:\n",
11806 printable_section_name (filedata
, section
),
11810 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11812 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11814 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11815 if (symtab
== NULL
)
11818 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11820 strtab
= filedata
->string_table
;
11821 strtab_size
= filedata
->string_table_length
;
11823 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11825 Elf_Internal_Shdr
* string_sec
;
11827 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11829 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11830 1, string_sec
->sh_size
,
11831 _("string table"));
11832 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11835 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11837 const char *version_string
;
11838 enum versioned_symbol_info sym_info
;
11839 unsigned short vna_other
;
11841 printf ("%6d: ", si
);
11842 print_vma (psym
->st_value
, LONG_HEX
);
11844 print_vma (psym
->st_size
, DEC_5
);
11845 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11846 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11847 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11848 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11851 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11853 printf (" %-7s", get_symbol_visibility (vis
));
11854 /* Check to see if any other bits in the st_other field are set.
11855 Note - displaying this information disrupts the layout of the
11856 table being generated, but for the moment this case is very rare. */
11857 if (psym
->st_other
^ vis
)
11858 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11860 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11861 print_symbol (25, psym
->st_name
< strtab_size
11862 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11865 = get_symbol_version_string (filedata
,
11866 section
->sh_type
== SHT_DYNSYM
,
11867 strtab
, strtab_size
, si
,
11868 psym
, &sym_info
, &vna_other
);
11869 if (version_string
)
11871 if (sym_info
== symbol_undefined
)
11872 printf ("@%s (%d)", version_string
, vna_other
);
11874 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11880 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11881 && si
>= section
->sh_info
11882 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11883 && filedata
->file_header
.e_machine
!= EM_MIPS
11884 /* Solaris binaries have been found to violate this requirement as
11885 well. Not sure if this is a bug or an ABI requirement. */
11886 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11887 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11888 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11892 if (strtab
!= filedata
->string_table
)
11898 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11900 if (do_histogram
&& buckets
!= NULL
)
11902 unsigned long * lengths
;
11903 unsigned long * counts
;
11906 unsigned long maxlength
= 0;
11907 unsigned long nzero_counts
= 0;
11908 unsigned long nsyms
= 0;
11911 printf (ngettext ("\nHistogram for bucket list length "
11912 "(total of %lu bucket):\n",
11913 "\nHistogram for bucket list length "
11914 "(total of %lu buckets):\n",
11915 (unsigned long) nbuckets
),
11916 (unsigned long) nbuckets
);
11918 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11919 if (lengths
== NULL
)
11921 error (_("Out of memory allocating space for histogram buckets\n"));
11924 visited
= xcmalloc (nchains
, 1);
11925 memset (visited
, 0, nchains
);
11927 printf (_(" Length Number %% of total Coverage\n"));
11928 for (hn
= 0; hn
< nbuckets
; ++hn
)
11930 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11933 if (maxlength
< ++lengths
[hn
])
11935 if (si
>= nchains
|| visited
[si
])
11937 error (_("histogram chain is corrupt\n"));
11945 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11946 if (counts
== NULL
)
11949 error (_("Out of memory allocating space for histogram counts\n"));
11953 for (hn
= 0; hn
< nbuckets
; ++hn
)
11954 ++counts
[lengths
[hn
]];
11959 printf (" 0 %-10lu (%5.1f%%)\n",
11960 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11961 for (i
= 1; i
<= maxlength
; ++i
)
11963 nzero_counts
+= counts
[i
] * i
;
11964 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11965 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11966 (nzero_counts
* 100.0) / nsyms
);
11974 if (buckets
!= NULL
)
11980 if (do_histogram
&& gnubuckets
!= NULL
)
11982 unsigned long * lengths
;
11983 unsigned long * counts
;
11985 unsigned long maxlength
= 0;
11986 unsigned long nzero_counts
= 0;
11987 unsigned long nsyms
= 0;
11989 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11990 "(total of %lu bucket):\n",
11991 "\nHistogram for `.gnu.hash' bucket list length "
11992 "(total of %lu buckets):\n",
11993 (unsigned long) ngnubuckets
),
11994 (unsigned long) ngnubuckets
);
11996 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11997 if (lengths
== NULL
)
11999 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12003 printf (_(" Length Number %% of total Coverage\n"));
12005 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12006 if (gnubuckets
[hn
] != 0)
12008 bfd_vma off
, length
= 1;
12010 for (off
= gnubuckets
[hn
] - gnusymidx
;
12011 /* PR 17531 file: 010-77222-0.004. */
12012 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12015 lengths
[hn
] = length
;
12016 if (length
> maxlength
)
12017 maxlength
= length
;
12021 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12022 if (counts
== NULL
)
12025 error (_("Out of memory allocating space for gnu histogram counts\n"));
12029 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12030 ++counts
[lengths
[hn
]];
12032 if (ngnubuckets
> 0)
12035 printf (" 0 %-10lu (%5.1f%%)\n",
12036 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12037 for (j
= 1; j
<= maxlength
; ++j
)
12039 nzero_counts
+= counts
[j
] * j
;
12040 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12041 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12042 (nzero_counts
* 100.0) / nsyms
);
12056 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12060 if (dynamic_syminfo
== NULL
12062 /* No syminfo, this is ok. */
12065 /* There better should be a dynamic symbol section. */
12066 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12070 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12071 "contains %d entry:\n",
12072 "\nDynamic info segment at offset 0x%lx "
12073 "contains %d entries:\n",
12074 dynamic_syminfo_nent
),
12075 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12077 printf (_(" Num: Name BoundTo Flags\n"));
12078 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12080 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12082 printf ("%4d: ", i
);
12083 if (i
>= num_dynamic_syms
)
12084 printf (_("<corrupt index>"));
12085 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12086 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12088 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12091 switch (dynamic_syminfo
[i
].si_boundto
)
12093 case SYMINFO_BT_SELF
:
12094 fputs ("SELF ", stdout
);
12096 case SYMINFO_BT_PARENT
:
12097 fputs ("PARENT ", stdout
);
12100 if (dynamic_syminfo
[i
].si_boundto
> 0
12101 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12102 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12104 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12108 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12112 if (flags
& SYMINFO_FLG_DIRECT
)
12113 printf (" DIRECT");
12114 if (flags
& SYMINFO_FLG_PASSTHRU
)
12115 printf (" PASSTHRU");
12116 if (flags
& SYMINFO_FLG_COPY
)
12118 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12119 printf (" LAZYLOAD");
12127 #define IN_RANGE(START,END,ADDR,OFF) \
12128 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12130 /* Check to see if the given reloc needs to be handled in a target specific
12131 manner. If so then process the reloc and return TRUE otherwise return
12134 If called with reloc == NULL, then this is a signal that reloc processing
12135 for the current section has finished, and any saved state should be
12139 target_specific_reloc_handling (Filedata
* filedata
,
12140 Elf_Internal_Rela
* reloc
,
12141 unsigned char * start
,
12142 unsigned char * end
,
12143 Elf_Internal_Sym
* symtab
,
12144 unsigned long num_syms
)
12146 unsigned int reloc_type
= 0;
12147 unsigned long sym_index
= 0;
12151 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12152 sym_index
= get_reloc_symindex (reloc
->r_info
);
12155 switch (filedata
->file_header
.e_machine
)
12158 case EM_MSP430_OLD
:
12160 static Elf_Internal_Sym
* saved_sym
= NULL
;
12168 switch (reloc_type
)
12170 case 10: /* R_MSP430_SYM_DIFF */
12171 if (uses_msp430x_relocs (filedata
))
12173 /* Fall through. */
12174 case 21: /* R_MSP430X_SYM_DIFF */
12176 if (sym_index
>= num_syms
)
12177 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12180 saved_sym
= symtab
+ sym_index
;
12183 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12184 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12185 goto handle_sym_diff
;
12187 case 5: /* R_MSP430_16_BYTE */
12188 case 9: /* R_MSP430_8 */
12189 if (uses_msp430x_relocs (filedata
))
12191 goto handle_sym_diff
;
12193 case 2: /* R_MSP430_ABS16 */
12194 case 15: /* R_MSP430X_ABS16 */
12195 if (! uses_msp430x_relocs (filedata
))
12197 goto handle_sym_diff
;
12200 if (saved_sym
!= NULL
)
12202 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12205 if (sym_index
>= num_syms
)
12206 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12210 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12211 - saved_sym
->st_value
);
12213 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12214 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12217 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12218 (long) reloc
->r_offset
);
12227 if (saved_sym
!= NULL
)
12228 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12235 case EM_CYGNUS_MN10300
:
12237 static Elf_Internal_Sym
* saved_sym
= NULL
;
12245 switch (reloc_type
)
12247 case 34: /* R_MN10300_ALIGN */
12249 case 33: /* R_MN10300_SYM_DIFF */
12250 if (sym_index
>= num_syms
)
12251 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12254 saved_sym
= symtab
+ sym_index
;
12257 case 1: /* R_MN10300_32 */
12258 case 2: /* R_MN10300_16 */
12259 if (saved_sym
!= NULL
)
12261 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12264 if (sym_index
>= num_syms
)
12265 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12269 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12270 - saved_sym
->st_value
);
12272 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12273 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12275 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12276 (long) reloc
->r_offset
);
12284 if (saved_sym
!= NULL
)
12285 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12293 static bfd_vma saved_sym1
= 0;
12294 static bfd_vma saved_sym2
= 0;
12295 static bfd_vma value
;
12299 saved_sym1
= saved_sym2
= 0;
12303 switch (reloc_type
)
12305 case 0x80: /* R_RL78_SYM. */
12306 saved_sym1
= saved_sym2
;
12307 if (sym_index
>= num_syms
)
12308 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12312 saved_sym2
= symtab
[sym_index
].st_value
;
12313 saved_sym2
+= reloc
->r_addend
;
12317 case 0x83: /* R_RL78_OPsub. */
12318 value
= saved_sym1
- saved_sym2
;
12319 saved_sym2
= saved_sym1
= 0;
12323 case 0x41: /* R_RL78_ABS32. */
12324 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12325 byte_put (start
+ reloc
->r_offset
, value
, 4);
12327 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12328 (long) reloc
->r_offset
);
12332 case 0x43: /* R_RL78_ABS16. */
12333 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12334 byte_put (start
+ reloc
->r_offset
, value
, 2);
12336 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12337 (long) reloc
->r_offset
);
12351 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12352 DWARF debug sections. This is a target specific test. Note - we do not
12353 go through the whole including-target-headers-multiple-times route, (as
12354 we have already done with <elf/h8.h>) because this would become very
12355 messy and even then this function would have to contain target specific
12356 information (the names of the relocs instead of their numeric values).
12357 FIXME: This is not the correct way to solve this problem. The proper way
12358 is to have target specific reloc sizing and typing functions created by
12359 the reloc-macros.h header, in the same way that it already creates the
12360 reloc naming functions. */
12363 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12365 /* Please keep this table alpha-sorted for ease of visual lookup. */
12366 switch (filedata
->file_header
.e_machine
)
12370 return reloc_type
== 1; /* R_386_32. */
12372 return reloc_type
== 1; /* R_68K_32. */
12374 return reloc_type
== 1; /* R_860_32. */
12376 return reloc_type
== 2; /* R_960_32. */
12378 return (reloc_type
== 258
12379 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12380 case EM_ADAPTEVA_EPIPHANY
:
12381 return reloc_type
== 3;
12383 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12385 return reloc_type
== 1; /* R_ARC_32. */
12386 case EM_ARC_COMPACT
:
12387 case EM_ARC_COMPACT2
:
12388 return reloc_type
== 4; /* R_ARC_32. */
12390 return reloc_type
== 2; /* R_ARM_ABS32 */
12393 return reloc_type
== 1;
12395 return reloc_type
== 0x12; /* R_byte4_data. */
12397 return reloc_type
== 3; /* R_CRIS_32. */
12399 return reloc_type
== 3; /* R_CR16_NUM32. */
12401 return reloc_type
== 15; /* R_CRX_NUM32. */
12403 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12404 case EM_CYGNUS_FRV
:
12405 return reloc_type
== 1;
12406 case EM_CYGNUS_D10V
:
12408 return reloc_type
== 6; /* R_D10V_32. */
12409 case EM_CYGNUS_D30V
:
12411 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12413 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12414 case EM_CYGNUS_FR30
:
12416 return reloc_type
== 3; /* R_FR30_32. */
12418 return reloc_type
== 1; /* R_FT32_32. */
12422 return reloc_type
== 1; /* R_H8_DIR32. */
12424 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12425 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12426 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12427 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12430 return reloc_type
== 2; /* R_IP2K_32. */
12432 return reloc_type
== 2; /* R_IQ2000_32. */
12433 case EM_LATTICEMICO32
:
12434 return reloc_type
== 3; /* R_LM32_32. */
12437 return reloc_type
== 3; /* R_M32C_32. */
12439 return reloc_type
== 34; /* R_M32R_32_RELA. */
12442 return reloc_type
== 6; /* R_M68HC11_32. */
12444 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12445 reloc_type
== 6; /* R_S12Z_CW32. */
12447 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12448 case EM_CYGNUS_MEP
:
12449 return reloc_type
== 4; /* R_MEP_32. */
12451 return reloc_type
== 2; /* R_METAG_ADDR32. */
12452 case EM_MICROBLAZE
:
12453 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12455 return reloc_type
== 2; /* R_MIPS_32. */
12457 return reloc_type
== 4; /* R_MMIX_32. */
12458 case EM_CYGNUS_MN10200
:
12460 return reloc_type
== 1; /* R_MN10200_32. */
12461 case EM_CYGNUS_MN10300
:
12463 return reloc_type
== 1; /* R_MN10300_32. */
12465 return reloc_type
== 1; /* R_MOXIE_32. */
12466 case EM_MSP430_OLD
:
12468 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12470 return reloc_type
== 2; /* R_MT_32. */
12472 return reloc_type
== 20; /* R_NDS32_RELA. */
12473 case EM_ALTERA_NIOS2
:
12474 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12476 return reloc_type
== 1; /* R_NIOS_32. */
12478 return reloc_type
== 1; /* R_OR1K_32. */
12480 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12481 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12482 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12485 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12487 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12489 return reloc_type
== 1; /* R_PPC_ADDR32. */
12491 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12493 return reloc_type
== 1; /* R_RISCV_32. */
12495 return reloc_type
== 1; /* R_RL78_DIR32. */
12497 return reloc_type
== 1; /* R_RX_DIR32. */
12499 return reloc_type
== 1; /* R_I370_ADDR31. */
12502 return reloc_type
== 4; /* R_S390_32. */
12504 return reloc_type
== 8; /* R_SCORE_ABS32. */
12506 return reloc_type
== 1; /* R_SH_DIR32. */
12507 case EM_SPARC32PLUS
:
12510 return reloc_type
== 3 /* R_SPARC_32. */
12511 || reloc_type
== 23; /* R_SPARC_UA32. */
12513 return reloc_type
== 6; /* R_SPU_ADDR32 */
12515 return reloc_type
== 1; /* R_C6000_ABS32. */
12517 return reloc_type
== 2; /* R_TILEGX_32. */
12519 return reloc_type
== 1; /* R_TILEPRO_32. */
12520 case EM_CYGNUS_V850
:
12522 return reloc_type
== 6; /* R_V850_ABS32. */
12524 return reloc_type
== 0x33; /* R_V810_WORD. */
12526 return reloc_type
== 1; /* R_VAX_32. */
12528 return reloc_type
== 3; /* R_VISIUM_32. */
12529 case EM_WEBASSEMBLY
:
12530 return reloc_type
== 1; /* R_WASM32_32. */
12534 return reloc_type
== 10; /* R_X86_64_32. */
12537 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12539 return reloc_type
== 4; /* R_XGATE_32. */
12541 return reloc_type
== 1; /* R_XSTROMY16_32. */
12542 case EM_XTENSA_OLD
:
12544 return reloc_type
== 1; /* R_XTENSA_32. */
12547 static unsigned int prev_warn
= 0;
12549 /* Avoid repeating the same warning multiple times. */
12550 if (prev_warn
!= filedata
->file_header
.e_machine
)
12551 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12552 filedata
->file_header
.e_machine
);
12553 prev_warn
= filedata
->file_header
.e_machine
;
12559 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12560 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12563 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12565 switch (filedata
->file_header
.e_machine
)
12566 /* Please keep this table alpha-sorted for ease of visual lookup. */
12570 return reloc_type
== 2; /* R_386_PC32. */
12572 return reloc_type
== 4; /* R_68K_PC32. */
12574 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12575 case EM_ADAPTEVA_EPIPHANY
:
12576 return reloc_type
== 6;
12578 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12579 case EM_ARC_COMPACT
:
12580 case EM_ARC_COMPACT2
:
12581 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12583 return reloc_type
== 3; /* R_ARM_REL32 */
12586 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12587 case EM_MICROBLAZE
:
12588 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12590 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12592 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12594 return reloc_type
== 26; /* R_PPC_REL32. */
12596 return reloc_type
== 26; /* R_PPC64_REL32. */
12598 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12601 return reloc_type
== 5; /* R_390_PC32. */
12603 return reloc_type
== 2; /* R_SH_REL32. */
12604 case EM_SPARC32PLUS
:
12607 return reloc_type
== 6; /* R_SPARC_DISP32. */
12609 return reloc_type
== 13; /* R_SPU_REL32. */
12611 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12613 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12615 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12619 return reloc_type
== 2; /* R_X86_64_PC32. */
12620 case EM_XTENSA_OLD
:
12622 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12624 /* Do not abort or issue an error message here. Not all targets use
12625 pc-relative 32-bit relocs in their DWARF debug information and we
12626 have already tested for target coverage in is_32bit_abs_reloc. A
12627 more helpful warning message will be generated by apply_relocations
12628 anyway, so just return. */
12633 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12634 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12637 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12639 switch (filedata
->file_header
.e_machine
)
12642 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12644 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12646 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12647 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12649 return reloc_type
== 80; /* R_PARISC_DIR64. */
12651 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12653 return reloc_type
== 2; /* R_RISCV_64. */
12654 case EM_SPARC32PLUS
:
12657 return reloc_type
== 32 /* R_SPARC_64. */
12658 || reloc_type
== 54; /* R_SPARC_UA64. */
12662 return reloc_type
== 1; /* R_X86_64_64. */
12665 return reloc_type
== 22; /* R_S390_64. */
12667 return reloc_type
== 1; /* R_TILEGX_64. */
12669 return reloc_type
== 18; /* R_MIPS_64. */
12675 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12676 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12679 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12681 switch (filedata
->file_header
.e_machine
)
12684 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12686 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12688 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12689 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12691 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12693 return reloc_type
== 44; /* R_PPC64_REL64. */
12694 case EM_SPARC32PLUS
:
12697 return reloc_type
== 46; /* R_SPARC_DISP64. */
12701 return reloc_type
== 24; /* R_X86_64_PC64. */
12704 return reloc_type
== 23; /* R_S390_PC64. */
12706 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12712 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12713 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12716 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12718 switch (filedata
->file_header
.e_machine
)
12720 case EM_CYGNUS_MN10200
:
12722 return reloc_type
== 4; /* R_MN10200_24. */
12724 return reloc_type
== 5; /* R_FT32_20. */
12730 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12731 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12734 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12736 /* Please keep this table alpha-sorted for ease of visual lookup. */
12737 switch (filedata
->file_header
.e_machine
)
12740 case EM_ARC_COMPACT
:
12741 case EM_ARC_COMPACT2
:
12742 return reloc_type
== 2; /* R_ARC_16. */
12743 case EM_ADAPTEVA_EPIPHANY
:
12744 return reloc_type
== 5;
12747 return reloc_type
== 4; /* R_AVR_16. */
12748 case EM_CYGNUS_D10V
:
12750 return reloc_type
== 3; /* R_D10V_16. */
12752 return reloc_type
== 2; /* R_FT32_16. */
12756 return reloc_type
== R_H8_DIR16
;
12759 return reloc_type
== 1; /* R_IP2K_16. */
12762 return reloc_type
== 1; /* R_M32C_16 */
12763 case EM_CYGNUS_MN10200
:
12765 return reloc_type
== 2; /* R_MN10200_16. */
12766 case EM_CYGNUS_MN10300
:
12768 return reloc_type
== 2; /* R_MN10300_16. */
12770 if (uses_msp430x_relocs (filedata
))
12771 return reloc_type
== 2; /* R_MSP430_ABS16. */
12772 /* Fall through. */
12773 case EM_MSP430_OLD
:
12774 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12776 return reloc_type
== 19; /* R_NDS32_RELA. */
12777 case EM_ALTERA_NIOS2
:
12778 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12780 return reloc_type
== 9; /* R_NIOS_16. */
12782 return reloc_type
== 2; /* R_OR1K_16. */
12784 return reloc_type
== 55; /* R_RISCV_SET16. */
12786 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12788 return reloc_type
== 2; /* R_C6000_ABS16. */
12790 return reloc_type
== 2; /* R_VISIUM_16. */
12793 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12795 return reloc_type
== 3; /* R_XGATE_16. */
12801 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12802 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12805 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12807 switch (filedata
->file_header
.e_machine
)
12810 return reloc_type
== 54; /* R_RISCV_SET8. */
12816 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12817 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12820 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12822 switch (filedata
->file_header
.e_machine
)
12825 return reloc_type
== 53; /* R_RISCV_SET6. */
12831 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12832 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12835 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12837 /* Please keep this table alpha-sorted for ease of visual lookup. */
12838 switch (filedata
->file_header
.e_machine
)
12841 return reloc_type
== 35; /* R_RISCV_ADD32. */
12847 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12848 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12851 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12853 /* Please keep this table alpha-sorted for ease of visual lookup. */
12854 switch (filedata
->file_header
.e_machine
)
12857 return reloc_type
== 39; /* R_RISCV_SUB32. */
12863 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12864 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12867 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12869 /* Please keep this table alpha-sorted for ease of visual lookup. */
12870 switch (filedata
->file_header
.e_machine
)
12873 return reloc_type
== 36; /* R_RISCV_ADD64. */
12879 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12880 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12883 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12885 /* Please keep this table alpha-sorted for ease of visual lookup. */
12886 switch (filedata
->file_header
.e_machine
)
12889 return reloc_type
== 40; /* R_RISCV_SUB64. */
12895 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12896 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12899 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12901 /* Please keep this table alpha-sorted for ease of visual lookup. */
12902 switch (filedata
->file_header
.e_machine
)
12905 return reloc_type
== 34; /* R_RISCV_ADD16. */
12911 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12912 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12915 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12917 /* Please keep this table alpha-sorted for ease of visual lookup. */
12918 switch (filedata
->file_header
.e_machine
)
12921 return reloc_type
== 38; /* R_RISCV_SUB16. */
12927 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12928 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12931 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12933 /* Please keep this table alpha-sorted for ease of visual lookup. */
12934 switch (filedata
->file_header
.e_machine
)
12937 return reloc_type
== 33; /* R_RISCV_ADD8. */
12943 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12944 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12947 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12949 /* Please keep this table alpha-sorted for ease of visual lookup. */
12950 switch (filedata
->file_header
.e_machine
)
12953 return reloc_type
== 37; /* R_RISCV_SUB8. */
12959 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12960 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12963 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12965 switch (filedata
->file_header
.e_machine
)
12968 return reloc_type
== 52; /* R_RISCV_SUB6. */
12974 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12975 relocation entries (possibly formerly used for SHT_GROUP sections). */
12978 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12980 switch (filedata
->file_header
.e_machine
)
12982 case EM_386
: /* R_386_NONE. */
12983 case EM_68K
: /* R_68K_NONE. */
12984 case EM_ADAPTEVA_EPIPHANY
:
12985 case EM_ALPHA
: /* R_ALPHA_NONE. */
12986 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12987 case EM_ARC
: /* R_ARC_NONE. */
12988 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12989 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12990 case EM_ARM
: /* R_ARM_NONE. */
12991 case EM_C166
: /* R_XC16X_NONE. */
12992 case EM_CRIS
: /* R_CRIS_NONE. */
12993 case EM_FT32
: /* R_FT32_NONE. */
12994 case EM_IA_64
: /* R_IA64_NONE. */
12995 case EM_K1OM
: /* R_X86_64_NONE. */
12996 case EM_L1OM
: /* R_X86_64_NONE. */
12997 case EM_M32R
: /* R_M32R_NONE. */
12998 case EM_MIPS
: /* R_MIPS_NONE. */
12999 case EM_MN10300
: /* R_MN10300_NONE. */
13000 case EM_MOXIE
: /* R_MOXIE_NONE. */
13001 case EM_NIOS32
: /* R_NIOS_NONE. */
13002 case EM_OR1K
: /* R_OR1K_NONE. */
13003 case EM_PARISC
: /* R_PARISC_NONE. */
13004 case EM_PPC64
: /* R_PPC64_NONE. */
13005 case EM_PPC
: /* R_PPC_NONE. */
13006 case EM_RISCV
: /* R_RISCV_NONE. */
13007 case EM_S390
: /* R_390_NONE. */
13009 case EM_SH
: /* R_SH_NONE. */
13010 case EM_SPARC32PLUS
:
13011 case EM_SPARC
: /* R_SPARC_NONE. */
13013 case EM_TILEGX
: /* R_TILEGX_NONE. */
13014 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13015 case EM_TI_C6000
:/* R_C6000_NONE. */
13016 case EM_X86_64
: /* R_X86_64_NONE. */
13018 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13019 return reloc_type
== 0;
13022 return reloc_type
== 0 || reloc_type
== 256;
13025 return (reloc_type
== 0 /* R_AVR_NONE. */
13026 || reloc_type
== 30 /* R_AVR_DIFF8. */
13027 || reloc_type
== 31 /* R_AVR_DIFF16. */
13028 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13030 return reloc_type
== 3; /* R_METAG_NONE. */
13032 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13033 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13034 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13035 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13036 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13038 return (reloc_type
== 0 /* R_PRU_NONE. */
13039 || reloc_type
== 65 /* R_PRU_DIFF8. */
13040 || reloc_type
== 66 /* R_PRU_DIFF16. */
13041 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13042 case EM_XTENSA_OLD
:
13044 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13045 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13046 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13047 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13052 /* Returns TRUE if there is a relocation against
13053 section NAME at OFFSET bytes. */
13056 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13058 Elf_Internal_Rela
* relocs
;
13059 Elf_Internal_Rela
* rp
;
13061 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13064 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13066 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13067 if (rp
->r_offset
== offset
)
13073 /* Apply relocations to a section.
13074 Returns TRUE upon success, FALSE otherwise.
13075 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13076 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13077 will be set to the number of relocs loaded.
13079 Note: So far support has been added only for those relocations
13080 which can be found in debug sections. FIXME: Add support for
13081 more relocations ? */
13084 apply_relocations (Filedata
* filedata
,
13085 const Elf_Internal_Shdr
* section
,
13086 unsigned char * start
,
13087 bfd_size_type size
,
13088 void ** relocs_return
,
13089 unsigned long * num_relocs_return
)
13091 Elf_Internal_Shdr
* relsec
;
13092 unsigned char * end
= start
+ size
;
13094 if (relocs_return
!= NULL
)
13096 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13097 * num_relocs_return
= 0;
13100 if (filedata
->file_header
.e_type
!= ET_REL
)
13101 /* No relocs to apply. */
13104 /* Find the reloc section associated with the section. */
13105 for (relsec
= filedata
->section_headers
;
13106 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13109 bfd_boolean is_rela
;
13110 unsigned long num_relocs
;
13111 Elf_Internal_Rela
* relocs
;
13112 Elf_Internal_Rela
* rp
;
13113 Elf_Internal_Shdr
* symsec
;
13114 Elf_Internal_Sym
* symtab
;
13115 unsigned long num_syms
;
13116 Elf_Internal_Sym
* sym
;
13118 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13119 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13120 || filedata
->section_headers
+ relsec
->sh_info
!= section
13121 || relsec
->sh_size
== 0
13122 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13125 is_rela
= relsec
->sh_type
== SHT_RELA
;
13129 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13130 relsec
->sh_size
, & relocs
, & num_relocs
))
13135 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13136 relsec
->sh_size
, & relocs
, & num_relocs
))
13140 /* SH uses RELA but uses in place value instead of the addend field. */
13141 if (filedata
->file_header
.e_machine
== EM_SH
)
13144 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13145 if (symsec
->sh_type
!= SHT_SYMTAB
13146 && symsec
->sh_type
!= SHT_DYNSYM
)
13148 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13150 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13153 unsigned int reloc_type
;
13154 unsigned int reloc_size
;
13155 bfd_boolean reloc_inplace
= FALSE
;
13156 bfd_boolean reloc_subtract
= FALSE
;
13157 unsigned char * rloc
;
13158 unsigned long sym_index
;
13160 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13162 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13164 else if (is_none_reloc (filedata
, reloc_type
))
13166 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13167 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13169 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13170 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13172 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13174 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13176 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13177 || is_6bit_abs_reloc (filedata
, reloc_type
))
13179 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13181 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13184 reloc_inplace
= TRUE
;
13186 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13188 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13191 reloc_inplace
= TRUE
;
13193 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13195 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13198 reloc_inplace
= TRUE
;
13200 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13202 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13205 reloc_inplace
= TRUE
;
13207 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13211 reloc_inplace
= TRUE
;
13215 static unsigned int prev_reloc
= 0;
13217 if (reloc_type
!= prev_reloc
)
13218 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13219 reloc_type
, printable_section_name (filedata
, section
));
13220 prev_reloc
= reloc_type
;
13224 rloc
= start
+ rp
->r_offset
;
13225 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
13227 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13228 (unsigned long) rp
->r_offset
,
13229 printable_section_name (filedata
, section
));
13233 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13234 if (sym_index
>= num_syms
)
13236 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13237 sym_index
, printable_section_name (filedata
, section
));
13240 sym
= symtab
+ sym_index
;
13242 /* If the reloc has a symbol associated with it,
13243 make sure that it is of an appropriate type.
13245 Relocations against symbols without type can happen.
13246 Gcc -feliminate-dwarf2-dups may generate symbols
13247 without type for debug info.
13249 Icc generates relocations against function symbols
13250 instead of local labels.
13252 Relocations against object symbols can happen, eg when
13253 referencing a global array. For an example of this see
13254 the _clz.o binary in libgcc.a. */
13256 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13257 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13259 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13260 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13261 printable_section_name (filedata
, relsec
),
13262 (long int)(rp
- relocs
));
13268 addend
+= rp
->r_addend
;
13269 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13270 partial_inplace. */
13272 || (filedata
->file_header
.e_machine
== EM_XTENSA
13273 && reloc_type
== 1)
13274 || ((filedata
->file_header
.e_machine
== EM_PJ
13275 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13276 && reloc_type
== 1)
13277 || ((filedata
->file_header
.e_machine
== EM_D30V
13278 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13279 && reloc_type
== 12)
13282 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13283 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13285 addend
+= byte_get (rloc
, reloc_size
);
13288 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13289 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13291 /* On HPPA, all pc-relative relocations are biased by 8. */
13292 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13294 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13297 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13298 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13300 if (reloc_subtract
)
13301 addend
-= sym
->st_value
;
13303 addend
+= sym
->st_value
;
13304 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13305 byte_put (rloc
, addend
, reloc_size
);
13307 else if (reloc_subtract
)
13308 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13310 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13314 /* Let the target specific reloc processing code know that
13315 we have finished with these relocs. */
13316 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13320 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13321 * num_relocs_return
= num_relocs
;
13332 #ifdef SUPPORT_DISASSEMBLY
13334 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13336 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13338 /* FIXME: XXX -- to be done --- XXX */
13344 /* Reads in the contents of SECTION from FILE, returning a pointer
13345 to a malloc'ed buffer or NULL if something went wrong. */
13348 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13350 bfd_size_type num_bytes
= section
->sh_size
;
13352 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13354 printf (_("Section '%s' has no data to dump.\n"),
13355 printable_section_name (filedata
, section
));
13359 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13360 _("section contents"));
13363 /* Uncompresses a section that was compressed using zlib, in place. */
13366 uncompress_section_contents (unsigned char ** buffer
,
13367 dwarf_size_type uncompressed_size
,
13368 dwarf_size_type
* size
)
13370 dwarf_size_type compressed_size
= *size
;
13371 unsigned char * compressed_buffer
= *buffer
;
13372 unsigned char * uncompressed_buffer
;
13376 /* It is possible the section consists of several compressed
13377 buffers concatenated together, so we uncompress in a loop. */
13378 /* PR 18313: The state field in the z_stream structure is supposed
13379 to be invisible to the user (ie us), but some compilers will
13380 still complain about it being used without initialisation. So
13381 we first zero the entire z_stream structure and then set the fields
13383 memset (& strm
, 0, sizeof strm
);
13384 strm
.avail_in
= compressed_size
;
13385 strm
.next_in
= (Bytef
*) compressed_buffer
;
13386 strm
.avail_out
= uncompressed_size
;
13387 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13389 rc
= inflateInit (& strm
);
13390 while (strm
.avail_in
> 0)
13394 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13395 + (uncompressed_size
- strm
.avail_out
));
13396 rc
= inflate (&strm
, Z_FINISH
);
13397 if (rc
!= Z_STREAM_END
)
13399 rc
= inflateReset (& strm
);
13401 rc
= inflateEnd (& strm
);
13403 || strm
.avail_out
!= 0)
13406 *buffer
= uncompressed_buffer
;
13407 *size
= uncompressed_size
;
13411 free (uncompressed_buffer
);
13412 /* Indicate decompression failure. */
13418 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13420 Elf_Internal_Shdr
* relsec
;
13421 bfd_size_type num_bytes
;
13422 unsigned char * data
;
13423 unsigned char * end
;
13424 unsigned char * real_start
;
13425 unsigned char * start
;
13426 bfd_boolean some_strings_shown
;
13428 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13430 /* PR 21820: Do not fail if the section was empty. */
13431 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13433 num_bytes
= section
->sh_size
;
13435 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13437 if (decompress_dumps
)
13439 dwarf_size_type new_size
= num_bytes
;
13440 dwarf_size_type uncompressed_size
= 0;
13442 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13444 Elf_Internal_Chdr chdr
;
13445 unsigned int compression_header_size
13446 = get_compression_header (& chdr
, (unsigned char *) start
,
13449 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13451 warn (_("section '%s' has unsupported compress type: %d\n"),
13452 printable_section_name (filedata
, section
), chdr
.ch_type
);
13455 uncompressed_size
= chdr
.ch_size
;
13456 start
+= compression_header_size
;
13457 new_size
-= compression_header_size
;
13459 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13461 /* Read the zlib header. In this case, it should be "ZLIB"
13462 followed by the uncompressed section size, 8 bytes in
13463 big-endian order. */
13464 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13465 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13466 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13467 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13468 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13469 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13470 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13471 uncompressed_size
+= start
[11];
13476 if (uncompressed_size
)
13478 if (uncompress_section_contents (& start
,
13479 uncompressed_size
, & new_size
))
13480 num_bytes
= new_size
;
13483 error (_("Unable to decompress section %s\n"),
13484 printable_section_name (filedata
, section
));
13489 start
= real_start
;
13492 /* If the section being dumped has relocations against it the user might
13493 be expecting these relocations to have been applied. Check for this
13494 case and issue a warning message in order to avoid confusion.
13495 FIXME: Maybe we ought to have an option that dumps a section with
13496 relocs applied ? */
13497 for (relsec
= filedata
->section_headers
;
13498 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13501 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13502 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13503 || filedata
->section_headers
+ relsec
->sh_info
!= section
13504 || relsec
->sh_size
== 0
13505 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13508 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13513 end
= start
+ num_bytes
;
13514 some_strings_shown
= FALSE
;
13518 while (!ISPRINT (* data
))
13519 if (++ data
>= end
)
13524 size_t maxlen
= end
- data
;
13527 /* PR 11128: Use two separate invocations in order to work
13528 around bugs in the Solaris 8 implementation of printf. */
13529 printf (" [%6tx] ", data
- start
);
13531 printf (" [%6Ix] ", (size_t) (data
- start
));
13535 print_symbol ((int) maxlen
, (const char *) data
);
13537 data
+= strnlen ((const char *) data
, maxlen
);
13541 printf (_("<corrupt>\n"));
13544 some_strings_shown
= TRUE
;
13548 if (! some_strings_shown
)
13549 printf (_(" No strings found in this section."));
13558 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13559 Filedata
* filedata
,
13560 bfd_boolean relocate
)
13562 Elf_Internal_Shdr
* relsec
;
13563 bfd_size_type bytes
;
13564 bfd_size_type section_size
;
13566 unsigned char * data
;
13567 unsigned char * real_start
;
13568 unsigned char * start
;
13570 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13572 /* PR 21820: Do not fail if the section was empty. */
13573 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13575 section_size
= section
->sh_size
;
13577 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13579 if (decompress_dumps
)
13581 dwarf_size_type new_size
= section_size
;
13582 dwarf_size_type uncompressed_size
= 0;
13584 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13586 Elf_Internal_Chdr chdr
;
13587 unsigned int compression_header_size
13588 = get_compression_header (& chdr
, start
, section_size
);
13590 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13592 warn (_("section '%s' has unsupported compress type: %d\n"),
13593 printable_section_name (filedata
, section
), chdr
.ch_type
);
13596 uncompressed_size
= chdr
.ch_size
;
13597 start
+= compression_header_size
;
13598 new_size
-= compression_header_size
;
13600 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13602 /* Read the zlib header. In this case, it should be "ZLIB"
13603 followed by the uncompressed section size, 8 bytes in
13604 big-endian order. */
13605 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13606 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13607 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13608 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13609 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13610 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13611 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13612 uncompressed_size
+= start
[11];
13617 if (uncompressed_size
)
13619 if (uncompress_section_contents (& start
, uncompressed_size
,
13622 section_size
= new_size
;
13626 error (_("Unable to decompress section %s\n"),
13627 printable_section_name (filedata
, section
));
13628 /* FIXME: Print the section anyway ? */
13633 start
= real_start
;
13638 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13643 /* If the section being dumped has relocations against it the user might
13644 be expecting these relocations to have been applied. Check for this
13645 case and issue a warning message in order to avoid confusion.
13646 FIXME: Maybe we ought to have an option that dumps a section with
13647 relocs applied ? */
13648 for (relsec
= filedata
->section_headers
;
13649 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13652 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13653 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13654 || filedata
->section_headers
+ relsec
->sh_info
!= section
13655 || relsec
->sh_size
== 0
13656 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13659 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13664 addr
= section
->sh_addr
;
13665 bytes
= section_size
;
13674 lbytes
= (bytes
> 16 ? 16 : bytes
);
13676 printf (" 0x%8.8lx ", (unsigned long) addr
);
13678 for (j
= 0; j
< 16; j
++)
13681 printf ("%2.2x", data
[j
]);
13689 for (j
= 0; j
< lbytes
; j
++)
13692 if (k
>= ' ' && k
< 0x7f)
13712 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13713 const Elf_Internal_Shdr
* sec
,
13716 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13718 Filedata
* filedata
= (Filedata
*) data
;
13720 if (section
->start
!= NULL
)
13722 /* If it is already loaded, do nothing. */
13723 if (streq (section
->filename
, filedata
->file_name
))
13725 free (section
->start
);
13728 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13729 section
->address
= sec
->sh_addr
;
13730 section
->user_data
= NULL
;
13731 section
->filename
= filedata
->file_name
;
13732 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13734 sec
->sh_size
, buf
);
13735 if (section
->start
== NULL
)
13739 unsigned char *start
= section
->start
;
13740 dwarf_size_type size
= sec
->sh_size
;
13741 dwarf_size_type uncompressed_size
= 0;
13743 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13745 Elf_Internal_Chdr chdr
;
13746 unsigned int compression_header_size
;
13748 if (size
< (is_32bit_elf
13749 ? sizeof (Elf32_External_Chdr
)
13750 : sizeof (Elf64_External_Chdr
)))
13752 warn (_("compressed section %s is too small to contain a compression header"),
13757 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13759 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13761 warn (_("section '%s' has unsupported compress type: %d\n"),
13762 section
->name
, chdr
.ch_type
);
13765 uncompressed_size
= chdr
.ch_size
;
13766 start
+= compression_header_size
;
13767 size
-= compression_header_size
;
13769 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13771 /* Read the zlib header. In this case, it should be "ZLIB"
13772 followed by the uncompressed section size, 8 bytes in
13773 big-endian order. */
13774 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13775 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13776 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13777 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13778 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13779 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13780 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13781 uncompressed_size
+= start
[11];
13786 if (uncompressed_size
)
13788 if (uncompress_section_contents (&start
, uncompressed_size
,
13791 /* Free the compressed buffer, update the section buffer
13792 and the section size if uncompress is successful. */
13793 free (section
->start
);
13794 section
->start
= start
;
13798 error (_("Unable to decompress section %s\n"),
13799 printable_section_name (filedata
, sec
));
13804 section
->size
= size
;
13807 if (section
->start
== NULL
)
13810 if (debug_displays
[debug
].relocate
)
13812 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13813 & section
->reloc_info
, & section
->num_relocs
))
13818 section
->reloc_info
= NULL
;
13819 section
->num_relocs
= 0;
13825 /* If this is not NULL, load_debug_section will only look for sections
13826 within the list of sections given here. */
13827 static unsigned int * section_subset
= NULL
;
13830 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13832 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13833 Elf_Internal_Shdr
* sec
;
13834 Filedata
* filedata
= (Filedata
*) data
;
13836 /* Without section headers we cannot find any sections. */
13837 if (filedata
->section_headers
== NULL
)
13840 if (filedata
->string_table
== NULL
13841 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13842 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13844 Elf_Internal_Shdr
* strs
;
13846 /* Read in the string table, so that we have section names to scan. */
13847 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13849 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13851 filedata
->string_table
13852 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13853 1, strs
->sh_size
, _("string table"));
13855 filedata
->string_table_length
13856 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13860 /* Locate the debug section. */
13861 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13863 section
->name
= section
->uncompressed_name
;
13866 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13868 section
->name
= section
->compressed_name
;
13873 /* If we're loading from a subset of sections, and we've loaded
13874 a section matching this name before, it's likely that it's a
13876 if (section_subset
!= NULL
)
13877 free_debug_section (debug
);
13879 return load_specific_debug_section (debug
, sec
, data
);
13883 free_debug_section (enum dwarf_section_display_enum debug
)
13885 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13887 if (section
->start
== NULL
)
13890 free ((char *) section
->start
);
13891 section
->start
= NULL
;
13892 section
->address
= 0;
13897 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13899 char * name
= SECTION_NAME (section
);
13900 const char * print_name
= printable_section_name (filedata
, section
);
13901 bfd_size_type length
;
13902 bfd_boolean result
= TRUE
;
13905 length
= section
->sh_size
;
13908 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13911 if (section
->sh_type
== SHT_NOBITS
)
13913 /* There is no point in dumping the contents of a debugging section
13914 which has the NOBITS type - the bits in the file will be random.
13915 This can happen when a file containing a .eh_frame section is
13916 stripped with the --only-keep-debug command line option. */
13917 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13922 if (const_strneq (name
, ".gnu.linkonce.wi."))
13923 name
= ".debug_info";
13925 /* See if we know how to display the contents of this section. */
13926 for (i
= 0; i
< max
; i
++)
13928 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13929 struct dwarf_section_display
* display
= debug_displays
+ i
;
13930 struct dwarf_section
* sec
= & display
->section
;
13932 if (streq (sec
->uncompressed_name
, name
)
13933 || (id
== line
&& const_strneq (name
, ".debug_line."))
13934 || streq (sec
->compressed_name
, name
))
13936 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13939 free_debug_section (id
);
13941 if (i
== line
&& const_strneq (name
, ".debug_line."))
13943 else if (streq (sec
->uncompressed_name
, name
))
13944 sec
->name
= sec
->uncompressed_name
;
13946 sec
->name
= sec
->compressed_name
;
13948 if (load_specific_debug_section (id
, section
, filedata
))
13950 /* If this debug section is part of a CU/TU set in a .dwp file,
13951 restrict load_debug_section to the sections in that set. */
13952 section_subset
= find_cu_tu_set (filedata
, shndx
);
13954 result
&= display
->display (sec
, filedata
);
13956 section_subset
= NULL
;
13958 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13959 free_debug_section (id
);
13967 printf (_("Unrecognized debug section: %s\n"), print_name
);
13974 /* Set DUMP_SECTS for all sections where dumps were requested
13975 based on section name. */
13978 initialise_dumps_byname (Filedata
* filedata
)
13980 struct dump_list_entry
* cur
;
13982 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13985 bfd_boolean any
= FALSE
;
13987 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13988 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13990 request_dump_bynumber (filedata
, i
, cur
->type
);
13995 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14001 process_section_contents (Filedata
* filedata
)
14003 Elf_Internal_Shdr
* section
;
14005 bfd_boolean res
= TRUE
;
14010 initialise_dumps_byname (filedata
);
14012 for (i
= 0, section
= filedata
->section_headers
;
14013 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14016 dump_type dump
= filedata
->dump_sects
[i
];
14018 #ifdef SUPPORT_DISASSEMBLY
14019 if (dump
& DISASS_DUMP
)
14021 if (! disassemble_section (section
, filedata
))
14025 if (dump
& HEX_DUMP
)
14027 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14031 if (dump
& RELOC_DUMP
)
14033 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14037 if (dump
& STRING_DUMP
)
14039 if (! dump_section_as_strings (section
, filedata
))
14043 if (dump
& DEBUG_DUMP
)
14045 if (! display_debug_section (i
, section
, filedata
))
14050 /* Check to see if the user requested a
14051 dump of a section that does not exist. */
14052 while (i
< filedata
->num_dump_sects
)
14054 if (filedata
->dump_sects
[i
])
14056 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14066 process_mips_fpe_exception (int mask
)
14070 bfd_boolean first
= TRUE
;
14072 if (mask
& OEX_FPU_INEX
)
14073 fputs ("INEX", stdout
), first
= FALSE
;
14074 if (mask
& OEX_FPU_UFLO
)
14075 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14076 if (mask
& OEX_FPU_OFLO
)
14077 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14078 if (mask
& OEX_FPU_DIV0
)
14079 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14080 if (mask
& OEX_FPU_INVAL
)
14081 printf ("%sINVAL", first
? "" : "|");
14084 fputs ("0", stdout
);
14087 /* Display's the value of TAG at location P. If TAG is
14088 greater than 0 it is assumed to be an unknown tag, and
14089 a message is printed to this effect. Otherwise it is
14090 assumed that a message has already been printed.
14092 If the bottom bit of TAG is set it assumed to have a
14093 string value, otherwise it is assumed to have an integer
14096 Returns an updated P pointing to the first unread byte
14097 beyond the end of TAG's value.
14099 Reads at or beyond END will not be made. */
14101 static unsigned char *
14102 display_tag_value (signed int tag
,
14104 const unsigned char * const end
)
14109 printf (" Tag_unknown_%d: ", tag
);
14113 warn (_("<corrupt tag>\n"));
14117 /* PR 17531 file: 027-19978-0.004. */
14118 size_t maxlen
= (end
- p
) - 1;
14123 print_symbol ((int) maxlen
, (const char *) p
);
14124 p
+= strnlen ((char *) p
, maxlen
) + 1;
14128 printf (_("<corrupt string tag>"));
14129 p
= (unsigned char *) end
;
14137 val
= read_uleb128 (p
, &len
, end
);
14139 printf ("%ld (0x%lx)\n", val
, val
);
14146 /* ARC ABI attributes section. */
14148 static unsigned char *
14149 display_arc_attribute (unsigned char * p
,
14150 const unsigned char * const end
)
14156 tag
= read_uleb128 (p
, &len
, end
);
14161 case Tag_ARC_PCS_config
:
14162 val
= read_uleb128 (p
, &len
, end
);
14164 printf (" Tag_ARC_PCS_config: ");
14168 printf (_("Absent/Non standard\n"));
14171 printf (_("Bare metal/mwdt\n"));
14174 printf (_("Bare metal/newlib\n"));
14177 printf (_("Linux/uclibc\n"));
14180 printf (_("Linux/glibc\n"));
14183 printf (_("Unknown\n"));
14188 case Tag_ARC_CPU_base
:
14189 val
= read_uleb128 (p
, &len
, end
);
14191 printf (" Tag_ARC_CPU_base: ");
14196 printf (_("Absent\n"));
14198 case TAG_CPU_ARC6xx
:
14199 printf ("ARC6xx\n");
14201 case TAG_CPU_ARC7xx
:
14202 printf ("ARC7xx\n");
14204 case TAG_CPU_ARCEM
:
14205 printf ("ARCEM\n");
14207 case TAG_CPU_ARCHS
:
14208 printf ("ARCHS\n");
14213 case Tag_ARC_CPU_variation
:
14214 val
= read_uleb128 (p
, &len
, end
);
14216 printf (" Tag_ARC_CPU_variation: ");
14220 if (val
> 0 && val
< 16)
14221 printf ("Core%d\n", val
);
14223 printf ("Unknown\n");
14227 printf (_("Absent\n"));
14232 case Tag_ARC_CPU_name
:
14233 printf (" Tag_ARC_CPU_name: ");
14234 p
= display_tag_value (-1, p
, end
);
14237 case Tag_ARC_ABI_rf16
:
14238 val
= read_uleb128 (p
, &len
, end
);
14240 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14243 case Tag_ARC_ABI_osver
:
14244 val
= read_uleb128 (p
, &len
, end
);
14246 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14249 case Tag_ARC_ABI_pic
:
14250 case Tag_ARC_ABI_sda
:
14251 val
= read_uleb128 (p
, &len
, end
);
14253 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14254 : " Tag_ARC_ABI_pic: ");
14258 printf (_("Absent\n"));
14267 printf (_("Unknown\n"));
14272 case Tag_ARC_ABI_tls
:
14273 val
= read_uleb128 (p
, &len
, end
);
14275 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14278 case Tag_ARC_ABI_enumsize
:
14279 val
= read_uleb128 (p
, &len
, end
);
14281 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14285 case Tag_ARC_ABI_exceptions
:
14286 val
= read_uleb128 (p
, &len
, end
);
14288 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14292 case Tag_ARC_ABI_double_size
:
14293 val
= read_uleb128 (p
, &len
, end
);
14295 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14298 case Tag_ARC_ISA_config
:
14299 printf (" Tag_ARC_ISA_config: ");
14300 p
= display_tag_value (-1, p
, end
);
14303 case Tag_ARC_ISA_apex
:
14304 printf (" Tag_ARC_ISA_apex: ");
14305 p
= display_tag_value (-1, p
, end
);
14308 case Tag_ARC_ISA_mpy_option
:
14309 val
= read_uleb128 (p
, &len
, end
);
14311 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14314 case Tag_ARC_ATR_version
:
14315 val
= read_uleb128 (p
, &len
, end
);
14317 printf (" Tag_ARC_ATR_version: %d\n", val
);
14321 return display_tag_value (tag
& 1, p
, end
);
14327 /* ARM EABI attributes section. */
14332 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14334 const char ** table
;
14335 } arm_attr_public_tag
;
14337 static const char * arm_attr_tag_CPU_arch
[] =
14338 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14339 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14341 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14342 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14343 {"No", "Thumb-1", "Thumb-2", "Yes"};
14344 static const char * arm_attr_tag_FP_arch
[] =
14345 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14346 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14347 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14348 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14349 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14350 "NEON for ARMv8.1"};
14351 static const char * arm_attr_tag_PCS_config
[] =
14352 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14353 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14354 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14355 {"V6", "SB", "TLS", "Unused"};
14356 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14357 {"Absolute", "PC-relative", "SB-relative", "None"};
14358 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14359 {"Absolute", "PC-relative", "None"};
14360 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14361 {"None", "direct", "GOT-indirect"};
14362 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14363 {"None", "??? 1", "2", "??? 3", "4"};
14364 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14365 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14366 {"Unused", "Needed", "Sign only"};
14367 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14368 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14369 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14370 {"Unused", "Finite", "RTABI", "IEEE 754"};
14371 static const char * arm_attr_tag_ABI_enum_size
[] =
14372 {"Unused", "small", "int", "forced to int"};
14373 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14374 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14375 static const char * arm_attr_tag_ABI_VFP_args
[] =
14376 {"AAPCS", "VFP registers", "custom", "compatible"};
14377 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14378 {"AAPCS", "WMMX registers", "custom"};
14379 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14380 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14381 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14382 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14383 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14384 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14385 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14386 static const char * arm_attr_tag_FP_HP_extension
[] =
14387 {"Not Allowed", "Allowed"};
14388 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14389 {"None", "IEEE 754", "Alternative Format"};
14390 static const char * arm_attr_tag_DSP_extension
[] =
14391 {"Follow architecture", "Allowed"};
14392 static const char * arm_attr_tag_MPextension_use
[] =
14393 {"Not Allowed", "Allowed"};
14394 static const char * arm_attr_tag_DIV_use
[] =
14395 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14396 "Allowed in v7-A with integer division extension"};
14397 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14398 static const char * arm_attr_tag_Virtualization_use
[] =
14399 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14400 "TrustZone and Virtualization Extensions"};
14401 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14402 {"Not Allowed", "Allowed"};
14404 #define LOOKUP(id, name) \
14405 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14406 static arm_attr_public_tag arm_attr_public_tags
[] =
14408 {4, "CPU_raw_name", 1, NULL
},
14409 {5, "CPU_name", 1, NULL
},
14410 LOOKUP(6, CPU_arch
),
14411 {7, "CPU_arch_profile", 0, NULL
},
14412 LOOKUP(8, ARM_ISA_use
),
14413 LOOKUP(9, THUMB_ISA_use
),
14414 LOOKUP(10, FP_arch
),
14415 LOOKUP(11, WMMX_arch
),
14416 LOOKUP(12, Advanced_SIMD_arch
),
14417 LOOKUP(13, PCS_config
),
14418 LOOKUP(14, ABI_PCS_R9_use
),
14419 LOOKUP(15, ABI_PCS_RW_data
),
14420 LOOKUP(16, ABI_PCS_RO_data
),
14421 LOOKUP(17, ABI_PCS_GOT_use
),
14422 LOOKUP(18, ABI_PCS_wchar_t
),
14423 LOOKUP(19, ABI_FP_rounding
),
14424 LOOKUP(20, ABI_FP_denormal
),
14425 LOOKUP(21, ABI_FP_exceptions
),
14426 LOOKUP(22, ABI_FP_user_exceptions
),
14427 LOOKUP(23, ABI_FP_number_model
),
14428 {24, "ABI_align_needed", 0, NULL
},
14429 {25, "ABI_align_preserved", 0, NULL
},
14430 LOOKUP(26, ABI_enum_size
),
14431 LOOKUP(27, ABI_HardFP_use
),
14432 LOOKUP(28, ABI_VFP_args
),
14433 LOOKUP(29, ABI_WMMX_args
),
14434 LOOKUP(30, ABI_optimization_goals
),
14435 LOOKUP(31, ABI_FP_optimization_goals
),
14436 {32, "compatibility", 0, NULL
},
14437 LOOKUP(34, CPU_unaligned_access
),
14438 LOOKUP(36, FP_HP_extension
),
14439 LOOKUP(38, ABI_FP_16bit_format
),
14440 LOOKUP(42, MPextension_use
),
14441 LOOKUP(44, DIV_use
),
14442 LOOKUP(46, DSP_extension
),
14443 {64, "nodefaults", 0, NULL
},
14444 {65, "also_compatible_with", 0, NULL
},
14445 LOOKUP(66, T2EE_use
),
14446 {67, "conformance", 1, NULL
},
14447 LOOKUP(68, Virtualization_use
),
14448 LOOKUP(70, MPextension_use_legacy
)
14452 static unsigned char *
14453 display_arm_attribute (unsigned char * p
,
14454 const unsigned char * const end
)
14459 arm_attr_public_tag
* attr
;
14463 tag
= read_uleb128 (p
, &len
, end
);
14466 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14468 if (arm_attr_public_tags
[i
].tag
== tag
)
14470 attr
= &arm_attr_public_tags
[i
];
14477 printf (" Tag_%s: ", attr
->name
);
14478 switch (attr
->type
)
14483 case 7: /* Tag_CPU_arch_profile. */
14484 val
= read_uleb128 (p
, &len
, end
);
14488 case 0: printf (_("None\n")); break;
14489 case 'A': printf (_("Application\n")); break;
14490 case 'R': printf (_("Realtime\n")); break;
14491 case 'M': printf (_("Microcontroller\n")); break;
14492 case 'S': printf (_("Application or Realtime\n")); break;
14493 default: printf ("??? (%d)\n", val
); break;
14497 case 24: /* Tag_align_needed. */
14498 val
= read_uleb128 (p
, &len
, end
);
14502 case 0: printf (_("None\n")); break;
14503 case 1: printf (_("8-byte\n")); break;
14504 case 2: printf (_("4-byte\n")); break;
14505 case 3: printf ("??? 3\n"); break;
14508 printf (_("8-byte and up to %d-byte extended\n"),
14511 printf ("??? (%d)\n", val
);
14516 case 25: /* Tag_align_preserved. */
14517 val
= read_uleb128 (p
, &len
, end
);
14521 case 0: printf (_("None\n")); break;
14522 case 1: printf (_("8-byte, except leaf SP\n")); break;
14523 case 2: printf (_("8-byte\n")); break;
14524 case 3: printf ("??? 3\n"); break;
14527 printf (_("8-byte and up to %d-byte extended\n"),
14530 printf ("??? (%d)\n", val
);
14535 case 32: /* Tag_compatibility. */
14537 val
= read_uleb128 (p
, &len
, end
);
14539 printf (_("flag = %d, vendor = "), val
);
14542 size_t maxlen
= (end
- p
) - 1;
14544 print_symbol ((int) maxlen
, (const char *) p
);
14545 p
+= strnlen ((char *) p
, maxlen
) + 1;
14549 printf (_("<corrupt>"));
14550 p
= (unsigned char *) end
;
14556 case 64: /* Tag_nodefaults. */
14557 /* PR 17531: file: 001-505008-0.01. */
14560 printf (_("True\n"));
14563 case 65: /* Tag_also_compatible_with. */
14564 val
= read_uleb128 (p
, &len
, end
);
14566 if (val
== 6 /* Tag_CPU_arch. */)
14568 val
= read_uleb128 (p
, &len
, end
);
14570 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14571 printf ("??? (%d)\n", val
);
14573 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14577 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14582 printf (_("<unknown: %d>\n"), tag
);
14588 return display_tag_value (-1, p
, end
);
14590 return display_tag_value (0, p
, end
);
14593 assert (attr
->type
& 0x80);
14594 val
= read_uleb128 (p
, &len
, end
);
14596 type
= attr
->type
& 0x7f;
14598 printf ("??? (%d)\n", val
);
14600 printf ("%s\n", attr
->table
[val
]);
14605 return display_tag_value (tag
, p
, end
);
14608 static unsigned char *
14609 display_gnu_attribute (unsigned char * p
,
14610 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14611 const unsigned char * const end
)
14617 tag
= read_uleb128 (p
, &len
, end
);
14620 /* Tag_compatibility is the only generic GNU attribute defined at
14624 val
= read_uleb128 (p
, &len
, end
);
14627 printf (_("flag = %d, vendor = "), val
);
14630 printf (_("<corrupt>\n"));
14631 warn (_("corrupt vendor attribute\n"));
14637 size_t maxlen
= (end
- p
) - 1;
14639 print_symbol ((int) maxlen
, (const char *) p
);
14640 p
+= strnlen ((char *) p
, maxlen
) + 1;
14644 printf (_("<corrupt>"));
14645 p
= (unsigned char *) end
;
14652 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14653 return display_proc_gnu_attribute (p
, tag
, end
);
14655 return display_tag_value (tag
, p
, end
);
14658 static unsigned char *
14659 display_power_gnu_attribute (unsigned char * p
,
14661 const unsigned char * const end
)
14666 if (tag
== Tag_GNU_Power_ABI_FP
)
14668 val
= read_uleb128 (p
, &len
, end
);
14670 printf (" Tag_GNU_Power_ABI_FP: ");
14673 printf (_("<corrupt>\n"));
14678 printf ("(%#x), ", val
);
14683 printf (_("unspecified hard/soft float, "));
14686 printf (_("hard float, "));
14689 printf (_("soft float, "));
14692 printf (_("single-precision hard float, "));
14699 printf (_("unspecified long double\n"));
14702 printf (_("128-bit IBM long double\n"));
14705 printf (_("64-bit long double\n"));
14708 printf (_("128-bit IEEE long double\n"));
14714 if (tag
== Tag_GNU_Power_ABI_Vector
)
14716 val
= read_uleb128 (p
, &len
, end
);
14718 printf (" Tag_GNU_Power_ABI_Vector: ");
14721 printf (_("<corrupt>\n"));
14726 printf ("(%#x), ", val
);
14731 printf (_("unspecified\n"));
14734 printf (_("generic\n"));
14737 printf ("AltiVec\n");
14746 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14748 val
= read_uleb128 (p
, &len
, end
);
14750 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14753 printf (_("<corrupt>\n"));
14758 printf ("(%#x), ", val
);
14763 printf (_("unspecified\n"));
14766 printf ("r3/r4\n");
14769 printf (_("memory\n"));
14778 return display_tag_value (tag
& 1, p
, end
);
14781 static unsigned char *
14782 display_s390_gnu_attribute (unsigned char * p
,
14784 const unsigned char * const end
)
14789 if (tag
== Tag_GNU_S390_ABI_Vector
)
14791 val
= read_uleb128 (p
, &len
, end
);
14793 printf (" Tag_GNU_S390_ABI_Vector: ");
14798 printf (_("any\n"));
14801 printf (_("software\n"));
14804 printf (_("hardware\n"));
14807 printf ("??? (%d)\n", val
);
14813 return display_tag_value (tag
& 1, p
, end
);
14817 display_sparc_hwcaps (unsigned int mask
)
14821 bfd_boolean first
= TRUE
;
14823 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14824 fputs ("mul32", stdout
), first
= FALSE
;
14825 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14826 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14827 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14828 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14829 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14830 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14831 if (mask
& ELF_SPARC_HWCAP_POPC
)
14832 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14833 if (mask
& ELF_SPARC_HWCAP_VIS
)
14834 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14835 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14836 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14837 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14838 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14839 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14840 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14841 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14842 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14843 if (mask
& ELF_SPARC_HWCAP_HPC
)
14844 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14845 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14846 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14847 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14848 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14849 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14850 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14851 if (mask
& ELF_SPARC_HWCAP_IMA
)
14852 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14853 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14854 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14857 fputc ('0', stdout
);
14858 fputc ('\n', stdout
);
14862 display_sparc_hwcaps2 (unsigned int mask
)
14866 bfd_boolean first
= TRUE
;
14868 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14869 fputs ("fjathplus", stdout
), first
= FALSE
;
14870 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14871 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14872 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14873 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14874 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14875 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14876 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14877 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14878 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14879 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14880 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14881 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14882 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14883 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14884 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14885 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14886 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14887 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14888 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14889 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14892 fputc ('0', stdout
);
14893 fputc ('\n', stdout
);
14896 static unsigned char *
14897 display_sparc_gnu_attribute (unsigned char * p
,
14899 const unsigned char * const end
)
14904 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14906 val
= read_uleb128 (p
, &len
, end
);
14908 printf (" Tag_GNU_Sparc_HWCAPS: ");
14909 display_sparc_hwcaps (val
);
14912 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14914 val
= read_uleb128 (p
, &len
, end
);
14916 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14917 display_sparc_hwcaps2 (val
);
14921 return display_tag_value (tag
, p
, end
);
14925 print_mips_fp_abi_value (unsigned int val
)
14929 case Val_GNU_MIPS_ABI_FP_ANY
:
14930 printf (_("Hard or soft float\n"));
14932 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14933 printf (_("Hard float (double precision)\n"));
14935 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14936 printf (_("Hard float (single precision)\n"));
14938 case Val_GNU_MIPS_ABI_FP_SOFT
:
14939 printf (_("Soft float\n"));
14941 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14942 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14944 case Val_GNU_MIPS_ABI_FP_XX
:
14945 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14947 case Val_GNU_MIPS_ABI_FP_64
:
14948 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14950 case Val_GNU_MIPS_ABI_FP_64A
:
14951 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14953 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14954 printf (_("NaN 2008 compatibility\n"));
14957 printf ("??? (%d)\n", val
);
14962 static unsigned char *
14963 display_mips_gnu_attribute (unsigned char * p
,
14965 const unsigned char * const end
)
14967 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14972 val
= read_uleb128 (p
, &len
, end
);
14974 printf (" Tag_GNU_MIPS_ABI_FP: ");
14976 print_mips_fp_abi_value (val
);
14981 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14986 val
= read_uleb128 (p
, &len
, end
);
14988 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14992 case Val_GNU_MIPS_ABI_MSA_ANY
:
14993 printf (_("Any MSA or not\n"));
14995 case Val_GNU_MIPS_ABI_MSA_128
:
14996 printf (_("128-bit MSA\n"));
14999 printf ("??? (%d)\n", val
);
15005 return display_tag_value (tag
& 1, p
, end
);
15008 static unsigned char *
15009 display_tic6x_attribute (unsigned char * p
,
15010 const unsigned char * const end
)
15016 tag
= read_uleb128 (p
, &len
, end
);
15022 val
= read_uleb128 (p
, &len
, end
);
15024 printf (" Tag_ISA: ");
15028 case C6XABI_Tag_ISA_none
:
15029 printf (_("None\n"));
15031 case C6XABI_Tag_ISA_C62X
:
15034 case C6XABI_Tag_ISA_C67X
:
15037 case C6XABI_Tag_ISA_C67XP
:
15038 printf ("C67x+\n");
15040 case C6XABI_Tag_ISA_C64X
:
15043 case C6XABI_Tag_ISA_C64XP
:
15044 printf ("C64x+\n");
15046 case C6XABI_Tag_ISA_C674X
:
15047 printf ("C674x\n");
15050 printf ("??? (%d)\n", val
);
15055 case Tag_ABI_wchar_t
:
15056 val
= read_uleb128 (p
, &len
, end
);
15058 printf (" Tag_ABI_wchar_t: ");
15062 printf (_("Not used\n"));
15065 printf (_("2 bytes\n"));
15068 printf (_("4 bytes\n"));
15071 printf ("??? (%d)\n", val
);
15076 case Tag_ABI_stack_align_needed
:
15077 val
= read_uleb128 (p
, &len
, end
);
15079 printf (" Tag_ABI_stack_align_needed: ");
15083 printf (_("8-byte\n"));
15086 printf (_("16-byte\n"));
15089 printf ("??? (%d)\n", val
);
15094 case Tag_ABI_stack_align_preserved
:
15095 val
= read_uleb128 (p
, &len
, end
);
15097 printf (" Tag_ABI_stack_align_preserved: ");
15101 printf (_("8-byte\n"));
15104 printf (_("16-byte\n"));
15107 printf ("??? (%d)\n", val
);
15113 val
= read_uleb128 (p
, &len
, end
);
15115 printf (" Tag_ABI_DSBT: ");
15119 printf (_("DSBT addressing not used\n"));
15122 printf (_("DSBT addressing used\n"));
15125 printf ("??? (%d)\n", val
);
15131 val
= read_uleb128 (p
, &len
, end
);
15133 printf (" Tag_ABI_PID: ");
15137 printf (_("Data addressing position-dependent\n"));
15140 printf (_("Data addressing position-independent, GOT near DP\n"));
15143 printf (_("Data addressing position-independent, GOT far from DP\n"));
15146 printf ("??? (%d)\n", val
);
15152 val
= read_uleb128 (p
, &len
, end
);
15154 printf (" Tag_ABI_PIC: ");
15158 printf (_("Code addressing position-dependent\n"));
15161 printf (_("Code addressing position-independent\n"));
15164 printf ("??? (%d)\n", val
);
15169 case Tag_ABI_array_object_alignment
:
15170 val
= read_uleb128 (p
, &len
, end
);
15172 printf (" Tag_ABI_array_object_alignment: ");
15176 printf (_("8-byte\n"));
15179 printf (_("4-byte\n"));
15182 printf (_("16-byte\n"));
15185 printf ("??? (%d)\n", val
);
15190 case Tag_ABI_array_object_align_expected
:
15191 val
= read_uleb128 (p
, &len
, end
);
15193 printf (" Tag_ABI_array_object_align_expected: ");
15197 printf (_("8-byte\n"));
15200 printf (_("4-byte\n"));
15203 printf (_("16-byte\n"));
15206 printf ("??? (%d)\n", val
);
15211 case Tag_ABI_compatibility
:
15213 val
= read_uleb128 (p
, &len
, end
);
15215 printf (" Tag_ABI_compatibility: ");
15216 printf (_("flag = %d, vendor = "), val
);
15219 size_t maxlen
= (end
- p
) - 1;
15221 print_symbol ((int) maxlen
, (const char *) p
);
15222 p
+= strnlen ((char *) p
, maxlen
) + 1;
15226 printf (_("<corrupt>"));
15227 p
= (unsigned char *) end
;
15233 case Tag_ABI_conformance
:
15235 printf (" Tag_ABI_conformance: \"");
15238 size_t maxlen
= (end
- p
) - 1;
15240 print_symbol ((int) maxlen
, (const char *) p
);
15241 p
+= strnlen ((char *) p
, maxlen
) + 1;
15245 printf (_("<corrupt>"));
15246 p
= (unsigned char *) end
;
15253 return display_tag_value (tag
, p
, end
);
15257 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15259 unsigned long addr
= 0;
15260 size_t bytes
= end
- p
;
15267 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15269 printf (" 0x%8.8lx ", addr
);
15271 for (j
= 0; j
< 16; j
++)
15274 printf ("%2.2x", p
[j
]);
15282 for (j
= 0; j
< lbytes
; j
++)
15285 if (k
>= ' ' && k
< 0x7f)
15301 static unsigned char *
15302 display_msp430x_attribute (unsigned char * p
,
15303 const unsigned char * const end
)
15309 tag
= read_uleb128 (p
, & len
, end
);
15314 case OFBA_MSPABI_Tag_ISA
:
15315 val
= read_uleb128 (p
, &len
, end
);
15317 printf (" Tag_ISA: ");
15320 case 0: printf (_("None\n")); break;
15321 case 1: printf (_("MSP430\n")); break;
15322 case 2: printf (_("MSP430X\n")); break;
15323 default: printf ("??? (%d)\n", val
); break;
15327 case OFBA_MSPABI_Tag_Code_Model
:
15328 val
= read_uleb128 (p
, &len
, end
);
15330 printf (" Tag_Code_Model: ");
15333 case 0: printf (_("None\n")); break;
15334 case 1: printf (_("Small\n")); break;
15335 case 2: printf (_("Large\n")); break;
15336 default: printf ("??? (%d)\n", val
); break;
15340 case OFBA_MSPABI_Tag_Data_Model
:
15341 val
= read_uleb128 (p
, &len
, end
);
15343 printf (" Tag_Data_Model: ");
15346 case 0: printf (_("None\n")); break;
15347 case 1: printf (_("Small\n")); break;
15348 case 2: printf (_("Large\n")); break;
15349 case 3: printf (_("Restricted Large\n")); break;
15350 default: printf ("??? (%d)\n", val
); break;
15355 printf (_(" <unknown tag %d>: "), tag
);
15362 size_t maxlen
= (end
- p
) - 1;
15364 print_symbol ((int) maxlen
, (const char *) p
);
15365 p
+= strnlen ((char *) p
, maxlen
) + 1;
15369 printf (_("<corrupt>"));
15370 p
= (unsigned char *) end
;
15376 val
= read_uleb128 (p
, &len
, end
);
15378 printf ("%d (0x%x)\n", val
, val
);
15387 struct riscv_attr_tag_t
{
15392 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15394 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15397 T(priv_spec_minor
),
15398 T(priv_spec_revision
),
15399 T(unaligned_access
),
15404 static unsigned char *
15405 display_riscv_attribute (unsigned char *p
,
15406 const unsigned char * const end
)
15411 struct riscv_attr_tag_t
*attr
= NULL
;
15414 tag
= read_uleb128 (p
, &len
, end
);
15417 /* Find the name of attribute. */
15418 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
15420 if (riscv_attr_tag
[i
].tag
== tag
)
15422 attr
= &riscv_attr_tag
[i
];
15428 printf (" %s: ", attr
->name
);
15430 return display_tag_value (tag
, p
, end
);
15434 case Tag_RISCV_priv_spec
:
15435 case Tag_RISCV_priv_spec_minor
:
15436 case Tag_RISCV_priv_spec_revision
:
15437 val
= read_uleb128 (p
, &len
, end
);
15439 printf (_("%d\n"), val
);
15441 case Tag_RISCV_unaligned_access
:
15442 val
= read_uleb128 (p
, &len
, end
);
15447 printf (_("No unaligned access\n"));
15450 printf (_("Unaligned access\n"));
15454 case Tag_RISCV_stack_align
:
15455 val
= read_uleb128 (p
, &len
, end
);
15457 printf (_("%d-bytes\n"), val
);
15459 case Tag_RISCV_arch
:
15460 p
= display_tag_value (-1, p
, end
);
15463 return display_tag_value (tag
, p
, end
);
15470 process_attributes (Filedata
* filedata
,
15471 const char * public_name
,
15472 unsigned int proc_type
,
15473 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15474 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15476 Elf_Internal_Shdr
* sect
;
15478 bfd_boolean res
= TRUE
;
15480 /* Find the section header so that we get the size. */
15481 for (i
= 0, sect
= filedata
->section_headers
;
15482 i
< filedata
->file_header
.e_shnum
;
15485 unsigned char * contents
;
15488 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15491 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15492 sect
->sh_size
, _("attributes"));
15493 if (contents
== NULL
)
15500 /* The first character is the version of the attributes.
15501 Currently only version 1, (aka 'A') is recognised here. */
15504 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15509 bfd_vma section_len
;
15511 section_len
= sect
->sh_size
- 1;
15514 while (section_len
> 0)
15517 unsigned int namelen
;
15518 bfd_boolean public_section
;
15519 bfd_boolean gnu_section
;
15521 if (section_len
<= 4)
15523 error (_("Tag section ends prematurely\n"));
15527 attr_len
= byte_get (p
, 4);
15530 if (attr_len
> section_len
)
15532 error (_("Bad attribute length (%u > %u)\n"),
15533 (unsigned) attr_len
, (unsigned) section_len
);
15534 attr_len
= section_len
;
15537 /* PR 17531: file: 001-101425-0.004 */
15538 else if (attr_len
< 5)
15540 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15545 section_len
-= attr_len
;
15548 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15549 if (namelen
== 0 || namelen
>= attr_len
)
15551 error (_("Corrupt attribute section name\n"));
15556 printf (_("Attribute Section: "));
15557 print_symbol (INT_MAX
, (const char *) p
);
15560 if (public_name
&& streq ((char *) p
, public_name
))
15561 public_section
= TRUE
;
15563 public_section
= FALSE
;
15565 if (streq ((char *) p
, "gnu"))
15566 gnu_section
= TRUE
;
15568 gnu_section
= FALSE
;
15571 attr_len
-= namelen
;
15573 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15578 unsigned char * end
;
15580 /* PR binutils/17531: Safe handling of corrupt files. */
15583 error (_("Unused bytes at end of section\n"));
15590 size
= byte_get (p
, 4);
15591 if (size
> attr_len
)
15593 error (_("Bad subsection length (%u > %u)\n"),
15594 (unsigned) size
, (unsigned) attr_len
);
15598 /* PR binutils/17531: Safe handling of corrupt files. */
15601 error (_("Bad subsection length (%u < 6)\n"),
15609 end
= p
+ size
- 1;
15610 assert (end
<= contents
+ sect
->sh_size
);
15616 printf (_("File Attributes\n"));
15619 printf (_("Section Attributes:"));
15622 printf (_("Symbol Attributes:"));
15623 /* Fall through. */
15629 val
= read_uleb128 (p
, &j
, end
);
15633 printf (" %d", val
);
15638 printf (_("Unknown tag: %d\n"), tag
);
15639 public_section
= FALSE
;
15643 if (public_section
&& display_pub_attribute
!= NULL
)
15646 p
= display_pub_attribute (p
, end
);
15649 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15652 p
= display_gnu_attribute (p
,
15653 display_proc_gnu_attribute
,
15659 printf (_(" Unknown attribute:\n"));
15660 display_raw_attribute (p
, end
);
15675 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15676 Print the Address, Access and Initial fields of an entry at VMA ADDR
15677 and return the VMA of the next entry, or -1 if there was a problem.
15678 Does not read from DATA_END or beyond. */
15681 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15682 unsigned char * data_end
)
15685 print_vma (addr
, LONG_HEX
);
15687 if (addr
< pltgot
+ 0xfff0)
15688 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15690 printf ("%10s", "");
15693 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15697 unsigned char * from
= data
+ addr
- pltgot
;
15699 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15701 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15702 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15703 return (bfd_vma
) -1;
15707 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15708 print_vma (entry
, LONG_HEX
);
15711 return addr
+ (is_32bit_elf
? 4 : 8);
15714 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15715 PLTGOT. Print the Address and Initial fields of an entry at VMA
15716 ADDR and return the VMA of the next entry. */
15719 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15722 print_vma (addr
, LONG_HEX
);
15725 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15730 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15731 print_vma (entry
, LONG_HEX
);
15733 return addr
+ (is_32bit_elf
? 4 : 8);
15737 print_mips_ases (unsigned int mask
)
15739 if (mask
& AFL_ASE_DSP
)
15740 fputs ("\n\tDSP ASE", stdout
);
15741 if (mask
& AFL_ASE_DSPR2
)
15742 fputs ("\n\tDSP R2 ASE", stdout
);
15743 if (mask
& AFL_ASE_DSPR3
)
15744 fputs ("\n\tDSP R3 ASE", stdout
);
15745 if (mask
& AFL_ASE_EVA
)
15746 fputs ("\n\tEnhanced VA Scheme", stdout
);
15747 if (mask
& AFL_ASE_MCU
)
15748 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15749 if (mask
& AFL_ASE_MDMX
)
15750 fputs ("\n\tMDMX ASE", stdout
);
15751 if (mask
& AFL_ASE_MIPS3D
)
15752 fputs ("\n\tMIPS-3D ASE", stdout
);
15753 if (mask
& AFL_ASE_MT
)
15754 fputs ("\n\tMT ASE", stdout
);
15755 if (mask
& AFL_ASE_SMARTMIPS
)
15756 fputs ("\n\tSmartMIPS ASE", stdout
);
15757 if (mask
& AFL_ASE_VIRT
)
15758 fputs ("\n\tVZ ASE", stdout
);
15759 if (mask
& AFL_ASE_MSA
)
15760 fputs ("\n\tMSA ASE", stdout
);
15761 if (mask
& AFL_ASE_MIPS16
)
15762 fputs ("\n\tMIPS16 ASE", stdout
);
15763 if (mask
& AFL_ASE_MICROMIPS
)
15764 fputs ("\n\tMICROMIPS ASE", stdout
);
15765 if (mask
& AFL_ASE_XPA
)
15766 fputs ("\n\tXPA ASE", stdout
);
15767 if (mask
& AFL_ASE_MIPS16E2
)
15768 fputs ("\n\tMIPS16e2 ASE", stdout
);
15769 if (mask
& AFL_ASE_CRC
)
15770 fputs ("\n\tCRC ASE", stdout
);
15771 if (mask
& AFL_ASE_GINV
)
15772 fputs ("\n\tGINV ASE", stdout
);
15773 if (mask
& AFL_ASE_LOONGSON_MMI
)
15774 fputs ("\n\tLoongson MMI ASE", stdout
);
15775 if (mask
& AFL_ASE_LOONGSON_CAM
)
15776 fputs ("\n\tLoongson CAM ASE", stdout
);
15777 if (mask
& AFL_ASE_LOONGSON_EXT
)
15778 fputs ("\n\tLoongson EXT ASE", stdout
);
15779 if (mask
& AFL_ASE_LOONGSON_EXT2
)
15780 fputs ("\n\tLoongson EXT2 ASE", stdout
);
15782 fprintf (stdout
, "\n\t%s", _("None"));
15783 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15784 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15788 print_mips_isa_ext (unsigned int isa_ext
)
15793 fputs (_("None"), stdout
);
15796 fputs ("RMI XLR", stdout
);
15798 case AFL_EXT_OCTEON3
:
15799 fputs ("Cavium Networks Octeon3", stdout
);
15801 case AFL_EXT_OCTEON2
:
15802 fputs ("Cavium Networks Octeon2", stdout
);
15804 case AFL_EXT_OCTEONP
:
15805 fputs ("Cavium Networks OcteonP", stdout
);
15807 case AFL_EXT_OCTEON
:
15808 fputs ("Cavium Networks Octeon", stdout
);
15811 fputs ("Toshiba R5900", stdout
);
15814 fputs ("MIPS R4650", stdout
);
15817 fputs ("LSI R4010", stdout
);
15820 fputs ("NEC VR4100", stdout
);
15823 fputs ("Toshiba R3900", stdout
);
15825 case AFL_EXT_10000
:
15826 fputs ("MIPS R10000", stdout
);
15829 fputs ("Broadcom SB-1", stdout
);
15832 fputs ("NEC VR4111/VR4181", stdout
);
15835 fputs ("NEC VR4120", stdout
);
15838 fputs ("NEC VR5400", stdout
);
15841 fputs ("NEC VR5500", stdout
);
15843 case AFL_EXT_LOONGSON_2E
:
15844 fputs ("ST Microelectronics Loongson 2E", stdout
);
15846 case AFL_EXT_LOONGSON_2F
:
15847 fputs ("ST Microelectronics Loongson 2F", stdout
);
15849 case AFL_EXT_INTERAPTIV_MR2
:
15850 fputs ("Imagination interAptiv MR2", stdout
);
15853 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15858 get_mips_reg_size (int reg_size
)
15860 return (reg_size
== AFL_REG_NONE
) ? 0
15861 : (reg_size
== AFL_REG_32
) ? 32
15862 : (reg_size
== AFL_REG_64
) ? 64
15863 : (reg_size
== AFL_REG_128
) ? 128
15868 process_mips_specific (Filedata
* filedata
)
15870 Elf_Internal_Dyn
* entry
;
15871 Elf_Internal_Shdr
*sect
= NULL
;
15872 size_t liblist_offset
= 0;
15873 size_t liblistno
= 0;
15874 size_t conflictsno
= 0;
15875 size_t options_offset
= 0;
15876 size_t conflicts_offset
= 0;
15877 size_t pltrelsz
= 0;
15879 bfd_vma pltgot
= 0;
15880 bfd_vma mips_pltgot
= 0;
15881 bfd_vma jmprel
= 0;
15882 bfd_vma local_gotno
= 0;
15883 bfd_vma gotsym
= 0;
15884 bfd_vma symtabno
= 0;
15885 bfd_boolean res
= TRUE
;
15887 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15888 display_mips_gnu_attribute
))
15891 sect
= find_section (filedata
, ".MIPS.abiflags");
15895 Elf_External_ABIFlags_v0
*abiflags_ext
;
15896 Elf_Internal_ABIFlags_v0 abiflags_in
;
15898 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15900 error (_("Corrupt MIPS ABI Flags section.\n"));
15905 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15906 sect
->sh_size
, _("MIPS ABI Flags section"));
15909 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15910 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15911 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15912 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15913 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15914 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15915 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15916 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15917 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15918 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15919 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15921 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15922 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15923 if (abiflags_in
.isa_rev
> 1)
15924 printf ("r%d", abiflags_in
.isa_rev
);
15925 printf ("\nGPR size: %d",
15926 get_mips_reg_size (abiflags_in
.gpr_size
));
15927 printf ("\nCPR1 size: %d",
15928 get_mips_reg_size (abiflags_in
.cpr1_size
));
15929 printf ("\nCPR2 size: %d",
15930 get_mips_reg_size (abiflags_in
.cpr2_size
));
15931 fputs ("\nFP ABI: ", stdout
);
15932 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15933 fputs ("ISA Extension: ", stdout
);
15934 print_mips_isa_ext (abiflags_in
.isa_ext
);
15935 fputs ("\nASEs:", stdout
);
15936 print_mips_ases (abiflags_in
.ases
);
15937 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15938 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15939 fputc ('\n', stdout
);
15940 free (abiflags_ext
);
15945 /* We have a lot of special sections. Thanks SGI! */
15946 if (dynamic_section
== NULL
)
15948 /* No dynamic information available. See if there is static GOT. */
15949 sect
= find_section (filedata
, ".got");
15952 unsigned char *data_end
;
15953 unsigned char *data
;
15957 pltgot
= sect
->sh_addr
;
15960 addr_size
= (is_32bit_elf
? 4 : 8);
15961 end
= pltgot
+ sect
->sh_size
;
15963 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15965 _("Global Offset Table data"));
15966 /* PR 12855: Null data is handled gracefully throughout. */
15967 data_end
= data
+ (end
- pltgot
);
15969 printf (_("\nStatic GOT:\n"));
15970 printf (_(" Canonical gp value: "));
15971 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15974 /* In a dynamic binary GOT[0] is reserved for the dynamic
15975 loader to store the lazy resolver pointer, however in
15976 a static binary it may well have been omitted and GOT
15977 reduced to a table of addresses.
15978 PR 21344: Check for the entry being fully available
15979 before fetching it. */
15981 && data
+ ent
- pltgot
+ addr_size
<= data_end
15982 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15984 printf (_(" Reserved entries:\n"));
15985 printf (_(" %*s %10s %*s\n"),
15986 addr_size
* 2, _("Address"), _("Access"),
15987 addr_size
* 2, _("Value"));
15988 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15990 if (ent
== (bfd_vma
) -1)
15991 goto sgot_print_fail
;
15993 /* Check for the MSB of GOT[1] being set, identifying a
15994 GNU object. This entry will be used by some runtime
15995 loaders, to store the module pointer. Otherwise this
15996 is an ordinary local entry.
15997 PR 21344: Check for the entry being fully available
15998 before fetching it. */
16000 && data
+ ent
- pltgot
+ addr_size
<= data_end
16001 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16002 >> (addr_size
* 8 - 1)) != 0)
16004 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16006 if (ent
== (bfd_vma
) -1)
16007 goto sgot_print_fail
;
16012 if (data
!= NULL
&& ent
< end
)
16014 printf (_(" Local entries:\n"));
16015 printf (" %*s %10s %*s\n",
16016 addr_size
* 2, _("Address"), _("Access"),
16017 addr_size
* 2, _("Value"));
16020 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16022 if (ent
== (bfd_vma
) -1)
16023 goto sgot_print_fail
;
16035 for (entry
= dynamic_section
;
16036 /* PR 17531 file: 012-50589-0.004. */
16037 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16039 switch (entry
->d_tag
)
16041 case DT_MIPS_LIBLIST
:
16043 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16044 liblistno
* sizeof (Elf32_External_Lib
));
16046 case DT_MIPS_LIBLISTNO
:
16047 liblistno
= entry
->d_un
.d_val
;
16049 case DT_MIPS_OPTIONS
:
16050 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16052 case DT_MIPS_CONFLICT
:
16054 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16055 conflictsno
* sizeof (Elf32_External_Conflict
));
16057 case DT_MIPS_CONFLICTNO
:
16058 conflictsno
= entry
->d_un
.d_val
;
16061 pltgot
= entry
->d_un
.d_ptr
;
16063 case DT_MIPS_LOCAL_GOTNO
:
16064 local_gotno
= entry
->d_un
.d_val
;
16066 case DT_MIPS_GOTSYM
:
16067 gotsym
= entry
->d_un
.d_val
;
16069 case DT_MIPS_SYMTABNO
:
16070 symtabno
= entry
->d_un
.d_val
;
16072 case DT_MIPS_PLTGOT
:
16073 mips_pltgot
= entry
->d_un
.d_ptr
;
16076 pltrel
= entry
->d_un
.d_val
;
16079 pltrelsz
= entry
->d_un
.d_val
;
16082 jmprel
= entry
->d_un
.d_ptr
;
16088 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16090 Elf32_External_Lib
* elib
;
16093 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16095 sizeof (Elf32_External_Lib
),
16096 _("liblist section data"));
16099 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16100 "\nSection '.liblist' contains %lu entries:\n",
16101 (unsigned long) liblistno
),
16102 (unsigned long) liblistno
);
16103 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16106 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16113 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16114 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16115 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16116 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16117 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16119 tmp
= gmtime (&atime
);
16120 snprintf (timebuf
, sizeof (timebuf
),
16121 "%04u-%02u-%02uT%02u:%02u:%02u",
16122 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16123 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16125 printf ("%3lu: ", (unsigned long) cnt
);
16126 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16127 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16129 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16130 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16131 liblist
.l_version
);
16133 if (liblist
.l_flags
== 0)
16137 static const struct
16144 { " EXACT_MATCH", LL_EXACT_MATCH
},
16145 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16146 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16147 { " EXPORTS", LL_EXPORTS
},
16148 { " DELAY_LOAD", LL_DELAY_LOAD
},
16149 { " DELTA", LL_DELTA
}
16151 int flags
= liblist
.l_flags
;
16154 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16155 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16157 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16158 flags
^= l_flags_vals
[fcnt
].bit
;
16161 printf (" %#x", (unsigned int) flags
);
16173 if (options_offset
!= 0)
16175 Elf_External_Options
* eopt
;
16176 Elf_Internal_Options
* iopt
;
16177 Elf_Internal_Options
* option
;
16180 sect
= filedata
->section_headers
;
16182 /* Find the section header so that we get the size. */
16183 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16184 /* PR 17533 file: 012-277276-0.004. */
16187 error (_("No MIPS_OPTIONS header found\n"));
16191 if (sect
->sh_size
< sizeof (* eopt
))
16193 error (_("The MIPS options section is too small.\n"));
16197 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16198 sect
->sh_size
, _("options"));
16201 iopt
= (Elf_Internal_Options
*)
16202 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16205 error (_("Out of memory allocating space for MIPS options\n"));
16212 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16214 Elf_External_Options
* eoption
;
16216 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16218 option
->kind
= BYTE_GET (eoption
->kind
);
16219 option
->size
= BYTE_GET (eoption
->size
);
16220 option
->section
= BYTE_GET (eoption
->section
);
16221 option
->info
= BYTE_GET (eoption
->info
);
16223 /* PR 17531: file: ffa0fa3b. */
16224 if (option
->size
< sizeof (* eopt
)
16225 || offset
+ option
->size
> sect
->sh_size
)
16227 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16230 offset
+= option
->size
;
16236 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16237 "\nSection '%s' contains %d entries:\n",
16239 printable_section_name (filedata
, sect
), cnt
);
16248 switch (option
->kind
)
16251 /* This shouldn't happen. */
16252 printf (" NULL %d %lx", option
->section
, option
->info
);
16255 printf (" REGINFO ");
16256 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16259 Elf32_External_RegInfo
* ereg
;
16260 Elf32_RegInfo reginfo
;
16262 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16263 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16264 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16265 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16266 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16267 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16268 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16270 printf ("GPR %08lx GP 0x%lx\n",
16271 reginfo
.ri_gprmask
,
16272 (unsigned long) reginfo
.ri_gp_value
);
16273 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16274 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16275 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16280 Elf64_External_RegInfo
* ereg
;
16281 Elf64_Internal_RegInfo reginfo
;
16283 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16284 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16285 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16286 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16287 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16288 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16289 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16291 printf ("GPR %08lx GP 0x",
16292 reginfo
.ri_gprmask
);
16293 printf_vma (reginfo
.ri_gp_value
);
16296 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16297 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16298 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16302 case ODK_EXCEPTIONS
:
16303 fputs (" EXCEPTIONS fpe_min(", stdout
);
16304 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16305 fputs (") fpe_max(", stdout
);
16306 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16307 fputs (")", stdout
);
16309 if (option
->info
& OEX_PAGE0
)
16310 fputs (" PAGE0", stdout
);
16311 if (option
->info
& OEX_SMM
)
16312 fputs (" SMM", stdout
);
16313 if (option
->info
& OEX_FPDBUG
)
16314 fputs (" FPDBUG", stdout
);
16315 if (option
->info
& OEX_DISMISS
)
16316 fputs (" DISMISS", stdout
);
16319 fputs (" PAD ", stdout
);
16320 if (option
->info
& OPAD_PREFIX
)
16321 fputs (" PREFIX", stdout
);
16322 if (option
->info
& OPAD_POSTFIX
)
16323 fputs (" POSTFIX", stdout
);
16324 if (option
->info
& OPAD_SYMBOL
)
16325 fputs (" SYMBOL", stdout
);
16328 fputs (" HWPATCH ", stdout
);
16329 if (option
->info
& OHW_R4KEOP
)
16330 fputs (" R4KEOP", stdout
);
16331 if (option
->info
& OHW_R8KPFETCH
)
16332 fputs (" R8KPFETCH", stdout
);
16333 if (option
->info
& OHW_R5KEOP
)
16334 fputs (" R5KEOP", stdout
);
16335 if (option
->info
& OHW_R5KCVTL
)
16336 fputs (" R5KCVTL", stdout
);
16339 fputs (" FILL ", stdout
);
16340 /* XXX Print content of info word? */
16343 fputs (" TAGS ", stdout
);
16344 /* XXX Print content of info word? */
16347 fputs (" HWAND ", stdout
);
16348 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16349 fputs (" R4KEOP_CHECKED", stdout
);
16350 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16351 fputs (" R4KEOP_CLEAN", stdout
);
16354 fputs (" HWOR ", stdout
);
16355 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16356 fputs (" R4KEOP_CHECKED", stdout
);
16357 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16358 fputs (" R4KEOP_CLEAN", stdout
);
16361 printf (" GP_GROUP %#06lx self-contained %#06lx",
16362 option
->info
& OGP_GROUP
,
16363 (option
->info
& OGP_SELF
) >> 16);
16366 printf (" IDENT %#06lx self-contained %#06lx",
16367 option
->info
& OGP_GROUP
,
16368 (option
->info
& OGP_SELF
) >> 16);
16371 /* This shouldn't happen. */
16372 printf (" %3d ??? %d %lx",
16373 option
->kind
, option
->section
, option
->info
);
16377 len
= sizeof (* eopt
);
16378 while (len
< option
->size
)
16380 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16382 if (ISPRINT (datum
))
16383 printf ("%c", datum
);
16385 printf ("\\%03o", datum
);
16388 fputs ("\n", stdout
);
16390 offset
+= option
->size
;
16400 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16402 Elf32_Conflict
* iconf
;
16405 if (dynamic_symbols
== NULL
)
16407 error (_("conflict list found without a dynamic symbol table\n"));
16411 /* PR 21345 - print a slightly more helpful error message
16412 if we are sure that the cmalloc will fail. */
16413 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16415 error (_("Overlarge number of conflicts detected: %lx\n"),
16416 (long) conflictsno
);
16420 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16423 error (_("Out of memory allocating space for dynamic conflicts\n"));
16429 Elf32_External_Conflict
* econf32
;
16431 econf32
= (Elf32_External_Conflict
*)
16432 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16433 sizeof (* econf32
), _("conflict"));
16437 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16438 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16444 Elf64_External_Conflict
* econf64
;
16446 econf64
= (Elf64_External_Conflict
*)
16447 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16448 sizeof (* econf64
), _("conflict"));
16452 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16453 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16458 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16459 "\nSection '.conflict' contains %lu entries:\n",
16460 (unsigned long) conflictsno
),
16461 (unsigned long) conflictsno
);
16462 puts (_(" Num: Index Value Name"));
16464 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16466 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16468 if (iconf
[cnt
] >= num_dynamic_syms
)
16469 printf (_("<corrupt symbol index>"));
16472 Elf_Internal_Sym
* psym
;
16474 psym
= & dynamic_symbols
[iconf
[cnt
]];
16475 print_vma (psym
->st_value
, FULL_HEX
);
16477 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16478 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16480 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16488 if (pltgot
!= 0 && local_gotno
!= 0)
16490 bfd_vma ent
, local_end
, global_end
;
16492 unsigned char * data
;
16493 unsigned char * data_end
;
16497 addr_size
= (is_32bit_elf
? 4 : 8);
16498 local_end
= pltgot
+ local_gotno
* addr_size
;
16500 /* PR binutils/17533 file: 012-111227-0.004 */
16501 if (symtabno
< gotsym
)
16503 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16504 (unsigned long) gotsym
, (unsigned long) symtabno
);
16508 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16509 /* PR 17531: file: 54c91a34. */
16510 if (global_end
< local_end
)
16512 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16516 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16517 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16518 global_end
- pltgot
, 1,
16519 _("Global Offset Table data"));
16520 /* PR 12855: Null data is handled gracefully throughout. */
16521 data_end
= data
+ (global_end
- pltgot
);
16523 printf (_("\nPrimary GOT:\n"));
16524 printf (_(" Canonical gp value: "));
16525 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16528 printf (_(" Reserved entries:\n"));
16529 printf (_(" %*s %10s %*s Purpose\n"),
16530 addr_size
* 2, _("Address"), _("Access"),
16531 addr_size
* 2, _("Initial"));
16532 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16533 printf (_(" Lazy resolver\n"));
16534 if (ent
== (bfd_vma
) -1)
16535 goto got_print_fail
;
16537 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16538 This entry will be used by some runtime loaders, to store the
16539 module pointer. Otherwise this is an ordinary local entry.
16540 PR 21344: Check for the entry being fully available before
16543 && data
+ ent
- pltgot
+ addr_size
<= data_end
16544 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16545 >> (addr_size
* 8 - 1)) != 0)
16547 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16548 printf (_(" Module pointer (GNU extension)\n"));
16549 if (ent
== (bfd_vma
) -1)
16550 goto got_print_fail
;
16554 if (data
!= NULL
&& ent
< local_end
)
16556 printf (_(" Local entries:\n"));
16557 printf (" %*s %10s %*s\n",
16558 addr_size
* 2, _("Address"), _("Access"),
16559 addr_size
* 2, _("Initial"));
16560 while (ent
< local_end
)
16562 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16564 if (ent
== (bfd_vma
) -1)
16565 goto got_print_fail
;
16570 if (data
!= NULL
&& gotsym
< symtabno
)
16574 printf (_(" Global entries:\n"));
16575 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16576 addr_size
* 2, _("Address"),
16578 addr_size
* 2, _("Initial"),
16579 addr_size
* 2, _("Sym.Val."),
16581 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16582 _("Ndx"), _("Name"));
16584 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16586 for (i
= gotsym
; i
< symtabno
; i
++)
16588 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16591 if (dynamic_symbols
== NULL
)
16592 printf (_("<no dynamic symbols>"));
16593 else if (i
< num_dynamic_syms
)
16595 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16597 print_vma (psym
->st_value
, LONG_HEX
);
16598 printf (" %-7s %3s ",
16599 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16600 get_symbol_index_type (filedata
, psym
->st_shndx
));
16602 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16603 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16605 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16608 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16609 (unsigned long) i
);
16612 if (ent
== (bfd_vma
) -1)
16623 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16626 size_t offset
, rel_offset
;
16627 unsigned long count
, i
;
16628 unsigned char * data
;
16629 int addr_size
, sym_width
;
16630 Elf_Internal_Rela
* rels
;
16632 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16633 if (pltrel
== DT_RELA
)
16635 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16640 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16645 addr_size
= (is_32bit_elf
? 4 : 8);
16646 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16648 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16649 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16650 1, _("Procedure Linkage Table data"));
16654 printf ("\nPLT GOT:\n\n");
16655 printf (_(" Reserved entries:\n"));
16656 printf (_(" %*s %*s Purpose\n"),
16657 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16658 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16659 printf (_(" PLT lazy resolver\n"));
16660 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16661 printf (_(" Module pointer\n"));
16664 printf (_(" Entries:\n"));
16665 printf (" %*s %*s %*s %-7s %3s %s\n",
16666 addr_size
* 2, _("Address"),
16667 addr_size
* 2, _("Initial"),
16668 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16669 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16670 for (i
= 0; i
< count
; i
++)
16672 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16674 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16677 if (idx
>= num_dynamic_syms
)
16678 printf (_("<corrupt symbol index: %lu>"), idx
);
16681 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16683 print_vma (psym
->st_value
, LONG_HEX
);
16684 printf (" %-7s %3s ",
16685 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16686 get_symbol_index_type (filedata
, psym
->st_shndx
));
16687 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16688 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16690 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16705 process_nds32_specific (Filedata
* filedata
)
16707 Elf_Internal_Shdr
*sect
= NULL
;
16709 sect
= find_section (filedata
, ".nds32_e_flags");
16712 unsigned int *flag
;
16714 printf ("\nNDS32 elf flags section:\n");
16715 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16716 sect
->sh_size
, _("NDS32 elf flags section"));
16721 switch ((*flag
) & 0x3)
16724 printf ("(VEC_SIZE):\tNo entry.\n");
16727 printf ("(VEC_SIZE):\t4 bytes\n");
16730 printf ("(VEC_SIZE):\t16 bytes\n");
16733 printf ("(VEC_SIZE):\treserved\n");
16742 process_gnu_liblist (Filedata
* filedata
)
16744 Elf_Internal_Shdr
* section
;
16745 Elf_Internal_Shdr
* string_sec
;
16746 Elf32_External_Lib
* elib
;
16748 size_t strtab_size
;
16750 unsigned long num_liblist
;
16752 bfd_boolean res
= TRUE
;
16757 for (i
= 0, section
= filedata
->section_headers
;
16758 i
< filedata
->file_header
.e_shnum
;
16761 switch (section
->sh_type
)
16763 case SHT_GNU_LIBLIST
:
16764 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16767 elib
= (Elf32_External_Lib
*)
16768 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16769 _("liblist section data"));
16777 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16778 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16779 string_sec
->sh_size
,
16780 _("liblist string table"));
16782 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16789 strtab_size
= string_sec
->sh_size
;
16791 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16792 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16793 "\nLibrary list section '%s' contains %lu entries:\n",
16795 printable_section_name (filedata
, section
),
16798 puts (_(" Library Time Stamp Checksum Version Flags"));
16800 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16808 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16809 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16810 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16811 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16812 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16814 tmp
= gmtime (&atime
);
16815 snprintf (timebuf
, sizeof (timebuf
),
16816 "%04u-%02u-%02uT%02u:%02u:%02u",
16817 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16818 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16820 printf ("%3lu: ", (unsigned long) cnt
);
16822 printf ("%-20s", liblist
.l_name
< strtab_size
16823 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16825 printf ("%-20.20s", liblist
.l_name
< strtab_size
16826 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16827 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16828 liblist
.l_version
, liblist
.l_flags
);
16839 static const char *
16840 get_note_type (Filedata
* filedata
, unsigned e_type
)
16842 static char buff
[64];
16844 if (filedata
->file_header
.e_type
== ET_CORE
)
16848 return _("NT_AUXV (auxiliary vector)");
16850 return _("NT_PRSTATUS (prstatus structure)");
16852 return _("NT_FPREGSET (floating point registers)");
16854 return _("NT_PRPSINFO (prpsinfo structure)");
16855 case NT_TASKSTRUCT
:
16856 return _("NT_TASKSTRUCT (task structure)");
16858 return _("NT_PRXFPREG (user_xfpregs structure)");
16860 return _("NT_PPC_VMX (ppc Altivec registers)");
16862 return _("NT_PPC_VSX (ppc VSX registers)");
16864 return _("NT_PPC_TAR (ppc TAR register)");
16866 return _("NT_PPC_PPR (ppc PPR register)");
16868 return _("NT_PPC_DSCR (ppc DSCR register)");
16870 return _("NT_PPC_EBB (ppc EBB registers)");
16872 return _("NT_PPC_PMU (ppc PMU registers)");
16873 case NT_PPC_TM_CGPR
:
16874 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16875 case NT_PPC_TM_CFPR
:
16876 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16877 case NT_PPC_TM_CVMX
:
16878 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16879 case NT_PPC_TM_CVSX
:
16880 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16881 case NT_PPC_TM_SPR
:
16882 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16883 case NT_PPC_TM_CTAR
:
16884 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16885 case NT_PPC_TM_CPPR
:
16886 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16887 case NT_PPC_TM_CDSCR
:
16888 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16890 return _("NT_386_TLS (x86 TLS information)");
16891 case NT_386_IOPERM
:
16892 return _("NT_386_IOPERM (x86 I/O permissions)");
16893 case NT_X86_XSTATE
:
16894 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16895 case NT_S390_HIGH_GPRS
:
16896 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16897 case NT_S390_TIMER
:
16898 return _("NT_S390_TIMER (s390 timer register)");
16899 case NT_S390_TODCMP
:
16900 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16901 case NT_S390_TODPREG
:
16902 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16904 return _("NT_S390_CTRS (s390 control registers)");
16905 case NT_S390_PREFIX
:
16906 return _("NT_S390_PREFIX (s390 prefix register)");
16907 case NT_S390_LAST_BREAK
:
16908 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16909 case NT_S390_SYSTEM_CALL
:
16910 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16912 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16913 case NT_S390_VXRS_LOW
:
16914 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16915 case NT_S390_VXRS_HIGH
:
16916 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16917 case NT_S390_GS_CB
:
16918 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16919 case NT_S390_GS_BC
:
16920 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16922 return _("NT_ARM_VFP (arm VFP registers)");
16924 return _("NT_ARM_TLS (AArch TLS registers)");
16925 case NT_ARM_HW_BREAK
:
16926 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16927 case NT_ARM_HW_WATCH
:
16928 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16930 return _("NT_PSTATUS (pstatus structure)");
16932 return _("NT_FPREGS (floating point registers)");
16934 return _("NT_PSINFO (psinfo structure)");
16936 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16938 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16939 case NT_WIN32PSTATUS
:
16940 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16942 return _("NT_SIGINFO (siginfo_t data)");
16944 return _("NT_FILE (mapped files)");
16952 return _("NT_VERSION (version)");
16954 return _("NT_ARCH (architecture)");
16955 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16957 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16963 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16968 print_core_note (Elf_Internal_Note
*pnote
)
16970 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16971 bfd_vma count
, page_size
;
16972 unsigned char *descdata
, *filenames
, *descend
;
16974 if (pnote
->type
!= NT_FILE
)
16984 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16985 /* Still "successful". */
16990 if (pnote
->descsz
< 2 * addr_size
)
16992 error (_(" Malformed note - too short for header\n"));
16996 descdata
= (unsigned char *) pnote
->descdata
;
16997 descend
= descdata
+ pnote
->descsz
;
16999 if (descdata
[pnote
->descsz
- 1] != '\0')
17001 error (_(" Malformed note - does not end with \\0\n"));
17005 count
= byte_get (descdata
, addr_size
);
17006 descdata
+= addr_size
;
17008 page_size
= byte_get (descdata
, addr_size
);
17009 descdata
+= addr_size
;
17011 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17012 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17014 error (_(" Malformed note - too short for supplied file count\n"));
17018 printf (_(" Page size: "));
17019 print_vma (page_size
, DEC
);
17022 printf (_(" %*s%*s%*s\n"),
17023 (int) (2 + 2 * addr_size
), _("Start"),
17024 (int) (4 + 2 * addr_size
), _("End"),
17025 (int) (4 + 2 * addr_size
), _("Page Offset"));
17026 filenames
= descdata
+ count
* 3 * addr_size
;
17027 while (count
-- > 0)
17029 bfd_vma start
, end
, file_ofs
;
17031 if (filenames
== descend
)
17033 error (_(" Malformed note - filenames end too early\n"));
17037 start
= byte_get (descdata
, addr_size
);
17038 descdata
+= addr_size
;
17039 end
= byte_get (descdata
, addr_size
);
17040 descdata
+= addr_size
;
17041 file_ofs
= byte_get (descdata
, addr_size
);
17042 descdata
+= addr_size
;
17045 print_vma (start
, FULL_HEX
);
17047 print_vma (end
, FULL_HEX
);
17049 print_vma (file_ofs
, FULL_HEX
);
17050 printf ("\n %s\n", filenames
);
17052 filenames
+= 1 + strlen ((char *) filenames
);
17058 static const char *
17059 get_gnu_elf_note_type (unsigned e_type
)
17061 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17064 case NT_GNU_ABI_TAG
:
17065 return _("NT_GNU_ABI_TAG (ABI version tag)");
17067 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17068 case NT_GNU_BUILD_ID
:
17069 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17070 case NT_GNU_GOLD_VERSION
:
17071 return _("NT_GNU_GOLD_VERSION (gold version)");
17072 case NT_GNU_PROPERTY_TYPE_0
:
17073 return _("NT_GNU_PROPERTY_TYPE_0");
17074 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17075 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17076 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17077 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17080 static char buff
[64];
17082 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17089 decode_x86_compat_isa (unsigned int bitmask
)
17093 unsigned int bit
= bitmask
& (- bitmask
);
17098 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17101 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17104 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17107 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17110 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17113 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17116 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17119 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17122 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17125 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17128 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17131 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17132 printf ("AVX512F");
17134 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17135 printf ("AVX512CD");
17137 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17138 printf ("AVX512ER");
17140 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17141 printf ("AVX512PF");
17143 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17144 printf ("AVX512VL");
17146 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17147 printf ("AVX512DQ");
17149 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17150 printf ("AVX512BW");
17153 printf (_("<unknown: %x>"), bit
);
17162 decode_x86_isa (unsigned int bitmask
)
17166 printf (_("<None>"));
17172 unsigned int bit
= bitmask
& (- bitmask
);
17177 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17180 case GNU_PROPERTY_X86_ISA_1_SSE
:
17183 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17186 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17189 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17192 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17195 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17198 case GNU_PROPERTY_X86_ISA_1_AVX
:
17201 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17204 case GNU_PROPERTY_X86_ISA_1_FMA
:
17207 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17208 printf ("AVX512F");
17210 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17211 printf ("AVX512CD");
17213 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17214 printf ("AVX512ER");
17216 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17217 printf ("AVX512PF");
17219 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17220 printf ("AVX512VL");
17222 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17223 printf ("AVX512DQ");
17225 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17226 printf ("AVX512BW");
17228 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17229 printf ("AVX512_4FMAPS");
17231 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17232 printf ("AVX512_4VNNIW");
17234 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17235 printf ("AVX512_BITALG");
17237 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17238 printf ("AVX512_IFMA");
17240 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17241 printf ("AVX512_VBMI");
17243 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17244 printf ("AVX512_VBMI2");
17246 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17247 printf ("AVX512_VNNI");
17250 printf (_("<unknown: %x>"), bit
);
17259 decode_x86_feature_1 (unsigned int bitmask
)
17263 printf (_("<None>"));
17269 unsigned int bit
= bitmask
& (- bitmask
);
17274 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17277 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17281 printf (_("<unknown: %x>"), bit
);
17290 decode_x86_feature_2 (unsigned int bitmask
)
17294 printf (_("<None>"));
17300 unsigned int bit
= bitmask
& (- bitmask
);
17305 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17308 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17311 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17314 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17317 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17320 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17323 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17326 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17329 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17330 printf ("XSAVEOPT");
17332 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17336 printf (_("<unknown: %x>"), bit
);
17345 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17347 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17348 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17349 unsigned int size
= is_32bit_elf
? 4 : 8;
17351 printf (_(" Properties: "));
17353 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17355 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17359 while (ptr
< ptr_end
)
17363 unsigned int datasz
;
17365 if ((size_t) (ptr_end
- ptr
) < 8)
17367 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17371 type
= byte_get (ptr
, 4);
17372 datasz
= byte_get (ptr
+ 4, 4);
17376 if (datasz
> (size_t) (ptr_end
- ptr
))
17378 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17383 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17385 if (filedata
->file_header
.e_machine
== EM_X86_64
17386 || filedata
->file_header
.e_machine
== EM_IAMCU
17387 || filedata
->file_header
.e_machine
== EM_386
)
17389 unsigned int bitmask
;
17392 bitmask
= byte_get (ptr
, 4);
17398 case GNU_PROPERTY_X86_ISA_1_USED
:
17400 printf (_("x86 ISA used: <corrupt length: %#x> "),
17404 printf ("x86 ISA used: ");
17405 decode_x86_isa (bitmask
);
17409 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17411 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17415 printf ("x86 ISA needed: ");
17416 decode_x86_isa (bitmask
);
17420 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17422 printf (_("x86 feature: <corrupt length: %#x> "),
17426 printf ("x86 feature: ");
17427 decode_x86_feature_1 (bitmask
);
17431 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17433 printf (_("x86 feature used: <corrupt length: %#x> "),
17437 printf ("x86 feature used: ");
17438 decode_x86_feature_2 (bitmask
);
17442 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17444 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17447 printf ("x86 feature needed: ");
17448 decode_x86_feature_2 (bitmask
);
17452 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17454 printf (_("x86 ISA used: <corrupt length: %#x> "),
17458 printf ("x86 ISA used: ");
17459 decode_x86_compat_isa (bitmask
);
17463 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
17465 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17469 printf ("x86 ISA needed: ");
17470 decode_x86_compat_isa (bitmask
);
17483 case GNU_PROPERTY_STACK_SIZE
:
17484 printf (_("stack size: "));
17485 if (datasz
!= size
)
17486 printf (_("<corrupt length: %#x> "), datasz
);
17488 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17491 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17492 printf ("no copy on protected ");
17494 printf (_("<corrupt length: %#x> "), datasz
);
17502 if (type
< GNU_PROPERTY_LOPROC
)
17503 printf (_("<unknown type %#x data: "), type
);
17504 else if (type
< GNU_PROPERTY_LOUSER
)
17505 printf (_("<procesor-specific type %#x data: "), type
);
17507 printf (_("<application-specific type %#x data: "), type
);
17508 for (j
= 0; j
< datasz
; ++j
)
17509 printf ("%02x ", ptr
[j
] & 0xff);
17513 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17514 if (ptr
== ptr_end
)
17527 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17529 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17530 switch (pnote
->type
)
17532 case NT_GNU_BUILD_ID
:
17536 printf (_(" Build ID: "));
17537 for (i
= 0; i
< pnote
->descsz
; ++i
)
17538 printf ("%02x", pnote
->descdata
[i
] & 0xff);
17543 case NT_GNU_ABI_TAG
:
17545 unsigned long os
, major
, minor
, subminor
;
17546 const char *osname
;
17548 /* PR 17531: file: 030-599401-0.004. */
17549 if (pnote
->descsz
< 16)
17551 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17555 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17556 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17557 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
17558 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
17562 case GNU_ABI_TAG_LINUX
:
17565 case GNU_ABI_TAG_HURD
:
17568 case GNU_ABI_TAG_SOLARIS
:
17569 osname
= "Solaris";
17571 case GNU_ABI_TAG_FREEBSD
:
17572 osname
= "FreeBSD";
17574 case GNU_ABI_TAG_NETBSD
:
17577 case GNU_ABI_TAG_SYLLABLE
:
17578 osname
= "Syllable";
17580 case GNU_ABI_TAG_NACL
:
17584 osname
= "Unknown";
17588 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17589 major
, minor
, subminor
);
17593 case NT_GNU_GOLD_VERSION
:
17597 printf (_(" Version: "));
17598 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17599 printf ("%c", pnote
->descdata
[i
]);
17606 unsigned long num_entries
, mask
;
17608 /* Hardware capabilities information. Word 0 is the number of entries.
17609 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17610 is a series of entries, where each entry is a single byte followed
17611 by a nul terminated string. The byte gives the bit number to test
17612 if enabled in the bitmask. */
17613 printf (_(" Hardware Capabilities: "));
17614 if (pnote
->descsz
< 8)
17616 error (_("<corrupt GNU_HWCAP>\n"));
17619 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17620 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17621 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17622 /* FIXME: Add code to display the entries... */
17626 case NT_GNU_PROPERTY_TYPE_0
:
17627 print_gnu_property_note (filedata
, pnote
);
17631 /* Handle unrecognised types. An error message should have already been
17632 created by get_gnu_elf_note_type(), so all that we need to do is to
17633 display the data. */
17637 printf (_(" Description data: "));
17638 for (i
= 0; i
< pnote
->descsz
; ++i
)
17639 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17648 static const char *
17649 get_v850_elf_note_type (enum v850_notes n_type
)
17651 static char buff
[64];
17655 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17656 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17657 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17658 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17659 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17660 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17662 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17668 print_v850_note (Elf_Internal_Note
* pnote
)
17672 if (pnote
->descsz
!= 4)
17675 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17679 printf (_("not set\n"));
17683 switch (pnote
->type
)
17685 case V850_NOTE_ALIGNMENT
:
17688 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17689 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17693 case V850_NOTE_DATA_SIZE
:
17696 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17697 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17701 case V850_NOTE_FPU_INFO
:
17704 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17705 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17709 case V850_NOTE_MMU_INFO
:
17710 case V850_NOTE_CACHE_INFO
:
17711 case V850_NOTE_SIMD_INFO
:
17712 if (val
== EF_RH850_SIMD
)
17714 printf (_("yes\n"));
17720 /* An 'unknown note type' message will already have been displayed. */
17724 printf (_("unknown value: %x\n"), val
);
17729 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17731 unsigned int version
;
17733 switch (pnote
->type
)
17735 case NT_NETBSD_IDENT
:
17736 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17737 if ((version
/ 10000) % 100)
17738 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17739 version
, version
/ 100000000, (version
/ 1000000) % 100,
17740 (version
/ 10000) % 100 > 26 ? "Z" : "",
17741 'A' + (version
/ 10000) % 26);
17743 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17744 version
, version
/ 100000000, (version
/ 1000000) % 100,
17745 (version
/ 100) % 100);
17748 case NT_NETBSD_MARCH
:
17749 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17754 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17760 static const char *
17761 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17765 case NT_FREEBSD_THRMISC
:
17766 return _("NT_THRMISC (thrmisc structure)");
17767 case NT_FREEBSD_PROCSTAT_PROC
:
17768 return _("NT_PROCSTAT_PROC (proc data)");
17769 case NT_FREEBSD_PROCSTAT_FILES
:
17770 return _("NT_PROCSTAT_FILES (files data)");
17771 case NT_FREEBSD_PROCSTAT_VMMAP
:
17772 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17773 case NT_FREEBSD_PROCSTAT_GROUPS
:
17774 return _("NT_PROCSTAT_GROUPS (groups data)");
17775 case NT_FREEBSD_PROCSTAT_UMASK
:
17776 return _("NT_PROCSTAT_UMASK (umask data)");
17777 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17778 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17779 case NT_FREEBSD_PROCSTAT_OSREL
:
17780 return _("NT_PROCSTAT_OSREL (osreldate data)");
17781 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17782 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17783 case NT_FREEBSD_PROCSTAT_AUXV
:
17784 return _("NT_PROCSTAT_AUXV (auxv data)");
17785 case NT_FREEBSD_PTLWPINFO
:
17786 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17788 return get_note_type (filedata
, e_type
);
17791 static const char *
17792 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17794 static char buff
[64];
17796 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17797 return _("NetBSD procinfo structure");
17799 /* As of Jan 2002 there are no other machine-independent notes
17800 defined for NetBSD core files. If the note type is less
17801 than the start of the machine-dependent note types, we don't
17804 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17806 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17810 switch (filedata
->file_header
.e_machine
)
17812 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17813 and PT_GETFPREGS == mach+2. */
17818 case EM_SPARC32PLUS
:
17822 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17823 return _("PT_GETREGS (reg structure)");
17824 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17825 return _("PT_GETFPREGS (fpreg structure)");
17831 /* On all other arch's, PT_GETREGS == mach+1 and
17832 PT_GETFPREGS == mach+3. */
17836 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17837 return _("PT_GETREGS (reg structure)");
17838 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17839 return _("PT_GETFPREGS (fpreg structure)");
17845 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17846 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17850 static const char *
17851 get_stapsdt_note_type (unsigned e_type
)
17853 static char buff
[64];
17858 return _("NT_STAPSDT (SystemTap probe descriptors)");
17864 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17869 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17871 size_t len
, maxlen
;
17872 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
17873 char *data
= pnote
->descdata
;
17874 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17875 bfd_vma pc
, base_addr
, semaphore
;
17876 char *provider
, *probe
, *arg_fmt
;
17878 if (pnote
->descsz
< (addr_size
* 3))
17879 goto stapdt_note_too_small
;
17881 pc
= byte_get ((unsigned char *) data
, addr_size
);
17884 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17887 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17890 if (data
>= data_end
)
17891 goto stapdt_note_too_small
;
17892 maxlen
= data_end
- data
;
17893 len
= strnlen (data
, maxlen
);
17900 goto stapdt_note_too_small
;
17902 if (data
>= data_end
)
17903 goto stapdt_note_too_small
;
17904 maxlen
= data_end
- data
;
17905 len
= strnlen (data
, maxlen
);
17912 goto stapdt_note_too_small
;
17914 if (data
>= data_end
)
17915 goto stapdt_note_too_small
;
17916 maxlen
= data_end
- data
;
17917 len
= strnlen (data
, maxlen
);
17924 goto stapdt_note_too_small
;
17926 printf (_(" Provider: %s\n"), provider
);
17927 printf (_(" Name: %s\n"), probe
);
17928 printf (_(" Location: "));
17929 print_vma (pc
, FULL_HEX
);
17930 printf (_(", Base: "));
17931 print_vma (base_addr
, FULL_HEX
);
17932 printf (_(", Semaphore: "));
17933 print_vma (semaphore
, FULL_HEX
);
17935 printf (_(" Arguments: %s\n"), arg_fmt
);
17937 return data
== data_end
;
17939 stapdt_note_too_small
:
17940 printf (_(" <corrupt - note is too small>\n"));
17941 error (_("corrupt stapdt note - the data size is too small\n"));
17945 static const char *
17946 get_ia64_vms_note_type (unsigned e_type
)
17948 static char buff
[64];
17953 return _("NT_VMS_MHD (module header)");
17955 return _("NT_VMS_LNM (language name)");
17957 return _("NT_VMS_SRC (source files)");
17959 return "NT_VMS_TITLE";
17961 return _("NT_VMS_EIDC (consistency check)");
17962 case NT_VMS_FPMODE
:
17963 return _("NT_VMS_FPMODE (FP mode)");
17964 case NT_VMS_LINKTIME
:
17965 return "NT_VMS_LINKTIME";
17966 case NT_VMS_IMGNAM
:
17967 return _("NT_VMS_IMGNAM (image name)");
17969 return _("NT_VMS_IMGID (image id)");
17970 case NT_VMS_LINKID
:
17971 return _("NT_VMS_LINKID (link id)");
17972 case NT_VMS_IMGBID
:
17973 return _("NT_VMS_IMGBID (build id)");
17974 case NT_VMS_GSTNAM
:
17975 return _("NT_VMS_GSTNAM (sym table name)");
17976 case NT_VMS_ORIG_DYN
:
17977 return "NT_VMS_ORIG_DYN";
17978 case NT_VMS_PATCHTIME
:
17979 return "NT_VMS_PATCHTIME";
17981 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17987 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17989 int maxlen
= pnote
->descsz
;
17991 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
17992 goto desc_size_fail
;
17994 switch (pnote
->type
)
17998 goto desc_size_fail
;
18000 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18002 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18003 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18004 if (l
+ 34 < maxlen
)
18006 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18007 if (l
+ 35 < maxlen
)
18008 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18010 printf (_(" Module version : <missing>\n"));
18014 printf (_(" Module name : <missing>\n"));
18015 printf (_(" Module version : <missing>\n"));
18020 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18024 case NT_VMS_FPMODE
:
18025 printf (_(" Floating Point mode: "));
18027 goto desc_size_fail
;
18028 /* FIXME: Generate an error if descsz > 8 ? */
18030 printf ("0x%016" BFD_VMA_FMT
"x\n",
18031 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18034 case NT_VMS_LINKTIME
:
18035 printf (_(" Link time: "));
18037 goto desc_size_fail
;
18038 /* FIXME: Generate an error if descsz > 8 ? */
18041 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18045 case NT_VMS_PATCHTIME
:
18046 printf (_(" Patch time: "));
18048 goto desc_size_fail
;
18049 /* FIXME: Generate an error if descsz > 8 ? */
18052 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18056 case NT_VMS_ORIG_DYN
:
18058 goto desc_size_fail
;
18060 printf (_(" Major id: %u, minor id: %u\n"),
18061 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18062 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18063 printf (_(" Last modified : "));
18065 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18066 printf (_("\n Link flags : "));
18067 printf ("0x%016" BFD_VMA_FMT
"x\n",
18068 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18069 printf (_(" Header flags: 0x%08x\n"),
18070 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18071 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18075 case NT_VMS_IMGNAM
:
18076 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18079 case NT_VMS_GSTNAM
:
18080 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18084 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18087 case NT_VMS_LINKID
:
18088 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18098 printf (_(" <corrupt - data size is too small>\n"));
18099 error (_("corrupt IA64 note: data size is too small\n"));
18103 /* Find the symbol associated with a build attribute that is attached
18104 to address OFFSET. If PNAME is non-NULL then store the name of
18105 the symbol (if found) in the provided pointer, Returns NULL if a
18106 symbol could not be found. */
18108 static Elf_Internal_Sym
*
18109 get_symbol_for_build_attribute (Filedata
* filedata
,
18110 unsigned long offset
,
18111 bfd_boolean is_open_attr
,
18112 const char ** pname
)
18114 static Filedata
* saved_filedata
= NULL
;
18115 static char * strtab
;
18116 static unsigned long strtablen
;
18117 static Elf_Internal_Sym
* symtab
;
18118 static unsigned long nsyms
;
18119 Elf_Internal_Sym
* saved_sym
= NULL
;
18120 Elf_Internal_Sym
* sym
;
18122 if (filedata
->section_headers
!= NULL
18123 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
18125 Elf_Internal_Shdr
* symsec
;
18127 /* Load the symbol and string sections. */
18128 for (symsec
= filedata
->section_headers
;
18129 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18132 if (symsec
->sh_type
== SHT_SYMTAB
)
18134 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
18136 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18138 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
18140 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18141 1, strtab_sec
->sh_size
,
18142 _("string table"));
18143 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
18147 saved_filedata
= filedata
;
18150 if (symtab
== NULL
|| strtab
== NULL
)
18153 /* Find a symbol whose value matches offset. */
18154 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
18155 if (sym
->st_value
== offset
)
18157 if (sym
->st_name
>= strtablen
)
18158 /* Huh ? This should not happen. */
18161 if (strtab
[sym
->st_name
] == 0)
18164 /* The AArch64 and ARM architectures define mapping symbols
18165 (eg $d, $x, $t) which we want to ignore. */
18166 if (strtab
[sym
->st_name
] == '$'
18167 && strtab
[sym
->st_name
+ 1] != 0
18168 && strtab
[sym
->st_name
+ 2] == 0)
18173 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18174 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18175 FUNC symbols entirely. */
18176 switch (ELF_ST_TYPE (sym
->st_info
))
18183 /* If the symbol has a size associated
18184 with it then we can stop searching. */
18185 sym
= symtab
+ nsyms
;
18190 /* Ignore function symbols. */
18197 switch (ELF_ST_BIND (sym
->st_info
))
18200 if (saved_sym
== NULL
18201 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18206 if (saved_sym
== NULL
)
18216 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18224 if (saved_sym
&& pname
)
18225 * pname
= strtab
+ saved_sym
->st_name
;
18230 /* Returns true iff addr1 and addr2 are in the same section. */
18233 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18235 Elf_Internal_Shdr
* a1
;
18236 Elf_Internal_Shdr
* a2
;
18238 a1
= find_section_by_address (filedata
, addr1
);
18239 a2
= find_section_by_address (filedata
, addr2
);
18241 return a1
== a2
&& a1
!= NULL
;
18245 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18246 Filedata
* filedata
)
18248 static unsigned long global_offset
= 0;
18249 static unsigned long global_end
= 0;
18250 static unsigned long func_offset
= 0;
18251 static unsigned long func_end
= 0;
18253 Elf_Internal_Sym
* sym
;
18255 unsigned long start
;
18257 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18259 switch (pnote
->descsz
)
18262 /* A zero-length description means that the range of
18263 the previous note of the same type should be used. */
18266 if (global_end
> global_offset
)
18267 printf (_(" Applies to region from %#lx to %#lx\n"),
18268 global_offset
, global_end
);
18270 printf (_(" Applies to region from %#lx\n"), global_offset
);
18274 if (func_end
> func_offset
)
18275 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18277 printf (_(" Applies to region from %#lx\n"), func_offset
);
18282 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18289 /* FIXME: We should check that version 3+ notes are being used here... */
18290 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18291 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18295 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18301 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18302 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18306 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18307 printf (_(" <invalid descsz>"));
18312 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18313 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18314 in order to avoid them being confused with the start address of the
18315 first function in the file... */
18316 if (sym
== NULL
&& is_open_attr
)
18317 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18320 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18321 end
= start
+ sym
->st_size
;
18325 /* FIXME: Need to properly allow for section alignment.
18326 16 is just the alignment used on x86_64. */
18328 && start
> BFD_ALIGN (global_end
, 16)
18329 /* Build notes are not guaranteed to be organised in order of
18330 increasing address, but we should find the all of the notes
18331 for one section in the same place. */
18332 && same_section (filedata
, start
, global_end
))
18333 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18334 global_end
+ 1, start
- 1);
18336 printf (_(" Applies to region from %#lx"), start
);
18337 global_offset
= start
;
18341 printf (_(" to %#lx"), end
);
18347 printf (_(" Applies to region from %#lx"), start
);
18348 func_offset
= start
;
18352 printf (_(" to %#lx"), end
);
18358 printf (_(" (%s)"), name
);
18365 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18367 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18368 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18369 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18371 char name_attribute
;
18372 const char * expected_types
;
18373 const char * name
= pnote
->namedata
;
18377 if (name
== NULL
|| pnote
->namesz
< 2)
18379 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18380 print_symbol (-20, _(" <corrupt name>"));
18389 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18390 if (name
[0] == 'G' && name
[1] == 'A')
18392 if (pnote
->namesz
< 4)
18394 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18395 print_symbol (-20, _(" <corrupt name>"));
18404 switch ((name_type
= * name
))
18406 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18407 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18408 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18409 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18410 printf ("%c", * name
);
18414 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
18415 print_symbol (-20, _("<unknown name type>"));
18422 switch ((name_attribute
= * name
))
18424 case GNU_BUILD_ATTRIBUTE_VERSION
:
18425 text
= _("<version>");
18426 expected_types
= string_expected
;
18429 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18430 text
= _("<stack prot>");
18431 expected_types
= "!+*";
18434 case GNU_BUILD_ATTRIBUTE_RELRO
:
18435 text
= _("<relro>");
18436 expected_types
= bool_expected
;
18439 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
18440 text
= _("<stack size>");
18441 expected_types
= number_expected
;
18444 case GNU_BUILD_ATTRIBUTE_TOOL
:
18445 text
= _("<tool>");
18446 expected_types
= string_expected
;
18449 case GNU_BUILD_ATTRIBUTE_ABI
:
18451 expected_types
= "$*";
18454 case GNU_BUILD_ATTRIBUTE_PIC
:
18456 expected_types
= number_expected
;
18459 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
18460 text
= _("<short enum>");
18461 expected_types
= bool_expected
;
18465 if (ISPRINT (* name
))
18467 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
18469 if (len
> left
&& ! do_wide
)
18471 printf ("%.*s:", len
, name
);
18477 static char tmpbuf
[128];
18479 error (_("unrecognised byte in name field: %d\n"), * name
);
18480 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
18484 expected_types
= "*$!+";
18489 left
-= printf ("%s", text
);
18491 if (strchr (expected_types
, name_type
) == NULL
)
18492 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
18494 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
18496 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18497 (unsigned long) pnote
->namesz
,
18498 (long) (name
- pnote
->namedata
));
18502 if (left
< 1 && ! do_wide
)
18507 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18509 unsigned int bytes
;
18510 unsigned long long val
= 0;
18511 unsigned int shift
= 0;
18512 char * decoded
= NULL
;
18514 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
18516 /* The -1 is because the name field is always 0 terminated, and we
18517 want to be able to ensure that the shift in the while loop below
18518 will not overflow. */
18521 if (bytes
> sizeof (val
))
18523 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18525 bytes
= sizeof (val
);
18527 /* We do not bother to warn if bytes == 0 as this can
18528 happen with some early versions of the gcc plugin. */
18532 unsigned long byte
= (* name
++) & 0xff;
18534 val
|= byte
<< shift
;
18538 switch (name_attribute
)
18540 case GNU_BUILD_ATTRIBUTE_PIC
:
18543 case 0: decoded
= "static"; break;
18544 case 1: decoded
= "pic"; break;
18545 case 2: decoded
= "PIC"; break;
18546 case 3: decoded
= "pie"; break;
18547 case 4: decoded
= "PIE"; break;
18551 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18554 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18555 case 0: decoded
= "off"; break;
18556 case 1: decoded
= "on"; break;
18557 case 2: decoded
= "all"; break;
18558 case 3: decoded
= "strong"; break;
18559 case 4: decoded
= "explicit"; break;
18567 if (decoded
!= NULL
)
18569 print_symbol (-left
, decoded
);
18580 left
-= printf ("0x%llx", val
);
18582 left
-= printf ("0x%-.*llx", left
, val
);
18586 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18587 left
-= print_symbol (- left
, name
);
18589 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18590 left
-= print_symbol (- left
, "true");
18592 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18593 left
-= print_symbol (- left
, "false");
18597 if (do_wide
&& left
> 0)
18598 printf ("%-*s", left
, " ");
18603 /* Note that by the ELF standard, the name field is already null byte
18604 terminated, and namesz includes the terminating null byte.
18605 I.E. the value of namesz for the name "FSF" is 4.
18607 If the value of namesz is zero, there is no name present. */
18610 process_note (Elf_Internal_Note
* pnote
,
18611 Filedata
* filedata
)
18613 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
18616 if (pnote
->namesz
== 0)
18617 /* If there is no note name, then use the default set of
18618 note type strings. */
18619 nt
= get_note_type (filedata
, pnote
->type
);
18621 else if (const_strneq (pnote
->namedata
, "GNU"))
18622 /* GNU-specific object file notes. */
18623 nt
= get_gnu_elf_note_type (pnote
->type
);
18625 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
18626 /* FreeBSD-specific core file notes. */
18627 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
18629 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
18630 /* NetBSD-specific core file notes. */
18631 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
18633 else if (const_strneq (pnote
->namedata
, "NetBSD"))
18634 /* NetBSD-specific core file notes. */
18635 return process_netbsd_elf_note (pnote
);
18637 else if (strneq (pnote
->namedata
, "SPU/", 4))
18639 /* SPU-specific core file notes. */
18640 nt
= pnote
->namedata
+ 4;
18644 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18645 /* VMS/ia64-specific file notes. */
18646 nt
= get_ia64_vms_note_type (pnote
->type
);
18648 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18649 nt
= get_stapsdt_note_type (pnote
->type
);
18652 /* Don't recognize this note name; just use the default set of
18653 note type strings. */
18654 nt
= get_note_type (filedata
, pnote
->type
);
18658 if (((const_strneq (pnote
->namedata
, "GA")
18659 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18660 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18661 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18662 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18663 print_gnu_build_attribute_name (pnote
);
18665 print_symbol (-20, name
);
18668 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
18670 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
18672 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18673 return print_ia64_vms_note (pnote
);
18674 else if (const_strneq (pnote
->namedata
, "GNU"))
18675 return print_gnu_note (filedata
, pnote
);
18676 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18677 return print_stapsdt_note (pnote
);
18678 else if (const_strneq (pnote
->namedata
, "CORE"))
18679 return print_core_note (pnote
);
18680 else if (((const_strneq (pnote
->namedata
, "GA")
18681 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18682 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18683 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18684 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18685 return print_gnu_build_attribute_description (pnote
, filedata
);
18691 printf (_(" description data: "));
18692 for (i
= 0; i
< pnote
->descsz
; i
++)
18693 printf ("%02x ", pnote
->descdata
[i
]);
18705 process_notes_at (Filedata
* filedata
,
18706 Elf_Internal_Shdr
* section
,
18711 Elf_External_Note
* pnotes
;
18712 Elf_External_Note
* external
;
18714 bfd_boolean res
= TRUE
;
18721 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18724 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18729 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18732 if (pnotes
== NULL
)
18738 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18740 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18741 (unsigned long) offset
, (unsigned long) length
);
18743 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18744 specifies that notes should be aligned to 4 bytes in 32-bit
18745 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18746 we also support 4 byte alignment in 64-bit objects. If section
18747 alignment is less than 4, we treate alignment as 4 bytes. */
18750 else if (align
!= 4 && align
!= 8)
18752 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18757 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18759 end
= (char *) pnotes
+ length
;
18760 while ((char *) external
< end
)
18762 Elf_Internal_Note inote
;
18765 char * temp
= NULL
;
18766 size_t data_remaining
= end
- (char *) external
;
18768 if (!is_ia64_vms (filedata
))
18770 /* PR binutils/15191
18771 Make sure that there is enough data to read. */
18772 min_notesz
= offsetof (Elf_External_Note
, name
);
18773 if (data_remaining
< min_notesz
)
18775 warn (ngettext ("Corrupt note: only %ld byte remains, "
18776 "not enough for a full note\n",
18777 "Corrupt note: only %ld bytes remain, "
18778 "not enough for a full note\n",
18780 (long) data_remaining
);
18783 data_remaining
-= min_notesz
;
18785 inote
.type
= BYTE_GET (external
->type
);
18786 inote
.namesz
= BYTE_GET (external
->namesz
);
18787 inote
.namedata
= external
->name
;
18788 inote
.descsz
= BYTE_GET (external
->descsz
);
18789 inote
.descdata
= ((char *) external
18790 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18791 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18792 next
= ((char *) external
18793 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18797 Elf64_External_VMS_Note
*vms_external
;
18799 /* PR binutils/15191
18800 Make sure that there is enough data to read. */
18801 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18802 if (data_remaining
< min_notesz
)
18804 warn (ngettext ("Corrupt note: only %ld byte remains, "
18805 "not enough for a full note\n",
18806 "Corrupt note: only %ld bytes remain, "
18807 "not enough for a full note\n",
18809 (long) data_remaining
);
18812 data_remaining
-= min_notesz
;
18814 vms_external
= (Elf64_External_VMS_Note
*) external
;
18815 inote
.type
= BYTE_GET (vms_external
->type
);
18816 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18817 inote
.namedata
= vms_external
->name
;
18818 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18819 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18820 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18821 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18824 /* PR 17531: file: 3443835e. */
18825 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18826 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18827 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18828 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18829 || ((size_t) (next
- inote
.descdata
)
18830 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18832 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18833 (unsigned long) ((char *) external
- (char *) pnotes
));
18834 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18835 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18839 external
= (Elf_External_Note
*) next
;
18841 /* Verify that name is null terminated. It appears that at least
18842 one version of Linux (RedHat 6.0) generates corefiles that don't
18843 comply with the ELF spec by failing to include the null byte in
18845 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
18847 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18849 temp
= (char *) malloc (inote
.namesz
+ 1);
18852 error (_("Out of memory allocating space for inote name\n"));
18857 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18858 inote
.namedata
= temp
;
18860 inote
.namedata
[inote
.namesz
] = 0;
18863 if (! process_note (& inote
, filedata
))
18879 process_corefile_note_segments (Filedata
* filedata
)
18881 Elf_Internal_Phdr
* segment
;
18883 bfd_boolean res
= TRUE
;
18885 if (! get_program_headers (filedata
))
18888 for (i
= 0, segment
= filedata
->program_headers
;
18889 i
< filedata
->file_header
.e_phnum
;
18892 if (segment
->p_type
== PT_NOTE
)
18893 if (! process_notes_at (filedata
, NULL
,
18894 (bfd_vma
) segment
->p_offset
,
18895 (bfd_vma
) segment
->p_filesz
,
18896 (bfd_vma
) segment
->p_align
))
18904 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18906 Elf_External_Note
* pnotes
;
18907 Elf_External_Note
* external
;
18909 bfd_boolean res
= TRUE
;
18914 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18916 if (pnotes
== NULL
)
18920 end
= (char*) pnotes
+ length
;
18922 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18923 (unsigned long) offset
, (unsigned long) length
);
18925 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18927 Elf_External_Note
* next
;
18928 Elf_Internal_Note inote
;
18930 inote
.type
= BYTE_GET (external
->type
);
18931 inote
.namesz
= BYTE_GET (external
->namesz
);
18932 inote
.namedata
= external
->name
;
18933 inote
.descsz
= BYTE_GET (external
->descsz
);
18934 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18935 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18937 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18939 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18940 inote
.descdata
= inote
.namedata
;
18944 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18946 if ( ((char *) next
> end
)
18947 || ((char *) next
< (char *) pnotes
))
18949 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18950 (unsigned long) ((char *) external
- (char *) pnotes
));
18951 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18952 inote
.type
, inote
.namesz
, inote
.descsz
);
18958 /* Prevent out-of-bounds indexing. */
18959 if ( inote
.namedata
+ inote
.namesz
> end
18960 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18962 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18963 (unsigned long) ((char *) external
- (char *) pnotes
));
18964 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18965 inote
.type
, inote
.namesz
, inote
.descsz
);
18969 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18971 if (! print_v850_note (& inote
))
18974 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18975 inote
.namesz
, inote
.descsz
);
18985 process_note_sections (Filedata
* filedata
)
18987 Elf_Internal_Shdr
* section
;
18989 unsigned int n
= 0;
18990 bfd_boolean res
= TRUE
;
18992 for (i
= 0, section
= filedata
->section_headers
;
18993 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18996 if (section
->sh_type
== SHT_NOTE
)
18998 if (! process_notes_at (filedata
, section
,
18999 (bfd_vma
) section
->sh_offset
,
19000 (bfd_vma
) section
->sh_size
,
19001 (bfd_vma
) section
->sh_addralign
))
19006 if (( filedata
->file_header
.e_machine
== EM_V800
19007 || filedata
->file_header
.e_machine
== EM_V850
19008 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19009 && section
->sh_type
== SHT_RENESAS_INFO
)
19011 if (! process_v850_notes (filedata
,
19012 (bfd_vma
) section
->sh_offset
,
19013 (bfd_vma
) section
->sh_size
))
19020 /* Try processing NOTE segments instead. */
19021 return process_corefile_note_segments (filedata
);
19027 process_notes (Filedata
* filedata
)
19029 /* If we have not been asked to display the notes then do nothing. */
19033 if (filedata
->file_header
.e_type
!= ET_CORE
)
19034 return process_note_sections (filedata
);
19036 /* No program headers means no NOTE segment. */
19037 if (filedata
->file_header
.e_phnum
> 0)
19038 return process_corefile_note_segments (filedata
);
19040 printf (_("No note segments present in the core file.\n"));
19044 static unsigned char *
19045 display_public_gnu_attributes (unsigned char * start
,
19046 const unsigned char * const end
)
19048 printf (_(" Unknown GNU attribute: %s\n"), start
);
19050 start
+= strnlen ((char *) start
, end
- start
);
19051 display_raw_attribute (start
, end
);
19053 return (unsigned char *) end
;
19056 static unsigned char *
19057 display_generic_attribute (unsigned char * start
,
19059 const unsigned char * const end
)
19062 return (unsigned char *) end
;
19064 return display_tag_value (tag
, start
, end
);
19068 process_arch_specific (Filedata
* filedata
)
19073 switch (filedata
->file_header
.e_machine
)
19076 case EM_ARC_COMPACT
:
19077 case EM_ARC_COMPACT2
:
19078 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19079 display_arc_attribute
,
19080 display_generic_attribute
);
19082 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19083 display_arm_attribute
,
19084 display_generic_attribute
);
19087 case EM_MIPS_RS3_LE
:
19088 return process_mips_specific (filedata
);
19091 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19092 display_msp430x_attribute
,
19093 display_generic_attribute
);
19096 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19097 display_riscv_attribute
,
19098 display_generic_attribute
);
19101 return process_nds32_specific (filedata
);
19105 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19106 display_power_gnu_attribute
);
19110 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19111 display_s390_gnu_attribute
);
19114 case EM_SPARC32PLUS
:
19116 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19117 display_sparc_gnu_attribute
);
19120 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19121 display_tic6x_attribute
,
19122 display_generic_attribute
);
19125 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19126 display_public_gnu_attributes
,
19127 display_generic_attribute
);
19132 get_file_header (Filedata
* filedata
)
19134 /* Read in the identity array. */
19135 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19138 /* Determine how to read the rest of the header. */
19139 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19144 byte_get
= byte_get_little_endian
;
19145 byte_put
= byte_put_little_endian
;
19148 byte_get
= byte_get_big_endian
;
19149 byte_put
= byte_put_big_endian
;
19153 /* For now we only support 32 bit and 64 bit ELF files. */
19154 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19156 /* Read in the rest of the header. */
19159 Elf32_External_Ehdr ehdr32
;
19161 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19164 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19165 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19166 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19167 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19168 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19169 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19170 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19171 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19172 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19173 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19174 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19175 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19176 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19180 Elf64_External_Ehdr ehdr64
;
19182 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19183 we will not be able to cope with the 64bit data found in
19184 64 ELF files. Detect this now and abort before we start
19185 overwriting things. */
19186 if (sizeof (bfd_vma
) < 8)
19188 error (_("This instance of readelf has been built without support for a\n\
19189 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19193 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19196 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19197 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19198 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19199 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19200 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19201 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19202 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19203 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19204 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19205 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19206 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19207 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19208 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19211 if (filedata
->file_header
.e_shoff
)
19213 /* There may be some extensions in the first section header. Don't
19214 bomb if we can't read it. */
19216 get_32bit_section_headers (filedata
, TRUE
);
19218 get_64bit_section_headers (filedata
, TRUE
);
19225 close_file (Filedata
* filedata
)
19229 if (filedata
->handle
)
19230 fclose (filedata
->handle
);
19236 close_debug_file (void * data
)
19238 close_file ((Filedata
*) data
);
19242 open_file (const char * pathname
)
19244 struct stat statbuf
;
19245 Filedata
* filedata
= NULL
;
19247 if (stat (pathname
, & statbuf
) < 0
19248 || ! S_ISREG (statbuf
.st_mode
))
19251 filedata
= calloc (1, sizeof * filedata
);
19252 if (filedata
== NULL
)
19255 filedata
->handle
= fopen (pathname
, "rb");
19256 if (filedata
->handle
== NULL
)
19259 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19260 filedata
->file_name
= pathname
;
19262 if (! get_file_header (filedata
))
19265 if (filedata
->file_header
.e_shoff
)
19269 /* Read the section headers again, this time for real. */
19271 res
= get_32bit_section_headers (filedata
, FALSE
);
19273 res
= get_64bit_section_headers (filedata
, FALSE
);
19284 if (filedata
->handle
)
19285 fclose (filedata
->handle
);
19292 open_debug_file (const char * pathname
)
19294 return open_file (pathname
);
19297 /* Process one ELF object file according to the command line options.
19298 This file may actually be stored in an archive. The file is
19299 positioned at the start of the ELF object. Returns TRUE if no
19300 problems were encountered, FALSE otherwise. */
19303 process_object (Filedata
* filedata
)
19305 bfd_boolean have_separate_files
;
19307 bfd_boolean res
= TRUE
;
19309 if (! get_file_header (filedata
))
19311 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19315 /* Initialise per file variables. */
19316 for (i
= ARRAY_SIZE (version_info
); i
--;)
19317 version_info
[i
] = 0;
19319 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19320 dynamic_info
[i
] = 0;
19321 dynamic_info_DT_GNU_HASH
= 0;
19323 /* Process the file. */
19325 printf (_("\nFile: %s\n"), filedata
->file_name
);
19327 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19328 Note we do this even if cmdline_dump_sects is empty because we
19329 must make sure that the dump_sets array is zeroed out before each
19330 object file is processed. */
19331 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19332 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19334 if (cmdline
.num_dump_sects
> 0)
19336 if (filedata
->num_dump_sects
== 0)
19337 /* A sneaky way of allocating the dump_sects array. */
19338 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19340 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19341 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19342 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19345 if (! process_file_header (filedata
))
19348 if (! process_section_headers (filedata
))
19350 /* Without loaded section headers we cannot process lots of things. */
19351 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19353 if (! do_using_dynamic
)
19354 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19357 if (! process_section_groups (filedata
))
19358 /* Without loaded section groups we cannot process unwind. */
19361 if (process_program_headers (filedata
))
19362 process_dynamic_section (filedata
);
19366 if (! process_relocs (filedata
))
19369 if (! process_unwind (filedata
))
19372 if (! process_symbol_table (filedata
))
19375 if (! process_syminfo (filedata
))
19378 if (! process_version_sections (filedata
))
19381 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19382 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
19384 have_separate_files
= FALSE
;
19386 if (! process_section_contents (filedata
))
19389 if (have_separate_files
)
19393 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
19395 if (! process_section_headers (d
->handle
))
19397 else if (! process_section_contents (d
->handle
))
19401 /* The file handles are closed by the call to free_debug_memory() below. */
19404 if (! process_notes (filedata
))
19407 if (! process_gnu_liblist (filedata
))
19410 if (! process_arch_specific (filedata
))
19413 free (filedata
->program_headers
);
19414 filedata
->program_headers
= NULL
;
19416 free (filedata
->section_headers
);
19417 filedata
->section_headers
= NULL
;
19419 free (filedata
->string_table
);
19420 filedata
->string_table
= NULL
;
19421 filedata
->string_table_length
= 0;
19423 if (dynamic_strings
)
19425 free (dynamic_strings
);
19426 dynamic_strings
= NULL
;
19427 dynamic_strings_length
= 0;
19430 if (dynamic_symbols
)
19432 free (dynamic_symbols
);
19433 dynamic_symbols
= NULL
;
19434 num_dynamic_syms
= 0;
19437 if (dynamic_syminfo
)
19439 free (dynamic_syminfo
);
19440 dynamic_syminfo
= NULL
;
19443 if (dynamic_section
)
19445 free (dynamic_section
);
19446 dynamic_section
= NULL
;
19449 if (section_headers_groups
)
19451 free (section_headers_groups
);
19452 section_headers_groups
= NULL
;
19455 if (section_groups
)
19457 struct group_list
* g
;
19458 struct group_list
* next
;
19460 for (i
= 0; i
< group_count
; i
++)
19462 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
19469 free (section_groups
);
19470 section_groups
= NULL
;
19473 free_debug_memory ();
19478 /* Process an ELF archive.
19479 On entry the file is positioned just after the ARMAG string.
19480 Returns TRUE upon success, FALSE otherwise. */
19483 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
19485 struct archive_info arch
;
19486 struct archive_info nested_arch
;
19488 bfd_boolean ret
= TRUE
;
19492 /* The ARCH structure is used to hold information about this archive. */
19493 arch
.file_name
= NULL
;
19495 arch
.index_array
= NULL
;
19496 arch
.sym_table
= NULL
;
19497 arch
.longnames
= NULL
;
19499 /* The NESTED_ARCH structure is used as a single-item cache of information
19500 about a nested archive (when members of a thin archive reside within
19501 another regular archive file). */
19502 nested_arch
.file_name
= NULL
;
19503 nested_arch
.file
= NULL
;
19504 nested_arch
.index_array
= NULL
;
19505 nested_arch
.sym_table
= NULL
;
19506 nested_arch
.longnames
= NULL
;
19508 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
19509 is_thin_archive
, do_archive_index
) != 0)
19515 if (do_archive_index
)
19517 if (arch
.sym_table
== NULL
)
19518 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
19521 unsigned long i
, l
;
19522 unsigned long current_pos
;
19524 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19525 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
19527 current_pos
= ftell (filedata
->handle
);
19529 for (i
= l
= 0; i
< arch
.index_num
; i
++)
19531 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
19533 char * member_name
;
19535 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
19537 if (member_name
!= NULL
)
19539 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
19541 if (qualified_name
!= NULL
)
19543 printf (_("Contents of binary %s at offset "), qualified_name
);
19544 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
19546 free (qualified_name
);
19551 if (l
>= arch
.sym_size
)
19553 error (_("%s: end of the symbol table reached before the end of the index\n"),
19554 filedata
->file_name
);
19558 /* PR 17531: file: 0b6630b2. */
19559 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
19560 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
19563 if (arch
.uses_64bit_indices
)
19568 if (l
< arch
.sym_size
)
19570 error (ngettext ("%s: %ld byte remains in the symbol table, "
19571 "but without corresponding entries in "
19572 "the index table\n",
19573 "%s: %ld bytes remain in the symbol table, "
19574 "but without corresponding entries in "
19575 "the index table\n",
19576 arch
.sym_size
- l
),
19577 filedata
->file_name
, arch
.sym_size
- l
);
19581 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
19583 error (_("%s: failed to seek back to start of object files in the archive\n"),
19584 filedata
->file_name
);
19590 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
19591 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
19592 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
19593 && !do_section_groups
&& !do_dyn_syms
)
19595 ret
= TRUE
; /* Archive index only. */
19604 char * qualified_name
;
19606 /* Read the next archive header. */
19607 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
19609 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
19612 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
19613 if (got
!= sizeof arch
.arhdr
)
19617 /* PR 24049 - we cannot use filedata->file_name as this will
19618 have already been freed. */
19619 error (_("%s: failed to read archive header\n"), arch
.file_name
);
19624 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
19626 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
19631 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
19633 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
19634 if (archive_file_size
& 01)
19635 ++archive_file_size
;
19637 name
= get_archive_member_name (&arch
, &nested_arch
);
19640 error (_("%s: bad archive file name\n"), arch
.file_name
);
19644 namelen
= strlen (name
);
19646 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
19647 if (qualified_name
== NULL
)
19649 error (_("%s: bad archive file name\n"), arch
.file_name
);
19654 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
19656 /* This is a proxy for an external member of a thin archive. */
19657 Filedata
* member_filedata
;
19658 char * member_file_name
= adjust_relative_path
19659 (filedata
->file_name
, name
, namelen
);
19661 if (member_file_name
== NULL
)
19667 member_filedata
= open_file (member_file_name
);
19668 if (member_filedata
== NULL
)
19670 error (_("Input file '%s' is not readable.\n"), member_file_name
);
19671 free (member_file_name
);
19676 archive_file_offset
= arch
.nested_member_origin
;
19677 member_filedata
->file_name
= qualified_name
;
19679 if (! process_object (member_filedata
))
19682 close_file (member_filedata
);
19683 free (member_file_name
);
19685 else if (is_thin_archive
)
19687 Filedata thin_filedata
;
19689 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
19691 /* PR 15140: Allow for corrupt thin archives. */
19692 if (nested_arch
.file
== NULL
)
19694 error (_("%s: contains corrupt thin archive: %s\n"),
19695 qualified_name
, name
);
19700 /* This is a proxy for a member of a nested archive. */
19701 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19703 /* The nested archive file will have been opened and setup by
19704 get_archive_member_name. */
19705 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19707 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19712 thin_filedata
.handle
= nested_arch
.file
;
19713 thin_filedata
.file_name
= qualified_name
;
19715 if (! process_object (& thin_filedata
))
19720 archive_file_offset
= arch
.next_arhdr_offset
;
19721 arch
.next_arhdr_offset
+= archive_file_size
;
19723 filedata
->file_name
= qualified_name
;
19724 if (! process_object (filedata
))
19728 if (filedata
->dump_sects
!= NULL
)
19730 free (filedata
->dump_sects
);
19731 filedata
->dump_sects
= NULL
;
19732 filedata
->num_dump_sects
= 0;
19735 free (qualified_name
);
19739 if (nested_arch
.file
!= NULL
)
19740 fclose (nested_arch
.file
);
19741 release_archive (&nested_arch
);
19742 release_archive (&arch
);
19748 process_file (char * file_name
)
19750 Filedata
* filedata
= NULL
;
19751 struct stat statbuf
;
19752 char armag
[SARMAG
];
19753 bfd_boolean ret
= TRUE
;
19755 if (stat (file_name
, &statbuf
) < 0)
19757 if (errno
== ENOENT
)
19758 error (_("'%s': No such file\n"), file_name
);
19760 error (_("Could not locate '%s'. System error message: %s\n"),
19761 file_name
, strerror (errno
));
19765 if (! S_ISREG (statbuf
.st_mode
))
19767 error (_("'%s' is not an ordinary file\n"), file_name
);
19771 filedata
= calloc (1, sizeof * filedata
);
19772 if (filedata
== NULL
)
19774 error (_("Out of memory allocating file data structure\n"));
19778 filedata
->file_name
= file_name
;
19779 filedata
->handle
= fopen (file_name
, "rb");
19780 if (filedata
->handle
== NULL
)
19782 error (_("Input file '%s' is not readable.\n"), file_name
);
19787 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19789 error (_("%s: Failed to read file's magic number\n"), file_name
);
19790 fclose (filedata
->handle
);
19795 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19797 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19799 if (! process_archive (filedata
, FALSE
))
19802 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19804 if ( ! process_archive (filedata
, TRUE
))
19809 if (do_archive_index
)
19810 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19813 rewind (filedata
->handle
);
19814 archive_file_size
= archive_file_offset
= 0;
19816 if (! process_object (filedata
))
19820 fclose (filedata
->handle
);
19826 #ifdef SUPPORT_DISASSEMBLY
19827 /* Needed by the i386 disassembler. For extra credit, someone could
19828 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19832 print_address (unsigned int addr
, FILE * outfile
)
19834 fprintf (outfile
,"0x%8.8x", addr
);
19837 /* Needed by the i386 disassembler. */
19840 db_task_printsym (unsigned int addr
)
19842 print_address (addr
, stderr
);
19847 main (int argc
, char ** argv
)
19851 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19852 setlocale (LC_MESSAGES
, "");
19854 #if defined (HAVE_SETLOCALE)
19855 setlocale (LC_CTYPE
, "");
19857 bindtextdomain (PACKAGE
, LOCALEDIR
);
19858 textdomain (PACKAGE
);
19860 expandargv (&argc
, &argv
);
19862 cmdline
.file_name
= "<cmdline>";
19863 parse_args (& cmdline
, argc
, argv
);
19865 if (optind
< (argc
- 1))
19867 else if (optind
>= argc
)
19869 warn (_("Nothing to do.\n"));
19874 while (optind
< argc
)
19875 if (! process_file (argv
[optind
++]))
19878 if (cmdline
.dump_sects
!= NULL
)
19879 free (cmdline
.dump_sects
);
19881 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;