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_aarch64_dynamic_type (unsigned long type
)
1805 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1806 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1813 get_mips_dynamic_type (unsigned long type
)
1817 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1818 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1819 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1820 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1821 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1822 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1823 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1824 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1825 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1826 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1827 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1828 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1829 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1830 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1831 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1832 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1833 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1834 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1835 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1836 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1837 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1838 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1839 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1840 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1841 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1842 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1843 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1844 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1845 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1846 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1847 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1848 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1849 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1850 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1851 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1852 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1853 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1854 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1855 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1856 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1857 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1858 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1859 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1860 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1861 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1862 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1869 get_sparc64_dynamic_type (unsigned long type
)
1873 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1880 get_ppc_dynamic_type (unsigned long type
)
1884 case DT_PPC_GOT
: return "PPC_GOT";
1885 case DT_PPC_OPT
: return "PPC_OPT";
1892 get_ppc64_dynamic_type (unsigned long type
)
1896 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1897 case DT_PPC64_OPD
: return "PPC64_OPD";
1898 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1899 case DT_PPC64_OPT
: return "PPC64_OPT";
1906 get_parisc_dynamic_type (unsigned long type
)
1910 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1911 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1912 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1913 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1914 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1915 case DT_HP_PREINIT
: return "HP_PREINIT";
1916 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1917 case DT_HP_NEEDED
: return "HP_NEEDED";
1918 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1919 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1920 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1921 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1922 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1923 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1924 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1925 case DT_HP_FILTERED
: return "HP_FILTERED";
1926 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1927 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1928 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1929 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1930 case DT_PLT
: return "PLT";
1931 case DT_PLT_SIZE
: return "PLT_SIZE";
1932 case DT_DLT
: return "DLT";
1933 case DT_DLT_SIZE
: return "DLT_SIZE";
1940 get_ia64_dynamic_type (unsigned long type
)
1944 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1945 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1946 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1947 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1948 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1949 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1950 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1951 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1952 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1953 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1954 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1955 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1956 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1957 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1958 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1959 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1960 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1961 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1962 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1963 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1964 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1965 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1966 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1967 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1968 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1969 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1970 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1971 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1972 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1973 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1974 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1981 get_solaris_section_type (unsigned long type
)
1985 case 0x6fffffee: return "SUNW_ancillary";
1986 case 0x6fffffef: return "SUNW_capchain";
1987 case 0x6ffffff0: return "SUNW_capinfo";
1988 case 0x6ffffff1: return "SUNW_symsort";
1989 case 0x6ffffff2: return "SUNW_tlssort";
1990 case 0x6ffffff3: return "SUNW_LDYNSYM";
1991 case 0x6ffffff4: return "SUNW_dof";
1992 case 0x6ffffff5: return "SUNW_cap";
1993 case 0x6ffffff6: return "SUNW_SIGNATURE";
1994 case 0x6ffffff7: return "SUNW_ANNOTATE";
1995 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1996 case 0x6ffffff9: return "SUNW_DEBUG";
1997 case 0x6ffffffa: return "SUNW_move";
1998 case 0x6ffffffb: return "SUNW_COMDAT";
1999 case 0x6ffffffc: return "SUNW_syminfo";
2000 case 0x6ffffffd: return "SUNW_verdef";
2001 case 0x6ffffffe: return "SUNW_verneed";
2002 case 0x6fffffff: return "SUNW_versym";
2003 case 0x70000000: return "SPARC_GOTDATA";
2004 default: return NULL
;
2009 get_alpha_dynamic_type (unsigned long type
)
2013 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2014 default: return NULL
;
2019 get_score_dynamic_type (unsigned long type
)
2023 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2024 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2025 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2026 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2027 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2028 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2029 default: return NULL
;
2034 get_tic6x_dynamic_type (unsigned long type
)
2038 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2039 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2040 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2041 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2042 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2043 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2044 default: return NULL
;
2049 get_nios2_dynamic_type (unsigned long type
)
2053 case DT_NIOS2_GP
: return "NIOS2_GP";
2054 default: return NULL
;
2059 get_solaris_dynamic_type (unsigned long type
)
2063 case 0x6000000d: return "SUNW_AUXILIARY";
2064 case 0x6000000e: return "SUNW_RTLDINF";
2065 case 0x6000000f: return "SUNW_FILTER";
2066 case 0x60000010: return "SUNW_CAP";
2067 case 0x60000011: return "SUNW_SYMTAB";
2068 case 0x60000012: return "SUNW_SYMSZ";
2069 case 0x60000013: return "SUNW_SORTENT";
2070 case 0x60000014: return "SUNW_SYMSORT";
2071 case 0x60000015: return "SUNW_SYMSORTSZ";
2072 case 0x60000016: return "SUNW_TLSSORT";
2073 case 0x60000017: return "SUNW_TLSSORTSZ";
2074 case 0x60000018: return "SUNW_CAPINFO";
2075 case 0x60000019: return "SUNW_STRPAD";
2076 case 0x6000001a: return "SUNW_CAPCHAIN";
2077 case 0x6000001b: return "SUNW_LDMACH";
2078 case 0x6000001d: return "SUNW_CAPCHAINENT";
2079 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2080 case 0x60000021: return "SUNW_PARENT";
2081 case 0x60000023: return "SUNW_ASLR";
2082 case 0x60000025: return "SUNW_RELAX";
2083 case 0x60000029: return "SUNW_NXHEAP";
2084 case 0x6000002b: return "SUNW_NXSTACK";
2086 case 0x70000001: return "SPARC_REGISTER";
2087 case 0x7ffffffd: return "AUXILIARY";
2088 case 0x7ffffffe: return "USED";
2089 case 0x7fffffff: return "FILTER";
2091 default: return NULL
;
2096 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2098 static char buff
[64];
2102 case DT_NULL
: return "NULL";
2103 case DT_NEEDED
: return "NEEDED";
2104 case DT_PLTRELSZ
: return "PLTRELSZ";
2105 case DT_PLTGOT
: return "PLTGOT";
2106 case DT_HASH
: return "HASH";
2107 case DT_STRTAB
: return "STRTAB";
2108 case DT_SYMTAB
: return "SYMTAB";
2109 case DT_RELA
: return "RELA";
2110 case DT_RELASZ
: return "RELASZ";
2111 case DT_RELAENT
: return "RELAENT";
2112 case DT_STRSZ
: return "STRSZ";
2113 case DT_SYMENT
: return "SYMENT";
2114 case DT_INIT
: return "INIT";
2115 case DT_FINI
: return "FINI";
2116 case DT_SONAME
: return "SONAME";
2117 case DT_RPATH
: return "RPATH";
2118 case DT_SYMBOLIC
: return "SYMBOLIC";
2119 case DT_REL
: return "REL";
2120 case DT_RELSZ
: return "RELSZ";
2121 case DT_RELENT
: return "RELENT";
2122 case DT_PLTREL
: return "PLTREL";
2123 case DT_DEBUG
: return "DEBUG";
2124 case DT_TEXTREL
: return "TEXTREL";
2125 case DT_JMPREL
: return "JMPREL";
2126 case DT_BIND_NOW
: return "BIND_NOW";
2127 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2128 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2129 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2130 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2131 case DT_RUNPATH
: return "RUNPATH";
2132 case DT_FLAGS
: return "FLAGS";
2134 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2135 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2136 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2138 case DT_CHECKSUM
: return "CHECKSUM";
2139 case DT_PLTPADSZ
: return "PLTPADSZ";
2140 case DT_MOVEENT
: return "MOVEENT";
2141 case DT_MOVESZ
: return "MOVESZ";
2142 case DT_FEATURE
: return "FEATURE";
2143 case DT_POSFLAG_1
: return "POSFLAG_1";
2144 case DT_SYMINSZ
: return "SYMINSZ";
2145 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2147 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2148 case DT_CONFIG
: return "CONFIG";
2149 case DT_DEPAUDIT
: return "DEPAUDIT";
2150 case DT_AUDIT
: return "AUDIT";
2151 case DT_PLTPAD
: return "PLTPAD";
2152 case DT_MOVETAB
: return "MOVETAB";
2153 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2155 case DT_VERSYM
: return "VERSYM";
2157 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2158 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2159 case DT_RELACOUNT
: return "RELACOUNT";
2160 case DT_RELCOUNT
: return "RELCOUNT";
2161 case DT_FLAGS_1
: return "FLAGS_1";
2162 case DT_VERDEF
: return "VERDEF";
2163 case DT_VERDEFNUM
: return "VERDEFNUM";
2164 case DT_VERNEED
: return "VERNEED";
2165 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2167 case DT_AUXILIARY
: return "AUXILIARY";
2168 case DT_USED
: return "USED";
2169 case DT_FILTER
: return "FILTER";
2171 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2172 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2173 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2174 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2175 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2176 case DT_GNU_HASH
: return "GNU_HASH";
2179 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2181 const char * result
;
2183 switch (filedata
->file_header
.e_machine
)
2186 result
= get_aarch64_dynamic_type (type
);
2189 case EM_MIPS_RS3_LE
:
2190 result
= get_mips_dynamic_type (type
);
2193 result
= get_sparc64_dynamic_type (type
);
2196 result
= get_ppc_dynamic_type (type
);
2199 result
= get_ppc64_dynamic_type (type
);
2202 result
= get_ia64_dynamic_type (type
);
2205 result
= get_alpha_dynamic_type (type
);
2208 result
= get_score_dynamic_type (type
);
2211 result
= get_tic6x_dynamic_type (type
);
2213 case EM_ALTERA_NIOS2
:
2214 result
= get_nios2_dynamic_type (type
);
2217 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2218 result
= get_solaris_dynamic_type (type
);
2227 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2229 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2230 || (filedata
->file_header
.e_machine
== EM_PARISC
2231 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2233 const char * result
;
2235 switch (filedata
->file_header
.e_machine
)
2238 result
= get_parisc_dynamic_type (type
);
2241 result
= get_ia64_dynamic_type (type
);
2244 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2245 result
= get_solaris_dynamic_type (type
);
2254 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2258 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2265 get_file_type (unsigned e_type
)
2267 static char buff
[32];
2271 case ET_NONE
: return _("NONE (None)");
2272 case ET_REL
: return _("REL (Relocatable file)");
2273 case ET_EXEC
: return _("EXEC (Executable file)");
2274 case ET_DYN
: return _("DYN (Shared object file)");
2275 case ET_CORE
: return _("CORE (Core file)");
2278 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2279 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2280 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2281 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2283 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2289 get_machine_name (unsigned e_machine
)
2291 static char buff
[64]; /* XXX */
2295 /* Please keep this switch table sorted by increasing EM_ value. */
2297 case EM_NONE
: return _("None");
2298 case EM_M32
: return "WE32100";
2299 case EM_SPARC
: return "Sparc";
2300 case EM_386
: return "Intel 80386";
2301 case EM_68K
: return "MC68000";
2302 case EM_88K
: return "MC88000";
2303 case EM_IAMCU
: return "Intel MCU";
2304 case EM_860
: return "Intel 80860";
2305 case EM_MIPS
: return "MIPS R3000";
2306 case EM_S370
: return "IBM System/370";
2308 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2309 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2310 case EM_PARISC
: return "HPPA";
2311 case EM_VPP550
: return "Fujitsu VPP500";
2312 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2313 case EM_960
: return "Intel 80960";
2314 case EM_PPC
: return "PowerPC";
2316 case EM_PPC64
: return "PowerPC64";
2318 case EM_S390
: return "IBM S/390";
2319 case EM_SPU
: return "SPU";
2321 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2322 case EM_FR20
: return "Fujitsu FR20";
2323 case EM_RH32
: return "TRW RH32";
2324 case EM_MCORE
: return "MCORE";
2326 case EM_ARM
: return "ARM";
2327 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2328 case EM_SH
: return "Renesas / SuperH SH";
2329 case EM_SPARCV9
: return "Sparc v9";
2330 case EM_TRICORE
: return "Siemens Tricore";
2331 case EM_ARC
: return "ARC";
2332 case EM_H8_300
: return "Renesas H8/300";
2333 case EM_H8_300H
: return "Renesas H8/300H";
2334 case EM_H8S
: return "Renesas H8S";
2335 case EM_H8_500
: return "Renesas H8/500";
2337 case EM_IA_64
: return "Intel IA-64";
2338 case EM_MIPS_X
: return "Stanford MIPS-X";
2339 case EM_COLDFIRE
: return "Motorola Coldfire";
2340 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2341 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2342 case EM_PCP
: return "Siemens PCP";
2343 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2344 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2345 case EM_STARCORE
: return "Motorola Star*Core processor";
2346 case EM_ME16
: return "Toyota ME16 processor";
2348 case EM_ST100
: return "STMicroelectronics ST100 processor";
2349 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2350 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2351 case EM_PDSP
: return "Sony DSP processor";
2352 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2353 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2354 case EM_FX66
: return "Siemens FX66 microcontroller";
2355 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2356 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2357 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2359 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2360 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2361 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2362 case EM_SVX
: return "Silicon Graphics SVx";
2363 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2364 case EM_VAX
: return "Digital VAX";
2365 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2366 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2367 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2368 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2370 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2371 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2372 case EM_PRISM
: return "Vitesse Prism";
2374 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2375 case EM_CYGNUS_FR30
:
2376 case EM_FR30
: return "Fujitsu FR30";
2377 case EM_CYGNUS_D10V
:
2378 case EM_D10V
: return "d10v";
2379 case EM_CYGNUS_D30V
:
2380 case EM_D30V
: return "d30v";
2381 case EM_CYGNUS_V850
:
2382 case EM_V850
: return "Renesas V850";
2383 case EM_CYGNUS_M32R
:
2384 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2385 case EM_CYGNUS_MN10300
:
2386 case EM_MN10300
: return "mn10300";
2388 case EM_CYGNUS_MN10200
:
2389 case EM_MN10200
: return "mn10200";
2390 case EM_PJ
: return "picoJava";
2391 case EM_OR1K
: return "OpenRISC 1000";
2392 case EM_ARC_COMPACT
: return "ARCompact";
2394 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2395 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2396 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2397 case EM_NS32K
: return "National Semiconductor 32000 series";
2398 case EM_TPC
: return "Tenor Network TPC processor";
2399 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2401 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2403 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2404 case EM_MAX
: return "MAX Processor";
2405 case EM_CR
: return "National Semiconductor CompactRISC";
2406 case EM_F2MC16
: return "Fujitsu F2MC16";
2407 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2408 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2409 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2410 case EM_SEP
: return "Sharp embedded microprocessor";
2411 case EM_ARCA
: return "Arca RISC microprocessor";
2413 case EM_UNICORE
: return "Unicore";
2414 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2415 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2416 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2417 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2418 case EM_XGATE
: return "Motorola XGATE embedded processor";
2420 case EM_XC16X
: return "Infineon Technologies xc16x";
2421 case EM_M16C
: return "Renesas M16C series microprocessors";
2422 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2423 case EM_CE
: return "Freescale Communication Engine RISC core";
2425 case EM_M32C
: return "Renesas M32c";
2427 case EM_TSK3000
: return "Altium TSK3000 core";
2428 case EM_RS08
: return "Freescale RS08 embedded processor";
2429 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2430 case EM_SCORE
: return "SUNPLUS S+Core";
2431 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2432 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2433 case EM_LATTICEMICO32
: return "Lattice Mico32";
2434 case EM_SE_C17
: return "Seiko Epson C17 family";
2436 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2437 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2438 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2439 case EM_TI_PRU
: return "TI PRU I/O processor";
2441 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2442 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2443 case EM_R32C
: return "Renesas R32C series microprocessors";
2444 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2445 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2446 case EM_8051
: return "Intel 8051 and variants";
2447 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2448 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2449 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2450 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2452 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2453 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2454 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2455 case EM_RX
: return "Renesas RX";
2456 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2457 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2458 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2461 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2462 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2463 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2465 case EM_L1OM
: return "Intel L1OM";
2466 case EM_K1OM
: return "Intel K1OM";
2467 case EM_INTEL182
: return "Intel (reserved)";
2468 case EM_AARCH64
: return "AArch64";
2469 case EM_ARM184
: return "ARM (reserved)";
2470 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2471 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2472 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2473 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2475 case EM_CUDA
: return "NVIDIA CUDA architecture";
2476 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2477 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2478 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2479 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2480 case EM_ARC_COMPACT2
: return "ARCv2";
2481 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2482 case EM_RL78
: return "Renesas RL78";
2483 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2484 case EM_78K0R
: return "Renesas 78K0R";
2486 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2487 case EM_BA1
: return "Beyond BA1 CPU architecture";
2488 case EM_BA2
: return "Beyond BA2 CPU architecture";
2489 case EM_XCORE
: return "XMOS xCORE processor family";
2490 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2492 case EM_KM32
: return "KM211 KM32 32-bit processor";
2493 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2494 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2495 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2496 case EM_KVARC
: return "KM211 KVARC processor";
2497 case EM_CDP
: return "Paneve CDP architecture family";
2498 case EM_COGE
: return "Cognitive Smart Memory Processor";
2499 case EM_COOL
: return "Bluechip Systems CoolEngine";
2500 case EM_NORC
: return "Nanoradio Optimized RISC";
2501 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2503 case EM_Z80
: return "Zilog Z80";
2504 case EM_VISIUM
: return "CDS VISIUMcore processor";
2505 case EM_FT32
: return "FTDI Chip FT32";
2506 case EM_MOXIE
: return "Moxie";
2507 case EM_AMDGPU
: return "AMD GPU";
2508 case EM_RISCV
: return "RISC-V";
2509 case EM_LANAI
: return "Lanai 32-bit processor";
2510 case EM_BPF
: return "Linux BPF";
2511 case EM_NFP
: return "Netronome Flow Processor";
2513 /* Large numbers... */
2514 case EM_MT
: return "Morpho Techologies MT processor";
2515 case EM_ALPHA
: return "Alpha";
2516 case EM_WEBASSEMBLY
: return "Web Assembly";
2517 case EM_DLX
: return "OpenDLX";
2518 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2519 case EM_IQ2000
: return "Vitesse IQ2000";
2521 case EM_NIOS32
: return "Altera Nios";
2522 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2523 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2524 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2525 case EM_S12Z
: return "Freescale S12Z";
2526 case EM_CSKY
: return "C-SKY";
2529 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2535 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2537 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2538 other compilers don't a specific architecture type in the e_flags, and
2539 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2540 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2543 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2544 but also sets a specific architecture type in the e_flags field.
2546 However, when decoding the flags we don't worry if we see an
2547 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2548 ARCEM architecture type. */
2550 switch (e_flags
& EF_ARC_MACH_MSK
)
2552 /* We only expect these to occur for EM_ARC_COMPACT2. */
2553 case EF_ARC_CPU_ARCV2EM
:
2554 strcat (buf
, ", ARC EM");
2556 case EF_ARC_CPU_ARCV2HS
:
2557 strcat (buf
, ", ARC HS");
2560 /* We only expect these to occur for EM_ARC_COMPACT. */
2561 case E_ARC_MACH_ARC600
:
2562 strcat (buf
, ", ARC600");
2564 case E_ARC_MACH_ARC601
:
2565 strcat (buf
, ", ARC601");
2567 case E_ARC_MACH_ARC700
:
2568 strcat (buf
, ", ARC700");
2571 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2572 new ELF with new architecture being read by an old version of
2573 readelf, or (c) An ELF built with non-GNU compiler that does not
2574 set the architecture in the e_flags. */
2576 if (e_machine
== EM_ARC_COMPACT
)
2577 strcat (buf
, ", Unknown ARCompact");
2579 strcat (buf
, ", Unknown ARC");
2583 switch (e_flags
& EF_ARC_OSABI_MSK
)
2585 case E_ARC_OSABI_ORIG
:
2586 strcat (buf
, ", (ABI:legacy)");
2588 case E_ARC_OSABI_V2
:
2589 strcat (buf
, ", (ABI:v2)");
2591 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2592 case E_ARC_OSABI_V3
:
2593 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2595 case E_ARC_OSABI_V4
:
2596 strcat (buf
, ", v4 ABI");
2599 strcat (buf
, ", unrecognised ARC OSABI flag");
2605 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2608 bfd_boolean unknown
= FALSE
;
2610 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2611 e_flags
&= ~ EF_ARM_EABIMASK
;
2613 /* Handle "generic" ARM flags. */
2614 if (e_flags
& EF_ARM_RELEXEC
)
2616 strcat (buf
, ", relocatable executable");
2617 e_flags
&= ~ EF_ARM_RELEXEC
;
2620 if (e_flags
& EF_ARM_PIC
)
2622 strcat (buf
, ", position independent");
2623 e_flags
&= ~ EF_ARM_PIC
;
2626 /* Now handle EABI specific flags. */
2630 strcat (buf
, ", <unrecognized EABI>");
2635 case EF_ARM_EABI_VER1
:
2636 strcat (buf
, ", Version1 EABI");
2641 /* Process flags one bit at a time. */
2642 flag
= e_flags
& - e_flags
;
2647 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2648 strcat (buf
, ", sorted symbol tables");
2658 case EF_ARM_EABI_VER2
:
2659 strcat (buf
, ", Version2 EABI");
2664 /* Process flags one bit at a time. */
2665 flag
= e_flags
& - e_flags
;
2670 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2671 strcat (buf
, ", sorted symbol tables");
2674 case EF_ARM_DYNSYMSUSESEGIDX
:
2675 strcat (buf
, ", dynamic symbols use segment index");
2678 case EF_ARM_MAPSYMSFIRST
:
2679 strcat (buf
, ", mapping symbols precede others");
2689 case EF_ARM_EABI_VER3
:
2690 strcat (buf
, ", Version3 EABI");
2693 case EF_ARM_EABI_VER4
:
2694 strcat (buf
, ", Version4 EABI");
2699 /* Process flags one bit at a time. */
2700 flag
= e_flags
& - e_flags
;
2706 strcat (buf
, ", BE8");
2710 strcat (buf
, ", LE8");
2720 case EF_ARM_EABI_VER5
:
2721 strcat (buf
, ", Version5 EABI");
2726 /* Process flags one bit at a time. */
2727 flag
= e_flags
& - e_flags
;
2733 strcat (buf
, ", BE8");
2737 strcat (buf
, ", LE8");
2740 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2741 strcat (buf
, ", soft-float ABI");
2744 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2745 strcat (buf
, ", hard-float ABI");
2755 case EF_ARM_EABI_UNKNOWN
:
2756 strcat (buf
, ", GNU EABI");
2761 /* Process flags one bit at a time. */
2762 flag
= e_flags
& - e_flags
;
2767 case EF_ARM_INTERWORK
:
2768 strcat (buf
, ", interworking enabled");
2771 case EF_ARM_APCS_26
:
2772 strcat (buf
, ", uses APCS/26");
2775 case EF_ARM_APCS_FLOAT
:
2776 strcat (buf
, ", uses APCS/float");
2780 strcat (buf
, ", position independent");
2784 strcat (buf
, ", 8 bit structure alignment");
2787 case EF_ARM_NEW_ABI
:
2788 strcat (buf
, ", uses new ABI");
2791 case EF_ARM_OLD_ABI
:
2792 strcat (buf
, ", uses old ABI");
2795 case EF_ARM_SOFT_FLOAT
:
2796 strcat (buf
, ", software FP");
2799 case EF_ARM_VFP_FLOAT
:
2800 strcat (buf
, ", VFP");
2803 case EF_ARM_MAVERICK_FLOAT
:
2804 strcat (buf
, ", Maverick FP");
2815 strcat (buf
,_(", <unknown>"));
2819 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2821 --size
; /* Leave space for null terminator. */
2823 switch (e_flags
& EF_AVR_MACH
)
2825 case E_AVR_MACH_AVR1
:
2826 strncat (buf
, ", avr:1", size
);
2828 case E_AVR_MACH_AVR2
:
2829 strncat (buf
, ", avr:2", size
);
2831 case E_AVR_MACH_AVR25
:
2832 strncat (buf
, ", avr:25", size
);
2834 case E_AVR_MACH_AVR3
:
2835 strncat (buf
, ", avr:3", size
);
2837 case E_AVR_MACH_AVR31
:
2838 strncat (buf
, ", avr:31", size
);
2840 case E_AVR_MACH_AVR35
:
2841 strncat (buf
, ", avr:35", size
);
2843 case E_AVR_MACH_AVR4
:
2844 strncat (buf
, ", avr:4", size
);
2846 case E_AVR_MACH_AVR5
:
2847 strncat (buf
, ", avr:5", size
);
2849 case E_AVR_MACH_AVR51
:
2850 strncat (buf
, ", avr:51", size
);
2852 case E_AVR_MACH_AVR6
:
2853 strncat (buf
, ", avr:6", size
);
2855 case E_AVR_MACH_AVRTINY
:
2856 strncat (buf
, ", avr:100", size
);
2858 case E_AVR_MACH_XMEGA1
:
2859 strncat (buf
, ", avr:101", size
);
2861 case E_AVR_MACH_XMEGA2
:
2862 strncat (buf
, ", avr:102", size
);
2864 case E_AVR_MACH_XMEGA3
:
2865 strncat (buf
, ", avr:103", size
);
2867 case E_AVR_MACH_XMEGA4
:
2868 strncat (buf
, ", avr:104", size
);
2870 case E_AVR_MACH_XMEGA5
:
2871 strncat (buf
, ", avr:105", size
);
2873 case E_AVR_MACH_XMEGA6
:
2874 strncat (buf
, ", avr:106", size
);
2876 case E_AVR_MACH_XMEGA7
:
2877 strncat (buf
, ", avr:107", size
);
2880 strncat (buf
, ", avr:<unknown>", size
);
2884 size
-= strlen (buf
);
2885 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2886 strncat (buf
, ", link-relax", size
);
2890 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2896 bfd_boolean has_fpu
= FALSE
;
2899 static const char *ABI_STRINGS
[] =
2901 "ABI v0", /* use r5 as return register; only used in N1213HC */
2902 "ABI v1", /* use r0 as return register */
2903 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2904 "ABI v2fp", /* for FPU */
2908 static const char *VER_STRINGS
[] =
2910 "Andes ELF V1.3 or older",
2914 static const char *ARCH_STRINGS
[] =
2923 abi
= EF_NDS_ABI
& e_flags
;
2924 arch
= EF_NDS_ARCH
& e_flags
;
2925 config
= EF_NDS_INST
& e_flags
;
2926 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2928 memset (buf
, 0, size
);
2935 case E_NDS_ABI_V2FP
:
2936 case E_NDS_ABI_AABI
:
2937 case E_NDS_ABI_V2FP_PLUS
:
2938 /* In case there are holes in the array. */
2939 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2943 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2949 case E_NDS32_ELF_VER_1_2
:
2950 case E_NDS32_ELF_VER_1_3
:
2951 case E_NDS32_ELF_VER_1_4
:
2952 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2956 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2960 if (E_NDS_ABI_V0
== abi
)
2962 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2963 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2964 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2965 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2971 case E_NDS_ARCH_STAR_V1_0
:
2972 case E_NDS_ARCH_STAR_V2_0
:
2973 case E_NDS_ARCH_STAR_V3_0
:
2974 case E_NDS_ARCH_STAR_V3_M
:
2975 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2979 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2980 /* ARCH version determines how the e_flags are interpreted.
2981 If it is unknown, we cannot proceed. */
2985 /* Newer ABI; Now handle architecture specific flags. */
2986 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2988 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2989 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2991 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2992 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2994 if (config
& E_NDS32_HAS_DIV_INST
)
2995 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2997 if (config
& E_NDS32_HAS_16BIT_INST
)
2998 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3002 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3004 if (version
<= E_NDS32_ELF_VER_1_3
)
3005 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3007 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3010 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3011 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3013 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3014 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3016 if (config
& E_NDS32_HAS_16BIT_INST
)
3018 if (version
<= E_NDS32_ELF_VER_1_3
)
3019 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3021 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3025 if (config
& E_NDS32_HAS_EXT_INST
)
3026 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3028 if (config
& E_NDS32_HAS_EXT2_INST
)
3029 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3031 if (config
& E_NDS32_HAS_FPU_INST
)
3034 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3037 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3040 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3043 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3046 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3051 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3053 case E_NDS32_FPU_REG_8SP_4DP
:
3054 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3056 case E_NDS32_FPU_REG_16SP_8DP
:
3057 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3059 case E_NDS32_FPU_REG_32SP_16DP
:
3060 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3062 case E_NDS32_FPU_REG_32SP_32DP
:
3063 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3068 if (config
& E_NDS32_HAS_AUDIO_INST
)
3069 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3071 if (config
& E_NDS32_HAS_STRING_INST
)
3072 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3074 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3075 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3077 if (config
& E_NDS32_HAS_VIDEO_INST
)
3079 if (version
<= E_NDS32_ELF_VER_1_3
)
3080 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3082 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3085 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3086 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3088 if (config
& E_NDS32_HAS_L2C_INST
)
3089 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3093 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3095 static char buf
[1024];
3106 case EM_ARC_COMPACT2
:
3107 case EM_ARC_COMPACT
:
3108 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3112 decode_ARM_machine_flags (e_flags
, buf
);
3116 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3120 if (e_flags
& EF_BFIN_PIC
)
3121 strcat (buf
, ", PIC");
3123 if (e_flags
& EF_BFIN_FDPIC
)
3124 strcat (buf
, ", FDPIC");
3126 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3127 strcat (buf
, ", code in L1");
3129 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3130 strcat (buf
, ", data in L1");
3135 switch (e_flags
& EF_FRV_CPU_MASK
)
3137 case EF_FRV_CPU_GENERIC
:
3141 strcat (buf
, ", fr???");
3144 case EF_FRV_CPU_FR300
:
3145 strcat (buf
, ", fr300");
3148 case EF_FRV_CPU_FR400
:
3149 strcat (buf
, ", fr400");
3151 case EF_FRV_CPU_FR405
:
3152 strcat (buf
, ", fr405");
3155 case EF_FRV_CPU_FR450
:
3156 strcat (buf
, ", fr450");
3159 case EF_FRV_CPU_FR500
:
3160 strcat (buf
, ", fr500");
3162 case EF_FRV_CPU_FR550
:
3163 strcat (buf
, ", fr550");
3166 case EF_FRV_CPU_SIMPLE
:
3167 strcat (buf
, ", simple");
3169 case EF_FRV_CPU_TOMCAT
:
3170 strcat (buf
, ", tomcat");
3176 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3177 strcat (buf
, ", m68000");
3178 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3179 strcat (buf
, ", cpu32");
3180 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3181 strcat (buf
, ", fido_a");
3184 char const * isa
= _("unknown");
3185 char const * mac
= _("unknown mac");
3186 char const * additional
= NULL
;
3188 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3190 case EF_M68K_CF_ISA_A_NODIV
:
3192 additional
= ", nodiv";
3194 case EF_M68K_CF_ISA_A
:
3197 case EF_M68K_CF_ISA_A_PLUS
:
3200 case EF_M68K_CF_ISA_B_NOUSP
:
3202 additional
= ", nousp";
3204 case EF_M68K_CF_ISA_B
:
3207 case EF_M68K_CF_ISA_C
:
3210 case EF_M68K_CF_ISA_C_NODIV
:
3212 additional
= ", nodiv";
3215 strcat (buf
, ", cf, isa ");
3218 strcat (buf
, additional
);
3219 if (e_flags
& EF_M68K_CF_FLOAT
)
3220 strcat (buf
, ", float");
3221 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3226 case EF_M68K_CF_MAC
:
3229 case EF_M68K_CF_EMAC
:
3232 case EF_M68K_CF_EMAC_B
:
3245 switch (e_flags
& EF_MEP_CPU_MASK
)
3247 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3248 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3249 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3250 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3251 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3252 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3253 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3256 switch (e_flags
& EF_MEP_COP_MASK
)
3258 case EF_MEP_COP_NONE
: break;
3259 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3260 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3261 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3262 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3263 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3266 if (e_flags
& EF_MEP_LIBRARY
)
3267 strcat (buf
, ", Built for Library");
3269 if (e_flags
& EF_MEP_INDEX_MASK
)
3270 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3271 e_flags
& EF_MEP_INDEX_MASK
);
3273 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3274 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3275 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3279 if (e_flags
& EF_PPC_EMB
)
3280 strcat (buf
, ", emb");
3282 if (e_flags
& EF_PPC_RELOCATABLE
)
3283 strcat (buf
, _(", relocatable"));
3285 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3286 strcat (buf
, _(", relocatable-lib"));
3290 if (e_flags
& EF_PPC64_ABI
)
3292 char abi
[] = ", abiv0";
3294 abi
[6] += e_flags
& EF_PPC64_ABI
;
3300 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3301 strcat (buf
, ", RH850 ABI");
3303 if (e_flags
& EF_V800_850E3
)
3304 strcat (buf
, ", V3 architecture");
3306 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3307 strcat (buf
, ", FPU not used");
3309 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3310 strcat (buf
, ", regmode: COMMON");
3312 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3313 strcat (buf
, ", r4 not used");
3315 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3316 strcat (buf
, ", r30 not used");
3318 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3319 strcat (buf
, ", r5 not used");
3321 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3322 strcat (buf
, ", r2 not used");
3324 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3326 switch (e_flags
& - e_flags
)
3328 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3329 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3330 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3331 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3332 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3333 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3334 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3335 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3336 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3337 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3338 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3339 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3346 case EM_CYGNUS_V850
:
3347 switch (e_flags
& EF_V850_ARCH
)
3349 case E_V850E3V5_ARCH
:
3350 strcat (buf
, ", v850e3v5");
3352 case E_V850E2V3_ARCH
:
3353 strcat (buf
, ", v850e2v3");
3356 strcat (buf
, ", v850e2");
3359 strcat (buf
, ", v850e1");
3362 strcat (buf
, ", v850e");
3365 strcat (buf
, ", v850");
3368 strcat (buf
, _(", unknown v850 architecture variant"));
3374 case EM_CYGNUS_M32R
:
3375 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3376 strcat (buf
, ", m32r");
3380 case EM_MIPS_RS3_LE
:
3381 if (e_flags
& EF_MIPS_NOREORDER
)
3382 strcat (buf
, ", noreorder");
3384 if (e_flags
& EF_MIPS_PIC
)
3385 strcat (buf
, ", pic");
3387 if (e_flags
& EF_MIPS_CPIC
)
3388 strcat (buf
, ", cpic");
3390 if (e_flags
& EF_MIPS_UCODE
)
3391 strcat (buf
, ", ugen_reserved");
3393 if (e_flags
& EF_MIPS_ABI2
)
3394 strcat (buf
, ", abi2");
3396 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3397 strcat (buf
, ", odk first");
3399 if (e_flags
& EF_MIPS_32BITMODE
)
3400 strcat (buf
, ", 32bitmode");
3402 if (e_flags
& EF_MIPS_NAN2008
)
3403 strcat (buf
, ", nan2008");
3405 if (e_flags
& EF_MIPS_FP64
)
3406 strcat (buf
, ", fp64");
3408 switch ((e_flags
& EF_MIPS_MACH
))
3410 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3411 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3412 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3413 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3414 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3415 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3416 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3417 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3418 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3419 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3420 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3421 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3422 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3423 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3424 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3425 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3426 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3427 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3428 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3429 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3430 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3432 /* We simply ignore the field in this case to avoid confusion:
3433 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3436 default: strcat (buf
, _(", unknown CPU")); break;
3439 switch ((e_flags
& EF_MIPS_ABI
))
3441 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3442 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3443 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3444 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3446 /* We simply ignore the field in this case to avoid confusion:
3447 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3448 This means it is likely to be an o32 file, but not for
3451 default: strcat (buf
, _(", unknown ABI")); break;
3454 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3455 strcat (buf
, ", mdmx");
3457 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3458 strcat (buf
, ", mips16");
3460 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3461 strcat (buf
, ", micromips");
3463 switch ((e_flags
& EF_MIPS_ARCH
))
3465 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3466 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3467 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3468 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3469 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3470 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3471 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3472 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3473 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3474 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3475 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3476 default: strcat (buf
, _(", unknown ISA")); break;
3481 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3485 switch (EF_NFP_MACH (e_flags
))
3487 case E_NFP_MACH_3200
:
3488 strcat (buf
, ", NFP-32xx");
3490 case E_NFP_MACH_6000
:
3491 strcat (buf
, ", NFP-6xxx");
3497 if (e_flags
& EF_RISCV_RVC
)
3498 strcat (buf
, ", RVC");
3500 if (e_flags
& EF_RISCV_RVE
)
3501 strcat (buf
, ", RVE");
3503 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3505 case EF_RISCV_FLOAT_ABI_SOFT
:
3506 strcat (buf
, ", soft-float ABI");
3509 case EF_RISCV_FLOAT_ABI_SINGLE
:
3510 strcat (buf
, ", single-float ABI");
3513 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3514 strcat (buf
, ", double-float ABI");
3517 case EF_RISCV_FLOAT_ABI_QUAD
:
3518 strcat (buf
, ", quad-float ABI");
3524 switch ((e_flags
& EF_SH_MACH_MASK
))
3526 case EF_SH1
: strcat (buf
, ", sh1"); break;
3527 case EF_SH2
: strcat (buf
, ", sh2"); break;
3528 case EF_SH3
: strcat (buf
, ", sh3"); break;
3529 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3530 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3531 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3532 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3533 case EF_SH4
: strcat (buf
, ", sh4"); break;
3534 case EF_SH5
: strcat (buf
, ", sh5"); break;
3535 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3536 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3537 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3538 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3539 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3540 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3541 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3542 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3543 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3544 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3545 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3546 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3547 default: strcat (buf
, _(", unknown ISA")); break;
3550 if (e_flags
& EF_SH_PIC
)
3551 strcat (buf
, ", pic");
3553 if (e_flags
& EF_SH_FDPIC
)
3554 strcat (buf
, ", fdpic");
3558 if (e_flags
& EF_OR1K_NODELAY
)
3559 strcat (buf
, ", no delay");
3563 if (e_flags
& EF_SPARC_32PLUS
)
3564 strcat (buf
, ", v8+");
3566 if (e_flags
& EF_SPARC_SUN_US1
)
3567 strcat (buf
, ", ultrasparcI");
3569 if (e_flags
& EF_SPARC_SUN_US3
)
3570 strcat (buf
, ", ultrasparcIII");
3572 if (e_flags
& EF_SPARC_HAL_R1
)
3573 strcat (buf
, ", halr1");
3575 if (e_flags
& EF_SPARC_LEDATA
)
3576 strcat (buf
, ", ledata");
3578 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3579 strcat (buf
, ", tso");
3581 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3582 strcat (buf
, ", pso");
3584 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3585 strcat (buf
, ", rmo");
3589 switch (e_flags
& EF_PARISC_ARCH
)
3591 case EFA_PARISC_1_0
:
3592 strcpy (buf
, ", PA-RISC 1.0");
3594 case EFA_PARISC_1_1
:
3595 strcpy (buf
, ", PA-RISC 1.1");
3597 case EFA_PARISC_2_0
:
3598 strcpy (buf
, ", PA-RISC 2.0");
3603 if (e_flags
& EF_PARISC_TRAPNIL
)
3604 strcat (buf
, ", trapnil");
3605 if (e_flags
& EF_PARISC_EXT
)
3606 strcat (buf
, ", ext");
3607 if (e_flags
& EF_PARISC_LSB
)
3608 strcat (buf
, ", lsb");
3609 if (e_flags
& EF_PARISC_WIDE
)
3610 strcat (buf
, ", wide");
3611 if (e_flags
& EF_PARISC_NO_KABP
)
3612 strcat (buf
, ", no kabp");
3613 if (e_flags
& EF_PARISC_LAZYSWAP
)
3614 strcat (buf
, ", lazyswap");
3619 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3620 strcat (buf
, ", new calling convention");
3622 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3623 strcat (buf
, ", gnu calling convention");
3627 if ((e_flags
& EF_IA_64_ABI64
))
3628 strcat (buf
, ", 64-bit");
3630 strcat (buf
, ", 32-bit");
3631 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3632 strcat (buf
, ", reduced fp model");
3633 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3634 strcat (buf
, ", no function descriptors, constant gp");
3635 else if ((e_flags
& EF_IA_64_CONS_GP
))
3636 strcat (buf
, ", constant gp");
3637 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3638 strcat (buf
, ", absolute");
3639 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3641 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3642 strcat (buf
, ", vms_linkages");
3643 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3645 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3647 case EF_IA_64_VMS_COMCOD_WARNING
:
3648 strcat (buf
, ", warning");
3650 case EF_IA_64_VMS_COMCOD_ERROR
:
3651 strcat (buf
, ", error");
3653 case EF_IA_64_VMS_COMCOD_ABORT
:
3654 strcat (buf
, ", abort");
3657 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3658 e_flags
& EF_IA_64_VMS_COMCOD
);
3659 strcat (buf
, ", <unknown>");
3665 if ((e_flags
& EF_VAX_NONPIC
))
3666 strcat (buf
, ", non-PIC");
3667 if ((e_flags
& EF_VAX_DFLOAT
))
3668 strcat (buf
, ", D-Float");
3669 if ((e_flags
& EF_VAX_GFLOAT
))
3670 strcat (buf
, ", G-Float");
3674 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3675 strcat (buf
, ", mcm");
3676 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3677 strcat (buf
, ", mcm24");
3678 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3679 strcat (buf
, ", gr6");
3683 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3685 case E_FLAG_RL78_ANY_CPU
: break;
3686 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3687 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3688 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3690 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3691 strcat (buf
, ", 64-bit doubles");
3695 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3696 strcat (buf
, ", 64-bit doubles");
3697 if (e_flags
& E_FLAG_RX_DSP
)
3698 strcat (buf
, ", dsp");
3699 if (e_flags
& E_FLAG_RX_PID
)
3700 strcat (buf
, ", pid");
3701 if (e_flags
& E_FLAG_RX_ABI
)
3702 strcat (buf
, ", RX ABI");
3703 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3704 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3705 ? ", uses String instructions" : ", bans String instructions");
3706 if (e_flags
& E_FLAG_RX_V2
)
3707 strcat (buf
, ", V2");
3708 if (e_flags
& E_FLAG_RX_V3
)
3709 strcat (buf
, ", V3");
3713 if (e_flags
& EF_S390_HIGH_GPRS
)
3714 strcat (buf
, ", highgprs");
3718 if ((e_flags
& EF_C6000_REL
))
3719 strcat (buf
, ", relocatable module");
3723 strcat (buf
, _(": architecture variant: "));
3724 switch (e_flags
& EF_MSP430_MACH
)
3726 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3727 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3728 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3729 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3730 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3731 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3732 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3733 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3734 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3735 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3736 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3737 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3738 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3739 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3740 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3742 strcat (buf
, _(": unknown")); break;
3745 if (e_flags
& ~ EF_MSP430_MACH
)
3746 strcat (buf
, _(": unknown extra flag bits also present"));
3754 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3756 static char buff
[32];
3760 case ELFOSABI_NONE
: return "UNIX - System V";
3761 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3762 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3763 case ELFOSABI_GNU
: return "UNIX - GNU";
3764 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3765 case ELFOSABI_AIX
: return "UNIX - AIX";
3766 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3767 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3768 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3769 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3770 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3771 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3772 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3773 case ELFOSABI_AROS
: return "AROS";
3774 case ELFOSABI_FENIXOS
: return "FenixOS";
3775 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3776 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3779 switch (filedata
->file_header
.e_machine
)
3784 case ELFOSABI_ARM
: return "ARM";
3785 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3796 case ELFOSABI_STANDALONE
: return _("Standalone App");
3805 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3806 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3815 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3821 get_aarch64_segment_type (unsigned long type
)
3825 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3826 default: return NULL
;
3831 get_arm_segment_type (unsigned long type
)
3835 case PT_ARM_EXIDX
: return "EXIDX";
3836 default: return NULL
;
3841 get_s390_segment_type (unsigned long type
)
3845 case PT_S390_PGSTE
: return "S390_PGSTE";
3846 default: return NULL
;
3851 get_mips_segment_type (unsigned long type
)
3855 case PT_MIPS_REGINFO
: return "REGINFO";
3856 case PT_MIPS_RTPROC
: return "RTPROC";
3857 case PT_MIPS_OPTIONS
: return "OPTIONS";
3858 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3859 default: return NULL
;
3864 get_parisc_segment_type (unsigned long type
)
3868 case PT_HP_TLS
: return "HP_TLS";
3869 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3870 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3871 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3872 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3873 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3874 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3875 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3876 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3877 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3878 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3879 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3880 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3881 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3882 case PT_HP_STACK
: return "HP_STACK";
3883 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3884 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3885 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3886 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3887 default: return NULL
;
3892 get_ia64_segment_type (unsigned long type
)
3896 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3897 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3898 case PT_HP_TLS
: return "HP_TLS";
3899 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3900 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3901 case PT_IA_64_HP_STACK
: return "HP_STACK";
3902 default: return NULL
;
3907 get_tic6x_segment_type (unsigned long type
)
3911 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3912 default: return NULL
;
3917 get_solaris_segment_type (unsigned long type
)
3921 case 0x6464e550: return "PT_SUNW_UNWIND";
3922 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3923 case 0x6ffffff7: return "PT_LOSUNW";
3924 case 0x6ffffffa: return "PT_SUNWBSS";
3925 case 0x6ffffffb: return "PT_SUNWSTACK";
3926 case 0x6ffffffc: return "PT_SUNWDTRACE";
3927 case 0x6ffffffd: return "PT_SUNWCAP";
3928 case 0x6fffffff: return "PT_HISUNW";
3929 default: return NULL
;
3934 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3936 static char buff
[32];
3940 case PT_NULL
: return "NULL";
3941 case PT_LOAD
: return "LOAD";
3942 case PT_DYNAMIC
: return "DYNAMIC";
3943 case PT_INTERP
: return "INTERP";
3944 case PT_NOTE
: return "NOTE";
3945 case PT_SHLIB
: return "SHLIB";
3946 case PT_PHDR
: return "PHDR";
3947 case PT_TLS
: return "TLS";
3948 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3949 case PT_GNU_STACK
: return "GNU_STACK";
3950 case PT_GNU_RELRO
: return "GNU_RELRO";
3951 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
3954 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3956 sprintf (buff
, "GNU_MBIND+%#lx",
3957 p_type
- PT_GNU_MBIND_LO
);
3959 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3961 const char * result
;
3963 switch (filedata
->file_header
.e_machine
)
3966 result
= get_aarch64_segment_type (p_type
);
3969 result
= get_arm_segment_type (p_type
);
3972 case EM_MIPS_RS3_LE
:
3973 result
= get_mips_segment_type (p_type
);
3976 result
= get_parisc_segment_type (p_type
);
3979 result
= get_ia64_segment_type (p_type
);
3982 result
= get_tic6x_segment_type (p_type
);
3986 result
= get_s390_segment_type (p_type
);
3996 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3998 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4000 const char * result
;
4002 switch (filedata
->file_header
.e_machine
)
4005 result
= get_parisc_segment_type (p_type
);
4008 result
= get_ia64_segment_type (p_type
);
4011 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4012 result
= get_solaris_segment_type (p_type
);
4021 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4024 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4031 get_arc_section_type_name (unsigned int sh_type
)
4035 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4043 get_mips_section_type_name (unsigned int sh_type
)
4047 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4048 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4049 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4050 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4051 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4052 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4053 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4054 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4055 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4056 case SHT_MIPS_RELD
: return "MIPS_RELD";
4057 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4058 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4059 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4060 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4061 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4062 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4063 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4064 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4065 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4066 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4067 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4068 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4069 case SHT_MIPS_LINE
: return "MIPS_LINE";
4070 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4071 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4072 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4073 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4074 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4075 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4076 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4077 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4078 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4079 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4080 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4081 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4082 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4083 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4084 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4085 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4086 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4094 get_parisc_section_type_name (unsigned int sh_type
)
4098 case SHT_PARISC_EXT
: return "PARISC_EXT";
4099 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4100 case SHT_PARISC_DOC
: return "PARISC_DOC";
4101 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4102 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4103 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4104 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4105 default: return NULL
;
4110 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4112 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4113 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4114 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4118 case SHT_IA_64_EXT
: return "IA_64_EXT";
4119 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4120 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4121 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4122 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4123 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4124 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4125 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4126 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4127 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4135 get_x86_64_section_type_name (unsigned int sh_type
)
4139 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4140 default: return NULL
;
4145 get_aarch64_section_type_name (unsigned int sh_type
)
4149 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4150 default: return NULL
;
4155 get_arm_section_type_name (unsigned int sh_type
)
4159 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4160 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4161 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4162 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4163 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4164 default: return NULL
;
4169 get_tic6x_section_type_name (unsigned int sh_type
)
4173 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4174 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4175 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4176 case SHT_TI_ICODE
: return "TI_ICODE";
4177 case SHT_TI_XREF
: return "TI_XREF";
4178 case SHT_TI_HANDLER
: return "TI_HANDLER";
4179 case SHT_TI_INITINFO
: return "TI_INITINFO";
4180 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4181 default: return NULL
;
4186 get_msp430x_section_type_name (unsigned int sh_type
)
4190 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4191 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4192 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4193 default: return NULL
;
4198 get_nfp_section_type_name (unsigned int sh_type
)
4202 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4203 case SHT_NFP_INITREG
: return "NFP_INITREG";
4204 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4205 default: return NULL
;
4210 get_v850_section_type_name (unsigned int sh_type
)
4214 case SHT_V850_SCOMMON
: return "V850 Small Common";
4215 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4216 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4217 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4218 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4219 default: return NULL
;
4224 get_riscv_section_type_name (unsigned int sh_type
)
4228 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4229 default: return NULL
;
4234 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4236 static char buff
[32];
4237 const char * result
;
4241 case SHT_NULL
: return "NULL";
4242 case SHT_PROGBITS
: return "PROGBITS";
4243 case SHT_SYMTAB
: return "SYMTAB";
4244 case SHT_STRTAB
: return "STRTAB";
4245 case SHT_RELA
: return "RELA";
4246 case SHT_HASH
: return "HASH";
4247 case SHT_DYNAMIC
: return "DYNAMIC";
4248 case SHT_NOTE
: return "NOTE";
4249 case SHT_NOBITS
: return "NOBITS";
4250 case SHT_REL
: return "REL";
4251 case SHT_SHLIB
: return "SHLIB";
4252 case SHT_DYNSYM
: return "DYNSYM";
4253 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4254 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4255 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4256 case SHT_GNU_HASH
: return "GNU_HASH";
4257 case SHT_GROUP
: return "GROUP";
4258 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4259 case SHT_GNU_verdef
: return "VERDEF";
4260 case SHT_GNU_verneed
: return "VERNEED";
4261 case SHT_GNU_versym
: return "VERSYM";
4262 case 0x6ffffff0: return "VERSYM";
4263 case 0x6ffffffc: return "VERDEF";
4264 case 0x7ffffffd: return "AUXILIARY";
4265 case 0x7fffffff: return "FILTER";
4266 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4269 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4271 switch (filedata
->file_header
.e_machine
)
4274 case EM_ARC_COMPACT
:
4275 case EM_ARC_COMPACT2
:
4276 result
= get_arc_section_type_name (sh_type
);
4279 case EM_MIPS_RS3_LE
:
4280 result
= get_mips_section_type_name (sh_type
);
4283 result
= get_parisc_section_type_name (sh_type
);
4286 result
= get_ia64_section_type_name (filedata
, sh_type
);
4291 result
= get_x86_64_section_type_name (sh_type
);
4294 result
= get_aarch64_section_type_name (sh_type
);
4297 result
= get_arm_section_type_name (sh_type
);
4300 result
= get_tic6x_section_type_name (sh_type
);
4303 result
= get_msp430x_section_type_name (sh_type
);
4306 result
= get_nfp_section_type_name (sh_type
);
4310 case EM_CYGNUS_V850
:
4311 result
= get_v850_section_type_name (sh_type
);
4314 result
= get_riscv_section_type_name (sh_type
);
4324 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4326 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4328 switch (filedata
->file_header
.e_machine
)
4331 result
= get_ia64_section_type_name (filedata
, sh_type
);
4334 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4335 result
= get_solaris_section_type (sh_type
);
4340 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4341 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4342 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4343 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4355 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4357 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4359 switch (filedata
->file_header
.e_machine
)
4363 case EM_CYGNUS_V850
:
4364 result
= get_v850_section_type_name (sh_type
);
4374 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4377 /* This message is probably going to be displayed in a 15
4378 character wide field, so put the hex value first. */
4379 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4385 #define OPTION_DEBUG_DUMP 512
4386 #define OPTION_DYN_SYMS 513
4387 #define OPTION_DWARF_DEPTH 514
4388 #define OPTION_DWARF_START 515
4389 #define OPTION_DWARF_CHECK 516
4391 static struct option options
[] =
4393 {"all", no_argument
, 0, 'a'},
4394 {"file-header", no_argument
, 0, 'h'},
4395 {"program-headers", no_argument
, 0, 'l'},
4396 {"headers", no_argument
, 0, 'e'},
4397 {"histogram", no_argument
, 0, 'I'},
4398 {"segments", no_argument
, 0, 'l'},
4399 {"sections", no_argument
, 0, 'S'},
4400 {"section-headers", no_argument
, 0, 'S'},
4401 {"section-groups", no_argument
, 0, 'g'},
4402 {"section-details", no_argument
, 0, 't'},
4403 {"full-section-name",no_argument
, 0, 'N'},
4404 {"symbols", no_argument
, 0, 's'},
4405 {"syms", no_argument
, 0, 's'},
4406 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4407 {"relocs", no_argument
, 0, 'r'},
4408 {"notes", no_argument
, 0, 'n'},
4409 {"dynamic", no_argument
, 0, 'd'},
4410 {"arch-specific", no_argument
, 0, 'A'},
4411 {"version-info", no_argument
, 0, 'V'},
4412 {"use-dynamic", no_argument
, 0, 'D'},
4413 {"unwind", no_argument
, 0, 'u'},
4414 {"archive-index", no_argument
, 0, 'c'},
4415 {"hex-dump", required_argument
, 0, 'x'},
4416 {"relocated-dump", required_argument
, 0, 'R'},
4417 {"string-dump", required_argument
, 0, 'p'},
4418 {"decompress", no_argument
, 0, 'z'},
4419 #ifdef SUPPORT_DISASSEMBLY
4420 {"instruction-dump", required_argument
, 0, 'i'},
4422 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4424 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4425 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4426 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4428 {"version", no_argument
, 0, 'v'},
4429 {"wide", no_argument
, 0, 'W'},
4430 {"help", no_argument
, 0, 'H'},
4431 {0, no_argument
, 0, 0}
4435 usage (FILE * stream
)
4437 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4438 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4439 fprintf (stream
, _(" Options are:\n\
4440 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4441 -h --file-header Display the ELF file header\n\
4442 -l --program-headers Display the program headers\n\
4443 --segments An alias for --program-headers\n\
4444 -S --section-headers Display the sections' header\n\
4445 --sections An alias for --section-headers\n\
4446 -g --section-groups Display the section groups\n\
4447 -t --section-details Display the section details\n\
4448 -e --headers Equivalent to: -h -l -S\n\
4449 -s --syms Display the symbol table\n\
4450 --symbols An alias for --syms\n\
4451 --dyn-syms Display the dynamic symbol table\n\
4452 -n --notes Display the core notes (if present)\n\
4453 -r --relocs Display the relocations (if present)\n\
4454 -u --unwind Display the unwind info (if present)\n\
4455 -d --dynamic Display the dynamic section (if present)\n\
4456 -V --version-info Display the version sections (if present)\n\
4457 -A --arch-specific Display architecture specific information (if any)\n\
4458 -c --archive-index Display the symbol/file index in an archive\n\
4459 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4460 -x --hex-dump=<number|name>\n\
4461 Dump the contents of section <number|name> as bytes\n\
4462 -p --string-dump=<number|name>\n\
4463 Dump the contents of section <number|name> as strings\n\
4464 -R --relocated-dump=<number|name>\n\
4465 Dump the contents of section <number|name> as relocated bytes\n\
4466 -z --decompress Decompress section before dumping it\n\
4467 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4468 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4469 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4470 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4471 =addr,=cu_index,=links,=follow-links]\n\
4472 Display the contents of DWARF debug sections\n"));
4473 fprintf (stream
, _("\
4474 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4475 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4477 #ifdef SUPPORT_DISASSEMBLY
4478 fprintf (stream
, _("\
4479 -i --instruction-dump=<number|name>\n\
4480 Disassemble the contents of section <number|name>\n"));
4482 fprintf (stream
, _("\
4483 -I --histogram Display histogram of bucket list lengths\n\
4484 -W --wide Allow output width to exceed 80 characters\n\
4485 @<file> Read options from <file>\n\
4486 -H --help Display this information\n\
4487 -v --version Display the version number of readelf\n"));
4489 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4490 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4492 exit (stream
== stdout
? 0 : 1);
4495 /* Record the fact that the user wants the contents of section number
4496 SECTION to be displayed using the method(s) encoded as flags bits
4497 in TYPE. Note, TYPE can be zero if we are creating the array for
4501 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4503 if (section
>= filedata
->num_dump_sects
)
4505 dump_type
* new_dump_sects
;
4507 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4508 sizeof (* new_dump_sects
));
4510 if (new_dump_sects
== NULL
)
4511 error (_("Out of memory allocating dump request table.\n"));
4514 if (filedata
->dump_sects
)
4516 /* Copy current flag settings. */
4517 memcpy (new_dump_sects
, filedata
->dump_sects
,
4518 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4520 free (filedata
->dump_sects
);
4523 filedata
->dump_sects
= new_dump_sects
;
4524 filedata
->num_dump_sects
= section
+ 1;
4528 if (filedata
->dump_sects
)
4529 filedata
->dump_sects
[section
] |= type
;
4532 /* Request a dump by section name. */
4535 request_dump_byname (const char * section
, dump_type type
)
4537 struct dump_list_entry
* new_request
;
4539 new_request
= (struct dump_list_entry
*)
4540 malloc (sizeof (struct dump_list_entry
));
4542 error (_("Out of memory allocating dump request table.\n"));
4544 new_request
->name
= strdup (section
);
4545 if (!new_request
->name
)
4546 error (_("Out of memory allocating dump request table.\n"));
4548 new_request
->type
= type
;
4550 new_request
->next
= dump_sects_byname
;
4551 dump_sects_byname
= new_request
;
4555 request_dump (Filedata
* filedata
, dump_type type
)
4561 section
= strtoul (optarg
, & cp
, 0);
4563 if (! *cp
&& section
>= 0)
4564 request_dump_bynumber (filedata
, section
, type
);
4566 request_dump_byname (optarg
, type
);
4570 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4577 while ((c
= getopt_long
4578 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4596 do_section_groups
= TRUE
;
4599 do_histogram
= TRUE
;
4604 do_section_groups
= TRUE
;
4609 do_section_details
= TRUE
;
4620 do_using_dynamic
= TRUE
;
4644 do_histogram
= TRUE
;
4650 do_archive_index
= TRUE
;
4653 request_dump (filedata
, HEX_DUMP
);
4656 request_dump (filedata
, STRING_DUMP
);
4659 request_dump (filedata
, RELOC_DUMP
);
4662 decompress_dumps
= TRUE
;
4668 do_debugging
= TRUE
;
4669 dwarf_select_sections_all ();
4673 do_debugging
= FALSE
;
4674 dwarf_select_sections_by_letters (optarg
);
4677 case OPTION_DEBUG_DUMP
:
4680 do_debugging
= TRUE
;
4683 do_debugging
= FALSE
;
4684 dwarf_select_sections_by_names (optarg
);
4687 case OPTION_DWARF_DEPTH
:
4691 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4694 case OPTION_DWARF_START
:
4698 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4701 case OPTION_DWARF_CHECK
:
4704 case OPTION_DYN_SYMS
:
4707 #ifdef SUPPORT_DISASSEMBLY
4709 request_dump (filedata
, DISASS_DUMP
);
4713 print_version (program_name
);
4722 /* xgettext:c-format */
4723 error (_("Invalid option '-%c'\n"), c
);
4730 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4731 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4732 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4733 && !do_section_groups
&& !do_archive_index
4739 get_elf_class (unsigned int elf_class
)
4741 static char buff
[32];
4745 case ELFCLASSNONE
: return _("none");
4746 case ELFCLASS32
: return "ELF32";
4747 case ELFCLASS64
: return "ELF64";
4749 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4755 get_data_encoding (unsigned int encoding
)
4757 static char buff
[32];
4761 case ELFDATANONE
: return _("none");
4762 case ELFDATA2LSB
: return _("2's complement, little endian");
4763 case ELFDATA2MSB
: return _("2's complement, big endian");
4765 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4770 /* Decode the data held in 'filedata->file_header'. */
4773 process_file_header (Filedata
* filedata
)
4775 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4777 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4778 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4779 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4780 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4783 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4787 init_dwarf_regnames (header
->e_machine
);
4793 printf (_("ELF Header:\n"));
4794 printf (_(" Magic: "));
4795 for (i
= 0; i
< EI_NIDENT
; i
++)
4796 printf ("%2.2x ", header
->e_ident
[i
]);
4798 printf (_(" Class: %s\n"),
4799 get_elf_class (header
->e_ident
[EI_CLASS
]));
4800 printf (_(" Data: %s\n"),
4801 get_data_encoding (header
->e_ident
[EI_DATA
]));
4802 printf (_(" Version: %d%s\n"),
4803 header
->e_ident
[EI_VERSION
],
4804 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4806 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4809 printf (_(" OS/ABI: %s\n"),
4810 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4811 printf (_(" ABI Version: %d\n"),
4812 header
->e_ident
[EI_ABIVERSION
]);
4813 printf (_(" Type: %s\n"),
4814 get_file_type (header
->e_type
));
4815 printf (_(" Machine: %s\n"),
4816 get_machine_name (header
->e_machine
));
4817 printf (_(" Version: 0x%lx\n"),
4820 printf (_(" Entry point address: "));
4821 print_vma (header
->e_entry
, PREFIX_HEX
);
4822 printf (_("\n Start of program headers: "));
4823 print_vma (header
->e_phoff
, DEC
);
4824 printf (_(" (bytes into file)\n Start of section headers: "));
4825 print_vma (header
->e_shoff
, DEC
);
4826 printf (_(" (bytes into file)\n"));
4828 printf (_(" Flags: 0x%lx%s\n"),
4830 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4831 printf (_(" Size of this header: %u (bytes)\n"),
4833 printf (_(" Size of program headers: %u (bytes)\n"),
4834 header
->e_phentsize
);
4835 printf (_(" Number of program headers: %u"),
4837 if (filedata
->section_headers
!= NULL
4838 && header
->e_phnum
== PN_XNUM
4839 && filedata
->section_headers
[0].sh_info
!= 0)
4841 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4842 printf (" (%u)", header
->e_phnum
);
4844 putc ('\n', stdout
);
4845 printf (_(" Size of section headers: %u (bytes)\n"),
4846 header
->e_shentsize
);
4847 printf (_(" Number of section headers: %u"),
4849 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4851 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4852 printf (" (%u)", header
->e_shnum
);
4854 putc ('\n', stdout
);
4855 printf (_(" Section header string table index: %u"),
4856 header
->e_shstrndx
);
4857 if (filedata
->section_headers
!= NULL
4858 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4860 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4861 printf (" (%u)", header
->e_shstrndx
);
4863 if (header
->e_shstrndx
!= SHN_UNDEF
4864 && header
->e_shstrndx
>= header
->e_shnum
)
4866 header
->e_shstrndx
= SHN_UNDEF
;
4867 printf (_(" <corrupt: out of range>"));
4869 putc ('\n', stdout
);
4872 if (filedata
->section_headers
!= NULL
)
4874 if (header
->e_phnum
== PN_XNUM
4875 && filedata
->section_headers
[0].sh_info
!= 0)
4876 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4877 if (header
->e_shnum
== SHN_UNDEF
)
4878 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4879 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4880 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4881 if (header
->e_shstrndx
>= header
->e_shnum
)
4882 header
->e_shstrndx
= SHN_UNDEF
;
4883 free (filedata
->section_headers
);
4884 filedata
->section_headers
= NULL
;
4890 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4891 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4894 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4896 Elf32_External_Phdr
* phdrs
;
4897 Elf32_External_Phdr
* external
;
4898 Elf_Internal_Phdr
* internal
;
4900 unsigned int size
= filedata
->file_header
.e_phentsize
;
4901 unsigned int num
= filedata
->file_header
.e_phnum
;
4903 /* PR binutils/17531: Cope with unexpected section header sizes. */
4904 if (size
== 0 || num
== 0)
4906 if (size
< sizeof * phdrs
)
4908 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4911 if (size
> sizeof * phdrs
)
4912 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4914 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4915 size
, num
, _("program headers"));
4919 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4920 i
< filedata
->file_header
.e_phnum
;
4921 i
++, internal
++, external
++)
4923 internal
->p_type
= BYTE_GET (external
->p_type
);
4924 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4925 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4926 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4927 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4928 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4929 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4930 internal
->p_align
= BYTE_GET (external
->p_align
);
4937 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4938 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4941 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4943 Elf64_External_Phdr
* phdrs
;
4944 Elf64_External_Phdr
* external
;
4945 Elf_Internal_Phdr
* internal
;
4947 unsigned int size
= filedata
->file_header
.e_phentsize
;
4948 unsigned int num
= filedata
->file_header
.e_phnum
;
4950 /* PR binutils/17531: Cope with unexpected section header sizes. */
4951 if (size
== 0 || num
== 0)
4953 if (size
< sizeof * phdrs
)
4955 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4958 if (size
> sizeof * phdrs
)
4959 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4961 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4962 size
, num
, _("program headers"));
4966 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4967 i
< filedata
->file_header
.e_phnum
;
4968 i
++, internal
++, external
++)
4970 internal
->p_type
= BYTE_GET (external
->p_type
);
4971 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4972 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4973 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4974 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4975 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4976 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4977 internal
->p_align
= BYTE_GET (external
->p_align
);
4984 /* Returns TRUE if the program headers were read into `program_headers'. */
4987 get_program_headers (Filedata
* filedata
)
4989 Elf_Internal_Phdr
* phdrs
;
4991 /* Check cache of prior read. */
4992 if (filedata
->program_headers
!= NULL
)
4995 /* Be kind to memory checkers by looking for
4996 e_phnum values which we know must be invalid. */
4997 if (filedata
->file_header
.e_phnum
4998 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4999 >= filedata
->file_size
)
5001 error (_("Too many program headers - %#x - the file is not that big\n"),
5002 filedata
->file_header
.e_phnum
);
5006 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5007 sizeof (Elf_Internal_Phdr
));
5010 error (_("Out of memory reading %u program headers\n"),
5011 filedata
->file_header
.e_phnum
);
5016 ? get_32bit_program_headers (filedata
, phdrs
)
5017 : get_64bit_program_headers (filedata
, phdrs
))
5019 filedata
->program_headers
= phdrs
;
5027 /* Returns TRUE if the program headers were loaded. */
5030 process_program_headers (Filedata
* filedata
)
5032 Elf_Internal_Phdr
* segment
;
5034 Elf_Internal_Phdr
* previous_load
= NULL
;
5036 if (filedata
->file_header
.e_phnum
== 0)
5038 /* PR binutils/12467. */
5039 if (filedata
->file_header
.e_phoff
!= 0)
5041 warn (_("possibly corrupt ELF header - it has a non-zero program"
5042 " header offset, but no program headers\n"));
5045 else if (do_segments
)
5046 printf (_("\nThere are no program headers in this file.\n"));
5050 if (do_segments
&& !do_header
)
5052 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5053 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5054 printf (ngettext ("There is %d program header, starting at offset %s\n",
5055 "There are %d program headers, starting at offset %s\n",
5056 filedata
->file_header
.e_phnum
),
5057 filedata
->file_header
.e_phnum
,
5058 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5061 if (! get_program_headers (filedata
))
5066 if (filedata
->file_header
.e_phnum
> 1)
5067 printf (_("\nProgram Headers:\n"));
5069 printf (_("\nProgram Headers:\n"));
5073 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5076 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5080 (_(" Type Offset VirtAddr PhysAddr\n"));
5082 (_(" FileSiz MemSiz Flags Align\n"));
5089 for (i
= 0, segment
= filedata
->program_headers
;
5090 i
< filedata
->file_header
.e_phnum
;
5095 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5099 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5100 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5101 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5102 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5103 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5105 (segment
->p_flags
& PF_R
? 'R' : ' '),
5106 (segment
->p_flags
& PF_W
? 'W' : ' '),
5107 (segment
->p_flags
& PF_X
? 'E' : ' '));
5108 printf ("%#lx", (unsigned long) segment
->p_align
);
5112 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5113 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5116 print_vma (segment
->p_offset
, FULL_HEX
);
5120 print_vma (segment
->p_vaddr
, FULL_HEX
);
5122 print_vma (segment
->p_paddr
, FULL_HEX
);
5125 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5126 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5129 print_vma (segment
->p_filesz
, FULL_HEX
);
5133 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5134 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5137 print_vma (segment
->p_memsz
, FULL_HEX
);
5141 (segment
->p_flags
& PF_R
? 'R' : ' '),
5142 (segment
->p_flags
& PF_W
? 'W' : ' '),
5143 (segment
->p_flags
& PF_X
? 'E' : ' '));
5145 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5146 printf ("%#lx", (unsigned long) segment
->p_align
);
5149 print_vma (segment
->p_align
, PREFIX_HEX
);
5154 print_vma (segment
->p_offset
, FULL_HEX
);
5156 print_vma (segment
->p_vaddr
, FULL_HEX
);
5158 print_vma (segment
->p_paddr
, FULL_HEX
);
5160 print_vma (segment
->p_filesz
, FULL_HEX
);
5162 print_vma (segment
->p_memsz
, FULL_HEX
);
5164 (segment
->p_flags
& PF_R
? 'R' : ' '),
5165 (segment
->p_flags
& PF_W
? 'W' : ' '),
5166 (segment
->p_flags
& PF_X
? 'E' : ' '));
5167 print_vma (segment
->p_align
, PREFIX_HEX
);
5170 putc ('\n', stdout
);
5173 switch (segment
->p_type
)
5176 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5177 required by the ELF standard, several programs, including the Linux
5178 kernel, make use of non-ordered segments. */
5180 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5181 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5183 if (segment
->p_memsz
< segment
->p_filesz
)
5184 error (_("the segment's file size is larger than its memory size\n"));
5185 previous_load
= segment
;
5189 /* PR 20815 - Verify that the program header is loaded into memory. */
5190 if (i
> 0 && previous_load
!= NULL
)
5191 error (_("the PHDR segment must occur before any LOAD segment\n"));
5192 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5196 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5197 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5198 && (filedata
->program_headers
[j
].p_vaddr
5199 + filedata
->program_headers
[j
].p_memsz
)
5200 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5202 if (j
== filedata
->file_header
.e_phnum
)
5203 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5209 error (_("more than one dynamic segment\n"));
5211 /* By default, assume that the .dynamic section is the first
5212 section in the DYNAMIC segment. */
5213 dynamic_addr
= segment
->p_offset
;
5214 dynamic_size
= segment
->p_filesz
;
5216 /* Try to locate the .dynamic section. If there is
5217 a section header table, we can easily locate it. */
5218 if (filedata
->section_headers
!= NULL
)
5220 Elf_Internal_Shdr
* sec
;
5222 sec
= find_section (filedata
, ".dynamic");
5223 if (sec
== NULL
|| sec
->sh_size
== 0)
5225 /* A corresponding .dynamic section is expected, but on
5226 IA-64/OpenVMS it is OK for it to be missing. */
5227 if (!is_ia64_vms (filedata
))
5228 error (_("no .dynamic section in the dynamic segment\n"));
5232 if (sec
->sh_type
== SHT_NOBITS
)
5238 dynamic_addr
= sec
->sh_offset
;
5239 dynamic_size
= sec
->sh_size
;
5241 if (dynamic_addr
< segment
->p_offset
5242 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5243 warn (_("the .dynamic section is not contained"
5244 " within the dynamic segment\n"));
5245 else if (dynamic_addr
> segment
->p_offset
)
5246 warn (_("the .dynamic section is not the first section"
5247 " in the dynamic segment.\n"));
5250 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5251 segment. Check this after matching against the section headers
5252 so we don't warn on debuginfo file (which have NOBITS .dynamic
5254 if (dynamic_addr
> filedata
->file_size
5255 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5257 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5258 dynamic_addr
= dynamic_size
= 0;
5263 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5265 error (_("Unable to find program interpreter name\n"));
5269 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5271 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5272 error (_("Internal error: failed to create format string to display program interpreter\n"));
5274 program_interpreter
[0] = 0;
5275 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5276 error (_("Unable to read program interpreter name\n"));
5279 printf (_(" [Requesting program interpreter: %s]\n"),
5280 program_interpreter
);
5287 && filedata
->section_headers
!= NULL
5288 && filedata
->string_table
!= NULL
)
5290 printf (_("\n Section to Segment mapping:\n"));
5291 printf (_(" Segment Sections...\n"));
5293 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5296 Elf_Internal_Shdr
* section
;
5298 segment
= filedata
->program_headers
+ i
;
5299 section
= filedata
->section_headers
+ 1;
5301 printf (" %2.2d ", i
);
5303 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5305 if (!ELF_TBSS_SPECIAL (section
, segment
)
5306 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5307 printf ("%s ", printable_section_name (filedata
, section
));
5318 /* Find the file offset corresponding to VMA by using the program headers. */
5321 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5323 Elf_Internal_Phdr
* seg
;
5325 if (! get_program_headers (filedata
))
5327 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5331 for (seg
= filedata
->program_headers
;
5332 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5335 if (seg
->p_type
!= PT_LOAD
)
5338 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5339 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5340 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5343 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5344 (unsigned long) vma
);
5349 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5350 If PROBE is true, this is just a probe and we do not generate any error
5351 messages if the load fails. */
5354 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5356 Elf32_External_Shdr
* shdrs
;
5357 Elf_Internal_Shdr
* internal
;
5359 unsigned int size
= filedata
->file_header
.e_shentsize
;
5360 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5362 /* PR binutils/17531: Cope with unexpected section header sizes. */
5363 if (size
== 0 || num
== 0)
5365 if (size
< sizeof * shdrs
)
5368 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5371 if (!probe
&& size
> sizeof * shdrs
)
5372 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5374 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5376 probe
? NULL
: _("section headers"));
5380 free (filedata
->section_headers
);
5381 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5382 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5383 if (filedata
->section_headers
== NULL
)
5386 error (_("Out of memory reading %u section headers\n"), num
);
5391 for (i
= 0, internal
= filedata
->section_headers
;
5395 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5396 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5397 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5398 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5399 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5400 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5401 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5402 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5403 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5404 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5405 if (!probe
&& internal
->sh_link
> num
)
5406 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5407 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5408 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5415 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5418 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5420 Elf64_External_Shdr
* shdrs
;
5421 Elf_Internal_Shdr
* internal
;
5423 unsigned int size
= filedata
->file_header
.e_shentsize
;
5424 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5426 /* PR binutils/17531: Cope with unexpected section header sizes. */
5427 if (size
== 0 || num
== 0)
5430 if (size
< sizeof * shdrs
)
5433 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5437 if (! probe
&& size
> sizeof * shdrs
)
5438 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5440 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5441 filedata
->file_header
.e_shoff
,
5443 probe
? NULL
: _("section headers"));
5447 free (filedata
->section_headers
);
5448 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5449 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5450 if (filedata
->section_headers
== NULL
)
5453 error (_("Out of memory reading %u section headers\n"), num
);
5458 for (i
= 0, internal
= filedata
->section_headers
;
5462 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5463 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5464 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5465 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5466 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5467 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5468 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5469 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5470 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5471 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5472 if (!probe
&& internal
->sh_link
> num
)
5473 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5474 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5475 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5482 static Elf_Internal_Sym
*
5483 get_32bit_elf_symbols (Filedata
* filedata
,
5484 Elf_Internal_Shdr
* section
,
5485 unsigned long * num_syms_return
)
5487 unsigned long number
= 0;
5488 Elf32_External_Sym
* esyms
= NULL
;
5489 Elf_External_Sym_Shndx
* shndx
= NULL
;
5490 Elf_Internal_Sym
* isyms
= NULL
;
5491 Elf_Internal_Sym
* psym
;
5493 elf_section_list
* entry
;
5495 if (section
->sh_size
== 0)
5497 if (num_syms_return
!= NULL
)
5498 * num_syms_return
= 0;
5502 /* Run some sanity checks first. */
5503 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5505 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5506 printable_section_name (filedata
, section
),
5507 (unsigned long) section
->sh_entsize
);
5511 if (section
->sh_size
> filedata
->file_size
)
5513 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5514 printable_section_name (filedata
, section
),
5515 (unsigned long) section
->sh_size
);
5519 number
= section
->sh_size
/ section
->sh_entsize
;
5521 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5523 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5524 (unsigned long) section
->sh_size
,
5525 printable_section_name (filedata
, section
),
5526 (unsigned long) section
->sh_entsize
);
5530 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5531 section
->sh_size
, _("symbols"));
5536 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5538 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5543 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5547 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5548 entry
->hdr
->sh_offset
,
5549 1, entry
->hdr
->sh_size
,
5550 _("symbol table section indices"));
5554 /* PR17531: file: heap-buffer-overflow */
5555 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5557 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5558 printable_section_name (filedata
, entry
->hdr
),
5559 (unsigned long) entry
->hdr
->sh_size
,
5560 (unsigned long) section
->sh_size
);
5565 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5569 error (_("Out of memory reading %lu symbols\n"),
5570 (unsigned long) number
);
5574 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5576 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5577 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5578 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5579 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5580 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5582 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5583 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5584 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5585 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5586 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5593 if (num_syms_return
!= NULL
)
5594 * num_syms_return
= isyms
== NULL
? 0 : number
;
5599 static Elf_Internal_Sym
*
5600 get_64bit_elf_symbols (Filedata
* filedata
,
5601 Elf_Internal_Shdr
* section
,
5602 unsigned long * num_syms_return
)
5604 unsigned long number
= 0;
5605 Elf64_External_Sym
* esyms
= NULL
;
5606 Elf_External_Sym_Shndx
* shndx
= NULL
;
5607 Elf_Internal_Sym
* isyms
= NULL
;
5608 Elf_Internal_Sym
* psym
;
5610 elf_section_list
* entry
;
5612 if (section
->sh_size
== 0)
5614 if (num_syms_return
!= NULL
)
5615 * num_syms_return
= 0;
5619 /* Run some sanity checks first. */
5620 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5622 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5623 printable_section_name (filedata
, section
),
5624 (unsigned long) section
->sh_entsize
);
5628 if (section
->sh_size
> filedata
->file_size
)
5630 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5631 printable_section_name (filedata
, section
),
5632 (unsigned long) section
->sh_size
);
5636 number
= section
->sh_size
/ section
->sh_entsize
;
5638 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5640 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5641 (unsigned long) section
->sh_size
,
5642 printable_section_name (filedata
, section
),
5643 (unsigned long) section
->sh_entsize
);
5647 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5648 section
->sh_size
, _("symbols"));
5653 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5655 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5660 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5664 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5665 entry
->hdr
->sh_offset
,
5666 1, entry
->hdr
->sh_size
,
5667 _("symbol table section indices"));
5671 /* PR17531: file: heap-buffer-overflow */
5672 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5674 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5675 printable_section_name (filedata
, entry
->hdr
),
5676 (unsigned long) entry
->hdr
->sh_size
,
5677 (unsigned long) section
->sh_size
);
5682 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5686 error (_("Out of memory reading %lu symbols\n"),
5687 (unsigned long) number
);
5691 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5693 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5694 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5695 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5696 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5698 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5700 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5701 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5702 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5704 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5705 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5712 if (num_syms_return
!= NULL
)
5713 * num_syms_return
= isyms
== NULL
? 0 : number
;
5719 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5721 static char buff
[1024];
5723 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5725 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5726 bfd_vma os_flags
= 0;
5727 bfd_vma proc_flags
= 0;
5728 bfd_vma unknown_flags
= 0;
5736 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5737 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5738 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5739 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5740 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5741 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5742 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5743 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5744 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5745 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5746 /* IA-64 specific. */
5747 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5748 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5749 /* IA-64 OpenVMS specific. */
5750 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5751 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5752 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5753 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5754 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5755 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5757 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5758 /* SPARC specific. */
5759 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5760 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5762 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5763 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5764 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5766 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5768 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5771 if (do_section_details
)
5773 sprintf (buff
, "[%*.*lx]: ",
5774 field_size
, field_size
, (unsigned long) sh_flags
);
5775 p
+= field_size
+ 4;
5782 flag
= sh_flags
& - sh_flags
;
5785 if (do_section_details
)
5789 case SHF_WRITE
: sindex
= 0; break;
5790 case SHF_ALLOC
: sindex
= 1; break;
5791 case SHF_EXECINSTR
: sindex
= 2; break;
5792 case SHF_MERGE
: sindex
= 3; break;
5793 case SHF_STRINGS
: sindex
= 4; break;
5794 case SHF_INFO_LINK
: sindex
= 5; break;
5795 case SHF_LINK_ORDER
: sindex
= 6; break;
5796 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5797 case SHF_GROUP
: sindex
= 8; break;
5798 case SHF_TLS
: sindex
= 9; break;
5799 case SHF_EXCLUDE
: sindex
= 18; break;
5800 case SHF_COMPRESSED
: sindex
= 20; break;
5801 case SHF_GNU_MBIND
: sindex
= 24; break;
5805 switch (filedata
->file_header
.e_machine
)
5808 if (flag
== SHF_IA_64_SHORT
)
5810 else if (flag
== SHF_IA_64_NORECOV
)
5813 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5816 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5817 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5818 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5819 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5820 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5821 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5832 case EM_OLD_SPARCV9
:
5833 case EM_SPARC32PLUS
:
5836 if (flag
== SHF_ORDERED
)
5843 case SHF_ENTRYSECT
: sindex
= 21; break;
5844 case SHF_ARM_PURECODE
: sindex
= 22; break;
5845 case SHF_COMDEF
: sindex
= 23; break;
5850 if (flag
== SHF_PPC_VLE
)
5861 if (p
!= buff
+ field_size
+ 4)
5863 if (size
< (10 + 2))
5865 warn (_("Internal error: not enough buffer room for section flag info"));
5866 return _("<unknown>");
5873 size
-= flags
[sindex
].len
;
5874 p
= stpcpy (p
, flags
[sindex
].str
);
5876 else if (flag
& SHF_MASKOS
)
5878 else if (flag
& SHF_MASKPROC
)
5881 unknown_flags
|= flag
;
5887 case SHF_WRITE
: *p
= 'W'; break;
5888 case SHF_ALLOC
: *p
= 'A'; break;
5889 case SHF_EXECINSTR
: *p
= 'X'; break;
5890 case SHF_MERGE
: *p
= 'M'; break;
5891 case SHF_STRINGS
: *p
= 'S'; break;
5892 case SHF_INFO_LINK
: *p
= 'I'; break;
5893 case SHF_LINK_ORDER
: *p
= 'L'; break;
5894 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5895 case SHF_GROUP
: *p
= 'G'; break;
5896 case SHF_TLS
: *p
= 'T'; break;
5897 case SHF_EXCLUDE
: *p
= 'E'; break;
5898 case SHF_COMPRESSED
: *p
= 'C'; break;
5899 case SHF_GNU_MBIND
: *p
= 'D'; break;
5902 if ((filedata
->file_header
.e_machine
== EM_X86_64
5903 || filedata
->file_header
.e_machine
== EM_L1OM
5904 || filedata
->file_header
.e_machine
== EM_K1OM
)
5905 && flag
== SHF_X86_64_LARGE
)
5907 else if (filedata
->file_header
.e_machine
== EM_ARM
5908 && flag
== SHF_ARM_PURECODE
)
5910 else if (filedata
->file_header
.e_machine
== EM_PPC
5911 && flag
== SHF_PPC_VLE
)
5913 else if (flag
& SHF_MASKOS
)
5916 sh_flags
&= ~ SHF_MASKOS
;
5918 else if (flag
& SHF_MASKPROC
)
5921 sh_flags
&= ~ SHF_MASKPROC
;
5931 if (do_section_details
)
5935 size
-= 5 + field_size
;
5936 if (p
!= buff
+ field_size
+ 4)
5940 warn (_("Internal error: not enough buffer room for section flag info"));
5941 return _("<unknown>");
5947 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5948 (unsigned long) os_flags
);
5949 p
+= 5 + field_size
;
5953 size
-= 7 + field_size
;
5954 if (p
!= buff
+ field_size
+ 4)
5958 warn (_("Internal error: not enough buffer room for section flag info"));
5959 return _("<unknown>");
5965 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5966 (unsigned long) proc_flags
);
5967 p
+= 7 + field_size
;
5971 size
-= 10 + field_size
;
5972 if (p
!= buff
+ field_size
+ 4)
5976 warn (_("Internal error: not enough buffer room for section flag info"));
5977 return _("<unknown>");
5983 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5984 (unsigned long) unknown_flags
);
5985 p
+= 10 + field_size
;
5994 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5998 Elf32_External_Chdr
*echdr
= (Elf32_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
);
6013 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6015 if (size
< sizeof (* echdr
))
6017 error (_("Compressed section is too small even for a compression header\n"));
6021 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6022 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6023 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6024 return sizeof (*echdr
);
6029 process_section_headers (Filedata
* filedata
)
6031 Elf_Internal_Shdr
* section
;
6034 filedata
->section_headers
= NULL
;
6036 if (filedata
->file_header
.e_shnum
== 0)
6038 /* PR binutils/12467. */
6039 if (filedata
->file_header
.e_shoff
!= 0)
6041 warn (_("possibly corrupt ELF file header - it has a non-zero"
6042 " section header offset, but no section headers\n"));
6045 else if (do_sections
)
6046 printf (_("\nThere are no sections in this file.\n"));
6051 if (do_sections
&& !do_header
)
6052 printf (ngettext ("There is %d section header, "
6053 "starting at offset 0x%lx:\n",
6054 "There are %d section headers, "
6055 "starting at offset 0x%lx:\n",
6056 filedata
->file_header
.e_shnum
),
6057 filedata
->file_header
.e_shnum
,
6058 (unsigned long) filedata
->file_header
.e_shoff
);
6062 if (! get_32bit_section_headers (filedata
, FALSE
))
6067 if (! get_64bit_section_headers (filedata
, FALSE
))
6071 /* Read in the string table, so that we have names to display. */
6072 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6073 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6075 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6077 if (section
->sh_size
!= 0)
6079 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6080 1, section
->sh_size
,
6083 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6087 /* Scan the sections for the dynamic symbol table
6088 and dynamic string table and debug sections. */
6089 dynamic_symbols
= NULL
;
6090 dynamic_strings
= NULL
;
6091 dynamic_syminfo
= NULL
;
6092 symtab_shndx_list
= NULL
;
6094 eh_addr_size
= is_32bit_elf
? 4 : 8;
6095 switch (filedata
->file_header
.e_machine
)
6098 case EM_MIPS_RS3_LE
:
6099 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6100 FDE addresses. However, the ABI also has a semi-official ILP32
6101 variant for which the normal FDE address size rules apply.
6103 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6104 section, where XX is the size of longs in bits. Unfortunately,
6105 earlier compilers provided no way of distinguishing ILP32 objects
6106 from LP64 objects, so if there's any doubt, we should assume that
6107 the official LP64 form is being used. */
6108 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6109 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6115 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6117 case E_H8_MACH_H8300
:
6118 case E_H8_MACH_H8300HN
:
6119 case E_H8_MACH_H8300SN
:
6120 case E_H8_MACH_H8300SXN
:
6123 case E_H8_MACH_H8300H
:
6124 case E_H8_MACH_H8300S
:
6125 case E_H8_MACH_H8300SX
:
6133 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6135 case EF_M32C_CPU_M16C
:
6142 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6145 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6146 if (section->sh_entsize != expected_entsize) \
6149 sprintf_vma (buf, section->sh_entsize); \
6150 /* Note: coded this way so that there is a single string for \
6152 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6153 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6154 (unsigned) expected_entsize); \
6155 section->sh_entsize = expected_entsize; \
6160 #define CHECK_ENTSIZE(section, i, type) \
6161 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6162 sizeof (Elf64_External_##type))
6164 for (i
= 0, section
= filedata
->section_headers
;
6165 i
< filedata
->file_header
.e_shnum
;
6168 char * name
= SECTION_NAME (section
);
6170 if (section
->sh_type
== SHT_DYNSYM
)
6172 if (dynamic_symbols
!= NULL
)
6174 error (_("File contains multiple dynamic symbol tables\n"));
6178 CHECK_ENTSIZE (section
, i
, Sym
);
6179 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6181 else if (section
->sh_type
== SHT_STRTAB
6182 && streq (name
, ".dynstr"))
6184 if (dynamic_strings
!= NULL
)
6186 error (_("File contains multiple dynamic string tables\n"));
6190 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6191 1, section
->sh_size
,
6192 _("dynamic strings"));
6193 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6195 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6197 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6199 entry
->hdr
= section
;
6200 entry
->next
= symtab_shndx_list
;
6201 symtab_shndx_list
= entry
;
6203 else if (section
->sh_type
== SHT_SYMTAB
)
6204 CHECK_ENTSIZE (section
, i
, Sym
);
6205 else if (section
->sh_type
== SHT_GROUP
)
6206 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6207 else if (section
->sh_type
== SHT_REL
)
6208 CHECK_ENTSIZE (section
, i
, Rel
);
6209 else if (section
->sh_type
== SHT_RELA
)
6210 CHECK_ENTSIZE (section
, i
, Rela
);
6211 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6212 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6213 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6214 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6215 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6216 && (const_strneq (name
, ".debug_")
6217 || const_strneq (name
, ".zdebug_")))
6220 name
+= sizeof (".zdebug_") - 1;
6222 name
+= sizeof (".debug_") - 1;
6225 || (do_debug_info
&& const_strneq (name
, "info"))
6226 || (do_debug_info
&& const_strneq (name
, "types"))
6227 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6228 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6229 || (do_debug_lines
&& const_strneq (name
, "line."))
6230 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6231 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6232 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6233 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6234 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6235 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6236 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6237 || (do_debug_frames
&& const_strneq (name
, "frame"))
6238 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6239 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6240 || (do_debug_str
&& const_strneq (name
, "str"))
6241 || (do_debug_loc
&& const_strneq (name
, "loc"))
6242 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6243 || (do_debug_addr
&& const_strneq (name
, "addr"))
6244 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6245 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6247 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6249 /* Linkonce section to be combined with .debug_info at link time. */
6250 else if ((do_debugging
|| do_debug_info
)
6251 && const_strneq (name
, ".gnu.linkonce.wi."))
6252 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6253 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6254 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6255 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6256 || streq (name
, ".debug_names")))
6257 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6258 /* Trace sections for Itanium VMS. */
6259 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6260 || do_trace_aranges
)
6261 && const_strneq (name
, ".trace_"))
6263 name
+= sizeof (".trace_") - 1;
6266 || (do_trace_info
&& streq (name
, "info"))
6267 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6268 || (do_trace_aranges
&& streq (name
, "aranges"))
6270 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6272 else if ((do_debugging
|| do_debug_links
)
6273 && (const_strneq (name
, ".gnu_debuglink")
6274 || const_strneq (name
, ".gnu_debugaltlink")))
6275 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6281 if (filedata
->file_header
.e_shnum
> 1)
6282 printf (_("\nSection Headers:\n"));
6284 printf (_("\nSection Header:\n"));
6288 if (do_section_details
)
6290 printf (_(" [Nr] Name\n"));
6291 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6295 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6299 if (do_section_details
)
6301 printf (_(" [Nr] Name\n"));
6302 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6306 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6310 if (do_section_details
)
6312 printf (_(" [Nr] Name\n"));
6313 printf (_(" Type Address Offset Link\n"));
6314 printf (_(" Size EntSize Info Align\n"));
6318 printf (_(" [Nr] Name Type Address Offset\n"));
6319 printf (_(" Size EntSize Flags Link Info Align\n"));
6323 if (do_section_details
)
6324 printf (_(" Flags\n"));
6326 for (i
= 0, section
= filedata
->section_headers
;
6327 i
< filedata
->file_header
.e_shnum
;
6330 /* Run some sanity checks on the section header. */
6332 /* Check the sh_link field. */
6333 switch (section
->sh_type
)
6337 if (section
->sh_link
== 0
6338 && (filedata
->file_header
.e_type
== ET_EXEC
6339 || filedata
->file_header
.e_type
== ET_DYN
))
6340 /* A dynamic relocation section where all entries use a
6341 zero symbol index need not specify a symtab section. */
6344 case SHT_SYMTAB_SHNDX
:
6348 case SHT_GNU_versym
:
6349 if (section
->sh_link
== 0
6350 || section
->sh_link
>= filedata
->file_header
.e_shnum
6351 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6352 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6353 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6354 i
, section
->sh_link
);
6360 case SHT_GNU_verneed
:
6361 case SHT_GNU_verdef
:
6362 case SHT_GNU_LIBLIST
:
6363 if (section
->sh_link
== 0
6364 || section
->sh_link
>= filedata
->file_header
.e_shnum
6365 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6366 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6367 i
, section
->sh_link
);
6370 case SHT_INIT_ARRAY
:
6371 case SHT_FINI_ARRAY
:
6372 case SHT_PREINIT_ARRAY
:
6373 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6374 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6375 i
, section
->sh_link
);
6379 /* FIXME: Add support for target specific section types. */
6380 #if 0 /* Currently we do not check other section types as there are too
6381 many special cases. Stab sections for example have a type
6382 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6384 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6385 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6386 i
, section
->sh_link
);
6391 /* Check the sh_info field. */
6392 switch (section
->sh_type
)
6396 if (section
->sh_info
== 0
6397 && (filedata
->file_header
.e_type
== ET_EXEC
6398 || filedata
->file_header
.e_type
== ET_DYN
))
6399 /* Dynamic relocations apply to segments, so they do not
6400 need to specify the section they relocate. */
6402 if (section
->sh_info
== 0
6403 || section
->sh_info
>= filedata
->file_header
.e_shnum
6404 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6405 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6406 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6407 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6408 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6409 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6410 /* FIXME: Are other section types valid ? */
6411 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6412 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6413 i
, section
->sh_info
);
6418 case SHT_SYMTAB_SHNDX
:
6419 case SHT_INIT_ARRAY
:
6420 case SHT_FINI_ARRAY
:
6421 case SHT_PREINIT_ARRAY
:
6422 if (section
->sh_info
!= 0)
6423 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6424 i
, section
->sh_info
);
6430 /* A symbol index - we assume that it is valid. */
6434 /* FIXME: Add support for target specific section types. */
6435 if (section
->sh_type
== SHT_NOBITS
)
6436 /* NOBITS section headers with non-zero sh_info fields can be
6437 created when a binary is stripped of everything but its debug
6438 information. The stripped sections have their headers
6439 preserved but their types set to SHT_NOBITS. So do not check
6440 this type of section. */
6442 else if (section
->sh_flags
& SHF_INFO_LINK
)
6444 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6445 warn (_("[%2u]: Expected link to another section in info field"), i
);
6447 else if (section
->sh_type
< SHT_LOOS
6448 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6449 && section
->sh_info
!= 0)
6450 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6451 i
, section
->sh_info
);
6455 /* Check the sh_size field. */
6456 if (section
->sh_size
> filedata
->file_size
6457 && section
->sh_type
!= SHT_NOBITS
6458 && section
->sh_type
!= SHT_NULL
6459 && section
->sh_type
< SHT_LOOS
)
6460 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6462 printf (" [%2u] ", i
);
6463 if (do_section_details
)
6464 printf ("%s\n ", printable_section_name (filedata
, section
));
6466 print_symbol (-17, SECTION_NAME (section
));
6468 printf (do_wide
? " %-15s " : " %-15.15s ",
6469 get_section_type_name (filedata
, section
->sh_type
));
6473 const char * link_too_big
= NULL
;
6475 print_vma (section
->sh_addr
, LONG_HEX
);
6477 printf ( " %6.6lx %6.6lx %2.2lx",
6478 (unsigned long) section
->sh_offset
,
6479 (unsigned long) section
->sh_size
,
6480 (unsigned long) section
->sh_entsize
);
6482 if (do_section_details
)
6483 fputs (" ", stdout
);
6485 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6487 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6490 /* The sh_link value is out of range. Normally this indicates
6491 an error but it can have special values in Solaris binaries. */
6492 switch (filedata
->file_header
.e_machine
)
6499 case EM_OLD_SPARCV9
:
6500 case EM_SPARC32PLUS
:
6503 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6504 link_too_big
= "BEFORE";
6505 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6506 link_too_big
= "AFTER";
6513 if (do_section_details
)
6515 if (link_too_big
!= NULL
&& * link_too_big
)
6516 printf ("<%s> ", link_too_big
);
6518 printf ("%2u ", section
->sh_link
);
6519 printf ("%3u %2lu\n", section
->sh_info
,
6520 (unsigned long) section
->sh_addralign
);
6523 printf ("%2u %3u %2lu\n",
6526 (unsigned long) section
->sh_addralign
);
6528 if (link_too_big
&& ! * link_too_big
)
6529 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6530 i
, section
->sh_link
);
6534 print_vma (section
->sh_addr
, LONG_HEX
);
6536 if ((long) section
->sh_offset
== section
->sh_offset
)
6537 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6541 print_vma (section
->sh_offset
, LONG_HEX
);
6544 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6545 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6549 print_vma (section
->sh_size
, LONG_HEX
);
6552 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6553 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6557 print_vma (section
->sh_entsize
, LONG_HEX
);
6560 if (do_section_details
)
6561 fputs (" ", stdout
);
6563 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6565 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6567 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6568 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6571 print_vma (section
->sh_addralign
, DEC
);
6575 else if (do_section_details
)
6578 print_vma (section
->sh_addr
, LONG_HEX
);
6579 if ((long) section
->sh_offset
== section
->sh_offset
)
6580 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6584 print_vma (section
->sh_offset
, LONG_HEX
);
6586 printf (" %u\n ", section
->sh_link
);
6587 print_vma (section
->sh_size
, LONG_HEX
);
6589 print_vma (section
->sh_entsize
, LONG_HEX
);
6591 printf (" %-16u %lu\n",
6593 (unsigned long) section
->sh_addralign
);
6598 print_vma (section
->sh_addr
, LONG_HEX
);
6599 if ((long) section
->sh_offset
== section
->sh_offset
)
6600 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6604 print_vma (section
->sh_offset
, LONG_HEX
);
6607 print_vma (section
->sh_size
, LONG_HEX
);
6609 print_vma (section
->sh_entsize
, LONG_HEX
);
6611 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6613 printf (" %2u %3u %lu\n",
6616 (unsigned long) section
->sh_addralign
);
6619 if (do_section_details
)
6621 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6622 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6624 /* Minimum section size is 12 bytes for 32-bit compression
6625 header + 12 bytes for compressed data header. */
6626 unsigned char buf
[24];
6628 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6629 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6630 sizeof (buf
), _("compression header")))
6632 Elf_Internal_Chdr chdr
;
6634 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6636 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6639 printf (_(" [<unknown>: 0x%x], "),
6641 print_vma (chdr
.ch_size
, LONG_HEX
);
6642 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6648 if (!do_section_details
)
6650 /* The ordering of the letters shown here matches the ordering of the
6651 corresponding SHF_xxx values, and hence the order in which these
6652 letters will be displayed to the user. */
6653 printf (_("Key to Flags:\n\
6654 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6655 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6656 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6657 if (filedata
->file_header
.e_machine
== EM_X86_64
6658 || filedata
->file_header
.e_machine
== EM_L1OM
6659 || filedata
->file_header
.e_machine
== EM_K1OM
)
6660 printf (_("l (large), "));
6661 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6662 printf (_("y (purecode), "));
6663 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6664 printf (_("v (VLE), "));
6665 printf ("p (processor specific)\n");
6672 get_group_flags (unsigned int flags
)
6674 static char buff
[128];
6678 else if (flags
== GRP_COMDAT
)
6681 snprintf (buff
, 14, _("[0x%x: "), flags
);
6683 flags
&= ~ GRP_COMDAT
;
6684 if (flags
& GRP_MASKOS
)
6686 strcat (buff
, "<OS specific>");
6687 flags
&= ~ GRP_MASKOS
;
6690 if (flags
& GRP_MASKPROC
)
6692 strcat (buff
, "<PROC specific>");
6693 flags
&= ~ GRP_MASKPROC
;
6697 strcat (buff
, "<unknown>");
6704 process_section_groups (Filedata
* filedata
)
6706 Elf_Internal_Shdr
* section
;
6708 struct group
* group
;
6709 Elf_Internal_Shdr
* symtab_sec
;
6710 Elf_Internal_Shdr
* strtab_sec
;
6711 Elf_Internal_Sym
* symtab
;
6712 unsigned long num_syms
;
6716 /* Don't process section groups unless needed. */
6717 if (!do_unwind
&& !do_section_groups
)
6720 if (filedata
->file_header
.e_shnum
== 0)
6722 if (do_section_groups
)
6723 printf (_("\nThere are no sections to group in this file.\n"));
6728 if (filedata
->section_headers
== NULL
)
6730 error (_("Section headers are not available!\n"));
6731 /* PR 13622: This can happen with a corrupt ELF header. */
6735 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6736 sizeof (struct group
*));
6738 if (section_headers_groups
== NULL
)
6740 error (_("Out of memory reading %u section group headers\n"),
6741 filedata
->file_header
.e_shnum
);
6745 /* Scan the sections for the group section. */
6747 for (i
= 0, section
= filedata
->section_headers
;
6748 i
< filedata
->file_header
.e_shnum
;
6750 if (section
->sh_type
== SHT_GROUP
)
6753 if (group_count
== 0)
6755 if (do_section_groups
)
6756 printf (_("\nThere are no section groups in this file.\n"));
6761 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6763 if (section_groups
== NULL
)
6765 error (_("Out of memory reading %lu groups\n"),
6766 (unsigned long) group_count
);
6776 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6777 i
< filedata
->file_header
.e_shnum
;
6780 if (section
->sh_type
== SHT_GROUP
)
6782 const char * name
= printable_section_name (filedata
, section
);
6783 const char * group_name
;
6784 unsigned char * start
;
6785 unsigned char * indices
;
6786 unsigned int entry
, j
, size
;
6787 Elf_Internal_Shdr
* sec
;
6788 Elf_Internal_Sym
* sym
;
6790 /* Get the symbol table. */
6791 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6792 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6795 error (_("Bad sh_link in group section `%s'\n"), name
);
6799 if (symtab_sec
!= sec
)
6804 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6809 error (_("Corrupt header in group section `%s'\n"), name
);
6813 if (section
->sh_info
>= num_syms
)
6815 error (_("Bad sh_info in group section `%s'\n"), name
);
6819 sym
= symtab
+ section
->sh_info
;
6821 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6823 if (sym
->st_shndx
== 0
6824 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6826 error (_("Bad sh_info in group section `%s'\n"), name
);
6830 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6839 /* Get the string table. */
6840 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6849 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6855 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6856 1, strtab_sec
->sh_size
,
6858 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6860 group_name
= sym
->st_name
< strtab_size
6861 ? strtab
+ sym
->st_name
: _("<corrupt>");
6864 /* PR 17531: file: loop. */
6865 if (section
->sh_entsize
> section
->sh_size
)
6867 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6868 printable_section_name (filedata
, section
),
6869 (unsigned long) section
->sh_entsize
,
6870 (unsigned long) section
->sh_size
);
6874 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6875 1, section
->sh_size
,
6881 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6882 entry
= byte_get (indices
, 4);
6885 if (do_section_groups
)
6887 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6888 get_group_flags (entry
), i
, name
, group_name
, size
);
6890 printf (_(" [Index] Name\n"));
6893 group
->group_index
= i
;
6895 for (j
= 0; j
< size
; j
++)
6897 struct group_list
* g
;
6899 entry
= byte_get (indices
, 4);
6902 if (entry
>= filedata
->file_header
.e_shnum
)
6904 static unsigned num_group_errors
= 0;
6906 if (num_group_errors
++ < 10)
6908 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6909 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6910 if (num_group_errors
== 10)
6911 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6916 if (section_headers_groups
[entry
] != NULL
)
6920 static unsigned num_errs
= 0;
6922 if (num_errs
++ < 10)
6924 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6926 section_headers_groups
[entry
]->group_index
);
6928 warn (_("Further error messages about already contained group sections suppressed\n"));
6934 /* Intel C/C++ compiler may put section 0 in a
6935 section group. We just warn it the first time
6936 and ignore it afterwards. */
6937 static bfd_boolean warned
= FALSE
;
6940 error (_("section 0 in group section [%5u]\n"),
6941 section_headers_groups
[entry
]->group_index
);
6947 section_headers_groups
[entry
] = group
;
6949 if (do_section_groups
)
6951 sec
= filedata
->section_headers
+ entry
;
6952 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6955 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6956 g
->section_index
= entry
;
6957 g
->next
= group
->root
;
6975 /* Data used to display dynamic fixups. */
6977 struct ia64_vms_dynfixup
6979 bfd_vma needed_ident
; /* Library ident number. */
6980 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6981 bfd_vma fixup_needed
; /* Index of the library. */
6982 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6983 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6986 /* Data used to display dynamic relocations. */
6988 struct ia64_vms_dynimgrela
6990 bfd_vma img_rela_cnt
; /* Number of relocations. */
6991 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6994 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6998 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6999 struct ia64_vms_dynfixup
* fixup
,
7000 const char * strtab
,
7001 unsigned int strtab_sz
)
7003 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7005 const char * lib_name
;
7007 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7008 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
7009 _("dynamic section image fixups"));
7013 if (fixup
->needed
< strtab_sz
)
7014 lib_name
= strtab
+ fixup
->needed
;
7017 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7018 (unsigned long) fixup
->needed
);
7021 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7022 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7024 (_("Seg Offset Type SymVec DataType\n"));
7026 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7031 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7032 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7033 type
= BYTE_GET (imfs
[i
].type
);
7034 rtype
= elf_ia64_reloc_type (type
);
7036 printf (" 0x%08x ", type
);
7038 printf (" %-32s ", rtype
);
7039 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7040 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7047 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7050 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7052 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7055 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7056 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7057 _("dynamic section image relocations"));
7061 printf (_("\nImage relocs\n"));
7063 (_("Seg Offset Type Addend Seg Sym Off\n"));
7065 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7070 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7071 printf ("%08" BFD_VMA_FMT
"x ",
7072 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7073 type
= BYTE_GET (imrs
[i
].type
);
7074 rtype
= elf_ia64_reloc_type (type
);
7076 printf ("0x%08x ", type
);
7078 printf ("%-31s ", rtype
);
7079 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7080 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7081 printf ("%08" BFD_VMA_FMT
"x\n",
7082 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7089 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7092 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7094 struct ia64_vms_dynfixup fixup
;
7095 struct ia64_vms_dynimgrela imgrela
;
7096 Elf_Internal_Dyn
*entry
;
7097 bfd_vma strtab_off
= 0;
7098 bfd_vma strtab_sz
= 0;
7099 char *strtab
= NULL
;
7100 bfd_boolean res
= TRUE
;
7102 memset (&fixup
, 0, sizeof (fixup
));
7103 memset (&imgrela
, 0, sizeof (imgrela
));
7105 /* Note: the order of the entries is specified by the OpenVMS specs. */
7106 for (entry
= dynamic_section
;
7107 entry
< dynamic_section
+ dynamic_nent
;
7110 switch (entry
->d_tag
)
7112 case DT_IA_64_VMS_STRTAB_OFFSET
:
7113 strtab_off
= entry
->d_un
.d_val
;
7116 strtab_sz
= entry
->d_un
.d_val
;
7118 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7119 1, strtab_sz
, _("dynamic string section"));
7122 case DT_IA_64_VMS_NEEDED_IDENT
:
7123 fixup
.needed_ident
= entry
->d_un
.d_val
;
7126 fixup
.needed
= entry
->d_un
.d_val
;
7128 case DT_IA_64_VMS_FIXUP_NEEDED
:
7129 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7131 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7132 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7134 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7135 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7136 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7139 case DT_IA_64_VMS_IMG_RELA_CNT
:
7140 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7142 case DT_IA_64_VMS_IMG_RELA_OFF
:
7143 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7144 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7166 dynamic_relocations
[] =
7168 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7169 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7170 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7173 /* Process the reloc section. */
7176 process_relocs (Filedata
* filedata
)
7178 unsigned long rel_size
;
7179 unsigned long rel_offset
;
7184 if (do_using_dynamic
)
7188 bfd_boolean has_dynamic_reloc
;
7191 has_dynamic_reloc
= FALSE
;
7193 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7195 is_rela
= dynamic_relocations
[i
].rela
;
7196 name
= dynamic_relocations
[i
].name
;
7197 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7198 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7201 has_dynamic_reloc
= TRUE
;
7203 if (is_rela
== UNKNOWN
)
7205 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7206 switch (dynamic_info
[DT_PLTREL
])
7220 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7221 name
, rel_offset
, rel_size
);
7223 dump_relocations (filedata
,
7224 offset_from_vma (filedata
, rel_offset
, rel_size
),
7226 dynamic_symbols
, num_dynamic_syms
,
7227 dynamic_strings
, dynamic_strings_length
,
7228 is_rela
, TRUE
/* is_dynamic */);
7232 if (is_ia64_vms (filedata
))
7233 if (process_ia64_vms_dynamic_relocs (filedata
))
7234 has_dynamic_reloc
= TRUE
;
7236 if (! has_dynamic_reloc
)
7237 printf (_("\nThere are no dynamic relocations in this file.\n"));
7241 Elf_Internal_Shdr
* section
;
7243 bfd_boolean found
= FALSE
;
7245 for (i
= 0, section
= filedata
->section_headers
;
7246 i
< filedata
->file_header
.e_shnum
;
7249 if ( section
->sh_type
!= SHT_RELA
7250 && section
->sh_type
!= SHT_REL
)
7253 rel_offset
= section
->sh_offset
;
7254 rel_size
= section
->sh_size
;
7258 Elf_Internal_Shdr
* strsec
;
7260 unsigned long num_rela
;
7262 printf (_("\nRelocation section "));
7264 if (filedata
->string_table
== NULL
)
7265 printf ("%d", section
->sh_name
);
7267 printf ("'%s'", printable_section_name (filedata
, section
));
7269 num_rela
= rel_size
/ section
->sh_entsize
;
7270 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7271 " at offset 0x%lx contains %lu entries:\n",
7273 rel_offset
, num_rela
);
7275 is_rela
= section
->sh_type
== SHT_RELA
;
7277 if (section
->sh_link
!= 0
7278 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7280 Elf_Internal_Shdr
* symsec
;
7281 Elf_Internal_Sym
* symtab
;
7282 unsigned long nsyms
;
7283 unsigned long strtablen
= 0;
7284 char * strtab
= NULL
;
7286 symsec
= filedata
->section_headers
+ section
->sh_link
;
7287 if (symsec
->sh_type
!= SHT_SYMTAB
7288 && symsec
->sh_type
!= SHT_DYNSYM
)
7291 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7296 if (symsec
->sh_link
!= 0
7297 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7299 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7301 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7304 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7307 dump_relocations (filedata
, rel_offset
, rel_size
,
7308 symtab
, nsyms
, strtab
, strtablen
,
7310 symsec
->sh_type
== SHT_DYNSYM
);
7316 dump_relocations (filedata
, rel_offset
, rel_size
,
7317 NULL
, 0, NULL
, 0, is_rela
,
7318 FALSE
/* is_dynamic */);
7326 /* Users sometimes forget the -D option, so try to be helpful. */
7327 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7329 if (dynamic_info
[dynamic_relocations
[i
].size
])
7331 printf (_("\nThere are no static relocations in this file."));
7332 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7337 if (i
== ARRAY_SIZE (dynamic_relocations
))
7338 printf (_("\nThere are no relocations in this file.\n"));
7345 /* An absolute address consists of a section and an offset. If the
7346 section is NULL, the offset itself is the address, otherwise, the
7347 address equals to LOAD_ADDRESS(section) + offset. */
7351 unsigned short section
;
7355 #define ABSADDR(a) \
7357 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7360 /* Find the nearest symbol at or below ADDR. Returns the symbol
7361 name, if found, and the offset from the symbol to ADDR. */
7364 find_symbol_for_address (Filedata
* filedata
,
7365 Elf_Internal_Sym
* symtab
,
7366 unsigned long nsyms
,
7367 const char * strtab
,
7368 unsigned long strtab_size
,
7369 struct absaddr addr
,
7370 const char ** symname
,
7373 bfd_vma dist
= 0x100000;
7374 Elf_Internal_Sym
* sym
;
7375 Elf_Internal_Sym
* beg
;
7376 Elf_Internal_Sym
* end
;
7377 Elf_Internal_Sym
* best
= NULL
;
7379 REMOVE_ARCH_BITS (addr
.offset
);
7381 end
= symtab
+ nsyms
;
7387 sym
= beg
+ (end
- beg
) / 2;
7389 value
= sym
->st_value
;
7390 REMOVE_ARCH_BITS (value
);
7392 if (sym
->st_name
!= 0
7393 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7394 && addr
.offset
>= value
7395 && addr
.offset
- value
< dist
)
7398 dist
= addr
.offset
- value
;
7403 if (addr
.offset
< value
)
7411 *symname
= (best
->st_name
>= strtab_size
7412 ? _("<corrupt>") : strtab
+ best
->st_name
);
7418 *offset
= addr
.offset
;
7421 static /* signed */ int
7422 symcmp (const void *p
, const void *q
)
7424 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7425 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7427 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7430 /* Process the unwind section. */
7432 #include "unwind-ia64.h"
7434 struct ia64_unw_table_entry
7436 struct absaddr start
;
7438 struct absaddr info
;
7441 struct ia64_unw_aux_info
7443 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7444 unsigned long table_len
; /* Length of unwind table. */
7445 unsigned char * info
; /* Unwind info. */
7446 unsigned long info_size
; /* Size of unwind info. */
7447 bfd_vma info_addr
; /* Starting address of unwind info. */
7448 bfd_vma seg_base
; /* Starting address of segment. */
7449 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7450 unsigned long nsyms
; /* Number of symbols. */
7451 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7452 unsigned long nfuns
; /* Number of entries in funtab. */
7453 char * strtab
; /* The string table. */
7454 unsigned long strtab_size
; /* Size of string table. */
7458 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7460 struct ia64_unw_table_entry
* tp
;
7461 unsigned long j
, nfuns
;
7463 bfd_boolean res
= TRUE
;
7465 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7466 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7467 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7468 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7470 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7472 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7476 const unsigned char * dp
;
7477 const unsigned char * head
;
7478 const unsigned char * end
;
7479 const char * procname
;
7481 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7482 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7484 fputs ("\n<", stdout
);
7488 fputs (procname
, stdout
);
7491 printf ("+%lx", (unsigned long) offset
);
7494 fputs (">: [", stdout
);
7495 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7496 fputc ('-', stdout
);
7497 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7498 printf ("], info at +0x%lx\n",
7499 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7501 /* PR 17531: file: 86232b32. */
7502 if (aux
->info
== NULL
)
7505 /* PR 17531: file: 0997b4d1. */
7506 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7508 warn (_("Invalid offset %lx in table entry %ld\n"),
7509 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7514 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7515 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7517 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7518 (unsigned) UNW_VER (stamp
),
7519 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7520 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7521 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7522 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7524 if (UNW_VER (stamp
) != 1)
7526 printf (_("\tUnknown version.\n"));
7531 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7532 /* PR 17531: file: 16ceda89. */
7533 if (end
> aux
->info
+ aux
->info_size
)
7534 end
= aux
->info
+ aux
->info_size
;
7535 for (dp
= head
+ 8; dp
< end
;)
7536 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7545 slurp_ia64_unwind_table (Filedata
* filedata
,
7546 struct ia64_unw_aux_info
* aux
,
7547 Elf_Internal_Shdr
* sec
)
7549 unsigned long size
, nrelas
, i
;
7550 Elf_Internal_Phdr
* seg
;
7551 struct ia64_unw_table_entry
* tep
;
7552 Elf_Internal_Shdr
* relsec
;
7553 Elf_Internal_Rela
* rela
;
7554 Elf_Internal_Rela
* rp
;
7555 unsigned char * table
;
7557 Elf_Internal_Sym
* sym
;
7558 const char * relname
;
7562 /* First, find the starting address of the segment that includes
7565 if (filedata
->file_header
.e_phnum
)
7567 if (! get_program_headers (filedata
))
7570 for (seg
= filedata
->program_headers
;
7571 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7574 if (seg
->p_type
!= PT_LOAD
)
7577 if (sec
->sh_addr
>= seg
->p_vaddr
7578 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7580 aux
->seg_base
= seg
->p_vaddr
;
7586 /* Second, build the unwind table from the contents of the unwind section: */
7587 size
= sec
->sh_size
;
7588 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7593 aux
->table_len
= size
/ (3 * eh_addr_size
);
7594 aux
->table
= (struct ia64_unw_table_entry
*)
7595 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7598 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7600 tep
->start
.section
= SHN_UNDEF
;
7601 tep
->end
.section
= SHN_UNDEF
;
7602 tep
->info
.section
= SHN_UNDEF
;
7603 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7604 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7605 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7606 tep
->start
.offset
+= aux
->seg_base
;
7607 tep
->end
.offset
+= aux
->seg_base
;
7608 tep
->info
.offset
+= aux
->seg_base
;
7612 /* Third, apply any relocations to the unwind table: */
7613 for (relsec
= filedata
->section_headers
;
7614 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7617 if (relsec
->sh_type
!= SHT_RELA
7618 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7619 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7622 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7631 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7633 unsigned int sym_ndx
;
7634 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7635 relname
= elf_ia64_reloc_type (r_type
);
7637 /* PR 17531: file: 9fa67536. */
7638 if (relname
== NULL
)
7640 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7644 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7646 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7650 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7652 /* PR 17531: file: 5bc8d9bf. */
7653 if (i
>= aux
->table_len
)
7655 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7659 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7660 if (sym_ndx
>= aux
->nsyms
)
7662 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7666 sym
= aux
->symtab
+ sym_ndx
;
7668 switch (rp
->r_offset
/ eh_addr_size
% 3)
7671 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7672 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7675 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7676 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7679 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7680 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7694 ia64_process_unwind (Filedata
* filedata
)
7696 Elf_Internal_Shdr
* sec
;
7697 Elf_Internal_Shdr
* unwsec
= NULL
;
7698 Elf_Internal_Shdr
* strsec
;
7699 unsigned long i
, unwcount
= 0, unwstart
= 0;
7700 struct ia64_unw_aux_info aux
;
7701 bfd_boolean res
= TRUE
;
7703 memset (& aux
, 0, sizeof (aux
));
7705 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7707 if (sec
->sh_type
== SHT_SYMTAB
7708 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7710 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7712 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7713 if (aux
.strtab
!= NULL
)
7715 error (_("Multiple auxillary string tables encountered\n"));
7719 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7722 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7724 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7729 printf (_("\nThere are no unwind sections in this file.\n"));
7731 while (unwcount
-- > 0)
7736 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7737 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7738 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7743 /* We have already counted the number of SHT_IA64_UNWIND
7744 sections so the loop above should never fail. */
7745 assert (unwsec
!= NULL
);
7748 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7750 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7752 /* We need to find which section group it is in. */
7753 struct group_list
* g
;
7755 if (section_headers_groups
== NULL
7756 || section_headers_groups
[i
] == NULL
)
7757 i
= filedata
->file_header
.e_shnum
;
7760 g
= section_headers_groups
[i
]->root
;
7762 for (; g
!= NULL
; g
= g
->next
)
7764 sec
= filedata
->section_headers
+ g
->section_index
;
7766 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7771 i
= filedata
->file_header
.e_shnum
;
7774 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7776 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7777 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
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_once
, len2
)
7782 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7787 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7788 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7789 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7790 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7792 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7793 suffix
= SECTION_NAME (unwsec
) + len
;
7794 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7796 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7797 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7801 if (i
== filedata
->file_header
.e_shnum
)
7803 printf (_("\nCould not find unwind info section for "));
7805 if (filedata
->string_table
== NULL
)
7806 printf ("%d", unwsec
->sh_name
);
7808 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7812 aux
.info_addr
= sec
->sh_addr
;
7813 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7816 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7818 printf (_("\nUnwind section "));
7820 if (filedata
->string_table
== NULL
)
7821 printf ("%d", unwsec
->sh_name
);
7823 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7825 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7826 (unsigned long) unwsec
->sh_offset
,
7827 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7829 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7830 && aux
.table_len
> 0)
7831 dump_ia64_unwind (filedata
, & aux
);
7834 free ((char *) aux
.table
);
7836 free ((char *) aux
.info
);
7845 free ((char *) aux
.strtab
);
7850 struct hppa_unw_table_entry
7852 struct absaddr start
;
7854 unsigned int Cannot_unwind
:1; /* 0 */
7855 unsigned int Millicode
:1; /* 1 */
7856 unsigned int Millicode_save_sr0
:1; /* 2 */
7857 unsigned int Region_description
:2; /* 3..4 */
7858 unsigned int reserved1
:1; /* 5 */
7859 unsigned int Entry_SR
:1; /* 6 */
7860 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7861 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7862 unsigned int Args_stored
:1; /* 16 */
7863 unsigned int Variable_Frame
:1; /* 17 */
7864 unsigned int Separate_Package_Body
:1; /* 18 */
7865 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7866 unsigned int Stack_Overflow_Check
:1; /* 20 */
7867 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7868 unsigned int Ada_Region
:1; /* 22 */
7869 unsigned int cxx_info
:1; /* 23 */
7870 unsigned int cxx_try_catch
:1; /* 24 */
7871 unsigned int sched_entry_seq
:1; /* 25 */
7872 unsigned int reserved2
:1; /* 26 */
7873 unsigned int Save_SP
:1; /* 27 */
7874 unsigned int Save_RP
:1; /* 28 */
7875 unsigned int Save_MRP_in_frame
:1; /* 29 */
7876 unsigned int extn_ptr_defined
:1; /* 30 */
7877 unsigned int Cleanup_defined
:1; /* 31 */
7879 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7880 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7881 unsigned int Large_frame
:1; /* 2 */
7882 unsigned int Pseudo_SP_Set
:1; /* 3 */
7883 unsigned int reserved4
:1; /* 4 */
7884 unsigned int Total_frame_size
:27; /* 5..31 */
7887 struct hppa_unw_aux_info
7889 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7890 unsigned long table_len
; /* Length of unwind table. */
7891 bfd_vma seg_base
; /* Starting address of segment. */
7892 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7893 unsigned long nsyms
; /* Number of symbols. */
7894 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7895 unsigned long nfuns
; /* Number of entries in funtab. */
7896 char * strtab
; /* The string table. */
7897 unsigned long strtab_size
; /* Size of string table. */
7901 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7903 struct hppa_unw_table_entry
* tp
;
7904 unsigned long j
, nfuns
;
7905 bfd_boolean res
= TRUE
;
7907 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7908 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7909 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7910 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7912 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7914 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7917 const char * procname
;
7919 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7920 aux
->strtab_size
, tp
->start
, &procname
,
7923 fputs ("\n<", stdout
);
7927 fputs (procname
, stdout
);
7930 printf ("+%lx", (unsigned long) offset
);
7933 fputs (">: [", stdout
);
7934 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7935 fputc ('-', stdout
);
7936 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7939 #define PF(_m) if (tp->_m) printf (#_m " ");
7940 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7943 PF(Millicode_save_sr0
);
7944 /* PV(Region_description); */
7950 PF(Separate_Package_Body
);
7951 PF(Frame_Extension_Millicode
);
7952 PF(Stack_Overflow_Check
);
7953 PF(Two_Instruction_SP_Increment
);
7957 PF(sched_entry_seq
);
7960 PF(Save_MRP_in_frame
);
7961 PF(extn_ptr_defined
);
7962 PF(Cleanup_defined
);
7963 PF(MPE_XL_interrupt_marker
);
7964 PF(HP_UX_interrupt_marker
);
7967 PV(Total_frame_size
);
7980 slurp_hppa_unwind_table (Filedata
* filedata
,
7981 struct hppa_unw_aux_info
* aux
,
7982 Elf_Internal_Shdr
* sec
)
7984 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7985 Elf_Internal_Phdr
* seg
;
7986 struct hppa_unw_table_entry
* tep
;
7987 Elf_Internal_Shdr
* relsec
;
7988 Elf_Internal_Rela
* rela
;
7989 Elf_Internal_Rela
* rp
;
7990 unsigned char * table
;
7992 Elf_Internal_Sym
* sym
;
7993 const char * relname
;
7995 /* First, find the starting address of the segment that includes
7997 if (filedata
->file_header
.e_phnum
)
7999 if (! get_program_headers (filedata
))
8002 for (seg
= filedata
->program_headers
;
8003 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8006 if (seg
->p_type
!= PT_LOAD
)
8009 if (sec
->sh_addr
>= seg
->p_vaddr
8010 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8012 aux
->seg_base
= seg
->p_vaddr
;
8018 /* Second, build the unwind table from the contents of the unwind
8020 size
= sec
->sh_size
;
8021 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8027 nentries
= size
/ unw_ent_size
;
8028 size
= unw_ent_size
* nentries
;
8030 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8031 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8033 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8035 unsigned int tmp1
, tmp2
;
8037 tep
->start
.section
= SHN_UNDEF
;
8038 tep
->end
.section
= SHN_UNDEF
;
8040 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8041 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8042 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8043 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8045 tep
->start
.offset
+= aux
->seg_base
;
8046 tep
->end
.offset
+= aux
->seg_base
;
8048 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8049 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8050 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8051 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8052 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8053 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8054 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8055 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8056 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8057 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8058 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8059 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8060 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8061 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8062 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8063 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8064 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8065 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8066 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8067 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8068 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8069 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8070 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8071 tep
->Cleanup_defined
= tmp1
& 0x1;
8073 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8074 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8075 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8076 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8077 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8078 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8082 /* Third, apply any relocations to the unwind table. */
8083 for (relsec
= filedata
->section_headers
;
8084 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8087 if (relsec
->sh_type
!= SHT_RELA
8088 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8089 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8092 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8096 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8098 unsigned int sym_ndx
;
8099 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8100 relname
= elf_hppa_reloc_type (r_type
);
8102 if (relname
== NULL
)
8104 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8108 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8109 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8111 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8115 i
= rp
->r_offset
/ unw_ent_size
;
8116 if (i
>= aux
->table_len
)
8118 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8122 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8123 if (sym_ndx
>= aux
->nsyms
)
8125 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8129 sym
= aux
->symtab
+ sym_ndx
;
8131 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8134 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8135 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8138 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8139 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8149 aux
->table_len
= nentries
;
8155 hppa_process_unwind (Filedata
* filedata
)
8157 struct hppa_unw_aux_info aux
;
8158 Elf_Internal_Shdr
* unwsec
= NULL
;
8159 Elf_Internal_Shdr
* strsec
;
8160 Elf_Internal_Shdr
* sec
;
8162 bfd_boolean res
= TRUE
;
8164 if (filedata
->string_table
== NULL
)
8167 memset (& aux
, 0, sizeof (aux
));
8169 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8171 if (sec
->sh_type
== SHT_SYMTAB
8172 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8174 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8176 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8177 if (aux
.strtab
!= NULL
)
8179 error (_("Multiple auxillary string tables encountered\n"));
8183 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8186 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8188 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8193 printf (_("\nThere are no unwind sections in this file.\n"));
8195 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8197 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8199 unsigned long num_unwind
= sec
->sh_size
/ 16;
8201 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8202 "contains %lu entry:\n",
8203 "\nUnwind section '%s' at offset 0x%lx "
8204 "contains %lu entries:\n",
8206 printable_section_name (filedata
, sec
),
8207 (unsigned long) sec
->sh_offset
,
8210 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8213 if (res
&& aux
.table_len
> 0)
8215 if (! dump_hppa_unwind (filedata
, &aux
))
8220 free ((char *) aux
.table
);
8228 free ((char *) aux
.strtab
);
8235 unsigned char * data
; /* The unwind data. */
8236 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8237 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8238 unsigned long nrelas
; /* The number of relocations. */
8239 unsigned int rel_type
; /* REL or RELA ? */
8240 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8243 struct arm_unw_aux_info
8245 Filedata
* filedata
; /* The file containing the unwind sections. */
8246 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8247 unsigned long nsyms
; /* Number of symbols. */
8248 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8249 unsigned long nfuns
; /* Number of these symbols. */
8250 char * strtab
; /* The file's string table. */
8251 unsigned long strtab_size
; /* Size of string table. */
8255 arm_print_vma_and_name (Filedata
* filedata
,
8256 struct arm_unw_aux_info
* aux
,
8258 struct absaddr addr
)
8260 const char *procname
;
8263 if (addr
.section
== SHN_UNDEF
)
8266 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8267 aux
->strtab_size
, addr
, &procname
,
8270 print_vma (fn
, PREFIX_HEX
);
8274 fputs (" <", stdout
);
8275 fputs (procname
, stdout
);
8278 printf ("+0x%lx", (unsigned long) sym_offset
);
8279 fputc ('>', stdout
);
8286 arm_free_section (struct arm_section
*arm_sec
)
8288 if (arm_sec
->data
!= NULL
)
8289 free (arm_sec
->data
);
8291 if (arm_sec
->rela
!= NULL
)
8292 free (arm_sec
->rela
);
8295 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8296 cached section and install SEC instead.
8297 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8298 and return its valued in * WORDP, relocating if necessary.
8299 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8300 relocation's offset in ADDR.
8301 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8302 into the string table of the symbol associated with the reloc. If no
8303 reloc was applied store -1 there.
8304 5) Return TRUE upon success, FALSE otherwise. */
8307 get_unwind_section_word (Filedata
* filedata
,
8308 struct arm_unw_aux_info
* aux
,
8309 struct arm_section
* arm_sec
,
8310 Elf_Internal_Shdr
* sec
,
8311 bfd_vma word_offset
,
8312 unsigned int * wordp
,
8313 struct absaddr
* addr
,
8316 Elf_Internal_Rela
*rp
;
8317 Elf_Internal_Sym
*sym
;
8318 const char * relname
;
8320 bfd_boolean wrapped
;
8322 if (sec
== NULL
|| arm_sec
== NULL
)
8325 addr
->section
= SHN_UNDEF
;
8328 if (sym_name
!= NULL
)
8329 *sym_name
= (bfd_vma
) -1;
8331 /* If necessary, update the section cache. */
8332 if (sec
!= arm_sec
->sec
)
8334 Elf_Internal_Shdr
*relsec
;
8336 arm_free_section (arm_sec
);
8339 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8340 sec
->sh_size
, _("unwind data"));
8341 arm_sec
->rela
= NULL
;
8342 arm_sec
->nrelas
= 0;
8344 for (relsec
= filedata
->section_headers
;
8345 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8348 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8349 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8350 /* PR 15745: Check the section type as well. */
8351 || (relsec
->sh_type
!= SHT_REL
8352 && relsec
->sh_type
!= SHT_RELA
))
8355 arm_sec
->rel_type
= relsec
->sh_type
;
8356 if (relsec
->sh_type
== SHT_REL
)
8358 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8360 & arm_sec
->rela
, & arm_sec
->nrelas
))
8363 else /* relsec->sh_type == SHT_RELA */
8365 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8367 & arm_sec
->rela
, & arm_sec
->nrelas
))
8373 arm_sec
->next_rela
= arm_sec
->rela
;
8376 /* If there is no unwind data we can do nothing. */
8377 if (arm_sec
->data
== NULL
)
8380 /* If the offset is invalid then fail. */
8381 if (/* PR 21343 *//* PR 18879 */
8383 || word_offset
> (sec
->sh_size
- 4)
8384 || ((bfd_signed_vma
) word_offset
) < 0)
8387 /* Get the word at the required offset. */
8388 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8390 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8391 if (arm_sec
->rela
== NULL
)
8397 /* Look through the relocs to find the one that applies to the provided offset. */
8399 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8401 bfd_vma prelval
, offset
;
8403 if (rp
->r_offset
> word_offset
&& !wrapped
)
8408 if (rp
->r_offset
> word_offset
)
8411 if (rp
->r_offset
& 3)
8413 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8414 (unsigned long) rp
->r_offset
);
8418 if (rp
->r_offset
< word_offset
)
8421 /* PR 17531: file: 027-161405-0.004 */
8422 if (aux
->symtab
== NULL
)
8425 if (arm_sec
->rel_type
== SHT_REL
)
8427 offset
= word
& 0x7fffffff;
8428 if (offset
& 0x40000000)
8429 offset
|= ~ (bfd_vma
) 0x7fffffff;
8431 else if (arm_sec
->rel_type
== SHT_RELA
)
8432 offset
= rp
->r_addend
;
8435 error (_("Unknown section relocation type %d encountered\n"),
8440 /* PR 17531 file: 027-1241568-0.004. */
8441 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8443 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8444 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8448 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8449 offset
+= sym
->st_value
;
8450 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8452 /* Check that we are processing the expected reloc type. */
8453 if (filedata
->file_header
.e_machine
== EM_ARM
)
8455 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8456 if (relname
== NULL
)
8458 warn (_("Skipping unknown ARM relocation type: %d\n"),
8459 (int) ELF32_R_TYPE (rp
->r_info
));
8463 if (streq (relname
, "R_ARM_NONE"))
8466 if (! streq (relname
, "R_ARM_PREL31"))
8468 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8472 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8474 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8475 if (relname
== NULL
)
8477 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8478 (int) ELF32_R_TYPE (rp
->r_info
));
8482 if (streq (relname
, "R_C6000_NONE"))
8485 if (! streq (relname
, "R_C6000_PREL31"))
8487 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8495 /* This function currently only supports ARM and TI unwinders. */
8496 warn (_("Only TI and ARM unwinders are currently supported\n"));
8500 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8501 addr
->section
= sym
->st_shndx
;
8502 addr
->offset
= offset
;
8505 * sym_name
= sym
->st_name
;
8510 arm_sec
->next_rela
= rp
;
8515 static const char *tic6x_unwind_regnames
[16] =
8517 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8518 "A14", "A13", "A12", "A11", "A10",
8519 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8523 decode_tic6x_unwind_regmask (unsigned int mask
)
8527 for (i
= 12; mask
; mask
>>= 1, i
--)
8531 fputs (tic6x_unwind_regnames
[i
], stdout
);
8533 fputs (", ", stdout
);
8539 if (remaining == 0 && more_words) \
8542 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8543 data_offset, & word, & addr, NULL)) \
8549 #define GET_OP(OP) \
8554 (OP) = word >> 24; \
8559 printf (_("[Truncated opcode]\n")); \
8562 printf ("0x%02x ", OP)
8565 decode_arm_unwind_bytecode (Filedata
* filedata
,
8566 struct arm_unw_aux_info
* aux
,
8568 unsigned int remaining
,
8569 unsigned int more_words
,
8570 bfd_vma data_offset
,
8571 Elf_Internal_Shdr
* data_sec
,
8572 struct arm_section
* data_arm_sec
)
8574 struct absaddr addr
;
8575 bfd_boolean res
= TRUE
;
8577 /* Decode the unwinding instructions. */
8580 unsigned int op
, op2
;
8589 printf (" 0x%02x ", op
);
8591 if ((op
& 0xc0) == 0x00)
8593 int offset
= ((op
& 0x3f) << 2) + 4;
8595 printf (" vsp = vsp + %d", offset
);
8597 else if ((op
& 0xc0) == 0x40)
8599 int offset
= ((op
& 0x3f) << 2) + 4;
8601 printf (" vsp = vsp - %d", offset
);
8603 else if ((op
& 0xf0) == 0x80)
8606 if (op
== 0x80 && op2
== 0)
8607 printf (_("Refuse to unwind"));
8610 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8611 bfd_boolean first
= TRUE
;
8615 for (i
= 0; i
< 12; i
++)
8616 if (mask
& (1 << i
))
8622 printf ("r%d", 4 + i
);
8627 else if ((op
& 0xf0) == 0x90)
8629 if (op
== 0x9d || op
== 0x9f)
8630 printf (_(" [Reserved]"));
8632 printf (" vsp = r%d", op
& 0x0f);
8634 else if ((op
& 0xf0) == 0xa0)
8636 int end
= 4 + (op
& 0x07);
8637 bfd_boolean first
= TRUE
;
8641 for (i
= 4; i
<= end
; i
++)
8657 else if (op
== 0xb0)
8658 printf (_(" finish"));
8659 else if (op
== 0xb1)
8662 if (op2
== 0 || (op2
& 0xf0) != 0)
8663 printf (_("[Spare]"));
8666 unsigned int mask
= op2
& 0x0f;
8667 bfd_boolean first
= TRUE
;
8671 for (i
= 0; i
< 12; i
++)
8672 if (mask
& (1 << i
))
8683 else if (op
== 0xb2)
8685 unsigned char buf
[9];
8686 unsigned int i
, len
;
8687 unsigned long offset
;
8689 for (i
= 0; i
< sizeof (buf
); i
++)
8692 if ((buf
[i
] & 0x80) == 0)
8695 if (i
== sizeof (buf
))
8697 error (_("corrupt change to vsp"));
8702 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8703 assert (len
== i
+ 1);
8704 offset
= offset
* 4 + 0x204;
8705 printf ("vsp = vsp + %ld", offset
);
8708 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8710 unsigned int first
, last
;
8717 printf ("pop {D%d", first
);
8719 printf ("-D%d", first
+ last
);
8722 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8724 unsigned int count
= op
& 0x07;
8728 printf ("-D%d", 8 + count
);
8731 else if (op
>= 0xc0 && op
<= 0xc5)
8733 unsigned int count
= op
& 0x07;
8735 printf (" pop {wR10");
8737 printf ("-wR%d", 10 + count
);
8740 else if (op
== 0xc6)
8742 unsigned int first
, last
;
8747 printf ("pop {wR%d", first
);
8749 printf ("-wR%d", first
+ last
);
8752 else if (op
== 0xc7)
8755 if (op2
== 0 || (op2
& 0xf0) != 0)
8756 printf (_("[Spare]"));
8759 unsigned int mask
= op2
& 0x0f;
8760 bfd_boolean first
= TRUE
;
8764 for (i
= 0; i
< 4; i
++)
8765 if (mask
& (1 << i
))
8771 printf ("wCGR%d", i
);
8778 printf (_(" [unsupported opcode]"));
8789 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8790 struct arm_unw_aux_info
* aux
,
8792 unsigned int remaining
,
8793 unsigned int more_words
,
8794 bfd_vma data_offset
,
8795 Elf_Internal_Shdr
* data_sec
,
8796 struct arm_section
* data_arm_sec
)
8798 struct absaddr addr
;
8800 /* Decode the unwinding instructions. */
8803 unsigned int op
, op2
;
8812 printf (" 0x%02x ", op
);
8814 if ((op
& 0xc0) == 0x00)
8816 int offset
= ((op
& 0x3f) << 3) + 8;
8817 printf (" sp = sp + %d", offset
);
8819 else if ((op
& 0xc0) == 0x80)
8822 if (op
== 0x80 && op2
== 0)
8823 printf (_("Refuse to unwind"));
8826 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8828 printf ("pop compact {");
8832 decode_tic6x_unwind_regmask (mask
);
8836 else if ((op
& 0xf0) == 0xc0)
8844 unsigned int offset
;
8848 /* Scan entire instruction first so that GET_OP output is not
8849 interleaved with disassembly. */
8851 for (i
= 0; nregs
< (op
& 0xf); i
++)
8857 regpos
[nregs
].offset
= i
* 2;
8858 regpos
[nregs
].reg
= reg
;
8865 regpos
[nregs
].offset
= i
* 2 + 1;
8866 regpos
[nregs
].reg
= reg
;
8871 printf (_("pop frame {"));
8874 printf (_("*corrupt* - no registers specified"));
8879 for (i
= i
* 2; i
> 0; i
--)
8881 if (regpos
[reg
].offset
== i
- 1)
8883 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8890 fputs (name
, stdout
);
8898 else if (op
== 0xd0)
8899 printf (" MOV FP, SP");
8900 else if (op
== 0xd1)
8901 printf (" __c6xabi_pop_rts");
8902 else if (op
== 0xd2)
8904 unsigned char buf
[9];
8905 unsigned int i
, len
;
8906 unsigned long offset
;
8908 for (i
= 0; i
< sizeof (buf
); i
++)
8911 if ((buf
[i
] & 0x80) == 0)
8914 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8915 if (i
== sizeof (buf
))
8917 warn (_("Corrupt stack pointer adjustment detected\n"));
8921 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8922 assert (len
== i
+ 1);
8923 offset
= offset
* 8 + 0x408;
8924 printf (_("sp = sp + %ld"), offset
);
8926 else if ((op
& 0xf0) == 0xe0)
8928 if ((op
& 0x0f) == 7)
8931 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8935 printf (_(" [unsupported opcode]"));
8944 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8948 offset
= word
& 0x7fffffff;
8949 if (offset
& 0x40000000)
8950 offset
|= ~ (bfd_vma
) 0x7fffffff;
8952 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8955 return offset
+ where
;
8959 decode_arm_unwind (Filedata
* filedata
,
8960 struct arm_unw_aux_info
* aux
,
8962 unsigned int remaining
,
8963 bfd_vma data_offset
,
8964 Elf_Internal_Shdr
* data_sec
,
8965 struct arm_section
* data_arm_sec
)
8968 unsigned int more_words
= 0;
8969 struct absaddr addr
;
8970 bfd_vma sym_name
= (bfd_vma
) -1;
8971 bfd_boolean res
= TRUE
;
8975 /* Fetch the first word.
8976 Note - when decoding an object file the address extracted
8977 here will always be 0. So we also pass in the sym_name
8978 parameter so that we can find the symbol associated with
8979 the personality routine. */
8980 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8981 & word
, & addr
, & sym_name
))
8987 if ((word
& 0x80000000) == 0)
8989 /* Expand prel31 for personality routine. */
8991 const char *procname
;
8993 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8994 printf (_(" Personality routine: "));
8996 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8997 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8999 procname
= aux
->strtab
+ sym_name
;
9000 print_vma (fn
, PREFIX_HEX
);
9003 fputs (" <", stdout
);
9004 fputs (procname
, stdout
);
9005 fputc ('>', stdout
);
9009 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9010 fputc ('\n', stdout
);
9012 /* The GCC personality routines use the standard compact
9013 encoding, starting with one byte giving the number of
9015 if (procname
!= NULL
9016 && (const_strneq (procname
, "__gcc_personality_v0")
9017 || const_strneq (procname
, "__gxx_personality_v0")
9018 || const_strneq (procname
, "__gcj_personality_v0")
9019 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9026 printf (_(" [Truncated data]\n"));
9029 more_words
= word
>> 24;
9039 /* ARM EHABI Section 6.3:
9041 An exception-handling table entry for the compact model looks like:
9045 1 0 index Data for personalityRoutine[index] */
9047 if (filedata
->file_header
.e_machine
== EM_ARM
9048 && (word
& 0x70000000))
9050 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9054 per_index
= (word
>> 24) & 0x7f;
9055 printf (_(" Compact model index: %d\n"), per_index
);
9062 else if (per_index
< 3)
9064 more_words
= (word
>> 16) & 0xff;
9070 switch (filedata
->file_header
.e_machine
)
9075 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9076 data_offset
, data_sec
, data_arm_sec
))
9081 warn (_("Unknown ARM compact model index encountered\n"));
9082 printf (_(" [reserved]\n"));
9090 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9091 data_offset
, data_sec
, data_arm_sec
))
9094 else if (per_index
< 5)
9096 if (((word
>> 17) & 0x7f) == 0x7f)
9097 printf (_(" Restore stack from frame pointer\n"));
9099 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9100 printf (_(" Registers restored: "));
9102 printf (" (compact) ");
9103 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9105 printf (_(" Return register: %s\n"),
9106 tic6x_unwind_regnames
[word
& 0xf]);
9109 printf (_(" [reserved (%d)]\n"), per_index
);
9113 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9114 filedata
->file_header
.e_machine
);
9118 /* Decode the descriptors. Not implemented. */
9124 dump_arm_unwind (Filedata
* filedata
,
9125 struct arm_unw_aux_info
* aux
,
9126 Elf_Internal_Shdr
* exidx_sec
)
9128 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9129 unsigned int i
, exidx_len
;
9130 unsigned long j
, nfuns
;
9131 bfd_boolean res
= TRUE
;
9133 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9134 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9135 exidx_len
= exidx_sec
->sh_size
/ 8;
9137 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9138 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9139 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9140 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9142 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9144 for (i
= 0; i
< exidx_len
; i
++)
9146 unsigned int exidx_fn
, exidx_entry
;
9147 struct absaddr fn_addr
, entry_addr
;
9150 fputc ('\n', stdout
);
9152 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9153 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9154 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9155 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9158 arm_free_section (& exidx_arm_sec
);
9159 arm_free_section (& extab_arm_sec
);
9163 /* ARM EHABI, Section 5:
9164 An index table entry consists of 2 words.
9165 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9166 if (exidx_fn
& 0x80000000)
9168 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9172 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9174 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9175 fputs (": ", stdout
);
9177 if (exidx_entry
== 1)
9179 print_vma (exidx_entry
, PREFIX_HEX
);
9180 fputs (" [cantunwind]\n", stdout
);
9182 else if (exidx_entry
& 0x80000000)
9184 print_vma (exidx_entry
, PREFIX_HEX
);
9185 fputc ('\n', stdout
);
9186 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9190 bfd_vma table
, table_offset
= 0;
9191 Elf_Internal_Shdr
*table_sec
;
9193 fputs ("@", stdout
);
9194 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9195 print_vma (table
, PREFIX_HEX
);
9198 /* Locate the matching .ARM.extab. */
9199 if (entry_addr
.section
!= SHN_UNDEF
9200 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9202 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9203 table_offset
= entry_addr
.offset
;
9205 if (table_offset
> table_sec
->sh_size
9206 || ((bfd_signed_vma
) table_offset
) < 0)
9208 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9209 (unsigned long) table_offset
,
9210 printable_section_name (filedata
, table_sec
));
9217 table_sec
= find_section_by_address (filedata
, table
);
9218 if (table_sec
!= NULL
)
9219 table_offset
= table
- table_sec
->sh_addr
;
9222 if (table_sec
== NULL
)
9224 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9225 (unsigned long) table
);
9230 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9239 arm_free_section (&exidx_arm_sec
);
9240 arm_free_section (&extab_arm_sec
);
9245 /* Used for both ARM and C6X unwinding tables. */
9248 arm_process_unwind (Filedata
* filedata
)
9250 struct arm_unw_aux_info aux
;
9251 Elf_Internal_Shdr
*unwsec
= NULL
;
9252 Elf_Internal_Shdr
*strsec
;
9253 Elf_Internal_Shdr
*sec
;
9255 unsigned int sec_type
;
9256 bfd_boolean res
= TRUE
;
9258 switch (filedata
->file_header
.e_machine
)
9261 sec_type
= SHT_ARM_EXIDX
;
9265 sec_type
= SHT_C6000_UNWIND
;
9269 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9270 filedata
->file_header
.e_machine
);
9274 if (filedata
->string_table
== NULL
)
9277 memset (& aux
, 0, sizeof (aux
));
9278 aux
.filedata
= filedata
;
9280 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9282 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9284 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9286 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9288 /* PR binutils/17531 file: 011-12666-0.004. */
9289 if (aux
.strtab
!= NULL
)
9291 error (_("Multiple string tables found in file.\n"));
9295 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9296 1, strsec
->sh_size
, _("string table"));
9297 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9299 else if (sec
->sh_type
== sec_type
)
9304 printf (_("\nThere are no unwind sections in this file.\n"));
9306 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9308 if (sec
->sh_type
== sec_type
)
9310 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9311 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9312 "contains %lu entry:\n",
9313 "\nUnwind section '%s' at offset 0x%lx "
9314 "contains %lu entries:\n",
9316 printable_section_name (filedata
, sec
),
9317 (unsigned long) sec
->sh_offset
,
9320 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9328 free ((char *) aux
.strtab
);
9334 process_unwind (Filedata
* filedata
)
9336 struct unwind_handler
9338 unsigned int machtype
;
9339 bfd_boolean (* handler
)(Filedata
*);
9342 { EM_ARM
, arm_process_unwind
},
9343 { EM_IA_64
, ia64_process_unwind
},
9344 { EM_PARISC
, hppa_process_unwind
},
9345 { EM_TI_C6000
, arm_process_unwind
},
9353 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9354 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9355 return handlers
[i
].handler (filedata
);
9357 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9358 get_machine_name (filedata
->file_header
.e_machine
));
9363 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9365 switch (entry
->d_tag
)
9367 case DT_AARCH64_BTI_PLT
:
9368 case DT_AARCH64_PAC_PLT
:
9371 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9378 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9380 switch (entry
->d_tag
)
9383 if (entry
->d_un
.d_val
== 0)
9387 static const char * opts
[] =
9389 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9390 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9391 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9392 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9396 bfd_boolean first
= TRUE
;
9398 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9399 if (entry
->d_un
.d_val
& (1 << cnt
))
9401 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9407 case DT_MIPS_IVERSION
:
9408 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9409 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9413 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9414 /* Note: coded this way so that there is a single string for translation. */
9415 printf (_("<corrupt: %s>"), buf
);
9419 case DT_MIPS_TIME_STAMP
:
9423 time_t atime
= entry
->d_un
.d_val
;
9425 tmp
= gmtime (&atime
);
9426 /* PR 17531: file: 6accc532. */
9428 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9430 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9431 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9432 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9433 printf (_("Time Stamp: %s"), timebuf
);
9437 case DT_MIPS_RLD_VERSION
:
9438 case DT_MIPS_LOCAL_GOTNO
:
9439 case DT_MIPS_CONFLICTNO
:
9440 case DT_MIPS_LIBLISTNO
:
9441 case DT_MIPS_SYMTABNO
:
9442 case DT_MIPS_UNREFEXTNO
:
9443 case DT_MIPS_HIPAGENO
:
9444 case DT_MIPS_DELTA_CLASS_NO
:
9445 case DT_MIPS_DELTA_INSTANCE_NO
:
9446 case DT_MIPS_DELTA_RELOC_NO
:
9447 case DT_MIPS_DELTA_SYM_NO
:
9448 case DT_MIPS_DELTA_CLASSSYM_NO
:
9449 case DT_MIPS_COMPACT_SIZE
:
9450 print_vma (entry
->d_un
.d_val
, DEC
);
9454 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9460 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9462 switch (entry
->d_tag
)
9464 case DT_HP_DLD_FLAGS
:
9473 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9474 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9475 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9476 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9477 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9478 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9479 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9480 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9481 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9482 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9483 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9484 { DT_HP_GST
, "HP_GST" },
9485 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9486 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9487 { DT_HP_NODELETE
, "HP_NODELETE" },
9488 { DT_HP_GROUP
, "HP_GROUP" },
9489 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9491 bfd_boolean first
= TRUE
;
9493 bfd_vma val
= entry
->d_un
.d_val
;
9495 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9496 if (val
& flags
[cnt
].bit
)
9500 fputs (flags
[cnt
].str
, stdout
);
9502 val
^= flags
[cnt
].bit
;
9505 if (val
!= 0 || first
)
9509 print_vma (val
, HEX
);
9515 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9523 /* VMS vs Unix time offset and factor. */
9525 #define VMS_EPOCH_OFFSET 35067168000000000LL
9526 #define VMS_GRANULARITY_FACTOR 10000000
9528 /* Display a VMS time in a human readable format. */
9531 print_vms_time (bfd_int64_t vmstime
)
9536 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9537 tm
= gmtime (&unxtime
);
9538 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9539 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9540 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9545 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9547 switch (entry
->d_tag
)
9549 case DT_IA_64_PLT_RESERVE
:
9550 /* First 3 slots reserved. */
9551 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9553 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9556 case DT_IA_64_VMS_LINKTIME
:
9558 print_vms_time (entry
->d_un
.d_val
);
9562 case DT_IA_64_VMS_LNKFLAGS
:
9563 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9564 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9565 printf (" CALL_DEBUG");
9566 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9567 printf (" NOP0BUFS");
9568 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9569 printf (" P0IMAGE");
9570 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9571 printf (" MKTHREADS");
9572 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9573 printf (" UPCALLS");
9574 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9576 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9577 printf (" INITIALIZE");
9578 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9580 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9581 printf (" EXE_INIT");
9582 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9583 printf (" TBK_IN_IMG");
9584 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9585 printf (" DBG_IN_IMG");
9586 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9587 printf (" TBK_IN_DSF");
9588 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9589 printf (" DBG_IN_DSF");
9590 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9591 printf (" SIGNATURES");
9592 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9593 printf (" REL_SEG_OFF");
9597 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9604 get_32bit_dynamic_section (Filedata
* filedata
)
9606 Elf32_External_Dyn
* edyn
;
9607 Elf32_External_Dyn
* ext
;
9608 Elf_Internal_Dyn
* entry
;
9610 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9611 dynamic_size
, _("dynamic section"));
9615 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9616 might not have the luxury of section headers. Look for the DT_NULL
9617 terminator to determine the number of entries. */
9618 for (ext
= edyn
, dynamic_nent
= 0;
9619 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9623 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9627 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9629 if (dynamic_section
== NULL
)
9631 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9632 (unsigned long) dynamic_nent
);
9637 for (ext
= edyn
, entry
= dynamic_section
;
9638 entry
< dynamic_section
+ dynamic_nent
;
9641 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9642 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9651 get_64bit_dynamic_section (Filedata
* filedata
)
9653 Elf64_External_Dyn
* edyn
;
9654 Elf64_External_Dyn
* ext
;
9655 Elf_Internal_Dyn
* entry
;
9657 /* Read in the data. */
9658 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9659 dynamic_size
, _("dynamic section"));
9663 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9664 might not have the luxury of section headers. Look for the DT_NULL
9665 terminator to determine the number of entries. */
9666 for (ext
= edyn
, dynamic_nent
= 0;
9667 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9668 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9672 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9676 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9678 if (dynamic_section
== NULL
)
9680 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9681 (unsigned long) dynamic_nent
);
9686 /* Convert from external to internal formats. */
9687 for (ext
= edyn
, entry
= dynamic_section
;
9688 entry
< dynamic_section
+ dynamic_nent
;
9691 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9692 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9701 print_dynamic_flags (bfd_vma flags
)
9703 bfd_boolean first
= TRUE
;
9709 flag
= flags
& - flags
;
9719 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9720 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9721 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9722 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9723 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9724 default: fputs (_("unknown"), stdout
); break;
9730 /* Parse and display the contents of the dynamic section. */
9733 process_dynamic_section (Filedata
* filedata
)
9735 Elf_Internal_Dyn
* entry
;
9737 if (dynamic_size
== 0)
9740 printf (_("\nThere is no dynamic section in this file.\n"));
9747 if (! get_32bit_dynamic_section (filedata
))
9752 if (! get_64bit_dynamic_section (filedata
))
9756 /* Find the appropriate symbol table. */
9757 if (dynamic_symbols
== NULL
)
9759 for (entry
= dynamic_section
;
9760 entry
< dynamic_section
+ dynamic_nent
;
9763 Elf_Internal_Shdr section
;
9765 if (entry
->d_tag
!= DT_SYMTAB
)
9768 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9770 /* Since we do not know how big the symbol table is,
9771 we default to reading in the entire file (!) and
9772 processing that. This is overkill, I know, but it
9774 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9775 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9777 /* See PR 21379 for a reproducer. */
9778 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9782 if (archive_file_offset
!= 0)
9783 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9785 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9788 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9790 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9791 section
.sh_name
= filedata
->string_table_length
;
9793 if (dynamic_symbols
!= NULL
)
9795 error (_("Multiple dynamic symbol table sections found\n"));
9796 free (dynamic_symbols
);
9798 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9799 if (num_dynamic_syms
< 1)
9801 error (_("Unable to determine the number of symbols to load\n"));
9807 /* Similarly find a string table. */
9808 if (dynamic_strings
== NULL
)
9810 for (entry
= dynamic_section
;
9811 entry
< dynamic_section
+ dynamic_nent
;
9814 unsigned long offset
;
9817 if (entry
->d_tag
!= DT_STRTAB
)
9820 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9822 /* Since we do not know how big the string table is,
9823 we default to reading in the entire file (!) and
9824 processing that. This is overkill, I know, but it
9827 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9829 if (archive_file_offset
!= 0)
9830 str_tab_len
= archive_file_size
- offset
;
9832 str_tab_len
= filedata
->file_size
- offset
;
9834 if (str_tab_len
< 1)
9837 (_("Unable to determine the length of the dynamic string table\n"));
9841 if (dynamic_strings
!= NULL
)
9843 error (_("Multiple dynamic string tables found\n"));
9844 free (dynamic_strings
);
9847 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9849 _("dynamic string table"));
9850 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9854 /* And find the syminfo section if available. */
9855 if (dynamic_syminfo
== NULL
)
9857 unsigned long syminsz
= 0;
9859 for (entry
= dynamic_section
;
9860 entry
< dynamic_section
+ dynamic_nent
;
9863 if (entry
->d_tag
== DT_SYMINENT
)
9865 /* Note: these braces are necessary to avoid a syntax
9866 error from the SunOS4 C compiler. */
9867 /* PR binutils/17531: A corrupt file can trigger this test.
9868 So do not use an assert, instead generate an error message. */
9869 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9870 error (_("Bad value (%d) for SYMINENT entry\n"),
9871 (int) entry
->d_un
.d_val
);
9873 else if (entry
->d_tag
== DT_SYMINSZ
)
9874 syminsz
= entry
->d_un
.d_val
;
9875 else if (entry
->d_tag
== DT_SYMINFO
)
9876 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9880 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9882 Elf_External_Syminfo
* extsyminfo
;
9883 Elf_External_Syminfo
* extsym
;
9884 Elf_Internal_Syminfo
* syminfo
;
9886 /* There is a syminfo section. Read the data. */
9887 extsyminfo
= (Elf_External_Syminfo
*)
9888 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9889 _("symbol information"));
9893 if (dynamic_syminfo
!= NULL
)
9895 error (_("Multiple dynamic symbol information sections found\n"));
9896 free (dynamic_syminfo
);
9898 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9899 if (dynamic_syminfo
== NULL
)
9901 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9902 (unsigned long) syminsz
);
9906 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9907 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9908 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9909 ++syminfo
, ++extsym
)
9911 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9912 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9919 if (do_dynamic
&& dynamic_addr
)
9920 printf (ngettext ("\nDynamic section at offset 0x%lx "
9921 "contains %lu entry:\n",
9922 "\nDynamic section at offset 0x%lx "
9923 "contains %lu entries:\n",
9925 dynamic_addr
, (unsigned long) dynamic_nent
);
9927 printf (_(" Tag Type Name/Value\n"));
9929 for (entry
= dynamic_section
;
9930 entry
< dynamic_section
+ dynamic_nent
;
9938 print_vma (entry
->d_tag
, FULL_HEX
);
9939 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9940 printf (" (%s)%*s", dtype
,
9941 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9944 switch (entry
->d_tag
)
9948 print_dynamic_flags (entry
->d_un
.d_val
);
9958 switch (entry
->d_tag
)
9961 printf (_("Auxiliary library"));
9965 printf (_("Filter library"));
9969 printf (_("Configuration file"));
9973 printf (_("Dependency audit library"));
9977 printf (_("Audit library"));
9981 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9982 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9986 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9995 printf (_("Flags:"));
9997 if (entry
->d_un
.d_val
== 0)
9998 printf (_(" None\n"));
10001 unsigned long int val
= entry
->d_un
.d_val
;
10003 if (val
& DTF_1_PARINIT
)
10005 printf (" PARINIT");
10006 val
^= DTF_1_PARINIT
;
10008 if (val
& DTF_1_CONFEXP
)
10010 printf (" CONFEXP");
10011 val
^= DTF_1_CONFEXP
;
10014 printf (" %lx", val
);
10023 printf (_("Flags:"));
10025 if (entry
->d_un
.d_val
== 0)
10026 printf (_(" None\n"));
10029 unsigned long int val
= entry
->d_un
.d_val
;
10031 if (val
& DF_P1_LAZYLOAD
)
10033 printf (" LAZYLOAD");
10034 val
^= DF_P1_LAZYLOAD
;
10036 if (val
& DF_P1_GROUPPERM
)
10038 printf (" GROUPPERM");
10039 val
^= DF_P1_GROUPPERM
;
10042 printf (" %lx", val
);
10051 printf (_("Flags:"));
10052 if (entry
->d_un
.d_val
== 0)
10053 printf (_(" None\n"));
10056 unsigned long int val
= entry
->d_un
.d_val
;
10058 if (val
& DF_1_NOW
)
10063 if (val
& DF_1_GLOBAL
)
10065 printf (" GLOBAL");
10066 val
^= DF_1_GLOBAL
;
10068 if (val
& DF_1_GROUP
)
10073 if (val
& DF_1_NODELETE
)
10075 printf (" NODELETE");
10076 val
^= DF_1_NODELETE
;
10078 if (val
& DF_1_LOADFLTR
)
10080 printf (" LOADFLTR");
10081 val
^= DF_1_LOADFLTR
;
10083 if (val
& DF_1_INITFIRST
)
10085 printf (" INITFIRST");
10086 val
^= DF_1_INITFIRST
;
10088 if (val
& DF_1_NOOPEN
)
10090 printf (" NOOPEN");
10091 val
^= DF_1_NOOPEN
;
10093 if (val
& DF_1_ORIGIN
)
10095 printf (" ORIGIN");
10096 val
^= DF_1_ORIGIN
;
10098 if (val
& DF_1_DIRECT
)
10100 printf (" DIRECT");
10101 val
^= DF_1_DIRECT
;
10103 if (val
& DF_1_TRANS
)
10108 if (val
& DF_1_INTERPOSE
)
10110 printf (" INTERPOSE");
10111 val
^= DF_1_INTERPOSE
;
10113 if (val
& DF_1_NODEFLIB
)
10115 printf (" NODEFLIB");
10116 val
^= DF_1_NODEFLIB
;
10118 if (val
& DF_1_NODUMP
)
10120 printf (" NODUMP");
10121 val
^= DF_1_NODUMP
;
10123 if (val
& DF_1_CONFALT
)
10125 printf (" CONFALT");
10126 val
^= DF_1_CONFALT
;
10128 if (val
& DF_1_ENDFILTEE
)
10130 printf (" ENDFILTEE");
10131 val
^= DF_1_ENDFILTEE
;
10133 if (val
& DF_1_DISPRELDNE
)
10135 printf (" DISPRELDNE");
10136 val
^= DF_1_DISPRELDNE
;
10138 if (val
& DF_1_DISPRELPND
)
10140 printf (" DISPRELPND");
10141 val
^= DF_1_DISPRELPND
;
10143 if (val
& DF_1_NODIRECT
)
10145 printf (" NODIRECT");
10146 val
^= DF_1_NODIRECT
;
10148 if (val
& DF_1_IGNMULDEF
)
10150 printf (" IGNMULDEF");
10151 val
^= DF_1_IGNMULDEF
;
10153 if (val
& DF_1_NOKSYMS
)
10155 printf (" NOKSYMS");
10156 val
^= DF_1_NOKSYMS
;
10158 if (val
& DF_1_NOHDR
)
10163 if (val
& DF_1_EDITED
)
10165 printf (" EDITED");
10166 val
^= DF_1_EDITED
;
10168 if (val
& DF_1_NORELOC
)
10170 printf (" NORELOC");
10171 val
^= DF_1_NORELOC
;
10173 if (val
& DF_1_SYMINTPOSE
)
10175 printf (" SYMINTPOSE");
10176 val
^= DF_1_SYMINTPOSE
;
10178 if (val
& DF_1_GLOBAUDIT
)
10180 printf (" GLOBAUDIT");
10181 val
^= DF_1_GLOBAUDIT
;
10183 if (val
& DF_1_SINGLETON
)
10185 printf (" SINGLETON");
10186 val
^= DF_1_SINGLETON
;
10188 if (val
& DF_1_STUB
)
10193 if (val
& DF_1_PIE
)
10198 if (val
& DF_1_KMOD
)
10203 if (val
& DF_1_WEAKFILTER
)
10205 printf (" WEAKFILTER");
10206 val
^= DF_1_WEAKFILTER
;
10208 if (val
& DF_1_NOCOMMON
)
10210 printf (" NOCOMMON");
10211 val
^= DF_1_NOCOMMON
;
10214 printf (" %lx", val
);
10221 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10223 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10243 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10249 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10250 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10256 switch (entry
->d_tag
)
10259 printf (_("Shared library: [%s]"), name
);
10261 if (streq (name
, program_interpreter
))
10262 printf (_(" program interpreter"));
10266 printf (_("Library soname: [%s]"), name
);
10270 printf (_("Library rpath: [%s]"), name
);
10274 printf (_("Library runpath: [%s]"), name
);
10278 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10283 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10296 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10297 /* Fall through. */
10301 case DT_INIT_ARRAYSZ
:
10302 case DT_FINI_ARRAYSZ
:
10303 case DT_GNU_CONFLICTSZ
:
10304 case DT_GNU_LIBLISTSZ
:
10307 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10308 printf (_(" (bytes)\n"));
10313 case DT_VERNEEDNUM
:
10318 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10327 case DT_INIT_ARRAY
:
10328 case DT_FINI_ARRAY
:
10331 if (entry
->d_tag
== DT_USED
10332 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10334 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10338 printf (_("Not needed object: [%s]\n"), name
);
10343 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10349 /* The value of this entry is ignored. */
10354 case DT_GNU_PRELINKED
:
10358 time_t atime
= entry
->d_un
.d_val
;
10360 tmp
= gmtime (&atime
);
10361 /* PR 17533 file: 041-1244816-0.004. */
10363 printf (_("<corrupt time val: %lx"),
10364 (unsigned long) atime
);
10366 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10367 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10368 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10374 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10377 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10383 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10384 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10389 switch (filedata
->file_header
.e_machine
)
10392 dynamic_section_aarch64_val (entry
);
10395 case EM_MIPS_RS3_LE
:
10396 dynamic_section_mips_val (entry
);
10399 dynamic_section_parisc_val (entry
);
10402 dynamic_section_ia64_val (entry
);
10405 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10417 get_ver_flags (unsigned int flags
)
10419 static char buff
[128];
10426 if (flags
& VER_FLG_BASE
)
10427 strcat (buff
, "BASE");
10429 if (flags
& VER_FLG_WEAK
)
10431 if (flags
& VER_FLG_BASE
)
10432 strcat (buff
, " | ");
10434 strcat (buff
, "WEAK");
10437 if (flags
& VER_FLG_INFO
)
10439 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10440 strcat (buff
, " | ");
10442 strcat (buff
, "INFO");
10445 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10447 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10448 strcat (buff
, " | ");
10450 strcat (buff
, _("<unknown>"));
10456 /* Display the contents of the version sections. */
10459 process_version_sections (Filedata
* filedata
)
10461 Elf_Internal_Shdr
* section
;
10463 bfd_boolean found
= FALSE
;
10468 for (i
= 0, section
= filedata
->section_headers
;
10469 i
< filedata
->file_header
.e_shnum
;
10472 switch (section
->sh_type
)
10474 case SHT_GNU_verdef
:
10476 Elf_External_Verdef
* edefs
;
10483 printf (ngettext ("\nVersion definition section '%s' "
10484 "contains %u entry:\n",
10485 "\nVersion definition section '%s' "
10486 "contains %u entries:\n",
10488 printable_section_name (filedata
, section
),
10491 printf (_(" Addr: 0x"));
10492 printf_vma (section
->sh_addr
);
10493 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10494 (unsigned long) section
->sh_offset
, section
->sh_link
,
10495 printable_section_name_from_index (filedata
, section
->sh_link
));
10497 edefs
= (Elf_External_Verdef
*)
10498 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10499 _("version definition section"));
10502 endbuf
= (char *) edefs
+ section
->sh_size
;
10504 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10507 Elf_External_Verdef
* edef
;
10508 Elf_Internal_Verdef ent
;
10509 Elf_External_Verdaux
* eaux
;
10510 Elf_Internal_Verdaux aux
;
10511 unsigned long isum
;
10514 vstart
= ((char *) edefs
) + idx
;
10515 if (vstart
+ sizeof (*edef
) > endbuf
)
10518 edef
= (Elf_External_Verdef
*) vstart
;
10520 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10521 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10522 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10523 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10524 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10525 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10526 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10528 printf (_(" %#06lx: Rev: %d Flags: %s"),
10529 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10531 printf (_(" Index: %d Cnt: %d "),
10532 ent
.vd_ndx
, ent
.vd_cnt
);
10534 /* Check for overflow. */
10535 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10538 vstart
+= ent
.vd_aux
;
10540 if (vstart
+ sizeof (*eaux
) > endbuf
)
10542 eaux
= (Elf_External_Verdaux
*) vstart
;
10544 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10545 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10547 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10548 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10550 printf (_("Name index: %ld\n"), aux
.vda_name
);
10552 isum
= idx
+ ent
.vd_aux
;
10554 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10556 if (aux
.vda_next
< sizeof (*eaux
)
10557 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10559 warn (_("Invalid vda_next field of %lx\n"),
10564 /* Check for overflow. */
10565 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10568 isum
+= aux
.vda_next
;
10569 vstart
+= aux
.vda_next
;
10571 if (vstart
+ sizeof (*eaux
) > endbuf
)
10573 eaux
= (Elf_External_Verdaux
*) vstart
;
10575 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10576 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10578 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10579 printf (_(" %#06lx: Parent %d: %s\n"),
10580 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10582 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10583 isum
, j
, aux
.vda_name
);
10586 if (j
< ent
.vd_cnt
)
10587 printf (_(" Version def aux past end of section\n"));
10590 file: id:000001,src:000172+005151,op:splice,rep:2. */
10591 if (ent
.vd_next
< sizeof (*edef
)
10592 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10594 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10595 cnt
= section
->sh_info
;
10598 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10601 idx
+= ent
.vd_next
;
10604 if (cnt
< section
->sh_info
)
10605 printf (_(" Version definition past end of section\n"));
10611 case SHT_GNU_verneed
:
10613 Elf_External_Verneed
* eneed
;
10620 printf (ngettext ("\nVersion needs section '%s' "
10621 "contains %u entry:\n",
10622 "\nVersion needs section '%s' "
10623 "contains %u entries:\n",
10625 printable_section_name (filedata
, section
), section
->sh_info
);
10627 printf (_(" Addr: 0x"));
10628 printf_vma (section
->sh_addr
);
10629 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10630 (unsigned long) section
->sh_offset
, section
->sh_link
,
10631 printable_section_name_from_index (filedata
, section
->sh_link
));
10633 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10634 section
->sh_offset
, 1,
10636 _("Version Needs section"));
10639 endbuf
= (char *) eneed
+ section
->sh_size
;
10641 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10643 Elf_External_Verneed
* entry
;
10644 Elf_Internal_Verneed ent
;
10645 unsigned long isum
;
10649 vstart
= ((char *) eneed
) + idx
;
10650 if (vstart
+ sizeof (*entry
) > endbuf
)
10653 entry
= (Elf_External_Verneed
*) vstart
;
10655 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10656 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10657 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10658 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10659 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10661 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10663 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10664 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10666 printf (_(" File: %lx"), ent
.vn_file
);
10668 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10670 /* Check for overflow. */
10671 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10673 vstart
+= ent
.vn_aux
;
10675 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10677 Elf_External_Vernaux
* eaux
;
10678 Elf_Internal_Vernaux aux
;
10680 if (vstart
+ sizeof (*eaux
) > endbuf
)
10682 eaux
= (Elf_External_Vernaux
*) vstart
;
10684 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10685 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10686 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10687 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10688 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10690 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10691 printf (_(" %#06lx: Name: %s"),
10692 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10694 printf (_(" %#06lx: Name index: %lx"),
10695 isum
, aux
.vna_name
);
10697 printf (_(" Flags: %s Version: %d\n"),
10698 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10700 if (aux
.vna_next
< sizeof (*eaux
)
10701 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10703 warn (_("Invalid vna_next field of %lx\n"),
10708 /* Check for overflow. */
10709 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10711 isum
+= aux
.vna_next
;
10712 vstart
+= aux
.vna_next
;
10715 if (j
< ent
.vn_cnt
)
10716 warn (_("Missing Version Needs auxillary information\n"));
10718 if (ent
.vn_next
< sizeof (*entry
)
10719 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10721 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10722 cnt
= section
->sh_info
;
10725 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10727 idx
+= ent
.vn_next
;
10730 if (cnt
< section
->sh_info
)
10731 warn (_("Missing Version Needs information\n"));
10737 case SHT_GNU_versym
:
10739 Elf_Internal_Shdr
* link_section
;
10742 unsigned char * edata
;
10743 unsigned short * data
;
10745 Elf_Internal_Sym
* symbols
;
10746 Elf_Internal_Shdr
* string_sec
;
10747 unsigned long num_syms
;
10750 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10753 link_section
= filedata
->section_headers
+ section
->sh_link
;
10754 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10756 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10761 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10762 if (symbols
== NULL
)
10765 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10767 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10768 string_sec
->sh_size
,
10769 _("version string table"));
10776 printf (ngettext ("\nVersion symbols section '%s' "
10777 "contains %lu entry:\n",
10778 "\nVersion symbols section '%s' "
10779 "contains %lu entries:\n",
10781 printable_section_name (filedata
, section
), (unsigned long) total
);
10783 printf (_(" Addr: "));
10784 printf_vma (section
->sh_addr
);
10785 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10786 (unsigned long) section
->sh_offset
, section
->sh_link
,
10787 printable_section_name (filedata
, link_section
));
10789 off
= offset_from_vma (filedata
,
10790 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10791 total
* sizeof (short));
10792 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10794 _("version symbol data"));
10802 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10804 for (cnt
= total
; cnt
--;)
10805 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10810 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10814 char *invalid
= _("*invalid*");
10816 printf (" %03x:", cnt
);
10818 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10819 switch (data
[cnt
+ j
])
10822 fputs (_(" 0 (*local*) "), stdout
);
10826 fputs (_(" 1 (*global*) "), stdout
);
10830 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10831 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10833 /* If this index value is greater than the size of the symbols
10834 array, break to avoid an out-of-bounds read. */
10835 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10837 warn (_("invalid index into symbol array\n"));
10842 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10844 Elf_Internal_Verneed ivn
;
10845 unsigned long offset
;
10847 offset
= offset_from_vma
10848 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10849 sizeof (Elf_External_Verneed
));
10853 Elf_Internal_Vernaux ivna
;
10854 Elf_External_Verneed evn
;
10855 Elf_External_Vernaux evna
;
10856 unsigned long a_off
;
10858 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10859 _("version need")) == NULL
)
10862 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10863 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10865 a_off
= offset
+ ivn
.vn_aux
;
10869 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10870 1, _("version need aux (2)")) == NULL
)
10873 ivna
.vna_other
= 0;
10877 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10878 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10881 a_off
+= ivna
.vna_next
;
10883 while (ivna
.vna_other
!= data
[cnt
+ j
]
10884 && ivna
.vna_next
!= 0);
10886 if (ivna
.vna_other
== data
[cnt
+ j
])
10888 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10890 if (ivna
.vna_name
>= string_sec
->sh_size
)
10893 name
= strtab
+ ivna
.vna_name
;
10897 offset
+= ivn
.vn_next
;
10899 while (ivn
.vn_next
);
10902 if (data
[cnt
+ j
] != 0x8001
10903 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10905 Elf_Internal_Verdef ivd
;
10906 Elf_External_Verdef evd
;
10907 unsigned long offset
;
10909 offset
= offset_from_vma
10910 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10915 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10916 _("version def")) == NULL
)
10919 /* PR 17531: file: 046-1082287-0.004. */
10920 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10925 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10926 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10929 offset
+= ivd
.vd_next
;
10931 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10932 && ivd
.vd_next
!= 0);
10934 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10936 Elf_External_Verdaux evda
;
10937 Elf_Internal_Verdaux ivda
;
10939 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10941 if (get_data (&evda
, filedata
,
10942 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10944 _("version def aux")) == NULL
)
10947 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10949 if (ivda
.vda_name
>= string_sec
->sh_size
)
10951 else if (name
!= NULL
&& name
!= invalid
)
10952 name
= _("*both*");
10954 name
= strtab
+ ivda
.vda_name
;
10958 nn
+= printf ("(%s%-*s",
10960 12 - (int) strlen (name
),
10964 printf ("%*c", 18 - nn
, ' ');
10982 printf (_("\nNo version information found in this file.\n"));
10987 static const char *
10988 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10990 static char buff
[32];
10994 case STB_LOCAL
: return "LOCAL";
10995 case STB_GLOBAL
: return "GLOBAL";
10996 case STB_WEAK
: return "WEAK";
10998 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10999 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11001 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11003 if (binding
== STB_GNU_UNIQUE
11004 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11005 /* GNU is still using the default value 0. */
11006 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
11008 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11011 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11016 static const char *
11017 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11019 static char buff
[32];
11023 case STT_NOTYPE
: return "NOTYPE";
11024 case STT_OBJECT
: return "OBJECT";
11025 case STT_FUNC
: return "FUNC";
11026 case STT_SECTION
: return "SECTION";
11027 case STT_FILE
: return "FILE";
11028 case STT_COMMON
: return "COMMON";
11029 case STT_TLS
: return "TLS";
11030 case STT_RELC
: return "RELC";
11031 case STT_SRELC
: return "SRELC";
11033 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11035 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11036 return "THUMB_FUNC";
11038 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11041 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11042 return "PARISC_MILLI";
11044 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11046 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11048 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11050 if (type
== STT_HP_OPAQUE
)
11051 return "HP_OPAQUE";
11052 if (type
== STT_HP_STUB
)
11056 if (type
== STT_GNU_IFUNC
11057 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11058 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
11059 /* GNU is still using the default value 0. */
11060 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
11063 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11066 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11071 static const char *
11072 get_symbol_visibility (unsigned int visibility
)
11074 switch (visibility
)
11076 case STV_DEFAULT
: return "DEFAULT";
11077 case STV_INTERNAL
: return "INTERNAL";
11078 case STV_HIDDEN
: return "HIDDEN";
11079 case STV_PROTECTED
: return "PROTECTED";
11081 error (_("Unrecognized visibility value: %u"), visibility
);
11082 return _("<unknown>");
11086 static const char *
11087 get_solaris_symbol_visibility (unsigned int visibility
)
11089 switch (visibility
)
11091 case 4: return "EXPORTED";
11092 case 5: return "SINGLETON";
11093 case 6: return "ELIMINATE";
11094 default: return get_symbol_visibility (visibility
);
11098 static const char *
11099 get_mips_symbol_other (unsigned int other
)
11103 case STO_OPTIONAL
: return "OPTIONAL";
11104 case STO_MIPS_PLT
: return "MIPS PLT";
11105 case STO_MIPS_PIC
: return "MIPS PIC";
11106 case STO_MICROMIPS
: return "MICROMIPS";
11107 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11108 case STO_MIPS16
: return "MIPS16";
11109 default: return NULL
;
11113 static const char *
11114 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11116 if (is_ia64_vms (filedata
))
11118 static char res
[32];
11122 /* Function types is for images and .STB files only. */
11123 switch (filedata
->file_header
.e_type
)
11127 switch (VMS_ST_FUNC_TYPE (other
))
11129 case VMS_SFT_CODE_ADDR
:
11130 strcat (res
, " CA");
11132 case VMS_SFT_SYMV_IDX
:
11133 strcat (res
, " VEC");
11136 strcat (res
, " FD");
11138 case VMS_SFT_RESERVE
:
11139 strcat (res
, " RSV");
11142 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11143 VMS_ST_FUNC_TYPE (other
));
11144 strcat (res
, " <unknown>");
11151 switch (VMS_ST_LINKAGE (other
))
11153 case VMS_STL_IGNORE
:
11154 strcat (res
, " IGN");
11156 case VMS_STL_RESERVE
:
11157 strcat (res
, " RSV");
11160 strcat (res
, " STD");
11163 strcat (res
, " LNK");
11166 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11167 VMS_ST_LINKAGE (other
));
11168 strcat (res
, " <unknown>");
11180 static const char *
11181 get_ppc64_symbol_other (unsigned int other
)
11183 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11186 other
>>= STO_PPC64_LOCAL_BIT
;
11189 static char buf
[32];
11191 other
= ppc64_decode_local_entry (other
);
11192 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11198 static const char *
11199 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11201 const char * result
= NULL
;
11202 static char buff
[32];
11207 switch (filedata
->file_header
.e_machine
)
11210 result
= get_mips_symbol_other (other
);
11213 result
= get_ia64_symbol_other (filedata
, other
);
11216 result
= get_ppc64_symbol_other (other
);
11226 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11230 static const char *
11231 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11233 static char buff
[32];
11237 case SHN_UNDEF
: return "UND";
11238 case SHN_ABS
: return "ABS";
11239 case SHN_COMMON
: return "COM";
11241 if (type
== SHN_IA_64_ANSI_COMMON
11242 && filedata
->file_header
.e_machine
== EM_IA_64
11243 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11245 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11246 || filedata
->file_header
.e_machine
== EM_L1OM
11247 || filedata
->file_header
.e_machine
== EM_K1OM
)
11248 && type
== SHN_X86_64_LCOMMON
)
11249 return "LARGE_COM";
11250 else if ((type
== SHN_MIPS_SCOMMON
11251 && filedata
->file_header
.e_machine
== EM_MIPS
)
11252 || (type
== SHN_TIC6X_SCOMMON
11253 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11255 else if (type
== SHN_MIPS_SUNDEFINED
11256 && filedata
->file_header
.e_machine
== EM_MIPS
)
11258 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11259 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11260 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11261 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11262 else if (type
>= SHN_LORESERVE
)
11263 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11264 else if (type
>= filedata
->file_header
.e_shnum
)
11265 sprintf (buff
, _("bad section index[%3d]"), type
);
11267 sprintf (buff
, "%3d", type
);
11275 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11277 unsigned char * e_data
;
11280 /* If the size_t type is smaller than the bfd_size_type, eg because
11281 you are building a 32-bit tool on a 64-bit host, then make sure
11282 that when (number) is cast to (size_t) no information is lost. */
11283 if (sizeof (size_t) < sizeof (bfd_size_type
)
11284 && (bfd_size_type
) ((size_t) number
) != number
)
11286 error (_("Size truncation prevents reading %s elements of size %u\n"),
11287 bfd_vmatoa ("u", number
), ent_size
);
11291 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11292 attempting to allocate memory when the read is bound to fail. */
11293 if (ent_size
* number
> filedata
->file_size
)
11295 error (_("Invalid number of dynamic entries: %s\n"),
11296 bfd_vmatoa ("u", number
));
11300 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11301 if (e_data
== NULL
)
11303 error (_("Out of memory reading %s dynamic entries\n"),
11304 bfd_vmatoa ("u", number
));
11308 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11310 error (_("Unable to read in %s bytes of dynamic data\n"),
11311 bfd_vmatoa ("u", number
* ent_size
));
11316 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11317 if (i_data
== NULL
)
11319 error (_("Out of memory allocating space for %s dynamic entries\n"),
11320 bfd_vmatoa ("u", number
));
11326 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11334 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11336 Elf_Internal_Sym
* psym
;
11339 n
= print_vma (si
, DEC_5
);
11341 fputs (&" "[n
], stdout
);
11342 printf (" %3lu: ", hn
);
11344 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11346 printf (_("<No info available for dynamic symbol number %lu>\n"),
11347 (unsigned long) si
);
11351 psym
= dynamic_symbols
+ si
;
11352 print_vma (psym
->st_value
, LONG_HEX
);
11354 print_vma (psym
->st_size
, DEC_5
);
11356 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11357 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11359 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11360 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11363 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11365 printf (" %-7s", get_symbol_visibility (vis
));
11366 /* Check to see if any other bits in the st_other field are set.
11367 Note - displaying this information disrupts the layout of the
11368 table being generated, but for the moment this case is very
11370 if (psym
->st_other
^ vis
)
11371 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11374 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11375 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11376 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11378 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11382 static const char *
11383 get_symbol_version_string (Filedata
* filedata
,
11384 bfd_boolean is_dynsym
,
11385 const char * strtab
,
11386 unsigned long int strtab_size
,
11388 Elf_Internal_Sym
* psym
,
11389 enum versioned_symbol_info
* sym_info
,
11390 unsigned short * vna_other
)
11392 unsigned char data
[2];
11393 unsigned short vers_data
;
11394 unsigned long offset
;
11395 unsigned short max_vd_ndx
;
11398 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11401 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11402 sizeof data
+ si
* sizeof (vers_data
));
11404 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11405 sizeof (data
), 1, _("version data")) == NULL
)
11408 vers_data
= byte_get (data
, 2);
11410 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11415 /* Usually we'd only see verdef for defined symbols, and verneed for
11416 undefined symbols. However, symbols defined by the linker in
11417 .dynbss for variables copied from a shared library in order to
11418 avoid text relocations are defined yet have verneed. We could
11419 use a heuristic to detect the special case, for example, check
11420 for verneed first on symbols defined in SHT_NOBITS sections, but
11421 it is simpler and more reliable to just look for both verdef and
11422 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11424 if (psym
->st_shndx
!= SHN_UNDEF
11425 && vers_data
!= 0x8001
11426 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11428 Elf_Internal_Verdef ivd
;
11429 Elf_Internal_Verdaux ivda
;
11430 Elf_External_Verdaux evda
;
11433 off
= offset_from_vma (filedata
,
11434 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11435 sizeof (Elf_External_Verdef
));
11439 Elf_External_Verdef evd
;
11441 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11442 _("version def")) == NULL
)
11451 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11452 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11453 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11454 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11457 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11458 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11460 off
+= ivd
.vd_next
;
11462 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11464 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11466 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11469 off
-= ivd
.vd_next
;
11472 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11473 _("version def aux")) != NULL
)
11475 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11477 if (psym
->st_name
!= ivda
.vda_name
)
11479 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11480 ? symbol_hidden
: symbol_public
);
11481 return (ivda
.vda_name
< strtab_size
11482 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11488 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11490 Elf_External_Verneed evn
;
11491 Elf_Internal_Verneed ivn
;
11492 Elf_Internal_Vernaux ivna
;
11494 offset
= offset_from_vma (filedata
,
11495 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11499 unsigned long vna_off
;
11501 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11502 _("version need")) == NULL
)
11505 ivna
.vna_other
= 0;
11510 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11511 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11513 vna_off
= offset
+ ivn
.vn_aux
;
11517 Elf_External_Vernaux evna
;
11519 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11520 _("version need aux (3)")) == NULL
)
11523 ivna
.vna_other
= 0;
11528 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11529 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11530 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11533 vna_off
+= ivna
.vna_next
;
11535 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11537 if (ivna
.vna_other
== vers_data
)
11540 offset
+= ivn
.vn_next
;
11542 while (ivn
.vn_next
!= 0);
11544 if (ivna
.vna_other
== vers_data
)
11546 *sym_info
= symbol_undefined
;
11547 *vna_other
= ivna
.vna_other
;
11548 return (ivna
.vna_name
< strtab_size
11549 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11551 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11552 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11553 return _("<corrupt>");
11558 /* Dump the symbol table. */
11560 process_symbol_table (Filedata
* filedata
)
11562 Elf_Internal_Shdr
* section
;
11563 bfd_size_type nbuckets
= 0;
11564 bfd_size_type nchains
= 0;
11565 bfd_vma
* buckets
= NULL
;
11566 bfd_vma
* chains
= NULL
;
11567 bfd_vma ngnubuckets
= 0;
11568 bfd_vma
* gnubuckets
= NULL
;
11569 bfd_vma
* gnuchains
= NULL
;
11570 bfd_vma gnusymidx
= 0;
11571 bfd_size_type ngnuchains
= 0;
11573 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11576 if (dynamic_info
[DT_HASH
]
11578 || (do_using_dynamic
11580 && dynamic_strings
!= NULL
)))
11582 unsigned char nb
[8];
11583 unsigned char nc
[8];
11584 unsigned int hash_ent_size
= 4;
11586 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11587 || filedata
->file_header
.e_machine
== EM_S390
11588 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11589 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11592 if (fseek (filedata
->handle
,
11593 (archive_file_offset
11594 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11595 sizeof nb
+ sizeof nc
)),
11598 error (_("Unable to seek to start of dynamic information\n"));
11602 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11604 error (_("Failed to read in number of buckets\n"));
11608 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11610 error (_("Failed to read in number of chains\n"));
11614 nbuckets
= byte_get (nb
, hash_ent_size
);
11615 nchains
= byte_get (nc
, hash_ent_size
);
11617 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11618 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11621 if (buckets
== NULL
|| chains
== NULL
)
11623 if (do_using_dynamic
)
11634 if (dynamic_info_DT_GNU_HASH
11636 || (do_using_dynamic
11638 && dynamic_strings
!= NULL
)))
11640 unsigned char nb
[16];
11641 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11642 bfd_vma buckets_vma
;
11644 if (fseek (filedata
->handle
,
11645 (archive_file_offset
11646 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11650 error (_("Unable to seek to start of dynamic information\n"));
11654 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11656 error (_("Failed to read in number of buckets\n"));
11660 ngnubuckets
= byte_get (nb
, 4);
11661 gnusymidx
= byte_get (nb
+ 4, 4);
11662 bitmaskwords
= byte_get (nb
+ 8, 4);
11663 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11665 buckets_vma
+= bitmaskwords
* 4;
11667 buckets_vma
+= bitmaskwords
* 8;
11669 if (fseek (filedata
->handle
,
11670 (archive_file_offset
11671 + offset_from_vma (filedata
, buckets_vma
, 4)),
11674 error (_("Unable to seek to start of dynamic information\n"));
11678 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11680 if (gnubuckets
== NULL
)
11683 for (i
= 0; i
< ngnubuckets
; i
++)
11684 if (gnubuckets
[i
] != 0)
11686 if (gnubuckets
[i
] < gnusymidx
)
11689 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11690 maxchain
= gnubuckets
[i
];
11693 if (maxchain
== 0xffffffff)
11696 maxchain
-= gnusymidx
;
11698 if (fseek (filedata
->handle
,
11699 (archive_file_offset
11700 + offset_from_vma (filedata
, buckets_vma
11701 + 4 * (ngnubuckets
+ maxchain
), 4)),
11704 error (_("Unable to seek to start of dynamic information\n"));
11710 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11712 error (_("Failed to determine last chain length\n"));
11716 if (maxchain
+ 1 == 0)
11721 while ((byte_get (nb
, 4) & 1) == 0);
11723 if (fseek (filedata
->handle
,
11724 (archive_file_offset
11725 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11728 error (_("Unable to seek to start of dynamic information\n"));
11732 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11733 ngnuchains
= maxchain
;
11736 if (gnuchains
== NULL
)
11741 if (do_using_dynamic
)
11746 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11748 && do_using_dynamic
11749 && dynamic_strings
!= NULL
11750 && dynamic_symbols
!= NULL
)
11754 if (dynamic_info
[DT_HASH
])
11759 printf (_("\nSymbol table for image:\n"));
11761 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11763 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11765 visited
= xcmalloc (nchains
, 1);
11766 memset (visited
, 0, nchains
);
11767 for (hn
= 0; hn
< nbuckets
; hn
++)
11769 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11771 print_dynamic_symbol (filedata
, si
, hn
);
11772 if (si
>= nchains
|| visited
[si
])
11774 error (_("histogram chain is corrupt\n"));
11783 if (dynamic_info_DT_GNU_HASH
)
11785 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11787 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11789 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11791 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11792 if (gnubuckets
[hn
] != 0)
11794 bfd_vma si
= gnubuckets
[hn
];
11795 bfd_vma off
= si
- gnusymidx
;
11799 print_dynamic_symbol (filedata
, si
, hn
);
11802 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11806 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11807 && filedata
->section_headers
!= NULL
)
11811 for (i
= 0, section
= filedata
->section_headers
;
11812 i
< filedata
->file_header
.e_shnum
;
11816 char * strtab
= NULL
;
11817 unsigned long int strtab_size
= 0;
11818 Elf_Internal_Sym
* symtab
;
11819 Elf_Internal_Sym
* psym
;
11820 unsigned long num_syms
;
11822 if ((section
->sh_type
!= SHT_SYMTAB
11823 && section
->sh_type
!= SHT_DYNSYM
)
11825 && section
->sh_type
== SHT_SYMTAB
))
11828 if (section
->sh_entsize
== 0)
11830 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11831 printable_section_name (filedata
, section
));
11835 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11836 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11837 "\nSymbol table '%s' contains %lu entries:\n",
11839 printable_section_name (filedata
, section
),
11843 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11845 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11847 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11848 if (symtab
== NULL
)
11851 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11853 strtab
= filedata
->string_table
;
11854 strtab_size
= filedata
->string_table_length
;
11856 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11858 Elf_Internal_Shdr
* string_sec
;
11860 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11862 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11863 1, string_sec
->sh_size
,
11864 _("string table"));
11865 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11868 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11870 const char *version_string
;
11871 enum versioned_symbol_info sym_info
;
11872 unsigned short vna_other
;
11874 printf ("%6d: ", si
);
11875 print_vma (psym
->st_value
, LONG_HEX
);
11877 print_vma (psym
->st_size
, DEC_5
);
11878 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11879 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11880 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11881 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11884 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11886 printf (" %-7s", get_symbol_visibility (vis
));
11887 /* Check to see if any other bits in the st_other field are set.
11888 Note - displaying this information disrupts the layout of the
11889 table being generated, but for the moment this case is very rare. */
11890 if (psym
->st_other
^ vis
)
11891 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11893 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11894 print_symbol (25, psym
->st_name
< strtab_size
11895 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11898 = get_symbol_version_string (filedata
,
11899 section
->sh_type
== SHT_DYNSYM
,
11900 strtab
, strtab_size
, si
,
11901 psym
, &sym_info
, &vna_other
);
11902 if (version_string
)
11904 if (sym_info
== symbol_undefined
)
11905 printf ("@%s (%d)", version_string
, vna_other
);
11907 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11913 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11914 && si
>= section
->sh_info
11915 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11916 && filedata
->file_header
.e_machine
!= EM_MIPS
11917 /* Solaris binaries have been found to violate this requirement as
11918 well. Not sure if this is a bug or an ABI requirement. */
11919 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11920 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11921 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11925 if (strtab
!= filedata
->string_table
)
11931 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11933 if (do_histogram
&& buckets
!= NULL
)
11935 unsigned long * lengths
;
11936 unsigned long * counts
;
11939 unsigned long maxlength
= 0;
11940 unsigned long nzero_counts
= 0;
11941 unsigned long nsyms
= 0;
11944 printf (ngettext ("\nHistogram for bucket list length "
11945 "(total of %lu bucket):\n",
11946 "\nHistogram for bucket list length "
11947 "(total of %lu buckets):\n",
11948 (unsigned long) nbuckets
),
11949 (unsigned long) nbuckets
);
11951 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11952 if (lengths
== NULL
)
11954 error (_("Out of memory allocating space for histogram buckets\n"));
11957 visited
= xcmalloc (nchains
, 1);
11958 memset (visited
, 0, nchains
);
11960 printf (_(" Length Number %% of total Coverage\n"));
11961 for (hn
= 0; hn
< nbuckets
; ++hn
)
11963 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11966 if (maxlength
< ++lengths
[hn
])
11968 if (si
>= nchains
|| visited
[si
])
11970 error (_("histogram chain is corrupt\n"));
11978 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11979 if (counts
== NULL
)
11982 error (_("Out of memory allocating space for histogram counts\n"));
11986 for (hn
= 0; hn
< nbuckets
; ++hn
)
11987 ++counts
[lengths
[hn
]];
11992 printf (" 0 %-10lu (%5.1f%%)\n",
11993 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11994 for (i
= 1; i
<= maxlength
; ++i
)
11996 nzero_counts
+= counts
[i
] * i
;
11997 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11998 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11999 (nzero_counts
* 100.0) / nsyms
);
12007 if (buckets
!= NULL
)
12013 if (do_histogram
&& gnubuckets
!= NULL
)
12015 unsigned long * lengths
;
12016 unsigned long * counts
;
12018 unsigned long maxlength
= 0;
12019 unsigned long nzero_counts
= 0;
12020 unsigned long nsyms
= 0;
12022 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
12023 "(total of %lu bucket):\n",
12024 "\nHistogram for `.gnu.hash' bucket list length "
12025 "(total of %lu buckets):\n",
12026 (unsigned long) ngnubuckets
),
12027 (unsigned long) ngnubuckets
);
12029 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12030 if (lengths
== NULL
)
12032 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12036 printf (_(" Length Number %% of total Coverage\n"));
12038 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12039 if (gnubuckets
[hn
] != 0)
12041 bfd_vma off
, length
= 1;
12043 for (off
= gnubuckets
[hn
] - gnusymidx
;
12044 /* PR 17531 file: 010-77222-0.004. */
12045 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12048 lengths
[hn
] = length
;
12049 if (length
> maxlength
)
12050 maxlength
= length
;
12054 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12055 if (counts
== NULL
)
12058 error (_("Out of memory allocating space for gnu histogram counts\n"));
12062 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12063 ++counts
[lengths
[hn
]];
12065 if (ngnubuckets
> 0)
12068 printf (" 0 %-10lu (%5.1f%%)\n",
12069 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12070 for (j
= 1; j
<= maxlength
; ++j
)
12072 nzero_counts
+= counts
[j
] * j
;
12073 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12074 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12075 (nzero_counts
* 100.0) / nsyms
);
12089 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12093 if (dynamic_syminfo
== NULL
12095 /* No syminfo, this is ok. */
12098 /* There better should be a dynamic symbol section. */
12099 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12103 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12104 "contains %d entry:\n",
12105 "\nDynamic info segment at offset 0x%lx "
12106 "contains %d entries:\n",
12107 dynamic_syminfo_nent
),
12108 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12110 printf (_(" Num: Name BoundTo Flags\n"));
12111 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12113 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12115 printf ("%4d: ", i
);
12116 if (i
>= num_dynamic_syms
)
12117 printf (_("<corrupt index>"));
12118 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12119 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12121 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12124 switch (dynamic_syminfo
[i
].si_boundto
)
12126 case SYMINFO_BT_SELF
:
12127 fputs ("SELF ", stdout
);
12129 case SYMINFO_BT_PARENT
:
12130 fputs ("PARENT ", stdout
);
12133 if (dynamic_syminfo
[i
].si_boundto
> 0
12134 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12135 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12137 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12141 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12145 if (flags
& SYMINFO_FLG_DIRECT
)
12146 printf (" DIRECT");
12147 if (flags
& SYMINFO_FLG_PASSTHRU
)
12148 printf (" PASSTHRU");
12149 if (flags
& SYMINFO_FLG_COPY
)
12151 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12152 printf (" LAZYLOAD");
12160 #define IN_RANGE(START,END,ADDR,OFF) \
12161 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12163 /* Check to see if the given reloc needs to be handled in a target specific
12164 manner. If so then process the reloc and return TRUE otherwise return
12167 If called with reloc == NULL, then this is a signal that reloc processing
12168 for the current section has finished, and any saved state should be
12172 target_specific_reloc_handling (Filedata
* filedata
,
12173 Elf_Internal_Rela
* reloc
,
12174 unsigned char * start
,
12175 unsigned char * end
,
12176 Elf_Internal_Sym
* symtab
,
12177 unsigned long num_syms
)
12179 unsigned int reloc_type
= 0;
12180 unsigned long sym_index
= 0;
12184 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12185 sym_index
= get_reloc_symindex (reloc
->r_info
);
12188 switch (filedata
->file_header
.e_machine
)
12191 case EM_MSP430_OLD
:
12193 static Elf_Internal_Sym
* saved_sym
= NULL
;
12201 switch (reloc_type
)
12203 case 10: /* R_MSP430_SYM_DIFF */
12204 if (uses_msp430x_relocs (filedata
))
12206 /* Fall through. */
12207 case 21: /* R_MSP430X_SYM_DIFF */
12209 if (sym_index
>= num_syms
)
12210 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12213 saved_sym
= symtab
+ sym_index
;
12216 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12217 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12218 goto handle_sym_diff
;
12220 case 5: /* R_MSP430_16_BYTE */
12221 case 9: /* R_MSP430_8 */
12222 if (uses_msp430x_relocs (filedata
))
12224 goto handle_sym_diff
;
12226 case 2: /* R_MSP430_ABS16 */
12227 case 15: /* R_MSP430X_ABS16 */
12228 if (! uses_msp430x_relocs (filedata
))
12230 goto handle_sym_diff
;
12233 if (saved_sym
!= NULL
)
12235 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12238 if (sym_index
>= num_syms
)
12239 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12243 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12244 - saved_sym
->st_value
);
12246 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12247 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12250 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12251 (long) reloc
->r_offset
);
12260 if (saved_sym
!= NULL
)
12261 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12268 case EM_CYGNUS_MN10300
:
12270 static Elf_Internal_Sym
* saved_sym
= NULL
;
12278 switch (reloc_type
)
12280 case 34: /* R_MN10300_ALIGN */
12282 case 33: /* R_MN10300_SYM_DIFF */
12283 if (sym_index
>= num_syms
)
12284 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12287 saved_sym
= symtab
+ sym_index
;
12290 case 1: /* R_MN10300_32 */
12291 case 2: /* R_MN10300_16 */
12292 if (saved_sym
!= NULL
)
12294 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12297 if (sym_index
>= num_syms
)
12298 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12302 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12303 - saved_sym
->st_value
);
12305 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12306 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12308 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12309 (long) reloc
->r_offset
);
12317 if (saved_sym
!= NULL
)
12318 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12326 static bfd_vma saved_sym1
= 0;
12327 static bfd_vma saved_sym2
= 0;
12328 static bfd_vma value
;
12332 saved_sym1
= saved_sym2
= 0;
12336 switch (reloc_type
)
12338 case 0x80: /* R_RL78_SYM. */
12339 saved_sym1
= saved_sym2
;
12340 if (sym_index
>= num_syms
)
12341 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12345 saved_sym2
= symtab
[sym_index
].st_value
;
12346 saved_sym2
+= reloc
->r_addend
;
12350 case 0x83: /* R_RL78_OPsub. */
12351 value
= saved_sym1
- saved_sym2
;
12352 saved_sym2
= saved_sym1
= 0;
12356 case 0x41: /* R_RL78_ABS32. */
12357 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12358 byte_put (start
+ reloc
->r_offset
, value
, 4);
12360 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12361 (long) reloc
->r_offset
);
12365 case 0x43: /* R_RL78_ABS16. */
12366 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12367 byte_put (start
+ reloc
->r_offset
, value
, 2);
12369 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12370 (long) reloc
->r_offset
);
12384 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12385 DWARF debug sections. This is a target specific test. Note - we do not
12386 go through the whole including-target-headers-multiple-times route, (as
12387 we have already done with <elf/h8.h>) because this would become very
12388 messy and even then this function would have to contain target specific
12389 information (the names of the relocs instead of their numeric values).
12390 FIXME: This is not the correct way to solve this problem. The proper way
12391 is to have target specific reloc sizing and typing functions created by
12392 the reloc-macros.h header, in the same way that it already creates the
12393 reloc naming functions. */
12396 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12398 /* Please keep this table alpha-sorted for ease of visual lookup. */
12399 switch (filedata
->file_header
.e_machine
)
12403 return reloc_type
== 1; /* R_386_32. */
12405 return reloc_type
== 1; /* R_68K_32. */
12407 return reloc_type
== 1; /* R_860_32. */
12409 return reloc_type
== 2; /* R_960_32. */
12411 return (reloc_type
== 258
12412 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12413 case EM_ADAPTEVA_EPIPHANY
:
12414 return reloc_type
== 3;
12416 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12418 return reloc_type
== 1; /* R_ARC_32. */
12419 case EM_ARC_COMPACT
:
12420 case EM_ARC_COMPACT2
:
12421 return reloc_type
== 4; /* R_ARC_32. */
12423 return reloc_type
== 2; /* R_ARM_ABS32 */
12426 return reloc_type
== 1;
12428 return reloc_type
== 0x12; /* R_byte4_data. */
12430 return reloc_type
== 3; /* R_CRIS_32. */
12432 return reloc_type
== 3; /* R_CR16_NUM32. */
12434 return reloc_type
== 15; /* R_CRX_NUM32. */
12436 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12437 case EM_CYGNUS_FRV
:
12438 return reloc_type
== 1;
12439 case EM_CYGNUS_D10V
:
12441 return reloc_type
== 6; /* R_D10V_32. */
12442 case EM_CYGNUS_D30V
:
12444 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12446 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12447 case EM_CYGNUS_FR30
:
12449 return reloc_type
== 3; /* R_FR30_32. */
12451 return reloc_type
== 1; /* R_FT32_32. */
12455 return reloc_type
== 1; /* R_H8_DIR32. */
12457 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12458 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12459 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12460 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12463 return reloc_type
== 2; /* R_IP2K_32. */
12465 return reloc_type
== 2; /* R_IQ2000_32. */
12466 case EM_LATTICEMICO32
:
12467 return reloc_type
== 3; /* R_LM32_32. */
12470 return reloc_type
== 3; /* R_M32C_32. */
12472 return reloc_type
== 34; /* R_M32R_32_RELA. */
12475 return reloc_type
== 6; /* R_M68HC11_32. */
12477 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12478 reloc_type
== 6; /* R_S12Z_CW32. */
12480 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12481 case EM_CYGNUS_MEP
:
12482 return reloc_type
== 4; /* R_MEP_32. */
12484 return reloc_type
== 2; /* R_METAG_ADDR32. */
12485 case EM_MICROBLAZE
:
12486 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12488 return reloc_type
== 2; /* R_MIPS_32. */
12490 return reloc_type
== 4; /* R_MMIX_32. */
12491 case EM_CYGNUS_MN10200
:
12493 return reloc_type
== 1; /* R_MN10200_32. */
12494 case EM_CYGNUS_MN10300
:
12496 return reloc_type
== 1; /* R_MN10300_32. */
12498 return reloc_type
== 1; /* R_MOXIE_32. */
12499 case EM_MSP430_OLD
:
12501 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12503 return reloc_type
== 2; /* R_MT_32. */
12505 return reloc_type
== 20; /* R_NDS32_RELA. */
12506 case EM_ALTERA_NIOS2
:
12507 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12509 return reloc_type
== 1; /* R_NIOS_32. */
12511 return reloc_type
== 1; /* R_OR1K_32. */
12513 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12514 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12515 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12518 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12520 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12522 return reloc_type
== 1; /* R_PPC_ADDR32. */
12524 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12526 return reloc_type
== 1; /* R_RISCV_32. */
12528 return reloc_type
== 1; /* R_RL78_DIR32. */
12530 return reloc_type
== 1; /* R_RX_DIR32. */
12532 return reloc_type
== 1; /* R_I370_ADDR31. */
12535 return reloc_type
== 4; /* R_S390_32. */
12537 return reloc_type
== 8; /* R_SCORE_ABS32. */
12539 return reloc_type
== 1; /* R_SH_DIR32. */
12540 case EM_SPARC32PLUS
:
12543 return reloc_type
== 3 /* R_SPARC_32. */
12544 || reloc_type
== 23; /* R_SPARC_UA32. */
12546 return reloc_type
== 6; /* R_SPU_ADDR32 */
12548 return reloc_type
== 1; /* R_C6000_ABS32. */
12550 return reloc_type
== 2; /* R_TILEGX_32. */
12552 return reloc_type
== 1; /* R_TILEPRO_32. */
12553 case EM_CYGNUS_V850
:
12555 return reloc_type
== 6; /* R_V850_ABS32. */
12557 return reloc_type
== 0x33; /* R_V810_WORD. */
12559 return reloc_type
== 1; /* R_VAX_32. */
12561 return reloc_type
== 3; /* R_VISIUM_32. */
12562 case EM_WEBASSEMBLY
:
12563 return reloc_type
== 1; /* R_WASM32_32. */
12567 return reloc_type
== 10; /* R_X86_64_32. */
12570 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12572 return reloc_type
== 4; /* R_XGATE_32. */
12574 return reloc_type
== 1; /* R_XSTROMY16_32. */
12575 case EM_XTENSA_OLD
:
12577 return reloc_type
== 1; /* R_XTENSA_32. */
12580 static unsigned int prev_warn
= 0;
12582 /* Avoid repeating the same warning multiple times. */
12583 if (prev_warn
!= filedata
->file_header
.e_machine
)
12584 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12585 filedata
->file_header
.e_machine
);
12586 prev_warn
= filedata
->file_header
.e_machine
;
12592 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12593 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12596 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12598 switch (filedata
->file_header
.e_machine
)
12599 /* Please keep this table alpha-sorted for ease of visual lookup. */
12603 return reloc_type
== 2; /* R_386_PC32. */
12605 return reloc_type
== 4; /* R_68K_PC32. */
12607 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12608 case EM_ADAPTEVA_EPIPHANY
:
12609 return reloc_type
== 6;
12611 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12612 case EM_ARC_COMPACT
:
12613 case EM_ARC_COMPACT2
:
12614 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12616 return reloc_type
== 3; /* R_ARM_REL32 */
12619 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12620 case EM_MICROBLAZE
:
12621 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12623 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12625 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12627 return reloc_type
== 26; /* R_PPC_REL32. */
12629 return reloc_type
== 26; /* R_PPC64_REL32. */
12631 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12634 return reloc_type
== 5; /* R_390_PC32. */
12636 return reloc_type
== 2; /* R_SH_REL32. */
12637 case EM_SPARC32PLUS
:
12640 return reloc_type
== 6; /* R_SPARC_DISP32. */
12642 return reloc_type
== 13; /* R_SPU_REL32. */
12644 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12646 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12648 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12652 return reloc_type
== 2; /* R_X86_64_PC32. */
12653 case EM_XTENSA_OLD
:
12655 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12657 /* Do not abort or issue an error message here. Not all targets use
12658 pc-relative 32-bit relocs in their DWARF debug information and we
12659 have already tested for target coverage in is_32bit_abs_reloc. A
12660 more helpful warning message will be generated by apply_relocations
12661 anyway, so just return. */
12666 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12667 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12670 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12672 switch (filedata
->file_header
.e_machine
)
12675 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12677 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12679 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12680 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12682 return reloc_type
== 80; /* R_PARISC_DIR64. */
12684 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12686 return reloc_type
== 2; /* R_RISCV_64. */
12687 case EM_SPARC32PLUS
:
12690 return reloc_type
== 32 /* R_SPARC_64. */
12691 || reloc_type
== 54; /* R_SPARC_UA64. */
12695 return reloc_type
== 1; /* R_X86_64_64. */
12698 return reloc_type
== 22; /* R_S390_64. */
12700 return reloc_type
== 1; /* R_TILEGX_64. */
12702 return reloc_type
== 18; /* R_MIPS_64. */
12708 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12709 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12712 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12714 switch (filedata
->file_header
.e_machine
)
12717 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12719 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12721 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12722 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12724 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12726 return reloc_type
== 44; /* R_PPC64_REL64. */
12727 case EM_SPARC32PLUS
:
12730 return reloc_type
== 46; /* R_SPARC_DISP64. */
12734 return reloc_type
== 24; /* R_X86_64_PC64. */
12737 return reloc_type
== 23; /* R_S390_PC64. */
12739 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12745 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12746 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12749 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12751 switch (filedata
->file_header
.e_machine
)
12753 case EM_CYGNUS_MN10200
:
12755 return reloc_type
== 4; /* R_MN10200_24. */
12757 return reloc_type
== 5; /* R_FT32_20. */
12763 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12764 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12767 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12769 /* Please keep this table alpha-sorted for ease of visual lookup. */
12770 switch (filedata
->file_header
.e_machine
)
12773 case EM_ARC_COMPACT
:
12774 case EM_ARC_COMPACT2
:
12775 return reloc_type
== 2; /* R_ARC_16. */
12776 case EM_ADAPTEVA_EPIPHANY
:
12777 return reloc_type
== 5;
12780 return reloc_type
== 4; /* R_AVR_16. */
12781 case EM_CYGNUS_D10V
:
12783 return reloc_type
== 3; /* R_D10V_16. */
12785 return reloc_type
== 2; /* R_FT32_16. */
12789 return reloc_type
== R_H8_DIR16
;
12792 return reloc_type
== 1; /* R_IP2K_16. */
12795 return reloc_type
== 1; /* R_M32C_16 */
12796 case EM_CYGNUS_MN10200
:
12798 return reloc_type
== 2; /* R_MN10200_16. */
12799 case EM_CYGNUS_MN10300
:
12801 return reloc_type
== 2; /* R_MN10300_16. */
12803 if (uses_msp430x_relocs (filedata
))
12804 return reloc_type
== 2; /* R_MSP430_ABS16. */
12805 /* Fall through. */
12806 case EM_MSP430_OLD
:
12807 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12809 return reloc_type
== 19; /* R_NDS32_RELA. */
12810 case EM_ALTERA_NIOS2
:
12811 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12813 return reloc_type
== 9; /* R_NIOS_16. */
12815 return reloc_type
== 2; /* R_OR1K_16. */
12817 return reloc_type
== 55; /* R_RISCV_SET16. */
12819 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12821 return reloc_type
== 2; /* R_C6000_ABS16. */
12823 return reloc_type
== 2; /* R_VISIUM_16. */
12826 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12828 return reloc_type
== 3; /* R_XGATE_16. */
12834 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12835 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12838 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12840 switch (filedata
->file_header
.e_machine
)
12843 return reloc_type
== 54; /* R_RISCV_SET8. */
12849 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12850 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12853 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12855 switch (filedata
->file_header
.e_machine
)
12858 return reloc_type
== 53; /* R_RISCV_SET6. */
12864 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12865 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12868 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12870 /* Please keep this table alpha-sorted for ease of visual lookup. */
12871 switch (filedata
->file_header
.e_machine
)
12874 return reloc_type
== 35; /* R_RISCV_ADD32. */
12880 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12881 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12884 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12886 /* Please keep this table alpha-sorted for ease of visual lookup. */
12887 switch (filedata
->file_header
.e_machine
)
12890 return reloc_type
== 39; /* R_RISCV_SUB32. */
12896 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12897 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12900 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12902 /* Please keep this table alpha-sorted for ease of visual lookup. */
12903 switch (filedata
->file_header
.e_machine
)
12906 return reloc_type
== 36; /* R_RISCV_ADD64. */
12912 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12913 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12916 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12918 /* Please keep this table alpha-sorted for ease of visual lookup. */
12919 switch (filedata
->file_header
.e_machine
)
12922 return reloc_type
== 40; /* R_RISCV_SUB64. */
12928 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12929 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12932 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12934 /* Please keep this table alpha-sorted for ease of visual lookup. */
12935 switch (filedata
->file_header
.e_machine
)
12938 return reloc_type
== 34; /* R_RISCV_ADD16. */
12944 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12945 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12948 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12950 /* Please keep this table alpha-sorted for ease of visual lookup. */
12951 switch (filedata
->file_header
.e_machine
)
12954 return reloc_type
== 38; /* R_RISCV_SUB16. */
12960 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12961 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12964 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12966 /* Please keep this table alpha-sorted for ease of visual lookup. */
12967 switch (filedata
->file_header
.e_machine
)
12970 return reloc_type
== 33; /* R_RISCV_ADD8. */
12976 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12977 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12980 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12982 /* Please keep this table alpha-sorted for ease of visual lookup. */
12983 switch (filedata
->file_header
.e_machine
)
12986 return reloc_type
== 37; /* R_RISCV_SUB8. */
12992 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12993 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12996 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12998 switch (filedata
->file_header
.e_machine
)
13001 return reloc_type
== 52; /* R_RISCV_SUB6. */
13007 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13008 relocation entries (possibly formerly used for SHT_GROUP sections). */
13011 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13013 switch (filedata
->file_header
.e_machine
)
13015 case EM_386
: /* R_386_NONE. */
13016 case EM_68K
: /* R_68K_NONE. */
13017 case EM_ADAPTEVA_EPIPHANY
:
13018 case EM_ALPHA
: /* R_ALPHA_NONE. */
13019 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13020 case EM_ARC
: /* R_ARC_NONE. */
13021 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13022 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13023 case EM_ARM
: /* R_ARM_NONE. */
13024 case EM_C166
: /* R_XC16X_NONE. */
13025 case EM_CRIS
: /* R_CRIS_NONE. */
13026 case EM_FT32
: /* R_FT32_NONE. */
13027 case EM_IA_64
: /* R_IA64_NONE. */
13028 case EM_K1OM
: /* R_X86_64_NONE. */
13029 case EM_L1OM
: /* R_X86_64_NONE. */
13030 case EM_M32R
: /* R_M32R_NONE. */
13031 case EM_MIPS
: /* R_MIPS_NONE. */
13032 case EM_MN10300
: /* R_MN10300_NONE. */
13033 case EM_MOXIE
: /* R_MOXIE_NONE. */
13034 case EM_NIOS32
: /* R_NIOS_NONE. */
13035 case EM_OR1K
: /* R_OR1K_NONE. */
13036 case EM_PARISC
: /* R_PARISC_NONE. */
13037 case EM_PPC64
: /* R_PPC64_NONE. */
13038 case EM_PPC
: /* R_PPC_NONE. */
13039 case EM_RISCV
: /* R_RISCV_NONE. */
13040 case EM_S390
: /* R_390_NONE. */
13042 case EM_SH
: /* R_SH_NONE. */
13043 case EM_SPARC32PLUS
:
13044 case EM_SPARC
: /* R_SPARC_NONE. */
13046 case EM_TILEGX
: /* R_TILEGX_NONE. */
13047 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13048 case EM_TI_C6000
:/* R_C6000_NONE. */
13049 case EM_X86_64
: /* R_X86_64_NONE. */
13051 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13052 return reloc_type
== 0;
13055 return reloc_type
== 0 || reloc_type
== 256;
13058 return (reloc_type
== 0 /* R_AVR_NONE. */
13059 || reloc_type
== 30 /* R_AVR_DIFF8. */
13060 || reloc_type
== 31 /* R_AVR_DIFF16. */
13061 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13063 return reloc_type
== 3; /* R_METAG_NONE. */
13065 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13066 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13067 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13068 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13069 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13071 return (reloc_type
== 0 /* R_PRU_NONE. */
13072 || reloc_type
== 65 /* R_PRU_DIFF8. */
13073 || reloc_type
== 66 /* R_PRU_DIFF16. */
13074 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13075 case EM_XTENSA_OLD
:
13077 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13078 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13079 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13080 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13085 /* Returns TRUE if there is a relocation against
13086 section NAME at OFFSET bytes. */
13089 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13091 Elf_Internal_Rela
* relocs
;
13092 Elf_Internal_Rela
* rp
;
13094 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13097 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13099 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13100 if (rp
->r_offset
== offset
)
13106 /* Apply relocations to a section.
13107 Returns TRUE upon success, FALSE otherwise.
13108 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13109 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13110 will be set to the number of relocs loaded.
13112 Note: So far support has been added only for those relocations
13113 which can be found in debug sections. FIXME: Add support for
13114 more relocations ? */
13117 apply_relocations (Filedata
* filedata
,
13118 const Elf_Internal_Shdr
* section
,
13119 unsigned char * start
,
13120 bfd_size_type size
,
13121 void ** relocs_return
,
13122 unsigned long * num_relocs_return
)
13124 Elf_Internal_Shdr
* relsec
;
13125 unsigned char * end
= start
+ size
;
13127 if (relocs_return
!= NULL
)
13129 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13130 * num_relocs_return
= 0;
13133 if (filedata
->file_header
.e_type
!= ET_REL
)
13134 /* No relocs to apply. */
13137 /* Find the reloc section associated with the section. */
13138 for (relsec
= filedata
->section_headers
;
13139 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13142 bfd_boolean is_rela
;
13143 unsigned long num_relocs
;
13144 Elf_Internal_Rela
* relocs
;
13145 Elf_Internal_Rela
* rp
;
13146 Elf_Internal_Shdr
* symsec
;
13147 Elf_Internal_Sym
* symtab
;
13148 unsigned long num_syms
;
13149 Elf_Internal_Sym
* sym
;
13151 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13152 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13153 || filedata
->section_headers
+ relsec
->sh_info
!= section
13154 || relsec
->sh_size
== 0
13155 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13158 is_rela
= relsec
->sh_type
== SHT_RELA
;
13162 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13163 relsec
->sh_size
, & relocs
, & num_relocs
))
13168 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13169 relsec
->sh_size
, & relocs
, & num_relocs
))
13173 /* SH uses RELA but uses in place value instead of the addend field. */
13174 if (filedata
->file_header
.e_machine
== EM_SH
)
13177 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13178 if (symsec
->sh_type
!= SHT_SYMTAB
13179 && symsec
->sh_type
!= SHT_DYNSYM
)
13181 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13183 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13186 unsigned int reloc_type
;
13187 unsigned int reloc_size
;
13188 bfd_boolean reloc_inplace
= FALSE
;
13189 bfd_boolean reloc_subtract
= FALSE
;
13190 unsigned char * rloc
;
13191 unsigned long sym_index
;
13193 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13195 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13197 else if (is_none_reloc (filedata
, reloc_type
))
13199 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13200 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13202 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13203 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13205 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13207 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13209 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13210 || is_6bit_abs_reloc (filedata
, reloc_type
))
13212 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13214 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13217 reloc_inplace
= TRUE
;
13219 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13221 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13224 reloc_inplace
= TRUE
;
13226 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13228 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13231 reloc_inplace
= TRUE
;
13233 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13235 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13238 reloc_inplace
= TRUE
;
13240 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13244 reloc_inplace
= TRUE
;
13248 static unsigned int prev_reloc
= 0;
13250 if (reloc_type
!= prev_reloc
)
13251 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13252 reloc_type
, printable_section_name (filedata
, section
));
13253 prev_reloc
= reloc_type
;
13257 rloc
= start
+ rp
->r_offset
;
13258 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
13260 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13261 (unsigned long) rp
->r_offset
,
13262 printable_section_name (filedata
, section
));
13266 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13267 if (sym_index
>= num_syms
)
13269 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13270 sym_index
, printable_section_name (filedata
, section
));
13273 sym
= symtab
+ sym_index
;
13275 /* If the reloc has a symbol associated with it,
13276 make sure that it is of an appropriate type.
13278 Relocations against symbols without type can happen.
13279 Gcc -feliminate-dwarf2-dups may generate symbols
13280 without type for debug info.
13282 Icc generates relocations against function symbols
13283 instead of local labels.
13285 Relocations against object symbols can happen, eg when
13286 referencing a global array. For an example of this see
13287 the _clz.o binary in libgcc.a. */
13289 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13290 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13292 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13293 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13294 printable_section_name (filedata
, relsec
),
13295 (long int)(rp
- relocs
));
13301 addend
+= rp
->r_addend
;
13302 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13303 partial_inplace. */
13305 || (filedata
->file_header
.e_machine
== EM_XTENSA
13306 && reloc_type
== 1)
13307 || ((filedata
->file_header
.e_machine
== EM_PJ
13308 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13309 && reloc_type
== 1)
13310 || ((filedata
->file_header
.e_machine
== EM_D30V
13311 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13312 && reloc_type
== 12)
13315 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13316 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13318 addend
+= byte_get (rloc
, reloc_size
);
13321 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13322 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13324 /* On HPPA, all pc-relative relocations are biased by 8. */
13325 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13327 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13330 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13331 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13333 if (reloc_subtract
)
13334 addend
-= sym
->st_value
;
13336 addend
+= sym
->st_value
;
13337 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13338 byte_put (rloc
, addend
, reloc_size
);
13340 else if (reloc_subtract
)
13341 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13343 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13347 /* Let the target specific reloc processing code know that
13348 we have finished with these relocs. */
13349 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13353 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13354 * num_relocs_return
= num_relocs
;
13365 #ifdef SUPPORT_DISASSEMBLY
13367 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13369 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13371 /* FIXME: XXX -- to be done --- XXX */
13377 /* Reads in the contents of SECTION from FILE, returning a pointer
13378 to a malloc'ed buffer or NULL if something went wrong. */
13381 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13383 bfd_size_type num_bytes
= section
->sh_size
;
13385 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13387 printf (_("Section '%s' has no data to dump.\n"),
13388 printable_section_name (filedata
, section
));
13392 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13393 _("section contents"));
13396 /* Uncompresses a section that was compressed using zlib, in place. */
13399 uncompress_section_contents (unsigned char ** buffer
,
13400 dwarf_size_type uncompressed_size
,
13401 dwarf_size_type
* size
)
13403 dwarf_size_type compressed_size
= *size
;
13404 unsigned char * compressed_buffer
= *buffer
;
13405 unsigned char * uncompressed_buffer
;
13409 /* It is possible the section consists of several compressed
13410 buffers concatenated together, so we uncompress in a loop. */
13411 /* PR 18313: The state field in the z_stream structure is supposed
13412 to be invisible to the user (ie us), but some compilers will
13413 still complain about it being used without initialisation. So
13414 we first zero the entire z_stream structure and then set the fields
13416 memset (& strm
, 0, sizeof strm
);
13417 strm
.avail_in
= compressed_size
;
13418 strm
.next_in
= (Bytef
*) compressed_buffer
;
13419 strm
.avail_out
= uncompressed_size
;
13420 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13422 rc
= inflateInit (& strm
);
13423 while (strm
.avail_in
> 0)
13427 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13428 + (uncompressed_size
- strm
.avail_out
));
13429 rc
= inflate (&strm
, Z_FINISH
);
13430 if (rc
!= Z_STREAM_END
)
13432 rc
= inflateReset (& strm
);
13434 rc
= inflateEnd (& strm
);
13436 || strm
.avail_out
!= 0)
13439 *buffer
= uncompressed_buffer
;
13440 *size
= uncompressed_size
;
13444 free (uncompressed_buffer
);
13445 /* Indicate decompression failure. */
13451 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13453 Elf_Internal_Shdr
* relsec
;
13454 bfd_size_type num_bytes
;
13455 unsigned char * data
;
13456 unsigned char * end
;
13457 unsigned char * real_start
;
13458 unsigned char * start
;
13459 bfd_boolean some_strings_shown
;
13461 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13463 /* PR 21820: Do not fail if the section was empty. */
13464 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13466 num_bytes
= section
->sh_size
;
13468 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13470 if (decompress_dumps
)
13472 dwarf_size_type new_size
= num_bytes
;
13473 dwarf_size_type uncompressed_size
= 0;
13475 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13477 Elf_Internal_Chdr chdr
;
13478 unsigned int compression_header_size
13479 = get_compression_header (& chdr
, (unsigned char *) start
,
13482 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13484 warn (_("section '%s' has unsupported compress type: %d\n"),
13485 printable_section_name (filedata
, section
), chdr
.ch_type
);
13488 uncompressed_size
= chdr
.ch_size
;
13489 start
+= compression_header_size
;
13490 new_size
-= compression_header_size
;
13492 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13494 /* Read the zlib header. In this case, it should be "ZLIB"
13495 followed by the uncompressed section size, 8 bytes in
13496 big-endian order. */
13497 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13498 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13499 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13500 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13501 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13502 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13503 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13504 uncompressed_size
+= start
[11];
13509 if (uncompressed_size
)
13511 if (uncompress_section_contents (& start
,
13512 uncompressed_size
, & new_size
))
13513 num_bytes
= new_size
;
13516 error (_("Unable to decompress section %s\n"),
13517 printable_section_name (filedata
, section
));
13522 start
= real_start
;
13525 /* If the section being dumped has relocations against it the user might
13526 be expecting these relocations to have been applied. Check for this
13527 case and issue a warning message in order to avoid confusion.
13528 FIXME: Maybe we ought to have an option that dumps a section with
13529 relocs applied ? */
13530 for (relsec
= filedata
->section_headers
;
13531 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13534 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13535 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13536 || filedata
->section_headers
+ relsec
->sh_info
!= section
13537 || relsec
->sh_size
== 0
13538 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13541 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13546 end
= start
+ num_bytes
;
13547 some_strings_shown
= FALSE
;
13551 while (!ISPRINT (* data
))
13552 if (++ data
>= end
)
13557 size_t maxlen
= end
- data
;
13560 /* PR 11128: Use two separate invocations in order to work
13561 around bugs in the Solaris 8 implementation of printf. */
13562 printf (" [%6tx] ", data
- start
);
13564 printf (" [%6Ix] ", (size_t) (data
- start
));
13568 print_symbol ((int) maxlen
, (const char *) data
);
13570 data
+= strnlen ((const char *) data
, maxlen
);
13574 printf (_("<corrupt>\n"));
13577 some_strings_shown
= TRUE
;
13581 if (! some_strings_shown
)
13582 printf (_(" No strings found in this section."));
13591 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13592 Filedata
* filedata
,
13593 bfd_boolean relocate
)
13595 Elf_Internal_Shdr
* relsec
;
13596 bfd_size_type bytes
;
13597 bfd_size_type section_size
;
13599 unsigned char * data
;
13600 unsigned char * real_start
;
13601 unsigned char * start
;
13603 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13605 /* PR 21820: Do not fail if the section was empty. */
13606 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13608 section_size
= section
->sh_size
;
13610 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13612 if (decompress_dumps
)
13614 dwarf_size_type new_size
= section_size
;
13615 dwarf_size_type uncompressed_size
= 0;
13617 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13619 Elf_Internal_Chdr chdr
;
13620 unsigned int compression_header_size
13621 = get_compression_header (& chdr
, start
, section_size
);
13623 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13625 warn (_("section '%s' has unsupported compress type: %d\n"),
13626 printable_section_name (filedata
, section
), chdr
.ch_type
);
13629 uncompressed_size
= chdr
.ch_size
;
13630 start
+= compression_header_size
;
13631 new_size
-= compression_header_size
;
13633 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13635 /* Read the zlib header. In this case, it should be "ZLIB"
13636 followed by the uncompressed section size, 8 bytes in
13637 big-endian order. */
13638 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13639 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13640 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13641 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13642 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13643 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13644 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13645 uncompressed_size
+= start
[11];
13650 if (uncompressed_size
)
13652 if (uncompress_section_contents (& start
, uncompressed_size
,
13655 section_size
= new_size
;
13659 error (_("Unable to decompress section %s\n"),
13660 printable_section_name (filedata
, section
));
13661 /* FIXME: Print the section anyway ? */
13666 start
= real_start
;
13671 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13676 /* If the section being dumped has relocations against it the user might
13677 be expecting these relocations to have been applied. Check for this
13678 case and issue a warning message in order to avoid confusion.
13679 FIXME: Maybe we ought to have an option that dumps a section with
13680 relocs applied ? */
13681 for (relsec
= filedata
->section_headers
;
13682 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13685 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13686 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13687 || filedata
->section_headers
+ relsec
->sh_info
!= section
13688 || relsec
->sh_size
== 0
13689 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13692 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13697 addr
= section
->sh_addr
;
13698 bytes
= section_size
;
13707 lbytes
= (bytes
> 16 ? 16 : bytes
);
13709 printf (" 0x%8.8lx ", (unsigned long) addr
);
13711 for (j
= 0; j
< 16; j
++)
13714 printf ("%2.2x", data
[j
]);
13722 for (j
= 0; j
< lbytes
; j
++)
13725 if (k
>= ' ' && k
< 0x7f)
13745 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13746 const Elf_Internal_Shdr
* sec
,
13749 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13751 Filedata
* filedata
= (Filedata
*) data
;
13753 if (section
->start
!= NULL
)
13755 /* If it is already loaded, do nothing. */
13756 if (streq (section
->filename
, filedata
->file_name
))
13758 free (section
->start
);
13761 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13762 section
->address
= sec
->sh_addr
;
13763 section
->user_data
= NULL
;
13764 section
->filename
= filedata
->file_name
;
13765 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13767 sec
->sh_size
, buf
);
13768 if (section
->start
== NULL
)
13772 unsigned char *start
= section
->start
;
13773 dwarf_size_type size
= sec
->sh_size
;
13774 dwarf_size_type uncompressed_size
= 0;
13776 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13778 Elf_Internal_Chdr chdr
;
13779 unsigned int compression_header_size
;
13781 if (size
< (is_32bit_elf
13782 ? sizeof (Elf32_External_Chdr
)
13783 : sizeof (Elf64_External_Chdr
)))
13785 warn (_("compressed section %s is too small to contain a compression header"),
13790 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13792 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13794 warn (_("section '%s' has unsupported compress type: %d\n"),
13795 section
->name
, chdr
.ch_type
);
13798 uncompressed_size
= chdr
.ch_size
;
13799 start
+= compression_header_size
;
13800 size
-= compression_header_size
;
13802 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13804 /* Read the zlib header. In this case, it should be "ZLIB"
13805 followed by the uncompressed section size, 8 bytes in
13806 big-endian order. */
13807 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13808 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13809 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13810 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13811 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13812 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13813 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13814 uncompressed_size
+= start
[11];
13819 if (uncompressed_size
)
13821 if (uncompress_section_contents (&start
, uncompressed_size
,
13824 /* Free the compressed buffer, update the section buffer
13825 and the section size if uncompress is successful. */
13826 free (section
->start
);
13827 section
->start
= start
;
13831 error (_("Unable to decompress section %s\n"),
13832 printable_section_name (filedata
, sec
));
13837 section
->size
= size
;
13840 if (section
->start
== NULL
)
13843 if (debug_displays
[debug
].relocate
)
13845 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13846 & section
->reloc_info
, & section
->num_relocs
))
13851 section
->reloc_info
= NULL
;
13852 section
->num_relocs
= 0;
13858 /* If this is not NULL, load_debug_section will only look for sections
13859 within the list of sections given here. */
13860 static unsigned int * section_subset
= NULL
;
13863 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13865 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13866 Elf_Internal_Shdr
* sec
;
13867 Filedata
* filedata
= (Filedata
*) data
;
13869 /* Without section headers we cannot find any sections. */
13870 if (filedata
->section_headers
== NULL
)
13873 if (filedata
->string_table
== NULL
13874 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13875 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13877 Elf_Internal_Shdr
* strs
;
13879 /* Read in the string table, so that we have section names to scan. */
13880 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13882 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13884 filedata
->string_table
13885 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13886 1, strs
->sh_size
, _("string table"));
13888 filedata
->string_table_length
13889 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13893 /* Locate the debug section. */
13894 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13896 section
->name
= section
->uncompressed_name
;
13899 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13901 section
->name
= section
->compressed_name
;
13906 /* If we're loading from a subset of sections, and we've loaded
13907 a section matching this name before, it's likely that it's a
13909 if (section_subset
!= NULL
)
13910 free_debug_section (debug
);
13912 return load_specific_debug_section (debug
, sec
, data
);
13916 free_debug_section (enum dwarf_section_display_enum debug
)
13918 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13920 if (section
->start
== NULL
)
13923 free ((char *) section
->start
);
13924 section
->start
= NULL
;
13925 section
->address
= 0;
13930 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13932 char * name
= SECTION_NAME (section
);
13933 const char * print_name
= printable_section_name (filedata
, section
);
13934 bfd_size_type length
;
13935 bfd_boolean result
= TRUE
;
13938 length
= section
->sh_size
;
13941 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13944 if (section
->sh_type
== SHT_NOBITS
)
13946 /* There is no point in dumping the contents of a debugging section
13947 which has the NOBITS type - the bits in the file will be random.
13948 This can happen when a file containing a .eh_frame section is
13949 stripped with the --only-keep-debug command line option. */
13950 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13955 if (const_strneq (name
, ".gnu.linkonce.wi."))
13956 name
= ".debug_info";
13958 /* See if we know how to display the contents of this section. */
13959 for (i
= 0; i
< max
; i
++)
13961 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13962 struct dwarf_section_display
* display
= debug_displays
+ i
;
13963 struct dwarf_section
* sec
= & display
->section
;
13965 if (streq (sec
->uncompressed_name
, name
)
13966 || (id
== line
&& const_strneq (name
, ".debug_line."))
13967 || streq (sec
->compressed_name
, name
))
13969 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13972 free_debug_section (id
);
13974 if (i
== line
&& const_strneq (name
, ".debug_line."))
13976 else if (streq (sec
->uncompressed_name
, name
))
13977 sec
->name
= sec
->uncompressed_name
;
13979 sec
->name
= sec
->compressed_name
;
13981 if (load_specific_debug_section (id
, section
, filedata
))
13983 /* If this debug section is part of a CU/TU set in a .dwp file,
13984 restrict load_debug_section to the sections in that set. */
13985 section_subset
= find_cu_tu_set (filedata
, shndx
);
13987 result
&= display
->display (sec
, filedata
);
13989 section_subset
= NULL
;
13991 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13992 free_debug_section (id
);
14000 printf (_("Unrecognized debug section: %s\n"), print_name
);
14007 /* Set DUMP_SECTS for all sections where dumps were requested
14008 based on section name. */
14011 initialise_dumps_byname (Filedata
* filedata
)
14013 struct dump_list_entry
* cur
;
14015 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14018 bfd_boolean any
= FALSE
;
14020 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14021 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14023 request_dump_bynumber (filedata
, i
, cur
->type
);
14028 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14034 process_section_contents (Filedata
* filedata
)
14036 Elf_Internal_Shdr
* section
;
14038 bfd_boolean res
= TRUE
;
14043 initialise_dumps_byname (filedata
);
14045 for (i
= 0, section
= filedata
->section_headers
;
14046 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14049 dump_type dump
= filedata
->dump_sects
[i
];
14051 #ifdef SUPPORT_DISASSEMBLY
14052 if (dump
& DISASS_DUMP
)
14054 if (! disassemble_section (section
, filedata
))
14058 if (dump
& HEX_DUMP
)
14060 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14064 if (dump
& RELOC_DUMP
)
14066 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14070 if (dump
& STRING_DUMP
)
14072 if (! dump_section_as_strings (section
, filedata
))
14076 if (dump
& DEBUG_DUMP
)
14078 if (! display_debug_section (i
, section
, filedata
))
14083 /* Check to see if the user requested a
14084 dump of a section that does not exist. */
14085 while (i
< filedata
->num_dump_sects
)
14087 if (filedata
->dump_sects
[i
])
14089 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14099 process_mips_fpe_exception (int mask
)
14103 bfd_boolean first
= TRUE
;
14105 if (mask
& OEX_FPU_INEX
)
14106 fputs ("INEX", stdout
), first
= FALSE
;
14107 if (mask
& OEX_FPU_UFLO
)
14108 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14109 if (mask
& OEX_FPU_OFLO
)
14110 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14111 if (mask
& OEX_FPU_DIV0
)
14112 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14113 if (mask
& OEX_FPU_INVAL
)
14114 printf ("%sINVAL", first
? "" : "|");
14117 fputs ("0", stdout
);
14120 /* Display's the value of TAG at location P. If TAG is
14121 greater than 0 it is assumed to be an unknown tag, and
14122 a message is printed to this effect. Otherwise it is
14123 assumed that a message has already been printed.
14125 If the bottom bit of TAG is set it assumed to have a
14126 string value, otherwise it is assumed to have an integer
14129 Returns an updated P pointing to the first unread byte
14130 beyond the end of TAG's value.
14132 Reads at or beyond END will not be made. */
14134 static unsigned char *
14135 display_tag_value (signed int tag
,
14137 const unsigned char * const end
)
14142 printf (" Tag_unknown_%d: ", tag
);
14146 warn (_("<corrupt tag>\n"));
14150 /* PR 17531 file: 027-19978-0.004. */
14151 size_t maxlen
= (end
- p
) - 1;
14156 print_symbol ((int) maxlen
, (const char *) p
);
14157 p
+= strnlen ((char *) p
, maxlen
) + 1;
14161 printf (_("<corrupt string tag>"));
14162 p
= (unsigned char *) end
;
14170 val
= read_uleb128 (p
, &len
, end
);
14172 printf ("%ld (0x%lx)\n", val
, val
);
14179 /* ARC ABI attributes section. */
14181 static unsigned char *
14182 display_arc_attribute (unsigned char * p
,
14183 const unsigned char * const end
)
14189 tag
= read_uleb128 (p
, &len
, end
);
14194 case Tag_ARC_PCS_config
:
14195 val
= read_uleb128 (p
, &len
, end
);
14197 printf (" Tag_ARC_PCS_config: ");
14201 printf (_("Absent/Non standard\n"));
14204 printf (_("Bare metal/mwdt\n"));
14207 printf (_("Bare metal/newlib\n"));
14210 printf (_("Linux/uclibc\n"));
14213 printf (_("Linux/glibc\n"));
14216 printf (_("Unknown\n"));
14221 case Tag_ARC_CPU_base
:
14222 val
= read_uleb128 (p
, &len
, end
);
14224 printf (" Tag_ARC_CPU_base: ");
14229 printf (_("Absent\n"));
14231 case TAG_CPU_ARC6xx
:
14232 printf ("ARC6xx\n");
14234 case TAG_CPU_ARC7xx
:
14235 printf ("ARC7xx\n");
14237 case TAG_CPU_ARCEM
:
14238 printf ("ARCEM\n");
14240 case TAG_CPU_ARCHS
:
14241 printf ("ARCHS\n");
14246 case Tag_ARC_CPU_variation
:
14247 val
= read_uleb128 (p
, &len
, end
);
14249 printf (" Tag_ARC_CPU_variation: ");
14253 if (val
> 0 && val
< 16)
14254 printf ("Core%d\n", val
);
14256 printf ("Unknown\n");
14260 printf (_("Absent\n"));
14265 case Tag_ARC_CPU_name
:
14266 printf (" Tag_ARC_CPU_name: ");
14267 p
= display_tag_value (-1, p
, end
);
14270 case Tag_ARC_ABI_rf16
:
14271 val
= read_uleb128 (p
, &len
, end
);
14273 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14276 case Tag_ARC_ABI_osver
:
14277 val
= read_uleb128 (p
, &len
, end
);
14279 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14282 case Tag_ARC_ABI_pic
:
14283 case Tag_ARC_ABI_sda
:
14284 val
= read_uleb128 (p
, &len
, end
);
14286 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14287 : " Tag_ARC_ABI_pic: ");
14291 printf (_("Absent\n"));
14300 printf (_("Unknown\n"));
14305 case Tag_ARC_ABI_tls
:
14306 val
= read_uleb128 (p
, &len
, end
);
14308 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14311 case Tag_ARC_ABI_enumsize
:
14312 val
= read_uleb128 (p
, &len
, end
);
14314 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14318 case Tag_ARC_ABI_exceptions
:
14319 val
= read_uleb128 (p
, &len
, end
);
14321 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14325 case Tag_ARC_ABI_double_size
:
14326 val
= read_uleb128 (p
, &len
, end
);
14328 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14331 case Tag_ARC_ISA_config
:
14332 printf (" Tag_ARC_ISA_config: ");
14333 p
= display_tag_value (-1, p
, end
);
14336 case Tag_ARC_ISA_apex
:
14337 printf (" Tag_ARC_ISA_apex: ");
14338 p
= display_tag_value (-1, p
, end
);
14341 case Tag_ARC_ISA_mpy_option
:
14342 val
= read_uleb128 (p
, &len
, end
);
14344 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14347 case Tag_ARC_ATR_version
:
14348 val
= read_uleb128 (p
, &len
, end
);
14350 printf (" Tag_ARC_ATR_version: %d\n", val
);
14354 return display_tag_value (tag
& 1, p
, end
);
14360 /* ARM EABI attributes section. */
14365 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14367 const char ** table
;
14368 } arm_attr_public_tag
;
14370 static const char * arm_attr_tag_CPU_arch
[] =
14371 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14372 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14374 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14375 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14376 {"No", "Thumb-1", "Thumb-2", "Yes"};
14377 static const char * arm_attr_tag_FP_arch
[] =
14378 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14379 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14380 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14381 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14382 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14383 "NEON for ARMv8.1"};
14384 static const char * arm_attr_tag_PCS_config
[] =
14385 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14386 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14387 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14388 {"V6", "SB", "TLS", "Unused"};
14389 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14390 {"Absolute", "PC-relative", "SB-relative", "None"};
14391 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14392 {"Absolute", "PC-relative", "None"};
14393 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14394 {"None", "direct", "GOT-indirect"};
14395 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14396 {"None", "??? 1", "2", "??? 3", "4"};
14397 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14398 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14399 {"Unused", "Needed", "Sign only"};
14400 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14401 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14402 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14403 {"Unused", "Finite", "RTABI", "IEEE 754"};
14404 static const char * arm_attr_tag_ABI_enum_size
[] =
14405 {"Unused", "small", "int", "forced to int"};
14406 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14407 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14408 static const char * arm_attr_tag_ABI_VFP_args
[] =
14409 {"AAPCS", "VFP registers", "custom", "compatible"};
14410 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14411 {"AAPCS", "WMMX registers", "custom"};
14412 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14413 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14414 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14415 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14416 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14417 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14418 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14419 static const char * arm_attr_tag_FP_HP_extension
[] =
14420 {"Not Allowed", "Allowed"};
14421 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14422 {"None", "IEEE 754", "Alternative Format"};
14423 static const char * arm_attr_tag_DSP_extension
[] =
14424 {"Follow architecture", "Allowed"};
14425 static const char * arm_attr_tag_MPextension_use
[] =
14426 {"Not Allowed", "Allowed"};
14427 static const char * arm_attr_tag_DIV_use
[] =
14428 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14429 "Allowed in v7-A with integer division extension"};
14430 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14431 static const char * arm_attr_tag_Virtualization_use
[] =
14432 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14433 "TrustZone and Virtualization Extensions"};
14434 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14435 {"Not Allowed", "Allowed"};
14437 #define LOOKUP(id, name) \
14438 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14439 static arm_attr_public_tag arm_attr_public_tags
[] =
14441 {4, "CPU_raw_name", 1, NULL
},
14442 {5, "CPU_name", 1, NULL
},
14443 LOOKUP(6, CPU_arch
),
14444 {7, "CPU_arch_profile", 0, NULL
},
14445 LOOKUP(8, ARM_ISA_use
),
14446 LOOKUP(9, THUMB_ISA_use
),
14447 LOOKUP(10, FP_arch
),
14448 LOOKUP(11, WMMX_arch
),
14449 LOOKUP(12, Advanced_SIMD_arch
),
14450 LOOKUP(13, PCS_config
),
14451 LOOKUP(14, ABI_PCS_R9_use
),
14452 LOOKUP(15, ABI_PCS_RW_data
),
14453 LOOKUP(16, ABI_PCS_RO_data
),
14454 LOOKUP(17, ABI_PCS_GOT_use
),
14455 LOOKUP(18, ABI_PCS_wchar_t
),
14456 LOOKUP(19, ABI_FP_rounding
),
14457 LOOKUP(20, ABI_FP_denormal
),
14458 LOOKUP(21, ABI_FP_exceptions
),
14459 LOOKUP(22, ABI_FP_user_exceptions
),
14460 LOOKUP(23, ABI_FP_number_model
),
14461 {24, "ABI_align_needed", 0, NULL
},
14462 {25, "ABI_align_preserved", 0, NULL
},
14463 LOOKUP(26, ABI_enum_size
),
14464 LOOKUP(27, ABI_HardFP_use
),
14465 LOOKUP(28, ABI_VFP_args
),
14466 LOOKUP(29, ABI_WMMX_args
),
14467 LOOKUP(30, ABI_optimization_goals
),
14468 LOOKUP(31, ABI_FP_optimization_goals
),
14469 {32, "compatibility", 0, NULL
},
14470 LOOKUP(34, CPU_unaligned_access
),
14471 LOOKUP(36, FP_HP_extension
),
14472 LOOKUP(38, ABI_FP_16bit_format
),
14473 LOOKUP(42, MPextension_use
),
14474 LOOKUP(44, DIV_use
),
14475 LOOKUP(46, DSP_extension
),
14476 {64, "nodefaults", 0, NULL
},
14477 {65, "also_compatible_with", 0, NULL
},
14478 LOOKUP(66, T2EE_use
),
14479 {67, "conformance", 1, NULL
},
14480 LOOKUP(68, Virtualization_use
),
14481 LOOKUP(70, MPextension_use_legacy
)
14485 static unsigned char *
14486 display_arm_attribute (unsigned char * p
,
14487 const unsigned char * const end
)
14492 arm_attr_public_tag
* attr
;
14496 tag
= read_uleb128 (p
, &len
, end
);
14499 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14501 if (arm_attr_public_tags
[i
].tag
== tag
)
14503 attr
= &arm_attr_public_tags
[i
];
14510 printf (" Tag_%s: ", attr
->name
);
14511 switch (attr
->type
)
14516 case 7: /* Tag_CPU_arch_profile. */
14517 val
= read_uleb128 (p
, &len
, end
);
14521 case 0: printf (_("None\n")); break;
14522 case 'A': printf (_("Application\n")); break;
14523 case 'R': printf (_("Realtime\n")); break;
14524 case 'M': printf (_("Microcontroller\n")); break;
14525 case 'S': printf (_("Application or Realtime\n")); break;
14526 default: printf ("??? (%d)\n", val
); break;
14530 case 24: /* Tag_align_needed. */
14531 val
= read_uleb128 (p
, &len
, end
);
14535 case 0: printf (_("None\n")); break;
14536 case 1: printf (_("8-byte\n")); break;
14537 case 2: printf (_("4-byte\n")); break;
14538 case 3: printf ("??? 3\n"); break;
14541 printf (_("8-byte and up to %d-byte extended\n"),
14544 printf ("??? (%d)\n", val
);
14549 case 25: /* Tag_align_preserved. */
14550 val
= read_uleb128 (p
, &len
, end
);
14554 case 0: printf (_("None\n")); break;
14555 case 1: printf (_("8-byte, except leaf SP\n")); break;
14556 case 2: printf (_("8-byte\n")); break;
14557 case 3: printf ("??? 3\n"); break;
14560 printf (_("8-byte and up to %d-byte extended\n"),
14563 printf ("??? (%d)\n", val
);
14568 case 32: /* Tag_compatibility. */
14570 val
= read_uleb128 (p
, &len
, end
);
14572 printf (_("flag = %d, vendor = "), val
);
14575 size_t maxlen
= (end
- p
) - 1;
14577 print_symbol ((int) maxlen
, (const char *) p
);
14578 p
+= strnlen ((char *) p
, maxlen
) + 1;
14582 printf (_("<corrupt>"));
14583 p
= (unsigned char *) end
;
14589 case 64: /* Tag_nodefaults. */
14590 /* PR 17531: file: 001-505008-0.01. */
14593 printf (_("True\n"));
14596 case 65: /* Tag_also_compatible_with. */
14597 val
= read_uleb128 (p
, &len
, end
);
14599 if (val
== 6 /* Tag_CPU_arch. */)
14601 val
= read_uleb128 (p
, &len
, end
);
14603 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14604 printf ("??? (%d)\n", val
);
14606 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14610 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14615 printf (_("<unknown: %d>\n"), tag
);
14621 return display_tag_value (-1, p
, end
);
14623 return display_tag_value (0, p
, end
);
14626 assert (attr
->type
& 0x80);
14627 val
= read_uleb128 (p
, &len
, end
);
14629 type
= attr
->type
& 0x7f;
14631 printf ("??? (%d)\n", val
);
14633 printf ("%s\n", attr
->table
[val
]);
14638 return display_tag_value (tag
, p
, end
);
14641 static unsigned char *
14642 display_gnu_attribute (unsigned char * p
,
14643 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14644 const unsigned char * const end
)
14650 tag
= read_uleb128 (p
, &len
, end
);
14653 /* Tag_compatibility is the only generic GNU attribute defined at
14657 val
= read_uleb128 (p
, &len
, end
);
14660 printf (_("flag = %d, vendor = "), val
);
14663 printf (_("<corrupt>\n"));
14664 warn (_("corrupt vendor attribute\n"));
14670 size_t maxlen
= (end
- p
) - 1;
14672 print_symbol ((int) maxlen
, (const char *) p
);
14673 p
+= strnlen ((char *) p
, maxlen
) + 1;
14677 printf (_("<corrupt>"));
14678 p
= (unsigned char *) end
;
14685 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14686 return display_proc_gnu_attribute (p
, tag
, end
);
14688 return display_tag_value (tag
, p
, end
);
14691 static unsigned char *
14692 display_power_gnu_attribute (unsigned char * p
,
14694 const unsigned char * const end
)
14699 if (tag
== Tag_GNU_Power_ABI_FP
)
14701 val
= read_uleb128 (p
, &len
, end
);
14703 printf (" Tag_GNU_Power_ABI_FP: ");
14706 printf (_("<corrupt>\n"));
14711 printf ("(%#x), ", val
);
14716 printf (_("unspecified hard/soft float, "));
14719 printf (_("hard float, "));
14722 printf (_("soft float, "));
14725 printf (_("single-precision hard float, "));
14732 printf (_("unspecified long double\n"));
14735 printf (_("128-bit IBM long double\n"));
14738 printf (_("64-bit long double\n"));
14741 printf (_("128-bit IEEE long double\n"));
14747 if (tag
== Tag_GNU_Power_ABI_Vector
)
14749 val
= read_uleb128 (p
, &len
, end
);
14751 printf (" Tag_GNU_Power_ABI_Vector: ");
14754 printf (_("<corrupt>\n"));
14759 printf ("(%#x), ", val
);
14764 printf (_("unspecified\n"));
14767 printf (_("generic\n"));
14770 printf ("AltiVec\n");
14779 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14781 val
= read_uleb128 (p
, &len
, end
);
14783 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14786 printf (_("<corrupt>\n"));
14791 printf ("(%#x), ", val
);
14796 printf (_("unspecified\n"));
14799 printf ("r3/r4\n");
14802 printf (_("memory\n"));
14811 return display_tag_value (tag
& 1, p
, end
);
14814 static unsigned char *
14815 display_s390_gnu_attribute (unsigned char * p
,
14817 const unsigned char * const end
)
14822 if (tag
== Tag_GNU_S390_ABI_Vector
)
14824 val
= read_uleb128 (p
, &len
, end
);
14826 printf (" Tag_GNU_S390_ABI_Vector: ");
14831 printf (_("any\n"));
14834 printf (_("software\n"));
14837 printf (_("hardware\n"));
14840 printf ("??? (%d)\n", val
);
14846 return display_tag_value (tag
& 1, p
, end
);
14850 display_sparc_hwcaps (unsigned int mask
)
14854 bfd_boolean first
= TRUE
;
14856 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14857 fputs ("mul32", stdout
), first
= FALSE
;
14858 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14859 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14860 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14861 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14862 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14863 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14864 if (mask
& ELF_SPARC_HWCAP_POPC
)
14865 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14866 if (mask
& ELF_SPARC_HWCAP_VIS
)
14867 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14868 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14869 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14870 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14871 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14872 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14873 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14874 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14875 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14876 if (mask
& ELF_SPARC_HWCAP_HPC
)
14877 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14878 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14879 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14880 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14881 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14882 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14883 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14884 if (mask
& ELF_SPARC_HWCAP_IMA
)
14885 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14886 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14887 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14890 fputc ('0', stdout
);
14891 fputc ('\n', stdout
);
14895 display_sparc_hwcaps2 (unsigned int mask
)
14899 bfd_boolean first
= TRUE
;
14901 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14902 fputs ("fjathplus", stdout
), first
= FALSE
;
14903 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14904 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14905 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14906 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14907 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14908 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14909 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14910 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14911 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14912 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14913 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14914 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14915 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14916 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14917 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14918 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14919 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14920 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14921 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14922 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14925 fputc ('0', stdout
);
14926 fputc ('\n', stdout
);
14929 static unsigned char *
14930 display_sparc_gnu_attribute (unsigned char * p
,
14932 const unsigned char * const end
)
14937 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14939 val
= read_uleb128 (p
, &len
, end
);
14941 printf (" Tag_GNU_Sparc_HWCAPS: ");
14942 display_sparc_hwcaps (val
);
14945 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14947 val
= read_uleb128 (p
, &len
, end
);
14949 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14950 display_sparc_hwcaps2 (val
);
14954 return display_tag_value (tag
, p
, end
);
14958 print_mips_fp_abi_value (unsigned int val
)
14962 case Val_GNU_MIPS_ABI_FP_ANY
:
14963 printf (_("Hard or soft float\n"));
14965 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14966 printf (_("Hard float (double precision)\n"));
14968 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14969 printf (_("Hard float (single precision)\n"));
14971 case Val_GNU_MIPS_ABI_FP_SOFT
:
14972 printf (_("Soft float\n"));
14974 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14975 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14977 case Val_GNU_MIPS_ABI_FP_XX
:
14978 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14980 case Val_GNU_MIPS_ABI_FP_64
:
14981 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14983 case Val_GNU_MIPS_ABI_FP_64A
:
14984 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14986 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14987 printf (_("NaN 2008 compatibility\n"));
14990 printf ("??? (%d)\n", val
);
14995 static unsigned char *
14996 display_mips_gnu_attribute (unsigned char * p
,
14998 const unsigned char * const end
)
15000 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15005 val
= read_uleb128 (p
, &len
, end
);
15007 printf (" Tag_GNU_MIPS_ABI_FP: ");
15009 print_mips_fp_abi_value (val
);
15014 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15019 val
= read_uleb128 (p
, &len
, end
);
15021 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15025 case Val_GNU_MIPS_ABI_MSA_ANY
:
15026 printf (_("Any MSA or not\n"));
15028 case Val_GNU_MIPS_ABI_MSA_128
:
15029 printf (_("128-bit MSA\n"));
15032 printf ("??? (%d)\n", val
);
15038 return display_tag_value (tag
& 1, p
, end
);
15041 static unsigned char *
15042 display_tic6x_attribute (unsigned char * p
,
15043 const unsigned char * const end
)
15049 tag
= read_uleb128 (p
, &len
, end
);
15055 val
= read_uleb128 (p
, &len
, end
);
15057 printf (" Tag_ISA: ");
15061 case C6XABI_Tag_ISA_none
:
15062 printf (_("None\n"));
15064 case C6XABI_Tag_ISA_C62X
:
15067 case C6XABI_Tag_ISA_C67X
:
15070 case C6XABI_Tag_ISA_C67XP
:
15071 printf ("C67x+\n");
15073 case C6XABI_Tag_ISA_C64X
:
15076 case C6XABI_Tag_ISA_C64XP
:
15077 printf ("C64x+\n");
15079 case C6XABI_Tag_ISA_C674X
:
15080 printf ("C674x\n");
15083 printf ("??? (%d)\n", val
);
15088 case Tag_ABI_wchar_t
:
15089 val
= read_uleb128 (p
, &len
, end
);
15091 printf (" Tag_ABI_wchar_t: ");
15095 printf (_("Not used\n"));
15098 printf (_("2 bytes\n"));
15101 printf (_("4 bytes\n"));
15104 printf ("??? (%d)\n", val
);
15109 case Tag_ABI_stack_align_needed
:
15110 val
= read_uleb128 (p
, &len
, end
);
15112 printf (" Tag_ABI_stack_align_needed: ");
15116 printf (_("8-byte\n"));
15119 printf (_("16-byte\n"));
15122 printf ("??? (%d)\n", val
);
15127 case Tag_ABI_stack_align_preserved
:
15128 val
= read_uleb128 (p
, &len
, end
);
15130 printf (" Tag_ABI_stack_align_preserved: ");
15134 printf (_("8-byte\n"));
15137 printf (_("16-byte\n"));
15140 printf ("??? (%d)\n", val
);
15146 val
= read_uleb128 (p
, &len
, end
);
15148 printf (" Tag_ABI_DSBT: ");
15152 printf (_("DSBT addressing not used\n"));
15155 printf (_("DSBT addressing used\n"));
15158 printf ("??? (%d)\n", val
);
15164 val
= read_uleb128 (p
, &len
, end
);
15166 printf (" Tag_ABI_PID: ");
15170 printf (_("Data addressing position-dependent\n"));
15173 printf (_("Data addressing position-independent, GOT near DP\n"));
15176 printf (_("Data addressing position-independent, GOT far from DP\n"));
15179 printf ("??? (%d)\n", val
);
15185 val
= read_uleb128 (p
, &len
, end
);
15187 printf (" Tag_ABI_PIC: ");
15191 printf (_("Code addressing position-dependent\n"));
15194 printf (_("Code addressing position-independent\n"));
15197 printf ("??? (%d)\n", val
);
15202 case Tag_ABI_array_object_alignment
:
15203 val
= read_uleb128 (p
, &len
, end
);
15205 printf (" Tag_ABI_array_object_alignment: ");
15209 printf (_("8-byte\n"));
15212 printf (_("4-byte\n"));
15215 printf (_("16-byte\n"));
15218 printf ("??? (%d)\n", val
);
15223 case Tag_ABI_array_object_align_expected
:
15224 val
= read_uleb128 (p
, &len
, end
);
15226 printf (" Tag_ABI_array_object_align_expected: ");
15230 printf (_("8-byte\n"));
15233 printf (_("4-byte\n"));
15236 printf (_("16-byte\n"));
15239 printf ("??? (%d)\n", val
);
15244 case Tag_ABI_compatibility
:
15246 val
= read_uleb128 (p
, &len
, end
);
15248 printf (" Tag_ABI_compatibility: ");
15249 printf (_("flag = %d, vendor = "), val
);
15252 size_t maxlen
= (end
- p
) - 1;
15254 print_symbol ((int) maxlen
, (const char *) p
);
15255 p
+= strnlen ((char *) p
, maxlen
) + 1;
15259 printf (_("<corrupt>"));
15260 p
= (unsigned char *) end
;
15266 case Tag_ABI_conformance
:
15268 printf (" Tag_ABI_conformance: \"");
15271 size_t maxlen
= (end
- p
) - 1;
15273 print_symbol ((int) maxlen
, (const char *) p
);
15274 p
+= strnlen ((char *) p
, maxlen
) + 1;
15278 printf (_("<corrupt>"));
15279 p
= (unsigned char *) end
;
15286 return display_tag_value (tag
, p
, end
);
15290 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15292 unsigned long addr
= 0;
15293 size_t bytes
= end
- p
;
15300 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15302 printf (" 0x%8.8lx ", addr
);
15304 for (j
= 0; j
< 16; j
++)
15307 printf ("%2.2x", p
[j
]);
15315 for (j
= 0; j
< lbytes
; j
++)
15318 if (k
>= ' ' && k
< 0x7f)
15334 static unsigned char *
15335 display_msp430x_attribute (unsigned char * p
,
15336 const unsigned char * const end
)
15342 tag
= read_uleb128 (p
, & len
, end
);
15347 case OFBA_MSPABI_Tag_ISA
:
15348 val
= read_uleb128 (p
, &len
, end
);
15350 printf (" Tag_ISA: ");
15353 case 0: printf (_("None\n")); break;
15354 case 1: printf (_("MSP430\n")); break;
15355 case 2: printf (_("MSP430X\n")); break;
15356 default: printf ("??? (%d)\n", val
); break;
15360 case OFBA_MSPABI_Tag_Code_Model
:
15361 val
= read_uleb128 (p
, &len
, end
);
15363 printf (" Tag_Code_Model: ");
15366 case 0: printf (_("None\n")); break;
15367 case 1: printf (_("Small\n")); break;
15368 case 2: printf (_("Large\n")); break;
15369 default: printf ("??? (%d)\n", val
); break;
15373 case OFBA_MSPABI_Tag_Data_Model
:
15374 val
= read_uleb128 (p
, &len
, end
);
15376 printf (" Tag_Data_Model: ");
15379 case 0: printf (_("None\n")); break;
15380 case 1: printf (_("Small\n")); break;
15381 case 2: printf (_("Large\n")); break;
15382 case 3: printf (_("Restricted Large\n")); break;
15383 default: printf ("??? (%d)\n", val
); break;
15388 printf (_(" <unknown tag %d>: "), tag
);
15395 size_t maxlen
= (end
- p
) - 1;
15397 print_symbol ((int) maxlen
, (const char *) p
);
15398 p
+= strnlen ((char *) p
, maxlen
) + 1;
15402 printf (_("<corrupt>"));
15403 p
= (unsigned char *) end
;
15409 val
= read_uleb128 (p
, &len
, end
);
15411 printf ("%d (0x%x)\n", val
, val
);
15420 struct riscv_attr_tag_t
{
15425 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15427 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15430 T(priv_spec_minor
),
15431 T(priv_spec_revision
),
15432 T(unaligned_access
),
15437 static unsigned char *
15438 display_riscv_attribute (unsigned char *p
,
15439 const unsigned char * const end
)
15444 struct riscv_attr_tag_t
*attr
= NULL
;
15447 tag
= read_uleb128 (p
, &len
, end
);
15450 /* Find the name of attribute. */
15451 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
15453 if (riscv_attr_tag
[i
].tag
== tag
)
15455 attr
= &riscv_attr_tag
[i
];
15461 printf (" %s: ", attr
->name
);
15463 return display_tag_value (tag
, p
, end
);
15467 case Tag_RISCV_priv_spec
:
15468 case Tag_RISCV_priv_spec_minor
:
15469 case Tag_RISCV_priv_spec_revision
:
15470 val
= read_uleb128 (p
, &len
, end
);
15472 printf (_("%d\n"), val
);
15474 case Tag_RISCV_unaligned_access
:
15475 val
= read_uleb128 (p
, &len
, end
);
15480 printf (_("No unaligned access\n"));
15483 printf (_("Unaligned access\n"));
15487 case Tag_RISCV_stack_align
:
15488 val
= read_uleb128 (p
, &len
, end
);
15490 printf (_("%d-bytes\n"), val
);
15492 case Tag_RISCV_arch
:
15493 p
= display_tag_value (-1, p
, end
);
15496 return display_tag_value (tag
, p
, end
);
15503 process_attributes (Filedata
* filedata
,
15504 const char * public_name
,
15505 unsigned int proc_type
,
15506 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15507 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15509 Elf_Internal_Shdr
* sect
;
15511 bfd_boolean res
= TRUE
;
15513 /* Find the section header so that we get the size. */
15514 for (i
= 0, sect
= filedata
->section_headers
;
15515 i
< filedata
->file_header
.e_shnum
;
15518 unsigned char * contents
;
15521 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15524 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15525 sect
->sh_size
, _("attributes"));
15526 if (contents
== NULL
)
15533 /* The first character is the version of the attributes.
15534 Currently only version 1, (aka 'A') is recognised here. */
15537 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15542 bfd_vma section_len
;
15544 section_len
= sect
->sh_size
- 1;
15547 while (section_len
> 0)
15550 unsigned int namelen
;
15551 bfd_boolean public_section
;
15552 bfd_boolean gnu_section
;
15554 if (section_len
<= 4)
15556 error (_("Tag section ends prematurely\n"));
15560 attr_len
= byte_get (p
, 4);
15563 if (attr_len
> section_len
)
15565 error (_("Bad attribute length (%u > %u)\n"),
15566 (unsigned) attr_len
, (unsigned) section_len
);
15567 attr_len
= section_len
;
15570 /* PR 17531: file: 001-101425-0.004 */
15571 else if (attr_len
< 5)
15573 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15578 section_len
-= attr_len
;
15581 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15582 if (namelen
== 0 || namelen
>= attr_len
)
15584 error (_("Corrupt attribute section name\n"));
15589 printf (_("Attribute Section: "));
15590 print_symbol (INT_MAX
, (const char *) p
);
15593 if (public_name
&& streq ((char *) p
, public_name
))
15594 public_section
= TRUE
;
15596 public_section
= FALSE
;
15598 if (streq ((char *) p
, "gnu"))
15599 gnu_section
= TRUE
;
15601 gnu_section
= FALSE
;
15604 attr_len
-= namelen
;
15606 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15611 unsigned char * end
;
15613 /* PR binutils/17531: Safe handling of corrupt files. */
15616 error (_("Unused bytes at end of section\n"));
15623 size
= byte_get (p
, 4);
15624 if (size
> attr_len
)
15626 error (_("Bad subsection length (%u > %u)\n"),
15627 (unsigned) size
, (unsigned) attr_len
);
15631 /* PR binutils/17531: Safe handling of corrupt files. */
15634 error (_("Bad subsection length (%u < 6)\n"),
15642 end
= p
+ size
- 1;
15643 assert (end
<= contents
+ sect
->sh_size
);
15649 printf (_("File Attributes\n"));
15652 printf (_("Section Attributes:"));
15655 printf (_("Symbol Attributes:"));
15656 /* Fall through. */
15662 val
= read_uleb128 (p
, &j
, end
);
15666 printf (" %d", val
);
15671 printf (_("Unknown tag: %d\n"), tag
);
15672 public_section
= FALSE
;
15676 if (public_section
&& display_pub_attribute
!= NULL
)
15679 p
= display_pub_attribute (p
, end
);
15682 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15685 p
= display_gnu_attribute (p
,
15686 display_proc_gnu_attribute
,
15692 printf (_(" Unknown attribute:\n"));
15693 display_raw_attribute (p
, end
);
15708 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15709 Print the Address, Access and Initial fields of an entry at VMA ADDR
15710 and return the VMA of the next entry, or -1 if there was a problem.
15711 Does not read from DATA_END or beyond. */
15714 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15715 unsigned char * data_end
)
15718 print_vma (addr
, LONG_HEX
);
15720 if (addr
< pltgot
+ 0xfff0)
15721 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15723 printf ("%10s", "");
15726 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15730 unsigned char * from
= data
+ addr
- pltgot
;
15732 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15734 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15735 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15736 return (bfd_vma
) -1;
15740 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15741 print_vma (entry
, LONG_HEX
);
15744 return addr
+ (is_32bit_elf
? 4 : 8);
15747 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15748 PLTGOT. Print the Address and Initial fields of an entry at VMA
15749 ADDR and return the VMA of the next entry. */
15752 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15755 print_vma (addr
, LONG_HEX
);
15758 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15763 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15764 print_vma (entry
, LONG_HEX
);
15766 return addr
+ (is_32bit_elf
? 4 : 8);
15770 print_mips_ases (unsigned int mask
)
15772 if (mask
& AFL_ASE_DSP
)
15773 fputs ("\n\tDSP ASE", stdout
);
15774 if (mask
& AFL_ASE_DSPR2
)
15775 fputs ("\n\tDSP R2 ASE", stdout
);
15776 if (mask
& AFL_ASE_DSPR3
)
15777 fputs ("\n\tDSP R3 ASE", stdout
);
15778 if (mask
& AFL_ASE_EVA
)
15779 fputs ("\n\tEnhanced VA Scheme", stdout
);
15780 if (mask
& AFL_ASE_MCU
)
15781 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15782 if (mask
& AFL_ASE_MDMX
)
15783 fputs ("\n\tMDMX ASE", stdout
);
15784 if (mask
& AFL_ASE_MIPS3D
)
15785 fputs ("\n\tMIPS-3D ASE", stdout
);
15786 if (mask
& AFL_ASE_MT
)
15787 fputs ("\n\tMT ASE", stdout
);
15788 if (mask
& AFL_ASE_SMARTMIPS
)
15789 fputs ("\n\tSmartMIPS ASE", stdout
);
15790 if (mask
& AFL_ASE_VIRT
)
15791 fputs ("\n\tVZ ASE", stdout
);
15792 if (mask
& AFL_ASE_MSA
)
15793 fputs ("\n\tMSA ASE", stdout
);
15794 if (mask
& AFL_ASE_MIPS16
)
15795 fputs ("\n\tMIPS16 ASE", stdout
);
15796 if (mask
& AFL_ASE_MICROMIPS
)
15797 fputs ("\n\tMICROMIPS ASE", stdout
);
15798 if (mask
& AFL_ASE_XPA
)
15799 fputs ("\n\tXPA ASE", stdout
);
15800 if (mask
& AFL_ASE_MIPS16E2
)
15801 fputs ("\n\tMIPS16e2 ASE", stdout
);
15802 if (mask
& AFL_ASE_CRC
)
15803 fputs ("\n\tCRC ASE", stdout
);
15804 if (mask
& AFL_ASE_GINV
)
15805 fputs ("\n\tGINV ASE", stdout
);
15806 if (mask
& AFL_ASE_LOONGSON_MMI
)
15807 fputs ("\n\tLoongson MMI ASE", stdout
);
15808 if (mask
& AFL_ASE_LOONGSON_CAM
)
15809 fputs ("\n\tLoongson CAM ASE", stdout
);
15810 if (mask
& AFL_ASE_LOONGSON_EXT
)
15811 fputs ("\n\tLoongson EXT ASE", stdout
);
15812 if (mask
& AFL_ASE_LOONGSON_EXT2
)
15813 fputs ("\n\tLoongson EXT2 ASE", stdout
);
15815 fprintf (stdout
, "\n\t%s", _("None"));
15816 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15817 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15821 print_mips_isa_ext (unsigned int isa_ext
)
15826 fputs (_("None"), stdout
);
15829 fputs ("RMI XLR", stdout
);
15831 case AFL_EXT_OCTEON3
:
15832 fputs ("Cavium Networks Octeon3", stdout
);
15834 case AFL_EXT_OCTEON2
:
15835 fputs ("Cavium Networks Octeon2", stdout
);
15837 case AFL_EXT_OCTEONP
:
15838 fputs ("Cavium Networks OcteonP", stdout
);
15840 case AFL_EXT_OCTEON
:
15841 fputs ("Cavium Networks Octeon", stdout
);
15844 fputs ("Toshiba R5900", stdout
);
15847 fputs ("MIPS R4650", stdout
);
15850 fputs ("LSI R4010", stdout
);
15853 fputs ("NEC VR4100", stdout
);
15856 fputs ("Toshiba R3900", stdout
);
15858 case AFL_EXT_10000
:
15859 fputs ("MIPS R10000", stdout
);
15862 fputs ("Broadcom SB-1", stdout
);
15865 fputs ("NEC VR4111/VR4181", stdout
);
15868 fputs ("NEC VR4120", stdout
);
15871 fputs ("NEC VR5400", stdout
);
15874 fputs ("NEC VR5500", stdout
);
15876 case AFL_EXT_LOONGSON_2E
:
15877 fputs ("ST Microelectronics Loongson 2E", stdout
);
15879 case AFL_EXT_LOONGSON_2F
:
15880 fputs ("ST Microelectronics Loongson 2F", stdout
);
15882 case AFL_EXT_INTERAPTIV_MR2
:
15883 fputs ("Imagination interAptiv MR2", stdout
);
15886 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15891 get_mips_reg_size (int reg_size
)
15893 return (reg_size
== AFL_REG_NONE
) ? 0
15894 : (reg_size
== AFL_REG_32
) ? 32
15895 : (reg_size
== AFL_REG_64
) ? 64
15896 : (reg_size
== AFL_REG_128
) ? 128
15901 process_mips_specific (Filedata
* filedata
)
15903 Elf_Internal_Dyn
* entry
;
15904 Elf_Internal_Shdr
*sect
= NULL
;
15905 size_t liblist_offset
= 0;
15906 size_t liblistno
= 0;
15907 size_t conflictsno
= 0;
15908 size_t options_offset
= 0;
15909 size_t conflicts_offset
= 0;
15910 size_t pltrelsz
= 0;
15912 bfd_vma pltgot
= 0;
15913 bfd_vma mips_pltgot
= 0;
15914 bfd_vma jmprel
= 0;
15915 bfd_vma local_gotno
= 0;
15916 bfd_vma gotsym
= 0;
15917 bfd_vma symtabno
= 0;
15918 bfd_boolean res
= TRUE
;
15920 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15921 display_mips_gnu_attribute
))
15924 sect
= find_section (filedata
, ".MIPS.abiflags");
15928 Elf_External_ABIFlags_v0
*abiflags_ext
;
15929 Elf_Internal_ABIFlags_v0 abiflags_in
;
15931 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15933 error (_("Corrupt MIPS ABI Flags section.\n"));
15938 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15939 sect
->sh_size
, _("MIPS ABI Flags section"));
15942 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15943 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15944 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15945 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15946 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15947 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15948 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15949 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15950 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15951 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15952 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15954 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15955 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15956 if (abiflags_in
.isa_rev
> 1)
15957 printf ("r%d", abiflags_in
.isa_rev
);
15958 printf ("\nGPR size: %d",
15959 get_mips_reg_size (abiflags_in
.gpr_size
));
15960 printf ("\nCPR1 size: %d",
15961 get_mips_reg_size (abiflags_in
.cpr1_size
));
15962 printf ("\nCPR2 size: %d",
15963 get_mips_reg_size (abiflags_in
.cpr2_size
));
15964 fputs ("\nFP ABI: ", stdout
);
15965 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15966 fputs ("ISA Extension: ", stdout
);
15967 print_mips_isa_ext (abiflags_in
.isa_ext
);
15968 fputs ("\nASEs:", stdout
);
15969 print_mips_ases (abiflags_in
.ases
);
15970 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15971 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15972 fputc ('\n', stdout
);
15973 free (abiflags_ext
);
15978 /* We have a lot of special sections. Thanks SGI! */
15979 if (dynamic_section
== NULL
)
15981 /* No dynamic information available. See if there is static GOT. */
15982 sect
= find_section (filedata
, ".got");
15985 unsigned char *data_end
;
15986 unsigned char *data
;
15990 pltgot
= sect
->sh_addr
;
15993 addr_size
= (is_32bit_elf
? 4 : 8);
15994 end
= pltgot
+ sect
->sh_size
;
15996 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15998 _("Global Offset Table data"));
15999 /* PR 12855: Null data is handled gracefully throughout. */
16000 data_end
= data
+ (end
- pltgot
);
16002 printf (_("\nStatic GOT:\n"));
16003 printf (_(" Canonical gp value: "));
16004 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16007 /* In a dynamic binary GOT[0] is reserved for the dynamic
16008 loader to store the lazy resolver pointer, however in
16009 a static binary it may well have been omitted and GOT
16010 reduced to a table of addresses.
16011 PR 21344: Check for the entry being fully available
16012 before fetching it. */
16014 && data
+ ent
- pltgot
+ addr_size
<= data_end
16015 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16017 printf (_(" Reserved entries:\n"));
16018 printf (_(" %*s %10s %*s\n"),
16019 addr_size
* 2, _("Address"), _("Access"),
16020 addr_size
* 2, _("Value"));
16021 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16023 if (ent
== (bfd_vma
) -1)
16024 goto sgot_print_fail
;
16026 /* Check for the MSB of GOT[1] being set, identifying a
16027 GNU object. This entry will be used by some runtime
16028 loaders, to store the module pointer. Otherwise this
16029 is an ordinary local entry.
16030 PR 21344: Check for the entry being fully available
16031 before fetching it. */
16033 && data
+ ent
- pltgot
+ addr_size
<= data_end
16034 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16035 >> (addr_size
* 8 - 1)) != 0)
16037 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16039 if (ent
== (bfd_vma
) -1)
16040 goto sgot_print_fail
;
16045 if (data
!= NULL
&& ent
< end
)
16047 printf (_(" Local entries:\n"));
16048 printf (" %*s %10s %*s\n",
16049 addr_size
* 2, _("Address"), _("Access"),
16050 addr_size
* 2, _("Value"));
16053 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16055 if (ent
== (bfd_vma
) -1)
16056 goto sgot_print_fail
;
16068 for (entry
= dynamic_section
;
16069 /* PR 17531 file: 012-50589-0.004. */
16070 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16072 switch (entry
->d_tag
)
16074 case DT_MIPS_LIBLIST
:
16076 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16077 liblistno
* sizeof (Elf32_External_Lib
));
16079 case DT_MIPS_LIBLISTNO
:
16080 liblistno
= entry
->d_un
.d_val
;
16082 case DT_MIPS_OPTIONS
:
16083 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16085 case DT_MIPS_CONFLICT
:
16087 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16088 conflictsno
* sizeof (Elf32_External_Conflict
));
16090 case DT_MIPS_CONFLICTNO
:
16091 conflictsno
= entry
->d_un
.d_val
;
16094 pltgot
= entry
->d_un
.d_ptr
;
16096 case DT_MIPS_LOCAL_GOTNO
:
16097 local_gotno
= entry
->d_un
.d_val
;
16099 case DT_MIPS_GOTSYM
:
16100 gotsym
= entry
->d_un
.d_val
;
16102 case DT_MIPS_SYMTABNO
:
16103 symtabno
= entry
->d_un
.d_val
;
16105 case DT_MIPS_PLTGOT
:
16106 mips_pltgot
= entry
->d_un
.d_ptr
;
16109 pltrel
= entry
->d_un
.d_val
;
16112 pltrelsz
= entry
->d_un
.d_val
;
16115 jmprel
= entry
->d_un
.d_ptr
;
16121 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16123 Elf32_External_Lib
* elib
;
16126 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16128 sizeof (Elf32_External_Lib
),
16129 _("liblist section data"));
16132 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16133 "\nSection '.liblist' contains %lu entries:\n",
16134 (unsigned long) liblistno
),
16135 (unsigned long) liblistno
);
16136 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16139 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16146 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16147 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16148 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16149 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16150 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16152 tmp
= gmtime (&atime
);
16153 snprintf (timebuf
, sizeof (timebuf
),
16154 "%04u-%02u-%02uT%02u:%02u:%02u",
16155 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16156 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16158 printf ("%3lu: ", (unsigned long) cnt
);
16159 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16160 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16162 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16163 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16164 liblist
.l_version
);
16166 if (liblist
.l_flags
== 0)
16170 static const struct
16177 { " EXACT_MATCH", LL_EXACT_MATCH
},
16178 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16179 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16180 { " EXPORTS", LL_EXPORTS
},
16181 { " DELAY_LOAD", LL_DELAY_LOAD
},
16182 { " DELTA", LL_DELTA
}
16184 int flags
= liblist
.l_flags
;
16187 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16188 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16190 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16191 flags
^= l_flags_vals
[fcnt
].bit
;
16194 printf (" %#x", (unsigned int) flags
);
16206 if (options_offset
!= 0)
16208 Elf_External_Options
* eopt
;
16209 Elf_Internal_Options
* iopt
;
16210 Elf_Internal_Options
* option
;
16213 sect
= filedata
->section_headers
;
16215 /* Find the section header so that we get the size. */
16216 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16217 /* PR 17533 file: 012-277276-0.004. */
16220 error (_("No MIPS_OPTIONS header found\n"));
16224 if (sect
->sh_size
< sizeof (* eopt
))
16226 error (_("The MIPS options section is too small.\n"));
16230 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16231 sect
->sh_size
, _("options"));
16234 iopt
= (Elf_Internal_Options
*)
16235 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16238 error (_("Out of memory allocating space for MIPS options\n"));
16245 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16247 Elf_External_Options
* eoption
;
16249 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16251 option
->kind
= BYTE_GET (eoption
->kind
);
16252 option
->size
= BYTE_GET (eoption
->size
);
16253 option
->section
= BYTE_GET (eoption
->section
);
16254 option
->info
= BYTE_GET (eoption
->info
);
16256 /* PR 17531: file: ffa0fa3b. */
16257 if (option
->size
< sizeof (* eopt
)
16258 || offset
+ option
->size
> sect
->sh_size
)
16260 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16263 offset
+= option
->size
;
16269 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16270 "\nSection '%s' contains %d entries:\n",
16272 printable_section_name (filedata
, sect
), cnt
);
16281 switch (option
->kind
)
16284 /* This shouldn't happen. */
16285 printf (" NULL %d %lx", option
->section
, option
->info
);
16288 printf (" REGINFO ");
16289 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16292 Elf32_External_RegInfo
* ereg
;
16293 Elf32_RegInfo reginfo
;
16295 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16296 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16297 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16298 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16299 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16300 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16301 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16303 printf ("GPR %08lx GP 0x%lx\n",
16304 reginfo
.ri_gprmask
,
16305 (unsigned long) reginfo
.ri_gp_value
);
16306 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16307 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16308 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16313 Elf64_External_RegInfo
* ereg
;
16314 Elf64_Internal_RegInfo reginfo
;
16316 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16317 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16318 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16319 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16320 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16321 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16322 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16324 printf ("GPR %08lx GP 0x",
16325 reginfo
.ri_gprmask
);
16326 printf_vma (reginfo
.ri_gp_value
);
16329 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16330 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16331 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16335 case ODK_EXCEPTIONS
:
16336 fputs (" EXCEPTIONS fpe_min(", stdout
);
16337 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16338 fputs (") fpe_max(", stdout
);
16339 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16340 fputs (")", stdout
);
16342 if (option
->info
& OEX_PAGE0
)
16343 fputs (" PAGE0", stdout
);
16344 if (option
->info
& OEX_SMM
)
16345 fputs (" SMM", stdout
);
16346 if (option
->info
& OEX_FPDBUG
)
16347 fputs (" FPDBUG", stdout
);
16348 if (option
->info
& OEX_DISMISS
)
16349 fputs (" DISMISS", stdout
);
16352 fputs (" PAD ", stdout
);
16353 if (option
->info
& OPAD_PREFIX
)
16354 fputs (" PREFIX", stdout
);
16355 if (option
->info
& OPAD_POSTFIX
)
16356 fputs (" POSTFIX", stdout
);
16357 if (option
->info
& OPAD_SYMBOL
)
16358 fputs (" SYMBOL", stdout
);
16361 fputs (" HWPATCH ", stdout
);
16362 if (option
->info
& OHW_R4KEOP
)
16363 fputs (" R4KEOP", stdout
);
16364 if (option
->info
& OHW_R8KPFETCH
)
16365 fputs (" R8KPFETCH", stdout
);
16366 if (option
->info
& OHW_R5KEOP
)
16367 fputs (" R5KEOP", stdout
);
16368 if (option
->info
& OHW_R5KCVTL
)
16369 fputs (" R5KCVTL", stdout
);
16372 fputs (" FILL ", stdout
);
16373 /* XXX Print content of info word? */
16376 fputs (" TAGS ", stdout
);
16377 /* XXX Print content of info word? */
16380 fputs (" HWAND ", stdout
);
16381 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16382 fputs (" R4KEOP_CHECKED", stdout
);
16383 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16384 fputs (" R4KEOP_CLEAN", stdout
);
16387 fputs (" HWOR ", stdout
);
16388 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16389 fputs (" R4KEOP_CHECKED", stdout
);
16390 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16391 fputs (" R4KEOP_CLEAN", stdout
);
16394 printf (" GP_GROUP %#06lx self-contained %#06lx",
16395 option
->info
& OGP_GROUP
,
16396 (option
->info
& OGP_SELF
) >> 16);
16399 printf (" IDENT %#06lx self-contained %#06lx",
16400 option
->info
& OGP_GROUP
,
16401 (option
->info
& OGP_SELF
) >> 16);
16404 /* This shouldn't happen. */
16405 printf (" %3d ??? %d %lx",
16406 option
->kind
, option
->section
, option
->info
);
16410 len
= sizeof (* eopt
);
16411 while (len
< option
->size
)
16413 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16415 if (ISPRINT (datum
))
16416 printf ("%c", datum
);
16418 printf ("\\%03o", datum
);
16421 fputs ("\n", stdout
);
16423 offset
+= option
->size
;
16433 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16435 Elf32_Conflict
* iconf
;
16438 if (dynamic_symbols
== NULL
)
16440 error (_("conflict list found without a dynamic symbol table\n"));
16444 /* PR 21345 - print a slightly more helpful error message
16445 if we are sure that the cmalloc will fail. */
16446 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16448 error (_("Overlarge number of conflicts detected: %lx\n"),
16449 (long) conflictsno
);
16453 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16456 error (_("Out of memory allocating space for dynamic conflicts\n"));
16462 Elf32_External_Conflict
* econf32
;
16464 econf32
= (Elf32_External_Conflict
*)
16465 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16466 sizeof (* econf32
), _("conflict"));
16470 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16471 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16477 Elf64_External_Conflict
* econf64
;
16479 econf64
= (Elf64_External_Conflict
*)
16480 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16481 sizeof (* econf64
), _("conflict"));
16485 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16486 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16491 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16492 "\nSection '.conflict' contains %lu entries:\n",
16493 (unsigned long) conflictsno
),
16494 (unsigned long) conflictsno
);
16495 puts (_(" Num: Index Value Name"));
16497 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16499 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16501 if (iconf
[cnt
] >= num_dynamic_syms
)
16502 printf (_("<corrupt symbol index>"));
16505 Elf_Internal_Sym
* psym
;
16507 psym
= & dynamic_symbols
[iconf
[cnt
]];
16508 print_vma (psym
->st_value
, FULL_HEX
);
16510 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16511 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16513 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16521 if (pltgot
!= 0 && local_gotno
!= 0)
16523 bfd_vma ent
, local_end
, global_end
;
16525 unsigned char * data
;
16526 unsigned char * data_end
;
16530 addr_size
= (is_32bit_elf
? 4 : 8);
16531 local_end
= pltgot
+ local_gotno
* addr_size
;
16533 /* PR binutils/17533 file: 012-111227-0.004 */
16534 if (symtabno
< gotsym
)
16536 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16537 (unsigned long) gotsym
, (unsigned long) symtabno
);
16541 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16542 /* PR 17531: file: 54c91a34. */
16543 if (global_end
< local_end
)
16545 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16549 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16550 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16551 global_end
- pltgot
, 1,
16552 _("Global Offset Table data"));
16553 /* PR 12855: Null data is handled gracefully throughout. */
16554 data_end
= data
+ (global_end
- pltgot
);
16556 printf (_("\nPrimary GOT:\n"));
16557 printf (_(" Canonical gp value: "));
16558 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16561 printf (_(" Reserved entries:\n"));
16562 printf (_(" %*s %10s %*s Purpose\n"),
16563 addr_size
* 2, _("Address"), _("Access"),
16564 addr_size
* 2, _("Initial"));
16565 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16566 printf (_(" Lazy resolver\n"));
16567 if (ent
== (bfd_vma
) -1)
16568 goto got_print_fail
;
16570 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16571 This entry will be used by some runtime loaders, to store the
16572 module pointer. Otherwise this is an ordinary local entry.
16573 PR 21344: Check for the entry being fully available before
16576 && data
+ ent
- pltgot
+ addr_size
<= data_end
16577 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16578 >> (addr_size
* 8 - 1)) != 0)
16580 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16581 printf (_(" Module pointer (GNU extension)\n"));
16582 if (ent
== (bfd_vma
) -1)
16583 goto got_print_fail
;
16587 if (data
!= NULL
&& ent
< local_end
)
16589 printf (_(" Local entries:\n"));
16590 printf (" %*s %10s %*s\n",
16591 addr_size
* 2, _("Address"), _("Access"),
16592 addr_size
* 2, _("Initial"));
16593 while (ent
< local_end
)
16595 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16597 if (ent
== (bfd_vma
) -1)
16598 goto got_print_fail
;
16603 if (data
!= NULL
&& gotsym
< symtabno
)
16607 printf (_(" Global entries:\n"));
16608 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16609 addr_size
* 2, _("Address"),
16611 addr_size
* 2, _("Initial"),
16612 addr_size
* 2, _("Sym.Val."),
16614 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16615 _("Ndx"), _("Name"));
16617 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16619 for (i
= gotsym
; i
< symtabno
; i
++)
16621 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16624 if (dynamic_symbols
== NULL
)
16625 printf (_("<no dynamic symbols>"));
16626 else if (i
< num_dynamic_syms
)
16628 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16630 print_vma (psym
->st_value
, LONG_HEX
);
16631 printf (" %-7s %3s ",
16632 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16633 get_symbol_index_type (filedata
, psym
->st_shndx
));
16635 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16636 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16638 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16641 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16642 (unsigned long) i
);
16645 if (ent
== (bfd_vma
) -1)
16656 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16659 size_t offset
, rel_offset
;
16660 unsigned long count
, i
;
16661 unsigned char * data
;
16662 int addr_size
, sym_width
;
16663 Elf_Internal_Rela
* rels
;
16665 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16666 if (pltrel
== DT_RELA
)
16668 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16673 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16678 addr_size
= (is_32bit_elf
? 4 : 8);
16679 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16681 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16682 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16683 1, _("Procedure Linkage Table data"));
16687 printf ("\nPLT GOT:\n\n");
16688 printf (_(" Reserved entries:\n"));
16689 printf (_(" %*s %*s Purpose\n"),
16690 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16691 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16692 printf (_(" PLT lazy resolver\n"));
16693 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16694 printf (_(" Module pointer\n"));
16697 printf (_(" Entries:\n"));
16698 printf (" %*s %*s %*s %-7s %3s %s\n",
16699 addr_size
* 2, _("Address"),
16700 addr_size
* 2, _("Initial"),
16701 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16702 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16703 for (i
= 0; i
< count
; i
++)
16705 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16707 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16710 if (idx
>= num_dynamic_syms
)
16711 printf (_("<corrupt symbol index: %lu>"), idx
);
16714 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16716 print_vma (psym
->st_value
, LONG_HEX
);
16717 printf (" %-7s %3s ",
16718 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16719 get_symbol_index_type (filedata
, psym
->st_shndx
));
16720 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16721 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16723 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16738 process_nds32_specific (Filedata
* filedata
)
16740 Elf_Internal_Shdr
*sect
= NULL
;
16742 sect
= find_section (filedata
, ".nds32_e_flags");
16745 unsigned int *flag
;
16747 printf ("\nNDS32 elf flags section:\n");
16748 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16749 sect
->sh_size
, _("NDS32 elf flags section"));
16754 switch ((*flag
) & 0x3)
16757 printf ("(VEC_SIZE):\tNo entry.\n");
16760 printf ("(VEC_SIZE):\t4 bytes\n");
16763 printf ("(VEC_SIZE):\t16 bytes\n");
16766 printf ("(VEC_SIZE):\treserved\n");
16775 process_gnu_liblist (Filedata
* filedata
)
16777 Elf_Internal_Shdr
* section
;
16778 Elf_Internal_Shdr
* string_sec
;
16779 Elf32_External_Lib
* elib
;
16781 size_t strtab_size
;
16783 unsigned long num_liblist
;
16785 bfd_boolean res
= TRUE
;
16790 for (i
= 0, section
= filedata
->section_headers
;
16791 i
< filedata
->file_header
.e_shnum
;
16794 switch (section
->sh_type
)
16796 case SHT_GNU_LIBLIST
:
16797 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16800 elib
= (Elf32_External_Lib
*)
16801 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16802 _("liblist section data"));
16810 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16811 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16812 string_sec
->sh_size
,
16813 _("liblist string table"));
16815 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16822 strtab_size
= string_sec
->sh_size
;
16824 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16825 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16826 "\nLibrary list section '%s' contains %lu entries:\n",
16828 printable_section_name (filedata
, section
),
16831 puts (_(" Library Time Stamp Checksum Version Flags"));
16833 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16841 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16842 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16843 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16844 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16845 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16847 tmp
= gmtime (&atime
);
16848 snprintf (timebuf
, sizeof (timebuf
),
16849 "%04u-%02u-%02uT%02u:%02u:%02u",
16850 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16851 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16853 printf ("%3lu: ", (unsigned long) cnt
);
16855 printf ("%-20s", liblist
.l_name
< strtab_size
16856 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16858 printf ("%-20.20s", liblist
.l_name
< strtab_size
16859 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16860 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16861 liblist
.l_version
, liblist
.l_flags
);
16872 static const char *
16873 get_note_type (Filedata
* filedata
, unsigned e_type
)
16875 static char buff
[64];
16877 if (filedata
->file_header
.e_type
== ET_CORE
)
16881 return _("NT_AUXV (auxiliary vector)");
16883 return _("NT_PRSTATUS (prstatus structure)");
16885 return _("NT_FPREGSET (floating point registers)");
16887 return _("NT_PRPSINFO (prpsinfo structure)");
16888 case NT_TASKSTRUCT
:
16889 return _("NT_TASKSTRUCT (task structure)");
16891 return _("NT_PRXFPREG (user_xfpregs structure)");
16893 return _("NT_PPC_VMX (ppc Altivec registers)");
16895 return _("NT_PPC_VSX (ppc VSX registers)");
16897 return _("NT_PPC_TAR (ppc TAR register)");
16899 return _("NT_PPC_PPR (ppc PPR register)");
16901 return _("NT_PPC_DSCR (ppc DSCR register)");
16903 return _("NT_PPC_EBB (ppc EBB registers)");
16905 return _("NT_PPC_PMU (ppc PMU registers)");
16906 case NT_PPC_TM_CGPR
:
16907 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16908 case NT_PPC_TM_CFPR
:
16909 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16910 case NT_PPC_TM_CVMX
:
16911 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16912 case NT_PPC_TM_CVSX
:
16913 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16914 case NT_PPC_TM_SPR
:
16915 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16916 case NT_PPC_TM_CTAR
:
16917 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16918 case NT_PPC_TM_CPPR
:
16919 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16920 case NT_PPC_TM_CDSCR
:
16921 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16923 return _("NT_386_TLS (x86 TLS information)");
16924 case NT_386_IOPERM
:
16925 return _("NT_386_IOPERM (x86 I/O permissions)");
16926 case NT_X86_XSTATE
:
16927 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16928 case NT_S390_HIGH_GPRS
:
16929 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16930 case NT_S390_TIMER
:
16931 return _("NT_S390_TIMER (s390 timer register)");
16932 case NT_S390_TODCMP
:
16933 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16934 case NT_S390_TODPREG
:
16935 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16937 return _("NT_S390_CTRS (s390 control registers)");
16938 case NT_S390_PREFIX
:
16939 return _("NT_S390_PREFIX (s390 prefix register)");
16940 case NT_S390_LAST_BREAK
:
16941 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16942 case NT_S390_SYSTEM_CALL
:
16943 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16945 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16946 case NT_S390_VXRS_LOW
:
16947 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16948 case NT_S390_VXRS_HIGH
:
16949 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16950 case NT_S390_GS_CB
:
16951 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16952 case NT_S390_GS_BC
:
16953 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16955 return _("NT_ARM_VFP (arm VFP registers)");
16957 return _("NT_ARM_TLS (AArch TLS registers)");
16958 case NT_ARM_HW_BREAK
:
16959 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16960 case NT_ARM_HW_WATCH
:
16961 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16963 return _("NT_PSTATUS (pstatus structure)");
16965 return _("NT_FPREGS (floating point registers)");
16967 return _("NT_PSINFO (psinfo structure)");
16969 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16971 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16972 case NT_WIN32PSTATUS
:
16973 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16975 return _("NT_SIGINFO (siginfo_t data)");
16977 return _("NT_FILE (mapped files)");
16985 return _("NT_VERSION (version)");
16987 return _("NT_ARCH (architecture)");
16988 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16990 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16996 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17001 print_core_note (Elf_Internal_Note
*pnote
)
17003 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17004 bfd_vma count
, page_size
;
17005 unsigned char *descdata
, *filenames
, *descend
;
17007 if (pnote
->type
!= NT_FILE
)
17017 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17018 /* Still "successful". */
17023 if (pnote
->descsz
< 2 * addr_size
)
17025 error (_(" Malformed note - too short for header\n"));
17029 descdata
= (unsigned char *) pnote
->descdata
;
17030 descend
= descdata
+ pnote
->descsz
;
17032 if (descdata
[pnote
->descsz
- 1] != '\0')
17034 error (_(" Malformed note - does not end with \\0\n"));
17038 count
= byte_get (descdata
, addr_size
);
17039 descdata
+= addr_size
;
17041 page_size
= byte_get (descdata
, addr_size
);
17042 descdata
+= addr_size
;
17044 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17045 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17047 error (_(" Malformed note - too short for supplied file count\n"));
17051 printf (_(" Page size: "));
17052 print_vma (page_size
, DEC
);
17055 printf (_(" %*s%*s%*s\n"),
17056 (int) (2 + 2 * addr_size
), _("Start"),
17057 (int) (4 + 2 * addr_size
), _("End"),
17058 (int) (4 + 2 * addr_size
), _("Page Offset"));
17059 filenames
= descdata
+ count
* 3 * addr_size
;
17060 while (count
-- > 0)
17062 bfd_vma start
, end
, file_ofs
;
17064 if (filenames
== descend
)
17066 error (_(" Malformed note - filenames end too early\n"));
17070 start
= byte_get (descdata
, addr_size
);
17071 descdata
+= addr_size
;
17072 end
= byte_get (descdata
, addr_size
);
17073 descdata
+= addr_size
;
17074 file_ofs
= byte_get (descdata
, addr_size
);
17075 descdata
+= addr_size
;
17078 print_vma (start
, FULL_HEX
);
17080 print_vma (end
, FULL_HEX
);
17082 print_vma (file_ofs
, FULL_HEX
);
17083 printf ("\n %s\n", filenames
);
17085 filenames
+= 1 + strlen ((char *) filenames
);
17091 static const char *
17092 get_gnu_elf_note_type (unsigned e_type
)
17094 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17097 case NT_GNU_ABI_TAG
:
17098 return _("NT_GNU_ABI_TAG (ABI version tag)");
17100 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17101 case NT_GNU_BUILD_ID
:
17102 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17103 case NT_GNU_GOLD_VERSION
:
17104 return _("NT_GNU_GOLD_VERSION (gold version)");
17105 case NT_GNU_PROPERTY_TYPE_0
:
17106 return _("NT_GNU_PROPERTY_TYPE_0");
17107 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17108 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17109 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17110 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17113 static char buff
[64];
17115 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17122 decode_x86_compat_isa (unsigned int bitmask
)
17126 unsigned int bit
= bitmask
& (- bitmask
);
17131 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17134 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17137 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17140 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17143 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17146 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17149 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17152 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17155 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17158 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17161 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17164 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17165 printf ("AVX512F");
17167 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17168 printf ("AVX512CD");
17170 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17171 printf ("AVX512ER");
17173 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17174 printf ("AVX512PF");
17176 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17177 printf ("AVX512VL");
17179 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17180 printf ("AVX512DQ");
17182 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17183 printf ("AVX512BW");
17186 printf (_("<unknown: %x>"), bit
);
17195 decode_x86_isa (unsigned int bitmask
)
17199 printf (_("<None>"));
17205 unsigned int bit
= bitmask
& (- bitmask
);
17210 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17213 case GNU_PROPERTY_X86_ISA_1_SSE
:
17216 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17219 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17222 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17225 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17228 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17231 case GNU_PROPERTY_X86_ISA_1_AVX
:
17234 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17237 case GNU_PROPERTY_X86_ISA_1_FMA
:
17240 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17241 printf ("AVX512F");
17243 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17244 printf ("AVX512CD");
17246 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17247 printf ("AVX512ER");
17249 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17250 printf ("AVX512PF");
17252 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17253 printf ("AVX512VL");
17255 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17256 printf ("AVX512DQ");
17258 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17259 printf ("AVX512BW");
17261 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17262 printf ("AVX512_4FMAPS");
17264 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17265 printf ("AVX512_4VNNIW");
17267 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17268 printf ("AVX512_BITALG");
17270 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17271 printf ("AVX512_IFMA");
17273 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17274 printf ("AVX512_VBMI");
17276 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17277 printf ("AVX512_VBMI2");
17279 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17280 printf ("AVX512_VNNI");
17283 printf (_("<unknown: %x>"), bit
);
17292 decode_x86_feature_1 (unsigned int bitmask
)
17296 printf (_("<None>"));
17302 unsigned int bit
= bitmask
& (- bitmask
);
17307 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17310 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17314 printf (_("<unknown: %x>"), bit
);
17323 decode_x86_feature_2 (unsigned int bitmask
)
17327 printf (_("<None>"));
17333 unsigned int bit
= bitmask
& (- bitmask
);
17338 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17341 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17344 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17347 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17350 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17353 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17356 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17359 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17362 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17363 printf ("XSAVEOPT");
17365 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17369 printf (_("<unknown: %x>"), bit
);
17378 decode_aarch64_feature_1_and (unsigned int bitmask
)
17382 unsigned int bit
= bitmask
& (- bitmask
);
17387 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17391 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17396 printf (_("<unknown: %x>"), bit
);
17405 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17407 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17408 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17409 unsigned int size
= is_32bit_elf
? 4 : 8;
17411 printf (_(" Properties: "));
17413 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17415 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17419 while (ptr
< ptr_end
)
17423 unsigned int datasz
;
17425 if ((size_t) (ptr_end
- ptr
) < 8)
17427 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17431 type
= byte_get (ptr
, 4);
17432 datasz
= byte_get (ptr
+ 4, 4);
17436 if (datasz
> (size_t) (ptr_end
- ptr
))
17438 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17443 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17445 if (filedata
->file_header
.e_machine
== EM_X86_64
17446 || filedata
->file_header
.e_machine
== EM_IAMCU
17447 || filedata
->file_header
.e_machine
== EM_386
)
17449 unsigned int bitmask
;
17452 bitmask
= byte_get (ptr
, 4);
17458 case GNU_PROPERTY_X86_ISA_1_USED
:
17460 printf (_("x86 ISA used: <corrupt length: %#x> "),
17464 printf ("x86 ISA used: ");
17465 decode_x86_isa (bitmask
);
17469 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17471 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17475 printf ("x86 ISA needed: ");
17476 decode_x86_isa (bitmask
);
17480 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17482 printf (_("x86 feature: <corrupt length: %#x> "),
17486 printf ("x86 feature: ");
17487 decode_x86_feature_1 (bitmask
);
17491 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17493 printf (_("x86 feature used: <corrupt length: %#x> "),
17497 printf ("x86 feature used: ");
17498 decode_x86_feature_2 (bitmask
);
17502 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17504 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17507 printf ("x86 feature needed: ");
17508 decode_x86_feature_2 (bitmask
);
17512 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17514 printf (_("x86 ISA used: <corrupt length: %#x> "),
17518 printf ("x86 ISA used: ");
17519 decode_x86_compat_isa (bitmask
);
17523 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
17525 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17529 printf ("x86 ISA needed: ");
17530 decode_x86_compat_isa (bitmask
);
17538 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
17540 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
17542 printf ("AArch64 feature: ");
17544 printf (_("<corrupt length: %#x> "), datasz
);
17546 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
17555 case GNU_PROPERTY_STACK_SIZE
:
17556 printf (_("stack size: "));
17557 if (datasz
!= size
)
17558 printf (_("<corrupt length: %#x> "), datasz
);
17560 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17563 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17564 printf ("no copy on protected ");
17566 printf (_("<corrupt length: %#x> "), datasz
);
17574 if (type
< GNU_PROPERTY_LOPROC
)
17575 printf (_("<unknown type %#x data: "), type
);
17576 else if (type
< GNU_PROPERTY_LOUSER
)
17577 printf (_("<procesor-specific type %#x data: "), type
);
17579 printf (_("<application-specific type %#x data: "), type
);
17580 for (j
= 0; j
< datasz
; ++j
)
17581 printf ("%02x ", ptr
[j
] & 0xff);
17585 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17586 if (ptr
== ptr_end
)
17599 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17601 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17602 switch (pnote
->type
)
17604 case NT_GNU_BUILD_ID
:
17608 printf (_(" Build ID: "));
17609 for (i
= 0; i
< pnote
->descsz
; ++i
)
17610 printf ("%02x", pnote
->descdata
[i
] & 0xff);
17615 case NT_GNU_ABI_TAG
:
17617 unsigned long os
, major
, minor
, subminor
;
17618 const char *osname
;
17620 /* PR 17531: file: 030-599401-0.004. */
17621 if (pnote
->descsz
< 16)
17623 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17627 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17628 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17629 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
17630 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
17634 case GNU_ABI_TAG_LINUX
:
17637 case GNU_ABI_TAG_HURD
:
17640 case GNU_ABI_TAG_SOLARIS
:
17641 osname
= "Solaris";
17643 case GNU_ABI_TAG_FREEBSD
:
17644 osname
= "FreeBSD";
17646 case GNU_ABI_TAG_NETBSD
:
17649 case GNU_ABI_TAG_SYLLABLE
:
17650 osname
= "Syllable";
17652 case GNU_ABI_TAG_NACL
:
17656 osname
= "Unknown";
17660 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17661 major
, minor
, subminor
);
17665 case NT_GNU_GOLD_VERSION
:
17669 printf (_(" Version: "));
17670 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17671 printf ("%c", pnote
->descdata
[i
]);
17678 unsigned long num_entries
, mask
;
17680 /* Hardware capabilities information. Word 0 is the number of entries.
17681 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17682 is a series of entries, where each entry is a single byte followed
17683 by a nul terminated string. The byte gives the bit number to test
17684 if enabled in the bitmask. */
17685 printf (_(" Hardware Capabilities: "));
17686 if (pnote
->descsz
< 8)
17688 error (_("<corrupt GNU_HWCAP>\n"));
17691 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17692 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17693 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17694 /* FIXME: Add code to display the entries... */
17698 case NT_GNU_PROPERTY_TYPE_0
:
17699 print_gnu_property_note (filedata
, pnote
);
17703 /* Handle unrecognised types. An error message should have already been
17704 created by get_gnu_elf_note_type(), so all that we need to do is to
17705 display the data. */
17709 printf (_(" Description data: "));
17710 for (i
= 0; i
< pnote
->descsz
; ++i
)
17711 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17720 static const char *
17721 get_v850_elf_note_type (enum v850_notes n_type
)
17723 static char buff
[64];
17727 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17728 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17729 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17730 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17731 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17732 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17734 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17740 print_v850_note (Elf_Internal_Note
* pnote
)
17744 if (pnote
->descsz
!= 4)
17747 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17751 printf (_("not set\n"));
17755 switch (pnote
->type
)
17757 case V850_NOTE_ALIGNMENT
:
17760 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17761 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17765 case V850_NOTE_DATA_SIZE
:
17768 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17769 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17773 case V850_NOTE_FPU_INFO
:
17776 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17777 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17781 case V850_NOTE_MMU_INFO
:
17782 case V850_NOTE_CACHE_INFO
:
17783 case V850_NOTE_SIMD_INFO
:
17784 if (val
== EF_RH850_SIMD
)
17786 printf (_("yes\n"));
17792 /* An 'unknown note type' message will already have been displayed. */
17796 printf (_("unknown value: %x\n"), val
);
17801 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17803 unsigned int version
;
17805 switch (pnote
->type
)
17807 case NT_NETBSD_IDENT
:
17808 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17809 if ((version
/ 10000) % 100)
17810 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17811 version
, version
/ 100000000, (version
/ 1000000) % 100,
17812 (version
/ 10000) % 100 > 26 ? "Z" : "",
17813 'A' + (version
/ 10000) % 26);
17815 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17816 version
, version
/ 100000000, (version
/ 1000000) % 100,
17817 (version
/ 100) % 100);
17820 case NT_NETBSD_MARCH
:
17821 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17826 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17832 static const char *
17833 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17837 case NT_FREEBSD_THRMISC
:
17838 return _("NT_THRMISC (thrmisc structure)");
17839 case NT_FREEBSD_PROCSTAT_PROC
:
17840 return _("NT_PROCSTAT_PROC (proc data)");
17841 case NT_FREEBSD_PROCSTAT_FILES
:
17842 return _("NT_PROCSTAT_FILES (files data)");
17843 case NT_FREEBSD_PROCSTAT_VMMAP
:
17844 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17845 case NT_FREEBSD_PROCSTAT_GROUPS
:
17846 return _("NT_PROCSTAT_GROUPS (groups data)");
17847 case NT_FREEBSD_PROCSTAT_UMASK
:
17848 return _("NT_PROCSTAT_UMASK (umask data)");
17849 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17850 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17851 case NT_FREEBSD_PROCSTAT_OSREL
:
17852 return _("NT_PROCSTAT_OSREL (osreldate data)");
17853 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17854 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17855 case NT_FREEBSD_PROCSTAT_AUXV
:
17856 return _("NT_PROCSTAT_AUXV (auxv data)");
17857 case NT_FREEBSD_PTLWPINFO
:
17858 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17860 return get_note_type (filedata
, e_type
);
17863 static const char *
17864 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17866 static char buff
[64];
17868 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17869 return _("NetBSD procinfo structure");
17871 /* As of Jan 2002 there are no other machine-independent notes
17872 defined for NetBSD core files. If the note type is less
17873 than the start of the machine-dependent note types, we don't
17876 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17878 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17882 switch (filedata
->file_header
.e_machine
)
17884 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17885 and PT_GETFPREGS == mach+2. */
17890 case EM_SPARC32PLUS
:
17894 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17895 return _("PT_GETREGS (reg structure)");
17896 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17897 return _("PT_GETFPREGS (fpreg structure)");
17903 /* On all other arch's, PT_GETREGS == mach+1 and
17904 PT_GETFPREGS == mach+3. */
17908 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17909 return _("PT_GETREGS (reg structure)");
17910 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17911 return _("PT_GETFPREGS (fpreg structure)");
17917 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17918 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17922 static const char *
17923 get_stapsdt_note_type (unsigned e_type
)
17925 static char buff
[64];
17930 return _("NT_STAPSDT (SystemTap probe descriptors)");
17936 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17941 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17943 size_t len
, maxlen
;
17944 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
17945 char *data
= pnote
->descdata
;
17946 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17947 bfd_vma pc
, base_addr
, semaphore
;
17948 char *provider
, *probe
, *arg_fmt
;
17950 if (pnote
->descsz
< (addr_size
* 3))
17951 goto stapdt_note_too_small
;
17953 pc
= byte_get ((unsigned char *) data
, addr_size
);
17956 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17959 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17962 if (data
>= data_end
)
17963 goto stapdt_note_too_small
;
17964 maxlen
= data_end
- data
;
17965 len
= strnlen (data
, maxlen
);
17972 goto stapdt_note_too_small
;
17974 if (data
>= data_end
)
17975 goto stapdt_note_too_small
;
17976 maxlen
= data_end
- data
;
17977 len
= strnlen (data
, maxlen
);
17984 goto stapdt_note_too_small
;
17986 if (data
>= data_end
)
17987 goto stapdt_note_too_small
;
17988 maxlen
= data_end
- data
;
17989 len
= strnlen (data
, maxlen
);
17996 goto stapdt_note_too_small
;
17998 printf (_(" Provider: %s\n"), provider
);
17999 printf (_(" Name: %s\n"), probe
);
18000 printf (_(" Location: "));
18001 print_vma (pc
, FULL_HEX
);
18002 printf (_(", Base: "));
18003 print_vma (base_addr
, FULL_HEX
);
18004 printf (_(", Semaphore: "));
18005 print_vma (semaphore
, FULL_HEX
);
18007 printf (_(" Arguments: %s\n"), arg_fmt
);
18009 return data
== data_end
;
18011 stapdt_note_too_small
:
18012 printf (_(" <corrupt - note is too small>\n"));
18013 error (_("corrupt stapdt note - the data size is too small\n"));
18017 static const char *
18018 get_ia64_vms_note_type (unsigned e_type
)
18020 static char buff
[64];
18025 return _("NT_VMS_MHD (module header)");
18027 return _("NT_VMS_LNM (language name)");
18029 return _("NT_VMS_SRC (source files)");
18031 return "NT_VMS_TITLE";
18033 return _("NT_VMS_EIDC (consistency check)");
18034 case NT_VMS_FPMODE
:
18035 return _("NT_VMS_FPMODE (FP mode)");
18036 case NT_VMS_LINKTIME
:
18037 return "NT_VMS_LINKTIME";
18038 case NT_VMS_IMGNAM
:
18039 return _("NT_VMS_IMGNAM (image name)");
18041 return _("NT_VMS_IMGID (image id)");
18042 case NT_VMS_LINKID
:
18043 return _("NT_VMS_LINKID (link id)");
18044 case NT_VMS_IMGBID
:
18045 return _("NT_VMS_IMGBID (build id)");
18046 case NT_VMS_GSTNAM
:
18047 return _("NT_VMS_GSTNAM (sym table name)");
18048 case NT_VMS_ORIG_DYN
:
18049 return "NT_VMS_ORIG_DYN";
18050 case NT_VMS_PATCHTIME
:
18051 return "NT_VMS_PATCHTIME";
18053 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18059 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18061 int maxlen
= pnote
->descsz
;
18063 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18064 goto desc_size_fail
;
18066 switch (pnote
->type
)
18070 goto desc_size_fail
;
18072 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18074 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18075 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18076 if (l
+ 34 < maxlen
)
18078 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18079 if (l
+ 35 < maxlen
)
18080 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18082 printf (_(" Module version : <missing>\n"));
18086 printf (_(" Module name : <missing>\n"));
18087 printf (_(" Module version : <missing>\n"));
18092 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18096 case NT_VMS_FPMODE
:
18097 printf (_(" Floating Point mode: "));
18099 goto desc_size_fail
;
18100 /* FIXME: Generate an error if descsz > 8 ? */
18102 printf ("0x%016" BFD_VMA_FMT
"x\n",
18103 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18106 case NT_VMS_LINKTIME
:
18107 printf (_(" Link time: "));
18109 goto desc_size_fail
;
18110 /* FIXME: Generate an error if descsz > 8 ? */
18113 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18117 case NT_VMS_PATCHTIME
:
18118 printf (_(" Patch time: "));
18120 goto desc_size_fail
;
18121 /* FIXME: Generate an error if descsz > 8 ? */
18124 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18128 case NT_VMS_ORIG_DYN
:
18130 goto desc_size_fail
;
18132 printf (_(" Major id: %u, minor id: %u\n"),
18133 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18134 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18135 printf (_(" Last modified : "));
18137 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18138 printf (_("\n Link flags : "));
18139 printf ("0x%016" BFD_VMA_FMT
"x\n",
18140 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18141 printf (_(" Header flags: 0x%08x\n"),
18142 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18143 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18147 case NT_VMS_IMGNAM
:
18148 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18151 case NT_VMS_GSTNAM
:
18152 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18156 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18159 case NT_VMS_LINKID
:
18160 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18170 printf (_(" <corrupt - data size is too small>\n"));
18171 error (_("corrupt IA64 note: data size is too small\n"));
18175 /* Find the symbol associated with a build attribute that is attached
18176 to address OFFSET. If PNAME is non-NULL then store the name of
18177 the symbol (if found) in the provided pointer, Returns NULL if a
18178 symbol could not be found. */
18180 static Elf_Internal_Sym
*
18181 get_symbol_for_build_attribute (Filedata
* filedata
,
18182 unsigned long offset
,
18183 bfd_boolean is_open_attr
,
18184 const char ** pname
)
18186 static Filedata
* saved_filedata
= NULL
;
18187 static char * strtab
;
18188 static unsigned long strtablen
;
18189 static Elf_Internal_Sym
* symtab
;
18190 static unsigned long nsyms
;
18191 Elf_Internal_Sym
* saved_sym
= NULL
;
18192 Elf_Internal_Sym
* sym
;
18194 if (filedata
->section_headers
!= NULL
18195 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
18197 Elf_Internal_Shdr
* symsec
;
18199 /* Load the symbol and string sections. */
18200 for (symsec
= filedata
->section_headers
;
18201 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18204 if (symsec
->sh_type
== SHT_SYMTAB
)
18206 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
18208 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18210 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
18212 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18213 1, strtab_sec
->sh_size
,
18214 _("string table"));
18215 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
18219 saved_filedata
= filedata
;
18222 if (symtab
== NULL
|| strtab
== NULL
)
18225 /* Find a symbol whose value matches offset. */
18226 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
18227 if (sym
->st_value
== offset
)
18229 if (sym
->st_name
>= strtablen
)
18230 /* Huh ? This should not happen. */
18233 if (strtab
[sym
->st_name
] == 0)
18236 /* The AArch64 and ARM architectures define mapping symbols
18237 (eg $d, $x, $t) which we want to ignore. */
18238 if (strtab
[sym
->st_name
] == '$'
18239 && strtab
[sym
->st_name
+ 1] != 0
18240 && strtab
[sym
->st_name
+ 2] == 0)
18245 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18246 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18247 FUNC symbols entirely. */
18248 switch (ELF_ST_TYPE (sym
->st_info
))
18255 /* If the symbol has a size associated
18256 with it then we can stop searching. */
18257 sym
= symtab
+ nsyms
;
18262 /* Ignore function symbols. */
18269 switch (ELF_ST_BIND (sym
->st_info
))
18272 if (saved_sym
== NULL
18273 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18278 if (saved_sym
== NULL
)
18288 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18296 if (saved_sym
&& pname
)
18297 * pname
= strtab
+ saved_sym
->st_name
;
18302 /* Returns true iff addr1 and addr2 are in the same section. */
18305 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18307 Elf_Internal_Shdr
* a1
;
18308 Elf_Internal_Shdr
* a2
;
18310 a1
= find_section_by_address (filedata
, addr1
);
18311 a2
= find_section_by_address (filedata
, addr2
);
18313 return a1
== a2
&& a1
!= NULL
;
18317 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18318 Filedata
* filedata
)
18320 static unsigned long global_offset
= 0;
18321 static unsigned long global_end
= 0;
18322 static unsigned long func_offset
= 0;
18323 static unsigned long func_end
= 0;
18325 Elf_Internal_Sym
* sym
;
18327 unsigned long start
;
18329 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18331 switch (pnote
->descsz
)
18334 /* A zero-length description means that the range of
18335 the previous note of the same type should be used. */
18338 if (global_end
> global_offset
)
18339 printf (_(" Applies to region from %#lx to %#lx\n"),
18340 global_offset
, global_end
);
18342 printf (_(" Applies to region from %#lx\n"), global_offset
);
18346 if (func_end
> func_offset
)
18347 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18349 printf (_(" Applies to region from %#lx\n"), func_offset
);
18354 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18361 /* FIXME: We should check that version 3+ notes are being used here... */
18362 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18363 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18367 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18373 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18374 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18378 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18379 printf (_(" <invalid descsz>"));
18384 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18385 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18386 in order to avoid them being confused with the start address of the
18387 first function in the file... */
18388 if (sym
== NULL
&& is_open_attr
)
18389 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18392 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18393 end
= start
+ sym
->st_size
;
18397 /* FIXME: Need to properly allow for section alignment.
18398 16 is just the alignment used on x86_64. */
18400 && start
> BFD_ALIGN (global_end
, 16)
18401 /* Build notes are not guaranteed to be organised in order of
18402 increasing address, but we should find the all of the notes
18403 for one section in the same place. */
18404 && same_section (filedata
, start
, global_end
))
18405 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18406 global_end
+ 1, start
- 1);
18408 printf (_(" Applies to region from %#lx"), start
);
18409 global_offset
= start
;
18413 printf (_(" to %#lx"), end
);
18419 printf (_(" Applies to region from %#lx"), start
);
18420 func_offset
= start
;
18424 printf (_(" to %#lx"), end
);
18430 printf (_(" (%s)"), name
);
18437 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18439 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18440 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18441 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18443 char name_attribute
;
18444 const char * expected_types
;
18445 const char * name
= pnote
->namedata
;
18449 if (name
== NULL
|| pnote
->namesz
< 2)
18451 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18452 print_symbol (-20, _(" <corrupt name>"));
18461 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18462 if (name
[0] == 'G' && name
[1] == 'A')
18464 if (pnote
->namesz
< 4)
18466 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18467 print_symbol (-20, _(" <corrupt name>"));
18476 switch ((name_type
= * name
))
18478 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18479 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18480 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18481 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18482 printf ("%c", * name
);
18486 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
18487 print_symbol (-20, _("<unknown name type>"));
18494 switch ((name_attribute
= * name
))
18496 case GNU_BUILD_ATTRIBUTE_VERSION
:
18497 text
= _("<version>");
18498 expected_types
= string_expected
;
18501 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18502 text
= _("<stack prot>");
18503 expected_types
= "!+*";
18506 case GNU_BUILD_ATTRIBUTE_RELRO
:
18507 text
= _("<relro>");
18508 expected_types
= bool_expected
;
18511 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
18512 text
= _("<stack size>");
18513 expected_types
= number_expected
;
18516 case GNU_BUILD_ATTRIBUTE_TOOL
:
18517 text
= _("<tool>");
18518 expected_types
= string_expected
;
18521 case GNU_BUILD_ATTRIBUTE_ABI
:
18523 expected_types
= "$*";
18526 case GNU_BUILD_ATTRIBUTE_PIC
:
18528 expected_types
= number_expected
;
18531 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
18532 text
= _("<short enum>");
18533 expected_types
= bool_expected
;
18537 if (ISPRINT (* name
))
18539 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
18541 if (len
> left
&& ! do_wide
)
18543 printf ("%.*s:", len
, name
);
18549 static char tmpbuf
[128];
18551 error (_("unrecognised byte in name field: %d\n"), * name
);
18552 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
18556 expected_types
= "*$!+";
18561 left
-= printf ("%s", text
);
18563 if (strchr (expected_types
, name_type
) == NULL
)
18564 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
18566 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
18568 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18569 (unsigned long) pnote
->namesz
,
18570 (long) (name
- pnote
->namedata
));
18574 if (left
< 1 && ! do_wide
)
18579 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18581 unsigned int bytes
;
18582 unsigned long long val
= 0;
18583 unsigned int shift
= 0;
18584 char * decoded
= NULL
;
18586 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
18588 /* The -1 is because the name field is always 0 terminated, and we
18589 want to be able to ensure that the shift in the while loop below
18590 will not overflow. */
18593 if (bytes
> sizeof (val
))
18595 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18597 bytes
= sizeof (val
);
18599 /* We do not bother to warn if bytes == 0 as this can
18600 happen with some early versions of the gcc plugin. */
18604 unsigned long byte
= (* name
++) & 0xff;
18606 val
|= byte
<< shift
;
18610 switch (name_attribute
)
18612 case GNU_BUILD_ATTRIBUTE_PIC
:
18615 case 0: decoded
= "static"; break;
18616 case 1: decoded
= "pic"; break;
18617 case 2: decoded
= "PIC"; break;
18618 case 3: decoded
= "pie"; break;
18619 case 4: decoded
= "PIE"; break;
18623 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18626 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18627 case 0: decoded
= "off"; break;
18628 case 1: decoded
= "on"; break;
18629 case 2: decoded
= "all"; break;
18630 case 3: decoded
= "strong"; break;
18631 case 4: decoded
= "explicit"; break;
18639 if (decoded
!= NULL
)
18641 print_symbol (-left
, decoded
);
18652 left
-= printf ("0x%llx", val
);
18654 left
-= printf ("0x%-.*llx", left
, val
);
18658 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18659 left
-= print_symbol (- left
, name
);
18661 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18662 left
-= print_symbol (- left
, "true");
18664 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18665 left
-= print_symbol (- left
, "false");
18669 if (do_wide
&& left
> 0)
18670 printf ("%-*s", left
, " ");
18675 /* Note that by the ELF standard, the name field is already null byte
18676 terminated, and namesz includes the terminating null byte.
18677 I.E. the value of namesz for the name "FSF" is 4.
18679 If the value of namesz is zero, there is no name present. */
18682 process_note (Elf_Internal_Note
* pnote
,
18683 Filedata
* filedata
)
18685 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
18688 if (pnote
->namesz
== 0)
18689 /* If there is no note name, then use the default set of
18690 note type strings. */
18691 nt
= get_note_type (filedata
, pnote
->type
);
18693 else if (const_strneq (pnote
->namedata
, "GNU"))
18694 /* GNU-specific object file notes. */
18695 nt
= get_gnu_elf_note_type (pnote
->type
);
18697 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
18698 /* FreeBSD-specific core file notes. */
18699 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
18701 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
18702 /* NetBSD-specific core file notes. */
18703 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
18705 else if (const_strneq (pnote
->namedata
, "NetBSD"))
18706 /* NetBSD-specific core file notes. */
18707 return process_netbsd_elf_note (pnote
);
18709 else if (strneq (pnote
->namedata
, "SPU/", 4))
18711 /* SPU-specific core file notes. */
18712 nt
= pnote
->namedata
+ 4;
18716 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18717 /* VMS/ia64-specific file notes. */
18718 nt
= get_ia64_vms_note_type (pnote
->type
);
18720 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18721 nt
= get_stapsdt_note_type (pnote
->type
);
18724 /* Don't recognize this note name; just use the default set of
18725 note type strings. */
18726 nt
= get_note_type (filedata
, pnote
->type
);
18730 if (((const_strneq (pnote
->namedata
, "GA")
18731 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18732 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18733 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18734 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18735 print_gnu_build_attribute_name (pnote
);
18737 print_symbol (-20, name
);
18740 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
18742 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
18744 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18745 return print_ia64_vms_note (pnote
);
18746 else if (const_strneq (pnote
->namedata
, "GNU"))
18747 return print_gnu_note (filedata
, pnote
);
18748 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18749 return print_stapsdt_note (pnote
);
18750 else if (const_strneq (pnote
->namedata
, "CORE"))
18751 return print_core_note (pnote
);
18752 else if (((const_strneq (pnote
->namedata
, "GA")
18753 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18754 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18755 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18756 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18757 return print_gnu_build_attribute_description (pnote
, filedata
);
18763 printf (_(" description data: "));
18764 for (i
= 0; i
< pnote
->descsz
; i
++)
18765 printf ("%02x ", pnote
->descdata
[i
]);
18777 process_notes_at (Filedata
* filedata
,
18778 Elf_Internal_Shdr
* section
,
18783 Elf_External_Note
* pnotes
;
18784 Elf_External_Note
* external
;
18786 bfd_boolean res
= TRUE
;
18793 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18796 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18801 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18804 if (pnotes
== NULL
)
18810 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18812 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18813 (unsigned long) offset
, (unsigned long) length
);
18815 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18816 specifies that notes should be aligned to 4 bytes in 32-bit
18817 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18818 we also support 4 byte alignment in 64-bit objects. If section
18819 alignment is less than 4, we treate alignment as 4 bytes. */
18822 else if (align
!= 4 && align
!= 8)
18824 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18829 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18831 end
= (char *) pnotes
+ length
;
18832 while ((char *) external
< end
)
18834 Elf_Internal_Note inote
;
18837 char * temp
= NULL
;
18838 size_t data_remaining
= end
- (char *) external
;
18840 if (!is_ia64_vms (filedata
))
18842 /* PR binutils/15191
18843 Make sure that there is enough data to read. */
18844 min_notesz
= offsetof (Elf_External_Note
, name
);
18845 if (data_remaining
< min_notesz
)
18847 warn (ngettext ("Corrupt note: only %ld byte remains, "
18848 "not enough for a full note\n",
18849 "Corrupt note: only %ld bytes remain, "
18850 "not enough for a full note\n",
18852 (long) data_remaining
);
18855 data_remaining
-= min_notesz
;
18857 inote
.type
= BYTE_GET (external
->type
);
18858 inote
.namesz
= BYTE_GET (external
->namesz
);
18859 inote
.namedata
= external
->name
;
18860 inote
.descsz
= BYTE_GET (external
->descsz
);
18861 inote
.descdata
= ((char *) external
18862 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18863 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18864 next
= ((char *) external
18865 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18869 Elf64_External_VMS_Note
*vms_external
;
18871 /* PR binutils/15191
18872 Make sure that there is enough data to read. */
18873 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18874 if (data_remaining
< min_notesz
)
18876 warn (ngettext ("Corrupt note: only %ld byte remains, "
18877 "not enough for a full note\n",
18878 "Corrupt note: only %ld bytes remain, "
18879 "not enough for a full note\n",
18881 (long) data_remaining
);
18884 data_remaining
-= min_notesz
;
18886 vms_external
= (Elf64_External_VMS_Note
*) external
;
18887 inote
.type
= BYTE_GET (vms_external
->type
);
18888 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18889 inote
.namedata
= vms_external
->name
;
18890 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18891 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18892 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18893 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18896 /* PR 17531: file: 3443835e. */
18897 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18898 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18899 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18900 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18901 || ((size_t) (next
- inote
.descdata
)
18902 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18904 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18905 (unsigned long) ((char *) external
- (char *) pnotes
));
18906 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18907 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18911 external
= (Elf_External_Note
*) next
;
18913 /* Verify that name is null terminated. It appears that at least
18914 one version of Linux (RedHat 6.0) generates corefiles that don't
18915 comply with the ELF spec by failing to include the null byte in
18917 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
18919 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18921 temp
= (char *) malloc (inote
.namesz
+ 1);
18924 error (_("Out of memory allocating space for inote name\n"));
18929 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18930 inote
.namedata
= temp
;
18932 inote
.namedata
[inote
.namesz
] = 0;
18935 if (! process_note (& inote
, filedata
))
18951 process_corefile_note_segments (Filedata
* filedata
)
18953 Elf_Internal_Phdr
* segment
;
18955 bfd_boolean res
= TRUE
;
18957 if (! get_program_headers (filedata
))
18960 for (i
= 0, segment
= filedata
->program_headers
;
18961 i
< filedata
->file_header
.e_phnum
;
18964 if (segment
->p_type
== PT_NOTE
)
18965 if (! process_notes_at (filedata
, NULL
,
18966 (bfd_vma
) segment
->p_offset
,
18967 (bfd_vma
) segment
->p_filesz
,
18968 (bfd_vma
) segment
->p_align
))
18976 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18978 Elf_External_Note
* pnotes
;
18979 Elf_External_Note
* external
;
18981 bfd_boolean res
= TRUE
;
18986 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18988 if (pnotes
== NULL
)
18992 end
= (char*) pnotes
+ length
;
18994 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18995 (unsigned long) offset
, (unsigned long) length
);
18997 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18999 Elf_External_Note
* next
;
19000 Elf_Internal_Note inote
;
19002 inote
.type
= BYTE_GET (external
->type
);
19003 inote
.namesz
= BYTE_GET (external
->namesz
);
19004 inote
.namedata
= external
->name
;
19005 inote
.descsz
= BYTE_GET (external
->descsz
);
19006 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19007 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19009 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19011 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19012 inote
.descdata
= inote
.namedata
;
19016 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19018 if ( ((char *) next
> end
)
19019 || ((char *) next
< (char *) pnotes
))
19021 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19022 (unsigned long) ((char *) external
- (char *) pnotes
));
19023 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19024 inote
.type
, inote
.namesz
, inote
.descsz
);
19030 /* Prevent out-of-bounds indexing. */
19031 if ( inote
.namedata
+ inote
.namesz
> end
19032 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19034 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19035 (unsigned long) ((char *) external
- (char *) pnotes
));
19036 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19037 inote
.type
, inote
.namesz
, inote
.descsz
);
19041 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19043 if (! print_v850_note (& inote
))
19046 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19047 inote
.namesz
, inote
.descsz
);
19057 process_note_sections (Filedata
* filedata
)
19059 Elf_Internal_Shdr
* section
;
19061 unsigned int n
= 0;
19062 bfd_boolean res
= TRUE
;
19064 for (i
= 0, section
= filedata
->section_headers
;
19065 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19068 if (section
->sh_type
== SHT_NOTE
)
19070 if (! process_notes_at (filedata
, section
,
19071 (bfd_vma
) section
->sh_offset
,
19072 (bfd_vma
) section
->sh_size
,
19073 (bfd_vma
) section
->sh_addralign
))
19078 if (( filedata
->file_header
.e_machine
== EM_V800
19079 || filedata
->file_header
.e_machine
== EM_V850
19080 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19081 && section
->sh_type
== SHT_RENESAS_INFO
)
19083 if (! process_v850_notes (filedata
,
19084 (bfd_vma
) section
->sh_offset
,
19085 (bfd_vma
) section
->sh_size
))
19092 /* Try processing NOTE segments instead. */
19093 return process_corefile_note_segments (filedata
);
19099 process_notes (Filedata
* filedata
)
19101 /* If we have not been asked to display the notes then do nothing. */
19105 if (filedata
->file_header
.e_type
!= ET_CORE
)
19106 return process_note_sections (filedata
);
19108 /* No program headers means no NOTE segment. */
19109 if (filedata
->file_header
.e_phnum
> 0)
19110 return process_corefile_note_segments (filedata
);
19112 printf (_("No note segments present in the core file.\n"));
19116 static unsigned char *
19117 display_public_gnu_attributes (unsigned char * start
,
19118 const unsigned char * const end
)
19120 printf (_(" Unknown GNU attribute: %s\n"), start
);
19122 start
+= strnlen ((char *) start
, end
- start
);
19123 display_raw_attribute (start
, end
);
19125 return (unsigned char *) end
;
19128 static unsigned char *
19129 display_generic_attribute (unsigned char * start
,
19131 const unsigned char * const end
)
19134 return (unsigned char *) end
;
19136 return display_tag_value (tag
, start
, end
);
19140 process_arch_specific (Filedata
* filedata
)
19145 switch (filedata
->file_header
.e_machine
)
19148 case EM_ARC_COMPACT
:
19149 case EM_ARC_COMPACT2
:
19150 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19151 display_arc_attribute
,
19152 display_generic_attribute
);
19154 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19155 display_arm_attribute
,
19156 display_generic_attribute
);
19159 case EM_MIPS_RS3_LE
:
19160 return process_mips_specific (filedata
);
19163 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19164 display_msp430x_attribute
,
19165 display_generic_attribute
);
19168 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19169 display_riscv_attribute
,
19170 display_generic_attribute
);
19173 return process_nds32_specific (filedata
);
19177 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19178 display_power_gnu_attribute
);
19182 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19183 display_s390_gnu_attribute
);
19186 case EM_SPARC32PLUS
:
19188 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19189 display_sparc_gnu_attribute
);
19192 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19193 display_tic6x_attribute
,
19194 display_generic_attribute
);
19197 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19198 display_public_gnu_attributes
,
19199 display_generic_attribute
);
19204 get_file_header (Filedata
* filedata
)
19206 /* Read in the identity array. */
19207 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19210 /* Determine how to read the rest of the header. */
19211 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19216 byte_get
= byte_get_little_endian
;
19217 byte_put
= byte_put_little_endian
;
19220 byte_get
= byte_get_big_endian
;
19221 byte_put
= byte_put_big_endian
;
19225 /* For now we only support 32 bit and 64 bit ELF files. */
19226 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19228 /* Read in the rest of the header. */
19231 Elf32_External_Ehdr ehdr32
;
19233 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19236 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19237 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19238 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19239 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19240 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19241 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19242 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19243 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19244 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19245 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19246 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19247 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19248 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19252 Elf64_External_Ehdr ehdr64
;
19254 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19255 we will not be able to cope with the 64bit data found in
19256 64 ELF files. Detect this now and abort before we start
19257 overwriting things. */
19258 if (sizeof (bfd_vma
) < 8)
19260 error (_("This instance of readelf has been built without support for a\n\
19261 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19265 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19268 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19269 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19270 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19271 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19272 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19273 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19274 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19275 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19276 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19277 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19278 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19279 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19280 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19283 if (filedata
->file_header
.e_shoff
)
19285 /* There may be some extensions in the first section header. Don't
19286 bomb if we can't read it. */
19288 get_32bit_section_headers (filedata
, TRUE
);
19290 get_64bit_section_headers (filedata
, TRUE
);
19297 close_file (Filedata
* filedata
)
19301 if (filedata
->handle
)
19302 fclose (filedata
->handle
);
19308 close_debug_file (void * data
)
19310 close_file ((Filedata
*) data
);
19314 open_file (const char * pathname
)
19316 struct stat statbuf
;
19317 Filedata
* filedata
= NULL
;
19319 if (stat (pathname
, & statbuf
) < 0
19320 || ! S_ISREG (statbuf
.st_mode
))
19323 filedata
= calloc (1, sizeof * filedata
);
19324 if (filedata
== NULL
)
19327 filedata
->handle
= fopen (pathname
, "rb");
19328 if (filedata
->handle
== NULL
)
19331 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19332 filedata
->file_name
= pathname
;
19334 if (! get_file_header (filedata
))
19337 if (filedata
->file_header
.e_shoff
)
19341 /* Read the section headers again, this time for real. */
19343 res
= get_32bit_section_headers (filedata
, FALSE
);
19345 res
= get_64bit_section_headers (filedata
, FALSE
);
19356 if (filedata
->handle
)
19357 fclose (filedata
->handle
);
19364 open_debug_file (const char * pathname
)
19366 return open_file (pathname
);
19369 /* Process one ELF object file according to the command line options.
19370 This file may actually be stored in an archive. The file is
19371 positioned at the start of the ELF object. Returns TRUE if no
19372 problems were encountered, FALSE otherwise. */
19375 process_object (Filedata
* filedata
)
19377 bfd_boolean have_separate_files
;
19379 bfd_boolean res
= TRUE
;
19381 if (! get_file_header (filedata
))
19383 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19387 /* Initialise per file variables. */
19388 for (i
= ARRAY_SIZE (version_info
); i
--;)
19389 version_info
[i
] = 0;
19391 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19392 dynamic_info
[i
] = 0;
19393 dynamic_info_DT_GNU_HASH
= 0;
19395 /* Process the file. */
19397 printf (_("\nFile: %s\n"), filedata
->file_name
);
19399 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19400 Note we do this even if cmdline_dump_sects is empty because we
19401 must make sure that the dump_sets array is zeroed out before each
19402 object file is processed. */
19403 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19404 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19406 if (cmdline
.num_dump_sects
> 0)
19408 if (filedata
->num_dump_sects
== 0)
19409 /* A sneaky way of allocating the dump_sects array. */
19410 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19412 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19413 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19414 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19417 if (! process_file_header (filedata
))
19420 if (! process_section_headers (filedata
))
19422 /* Without loaded section headers we cannot process lots of things. */
19423 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19425 if (! do_using_dynamic
)
19426 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19429 if (! process_section_groups (filedata
))
19430 /* Without loaded section groups we cannot process unwind. */
19433 if (process_program_headers (filedata
))
19434 process_dynamic_section (filedata
);
19438 if (! process_relocs (filedata
))
19441 if (! process_unwind (filedata
))
19444 if (! process_symbol_table (filedata
))
19447 if (! process_syminfo (filedata
))
19450 if (! process_version_sections (filedata
))
19453 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19454 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
19456 have_separate_files
= FALSE
;
19458 if (! process_section_contents (filedata
))
19461 if (have_separate_files
)
19465 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
19467 if (! process_section_headers (d
->handle
))
19469 else if (! process_section_contents (d
->handle
))
19473 /* The file handles are closed by the call to free_debug_memory() below. */
19476 if (! process_notes (filedata
))
19479 if (! process_gnu_liblist (filedata
))
19482 if (! process_arch_specific (filedata
))
19485 free (filedata
->program_headers
);
19486 filedata
->program_headers
= NULL
;
19488 free (filedata
->section_headers
);
19489 filedata
->section_headers
= NULL
;
19491 free (filedata
->string_table
);
19492 filedata
->string_table
= NULL
;
19493 filedata
->string_table_length
= 0;
19495 if (dynamic_strings
)
19497 free (dynamic_strings
);
19498 dynamic_strings
= NULL
;
19499 dynamic_strings_length
= 0;
19502 if (dynamic_symbols
)
19504 free (dynamic_symbols
);
19505 dynamic_symbols
= NULL
;
19506 num_dynamic_syms
= 0;
19509 if (dynamic_syminfo
)
19511 free (dynamic_syminfo
);
19512 dynamic_syminfo
= NULL
;
19515 if (dynamic_section
)
19517 free (dynamic_section
);
19518 dynamic_section
= NULL
;
19521 if (section_headers_groups
)
19523 free (section_headers_groups
);
19524 section_headers_groups
= NULL
;
19527 if (section_groups
)
19529 struct group_list
* g
;
19530 struct group_list
* next
;
19532 for (i
= 0; i
< group_count
; i
++)
19534 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
19541 free (section_groups
);
19542 section_groups
= NULL
;
19545 free_debug_memory ();
19550 /* Process an ELF archive.
19551 On entry the file is positioned just after the ARMAG string.
19552 Returns TRUE upon success, FALSE otherwise. */
19555 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
19557 struct archive_info arch
;
19558 struct archive_info nested_arch
;
19560 bfd_boolean ret
= TRUE
;
19564 /* The ARCH structure is used to hold information about this archive. */
19565 arch
.file_name
= NULL
;
19567 arch
.index_array
= NULL
;
19568 arch
.sym_table
= NULL
;
19569 arch
.longnames
= NULL
;
19571 /* The NESTED_ARCH structure is used as a single-item cache of information
19572 about a nested archive (when members of a thin archive reside within
19573 another regular archive file). */
19574 nested_arch
.file_name
= NULL
;
19575 nested_arch
.file
= NULL
;
19576 nested_arch
.index_array
= NULL
;
19577 nested_arch
.sym_table
= NULL
;
19578 nested_arch
.longnames
= NULL
;
19580 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
19581 is_thin_archive
, do_archive_index
) != 0)
19587 if (do_archive_index
)
19589 if (arch
.sym_table
== NULL
)
19590 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
19593 unsigned long i
, l
;
19594 unsigned long current_pos
;
19596 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19597 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
19599 current_pos
= ftell (filedata
->handle
);
19601 for (i
= l
= 0; i
< arch
.index_num
; i
++)
19603 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
19605 char * member_name
;
19607 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
19609 if (member_name
!= NULL
)
19611 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
19613 if (qualified_name
!= NULL
)
19615 printf (_("Contents of binary %s at offset "), qualified_name
);
19616 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
19618 free (qualified_name
);
19623 if (l
>= arch
.sym_size
)
19625 error (_("%s: end of the symbol table reached before the end of the index\n"),
19626 filedata
->file_name
);
19630 /* PR 17531: file: 0b6630b2. */
19631 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
19632 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
19635 if (arch
.uses_64bit_indices
)
19640 if (l
< arch
.sym_size
)
19642 error (ngettext ("%s: %ld byte remains in the symbol table, "
19643 "but without corresponding entries in "
19644 "the index table\n",
19645 "%s: %ld bytes remain in the symbol table, "
19646 "but without corresponding entries in "
19647 "the index table\n",
19648 arch
.sym_size
- l
),
19649 filedata
->file_name
, arch
.sym_size
- l
);
19653 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
19655 error (_("%s: failed to seek back to start of object files in the archive\n"),
19656 filedata
->file_name
);
19662 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
19663 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
19664 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
19665 && !do_section_groups
&& !do_dyn_syms
)
19667 ret
= TRUE
; /* Archive index only. */
19676 char * qualified_name
;
19678 /* Read the next archive header. */
19679 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
19681 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
19684 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
19685 if (got
!= sizeof arch
.arhdr
)
19689 /* PR 24049 - we cannot use filedata->file_name as this will
19690 have already been freed. */
19691 error (_("%s: failed to read archive header\n"), arch
.file_name
);
19696 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
19698 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
19703 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
19705 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
19706 if (archive_file_size
& 01)
19707 ++archive_file_size
;
19709 name
= get_archive_member_name (&arch
, &nested_arch
);
19712 error (_("%s: bad archive file name\n"), arch
.file_name
);
19716 namelen
= strlen (name
);
19718 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
19719 if (qualified_name
== NULL
)
19721 error (_("%s: bad archive file name\n"), arch
.file_name
);
19726 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
19728 /* This is a proxy for an external member of a thin archive. */
19729 Filedata
* member_filedata
;
19730 char * member_file_name
= adjust_relative_path
19731 (filedata
->file_name
, name
, namelen
);
19733 if (member_file_name
== NULL
)
19739 member_filedata
= open_file (member_file_name
);
19740 if (member_filedata
== NULL
)
19742 error (_("Input file '%s' is not readable.\n"), member_file_name
);
19743 free (member_file_name
);
19748 archive_file_offset
= arch
.nested_member_origin
;
19749 member_filedata
->file_name
= qualified_name
;
19751 if (! process_object (member_filedata
))
19754 close_file (member_filedata
);
19755 free (member_file_name
);
19757 else if (is_thin_archive
)
19759 Filedata thin_filedata
;
19761 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
19763 /* PR 15140: Allow for corrupt thin archives. */
19764 if (nested_arch
.file
== NULL
)
19766 error (_("%s: contains corrupt thin archive: %s\n"),
19767 qualified_name
, name
);
19772 /* This is a proxy for a member of a nested archive. */
19773 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19775 /* The nested archive file will have been opened and setup by
19776 get_archive_member_name. */
19777 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19779 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19784 thin_filedata
.handle
= nested_arch
.file
;
19785 thin_filedata
.file_name
= qualified_name
;
19787 if (! process_object (& thin_filedata
))
19792 archive_file_offset
= arch
.next_arhdr_offset
;
19793 arch
.next_arhdr_offset
+= archive_file_size
;
19795 filedata
->file_name
= qualified_name
;
19796 if (! process_object (filedata
))
19800 if (filedata
->dump_sects
!= NULL
)
19802 free (filedata
->dump_sects
);
19803 filedata
->dump_sects
= NULL
;
19804 filedata
->num_dump_sects
= 0;
19807 free (qualified_name
);
19811 if (nested_arch
.file
!= NULL
)
19812 fclose (nested_arch
.file
);
19813 release_archive (&nested_arch
);
19814 release_archive (&arch
);
19820 process_file (char * file_name
)
19822 Filedata
* filedata
= NULL
;
19823 struct stat statbuf
;
19824 char armag
[SARMAG
];
19825 bfd_boolean ret
= TRUE
;
19827 if (stat (file_name
, &statbuf
) < 0)
19829 if (errno
== ENOENT
)
19830 error (_("'%s': No such file\n"), file_name
);
19832 error (_("Could not locate '%s'. System error message: %s\n"),
19833 file_name
, strerror (errno
));
19837 if (! S_ISREG (statbuf
.st_mode
))
19839 error (_("'%s' is not an ordinary file\n"), file_name
);
19843 filedata
= calloc (1, sizeof * filedata
);
19844 if (filedata
== NULL
)
19846 error (_("Out of memory allocating file data structure\n"));
19850 filedata
->file_name
= file_name
;
19851 filedata
->handle
= fopen (file_name
, "rb");
19852 if (filedata
->handle
== NULL
)
19854 error (_("Input file '%s' is not readable.\n"), file_name
);
19859 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19861 error (_("%s: Failed to read file's magic number\n"), file_name
);
19862 fclose (filedata
->handle
);
19867 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19869 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19871 if (! process_archive (filedata
, FALSE
))
19874 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19876 if ( ! process_archive (filedata
, TRUE
))
19881 if (do_archive_index
)
19882 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19885 rewind (filedata
->handle
);
19886 archive_file_size
= archive_file_offset
= 0;
19888 if (! process_object (filedata
))
19892 fclose (filedata
->handle
);
19898 #ifdef SUPPORT_DISASSEMBLY
19899 /* Needed by the i386 disassembler. For extra credit, someone could
19900 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19904 print_address (unsigned int addr
, FILE * outfile
)
19906 fprintf (outfile
,"0x%8.8x", addr
);
19909 /* Needed by the i386 disassembler. */
19912 db_task_printsym (unsigned int addr
)
19914 print_address (addr
, stderr
);
19919 main (int argc
, char ** argv
)
19923 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19924 setlocale (LC_MESSAGES
, "");
19926 #if defined (HAVE_SETLOCALE)
19927 setlocale (LC_CTYPE
, "");
19929 bindtextdomain (PACKAGE
, LOCALEDIR
);
19930 textdomain (PACKAGE
);
19932 expandargv (&argc
, &argv
);
19934 cmdline
.file_name
= "<cmdline>";
19935 parse_args (& cmdline
, argc
, argv
);
19937 if (optind
< (argc
- 1))
19939 else if (optind
>= argc
)
19941 warn (_("Nothing to do.\n"));
19946 while (optind
< argc
)
19947 if (! process_file (argv
[optind
++]))
19950 if (cmdline
.dump_sects
!= NULL
)
19951 free (cmdline
.dump_sects
);
19953 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;