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 chekers (eg valgrind, address sanitizer) by not
402 attempting to allocate memory when the read is bound to fail. */
403 if (amt
> filedata
->file_size
404 || offset
+ archive_file_offset
+ amt
> filedata
->file_size
)
407 error (_("Reading %s bytes extends past end of file for %s\n"),
408 bfd_vmatoa ("u", amt
), reason
);
412 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
415 error (_("Unable to seek to 0x%lx for %s\n"),
416 archive_file_offset
+ offset
, reason
);
423 /* Check for overflow. */
424 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
425 /* + 1 so that we can '\0' terminate invalid string table sections. */
426 mvar
= malloc ((size_t) amt
+ 1);
431 error (_("Out of memory allocating %s bytes for %s\n"),
432 bfd_vmatoa ("u", amt
), reason
);
436 ((char *) mvar
)[amt
] = '\0';
439 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
442 error (_("Unable to read in %s bytes of %s\n"),
443 bfd_vmatoa ("u", amt
), reason
);
452 /* Print a VMA value in the MODE specified.
453 Returns the number of characters displayed. */
456 print_vma (bfd_vma vma
, print_mode mode
)
468 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
475 return printf ("%5" BFD_VMA_FMT
"d", vma
);
481 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
484 return printf ("%" BFD_VMA_FMT
"d", vma
);
487 return printf ("%" BFD_VMA_FMT
"u", vma
);
490 /* FIXME: Report unrecognised mode ? */
495 /* Display a symbol on stdout. Handles the display of control characters and
496 multibye characters (assuming the host environment supports them).
498 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
500 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
501 padding as necessary.
503 Returns the number of emitted characters. */
506 print_symbol (signed int width
, const char *symbol
)
508 bfd_boolean extra_padding
= FALSE
;
509 signed int num_printed
= 0;
510 #ifdef HAVE_MBSTATE_T
513 unsigned int width_remaining
;
517 /* Keep the width positive. This helps the code below. */
519 extra_padding
= TRUE
;
525 /* Set the remaining width to a very large value.
526 This simplifies the code below. */
527 width_remaining
= INT_MAX
;
529 width_remaining
= width
;
531 #ifdef HAVE_MBSTATE_T
532 /* Initialise the multibyte conversion state. */
533 memset (& state
, 0, sizeof (state
));
536 while (width_remaining
)
539 const char c
= *symbol
++;
544 /* Do not print control characters directly as they can affect terminal
545 settings. Such characters usually appear in the names generated
546 by the assembler for local labels. */
549 if (width_remaining
< 2)
552 printf ("^%c", c
+ 0x40);
553 width_remaining
-= 2;
556 else if (ISPRINT (c
))
564 #ifdef HAVE_MBSTATE_T
567 /* Let printf do the hard work of displaying multibyte characters. */
568 printf ("%.1s", symbol
- 1);
572 #ifdef HAVE_MBSTATE_T
573 /* Try to find out how many bytes made up the character that was
574 just printed. Advance the symbol pointer past the bytes that
576 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
580 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
585 if (extra_padding
&& num_printed
< width
)
587 /* Fill in the remaining spaces. */
588 printf ("%-*s", width
- num_printed
, " ");
595 /* Returns a pointer to a static buffer containing a printable version of
596 the given section's name. Like print_symbol, except that it does not try
597 to print multibyte characters, it just interprets them as hex values. */
600 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
602 #define MAX_PRINT_SEC_NAME_LEN 128
603 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
604 const char * name
= SECTION_NAME (sec
);
605 char * buf
= sec_name_buf
;
607 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
609 while ((c
= * name
++) != 0)
620 else if (ISPRINT (c
))
627 static char hex
[17] = "0123456789ABCDEF";
632 * buf
++ = hex
[(c
& 0xf0) >> 4];
633 * buf
++ = hex
[c
& 0x0f];
647 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
649 if (ndx
>= filedata
->file_header
.e_shnum
)
650 return _("<corrupt>");
652 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
655 /* Return a pointer to section NAME, or NULL if no such section exists. */
657 static Elf_Internal_Shdr
*
658 find_section (Filedata
* filedata
, const char * name
)
662 if (filedata
->section_headers
== NULL
)
665 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
666 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
667 return filedata
->section_headers
+ i
;
672 /* Return a pointer to a section containing ADDR, or NULL if no such
675 static Elf_Internal_Shdr
*
676 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
680 if (filedata
->section_headers
== NULL
)
683 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
685 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
687 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
694 static Elf_Internal_Shdr
*
695 find_section_by_type (Filedata
* filedata
, unsigned int type
)
699 if (filedata
->section_headers
== NULL
)
702 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
704 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
706 if (sec
->sh_type
== type
)
713 /* Return a pointer to section NAME, or NULL if no such section exists,
714 restricted to the list of sections given in SET. */
716 static Elf_Internal_Shdr
*
717 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
721 if (filedata
->section_headers
== NULL
)
726 while ((i
= *set
++) > 0)
728 /* See PR 21156 for a reproducer. */
729 if (i
>= filedata
->file_header
.e_shnum
)
730 continue; /* FIXME: Should we issue an error message ? */
732 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
733 return filedata
->section_headers
+ i
;
737 return find_section (filedata
, name
);
740 /* Read an unsigned LEB128 encoded value from DATA.
741 Set *LENGTH_RETURN to the number of bytes read. */
743 static inline unsigned long
744 read_uleb128 (unsigned char * data
,
745 unsigned int * length_return
,
746 const unsigned char * const end
)
748 return read_leb128 (data
, length_return
, FALSE
, end
);
751 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
752 This OS has so many departures from the ELF standard that we test it at
755 static inline bfd_boolean
756 is_ia64_vms (Filedata
* filedata
)
758 return filedata
->file_header
.e_machine
== EM_IA_64
759 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
762 /* Guess the relocation size commonly used by the specific machines. */
765 guess_is_rela (unsigned int e_machine
)
769 /* Targets that use REL relocations. */
785 /* Targets that use RELA relocations. */
789 case EM_ADAPTEVA_EPIPHANY
:
791 case EM_ALTERA_NIOS2
:
794 case EM_ARC_COMPACT2
:
815 case EM_LATTICEMICO32
:
824 case EM_CYGNUS_MN10200
:
826 case EM_CYGNUS_MN10300
:
862 case EM_MICROBLAZE_OLD
:
884 warn (_("Don't know about relocations on this machine architecture\n"));
889 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
890 Returns TRUE upon success, FALSE otherwise. If successful then a
891 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
892 and the number of relocs loaded is placed in *NRELASP. It is the caller's
893 responsibility to free the allocated buffer. */
896 slurp_rela_relocs (Filedata
* filedata
,
897 unsigned long rel_offset
,
898 unsigned long rel_size
,
899 Elf_Internal_Rela
** relasp
,
900 unsigned long * nrelasp
)
902 Elf_Internal_Rela
* relas
;
908 Elf32_External_Rela
* erelas
;
910 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
911 rel_size
, _("32-bit relocation data"));
915 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
917 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
918 sizeof (Elf_Internal_Rela
));
923 error (_("out of memory parsing relocs\n"));
927 for (i
= 0; i
< nrelas
; i
++)
929 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
930 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
931 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
938 Elf64_External_Rela
* erelas
;
940 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
941 rel_size
, _("64-bit relocation data"));
945 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
947 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
948 sizeof (Elf_Internal_Rela
));
953 error (_("out of memory parsing relocs\n"));
957 for (i
= 0; i
< nrelas
; i
++)
959 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
960 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
961 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
963 /* The #ifdef BFD64 below is to prevent a compile time
964 warning. We know that if we do not have a 64 bit data
965 type that we will never execute this code anyway. */
967 if (filedata
->file_header
.e_machine
== EM_MIPS
968 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
970 /* In little-endian objects, r_info isn't really a
971 64-bit little-endian value: it has a 32-bit
972 little-endian symbol index followed by four
973 individual byte fields. Reorder INFO
975 bfd_vma inf
= relas
[i
].r_info
;
976 inf
= (((inf
& 0xffffffff) << 32)
977 | ((inf
>> 56) & 0xff)
978 | ((inf
>> 40) & 0xff00)
979 | ((inf
>> 24) & 0xff0000)
980 | ((inf
>> 8) & 0xff000000));
981 relas
[i
].r_info
= inf
;
994 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
995 Returns TRUE upon success, FALSE otherwise. If successful then a
996 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
997 and the number of relocs loaded is placed in *NRELSP. It is the caller's
998 responsibility to free the allocated buffer. */
1001 slurp_rel_relocs (Filedata
* filedata
,
1002 unsigned long rel_offset
,
1003 unsigned long rel_size
,
1004 Elf_Internal_Rela
** relsp
,
1005 unsigned long * nrelsp
)
1007 Elf_Internal_Rela
* rels
;
1013 Elf32_External_Rel
* erels
;
1015 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1016 rel_size
, _("32-bit relocation data"));
1020 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1022 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1027 error (_("out of memory parsing relocs\n"));
1031 for (i
= 0; i
< nrels
; i
++)
1033 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1034 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1035 rels
[i
].r_addend
= 0;
1042 Elf64_External_Rel
* erels
;
1044 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1045 rel_size
, _("64-bit relocation data"));
1049 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1051 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1056 error (_("out of memory parsing relocs\n"));
1060 for (i
= 0; i
< nrels
; i
++)
1062 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1063 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1064 rels
[i
].r_addend
= 0;
1066 /* The #ifdef BFD64 below is to prevent a compile time
1067 warning. We know that if we do not have a 64 bit data
1068 type that we will never execute this code anyway. */
1070 if (filedata
->file_header
.e_machine
== EM_MIPS
1071 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1073 /* In little-endian objects, r_info isn't really a
1074 64-bit little-endian value: it has a 32-bit
1075 little-endian symbol index followed by four
1076 individual byte fields. Reorder INFO
1078 bfd_vma inf
= rels
[i
].r_info
;
1079 inf
= (((inf
& 0xffffffff) << 32)
1080 | ((inf
>> 56) & 0xff)
1081 | ((inf
>> 40) & 0xff00)
1082 | ((inf
>> 24) & 0xff0000)
1083 | ((inf
>> 8) & 0xff000000));
1084 rels
[i
].r_info
= inf
;
1097 /* Returns the reloc type extracted from the reloc info field. */
1100 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1103 return ELF32_R_TYPE (reloc_info
);
1105 switch (filedata
->file_header
.e_machine
)
1108 /* Note: We assume that reloc_info has already been adjusted for us. */
1109 return ELF64_MIPS_R_TYPE (reloc_info
);
1112 return ELF64_R_TYPE_ID (reloc_info
);
1115 return ELF64_R_TYPE (reloc_info
);
1119 /* Return the symbol index extracted from the reloc info field. */
1122 get_reloc_symindex (bfd_vma reloc_info
)
1124 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1127 static inline bfd_boolean
1128 uses_msp430x_relocs (Filedata
* filedata
)
1131 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1132 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1133 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1134 /* TI compiler uses ELFOSABI_NONE. */
1135 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1138 /* Display the contents of the relocation data found at the specified
1142 dump_relocations (Filedata
* filedata
,
1143 unsigned long rel_offset
,
1144 unsigned long rel_size
,
1145 Elf_Internal_Sym
* symtab
,
1146 unsigned long nsyms
,
1148 unsigned long strtablen
,
1150 bfd_boolean is_dynsym
)
1153 Elf_Internal_Rela
* rels
;
1154 bfd_boolean res
= TRUE
;
1156 if (is_rela
== UNKNOWN
)
1157 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1161 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1166 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1175 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1177 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1182 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1184 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1192 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1194 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1199 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1201 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1205 for (i
= 0; i
< rel_size
; i
++)
1210 bfd_vma symtab_index
;
1213 offset
= rels
[i
].r_offset
;
1214 inf
= rels
[i
].r_info
;
1216 type
= get_reloc_type (filedata
, inf
);
1217 symtab_index
= get_reloc_symindex (inf
);
1221 printf ("%8.8lx %8.8lx ",
1222 (unsigned long) offset
& 0xffffffff,
1223 (unsigned long) inf
& 0xffffffff);
1227 #if BFD_HOST_64BIT_LONG
1229 ? "%16.16lx %16.16lx "
1230 : "%12.12lx %12.12lx ",
1232 #elif BFD_HOST_64BIT_LONG_LONG
1235 ? "%16.16llx %16.16llx "
1236 : "%12.12llx %12.12llx ",
1240 ? "%16.16I64x %16.16I64x "
1241 : "%12.12I64x %12.12I64x ",
1246 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1247 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1248 _bfd_int64_high (offset
),
1249 _bfd_int64_low (offset
),
1250 _bfd_int64_high (inf
),
1251 _bfd_int64_low (inf
));
1255 switch (filedata
->file_header
.e_machine
)
1262 rtype
= elf_aarch64_reloc_type (type
);
1266 case EM_CYGNUS_M32R
:
1267 rtype
= elf_m32r_reloc_type (type
);
1272 rtype
= elf_i386_reloc_type (type
);
1277 rtype
= elf_m68hc11_reloc_type (type
);
1281 rtype
= elf_s12z_reloc_type (type
);
1285 rtype
= elf_m68k_reloc_type (type
);
1289 rtype
= elf_i960_reloc_type (type
);
1294 rtype
= elf_avr_reloc_type (type
);
1297 case EM_OLD_SPARCV9
:
1298 case EM_SPARC32PLUS
:
1301 rtype
= elf_sparc_reloc_type (type
);
1305 rtype
= elf_spu_reloc_type (type
);
1309 rtype
= v800_reloc_type (type
);
1312 case EM_CYGNUS_V850
:
1313 rtype
= v850_reloc_type (type
);
1317 case EM_CYGNUS_D10V
:
1318 rtype
= elf_d10v_reloc_type (type
);
1322 case EM_CYGNUS_D30V
:
1323 rtype
= elf_d30v_reloc_type (type
);
1327 rtype
= elf_dlx_reloc_type (type
);
1331 rtype
= elf_sh_reloc_type (type
);
1335 case EM_CYGNUS_MN10300
:
1336 rtype
= elf_mn10300_reloc_type (type
);
1340 case EM_CYGNUS_MN10200
:
1341 rtype
= elf_mn10200_reloc_type (type
);
1345 case EM_CYGNUS_FR30
:
1346 rtype
= elf_fr30_reloc_type (type
);
1350 rtype
= elf_frv_reloc_type (type
);
1354 rtype
= elf_csky_reloc_type (type
);
1358 rtype
= elf_ft32_reloc_type (type
);
1362 rtype
= elf_mcore_reloc_type (type
);
1366 rtype
= elf_mmix_reloc_type (type
);
1370 rtype
= elf_moxie_reloc_type (type
);
1374 if (uses_msp430x_relocs (filedata
))
1376 rtype
= elf_msp430x_reloc_type (type
);
1381 rtype
= elf_msp430_reloc_type (type
);
1385 rtype
= elf_nds32_reloc_type (type
);
1389 rtype
= elf_ppc_reloc_type (type
);
1393 rtype
= elf_ppc64_reloc_type (type
);
1397 case EM_MIPS_RS3_LE
:
1398 rtype
= elf_mips_reloc_type (type
);
1402 rtype
= elf_riscv_reloc_type (type
);
1406 rtype
= elf_alpha_reloc_type (type
);
1410 rtype
= elf_arm_reloc_type (type
);
1414 case EM_ARC_COMPACT
:
1415 case EM_ARC_COMPACT2
:
1416 rtype
= elf_arc_reloc_type (type
);
1420 rtype
= elf_hppa_reloc_type (type
);
1426 rtype
= elf_h8_reloc_type (type
);
1430 rtype
= elf_or1k_reloc_type (type
);
1435 rtype
= elf_pj_reloc_type (type
);
1438 rtype
= elf_ia64_reloc_type (type
);
1442 rtype
= elf_cris_reloc_type (type
);
1446 rtype
= elf_i860_reloc_type (type
);
1452 rtype
= elf_x86_64_reloc_type (type
);
1456 rtype
= i370_reloc_type (type
);
1461 rtype
= elf_s390_reloc_type (type
);
1465 rtype
= elf_score_reloc_type (type
);
1469 rtype
= elf_xstormy16_reloc_type (type
);
1473 rtype
= elf_crx_reloc_type (type
);
1477 rtype
= elf_vax_reloc_type (type
);
1481 rtype
= elf_visium_reloc_type (type
);
1484 case EM_ADAPTEVA_EPIPHANY
:
1485 rtype
= elf_epiphany_reloc_type (type
);
1490 rtype
= elf_ip2k_reloc_type (type
);
1494 rtype
= elf_iq2000_reloc_type (type
);
1499 rtype
= elf_xtensa_reloc_type (type
);
1502 case EM_LATTICEMICO32
:
1503 rtype
= elf_lm32_reloc_type (type
);
1508 rtype
= elf_m32c_reloc_type (type
);
1512 rtype
= elf_mt_reloc_type (type
);
1516 rtype
= elf_bfin_reloc_type (type
);
1520 rtype
= elf_mep_reloc_type (type
);
1524 rtype
= elf_cr16_reloc_type (type
);
1528 case EM_MICROBLAZE_OLD
:
1529 rtype
= elf_microblaze_reloc_type (type
);
1533 rtype
= elf_rl78_reloc_type (type
);
1537 rtype
= elf_rx_reloc_type (type
);
1541 rtype
= elf_metag_reloc_type (type
);
1546 rtype
= elf_xc16x_reloc_type (type
);
1550 rtype
= elf_tic6x_reloc_type (type
);
1554 rtype
= elf_tilegx_reloc_type (type
);
1558 rtype
= elf_tilepro_reloc_type (type
);
1561 case EM_WEBASSEMBLY
:
1562 rtype
= elf_wasm32_reloc_type (type
);
1566 rtype
= elf_xgate_reloc_type (type
);
1569 case EM_ALTERA_NIOS2
:
1570 rtype
= elf_nios2_reloc_type (type
);
1574 rtype
= elf_pru_reloc_type (type
);
1578 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1579 rtype
= elf_nfp3200_reloc_type (type
);
1581 rtype
= elf_nfp_reloc_type (type
);
1586 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1588 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1590 if (filedata
->file_header
.e_machine
== EM_ALPHA
1592 && streq (rtype
, "R_ALPHA_LITUSE")
1595 switch (rels
[i
].r_addend
)
1597 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1598 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1599 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1600 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1601 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1602 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1603 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1604 default: rtype
= NULL
;
1608 printf (" (%s)", rtype
);
1612 printf (_("<unknown addend: %lx>"),
1613 (unsigned long) rels
[i
].r_addend
);
1617 else if (symtab_index
)
1619 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1621 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1626 Elf_Internal_Sym
* psym
;
1627 const char * version_string
;
1628 enum versioned_symbol_info sym_info
;
1629 unsigned short vna_other
;
1631 psym
= symtab
+ symtab_index
;
1634 = get_symbol_version_string (filedata
, is_dynsym
,
1643 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1647 unsigned int width
= is_32bit_elf
? 8 : 14;
1649 /* Relocations against GNU_IFUNC symbols do not use the value
1650 of the symbol as the address to relocate against. Instead
1651 they invoke the function named by the symbol and use its
1652 result as the address for relocation.
1654 To indicate this to the user, do not display the value of
1655 the symbol in the "Symbols's Value" field. Instead show
1656 its name followed by () as a hint that the symbol is
1660 || psym
->st_name
== 0
1661 || psym
->st_name
>= strtablen
)
1664 name
= strtab
+ psym
->st_name
;
1666 len
= print_symbol (width
, name
);
1668 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1670 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1674 print_vma (psym
->st_value
, LONG_HEX
);
1676 printf (is_32bit_elf
? " " : " ");
1679 if (psym
->st_name
== 0)
1681 const char * sec_name
= "<null>";
1684 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1686 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1687 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1688 else if (psym
->st_shndx
== SHN_ABS
)
1690 else if (psym
->st_shndx
== SHN_COMMON
)
1691 sec_name
= "COMMON";
1692 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1693 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1694 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1695 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1696 sec_name
= "SCOMMON";
1697 else if (filedata
->file_header
.e_machine
== EM_MIPS
1698 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1699 sec_name
= "SUNDEF";
1700 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1701 || filedata
->file_header
.e_machine
== EM_L1OM
1702 || filedata
->file_header
.e_machine
== EM_K1OM
)
1703 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1704 sec_name
= "LARGE_COMMON";
1705 else if (filedata
->file_header
.e_machine
== EM_IA_64
1706 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1707 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1708 sec_name
= "ANSI_COM";
1709 else if (is_ia64_vms (filedata
)
1710 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1711 sec_name
= "VMS_SYMVEC";
1714 sprintf (name_buf
, "<section 0x%x>",
1715 (unsigned int) psym
->st_shndx
);
1716 sec_name
= name_buf
;
1719 print_symbol (22, sec_name
);
1721 else if (strtab
== NULL
)
1722 printf (_("<string table index: %3ld>"), psym
->st_name
);
1723 else if (psym
->st_name
>= strtablen
)
1725 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1730 print_symbol (22, strtab
+ psym
->st_name
);
1732 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1738 bfd_vma off
= rels
[i
].r_addend
;
1740 if ((bfd_signed_vma
) off
< 0)
1741 printf (" - %" BFD_VMA_FMT
"x", - off
);
1743 printf (" + %" BFD_VMA_FMT
"x", off
);
1749 bfd_vma off
= rels
[i
].r_addend
;
1751 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1752 if ((bfd_signed_vma
) off
< 0)
1753 printf ("-%" BFD_VMA_FMT
"x", - off
);
1755 printf ("%" BFD_VMA_FMT
"x", off
);
1758 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1760 && streq (rtype
, "R_SPARC_OLO10"))
1761 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1766 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1768 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1769 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1770 const char * rtype2
= elf_mips_reloc_type (type2
);
1771 const char * rtype3
= elf_mips_reloc_type (type3
);
1773 printf (" Type2: ");
1776 printf (_("unrecognized: %-7lx"),
1777 (unsigned long) type2
& 0xffffffff);
1779 printf ("%-17.17s", rtype2
);
1781 printf ("\n Type3: ");
1784 printf (_("unrecognized: %-7lx"),
1785 (unsigned long) type3
& 0xffffffff);
1787 printf ("%-17.17s", rtype3
);
1800 get_mips_dynamic_type (unsigned long type
)
1804 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1805 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1806 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1807 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1808 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1809 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1810 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1811 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1812 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1813 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1814 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1815 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1816 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1817 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1818 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1819 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1820 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1821 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1822 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1823 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1824 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1825 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1826 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1827 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1828 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1829 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1830 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1831 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1832 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1833 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1834 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1835 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1836 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1837 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1838 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1839 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1840 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1841 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1842 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1843 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1844 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1845 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1846 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1847 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1848 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1849 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1856 get_sparc64_dynamic_type (unsigned long type
)
1860 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1867 get_ppc_dynamic_type (unsigned long type
)
1871 case DT_PPC_GOT
: return "PPC_GOT";
1872 case DT_PPC_OPT
: return "PPC_OPT";
1879 get_ppc64_dynamic_type (unsigned long type
)
1883 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1884 case DT_PPC64_OPD
: return "PPC64_OPD";
1885 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1886 case DT_PPC64_OPT
: return "PPC64_OPT";
1893 get_parisc_dynamic_type (unsigned long type
)
1897 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1898 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1899 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1900 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1901 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1902 case DT_HP_PREINIT
: return "HP_PREINIT";
1903 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1904 case DT_HP_NEEDED
: return "HP_NEEDED";
1905 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1906 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1907 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1908 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1909 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1910 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1911 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1912 case DT_HP_FILTERED
: return "HP_FILTERED";
1913 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1914 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1915 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1916 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1917 case DT_PLT
: return "PLT";
1918 case DT_PLT_SIZE
: return "PLT_SIZE";
1919 case DT_DLT
: return "DLT";
1920 case DT_DLT_SIZE
: return "DLT_SIZE";
1927 get_ia64_dynamic_type (unsigned long type
)
1931 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1932 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1933 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1934 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1935 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1936 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1937 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1938 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1939 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1940 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1941 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1942 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1943 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1944 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1945 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1946 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1947 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1948 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1949 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1950 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1951 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1952 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1953 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1954 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1955 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1956 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1957 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1958 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1959 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1960 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1961 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1968 get_solaris_section_type (unsigned long type
)
1972 case 0x6fffffee: return "SUNW_ancillary";
1973 case 0x6fffffef: return "SUNW_capchain";
1974 case 0x6ffffff0: return "SUNW_capinfo";
1975 case 0x6ffffff1: return "SUNW_symsort";
1976 case 0x6ffffff2: return "SUNW_tlssort";
1977 case 0x6ffffff3: return "SUNW_LDYNSYM";
1978 case 0x6ffffff4: return "SUNW_dof";
1979 case 0x6ffffff5: return "SUNW_cap";
1980 case 0x6ffffff6: return "SUNW_SIGNATURE";
1981 case 0x6ffffff7: return "SUNW_ANNOTATE";
1982 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1983 case 0x6ffffff9: return "SUNW_DEBUG";
1984 case 0x6ffffffa: return "SUNW_move";
1985 case 0x6ffffffb: return "SUNW_COMDAT";
1986 case 0x6ffffffc: return "SUNW_syminfo";
1987 case 0x6ffffffd: return "SUNW_verdef";
1988 case 0x6ffffffe: return "SUNW_verneed";
1989 case 0x6fffffff: return "SUNW_versym";
1990 case 0x70000000: return "SPARC_GOTDATA";
1991 default: return NULL
;
1996 get_alpha_dynamic_type (unsigned long type
)
2000 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2001 default: return NULL
;
2006 get_score_dynamic_type (unsigned long type
)
2010 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2011 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2012 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2013 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2014 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2015 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2016 default: return NULL
;
2021 get_tic6x_dynamic_type (unsigned long type
)
2025 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2026 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2027 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2028 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2029 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2030 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2031 default: return NULL
;
2036 get_nios2_dynamic_type (unsigned long type
)
2040 case DT_NIOS2_GP
: return "NIOS2_GP";
2041 default: return NULL
;
2046 get_solaris_dynamic_type (unsigned long type
)
2050 case 0x6000000d: return "SUNW_AUXILIARY";
2051 case 0x6000000e: return "SUNW_RTLDINF";
2052 case 0x6000000f: return "SUNW_FILTER";
2053 case 0x60000010: return "SUNW_CAP";
2054 case 0x60000011: return "SUNW_SYMTAB";
2055 case 0x60000012: return "SUNW_SYMSZ";
2056 case 0x60000013: return "SUNW_SORTENT";
2057 case 0x60000014: return "SUNW_SYMSORT";
2058 case 0x60000015: return "SUNW_SYMSORTSZ";
2059 case 0x60000016: return "SUNW_TLSSORT";
2060 case 0x60000017: return "SUNW_TLSSORTSZ";
2061 case 0x60000018: return "SUNW_CAPINFO";
2062 case 0x60000019: return "SUNW_STRPAD";
2063 case 0x6000001a: return "SUNW_CAPCHAIN";
2064 case 0x6000001b: return "SUNW_LDMACH";
2065 case 0x6000001d: return "SUNW_CAPCHAINENT";
2066 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2067 case 0x60000021: return "SUNW_PARENT";
2068 case 0x60000023: return "SUNW_ASLR";
2069 case 0x60000025: return "SUNW_RELAX";
2070 case 0x60000029: return "SUNW_NXHEAP";
2071 case 0x6000002b: return "SUNW_NXSTACK";
2073 case 0x70000001: return "SPARC_REGISTER";
2074 case 0x7ffffffd: return "AUXILIARY";
2075 case 0x7ffffffe: return "USED";
2076 case 0x7fffffff: return "FILTER";
2078 default: return NULL
;
2083 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2085 static char buff
[64];
2089 case DT_NULL
: return "NULL";
2090 case DT_NEEDED
: return "NEEDED";
2091 case DT_PLTRELSZ
: return "PLTRELSZ";
2092 case DT_PLTGOT
: return "PLTGOT";
2093 case DT_HASH
: return "HASH";
2094 case DT_STRTAB
: return "STRTAB";
2095 case DT_SYMTAB
: return "SYMTAB";
2096 case DT_RELA
: return "RELA";
2097 case DT_RELASZ
: return "RELASZ";
2098 case DT_RELAENT
: return "RELAENT";
2099 case DT_STRSZ
: return "STRSZ";
2100 case DT_SYMENT
: return "SYMENT";
2101 case DT_INIT
: return "INIT";
2102 case DT_FINI
: return "FINI";
2103 case DT_SONAME
: return "SONAME";
2104 case DT_RPATH
: return "RPATH";
2105 case DT_SYMBOLIC
: return "SYMBOLIC";
2106 case DT_REL
: return "REL";
2107 case DT_RELSZ
: return "RELSZ";
2108 case DT_RELENT
: return "RELENT";
2109 case DT_PLTREL
: return "PLTREL";
2110 case DT_DEBUG
: return "DEBUG";
2111 case DT_TEXTREL
: return "TEXTREL";
2112 case DT_JMPREL
: return "JMPREL";
2113 case DT_BIND_NOW
: return "BIND_NOW";
2114 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2115 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2116 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2117 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2118 case DT_RUNPATH
: return "RUNPATH";
2119 case DT_FLAGS
: return "FLAGS";
2121 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2122 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2123 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2125 case DT_CHECKSUM
: return "CHECKSUM";
2126 case DT_PLTPADSZ
: return "PLTPADSZ";
2127 case DT_MOVEENT
: return "MOVEENT";
2128 case DT_MOVESZ
: return "MOVESZ";
2129 case DT_FEATURE
: return "FEATURE";
2130 case DT_POSFLAG_1
: return "POSFLAG_1";
2131 case DT_SYMINSZ
: return "SYMINSZ";
2132 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2134 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2135 case DT_CONFIG
: return "CONFIG";
2136 case DT_DEPAUDIT
: return "DEPAUDIT";
2137 case DT_AUDIT
: return "AUDIT";
2138 case DT_PLTPAD
: return "PLTPAD";
2139 case DT_MOVETAB
: return "MOVETAB";
2140 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2142 case DT_VERSYM
: return "VERSYM";
2144 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2145 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2146 case DT_RELACOUNT
: return "RELACOUNT";
2147 case DT_RELCOUNT
: return "RELCOUNT";
2148 case DT_FLAGS_1
: return "FLAGS_1";
2149 case DT_VERDEF
: return "VERDEF";
2150 case DT_VERDEFNUM
: return "VERDEFNUM";
2151 case DT_VERNEED
: return "VERNEED";
2152 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2154 case DT_AUXILIARY
: return "AUXILIARY";
2155 case DT_USED
: return "USED";
2156 case DT_FILTER
: return "FILTER";
2158 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2159 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2160 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2161 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2162 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2163 case DT_GNU_HASH
: return "GNU_HASH";
2166 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2168 const char * result
;
2170 switch (filedata
->file_header
.e_machine
)
2173 case EM_MIPS_RS3_LE
:
2174 result
= get_mips_dynamic_type (type
);
2177 result
= get_sparc64_dynamic_type (type
);
2180 result
= get_ppc_dynamic_type (type
);
2183 result
= get_ppc64_dynamic_type (type
);
2186 result
= get_ia64_dynamic_type (type
);
2189 result
= get_alpha_dynamic_type (type
);
2192 result
= get_score_dynamic_type (type
);
2195 result
= get_tic6x_dynamic_type (type
);
2197 case EM_ALTERA_NIOS2
:
2198 result
= get_nios2_dynamic_type (type
);
2201 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2202 result
= get_solaris_dynamic_type (type
);
2211 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2213 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2214 || (filedata
->file_header
.e_machine
== EM_PARISC
2215 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2217 const char * result
;
2219 switch (filedata
->file_header
.e_machine
)
2222 result
= get_parisc_dynamic_type (type
);
2225 result
= get_ia64_dynamic_type (type
);
2228 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2229 result
= get_solaris_dynamic_type (type
);
2238 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2242 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2249 get_file_type (unsigned e_type
)
2251 static char buff
[32];
2255 case ET_NONE
: return _("NONE (None)");
2256 case ET_REL
: return _("REL (Relocatable file)");
2257 case ET_EXEC
: return _("EXEC (Executable file)");
2258 case ET_DYN
: return _("DYN (Shared object file)");
2259 case ET_CORE
: return _("CORE (Core file)");
2262 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2263 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2264 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2265 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2267 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2273 get_machine_name (unsigned e_machine
)
2275 static char buff
[64]; /* XXX */
2279 /* Please keep this switch table sorted by increasing EM_ value. */
2281 case EM_NONE
: return _("None");
2282 case EM_M32
: return "WE32100";
2283 case EM_SPARC
: return "Sparc";
2284 case EM_386
: return "Intel 80386";
2285 case EM_68K
: return "MC68000";
2286 case EM_88K
: return "MC88000";
2287 case EM_IAMCU
: return "Intel MCU";
2288 case EM_860
: return "Intel 80860";
2289 case EM_MIPS
: return "MIPS R3000";
2290 case EM_S370
: return "IBM System/370";
2292 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2293 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2294 case EM_PARISC
: return "HPPA";
2295 case EM_VPP550
: return "Fujitsu VPP500";
2296 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2297 case EM_960
: return "Intel 80960";
2298 case EM_PPC
: return "PowerPC";
2300 case EM_PPC64
: return "PowerPC64";
2302 case EM_S390
: return "IBM S/390";
2303 case EM_SPU
: return "SPU";
2305 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2306 case EM_FR20
: return "Fujitsu FR20";
2307 case EM_RH32
: return "TRW RH32";
2308 case EM_MCORE
: return "MCORE";
2310 case EM_ARM
: return "ARM";
2311 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2312 case EM_SH
: return "Renesas / SuperH SH";
2313 case EM_SPARCV9
: return "Sparc v9";
2314 case EM_TRICORE
: return "Siemens Tricore";
2315 case EM_ARC
: return "ARC";
2316 case EM_H8_300
: return "Renesas H8/300";
2317 case EM_H8_300H
: return "Renesas H8/300H";
2318 case EM_H8S
: return "Renesas H8S";
2319 case EM_H8_500
: return "Renesas H8/500";
2321 case EM_IA_64
: return "Intel IA-64";
2322 case EM_MIPS_X
: return "Stanford MIPS-X";
2323 case EM_COLDFIRE
: return "Motorola Coldfire";
2324 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2325 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2326 case EM_PCP
: return "Siemens PCP";
2327 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2328 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2329 case EM_STARCORE
: return "Motorola Star*Core processor";
2330 case EM_ME16
: return "Toyota ME16 processor";
2332 case EM_ST100
: return "STMicroelectronics ST100 processor";
2333 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2334 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2335 case EM_PDSP
: return "Sony DSP processor";
2336 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2337 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2338 case EM_FX66
: return "Siemens FX66 microcontroller";
2339 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2340 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2341 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2343 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2344 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2345 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2346 case EM_SVX
: return "Silicon Graphics SVx";
2347 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2348 case EM_VAX
: return "Digital VAX";
2349 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2350 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2351 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2352 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2354 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2355 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2356 case EM_PRISM
: return "Vitesse Prism";
2358 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2359 case EM_CYGNUS_FR30
:
2360 case EM_FR30
: return "Fujitsu FR30";
2361 case EM_CYGNUS_D10V
:
2362 case EM_D10V
: return "d10v";
2363 case EM_CYGNUS_D30V
:
2364 case EM_D30V
: return "d30v";
2365 case EM_CYGNUS_V850
:
2366 case EM_V850
: return "Renesas V850";
2367 case EM_CYGNUS_M32R
:
2368 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2369 case EM_CYGNUS_MN10300
:
2370 case EM_MN10300
: return "mn10300";
2372 case EM_CYGNUS_MN10200
:
2373 case EM_MN10200
: return "mn10200";
2374 case EM_PJ
: return "picoJava";
2375 case EM_OR1K
: return "OpenRISC 1000";
2376 case EM_ARC_COMPACT
: return "ARCompact";
2378 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2379 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2380 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2381 case EM_NS32K
: return "National Semiconductor 32000 series";
2382 case EM_TPC
: return "Tenor Network TPC processor";
2383 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2385 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2387 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2388 case EM_MAX
: return "MAX Processor";
2389 case EM_CR
: return "National Semiconductor CompactRISC";
2390 case EM_F2MC16
: return "Fujitsu F2MC16";
2391 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2392 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2393 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2394 case EM_SEP
: return "Sharp embedded microprocessor";
2395 case EM_ARCA
: return "Arca RISC microprocessor";
2397 case EM_UNICORE
: return "Unicore";
2398 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2399 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2400 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2401 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2402 case EM_XGATE
: return "Motorola XGATE embedded processor";
2404 case EM_XC16X
: return "Infineon Technologies xc16x";
2405 case EM_M16C
: return "Renesas M16C series microprocessors";
2406 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2407 case EM_CE
: return "Freescale Communication Engine RISC core";
2409 case EM_M32C
: return "Renesas M32c";
2411 case EM_TSK3000
: return "Altium TSK3000 core";
2412 case EM_RS08
: return "Freescale RS08 embedded processor";
2413 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2414 case EM_SCORE
: return "SUNPLUS S+Core";
2415 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2416 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2417 case EM_LATTICEMICO32
: return "Lattice Mico32";
2418 case EM_SE_C17
: return "Seiko Epson C17 family";
2420 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2421 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2422 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2423 case EM_TI_PRU
: return "TI PRU I/O processor";
2425 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2426 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2427 case EM_R32C
: return "Renesas R32C series microprocessors";
2428 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2429 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2430 case EM_8051
: return "Intel 8051 and variants";
2431 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2432 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2433 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2434 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2436 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2437 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2438 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2439 case EM_RX
: return "Renesas RX";
2440 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2441 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2442 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2445 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2446 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2447 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2449 case EM_L1OM
: return "Intel L1OM";
2450 case EM_K1OM
: return "Intel K1OM";
2451 case EM_INTEL182
: return "Intel (reserved)";
2452 case EM_AARCH64
: return "AArch64";
2453 case EM_ARM184
: return "ARM (reserved)";
2454 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2455 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2456 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2457 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2459 case EM_CUDA
: return "NVIDIA CUDA architecture";
2460 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2461 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2462 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2463 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2464 case EM_ARC_COMPACT2
: return "ARCv2";
2465 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2466 case EM_RL78
: return "Renesas RL78";
2467 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2468 case EM_78K0R
: return "Renesas 78K0R";
2470 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2471 case EM_BA1
: return "Beyond BA1 CPU architecture";
2472 case EM_BA2
: return "Beyond BA2 CPU architecture";
2473 case EM_XCORE
: return "XMOS xCORE processor family";
2474 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2476 case EM_KM32
: return "KM211 KM32 32-bit processor";
2477 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2478 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2479 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2480 case EM_KVARC
: return "KM211 KVARC processor";
2481 case EM_CDP
: return "Paneve CDP architecture family";
2482 case EM_COGE
: return "Cognitive Smart Memory Processor";
2483 case EM_COOL
: return "Bluechip Systems CoolEngine";
2484 case EM_NORC
: return "Nanoradio Optimized RISC";
2485 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2487 case EM_Z80
: return "Zilog Z80";
2488 case EM_VISIUM
: return "CDS VISIUMcore processor";
2489 case EM_FT32
: return "FTDI Chip FT32";
2490 case EM_MOXIE
: return "Moxie";
2491 case EM_AMDGPU
: return "AMD GPU";
2492 case EM_RISCV
: return "RISC-V";
2493 case EM_LANAI
: return "Lanai 32-bit processor";
2494 case EM_BPF
: return "Linux BPF";
2495 case EM_NFP
: return "Netronome Flow Processor";
2497 /* Large numbers... */
2498 case EM_MT
: return "Morpho Techologies MT processor";
2499 case EM_ALPHA
: return "Alpha";
2500 case EM_WEBASSEMBLY
: return "Web Assembly";
2501 case EM_DLX
: return "OpenDLX";
2502 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2503 case EM_IQ2000
: return "Vitesse IQ2000";
2505 case EM_NIOS32
: return "Altera Nios";
2506 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2507 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2508 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2509 case EM_S12Z
: return "Freescale S12Z";
2510 case EM_CSKY
: return "C-SKY";
2513 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2519 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2521 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2522 other compilers don't a specific architecture type in the e_flags, and
2523 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2524 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2527 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2528 but also sets a specific architecture type in the e_flags field.
2530 However, when decoding the flags we don't worry if we see an
2531 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2532 ARCEM architecture type. */
2534 switch (e_flags
& EF_ARC_MACH_MSK
)
2536 /* We only expect these to occur for EM_ARC_COMPACT2. */
2537 case EF_ARC_CPU_ARCV2EM
:
2538 strcat (buf
, ", ARC EM");
2540 case EF_ARC_CPU_ARCV2HS
:
2541 strcat (buf
, ", ARC HS");
2544 /* We only expect these to occur for EM_ARC_COMPACT. */
2545 case E_ARC_MACH_ARC600
:
2546 strcat (buf
, ", ARC600");
2548 case E_ARC_MACH_ARC601
:
2549 strcat (buf
, ", ARC601");
2551 case E_ARC_MACH_ARC700
:
2552 strcat (buf
, ", ARC700");
2555 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2556 new ELF with new architecture being read by an old version of
2557 readelf, or (c) An ELF built with non-GNU compiler that does not
2558 set the architecture in the e_flags. */
2560 if (e_machine
== EM_ARC_COMPACT
)
2561 strcat (buf
, ", Unknown ARCompact");
2563 strcat (buf
, ", Unknown ARC");
2567 switch (e_flags
& EF_ARC_OSABI_MSK
)
2569 case E_ARC_OSABI_ORIG
:
2570 strcat (buf
, ", (ABI:legacy)");
2572 case E_ARC_OSABI_V2
:
2573 strcat (buf
, ", (ABI:v2)");
2575 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2576 case E_ARC_OSABI_V3
:
2577 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2579 case E_ARC_OSABI_V4
:
2580 strcat (buf
, ", v4 ABI");
2583 strcat (buf
, ", unrecognised ARC OSABI flag");
2589 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2592 bfd_boolean unknown
= FALSE
;
2594 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2595 e_flags
&= ~ EF_ARM_EABIMASK
;
2597 /* Handle "generic" ARM flags. */
2598 if (e_flags
& EF_ARM_RELEXEC
)
2600 strcat (buf
, ", relocatable executable");
2601 e_flags
&= ~ EF_ARM_RELEXEC
;
2604 if (e_flags
& EF_ARM_PIC
)
2606 strcat (buf
, ", position independent");
2607 e_flags
&= ~ EF_ARM_PIC
;
2610 /* Now handle EABI specific flags. */
2614 strcat (buf
, ", <unrecognized EABI>");
2619 case EF_ARM_EABI_VER1
:
2620 strcat (buf
, ", Version1 EABI");
2625 /* Process flags one bit at a time. */
2626 flag
= e_flags
& - e_flags
;
2631 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2632 strcat (buf
, ", sorted symbol tables");
2642 case EF_ARM_EABI_VER2
:
2643 strcat (buf
, ", Version2 EABI");
2648 /* Process flags one bit at a time. */
2649 flag
= e_flags
& - e_flags
;
2654 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2655 strcat (buf
, ", sorted symbol tables");
2658 case EF_ARM_DYNSYMSUSESEGIDX
:
2659 strcat (buf
, ", dynamic symbols use segment index");
2662 case EF_ARM_MAPSYMSFIRST
:
2663 strcat (buf
, ", mapping symbols precede others");
2673 case EF_ARM_EABI_VER3
:
2674 strcat (buf
, ", Version3 EABI");
2677 case EF_ARM_EABI_VER4
:
2678 strcat (buf
, ", Version4 EABI");
2683 /* Process flags one bit at a time. */
2684 flag
= e_flags
& - e_flags
;
2690 strcat (buf
, ", BE8");
2694 strcat (buf
, ", LE8");
2704 case EF_ARM_EABI_VER5
:
2705 strcat (buf
, ", Version5 EABI");
2710 /* Process flags one bit at a time. */
2711 flag
= e_flags
& - e_flags
;
2717 strcat (buf
, ", BE8");
2721 strcat (buf
, ", LE8");
2724 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2725 strcat (buf
, ", soft-float ABI");
2728 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2729 strcat (buf
, ", hard-float ABI");
2739 case EF_ARM_EABI_UNKNOWN
:
2740 strcat (buf
, ", GNU EABI");
2745 /* Process flags one bit at a time. */
2746 flag
= e_flags
& - e_flags
;
2751 case EF_ARM_INTERWORK
:
2752 strcat (buf
, ", interworking enabled");
2755 case EF_ARM_APCS_26
:
2756 strcat (buf
, ", uses APCS/26");
2759 case EF_ARM_APCS_FLOAT
:
2760 strcat (buf
, ", uses APCS/float");
2764 strcat (buf
, ", position independent");
2768 strcat (buf
, ", 8 bit structure alignment");
2771 case EF_ARM_NEW_ABI
:
2772 strcat (buf
, ", uses new ABI");
2775 case EF_ARM_OLD_ABI
:
2776 strcat (buf
, ", uses old ABI");
2779 case EF_ARM_SOFT_FLOAT
:
2780 strcat (buf
, ", software FP");
2783 case EF_ARM_VFP_FLOAT
:
2784 strcat (buf
, ", VFP");
2787 case EF_ARM_MAVERICK_FLOAT
:
2788 strcat (buf
, ", Maverick FP");
2799 strcat (buf
,_(", <unknown>"));
2803 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2805 --size
; /* Leave space for null terminator. */
2807 switch (e_flags
& EF_AVR_MACH
)
2809 case E_AVR_MACH_AVR1
:
2810 strncat (buf
, ", avr:1", size
);
2812 case E_AVR_MACH_AVR2
:
2813 strncat (buf
, ", avr:2", size
);
2815 case E_AVR_MACH_AVR25
:
2816 strncat (buf
, ", avr:25", size
);
2818 case E_AVR_MACH_AVR3
:
2819 strncat (buf
, ", avr:3", size
);
2821 case E_AVR_MACH_AVR31
:
2822 strncat (buf
, ", avr:31", size
);
2824 case E_AVR_MACH_AVR35
:
2825 strncat (buf
, ", avr:35", size
);
2827 case E_AVR_MACH_AVR4
:
2828 strncat (buf
, ", avr:4", size
);
2830 case E_AVR_MACH_AVR5
:
2831 strncat (buf
, ", avr:5", size
);
2833 case E_AVR_MACH_AVR51
:
2834 strncat (buf
, ", avr:51", size
);
2836 case E_AVR_MACH_AVR6
:
2837 strncat (buf
, ", avr:6", size
);
2839 case E_AVR_MACH_AVRTINY
:
2840 strncat (buf
, ", avr:100", size
);
2842 case E_AVR_MACH_XMEGA1
:
2843 strncat (buf
, ", avr:101", size
);
2845 case E_AVR_MACH_XMEGA2
:
2846 strncat (buf
, ", avr:102", size
);
2848 case E_AVR_MACH_XMEGA3
:
2849 strncat (buf
, ", avr:103", size
);
2851 case E_AVR_MACH_XMEGA4
:
2852 strncat (buf
, ", avr:104", size
);
2854 case E_AVR_MACH_XMEGA5
:
2855 strncat (buf
, ", avr:105", size
);
2857 case E_AVR_MACH_XMEGA6
:
2858 strncat (buf
, ", avr:106", size
);
2860 case E_AVR_MACH_XMEGA7
:
2861 strncat (buf
, ", avr:107", size
);
2864 strncat (buf
, ", avr:<unknown>", size
);
2868 size
-= strlen (buf
);
2869 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2870 strncat (buf
, ", link-relax", size
);
2874 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2880 bfd_boolean has_fpu
= FALSE
;
2883 static const char *ABI_STRINGS
[] =
2885 "ABI v0", /* use r5 as return register; only used in N1213HC */
2886 "ABI v1", /* use r0 as return register */
2887 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2888 "ABI v2fp", /* for FPU */
2892 static const char *VER_STRINGS
[] =
2894 "Andes ELF V1.3 or older",
2898 static const char *ARCH_STRINGS
[] =
2907 abi
= EF_NDS_ABI
& e_flags
;
2908 arch
= EF_NDS_ARCH
& e_flags
;
2909 config
= EF_NDS_INST
& e_flags
;
2910 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2912 memset (buf
, 0, size
);
2919 case E_NDS_ABI_V2FP
:
2920 case E_NDS_ABI_AABI
:
2921 case E_NDS_ABI_V2FP_PLUS
:
2922 /* In case there are holes in the array. */
2923 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2927 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2933 case E_NDS32_ELF_VER_1_2
:
2934 case E_NDS32_ELF_VER_1_3
:
2935 case E_NDS32_ELF_VER_1_4
:
2936 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2940 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2944 if (E_NDS_ABI_V0
== abi
)
2946 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2947 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2948 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2949 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2955 case E_NDS_ARCH_STAR_V1_0
:
2956 case E_NDS_ARCH_STAR_V2_0
:
2957 case E_NDS_ARCH_STAR_V3_0
:
2958 case E_NDS_ARCH_STAR_V3_M
:
2959 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2963 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2964 /* ARCH version determines how the e_flags are interpreted.
2965 If it is unknown, we cannot proceed. */
2969 /* Newer ABI; Now handle architecture specific flags. */
2970 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2972 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2973 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2975 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2976 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2978 if (config
& E_NDS32_HAS_DIV_INST
)
2979 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2981 if (config
& E_NDS32_HAS_16BIT_INST
)
2982 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2986 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2988 if (version
<= E_NDS32_ELF_VER_1_3
)
2989 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2991 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2994 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2995 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2997 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2998 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3000 if (config
& E_NDS32_HAS_16BIT_INST
)
3002 if (version
<= E_NDS32_ELF_VER_1_3
)
3003 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3005 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3009 if (config
& E_NDS32_HAS_EXT_INST
)
3010 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3012 if (config
& E_NDS32_HAS_EXT2_INST
)
3013 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3015 if (config
& E_NDS32_HAS_FPU_INST
)
3018 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3021 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3024 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3027 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3030 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3035 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3037 case E_NDS32_FPU_REG_8SP_4DP
:
3038 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3040 case E_NDS32_FPU_REG_16SP_8DP
:
3041 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3043 case E_NDS32_FPU_REG_32SP_16DP
:
3044 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3046 case E_NDS32_FPU_REG_32SP_32DP
:
3047 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3052 if (config
& E_NDS32_HAS_AUDIO_INST
)
3053 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3055 if (config
& E_NDS32_HAS_STRING_INST
)
3056 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3058 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3059 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3061 if (config
& E_NDS32_HAS_VIDEO_INST
)
3063 if (version
<= E_NDS32_ELF_VER_1_3
)
3064 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3066 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3069 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3070 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3072 if (config
& E_NDS32_HAS_L2C_INST
)
3073 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3077 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3079 static char buf
[1024];
3090 case EM_ARC_COMPACT2
:
3091 case EM_ARC_COMPACT
:
3092 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3096 decode_ARM_machine_flags (e_flags
, buf
);
3100 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3104 if (e_flags
& EF_BFIN_PIC
)
3105 strcat (buf
, ", PIC");
3107 if (e_flags
& EF_BFIN_FDPIC
)
3108 strcat (buf
, ", FDPIC");
3110 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3111 strcat (buf
, ", code in L1");
3113 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3114 strcat (buf
, ", data in L1");
3119 switch (e_flags
& EF_FRV_CPU_MASK
)
3121 case EF_FRV_CPU_GENERIC
:
3125 strcat (buf
, ", fr???");
3128 case EF_FRV_CPU_FR300
:
3129 strcat (buf
, ", fr300");
3132 case EF_FRV_CPU_FR400
:
3133 strcat (buf
, ", fr400");
3135 case EF_FRV_CPU_FR405
:
3136 strcat (buf
, ", fr405");
3139 case EF_FRV_CPU_FR450
:
3140 strcat (buf
, ", fr450");
3143 case EF_FRV_CPU_FR500
:
3144 strcat (buf
, ", fr500");
3146 case EF_FRV_CPU_FR550
:
3147 strcat (buf
, ", fr550");
3150 case EF_FRV_CPU_SIMPLE
:
3151 strcat (buf
, ", simple");
3153 case EF_FRV_CPU_TOMCAT
:
3154 strcat (buf
, ", tomcat");
3160 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3161 strcat (buf
, ", m68000");
3162 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3163 strcat (buf
, ", cpu32");
3164 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3165 strcat (buf
, ", fido_a");
3168 char const * isa
= _("unknown");
3169 char const * mac
= _("unknown mac");
3170 char const * additional
= NULL
;
3172 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3174 case EF_M68K_CF_ISA_A_NODIV
:
3176 additional
= ", nodiv";
3178 case EF_M68K_CF_ISA_A
:
3181 case EF_M68K_CF_ISA_A_PLUS
:
3184 case EF_M68K_CF_ISA_B_NOUSP
:
3186 additional
= ", nousp";
3188 case EF_M68K_CF_ISA_B
:
3191 case EF_M68K_CF_ISA_C
:
3194 case EF_M68K_CF_ISA_C_NODIV
:
3196 additional
= ", nodiv";
3199 strcat (buf
, ", cf, isa ");
3202 strcat (buf
, additional
);
3203 if (e_flags
& EF_M68K_CF_FLOAT
)
3204 strcat (buf
, ", float");
3205 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3210 case EF_M68K_CF_MAC
:
3213 case EF_M68K_CF_EMAC
:
3216 case EF_M68K_CF_EMAC_B
:
3229 switch (e_flags
& EF_MEP_CPU_MASK
)
3231 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3232 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3233 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3234 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3235 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3236 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3237 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3240 switch (e_flags
& EF_MEP_COP_MASK
)
3242 case EF_MEP_COP_NONE
: break;
3243 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3244 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3245 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3246 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3247 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3250 if (e_flags
& EF_MEP_LIBRARY
)
3251 strcat (buf
, ", Built for Library");
3253 if (e_flags
& EF_MEP_INDEX_MASK
)
3254 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3255 e_flags
& EF_MEP_INDEX_MASK
);
3257 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3258 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3259 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3263 if (e_flags
& EF_PPC_EMB
)
3264 strcat (buf
, ", emb");
3266 if (e_flags
& EF_PPC_RELOCATABLE
)
3267 strcat (buf
, _(", relocatable"));
3269 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3270 strcat (buf
, _(", relocatable-lib"));
3274 if (e_flags
& EF_PPC64_ABI
)
3276 char abi
[] = ", abiv0";
3278 abi
[6] += e_flags
& EF_PPC64_ABI
;
3284 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3285 strcat (buf
, ", RH850 ABI");
3287 if (e_flags
& EF_V800_850E3
)
3288 strcat (buf
, ", V3 architecture");
3290 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3291 strcat (buf
, ", FPU not used");
3293 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3294 strcat (buf
, ", regmode: COMMON");
3296 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3297 strcat (buf
, ", r4 not used");
3299 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3300 strcat (buf
, ", r30 not used");
3302 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3303 strcat (buf
, ", r5 not used");
3305 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3306 strcat (buf
, ", r2 not used");
3308 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3310 switch (e_flags
& - e_flags
)
3312 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3313 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3314 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3315 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3316 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3317 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3318 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3319 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3320 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3321 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3322 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3323 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3330 case EM_CYGNUS_V850
:
3331 switch (e_flags
& EF_V850_ARCH
)
3333 case E_V850E3V5_ARCH
:
3334 strcat (buf
, ", v850e3v5");
3336 case E_V850E2V3_ARCH
:
3337 strcat (buf
, ", v850e2v3");
3340 strcat (buf
, ", v850e2");
3343 strcat (buf
, ", v850e1");
3346 strcat (buf
, ", v850e");
3349 strcat (buf
, ", v850");
3352 strcat (buf
, _(", unknown v850 architecture variant"));
3358 case EM_CYGNUS_M32R
:
3359 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3360 strcat (buf
, ", m32r");
3364 case EM_MIPS_RS3_LE
:
3365 if (e_flags
& EF_MIPS_NOREORDER
)
3366 strcat (buf
, ", noreorder");
3368 if (e_flags
& EF_MIPS_PIC
)
3369 strcat (buf
, ", pic");
3371 if (e_flags
& EF_MIPS_CPIC
)
3372 strcat (buf
, ", cpic");
3374 if (e_flags
& EF_MIPS_UCODE
)
3375 strcat (buf
, ", ugen_reserved");
3377 if (e_flags
& EF_MIPS_ABI2
)
3378 strcat (buf
, ", abi2");
3380 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3381 strcat (buf
, ", odk first");
3383 if (e_flags
& EF_MIPS_32BITMODE
)
3384 strcat (buf
, ", 32bitmode");
3386 if (e_flags
& EF_MIPS_NAN2008
)
3387 strcat (buf
, ", nan2008");
3389 if (e_flags
& EF_MIPS_FP64
)
3390 strcat (buf
, ", fp64");
3392 switch ((e_flags
& EF_MIPS_MACH
))
3394 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3395 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3396 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3397 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3398 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3399 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3400 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3401 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3402 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3403 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3404 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3405 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3406 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3407 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3408 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3409 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3410 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3411 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3412 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3413 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3414 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3416 /* We simply ignore the field in this case to avoid confusion:
3417 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3420 default: strcat (buf
, _(", unknown CPU")); break;
3423 switch ((e_flags
& EF_MIPS_ABI
))
3425 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3426 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3427 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3428 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3430 /* We simply ignore the field in this case to avoid confusion:
3431 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3432 This means it is likely to be an o32 file, but not for
3435 default: strcat (buf
, _(", unknown ABI")); break;
3438 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3439 strcat (buf
, ", mdmx");
3441 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3442 strcat (buf
, ", mips16");
3444 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3445 strcat (buf
, ", micromips");
3447 switch ((e_flags
& EF_MIPS_ARCH
))
3449 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3450 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3451 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3452 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3453 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3454 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3455 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3456 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3457 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3458 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3459 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3460 default: strcat (buf
, _(", unknown ISA")); break;
3465 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3469 switch (EF_NFP_MACH (e_flags
))
3471 case E_NFP_MACH_3200
:
3472 strcat (buf
, ", NFP-32xx");
3474 case E_NFP_MACH_6000
:
3475 strcat (buf
, ", NFP-6xxx");
3481 if (e_flags
& EF_RISCV_RVC
)
3482 strcat (buf
, ", RVC");
3484 if (e_flags
& EF_RISCV_RVE
)
3485 strcat (buf
, ", RVE");
3487 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3489 case EF_RISCV_FLOAT_ABI_SOFT
:
3490 strcat (buf
, ", soft-float ABI");
3493 case EF_RISCV_FLOAT_ABI_SINGLE
:
3494 strcat (buf
, ", single-float ABI");
3497 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3498 strcat (buf
, ", double-float ABI");
3501 case EF_RISCV_FLOAT_ABI_QUAD
:
3502 strcat (buf
, ", quad-float ABI");
3508 switch ((e_flags
& EF_SH_MACH_MASK
))
3510 case EF_SH1
: strcat (buf
, ", sh1"); break;
3511 case EF_SH2
: strcat (buf
, ", sh2"); break;
3512 case EF_SH3
: strcat (buf
, ", sh3"); break;
3513 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3514 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3515 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3516 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3517 case EF_SH4
: strcat (buf
, ", sh4"); break;
3518 case EF_SH5
: strcat (buf
, ", sh5"); break;
3519 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3520 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3521 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3522 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3523 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3524 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3525 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3526 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3527 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3528 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3529 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3530 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3531 default: strcat (buf
, _(", unknown ISA")); break;
3534 if (e_flags
& EF_SH_PIC
)
3535 strcat (buf
, ", pic");
3537 if (e_flags
& EF_SH_FDPIC
)
3538 strcat (buf
, ", fdpic");
3542 if (e_flags
& EF_OR1K_NODELAY
)
3543 strcat (buf
, ", no delay");
3547 if (e_flags
& EF_SPARC_32PLUS
)
3548 strcat (buf
, ", v8+");
3550 if (e_flags
& EF_SPARC_SUN_US1
)
3551 strcat (buf
, ", ultrasparcI");
3553 if (e_flags
& EF_SPARC_SUN_US3
)
3554 strcat (buf
, ", ultrasparcIII");
3556 if (e_flags
& EF_SPARC_HAL_R1
)
3557 strcat (buf
, ", halr1");
3559 if (e_flags
& EF_SPARC_LEDATA
)
3560 strcat (buf
, ", ledata");
3562 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3563 strcat (buf
, ", tso");
3565 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3566 strcat (buf
, ", pso");
3568 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3569 strcat (buf
, ", rmo");
3573 switch (e_flags
& EF_PARISC_ARCH
)
3575 case EFA_PARISC_1_0
:
3576 strcpy (buf
, ", PA-RISC 1.0");
3578 case EFA_PARISC_1_1
:
3579 strcpy (buf
, ", PA-RISC 1.1");
3581 case EFA_PARISC_2_0
:
3582 strcpy (buf
, ", PA-RISC 2.0");
3587 if (e_flags
& EF_PARISC_TRAPNIL
)
3588 strcat (buf
, ", trapnil");
3589 if (e_flags
& EF_PARISC_EXT
)
3590 strcat (buf
, ", ext");
3591 if (e_flags
& EF_PARISC_LSB
)
3592 strcat (buf
, ", lsb");
3593 if (e_flags
& EF_PARISC_WIDE
)
3594 strcat (buf
, ", wide");
3595 if (e_flags
& EF_PARISC_NO_KABP
)
3596 strcat (buf
, ", no kabp");
3597 if (e_flags
& EF_PARISC_LAZYSWAP
)
3598 strcat (buf
, ", lazyswap");
3603 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3604 strcat (buf
, ", new calling convention");
3606 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3607 strcat (buf
, ", gnu calling convention");
3611 if ((e_flags
& EF_IA_64_ABI64
))
3612 strcat (buf
, ", 64-bit");
3614 strcat (buf
, ", 32-bit");
3615 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3616 strcat (buf
, ", reduced fp model");
3617 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3618 strcat (buf
, ", no function descriptors, constant gp");
3619 else if ((e_flags
& EF_IA_64_CONS_GP
))
3620 strcat (buf
, ", constant gp");
3621 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3622 strcat (buf
, ", absolute");
3623 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3625 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3626 strcat (buf
, ", vms_linkages");
3627 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3629 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3631 case EF_IA_64_VMS_COMCOD_WARNING
:
3632 strcat (buf
, ", warning");
3634 case EF_IA_64_VMS_COMCOD_ERROR
:
3635 strcat (buf
, ", error");
3637 case EF_IA_64_VMS_COMCOD_ABORT
:
3638 strcat (buf
, ", abort");
3641 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3642 e_flags
& EF_IA_64_VMS_COMCOD
);
3643 strcat (buf
, ", <unknown>");
3649 if ((e_flags
& EF_VAX_NONPIC
))
3650 strcat (buf
, ", non-PIC");
3651 if ((e_flags
& EF_VAX_DFLOAT
))
3652 strcat (buf
, ", D-Float");
3653 if ((e_flags
& EF_VAX_GFLOAT
))
3654 strcat (buf
, ", G-Float");
3658 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3659 strcat (buf
, ", mcm");
3660 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3661 strcat (buf
, ", mcm24");
3662 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3663 strcat (buf
, ", gr6");
3667 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3669 case E_FLAG_RL78_ANY_CPU
: break;
3670 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3671 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3672 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3674 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3675 strcat (buf
, ", 64-bit doubles");
3679 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3680 strcat (buf
, ", 64-bit doubles");
3681 if (e_flags
& E_FLAG_RX_DSP
)
3682 strcat (buf
, ", dsp");
3683 if (e_flags
& E_FLAG_RX_PID
)
3684 strcat (buf
, ", pid");
3685 if (e_flags
& E_FLAG_RX_ABI
)
3686 strcat (buf
, ", RX ABI");
3687 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3688 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3689 ? ", uses String instructions" : ", bans String instructions");
3690 if (e_flags
& E_FLAG_RX_V2
)
3691 strcat (buf
, ", V2");
3692 if (e_flags
& E_FLAG_RX_V3
)
3693 strcat (buf
, ", V3");
3697 if (e_flags
& EF_S390_HIGH_GPRS
)
3698 strcat (buf
, ", highgprs");
3702 if ((e_flags
& EF_C6000_REL
))
3703 strcat (buf
, ", relocatable module");
3707 strcat (buf
, _(": architecture variant: "));
3708 switch (e_flags
& EF_MSP430_MACH
)
3710 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3711 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3712 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3713 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3714 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3715 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3716 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3717 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3718 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3719 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3720 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3721 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3722 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3723 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3724 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3726 strcat (buf
, _(": unknown")); break;
3729 if (e_flags
& ~ EF_MSP430_MACH
)
3730 strcat (buf
, _(": unknown extra flag bits also present"));
3738 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3740 static char buff
[32];
3744 case ELFOSABI_NONE
: return "UNIX - System V";
3745 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3746 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3747 case ELFOSABI_GNU
: return "UNIX - GNU";
3748 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3749 case ELFOSABI_AIX
: return "UNIX - AIX";
3750 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3751 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3752 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3753 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3754 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3755 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3756 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3757 case ELFOSABI_AROS
: return "AROS";
3758 case ELFOSABI_FENIXOS
: return "FenixOS";
3759 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3760 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3763 switch (filedata
->file_header
.e_machine
)
3768 case ELFOSABI_ARM
: return "ARM";
3769 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3780 case ELFOSABI_STANDALONE
: return _("Standalone App");
3789 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3790 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3799 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3805 get_aarch64_segment_type (unsigned long type
)
3809 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3810 default: return NULL
;
3815 get_arm_segment_type (unsigned long type
)
3819 case PT_ARM_EXIDX
: return "EXIDX";
3820 default: return NULL
;
3825 get_s390_segment_type (unsigned long type
)
3829 case PT_S390_PGSTE
: return "S390_PGSTE";
3830 default: return NULL
;
3835 get_mips_segment_type (unsigned long type
)
3839 case PT_MIPS_REGINFO
: return "REGINFO";
3840 case PT_MIPS_RTPROC
: return "RTPROC";
3841 case PT_MIPS_OPTIONS
: return "OPTIONS";
3842 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3843 default: return NULL
;
3848 get_parisc_segment_type (unsigned long type
)
3852 case PT_HP_TLS
: return "HP_TLS";
3853 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3854 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3855 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3856 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3857 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3858 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3859 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3860 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3861 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3862 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3863 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3864 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3865 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3866 case PT_HP_STACK
: return "HP_STACK";
3867 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3868 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3869 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3870 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3871 default: return NULL
;
3876 get_ia64_segment_type (unsigned long type
)
3880 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3881 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3882 case PT_HP_TLS
: return "HP_TLS";
3883 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3884 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3885 case PT_IA_64_HP_STACK
: return "HP_STACK";
3886 default: return NULL
;
3891 get_tic6x_segment_type (unsigned long type
)
3895 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3896 default: return NULL
;
3901 get_solaris_segment_type (unsigned long type
)
3905 case 0x6464e550: return "PT_SUNW_UNWIND";
3906 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3907 case 0x6ffffff7: return "PT_LOSUNW";
3908 case 0x6ffffffa: return "PT_SUNWBSS";
3909 case 0x6ffffffb: return "PT_SUNWSTACK";
3910 case 0x6ffffffc: return "PT_SUNWDTRACE";
3911 case 0x6ffffffd: return "PT_SUNWCAP";
3912 case 0x6fffffff: return "PT_HISUNW";
3913 default: return NULL
;
3918 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3920 static char buff
[32];
3924 case PT_NULL
: return "NULL";
3925 case PT_LOAD
: return "LOAD";
3926 case PT_DYNAMIC
: return "DYNAMIC";
3927 case PT_INTERP
: return "INTERP";
3928 case PT_NOTE
: return "NOTE";
3929 case PT_SHLIB
: return "SHLIB";
3930 case PT_PHDR
: return "PHDR";
3931 case PT_TLS
: return "TLS";
3932 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3933 case PT_GNU_STACK
: return "GNU_STACK";
3934 case PT_GNU_RELRO
: return "GNU_RELRO";
3935 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
3938 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3940 sprintf (buff
, "GNU_MBIND+%#lx",
3941 p_type
- PT_GNU_MBIND_LO
);
3943 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3945 const char * result
;
3947 switch (filedata
->file_header
.e_machine
)
3950 result
= get_aarch64_segment_type (p_type
);
3953 result
= get_arm_segment_type (p_type
);
3956 case EM_MIPS_RS3_LE
:
3957 result
= get_mips_segment_type (p_type
);
3960 result
= get_parisc_segment_type (p_type
);
3963 result
= get_ia64_segment_type (p_type
);
3966 result
= get_tic6x_segment_type (p_type
);
3970 result
= get_s390_segment_type (p_type
);
3980 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3982 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3984 const char * result
;
3986 switch (filedata
->file_header
.e_machine
)
3989 result
= get_parisc_segment_type (p_type
);
3992 result
= get_ia64_segment_type (p_type
);
3995 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3996 result
= get_solaris_segment_type (p_type
);
4005 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4008 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4015 get_arc_section_type_name (unsigned int sh_type
)
4019 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4027 get_mips_section_type_name (unsigned int sh_type
)
4031 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4032 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4033 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4034 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4035 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4036 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4037 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4038 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4039 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4040 case SHT_MIPS_RELD
: return "MIPS_RELD";
4041 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4042 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4043 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4044 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4045 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4046 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4047 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4048 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4049 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4050 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4051 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4052 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4053 case SHT_MIPS_LINE
: return "MIPS_LINE";
4054 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4055 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4056 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4057 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4058 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4059 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4060 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4061 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4062 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4063 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4064 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4065 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4066 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4067 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4068 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4069 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4070 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4078 get_parisc_section_type_name (unsigned int sh_type
)
4082 case SHT_PARISC_EXT
: return "PARISC_EXT";
4083 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4084 case SHT_PARISC_DOC
: return "PARISC_DOC";
4085 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4086 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4087 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4088 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4089 default: return NULL
;
4094 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4096 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4097 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4098 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4102 case SHT_IA_64_EXT
: return "IA_64_EXT";
4103 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4104 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4105 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4106 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4107 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4108 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4109 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4110 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4111 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4119 get_x86_64_section_type_name (unsigned int sh_type
)
4123 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4124 default: return NULL
;
4129 get_aarch64_section_type_name (unsigned int sh_type
)
4133 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4134 default: return NULL
;
4139 get_arm_section_type_name (unsigned int sh_type
)
4143 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4144 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4145 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4146 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4147 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4148 default: return NULL
;
4153 get_tic6x_section_type_name (unsigned int sh_type
)
4157 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4158 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4159 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4160 case SHT_TI_ICODE
: return "TI_ICODE";
4161 case SHT_TI_XREF
: return "TI_XREF";
4162 case SHT_TI_HANDLER
: return "TI_HANDLER";
4163 case SHT_TI_INITINFO
: return "TI_INITINFO";
4164 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4165 default: return NULL
;
4170 get_msp430x_section_type_name (unsigned int sh_type
)
4174 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4175 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4176 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4177 default: return NULL
;
4182 get_nfp_section_type_name (unsigned int sh_type
)
4186 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4187 case SHT_NFP_INITREG
: return "NFP_INITREG";
4188 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4189 default: return NULL
;
4194 get_v850_section_type_name (unsigned int sh_type
)
4198 case SHT_V850_SCOMMON
: return "V850 Small Common";
4199 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4200 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4201 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4202 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4203 default: return NULL
;
4208 get_riscv_section_type_name (unsigned int sh_type
)
4212 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4213 default: return NULL
;
4218 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4220 static char buff
[32];
4221 const char * result
;
4225 case SHT_NULL
: return "NULL";
4226 case SHT_PROGBITS
: return "PROGBITS";
4227 case SHT_SYMTAB
: return "SYMTAB";
4228 case SHT_STRTAB
: return "STRTAB";
4229 case SHT_RELA
: return "RELA";
4230 case SHT_HASH
: return "HASH";
4231 case SHT_DYNAMIC
: return "DYNAMIC";
4232 case SHT_NOTE
: return "NOTE";
4233 case SHT_NOBITS
: return "NOBITS";
4234 case SHT_REL
: return "REL";
4235 case SHT_SHLIB
: return "SHLIB";
4236 case SHT_DYNSYM
: return "DYNSYM";
4237 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4238 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4239 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4240 case SHT_GNU_HASH
: return "GNU_HASH";
4241 case SHT_GROUP
: return "GROUP";
4242 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4243 case SHT_GNU_verdef
: return "VERDEF";
4244 case SHT_GNU_verneed
: return "VERNEED";
4245 case SHT_GNU_versym
: return "VERSYM";
4246 case 0x6ffffff0: return "VERSYM";
4247 case 0x6ffffffc: return "VERDEF";
4248 case 0x7ffffffd: return "AUXILIARY";
4249 case 0x7fffffff: return "FILTER";
4250 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4253 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4255 switch (filedata
->file_header
.e_machine
)
4258 case EM_ARC_COMPACT
:
4259 case EM_ARC_COMPACT2
:
4260 result
= get_arc_section_type_name (sh_type
);
4263 case EM_MIPS_RS3_LE
:
4264 result
= get_mips_section_type_name (sh_type
);
4267 result
= get_parisc_section_type_name (sh_type
);
4270 result
= get_ia64_section_type_name (filedata
, sh_type
);
4275 result
= get_x86_64_section_type_name (sh_type
);
4278 result
= get_aarch64_section_type_name (sh_type
);
4281 result
= get_arm_section_type_name (sh_type
);
4284 result
= get_tic6x_section_type_name (sh_type
);
4287 result
= get_msp430x_section_type_name (sh_type
);
4290 result
= get_nfp_section_type_name (sh_type
);
4294 case EM_CYGNUS_V850
:
4295 result
= get_v850_section_type_name (sh_type
);
4298 result
= get_riscv_section_type_name (sh_type
);
4308 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4310 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4312 switch (filedata
->file_header
.e_machine
)
4315 result
= get_ia64_section_type_name (filedata
, sh_type
);
4318 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4319 result
= get_solaris_section_type (sh_type
);
4324 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4325 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4326 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4327 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4339 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4341 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4343 switch (filedata
->file_header
.e_machine
)
4347 case EM_CYGNUS_V850
:
4348 result
= get_v850_section_type_name (sh_type
);
4358 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4361 /* This message is probably going to be displayed in a 15
4362 character wide field, so put the hex value first. */
4363 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4369 #define OPTION_DEBUG_DUMP 512
4370 #define OPTION_DYN_SYMS 513
4371 #define OPTION_DWARF_DEPTH 514
4372 #define OPTION_DWARF_START 515
4373 #define OPTION_DWARF_CHECK 516
4375 static struct option options
[] =
4377 {"all", no_argument
, 0, 'a'},
4378 {"file-header", no_argument
, 0, 'h'},
4379 {"program-headers", no_argument
, 0, 'l'},
4380 {"headers", no_argument
, 0, 'e'},
4381 {"histogram", no_argument
, 0, 'I'},
4382 {"segments", no_argument
, 0, 'l'},
4383 {"sections", no_argument
, 0, 'S'},
4384 {"section-headers", no_argument
, 0, 'S'},
4385 {"section-groups", no_argument
, 0, 'g'},
4386 {"section-details", no_argument
, 0, 't'},
4387 {"full-section-name",no_argument
, 0, 'N'},
4388 {"symbols", no_argument
, 0, 's'},
4389 {"syms", no_argument
, 0, 's'},
4390 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4391 {"relocs", no_argument
, 0, 'r'},
4392 {"notes", no_argument
, 0, 'n'},
4393 {"dynamic", no_argument
, 0, 'd'},
4394 {"arch-specific", no_argument
, 0, 'A'},
4395 {"version-info", no_argument
, 0, 'V'},
4396 {"use-dynamic", no_argument
, 0, 'D'},
4397 {"unwind", no_argument
, 0, 'u'},
4398 {"archive-index", no_argument
, 0, 'c'},
4399 {"hex-dump", required_argument
, 0, 'x'},
4400 {"relocated-dump", required_argument
, 0, 'R'},
4401 {"string-dump", required_argument
, 0, 'p'},
4402 {"decompress", no_argument
, 0, 'z'},
4403 #ifdef SUPPORT_DISASSEMBLY
4404 {"instruction-dump", required_argument
, 0, 'i'},
4406 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4408 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4409 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4410 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4412 {"version", no_argument
, 0, 'v'},
4413 {"wide", no_argument
, 0, 'W'},
4414 {"help", no_argument
, 0, 'H'},
4415 {0, no_argument
, 0, 0}
4419 usage (FILE * stream
)
4421 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4422 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4423 fprintf (stream
, _(" Options are:\n\
4424 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4425 -h --file-header Display the ELF file header\n\
4426 -l --program-headers Display the program headers\n\
4427 --segments An alias for --program-headers\n\
4428 -S --section-headers Display the sections' header\n\
4429 --sections An alias for --section-headers\n\
4430 -g --section-groups Display the section groups\n\
4431 -t --section-details Display the section details\n\
4432 -e --headers Equivalent to: -h -l -S\n\
4433 -s --syms Display the symbol table\n\
4434 --symbols An alias for --syms\n\
4435 --dyn-syms Display the dynamic symbol table\n\
4436 -n --notes Display the core notes (if present)\n\
4437 -r --relocs Display the relocations (if present)\n\
4438 -u --unwind Display the unwind info (if present)\n\
4439 -d --dynamic Display the dynamic section (if present)\n\
4440 -V --version-info Display the version sections (if present)\n\
4441 -A --arch-specific Display architecture specific information (if any)\n\
4442 -c --archive-index Display the symbol/file index in an archive\n\
4443 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4444 -x --hex-dump=<number|name>\n\
4445 Dump the contents of section <number|name> as bytes\n\
4446 -p --string-dump=<number|name>\n\
4447 Dump the contents of section <number|name> as strings\n\
4448 -R --relocated-dump=<number|name>\n\
4449 Dump the contents of section <number|name> as relocated bytes\n\
4450 -z --decompress Decompress section before dumping it\n\
4451 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4452 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4453 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4454 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4455 =addr,=cu_index,=links,=follow-links]\n\
4456 Display the contents of DWARF debug sections\n"));
4457 fprintf (stream
, _("\
4458 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4459 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4461 #ifdef SUPPORT_DISASSEMBLY
4462 fprintf (stream
, _("\
4463 -i --instruction-dump=<number|name>\n\
4464 Disassemble the contents of section <number|name>\n"));
4466 fprintf (stream
, _("\
4467 -I --histogram Display histogram of bucket list lengths\n\
4468 -W --wide Allow output width to exceed 80 characters\n\
4469 @<file> Read options from <file>\n\
4470 -H --help Display this information\n\
4471 -v --version Display the version number of readelf\n"));
4473 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4474 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4476 exit (stream
== stdout
? 0 : 1);
4479 /* Record the fact that the user wants the contents of section number
4480 SECTION to be displayed using the method(s) encoded as flags bits
4481 in TYPE. Note, TYPE can be zero if we are creating the array for
4485 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4487 if (section
>= filedata
->num_dump_sects
)
4489 dump_type
* new_dump_sects
;
4491 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4492 sizeof (* new_dump_sects
));
4494 if (new_dump_sects
== NULL
)
4495 error (_("Out of memory allocating dump request table.\n"));
4498 if (filedata
->dump_sects
)
4500 /* Copy current flag settings. */
4501 memcpy (new_dump_sects
, filedata
->dump_sects
,
4502 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4504 free (filedata
->dump_sects
);
4507 filedata
->dump_sects
= new_dump_sects
;
4508 filedata
->num_dump_sects
= section
+ 1;
4512 if (filedata
->dump_sects
)
4513 filedata
->dump_sects
[section
] |= type
;
4516 /* Request a dump by section name. */
4519 request_dump_byname (const char * section
, dump_type type
)
4521 struct dump_list_entry
* new_request
;
4523 new_request
= (struct dump_list_entry
*)
4524 malloc (sizeof (struct dump_list_entry
));
4526 error (_("Out of memory allocating dump request table.\n"));
4528 new_request
->name
= strdup (section
);
4529 if (!new_request
->name
)
4530 error (_("Out of memory allocating dump request table.\n"));
4532 new_request
->type
= type
;
4534 new_request
->next
= dump_sects_byname
;
4535 dump_sects_byname
= new_request
;
4539 request_dump (Filedata
* filedata
, dump_type type
)
4545 section
= strtoul (optarg
, & cp
, 0);
4547 if (! *cp
&& section
>= 0)
4548 request_dump_bynumber (filedata
, section
, type
);
4550 request_dump_byname (optarg
, type
);
4554 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4561 while ((c
= getopt_long
4562 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4580 do_section_groups
= TRUE
;
4583 do_histogram
= TRUE
;
4588 do_section_groups
= TRUE
;
4593 do_section_details
= TRUE
;
4604 do_using_dynamic
= TRUE
;
4628 do_histogram
= TRUE
;
4634 do_archive_index
= TRUE
;
4637 request_dump (filedata
, HEX_DUMP
);
4640 request_dump (filedata
, STRING_DUMP
);
4643 request_dump (filedata
, RELOC_DUMP
);
4646 decompress_dumps
= TRUE
;
4652 do_debugging
= TRUE
;
4653 dwarf_select_sections_all ();
4657 do_debugging
= FALSE
;
4658 dwarf_select_sections_by_letters (optarg
);
4661 case OPTION_DEBUG_DUMP
:
4664 do_debugging
= TRUE
;
4667 do_debugging
= FALSE
;
4668 dwarf_select_sections_by_names (optarg
);
4671 case OPTION_DWARF_DEPTH
:
4675 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4678 case OPTION_DWARF_START
:
4682 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4685 case OPTION_DWARF_CHECK
:
4688 case OPTION_DYN_SYMS
:
4691 #ifdef SUPPORT_DISASSEMBLY
4693 request_dump (filedata
, DISASS_DUMP
);
4697 print_version (program_name
);
4706 /* xgettext:c-format */
4707 error (_("Invalid option '-%c'\n"), c
);
4714 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4715 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4716 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4717 && !do_section_groups
&& !do_archive_index
4723 get_elf_class (unsigned int elf_class
)
4725 static char buff
[32];
4729 case ELFCLASSNONE
: return _("none");
4730 case ELFCLASS32
: return "ELF32";
4731 case ELFCLASS64
: return "ELF64";
4733 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4739 get_data_encoding (unsigned int encoding
)
4741 static char buff
[32];
4745 case ELFDATANONE
: return _("none");
4746 case ELFDATA2LSB
: return _("2's complement, little endian");
4747 case ELFDATA2MSB
: return _("2's complement, big endian");
4749 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4754 /* Decode the data held in 'filedata->file_header'. */
4757 process_file_header (Filedata
* filedata
)
4759 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4761 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4762 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4763 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4764 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4767 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4771 init_dwarf_regnames (header
->e_machine
);
4777 printf (_("ELF Header:\n"));
4778 printf (_(" Magic: "));
4779 for (i
= 0; i
< EI_NIDENT
; i
++)
4780 printf ("%2.2x ", header
->e_ident
[i
]);
4782 printf (_(" Class: %s\n"),
4783 get_elf_class (header
->e_ident
[EI_CLASS
]));
4784 printf (_(" Data: %s\n"),
4785 get_data_encoding (header
->e_ident
[EI_DATA
]));
4786 printf (_(" Version: %d%s\n"),
4787 header
->e_ident
[EI_VERSION
],
4788 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4790 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4793 printf (_(" OS/ABI: %s\n"),
4794 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4795 printf (_(" ABI Version: %d\n"),
4796 header
->e_ident
[EI_ABIVERSION
]);
4797 printf (_(" Type: %s\n"),
4798 get_file_type (header
->e_type
));
4799 printf (_(" Machine: %s\n"),
4800 get_machine_name (header
->e_machine
));
4801 printf (_(" Version: 0x%lx\n"),
4804 printf (_(" Entry point address: "));
4805 print_vma (header
->e_entry
, PREFIX_HEX
);
4806 printf (_("\n Start of program headers: "));
4807 print_vma (header
->e_phoff
, DEC
);
4808 printf (_(" (bytes into file)\n Start of section headers: "));
4809 print_vma (header
->e_shoff
, DEC
);
4810 printf (_(" (bytes into file)\n"));
4812 printf (_(" Flags: 0x%lx%s\n"),
4814 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4815 printf (_(" Size of this header: %u (bytes)\n"),
4817 printf (_(" Size of program headers: %u (bytes)\n"),
4818 header
->e_phentsize
);
4819 printf (_(" Number of program headers: %u"),
4821 if (filedata
->section_headers
!= NULL
4822 && header
->e_phnum
== PN_XNUM
4823 && filedata
->section_headers
[0].sh_info
!= 0)
4825 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4826 printf (" (%u)", header
->e_phnum
);
4828 putc ('\n', stdout
);
4829 printf (_(" Size of section headers: %u (bytes)\n"),
4830 header
->e_shentsize
);
4831 printf (_(" Number of section headers: %u"),
4833 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4835 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4836 printf (" (%u)", header
->e_shnum
);
4838 putc ('\n', stdout
);
4839 printf (_(" Section header string table index: %u"),
4840 header
->e_shstrndx
);
4841 if (filedata
->section_headers
!= NULL
4842 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4844 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4845 printf (" (%u)", header
->e_shstrndx
);
4847 if (header
->e_shstrndx
!= SHN_UNDEF
4848 && header
->e_shstrndx
>= header
->e_shnum
)
4850 header
->e_shstrndx
= SHN_UNDEF
;
4851 printf (_(" <corrupt: out of range>"));
4853 putc ('\n', stdout
);
4856 if (filedata
->section_headers
!= NULL
)
4858 if (header
->e_phnum
== PN_XNUM
4859 && filedata
->section_headers
[0].sh_info
!= 0)
4860 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4861 if (header
->e_shnum
== SHN_UNDEF
)
4862 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4863 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4864 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4865 if (header
->e_shstrndx
>= header
->e_shnum
)
4866 header
->e_shstrndx
= SHN_UNDEF
;
4867 free (filedata
->section_headers
);
4868 filedata
->section_headers
= NULL
;
4874 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4875 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4878 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4880 Elf32_External_Phdr
* phdrs
;
4881 Elf32_External_Phdr
* external
;
4882 Elf_Internal_Phdr
* internal
;
4884 unsigned int size
= filedata
->file_header
.e_phentsize
;
4885 unsigned int num
= filedata
->file_header
.e_phnum
;
4887 /* PR binutils/17531: Cope with unexpected section header sizes. */
4888 if (size
== 0 || num
== 0)
4890 if (size
< sizeof * phdrs
)
4892 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4895 if (size
> sizeof * phdrs
)
4896 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4898 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4899 size
, num
, _("program headers"));
4903 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4904 i
< filedata
->file_header
.e_phnum
;
4905 i
++, internal
++, external
++)
4907 internal
->p_type
= BYTE_GET (external
->p_type
);
4908 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4909 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4910 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4911 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4912 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4913 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4914 internal
->p_align
= BYTE_GET (external
->p_align
);
4921 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4922 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4925 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4927 Elf64_External_Phdr
* phdrs
;
4928 Elf64_External_Phdr
* external
;
4929 Elf_Internal_Phdr
* internal
;
4931 unsigned int size
= filedata
->file_header
.e_phentsize
;
4932 unsigned int num
= filedata
->file_header
.e_phnum
;
4934 /* PR binutils/17531: Cope with unexpected section header sizes. */
4935 if (size
== 0 || num
== 0)
4937 if (size
< sizeof * phdrs
)
4939 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4942 if (size
> sizeof * phdrs
)
4943 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4945 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4946 size
, num
, _("program headers"));
4950 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4951 i
< filedata
->file_header
.e_phnum
;
4952 i
++, internal
++, external
++)
4954 internal
->p_type
= BYTE_GET (external
->p_type
);
4955 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4956 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4957 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4958 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4959 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4960 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4961 internal
->p_align
= BYTE_GET (external
->p_align
);
4968 /* Returns TRUE if the program headers were read into `program_headers'. */
4971 get_program_headers (Filedata
* filedata
)
4973 Elf_Internal_Phdr
* phdrs
;
4975 /* Check cache of prior read. */
4976 if (filedata
->program_headers
!= NULL
)
4979 /* Be kind to memory checkers by looking for
4980 e_phnum values which we know must be invalid. */
4981 if (filedata
->file_header
.e_phnum
4982 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4983 >= filedata
->file_size
)
4985 error (_("Too many program headers - %#x - the file is not that big\n"),
4986 filedata
->file_header
.e_phnum
);
4990 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4991 sizeof (Elf_Internal_Phdr
));
4994 error (_("Out of memory reading %u program headers\n"),
4995 filedata
->file_header
.e_phnum
);
5000 ? get_32bit_program_headers (filedata
, phdrs
)
5001 : get_64bit_program_headers (filedata
, phdrs
))
5003 filedata
->program_headers
= phdrs
;
5011 /* Returns TRUE if the program headers were loaded. */
5014 process_program_headers (Filedata
* filedata
)
5016 Elf_Internal_Phdr
* segment
;
5018 Elf_Internal_Phdr
* previous_load
= NULL
;
5020 if (filedata
->file_header
.e_phnum
== 0)
5022 /* PR binutils/12467. */
5023 if (filedata
->file_header
.e_phoff
!= 0)
5025 warn (_("possibly corrupt ELF header - it has a non-zero program"
5026 " header offset, but no program headers\n"));
5029 else if (do_segments
)
5030 printf (_("\nThere are no program headers in this file.\n"));
5034 if (do_segments
&& !do_header
)
5036 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5037 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5038 printf (ngettext ("There is %d program header, starting at offset %s\n",
5039 "There are %d program headers, starting at offset %s\n",
5040 filedata
->file_header
.e_phnum
),
5041 filedata
->file_header
.e_phnum
,
5042 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5045 if (! get_program_headers (filedata
))
5050 if (filedata
->file_header
.e_phnum
> 1)
5051 printf (_("\nProgram Headers:\n"));
5053 printf (_("\nProgram Headers:\n"));
5057 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5060 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5064 (_(" Type Offset VirtAddr PhysAddr\n"));
5066 (_(" FileSiz MemSiz Flags Align\n"));
5073 for (i
= 0, segment
= filedata
->program_headers
;
5074 i
< filedata
->file_header
.e_phnum
;
5079 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5083 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5084 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5085 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5086 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5087 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5089 (segment
->p_flags
& PF_R
? 'R' : ' '),
5090 (segment
->p_flags
& PF_W
? 'W' : ' '),
5091 (segment
->p_flags
& PF_X
? 'E' : ' '));
5092 printf ("%#lx", (unsigned long) segment
->p_align
);
5096 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5097 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5100 print_vma (segment
->p_offset
, FULL_HEX
);
5104 print_vma (segment
->p_vaddr
, FULL_HEX
);
5106 print_vma (segment
->p_paddr
, FULL_HEX
);
5109 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5110 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5113 print_vma (segment
->p_filesz
, FULL_HEX
);
5117 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5118 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5121 print_vma (segment
->p_memsz
, FULL_HEX
);
5125 (segment
->p_flags
& PF_R
? 'R' : ' '),
5126 (segment
->p_flags
& PF_W
? 'W' : ' '),
5127 (segment
->p_flags
& PF_X
? 'E' : ' '));
5129 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5130 printf ("%#lx", (unsigned long) segment
->p_align
);
5133 print_vma (segment
->p_align
, PREFIX_HEX
);
5138 print_vma (segment
->p_offset
, FULL_HEX
);
5140 print_vma (segment
->p_vaddr
, FULL_HEX
);
5142 print_vma (segment
->p_paddr
, FULL_HEX
);
5144 print_vma (segment
->p_filesz
, FULL_HEX
);
5146 print_vma (segment
->p_memsz
, FULL_HEX
);
5148 (segment
->p_flags
& PF_R
? 'R' : ' '),
5149 (segment
->p_flags
& PF_W
? 'W' : ' '),
5150 (segment
->p_flags
& PF_X
? 'E' : ' '));
5151 print_vma (segment
->p_align
, PREFIX_HEX
);
5154 putc ('\n', stdout
);
5157 switch (segment
->p_type
)
5160 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5161 required by the ELF standard, several programs, including the Linux
5162 kernel, make use of non-ordered segments. */
5164 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5165 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5167 if (segment
->p_memsz
< segment
->p_filesz
)
5168 error (_("the segment's file size is larger than its memory size\n"));
5169 previous_load
= segment
;
5173 /* PR 20815 - Verify that the program header is loaded into memory. */
5174 if (i
> 0 && previous_load
!= NULL
)
5175 error (_("the PHDR segment must occur before any LOAD segment\n"));
5176 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5180 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5181 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5182 && (filedata
->program_headers
[j
].p_vaddr
5183 + filedata
->program_headers
[j
].p_memsz
)
5184 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5186 if (j
== filedata
->file_header
.e_phnum
)
5187 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5193 error (_("more than one dynamic segment\n"));
5195 /* By default, assume that the .dynamic section is the first
5196 section in the DYNAMIC segment. */
5197 dynamic_addr
= segment
->p_offset
;
5198 dynamic_size
= segment
->p_filesz
;
5200 /* Try to locate the .dynamic section. If there is
5201 a section header table, we can easily locate it. */
5202 if (filedata
->section_headers
!= NULL
)
5204 Elf_Internal_Shdr
* sec
;
5206 sec
= find_section (filedata
, ".dynamic");
5207 if (sec
== NULL
|| sec
->sh_size
== 0)
5209 /* A corresponding .dynamic section is expected, but on
5210 IA-64/OpenVMS it is OK for it to be missing. */
5211 if (!is_ia64_vms (filedata
))
5212 error (_("no .dynamic section in the dynamic segment\n"));
5216 if (sec
->sh_type
== SHT_NOBITS
)
5222 dynamic_addr
= sec
->sh_offset
;
5223 dynamic_size
= sec
->sh_size
;
5225 if (dynamic_addr
< segment
->p_offset
5226 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5227 warn (_("the .dynamic section is not contained"
5228 " within the dynamic segment\n"));
5229 else if (dynamic_addr
> segment
->p_offset
)
5230 warn (_("the .dynamic section is not the first section"
5231 " in the dynamic segment.\n"));
5234 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5235 segment. Check this after matching against the section headers
5236 so we don't warn on debuginfo file (which have NOBITS .dynamic
5238 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5240 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5241 dynamic_addr
= dynamic_size
= 0;
5246 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5248 error (_("Unable to find program interpreter name\n"));
5252 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5254 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5255 error (_("Internal error: failed to create format string to display program interpreter\n"));
5257 program_interpreter
[0] = 0;
5258 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5259 error (_("Unable to read program interpreter name\n"));
5262 printf (_(" [Requesting program interpreter: %s]\n"),
5263 program_interpreter
);
5270 && filedata
->section_headers
!= NULL
5271 && filedata
->string_table
!= NULL
)
5273 printf (_("\n Section to Segment mapping:\n"));
5274 printf (_(" Segment Sections...\n"));
5276 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5279 Elf_Internal_Shdr
* section
;
5281 segment
= filedata
->program_headers
+ i
;
5282 section
= filedata
->section_headers
+ 1;
5284 printf (" %2.2d ", i
);
5286 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5288 if (!ELF_TBSS_SPECIAL (section
, segment
)
5289 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5290 printf ("%s ", printable_section_name (filedata
, section
));
5301 /* Find the file offset corresponding to VMA by using the program headers. */
5304 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5306 Elf_Internal_Phdr
* seg
;
5308 if (! get_program_headers (filedata
))
5310 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5314 for (seg
= filedata
->program_headers
;
5315 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5318 if (seg
->p_type
!= PT_LOAD
)
5321 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5322 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5323 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5326 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5327 (unsigned long) vma
);
5332 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5333 If PROBE is true, this is just a probe and we do not generate any error
5334 messages if the load fails. */
5337 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5339 Elf32_External_Shdr
* shdrs
;
5340 Elf_Internal_Shdr
* internal
;
5342 unsigned int size
= filedata
->file_header
.e_shentsize
;
5343 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5345 /* PR binutils/17531: Cope with unexpected section header sizes. */
5346 if (size
== 0 || num
== 0)
5348 if (size
< sizeof * shdrs
)
5351 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5354 if (!probe
&& size
> sizeof * shdrs
)
5355 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5357 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5359 probe
? NULL
: _("section headers"));
5363 free (filedata
->section_headers
);
5364 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5365 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5366 if (filedata
->section_headers
== NULL
)
5369 error (_("Out of memory reading %u section headers\n"), num
);
5374 for (i
= 0, internal
= filedata
->section_headers
;
5378 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5379 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5380 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5381 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5382 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5383 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5384 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5385 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5386 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5387 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5388 if (!probe
&& internal
->sh_link
> num
)
5389 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5390 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5391 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5398 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5401 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5403 Elf64_External_Shdr
* shdrs
;
5404 Elf_Internal_Shdr
* internal
;
5406 unsigned int size
= filedata
->file_header
.e_shentsize
;
5407 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5409 /* PR binutils/17531: Cope with unexpected section header sizes. */
5410 if (size
== 0 || num
== 0)
5413 if (size
< sizeof * shdrs
)
5416 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5420 if (! probe
&& size
> sizeof * shdrs
)
5421 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5423 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5424 filedata
->file_header
.e_shoff
,
5426 probe
? NULL
: _("section headers"));
5430 free (filedata
->section_headers
);
5431 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5432 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5433 if (filedata
->section_headers
== NULL
)
5436 error (_("Out of memory reading %u section headers\n"), num
);
5441 for (i
= 0, internal
= filedata
->section_headers
;
5445 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5446 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5447 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5448 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5449 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5450 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5451 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5452 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5453 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5454 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5455 if (!probe
&& internal
->sh_link
> num
)
5456 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5457 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5458 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5465 static Elf_Internal_Sym
*
5466 get_32bit_elf_symbols (Filedata
* filedata
,
5467 Elf_Internal_Shdr
* section
,
5468 unsigned long * num_syms_return
)
5470 unsigned long number
= 0;
5471 Elf32_External_Sym
* esyms
= NULL
;
5472 Elf_External_Sym_Shndx
* shndx
= NULL
;
5473 Elf_Internal_Sym
* isyms
= NULL
;
5474 Elf_Internal_Sym
* psym
;
5476 elf_section_list
* entry
;
5478 if (section
->sh_size
== 0)
5480 if (num_syms_return
!= NULL
)
5481 * num_syms_return
= 0;
5485 /* Run some sanity checks first. */
5486 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5488 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5489 printable_section_name (filedata
, section
),
5490 (unsigned long) section
->sh_entsize
);
5494 if (section
->sh_size
> filedata
->file_size
)
5496 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5497 printable_section_name (filedata
, section
),
5498 (unsigned long) section
->sh_size
);
5502 number
= section
->sh_size
/ section
->sh_entsize
;
5504 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5506 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5507 (unsigned long) section
->sh_size
,
5508 printable_section_name (filedata
, section
),
5509 (unsigned long) section
->sh_entsize
);
5513 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5514 section
->sh_size
, _("symbols"));
5519 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5521 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5526 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5530 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5531 entry
->hdr
->sh_offset
,
5532 1, entry
->hdr
->sh_size
,
5533 _("symbol table section indices"));
5537 /* PR17531: file: heap-buffer-overflow */
5538 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5540 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5541 printable_section_name (filedata
, entry
->hdr
),
5542 (unsigned long) entry
->hdr
->sh_size
,
5543 (unsigned long) section
->sh_size
);
5548 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5552 error (_("Out of memory reading %lu symbols\n"),
5553 (unsigned long) number
);
5557 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5559 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5560 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5561 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5562 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5563 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5565 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5566 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5567 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5568 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5569 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5576 if (num_syms_return
!= NULL
)
5577 * num_syms_return
= isyms
== NULL
? 0 : number
;
5582 static Elf_Internal_Sym
*
5583 get_64bit_elf_symbols (Filedata
* filedata
,
5584 Elf_Internal_Shdr
* section
,
5585 unsigned long * num_syms_return
)
5587 unsigned long number
= 0;
5588 Elf64_External_Sym
* esyms
= NULL
;
5589 Elf_External_Sym_Shndx
* shndx
= NULL
;
5590 Elf_Internal_Sym
* isyms
= NULL
;
5591 Elf_Internal_Sym
* psym
;
5593 elf_section_list
* entry
;
5595 if (section
->sh_size
== 0)
5597 if (num_syms_return
!= NULL
)
5598 * num_syms_return
= 0;
5602 /* Run some sanity checks first. */
5603 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5605 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5606 printable_section_name (filedata
, section
),
5607 (unsigned long) section
->sh_entsize
);
5611 if (section
->sh_size
> filedata
->file_size
)
5613 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5614 printable_section_name (filedata
, section
),
5615 (unsigned long) section
->sh_size
);
5619 number
= section
->sh_size
/ section
->sh_entsize
;
5621 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5623 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5624 (unsigned long) section
->sh_size
,
5625 printable_section_name (filedata
, section
),
5626 (unsigned long) section
->sh_entsize
);
5630 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5631 section
->sh_size
, _("symbols"));
5636 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5638 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5643 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5647 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5648 entry
->hdr
->sh_offset
,
5649 1, entry
->hdr
->sh_size
,
5650 _("symbol table section indices"));
5654 /* PR17531: file: heap-buffer-overflow */
5655 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5657 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5658 printable_section_name (filedata
, entry
->hdr
),
5659 (unsigned long) entry
->hdr
->sh_size
,
5660 (unsigned long) section
->sh_size
);
5665 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5669 error (_("Out of memory reading %lu symbols\n"),
5670 (unsigned long) number
);
5674 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5676 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5677 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5678 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5679 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5681 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5683 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5684 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5685 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5687 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5688 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5695 if (num_syms_return
!= NULL
)
5696 * num_syms_return
= isyms
== NULL
? 0 : number
;
5702 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5704 static char buff
[1024];
5706 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5708 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5709 bfd_vma os_flags
= 0;
5710 bfd_vma proc_flags
= 0;
5711 bfd_vma unknown_flags
= 0;
5719 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5720 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5721 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5722 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5723 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5724 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5725 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5726 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5727 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5728 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5729 /* IA-64 specific. */
5730 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5731 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5732 /* IA-64 OpenVMS specific. */
5733 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5734 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5735 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5736 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5737 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5738 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5740 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5741 /* SPARC specific. */
5742 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5743 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5745 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5746 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5747 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5749 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5751 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5754 if (do_section_details
)
5756 sprintf (buff
, "[%*.*lx]: ",
5757 field_size
, field_size
, (unsigned long) sh_flags
);
5758 p
+= field_size
+ 4;
5765 flag
= sh_flags
& - sh_flags
;
5768 if (do_section_details
)
5772 case SHF_WRITE
: sindex
= 0; break;
5773 case SHF_ALLOC
: sindex
= 1; break;
5774 case SHF_EXECINSTR
: sindex
= 2; break;
5775 case SHF_MERGE
: sindex
= 3; break;
5776 case SHF_STRINGS
: sindex
= 4; break;
5777 case SHF_INFO_LINK
: sindex
= 5; break;
5778 case SHF_LINK_ORDER
: sindex
= 6; break;
5779 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5780 case SHF_GROUP
: sindex
= 8; break;
5781 case SHF_TLS
: sindex
= 9; break;
5782 case SHF_EXCLUDE
: sindex
= 18; break;
5783 case SHF_COMPRESSED
: sindex
= 20; break;
5784 case SHF_GNU_MBIND
: sindex
= 24; break;
5788 switch (filedata
->file_header
.e_machine
)
5791 if (flag
== SHF_IA_64_SHORT
)
5793 else if (flag
== SHF_IA_64_NORECOV
)
5796 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5799 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5800 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5801 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5802 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5803 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5804 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5815 case EM_OLD_SPARCV9
:
5816 case EM_SPARC32PLUS
:
5819 if (flag
== SHF_ORDERED
)
5826 case SHF_ENTRYSECT
: sindex
= 21; break;
5827 case SHF_ARM_PURECODE
: sindex
= 22; break;
5828 case SHF_COMDEF
: sindex
= 23; break;
5833 if (flag
== SHF_PPC_VLE
)
5844 if (p
!= buff
+ field_size
+ 4)
5846 if (size
< (10 + 2))
5848 warn (_("Internal error: not enough buffer room for section flag info"));
5849 return _("<unknown>");
5856 size
-= flags
[sindex
].len
;
5857 p
= stpcpy (p
, flags
[sindex
].str
);
5859 else if (flag
& SHF_MASKOS
)
5861 else if (flag
& SHF_MASKPROC
)
5864 unknown_flags
|= flag
;
5870 case SHF_WRITE
: *p
= 'W'; break;
5871 case SHF_ALLOC
: *p
= 'A'; break;
5872 case SHF_EXECINSTR
: *p
= 'X'; break;
5873 case SHF_MERGE
: *p
= 'M'; break;
5874 case SHF_STRINGS
: *p
= 'S'; break;
5875 case SHF_INFO_LINK
: *p
= 'I'; break;
5876 case SHF_LINK_ORDER
: *p
= 'L'; break;
5877 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5878 case SHF_GROUP
: *p
= 'G'; break;
5879 case SHF_TLS
: *p
= 'T'; break;
5880 case SHF_EXCLUDE
: *p
= 'E'; break;
5881 case SHF_COMPRESSED
: *p
= 'C'; break;
5882 case SHF_GNU_MBIND
: *p
= 'D'; break;
5885 if ((filedata
->file_header
.e_machine
== EM_X86_64
5886 || filedata
->file_header
.e_machine
== EM_L1OM
5887 || filedata
->file_header
.e_machine
== EM_K1OM
)
5888 && flag
== SHF_X86_64_LARGE
)
5890 else if (filedata
->file_header
.e_machine
== EM_ARM
5891 && flag
== SHF_ARM_PURECODE
)
5893 else if (filedata
->file_header
.e_machine
== EM_PPC
5894 && flag
== SHF_PPC_VLE
)
5896 else if (flag
& SHF_MASKOS
)
5899 sh_flags
&= ~ SHF_MASKOS
;
5901 else if (flag
& SHF_MASKPROC
)
5904 sh_flags
&= ~ SHF_MASKPROC
;
5914 if (do_section_details
)
5918 size
-= 5 + field_size
;
5919 if (p
!= buff
+ field_size
+ 4)
5923 warn (_("Internal error: not enough buffer room for section flag info"));
5924 return _("<unknown>");
5930 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5931 (unsigned long) os_flags
);
5932 p
+= 5 + field_size
;
5936 size
-= 7 + field_size
;
5937 if (p
!= buff
+ field_size
+ 4)
5941 warn (_("Internal error: not enough buffer room for section flag info"));
5942 return _("<unknown>");
5948 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5949 (unsigned long) proc_flags
);
5950 p
+= 7 + field_size
;
5954 size
-= 10 + field_size
;
5955 if (p
!= buff
+ field_size
+ 4)
5959 warn (_("Internal error: not enough buffer room for section flag info"));
5960 return _("<unknown>");
5966 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5967 (unsigned long) unknown_flags
);
5968 p
+= 10 + field_size
;
5977 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5981 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5983 if (size
< sizeof (* echdr
))
5985 error (_("Compressed section is too small even for a compression header\n"));
5989 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5990 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5991 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5992 return sizeof (*echdr
);
5996 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5998 if (size
< sizeof (* echdr
))
6000 error (_("Compressed section is too small even for a compression header\n"));
6004 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6005 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6006 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6007 return sizeof (*echdr
);
6012 process_section_headers (Filedata
* filedata
)
6014 Elf_Internal_Shdr
* section
;
6017 filedata
->section_headers
= NULL
;
6019 if (filedata
->file_header
.e_shnum
== 0)
6021 /* PR binutils/12467. */
6022 if (filedata
->file_header
.e_shoff
!= 0)
6024 warn (_("possibly corrupt ELF file header - it has a non-zero"
6025 " section header offset, but no section headers\n"));
6028 else if (do_sections
)
6029 printf (_("\nThere are no sections in this file.\n"));
6034 if (do_sections
&& !do_header
)
6035 printf (ngettext ("There is %d section header, "
6036 "starting at offset 0x%lx:\n",
6037 "There are %d section headers, "
6038 "starting at offset 0x%lx:\n",
6039 filedata
->file_header
.e_shnum
),
6040 filedata
->file_header
.e_shnum
,
6041 (unsigned long) filedata
->file_header
.e_shoff
);
6045 if (! get_32bit_section_headers (filedata
, FALSE
))
6050 if (! get_64bit_section_headers (filedata
, FALSE
))
6054 /* Read in the string table, so that we have names to display. */
6055 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6056 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6058 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6060 if (section
->sh_size
!= 0)
6062 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6063 1, section
->sh_size
,
6066 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6070 /* Scan the sections for the dynamic symbol table
6071 and dynamic string table and debug sections. */
6072 dynamic_symbols
= NULL
;
6073 dynamic_strings
= NULL
;
6074 dynamic_syminfo
= NULL
;
6075 symtab_shndx_list
= NULL
;
6077 eh_addr_size
= is_32bit_elf
? 4 : 8;
6078 switch (filedata
->file_header
.e_machine
)
6081 case EM_MIPS_RS3_LE
:
6082 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6083 FDE addresses. However, the ABI also has a semi-official ILP32
6084 variant for which the normal FDE address size rules apply.
6086 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6087 section, where XX is the size of longs in bits. Unfortunately,
6088 earlier compilers provided no way of distinguishing ILP32 objects
6089 from LP64 objects, so if there's any doubt, we should assume that
6090 the official LP64 form is being used. */
6091 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6092 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6098 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6100 case E_H8_MACH_H8300
:
6101 case E_H8_MACH_H8300HN
:
6102 case E_H8_MACH_H8300SN
:
6103 case E_H8_MACH_H8300SXN
:
6106 case E_H8_MACH_H8300H
:
6107 case E_H8_MACH_H8300S
:
6108 case E_H8_MACH_H8300SX
:
6116 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6118 case EF_M32C_CPU_M16C
:
6125 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6128 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6129 if (section->sh_entsize != expected_entsize) \
6132 sprintf_vma (buf, section->sh_entsize); \
6133 /* Note: coded this way so that there is a single string for \
6135 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6136 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6137 (unsigned) expected_entsize); \
6138 section->sh_entsize = expected_entsize; \
6143 #define CHECK_ENTSIZE(section, i, type) \
6144 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6145 sizeof (Elf64_External_##type))
6147 for (i
= 0, section
= filedata
->section_headers
;
6148 i
< filedata
->file_header
.e_shnum
;
6151 char * name
= SECTION_NAME (section
);
6153 if (section
->sh_type
== SHT_DYNSYM
)
6155 if (dynamic_symbols
!= NULL
)
6157 error (_("File contains multiple dynamic symbol tables\n"));
6161 CHECK_ENTSIZE (section
, i
, Sym
);
6162 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6164 else if (section
->sh_type
== SHT_STRTAB
6165 && streq (name
, ".dynstr"))
6167 if (dynamic_strings
!= NULL
)
6169 error (_("File contains multiple dynamic string tables\n"));
6173 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6174 1, section
->sh_size
,
6175 _("dynamic strings"));
6176 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6178 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6180 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6182 entry
->hdr
= section
;
6183 entry
->next
= symtab_shndx_list
;
6184 symtab_shndx_list
= entry
;
6186 else if (section
->sh_type
== SHT_SYMTAB
)
6187 CHECK_ENTSIZE (section
, i
, Sym
);
6188 else if (section
->sh_type
== SHT_GROUP
)
6189 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6190 else if (section
->sh_type
== SHT_REL
)
6191 CHECK_ENTSIZE (section
, i
, Rel
);
6192 else if (section
->sh_type
== SHT_RELA
)
6193 CHECK_ENTSIZE (section
, i
, Rela
);
6194 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6195 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6196 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6197 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6198 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6199 && (const_strneq (name
, ".debug_")
6200 || const_strneq (name
, ".zdebug_")))
6203 name
+= sizeof (".zdebug_") - 1;
6205 name
+= sizeof (".debug_") - 1;
6208 || (do_debug_info
&& const_strneq (name
, "info"))
6209 || (do_debug_info
&& const_strneq (name
, "types"))
6210 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6211 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6212 || (do_debug_lines
&& const_strneq (name
, "line."))
6213 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6214 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6215 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6216 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6217 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6218 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6219 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6220 || (do_debug_frames
&& const_strneq (name
, "frame"))
6221 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6222 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6223 || (do_debug_str
&& const_strneq (name
, "str"))
6224 || (do_debug_loc
&& const_strneq (name
, "loc"))
6225 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6226 || (do_debug_addr
&& const_strneq (name
, "addr"))
6227 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6228 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6230 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6232 /* Linkonce section to be combined with .debug_info at link time. */
6233 else if ((do_debugging
|| do_debug_info
)
6234 && const_strneq (name
, ".gnu.linkonce.wi."))
6235 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6236 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6237 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6238 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6239 || streq (name
, ".debug_names")))
6240 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6241 /* Trace sections for Itanium VMS. */
6242 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6243 || do_trace_aranges
)
6244 && const_strneq (name
, ".trace_"))
6246 name
+= sizeof (".trace_") - 1;
6249 || (do_trace_info
&& streq (name
, "info"))
6250 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6251 || (do_trace_aranges
&& streq (name
, "aranges"))
6253 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6255 else if ((do_debugging
|| do_debug_links
)
6256 && (const_strneq (name
, ".gnu_debuglink")
6257 || const_strneq (name
, ".gnu_debugaltlink")))
6258 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6264 if (filedata
->file_header
.e_shnum
> 1)
6265 printf (_("\nSection Headers:\n"));
6267 printf (_("\nSection Header:\n"));
6271 if (do_section_details
)
6273 printf (_(" [Nr] Name\n"));
6274 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6278 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6282 if (do_section_details
)
6284 printf (_(" [Nr] Name\n"));
6285 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6289 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6293 if (do_section_details
)
6295 printf (_(" [Nr] Name\n"));
6296 printf (_(" Type Address Offset Link\n"));
6297 printf (_(" Size EntSize Info Align\n"));
6301 printf (_(" [Nr] Name Type Address Offset\n"));
6302 printf (_(" Size EntSize Flags Link Info Align\n"));
6306 if (do_section_details
)
6307 printf (_(" Flags\n"));
6309 for (i
= 0, section
= filedata
->section_headers
;
6310 i
< filedata
->file_header
.e_shnum
;
6313 /* Run some sanity checks on the section header. */
6315 /* Check the sh_link field. */
6316 switch (section
->sh_type
)
6320 if (section
->sh_link
== 0
6321 && (filedata
->file_header
.e_type
== ET_EXEC
6322 || filedata
->file_header
.e_type
== ET_DYN
))
6323 /* A dynamic relocation section where all entries use a
6324 zero symbol index need not specify a symtab section. */
6327 case SHT_SYMTAB_SHNDX
:
6331 case SHT_GNU_versym
:
6332 if (section
->sh_link
== 0
6333 || section
->sh_link
>= filedata
->file_header
.e_shnum
6334 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6335 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6336 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6337 i
, section
->sh_link
);
6343 case SHT_GNU_verneed
:
6344 case SHT_GNU_verdef
:
6345 case SHT_GNU_LIBLIST
:
6346 if (section
->sh_link
== 0
6347 || section
->sh_link
>= filedata
->file_header
.e_shnum
6348 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6349 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6350 i
, section
->sh_link
);
6353 case SHT_INIT_ARRAY
:
6354 case SHT_FINI_ARRAY
:
6355 case SHT_PREINIT_ARRAY
:
6356 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6357 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6358 i
, section
->sh_link
);
6362 /* FIXME: Add support for target specific section types. */
6363 #if 0 /* Currently we do not check other section types as there are too
6364 many special cases. Stab sections for example have a type
6365 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6367 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6368 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6369 i
, section
->sh_link
);
6374 /* Check the sh_info field. */
6375 switch (section
->sh_type
)
6379 if (section
->sh_info
== 0
6380 && (filedata
->file_header
.e_type
== ET_EXEC
6381 || filedata
->file_header
.e_type
== ET_DYN
))
6382 /* Dynamic relocations apply to segments, so they do not
6383 need to specify the section they relocate. */
6385 if (section
->sh_info
== 0
6386 || section
->sh_info
>= filedata
->file_header
.e_shnum
6387 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6388 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6389 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6390 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6391 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6392 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6393 /* FIXME: Are other section types valid ? */
6394 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6395 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6396 i
, section
->sh_info
);
6401 case SHT_SYMTAB_SHNDX
:
6402 case SHT_INIT_ARRAY
:
6403 case SHT_FINI_ARRAY
:
6404 case SHT_PREINIT_ARRAY
:
6405 if (section
->sh_info
!= 0)
6406 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6407 i
, section
->sh_info
);
6413 /* A symbol index - we assume that it is valid. */
6417 /* FIXME: Add support for target specific section types. */
6418 if (section
->sh_type
== SHT_NOBITS
)
6419 /* NOBITS section headers with non-zero sh_info fields can be
6420 created when a binary is stripped of everything but its debug
6421 information. The stripped sections have their headers
6422 preserved but their types set to SHT_NOBITS. So do not check
6423 this type of section. */
6425 else if (section
->sh_flags
& SHF_INFO_LINK
)
6427 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6428 warn (_("[%2u]: Expected link to another section in info field"), i
);
6430 else if (section
->sh_type
< SHT_LOOS
6431 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6432 && section
->sh_info
!= 0)
6433 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6434 i
, section
->sh_info
);
6438 /* Check the sh_size field. */
6439 if (section
->sh_size
> filedata
->file_size
6440 && section
->sh_type
!= SHT_NOBITS
6441 && section
->sh_type
!= SHT_NULL
6442 && section
->sh_type
< SHT_LOOS
)
6443 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6445 printf (" [%2u] ", i
);
6446 if (do_section_details
)
6447 printf ("%s\n ", printable_section_name (filedata
, section
));
6449 print_symbol (-17, SECTION_NAME (section
));
6451 printf (do_wide
? " %-15s " : " %-15.15s ",
6452 get_section_type_name (filedata
, section
->sh_type
));
6456 const char * link_too_big
= NULL
;
6458 print_vma (section
->sh_addr
, LONG_HEX
);
6460 printf ( " %6.6lx %6.6lx %2.2lx",
6461 (unsigned long) section
->sh_offset
,
6462 (unsigned long) section
->sh_size
,
6463 (unsigned long) section
->sh_entsize
);
6465 if (do_section_details
)
6466 fputs (" ", stdout
);
6468 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6470 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6473 /* The sh_link value is out of range. Normally this indicates
6474 an error but it can have special values in Solaris binaries. */
6475 switch (filedata
->file_header
.e_machine
)
6482 case EM_OLD_SPARCV9
:
6483 case EM_SPARC32PLUS
:
6486 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6487 link_too_big
= "BEFORE";
6488 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6489 link_too_big
= "AFTER";
6496 if (do_section_details
)
6498 if (link_too_big
!= NULL
&& * link_too_big
)
6499 printf ("<%s> ", link_too_big
);
6501 printf ("%2u ", section
->sh_link
);
6502 printf ("%3u %2lu\n", section
->sh_info
,
6503 (unsigned long) section
->sh_addralign
);
6506 printf ("%2u %3u %2lu\n",
6509 (unsigned long) section
->sh_addralign
);
6511 if (link_too_big
&& ! * link_too_big
)
6512 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6513 i
, section
->sh_link
);
6517 print_vma (section
->sh_addr
, LONG_HEX
);
6519 if ((long) section
->sh_offset
== section
->sh_offset
)
6520 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6524 print_vma (section
->sh_offset
, LONG_HEX
);
6527 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6528 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6532 print_vma (section
->sh_size
, LONG_HEX
);
6535 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6536 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6540 print_vma (section
->sh_entsize
, LONG_HEX
);
6543 if (do_section_details
)
6544 fputs (" ", stdout
);
6546 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6548 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6550 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6551 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6554 print_vma (section
->sh_addralign
, DEC
);
6558 else if (do_section_details
)
6561 print_vma (section
->sh_addr
, LONG_HEX
);
6562 if ((long) section
->sh_offset
== section
->sh_offset
)
6563 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6567 print_vma (section
->sh_offset
, LONG_HEX
);
6569 printf (" %u\n ", section
->sh_link
);
6570 print_vma (section
->sh_size
, LONG_HEX
);
6572 print_vma (section
->sh_entsize
, LONG_HEX
);
6574 printf (" %-16u %lu\n",
6576 (unsigned long) section
->sh_addralign
);
6581 print_vma (section
->sh_addr
, LONG_HEX
);
6582 if ((long) section
->sh_offset
== section
->sh_offset
)
6583 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6587 print_vma (section
->sh_offset
, LONG_HEX
);
6590 print_vma (section
->sh_size
, LONG_HEX
);
6592 print_vma (section
->sh_entsize
, LONG_HEX
);
6594 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6596 printf (" %2u %3u %lu\n",
6599 (unsigned long) section
->sh_addralign
);
6602 if (do_section_details
)
6604 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6605 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6607 /* Minimum section size is 12 bytes for 32-bit compression
6608 header + 12 bytes for compressed data header. */
6609 unsigned char buf
[24];
6611 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6612 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6613 sizeof (buf
), _("compression header")))
6615 Elf_Internal_Chdr chdr
;
6617 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6619 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6622 printf (_(" [<unknown>: 0x%x], "),
6624 print_vma (chdr
.ch_size
, LONG_HEX
);
6625 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6631 if (!do_section_details
)
6633 /* The ordering of the letters shown here matches the ordering of the
6634 corresponding SHF_xxx values, and hence the order in which these
6635 letters will be displayed to the user. */
6636 printf (_("Key to Flags:\n\
6637 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6638 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6639 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6640 if (filedata
->file_header
.e_machine
== EM_X86_64
6641 || filedata
->file_header
.e_machine
== EM_L1OM
6642 || filedata
->file_header
.e_machine
== EM_K1OM
)
6643 printf (_("l (large), "));
6644 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6645 printf (_("y (purecode), "));
6646 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6647 printf (_("v (VLE), "));
6648 printf ("p (processor specific)\n");
6655 get_group_flags (unsigned int flags
)
6657 static char buff
[128];
6661 else if (flags
== GRP_COMDAT
)
6664 snprintf (buff
, 14, _("[0x%x: "), flags
);
6666 flags
&= ~ GRP_COMDAT
;
6667 if (flags
& GRP_MASKOS
)
6669 strcat (buff
, "<OS specific>");
6670 flags
&= ~ GRP_MASKOS
;
6673 if (flags
& GRP_MASKPROC
)
6675 strcat (buff
, "<PROC specific>");
6676 flags
&= ~ GRP_MASKPROC
;
6680 strcat (buff
, "<unknown>");
6687 process_section_groups (Filedata
* filedata
)
6689 Elf_Internal_Shdr
* section
;
6691 struct group
* group
;
6692 Elf_Internal_Shdr
* symtab_sec
;
6693 Elf_Internal_Shdr
* strtab_sec
;
6694 Elf_Internal_Sym
* symtab
;
6695 unsigned long num_syms
;
6699 /* Don't process section groups unless needed. */
6700 if (!do_unwind
&& !do_section_groups
)
6703 if (filedata
->file_header
.e_shnum
== 0)
6705 if (do_section_groups
)
6706 printf (_("\nThere are no sections to group in this file.\n"));
6711 if (filedata
->section_headers
== NULL
)
6713 error (_("Section headers are not available!\n"));
6714 /* PR 13622: This can happen with a corrupt ELF header. */
6718 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6719 sizeof (struct group
*));
6721 if (section_headers_groups
== NULL
)
6723 error (_("Out of memory reading %u section group headers\n"),
6724 filedata
->file_header
.e_shnum
);
6728 /* Scan the sections for the group section. */
6730 for (i
= 0, section
= filedata
->section_headers
;
6731 i
< filedata
->file_header
.e_shnum
;
6733 if (section
->sh_type
== SHT_GROUP
)
6736 if (group_count
== 0)
6738 if (do_section_groups
)
6739 printf (_("\nThere are no section groups in this file.\n"));
6744 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6746 if (section_groups
== NULL
)
6748 error (_("Out of memory reading %lu groups\n"),
6749 (unsigned long) group_count
);
6759 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6760 i
< filedata
->file_header
.e_shnum
;
6763 if (section
->sh_type
== SHT_GROUP
)
6765 const char * name
= printable_section_name (filedata
, section
);
6766 const char * group_name
;
6767 unsigned char * start
;
6768 unsigned char * indices
;
6769 unsigned int entry
, j
, size
;
6770 Elf_Internal_Shdr
* sec
;
6771 Elf_Internal_Sym
* sym
;
6773 /* Get the symbol table. */
6774 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6775 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6778 error (_("Bad sh_link in group section `%s'\n"), name
);
6782 if (symtab_sec
!= sec
)
6787 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6792 error (_("Corrupt header in group section `%s'\n"), name
);
6796 if (section
->sh_info
>= num_syms
)
6798 error (_("Bad sh_info in group section `%s'\n"), name
);
6802 sym
= symtab
+ section
->sh_info
;
6804 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6806 if (sym
->st_shndx
== 0
6807 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6809 error (_("Bad sh_info in group section `%s'\n"), name
);
6813 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6822 /* Get the string table. */
6823 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6832 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6838 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6839 1, strtab_sec
->sh_size
,
6841 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6843 group_name
= sym
->st_name
< strtab_size
6844 ? strtab
+ sym
->st_name
: _("<corrupt>");
6847 /* PR 17531: file: loop. */
6848 if (section
->sh_entsize
> section
->sh_size
)
6850 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6851 printable_section_name (filedata
, section
),
6852 (unsigned long) section
->sh_entsize
,
6853 (unsigned long) section
->sh_size
);
6857 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6858 1, section
->sh_size
,
6864 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6865 entry
= byte_get (indices
, 4);
6868 if (do_section_groups
)
6870 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6871 get_group_flags (entry
), i
, name
, group_name
, size
);
6873 printf (_(" [Index] Name\n"));
6876 group
->group_index
= i
;
6878 for (j
= 0; j
< size
; j
++)
6880 struct group_list
* g
;
6882 entry
= byte_get (indices
, 4);
6885 if (entry
>= filedata
->file_header
.e_shnum
)
6887 static unsigned num_group_errors
= 0;
6889 if (num_group_errors
++ < 10)
6891 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6892 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6893 if (num_group_errors
== 10)
6894 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6899 if (section_headers_groups
[entry
] != NULL
)
6903 static unsigned num_errs
= 0;
6905 if (num_errs
++ < 10)
6907 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6909 section_headers_groups
[entry
]->group_index
);
6911 warn (_("Further error messages about already contained group sections suppressed\n"));
6917 /* Intel C/C++ compiler may put section 0 in a
6918 section group. We just warn it the first time
6919 and ignore it afterwards. */
6920 static bfd_boolean warned
= FALSE
;
6923 error (_("section 0 in group section [%5u]\n"),
6924 section_headers_groups
[entry
]->group_index
);
6930 section_headers_groups
[entry
] = group
;
6932 if (do_section_groups
)
6934 sec
= filedata
->section_headers
+ entry
;
6935 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6938 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6939 g
->section_index
= entry
;
6940 g
->next
= group
->root
;
6958 /* Data used to display dynamic fixups. */
6960 struct ia64_vms_dynfixup
6962 bfd_vma needed_ident
; /* Library ident number. */
6963 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6964 bfd_vma fixup_needed
; /* Index of the library. */
6965 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6966 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6969 /* Data used to display dynamic relocations. */
6971 struct ia64_vms_dynimgrela
6973 bfd_vma img_rela_cnt
; /* Number of relocations. */
6974 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6977 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6981 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6982 struct ia64_vms_dynfixup
* fixup
,
6983 const char * strtab
,
6984 unsigned int strtab_sz
)
6986 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6988 const char * lib_name
;
6990 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6991 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6992 _("dynamic section image fixups"));
6996 if (fixup
->needed
< strtab_sz
)
6997 lib_name
= strtab
+ fixup
->needed
;
7000 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7001 (unsigned long) fixup
->needed
);
7004 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7005 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7007 (_("Seg Offset Type SymVec DataType\n"));
7009 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7014 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7015 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7016 type
= BYTE_GET (imfs
[i
].type
);
7017 rtype
= elf_ia64_reloc_type (type
);
7019 printf (" 0x%08x ", type
);
7021 printf (" %-32s ", rtype
);
7022 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7023 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7030 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7033 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7035 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7038 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7039 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7040 _("dynamic section image relocations"));
7044 printf (_("\nImage relocs\n"));
7046 (_("Seg Offset Type Addend Seg Sym Off\n"));
7048 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7053 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7054 printf ("%08" BFD_VMA_FMT
"x ",
7055 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7056 type
= BYTE_GET (imrs
[i
].type
);
7057 rtype
= elf_ia64_reloc_type (type
);
7059 printf ("0x%08x ", type
);
7061 printf ("%-31s ", rtype
);
7062 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7063 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7064 printf ("%08" BFD_VMA_FMT
"x\n",
7065 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7072 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7075 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7077 struct ia64_vms_dynfixup fixup
;
7078 struct ia64_vms_dynimgrela imgrela
;
7079 Elf_Internal_Dyn
*entry
;
7080 bfd_vma strtab_off
= 0;
7081 bfd_vma strtab_sz
= 0;
7082 char *strtab
= NULL
;
7083 bfd_boolean res
= TRUE
;
7085 memset (&fixup
, 0, sizeof (fixup
));
7086 memset (&imgrela
, 0, sizeof (imgrela
));
7088 /* Note: the order of the entries is specified by the OpenVMS specs. */
7089 for (entry
= dynamic_section
;
7090 entry
< dynamic_section
+ dynamic_nent
;
7093 switch (entry
->d_tag
)
7095 case DT_IA_64_VMS_STRTAB_OFFSET
:
7096 strtab_off
= entry
->d_un
.d_val
;
7099 strtab_sz
= entry
->d_un
.d_val
;
7101 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7102 1, strtab_sz
, _("dynamic string section"));
7105 case DT_IA_64_VMS_NEEDED_IDENT
:
7106 fixup
.needed_ident
= entry
->d_un
.d_val
;
7109 fixup
.needed
= entry
->d_un
.d_val
;
7111 case DT_IA_64_VMS_FIXUP_NEEDED
:
7112 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7114 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7115 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7117 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7118 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7119 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7122 case DT_IA_64_VMS_IMG_RELA_CNT
:
7123 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7125 case DT_IA_64_VMS_IMG_RELA_OFF
:
7126 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7127 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7149 dynamic_relocations
[] =
7151 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7152 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7153 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7156 /* Process the reloc section. */
7159 process_relocs (Filedata
* filedata
)
7161 unsigned long rel_size
;
7162 unsigned long rel_offset
;
7167 if (do_using_dynamic
)
7171 bfd_boolean has_dynamic_reloc
;
7174 has_dynamic_reloc
= FALSE
;
7176 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7178 is_rela
= dynamic_relocations
[i
].rela
;
7179 name
= dynamic_relocations
[i
].name
;
7180 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7181 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7184 has_dynamic_reloc
= TRUE
;
7186 if (is_rela
== UNKNOWN
)
7188 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7189 switch (dynamic_info
[DT_PLTREL
])
7203 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7204 name
, rel_offset
, rel_size
);
7206 dump_relocations (filedata
,
7207 offset_from_vma (filedata
, rel_offset
, rel_size
),
7209 dynamic_symbols
, num_dynamic_syms
,
7210 dynamic_strings
, dynamic_strings_length
,
7211 is_rela
, TRUE
/* is_dynamic */);
7215 if (is_ia64_vms (filedata
))
7216 if (process_ia64_vms_dynamic_relocs (filedata
))
7217 has_dynamic_reloc
= TRUE
;
7219 if (! has_dynamic_reloc
)
7220 printf (_("\nThere are no dynamic relocations in this file.\n"));
7224 Elf_Internal_Shdr
* section
;
7226 bfd_boolean found
= FALSE
;
7228 for (i
= 0, section
= filedata
->section_headers
;
7229 i
< filedata
->file_header
.e_shnum
;
7232 if ( section
->sh_type
!= SHT_RELA
7233 && section
->sh_type
!= SHT_REL
)
7236 rel_offset
= section
->sh_offset
;
7237 rel_size
= section
->sh_size
;
7241 Elf_Internal_Shdr
* strsec
;
7243 unsigned long num_rela
;
7245 printf (_("\nRelocation section "));
7247 if (filedata
->string_table
== NULL
)
7248 printf ("%d", section
->sh_name
);
7250 printf ("'%s'", printable_section_name (filedata
, section
));
7252 num_rela
= rel_size
/ section
->sh_entsize
;
7253 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7254 " at offset 0x%lx contains %lu entries:\n",
7256 rel_offset
, num_rela
);
7258 is_rela
= section
->sh_type
== SHT_RELA
;
7260 if (section
->sh_link
!= 0
7261 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7263 Elf_Internal_Shdr
* symsec
;
7264 Elf_Internal_Sym
* symtab
;
7265 unsigned long nsyms
;
7266 unsigned long strtablen
= 0;
7267 char * strtab
= NULL
;
7269 symsec
= filedata
->section_headers
+ section
->sh_link
;
7270 if (symsec
->sh_type
!= SHT_SYMTAB
7271 && symsec
->sh_type
!= SHT_DYNSYM
)
7274 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7279 if (symsec
->sh_link
!= 0
7280 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7282 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7284 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7287 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7290 dump_relocations (filedata
, rel_offset
, rel_size
,
7291 symtab
, nsyms
, strtab
, strtablen
,
7293 symsec
->sh_type
== SHT_DYNSYM
);
7299 dump_relocations (filedata
, rel_offset
, rel_size
,
7300 NULL
, 0, NULL
, 0, is_rela
,
7301 FALSE
/* is_dynamic */);
7309 /* Users sometimes forget the -D option, so try to be helpful. */
7310 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7312 if (dynamic_info
[dynamic_relocations
[i
].size
])
7314 printf (_("\nThere are no static relocations in this file."));
7315 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7320 if (i
== ARRAY_SIZE (dynamic_relocations
))
7321 printf (_("\nThere are no relocations in this file.\n"));
7328 /* An absolute address consists of a section and an offset. If the
7329 section is NULL, the offset itself is the address, otherwise, the
7330 address equals to LOAD_ADDRESS(section) + offset. */
7334 unsigned short section
;
7338 #define ABSADDR(a) \
7340 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7343 /* Find the nearest symbol at or below ADDR. Returns the symbol
7344 name, if found, and the offset from the symbol to ADDR. */
7347 find_symbol_for_address (Filedata
* filedata
,
7348 Elf_Internal_Sym
* symtab
,
7349 unsigned long nsyms
,
7350 const char * strtab
,
7351 unsigned long strtab_size
,
7352 struct absaddr addr
,
7353 const char ** symname
,
7356 bfd_vma dist
= 0x100000;
7357 Elf_Internal_Sym
* sym
;
7358 Elf_Internal_Sym
* beg
;
7359 Elf_Internal_Sym
* end
;
7360 Elf_Internal_Sym
* best
= NULL
;
7362 REMOVE_ARCH_BITS (addr
.offset
);
7364 end
= symtab
+ nsyms
;
7370 sym
= beg
+ (end
- beg
) / 2;
7372 value
= sym
->st_value
;
7373 REMOVE_ARCH_BITS (value
);
7375 if (sym
->st_name
!= 0
7376 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7377 && addr
.offset
>= value
7378 && addr
.offset
- value
< dist
)
7381 dist
= addr
.offset
- value
;
7386 if (addr
.offset
< value
)
7394 *symname
= (best
->st_name
>= strtab_size
7395 ? _("<corrupt>") : strtab
+ best
->st_name
);
7401 *offset
= addr
.offset
;
7404 static /* signed */ int
7405 symcmp (const void *p
, const void *q
)
7407 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7408 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7410 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7413 /* Process the unwind section. */
7415 #include "unwind-ia64.h"
7417 struct ia64_unw_table_entry
7419 struct absaddr start
;
7421 struct absaddr info
;
7424 struct ia64_unw_aux_info
7426 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7427 unsigned long table_len
; /* Length of unwind table. */
7428 unsigned char * info
; /* Unwind info. */
7429 unsigned long info_size
; /* Size of unwind info. */
7430 bfd_vma info_addr
; /* Starting address of unwind info. */
7431 bfd_vma seg_base
; /* Starting address of segment. */
7432 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7433 unsigned long nsyms
; /* Number of symbols. */
7434 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7435 unsigned long nfuns
; /* Number of entries in funtab. */
7436 char * strtab
; /* The string table. */
7437 unsigned long strtab_size
; /* Size of string table. */
7441 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7443 struct ia64_unw_table_entry
* tp
;
7444 unsigned long j
, nfuns
;
7446 bfd_boolean res
= TRUE
;
7448 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7449 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7450 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7451 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7453 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7455 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7459 const unsigned char * dp
;
7460 const unsigned char * head
;
7461 const unsigned char * end
;
7462 const char * procname
;
7464 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7465 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7467 fputs ("\n<", stdout
);
7471 fputs (procname
, stdout
);
7474 printf ("+%lx", (unsigned long) offset
);
7477 fputs (">: [", stdout
);
7478 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7479 fputc ('-', stdout
);
7480 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7481 printf ("], info at +0x%lx\n",
7482 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7484 /* PR 17531: file: 86232b32. */
7485 if (aux
->info
== NULL
)
7488 /* PR 17531: file: 0997b4d1. */
7489 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7491 warn (_("Invalid offset %lx in table entry %ld\n"),
7492 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7497 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7498 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7500 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7501 (unsigned) UNW_VER (stamp
),
7502 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7503 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7504 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7505 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7507 if (UNW_VER (stamp
) != 1)
7509 printf (_("\tUnknown version.\n"));
7514 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7515 /* PR 17531: file: 16ceda89. */
7516 if (end
> aux
->info
+ aux
->info_size
)
7517 end
= aux
->info
+ aux
->info_size
;
7518 for (dp
= head
+ 8; dp
< end
;)
7519 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7528 slurp_ia64_unwind_table (Filedata
* filedata
,
7529 struct ia64_unw_aux_info
* aux
,
7530 Elf_Internal_Shdr
* sec
)
7532 unsigned long size
, nrelas
, i
;
7533 Elf_Internal_Phdr
* seg
;
7534 struct ia64_unw_table_entry
* tep
;
7535 Elf_Internal_Shdr
* relsec
;
7536 Elf_Internal_Rela
* rela
;
7537 Elf_Internal_Rela
* rp
;
7538 unsigned char * table
;
7540 Elf_Internal_Sym
* sym
;
7541 const char * relname
;
7545 /* First, find the starting address of the segment that includes
7548 if (filedata
->file_header
.e_phnum
)
7550 if (! get_program_headers (filedata
))
7553 for (seg
= filedata
->program_headers
;
7554 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7557 if (seg
->p_type
!= PT_LOAD
)
7560 if (sec
->sh_addr
>= seg
->p_vaddr
7561 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7563 aux
->seg_base
= seg
->p_vaddr
;
7569 /* Second, build the unwind table from the contents of the unwind section: */
7570 size
= sec
->sh_size
;
7571 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7576 aux
->table_len
= size
/ (3 * eh_addr_size
);
7577 aux
->table
= (struct ia64_unw_table_entry
*)
7578 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7581 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7583 tep
->start
.section
= SHN_UNDEF
;
7584 tep
->end
.section
= SHN_UNDEF
;
7585 tep
->info
.section
= SHN_UNDEF
;
7586 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7587 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7588 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7589 tep
->start
.offset
+= aux
->seg_base
;
7590 tep
->end
.offset
+= aux
->seg_base
;
7591 tep
->info
.offset
+= aux
->seg_base
;
7595 /* Third, apply any relocations to the unwind table: */
7596 for (relsec
= filedata
->section_headers
;
7597 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7600 if (relsec
->sh_type
!= SHT_RELA
7601 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7602 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7605 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7614 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7616 unsigned int sym_ndx
;
7617 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7618 relname
= elf_ia64_reloc_type (r_type
);
7620 /* PR 17531: file: 9fa67536. */
7621 if (relname
== NULL
)
7623 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7627 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7629 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7633 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7635 /* PR 17531: file: 5bc8d9bf. */
7636 if (i
>= aux
->table_len
)
7638 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7642 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7643 if (sym_ndx
>= aux
->nsyms
)
7645 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7649 sym
= aux
->symtab
+ sym_ndx
;
7651 switch (rp
->r_offset
/ eh_addr_size
% 3)
7654 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7655 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7658 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7659 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7662 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7663 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7677 ia64_process_unwind (Filedata
* filedata
)
7679 Elf_Internal_Shdr
* sec
;
7680 Elf_Internal_Shdr
* unwsec
= NULL
;
7681 Elf_Internal_Shdr
* strsec
;
7682 unsigned long i
, unwcount
= 0, unwstart
= 0;
7683 struct ia64_unw_aux_info aux
;
7684 bfd_boolean res
= TRUE
;
7686 memset (& aux
, 0, sizeof (aux
));
7688 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7690 if (sec
->sh_type
== SHT_SYMTAB
7691 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7693 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7695 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7696 if (aux
.strtab
!= NULL
)
7698 error (_("Multiple auxillary string tables encountered\n"));
7702 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7705 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7707 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7712 printf (_("\nThere are no unwind sections in this file.\n"));
7714 while (unwcount
-- > 0)
7719 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7720 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7721 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7726 /* We have already counted the number of SHT_IA64_UNWIND
7727 sections so the loop above should never fail. */
7728 assert (unwsec
!= NULL
);
7731 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7733 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7735 /* We need to find which section group it is in. */
7736 struct group_list
* g
;
7738 if (section_headers_groups
== NULL
7739 || section_headers_groups
[i
] == NULL
)
7740 i
= filedata
->file_header
.e_shnum
;
7743 g
= section_headers_groups
[i
]->root
;
7745 for (; g
!= NULL
; g
= g
->next
)
7747 sec
= filedata
->section_headers
+ g
->section_index
;
7749 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7754 i
= filedata
->file_header
.e_shnum
;
7757 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7759 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7760 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7761 suffix
= SECTION_NAME (unwsec
) + len
;
7762 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7764 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7765 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7770 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7771 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7772 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7773 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7775 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7776 suffix
= SECTION_NAME (unwsec
) + len
;
7777 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7779 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7780 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7784 if (i
== filedata
->file_header
.e_shnum
)
7786 printf (_("\nCould not find unwind info section for "));
7788 if (filedata
->string_table
== NULL
)
7789 printf ("%d", unwsec
->sh_name
);
7791 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7795 aux
.info_addr
= sec
->sh_addr
;
7796 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7799 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7801 printf (_("\nUnwind section "));
7803 if (filedata
->string_table
== NULL
)
7804 printf ("%d", unwsec
->sh_name
);
7806 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7808 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7809 (unsigned long) unwsec
->sh_offset
,
7810 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7812 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7813 && aux
.table_len
> 0)
7814 dump_ia64_unwind (filedata
, & aux
);
7817 free ((char *) aux
.table
);
7819 free ((char *) aux
.info
);
7828 free ((char *) aux
.strtab
);
7833 struct hppa_unw_table_entry
7835 struct absaddr start
;
7837 unsigned int Cannot_unwind
:1; /* 0 */
7838 unsigned int Millicode
:1; /* 1 */
7839 unsigned int Millicode_save_sr0
:1; /* 2 */
7840 unsigned int Region_description
:2; /* 3..4 */
7841 unsigned int reserved1
:1; /* 5 */
7842 unsigned int Entry_SR
:1; /* 6 */
7843 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7844 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7845 unsigned int Args_stored
:1; /* 16 */
7846 unsigned int Variable_Frame
:1; /* 17 */
7847 unsigned int Separate_Package_Body
:1; /* 18 */
7848 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7849 unsigned int Stack_Overflow_Check
:1; /* 20 */
7850 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7851 unsigned int Ada_Region
:1; /* 22 */
7852 unsigned int cxx_info
:1; /* 23 */
7853 unsigned int cxx_try_catch
:1; /* 24 */
7854 unsigned int sched_entry_seq
:1; /* 25 */
7855 unsigned int reserved2
:1; /* 26 */
7856 unsigned int Save_SP
:1; /* 27 */
7857 unsigned int Save_RP
:1; /* 28 */
7858 unsigned int Save_MRP_in_frame
:1; /* 29 */
7859 unsigned int extn_ptr_defined
:1; /* 30 */
7860 unsigned int Cleanup_defined
:1; /* 31 */
7862 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7863 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7864 unsigned int Large_frame
:1; /* 2 */
7865 unsigned int Pseudo_SP_Set
:1; /* 3 */
7866 unsigned int reserved4
:1; /* 4 */
7867 unsigned int Total_frame_size
:27; /* 5..31 */
7870 struct hppa_unw_aux_info
7872 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7873 unsigned long table_len
; /* Length of unwind table. */
7874 bfd_vma seg_base
; /* Starting address of segment. */
7875 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7876 unsigned long nsyms
; /* Number of symbols. */
7877 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7878 unsigned long nfuns
; /* Number of entries in funtab. */
7879 char * strtab
; /* The string table. */
7880 unsigned long strtab_size
; /* Size of string table. */
7884 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7886 struct hppa_unw_table_entry
* tp
;
7887 unsigned long j
, nfuns
;
7888 bfd_boolean res
= TRUE
;
7890 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7891 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7892 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7893 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7895 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7897 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7900 const char * procname
;
7902 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7903 aux
->strtab_size
, tp
->start
, &procname
,
7906 fputs ("\n<", stdout
);
7910 fputs (procname
, stdout
);
7913 printf ("+%lx", (unsigned long) offset
);
7916 fputs (">: [", stdout
);
7917 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7918 fputc ('-', stdout
);
7919 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7922 #define PF(_m) if (tp->_m) printf (#_m " ");
7923 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7926 PF(Millicode_save_sr0
);
7927 /* PV(Region_description); */
7933 PF(Separate_Package_Body
);
7934 PF(Frame_Extension_Millicode
);
7935 PF(Stack_Overflow_Check
);
7936 PF(Two_Instruction_SP_Increment
);
7940 PF(sched_entry_seq
);
7943 PF(Save_MRP_in_frame
);
7944 PF(extn_ptr_defined
);
7945 PF(Cleanup_defined
);
7946 PF(MPE_XL_interrupt_marker
);
7947 PF(HP_UX_interrupt_marker
);
7950 PV(Total_frame_size
);
7963 slurp_hppa_unwind_table (Filedata
* filedata
,
7964 struct hppa_unw_aux_info
* aux
,
7965 Elf_Internal_Shdr
* sec
)
7967 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7968 Elf_Internal_Phdr
* seg
;
7969 struct hppa_unw_table_entry
* tep
;
7970 Elf_Internal_Shdr
* relsec
;
7971 Elf_Internal_Rela
* rela
;
7972 Elf_Internal_Rela
* rp
;
7973 unsigned char * table
;
7975 Elf_Internal_Sym
* sym
;
7976 const char * relname
;
7978 /* First, find the starting address of the segment that includes
7980 if (filedata
->file_header
.e_phnum
)
7982 if (! get_program_headers (filedata
))
7985 for (seg
= filedata
->program_headers
;
7986 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7989 if (seg
->p_type
!= PT_LOAD
)
7992 if (sec
->sh_addr
>= seg
->p_vaddr
7993 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7995 aux
->seg_base
= seg
->p_vaddr
;
8001 /* Second, build the unwind table from the contents of the unwind
8003 size
= sec
->sh_size
;
8004 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8010 nentries
= size
/ unw_ent_size
;
8011 size
= unw_ent_size
* nentries
;
8013 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8014 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8016 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8018 unsigned int tmp1
, tmp2
;
8020 tep
->start
.section
= SHN_UNDEF
;
8021 tep
->end
.section
= SHN_UNDEF
;
8023 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8024 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8025 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8026 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8028 tep
->start
.offset
+= aux
->seg_base
;
8029 tep
->end
.offset
+= aux
->seg_base
;
8031 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8032 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8033 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8034 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8035 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8036 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8037 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8038 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8039 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8040 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8041 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8042 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8043 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8044 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8045 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8046 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8047 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8048 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8049 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8050 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8051 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8052 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8053 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8054 tep
->Cleanup_defined
= tmp1
& 0x1;
8056 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8057 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8058 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8059 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8060 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8061 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8065 /* Third, apply any relocations to the unwind table. */
8066 for (relsec
= filedata
->section_headers
;
8067 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8070 if (relsec
->sh_type
!= SHT_RELA
8071 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8072 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8075 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8079 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8081 unsigned int sym_ndx
;
8082 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8083 relname
= elf_hppa_reloc_type (r_type
);
8085 if (relname
== NULL
)
8087 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8091 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8092 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8094 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8098 i
= rp
->r_offset
/ unw_ent_size
;
8099 if (i
>= aux
->table_len
)
8101 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8105 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8106 if (sym_ndx
>= aux
->nsyms
)
8108 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8112 sym
= aux
->symtab
+ sym_ndx
;
8114 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8117 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8118 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8121 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8122 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8132 aux
->table_len
= nentries
;
8138 hppa_process_unwind (Filedata
* filedata
)
8140 struct hppa_unw_aux_info aux
;
8141 Elf_Internal_Shdr
* unwsec
= NULL
;
8142 Elf_Internal_Shdr
* strsec
;
8143 Elf_Internal_Shdr
* sec
;
8145 bfd_boolean res
= TRUE
;
8147 if (filedata
->string_table
== NULL
)
8150 memset (& aux
, 0, sizeof (aux
));
8152 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8154 if (sec
->sh_type
== SHT_SYMTAB
8155 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8157 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8159 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8160 if (aux
.strtab
!= NULL
)
8162 error (_("Multiple auxillary string tables encountered\n"));
8166 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8169 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8171 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8176 printf (_("\nThere are no unwind sections in this file.\n"));
8178 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8180 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8182 unsigned long num_unwind
= sec
->sh_size
/ 16;
8184 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8185 "contains %lu entry:\n",
8186 "\nUnwind section '%s' at offset 0x%lx "
8187 "contains %lu entries:\n",
8189 printable_section_name (filedata
, sec
),
8190 (unsigned long) sec
->sh_offset
,
8193 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8196 if (res
&& aux
.table_len
> 0)
8198 if (! dump_hppa_unwind (filedata
, &aux
))
8203 free ((char *) aux
.table
);
8211 free ((char *) aux
.strtab
);
8218 unsigned char * data
; /* The unwind data. */
8219 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8220 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8221 unsigned long nrelas
; /* The number of relocations. */
8222 unsigned int rel_type
; /* REL or RELA ? */
8223 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8226 struct arm_unw_aux_info
8228 Filedata
* filedata
; /* The file containing the unwind sections. */
8229 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8230 unsigned long nsyms
; /* Number of symbols. */
8231 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8232 unsigned long nfuns
; /* Number of these symbols. */
8233 char * strtab
; /* The file's string table. */
8234 unsigned long strtab_size
; /* Size of string table. */
8238 arm_print_vma_and_name (Filedata
* filedata
,
8239 struct arm_unw_aux_info
* aux
,
8241 struct absaddr addr
)
8243 const char *procname
;
8246 if (addr
.section
== SHN_UNDEF
)
8249 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8250 aux
->strtab_size
, addr
, &procname
,
8253 print_vma (fn
, PREFIX_HEX
);
8257 fputs (" <", stdout
);
8258 fputs (procname
, stdout
);
8261 printf ("+0x%lx", (unsigned long) sym_offset
);
8262 fputc ('>', stdout
);
8269 arm_free_section (struct arm_section
*arm_sec
)
8271 if (arm_sec
->data
!= NULL
)
8272 free (arm_sec
->data
);
8274 if (arm_sec
->rela
!= NULL
)
8275 free (arm_sec
->rela
);
8278 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8279 cached section and install SEC instead.
8280 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8281 and return its valued in * WORDP, relocating if necessary.
8282 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8283 relocation's offset in ADDR.
8284 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8285 into the string table of the symbol associated with the reloc. If no
8286 reloc was applied store -1 there.
8287 5) Return TRUE upon success, FALSE otherwise. */
8290 get_unwind_section_word (Filedata
* filedata
,
8291 struct arm_unw_aux_info
* aux
,
8292 struct arm_section
* arm_sec
,
8293 Elf_Internal_Shdr
* sec
,
8294 bfd_vma word_offset
,
8295 unsigned int * wordp
,
8296 struct absaddr
* addr
,
8299 Elf_Internal_Rela
*rp
;
8300 Elf_Internal_Sym
*sym
;
8301 const char * relname
;
8303 bfd_boolean wrapped
;
8305 if (sec
== NULL
|| arm_sec
== NULL
)
8308 addr
->section
= SHN_UNDEF
;
8311 if (sym_name
!= NULL
)
8312 *sym_name
= (bfd_vma
) -1;
8314 /* If necessary, update the section cache. */
8315 if (sec
!= arm_sec
->sec
)
8317 Elf_Internal_Shdr
*relsec
;
8319 arm_free_section (arm_sec
);
8322 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8323 sec
->sh_size
, _("unwind data"));
8324 arm_sec
->rela
= NULL
;
8325 arm_sec
->nrelas
= 0;
8327 for (relsec
= filedata
->section_headers
;
8328 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8331 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8332 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8333 /* PR 15745: Check the section type as well. */
8334 || (relsec
->sh_type
!= SHT_REL
8335 && relsec
->sh_type
!= SHT_RELA
))
8338 arm_sec
->rel_type
= relsec
->sh_type
;
8339 if (relsec
->sh_type
== SHT_REL
)
8341 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8343 & arm_sec
->rela
, & arm_sec
->nrelas
))
8346 else /* relsec->sh_type == SHT_RELA */
8348 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8350 & arm_sec
->rela
, & arm_sec
->nrelas
))
8356 arm_sec
->next_rela
= arm_sec
->rela
;
8359 /* If there is no unwind data we can do nothing. */
8360 if (arm_sec
->data
== NULL
)
8363 /* If the offset is invalid then fail. */
8364 if (/* PR 21343 *//* PR 18879 */
8366 || word_offset
> (sec
->sh_size
- 4)
8367 || ((bfd_signed_vma
) word_offset
) < 0)
8370 /* Get the word at the required offset. */
8371 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8373 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8374 if (arm_sec
->rela
== NULL
)
8380 /* Look through the relocs to find the one that applies to the provided offset. */
8382 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8384 bfd_vma prelval
, offset
;
8386 if (rp
->r_offset
> word_offset
&& !wrapped
)
8391 if (rp
->r_offset
> word_offset
)
8394 if (rp
->r_offset
& 3)
8396 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8397 (unsigned long) rp
->r_offset
);
8401 if (rp
->r_offset
< word_offset
)
8404 /* PR 17531: file: 027-161405-0.004 */
8405 if (aux
->symtab
== NULL
)
8408 if (arm_sec
->rel_type
== SHT_REL
)
8410 offset
= word
& 0x7fffffff;
8411 if (offset
& 0x40000000)
8412 offset
|= ~ (bfd_vma
) 0x7fffffff;
8414 else if (arm_sec
->rel_type
== SHT_RELA
)
8415 offset
= rp
->r_addend
;
8418 error (_("Unknown section relocation type %d encountered\n"),
8423 /* PR 17531 file: 027-1241568-0.004. */
8424 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8426 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8427 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8431 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8432 offset
+= sym
->st_value
;
8433 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8435 /* Check that we are processing the expected reloc type. */
8436 if (filedata
->file_header
.e_machine
== EM_ARM
)
8438 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8439 if (relname
== NULL
)
8441 warn (_("Skipping unknown ARM relocation type: %d\n"),
8442 (int) ELF32_R_TYPE (rp
->r_info
));
8446 if (streq (relname
, "R_ARM_NONE"))
8449 if (! streq (relname
, "R_ARM_PREL31"))
8451 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8455 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8457 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8458 if (relname
== NULL
)
8460 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8461 (int) ELF32_R_TYPE (rp
->r_info
));
8465 if (streq (relname
, "R_C6000_NONE"))
8468 if (! streq (relname
, "R_C6000_PREL31"))
8470 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8478 /* This function currently only supports ARM and TI unwinders. */
8479 warn (_("Only TI and ARM unwinders are currently supported\n"));
8483 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8484 addr
->section
= sym
->st_shndx
;
8485 addr
->offset
= offset
;
8488 * sym_name
= sym
->st_name
;
8493 arm_sec
->next_rela
= rp
;
8498 static const char *tic6x_unwind_regnames
[16] =
8500 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8501 "A14", "A13", "A12", "A11", "A10",
8502 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8506 decode_tic6x_unwind_regmask (unsigned int mask
)
8510 for (i
= 12; mask
; mask
>>= 1, i
--)
8514 fputs (tic6x_unwind_regnames
[i
], stdout
);
8516 fputs (", ", stdout
);
8522 if (remaining == 0 && more_words) \
8525 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8526 data_offset, & word, & addr, NULL)) \
8532 #define GET_OP(OP) \
8537 (OP) = word >> 24; \
8542 printf (_("[Truncated opcode]\n")); \
8545 printf ("0x%02x ", OP)
8548 decode_arm_unwind_bytecode (Filedata
* filedata
,
8549 struct arm_unw_aux_info
* aux
,
8551 unsigned int remaining
,
8552 unsigned int more_words
,
8553 bfd_vma data_offset
,
8554 Elf_Internal_Shdr
* data_sec
,
8555 struct arm_section
* data_arm_sec
)
8557 struct absaddr addr
;
8558 bfd_boolean res
= TRUE
;
8560 /* Decode the unwinding instructions. */
8563 unsigned int op
, op2
;
8572 printf (" 0x%02x ", op
);
8574 if ((op
& 0xc0) == 0x00)
8576 int offset
= ((op
& 0x3f) << 2) + 4;
8578 printf (" vsp = vsp + %d", offset
);
8580 else if ((op
& 0xc0) == 0x40)
8582 int offset
= ((op
& 0x3f) << 2) + 4;
8584 printf (" vsp = vsp - %d", offset
);
8586 else if ((op
& 0xf0) == 0x80)
8589 if (op
== 0x80 && op2
== 0)
8590 printf (_("Refuse to unwind"));
8593 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8594 bfd_boolean first
= TRUE
;
8598 for (i
= 0; i
< 12; i
++)
8599 if (mask
& (1 << i
))
8605 printf ("r%d", 4 + i
);
8610 else if ((op
& 0xf0) == 0x90)
8612 if (op
== 0x9d || op
== 0x9f)
8613 printf (_(" [Reserved]"));
8615 printf (" vsp = r%d", op
& 0x0f);
8617 else if ((op
& 0xf0) == 0xa0)
8619 int end
= 4 + (op
& 0x07);
8620 bfd_boolean first
= TRUE
;
8624 for (i
= 4; i
<= end
; i
++)
8640 else if (op
== 0xb0)
8641 printf (_(" finish"));
8642 else if (op
== 0xb1)
8645 if (op2
== 0 || (op2
& 0xf0) != 0)
8646 printf (_("[Spare]"));
8649 unsigned int mask
= op2
& 0x0f;
8650 bfd_boolean first
= TRUE
;
8654 for (i
= 0; i
< 12; i
++)
8655 if (mask
& (1 << i
))
8666 else if (op
== 0xb2)
8668 unsigned char buf
[9];
8669 unsigned int i
, len
;
8670 unsigned long offset
;
8672 for (i
= 0; i
< sizeof (buf
); i
++)
8675 if ((buf
[i
] & 0x80) == 0)
8678 if (i
== sizeof (buf
))
8680 error (_("corrupt change to vsp"));
8685 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8686 assert (len
== i
+ 1);
8687 offset
= offset
* 4 + 0x204;
8688 printf ("vsp = vsp + %ld", offset
);
8691 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8693 unsigned int first
, last
;
8700 printf ("pop {D%d", first
);
8702 printf ("-D%d", first
+ last
);
8705 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8707 unsigned int count
= op
& 0x07;
8711 printf ("-D%d", 8 + count
);
8714 else if (op
>= 0xc0 && op
<= 0xc5)
8716 unsigned int count
= op
& 0x07;
8718 printf (" pop {wR10");
8720 printf ("-wR%d", 10 + count
);
8723 else if (op
== 0xc6)
8725 unsigned int first
, last
;
8730 printf ("pop {wR%d", first
);
8732 printf ("-wR%d", first
+ last
);
8735 else if (op
== 0xc7)
8738 if (op2
== 0 || (op2
& 0xf0) != 0)
8739 printf (_("[Spare]"));
8742 unsigned int mask
= op2
& 0x0f;
8743 bfd_boolean first
= TRUE
;
8747 for (i
= 0; i
< 4; i
++)
8748 if (mask
& (1 << i
))
8754 printf ("wCGR%d", i
);
8761 printf (_(" [unsupported opcode]"));
8772 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8773 struct arm_unw_aux_info
* aux
,
8775 unsigned int remaining
,
8776 unsigned int more_words
,
8777 bfd_vma data_offset
,
8778 Elf_Internal_Shdr
* data_sec
,
8779 struct arm_section
* data_arm_sec
)
8781 struct absaddr addr
;
8783 /* Decode the unwinding instructions. */
8786 unsigned int op
, op2
;
8795 printf (" 0x%02x ", op
);
8797 if ((op
& 0xc0) == 0x00)
8799 int offset
= ((op
& 0x3f) << 3) + 8;
8800 printf (" sp = sp + %d", offset
);
8802 else if ((op
& 0xc0) == 0x80)
8805 if (op
== 0x80 && op2
== 0)
8806 printf (_("Refuse to unwind"));
8809 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8811 printf ("pop compact {");
8815 decode_tic6x_unwind_regmask (mask
);
8819 else if ((op
& 0xf0) == 0xc0)
8827 unsigned int offset
;
8831 /* Scan entire instruction first so that GET_OP output is not
8832 interleaved with disassembly. */
8834 for (i
= 0; nregs
< (op
& 0xf); i
++)
8840 regpos
[nregs
].offset
= i
* 2;
8841 regpos
[nregs
].reg
= reg
;
8848 regpos
[nregs
].offset
= i
* 2 + 1;
8849 regpos
[nregs
].reg
= reg
;
8854 printf (_("pop frame {"));
8856 for (i
= i
* 2; i
> 0; i
--)
8858 if (regpos
[reg
].offset
== i
- 1)
8860 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8867 fputs (name
, stdout
);
8874 else if (op
== 0xd0)
8875 printf (" MOV FP, SP");
8876 else if (op
== 0xd1)
8877 printf (" __c6xabi_pop_rts");
8878 else if (op
== 0xd2)
8880 unsigned char buf
[9];
8881 unsigned int i
, len
;
8882 unsigned long offset
;
8884 for (i
= 0; i
< sizeof (buf
); i
++)
8887 if ((buf
[i
] & 0x80) == 0)
8890 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8891 if (i
== sizeof (buf
))
8893 warn (_("Corrupt stack pointer adjustment detected\n"));
8897 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8898 assert (len
== i
+ 1);
8899 offset
= offset
* 8 + 0x408;
8900 printf (_("sp = sp + %ld"), offset
);
8902 else if ((op
& 0xf0) == 0xe0)
8904 if ((op
& 0x0f) == 7)
8907 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8911 printf (_(" [unsupported opcode]"));
8920 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8924 offset
= word
& 0x7fffffff;
8925 if (offset
& 0x40000000)
8926 offset
|= ~ (bfd_vma
) 0x7fffffff;
8928 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8931 return offset
+ where
;
8935 decode_arm_unwind (Filedata
* filedata
,
8936 struct arm_unw_aux_info
* aux
,
8938 unsigned int remaining
,
8939 bfd_vma data_offset
,
8940 Elf_Internal_Shdr
* data_sec
,
8941 struct arm_section
* data_arm_sec
)
8944 unsigned int more_words
= 0;
8945 struct absaddr addr
;
8946 bfd_vma sym_name
= (bfd_vma
) -1;
8947 bfd_boolean res
= TRUE
;
8951 /* Fetch the first word.
8952 Note - when decoding an object file the address extracted
8953 here will always be 0. So we also pass in the sym_name
8954 parameter so that we can find the symbol associated with
8955 the personality routine. */
8956 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8957 & word
, & addr
, & sym_name
))
8963 if ((word
& 0x80000000) == 0)
8965 /* Expand prel31 for personality routine. */
8967 const char *procname
;
8969 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8970 printf (_(" Personality routine: "));
8972 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8973 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8975 procname
= aux
->strtab
+ sym_name
;
8976 print_vma (fn
, PREFIX_HEX
);
8979 fputs (" <", stdout
);
8980 fputs (procname
, stdout
);
8981 fputc ('>', stdout
);
8985 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8986 fputc ('\n', stdout
);
8988 /* The GCC personality routines use the standard compact
8989 encoding, starting with one byte giving the number of
8991 if (procname
!= NULL
8992 && (const_strneq (procname
, "__gcc_personality_v0")
8993 || const_strneq (procname
, "__gxx_personality_v0")
8994 || const_strneq (procname
, "__gcj_personality_v0")
8995 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9002 printf (_(" [Truncated data]\n"));
9005 more_words
= word
>> 24;
9015 /* ARM EHABI Section 6.3:
9017 An exception-handling table entry for the compact model looks like:
9021 1 0 index Data for personalityRoutine[index] */
9023 if (filedata
->file_header
.e_machine
== EM_ARM
9024 && (word
& 0x70000000))
9026 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9030 per_index
= (word
>> 24) & 0x7f;
9031 printf (_(" Compact model index: %d\n"), per_index
);
9038 else if (per_index
< 3)
9040 more_words
= (word
>> 16) & 0xff;
9046 switch (filedata
->file_header
.e_machine
)
9051 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9052 data_offset
, data_sec
, data_arm_sec
))
9057 warn (_("Unknown ARM compact model index encountered\n"));
9058 printf (_(" [reserved]\n"));
9066 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9067 data_offset
, data_sec
, data_arm_sec
))
9070 else if (per_index
< 5)
9072 if (((word
>> 17) & 0x7f) == 0x7f)
9073 printf (_(" Restore stack from frame pointer\n"));
9075 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9076 printf (_(" Registers restored: "));
9078 printf (" (compact) ");
9079 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9081 printf (_(" Return register: %s\n"),
9082 tic6x_unwind_regnames
[word
& 0xf]);
9085 printf (_(" [reserved (%d)]\n"), per_index
);
9089 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9090 filedata
->file_header
.e_machine
);
9094 /* Decode the descriptors. Not implemented. */
9100 dump_arm_unwind (Filedata
* filedata
,
9101 struct arm_unw_aux_info
* aux
,
9102 Elf_Internal_Shdr
* exidx_sec
)
9104 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9105 unsigned int i
, exidx_len
;
9106 unsigned long j
, nfuns
;
9107 bfd_boolean res
= TRUE
;
9109 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9110 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9111 exidx_len
= exidx_sec
->sh_size
/ 8;
9113 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9114 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9115 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9116 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9118 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9120 for (i
= 0; i
< exidx_len
; i
++)
9122 unsigned int exidx_fn
, exidx_entry
;
9123 struct absaddr fn_addr
, entry_addr
;
9126 fputc ('\n', stdout
);
9128 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9129 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9130 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9131 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9134 arm_free_section (& exidx_arm_sec
);
9135 arm_free_section (& extab_arm_sec
);
9139 /* ARM EHABI, Section 5:
9140 An index table entry consists of 2 words.
9141 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9142 if (exidx_fn
& 0x80000000)
9144 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9148 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9150 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9151 fputs (": ", stdout
);
9153 if (exidx_entry
== 1)
9155 print_vma (exidx_entry
, PREFIX_HEX
);
9156 fputs (" [cantunwind]\n", stdout
);
9158 else if (exidx_entry
& 0x80000000)
9160 print_vma (exidx_entry
, PREFIX_HEX
);
9161 fputc ('\n', stdout
);
9162 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9166 bfd_vma table
, table_offset
= 0;
9167 Elf_Internal_Shdr
*table_sec
;
9169 fputs ("@", stdout
);
9170 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9171 print_vma (table
, PREFIX_HEX
);
9174 /* Locate the matching .ARM.extab. */
9175 if (entry_addr
.section
!= SHN_UNDEF
9176 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9178 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9179 table_offset
= entry_addr
.offset
;
9181 if (table_offset
> table_sec
->sh_size
9182 || ((bfd_signed_vma
) table_offset
) < 0)
9184 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9185 (unsigned long) table_offset
,
9186 printable_section_name (filedata
, table_sec
));
9193 table_sec
= find_section_by_address (filedata
, table
);
9194 if (table_sec
!= NULL
)
9195 table_offset
= table
- table_sec
->sh_addr
;
9198 if (table_sec
== NULL
)
9200 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9201 (unsigned long) table
);
9206 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9215 arm_free_section (&exidx_arm_sec
);
9216 arm_free_section (&extab_arm_sec
);
9221 /* Used for both ARM and C6X unwinding tables. */
9224 arm_process_unwind (Filedata
* filedata
)
9226 struct arm_unw_aux_info aux
;
9227 Elf_Internal_Shdr
*unwsec
= NULL
;
9228 Elf_Internal_Shdr
*strsec
;
9229 Elf_Internal_Shdr
*sec
;
9231 unsigned int sec_type
;
9232 bfd_boolean res
= TRUE
;
9234 switch (filedata
->file_header
.e_machine
)
9237 sec_type
= SHT_ARM_EXIDX
;
9241 sec_type
= SHT_C6000_UNWIND
;
9245 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9246 filedata
->file_header
.e_machine
);
9250 if (filedata
->string_table
== NULL
)
9253 memset (& aux
, 0, sizeof (aux
));
9254 aux
.filedata
= filedata
;
9256 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9258 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9260 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9262 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9264 /* PR binutils/17531 file: 011-12666-0.004. */
9265 if (aux
.strtab
!= NULL
)
9267 error (_("Multiple string tables found in file.\n"));
9271 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9272 1, strsec
->sh_size
, _("string table"));
9273 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9275 else if (sec
->sh_type
== sec_type
)
9280 printf (_("\nThere are no unwind sections in this file.\n"));
9282 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9284 if (sec
->sh_type
== sec_type
)
9286 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9287 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9288 "contains %lu entry:\n",
9289 "\nUnwind section '%s' at offset 0x%lx "
9290 "contains %lu entries:\n",
9292 printable_section_name (filedata
, sec
),
9293 (unsigned long) sec
->sh_offset
,
9296 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9304 free ((char *) aux
.strtab
);
9310 process_unwind (Filedata
* filedata
)
9312 struct unwind_handler
9314 unsigned int machtype
;
9315 bfd_boolean (* handler
)(Filedata
*);
9318 { EM_ARM
, arm_process_unwind
},
9319 { EM_IA_64
, ia64_process_unwind
},
9320 { EM_PARISC
, hppa_process_unwind
},
9321 { EM_TI_C6000
, arm_process_unwind
},
9329 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9330 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9331 return handlers
[i
].handler (filedata
);
9333 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9334 get_machine_name (filedata
->file_header
.e_machine
));
9339 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9341 switch (entry
->d_tag
)
9344 if (entry
->d_un
.d_val
== 0)
9348 static const char * opts
[] =
9350 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9351 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9352 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9353 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9357 bfd_boolean first
= TRUE
;
9359 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9360 if (entry
->d_un
.d_val
& (1 << cnt
))
9362 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9368 case DT_MIPS_IVERSION
:
9369 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9370 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9374 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9375 /* Note: coded this way so that there is a single string for translation. */
9376 printf (_("<corrupt: %s>"), buf
);
9380 case DT_MIPS_TIME_STAMP
:
9384 time_t atime
= entry
->d_un
.d_val
;
9386 tmp
= gmtime (&atime
);
9387 /* PR 17531: file: 6accc532. */
9389 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9391 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9392 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9393 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9394 printf (_("Time Stamp: %s"), timebuf
);
9398 case DT_MIPS_RLD_VERSION
:
9399 case DT_MIPS_LOCAL_GOTNO
:
9400 case DT_MIPS_CONFLICTNO
:
9401 case DT_MIPS_LIBLISTNO
:
9402 case DT_MIPS_SYMTABNO
:
9403 case DT_MIPS_UNREFEXTNO
:
9404 case DT_MIPS_HIPAGENO
:
9405 case DT_MIPS_DELTA_CLASS_NO
:
9406 case DT_MIPS_DELTA_INSTANCE_NO
:
9407 case DT_MIPS_DELTA_RELOC_NO
:
9408 case DT_MIPS_DELTA_SYM_NO
:
9409 case DT_MIPS_DELTA_CLASSSYM_NO
:
9410 case DT_MIPS_COMPACT_SIZE
:
9411 print_vma (entry
->d_un
.d_val
, DEC
);
9415 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9421 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9423 switch (entry
->d_tag
)
9425 case DT_HP_DLD_FLAGS
:
9434 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9435 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9436 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9437 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9438 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9439 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9440 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9441 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9442 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9443 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9444 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9445 { DT_HP_GST
, "HP_GST" },
9446 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9447 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9448 { DT_HP_NODELETE
, "HP_NODELETE" },
9449 { DT_HP_GROUP
, "HP_GROUP" },
9450 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9452 bfd_boolean first
= TRUE
;
9454 bfd_vma val
= entry
->d_un
.d_val
;
9456 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9457 if (val
& flags
[cnt
].bit
)
9461 fputs (flags
[cnt
].str
, stdout
);
9463 val
^= flags
[cnt
].bit
;
9466 if (val
!= 0 || first
)
9470 print_vma (val
, HEX
);
9476 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9484 /* VMS vs Unix time offset and factor. */
9486 #define VMS_EPOCH_OFFSET 35067168000000000LL
9487 #define VMS_GRANULARITY_FACTOR 10000000
9489 /* Display a VMS time in a human readable format. */
9492 print_vms_time (bfd_int64_t vmstime
)
9497 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9498 tm
= gmtime (&unxtime
);
9499 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9500 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9501 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9506 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9508 switch (entry
->d_tag
)
9510 case DT_IA_64_PLT_RESERVE
:
9511 /* First 3 slots reserved. */
9512 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9514 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9517 case DT_IA_64_VMS_LINKTIME
:
9519 print_vms_time (entry
->d_un
.d_val
);
9523 case DT_IA_64_VMS_LNKFLAGS
:
9524 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9525 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9526 printf (" CALL_DEBUG");
9527 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9528 printf (" NOP0BUFS");
9529 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9530 printf (" P0IMAGE");
9531 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9532 printf (" MKTHREADS");
9533 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9534 printf (" UPCALLS");
9535 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9537 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9538 printf (" INITIALIZE");
9539 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9541 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9542 printf (" EXE_INIT");
9543 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9544 printf (" TBK_IN_IMG");
9545 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9546 printf (" DBG_IN_IMG");
9547 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9548 printf (" TBK_IN_DSF");
9549 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9550 printf (" DBG_IN_DSF");
9551 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9552 printf (" SIGNATURES");
9553 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9554 printf (" REL_SEG_OFF");
9558 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9565 get_32bit_dynamic_section (Filedata
* filedata
)
9567 Elf32_External_Dyn
* edyn
;
9568 Elf32_External_Dyn
* ext
;
9569 Elf_Internal_Dyn
* entry
;
9571 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9572 dynamic_size
, _("dynamic section"));
9576 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9577 might not have the luxury of section headers. Look for the DT_NULL
9578 terminator to determine the number of entries. */
9579 for (ext
= edyn
, dynamic_nent
= 0;
9580 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9584 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9588 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9590 if (dynamic_section
== NULL
)
9592 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9593 (unsigned long) dynamic_nent
);
9598 for (ext
= edyn
, entry
= dynamic_section
;
9599 entry
< dynamic_section
+ dynamic_nent
;
9602 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9603 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9612 get_64bit_dynamic_section (Filedata
* filedata
)
9614 Elf64_External_Dyn
* edyn
;
9615 Elf64_External_Dyn
* ext
;
9616 Elf_Internal_Dyn
* entry
;
9618 /* Read in the data. */
9619 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9620 dynamic_size
, _("dynamic section"));
9624 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9625 might not have the luxury of section headers. Look for the DT_NULL
9626 terminator to determine the number of entries. */
9627 for (ext
= edyn
, dynamic_nent
= 0;
9628 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9629 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9633 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9637 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9639 if (dynamic_section
== NULL
)
9641 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9642 (unsigned long) dynamic_nent
);
9647 /* Convert from external to internal formats. */
9648 for (ext
= edyn
, entry
= dynamic_section
;
9649 entry
< dynamic_section
+ dynamic_nent
;
9652 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9653 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9662 print_dynamic_flags (bfd_vma flags
)
9664 bfd_boolean first
= TRUE
;
9670 flag
= flags
& - flags
;
9680 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9681 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9682 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9683 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9684 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9685 default: fputs (_("unknown"), stdout
); break;
9691 /* Parse and display the contents of the dynamic section. */
9694 process_dynamic_section (Filedata
* filedata
)
9696 Elf_Internal_Dyn
* entry
;
9698 if (dynamic_size
== 0)
9701 printf (_("\nThere is no dynamic section in this file.\n"));
9708 if (! get_32bit_dynamic_section (filedata
))
9713 if (! get_64bit_dynamic_section (filedata
))
9717 /* Find the appropriate symbol table. */
9718 if (dynamic_symbols
== NULL
)
9720 for (entry
= dynamic_section
;
9721 entry
< dynamic_section
+ dynamic_nent
;
9724 Elf_Internal_Shdr section
;
9726 if (entry
->d_tag
!= DT_SYMTAB
)
9729 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9731 /* Since we do not know how big the symbol table is,
9732 we default to reading in the entire file (!) and
9733 processing that. This is overkill, I know, but it
9735 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9736 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9738 /* See PR 21379 for a reproducer. */
9739 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9743 if (archive_file_offset
!= 0)
9744 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9746 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9749 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9751 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9752 section
.sh_name
= filedata
->string_table_length
;
9754 if (dynamic_symbols
!= NULL
)
9756 error (_("Multiple dynamic symbol table sections found\n"));
9757 free (dynamic_symbols
);
9759 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9760 if (num_dynamic_syms
< 1)
9762 error (_("Unable to determine the number of symbols to load\n"));
9768 /* Similarly find a string table. */
9769 if (dynamic_strings
== NULL
)
9771 for (entry
= dynamic_section
;
9772 entry
< dynamic_section
+ dynamic_nent
;
9775 unsigned long offset
;
9778 if (entry
->d_tag
!= DT_STRTAB
)
9781 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9783 /* Since we do not know how big the string table is,
9784 we default to reading in the entire file (!) and
9785 processing that. This is overkill, I know, but it
9788 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9790 if (archive_file_offset
!= 0)
9791 str_tab_len
= archive_file_size
- offset
;
9793 str_tab_len
= filedata
->file_size
- offset
;
9795 if (str_tab_len
< 1)
9798 (_("Unable to determine the length of the dynamic string table\n"));
9802 if (dynamic_strings
!= NULL
)
9804 error (_("Multiple dynamic string tables found\n"));
9805 free (dynamic_strings
);
9808 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9810 _("dynamic string table"));
9811 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9815 /* And find the syminfo section if available. */
9816 if (dynamic_syminfo
== NULL
)
9818 unsigned long syminsz
= 0;
9820 for (entry
= dynamic_section
;
9821 entry
< dynamic_section
+ dynamic_nent
;
9824 if (entry
->d_tag
== DT_SYMINENT
)
9826 /* Note: these braces are necessary to avoid a syntax
9827 error from the SunOS4 C compiler. */
9828 /* PR binutils/17531: A corrupt file can trigger this test.
9829 So do not use an assert, instead generate an error message. */
9830 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9831 error (_("Bad value (%d) for SYMINENT entry\n"),
9832 (int) entry
->d_un
.d_val
);
9834 else if (entry
->d_tag
== DT_SYMINSZ
)
9835 syminsz
= entry
->d_un
.d_val
;
9836 else if (entry
->d_tag
== DT_SYMINFO
)
9837 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9841 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9843 Elf_External_Syminfo
* extsyminfo
;
9844 Elf_External_Syminfo
* extsym
;
9845 Elf_Internal_Syminfo
* syminfo
;
9847 /* There is a syminfo section. Read the data. */
9848 extsyminfo
= (Elf_External_Syminfo
*)
9849 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9850 _("symbol information"));
9854 if (dynamic_syminfo
!= NULL
)
9856 error (_("Multiple dynamic symbol information sections found\n"));
9857 free (dynamic_syminfo
);
9859 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9860 if (dynamic_syminfo
== NULL
)
9862 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9863 (unsigned long) syminsz
);
9867 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9868 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9869 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9870 ++syminfo
, ++extsym
)
9872 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9873 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9880 if (do_dynamic
&& dynamic_addr
)
9881 printf (ngettext ("\nDynamic section at offset 0x%lx "
9882 "contains %lu entry:\n",
9883 "\nDynamic section at offset 0x%lx "
9884 "contains %lu entries:\n",
9886 dynamic_addr
, (unsigned long) dynamic_nent
);
9888 printf (_(" Tag Type Name/Value\n"));
9890 for (entry
= dynamic_section
;
9891 entry
< dynamic_section
+ dynamic_nent
;
9899 print_vma (entry
->d_tag
, FULL_HEX
);
9900 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9901 printf (" (%s)%*s", dtype
,
9902 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9905 switch (entry
->d_tag
)
9909 print_dynamic_flags (entry
->d_un
.d_val
);
9919 switch (entry
->d_tag
)
9922 printf (_("Auxiliary library"));
9926 printf (_("Filter library"));
9930 printf (_("Configuration file"));
9934 printf (_("Dependency audit library"));
9938 printf (_("Audit library"));
9942 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9943 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9947 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9956 printf (_("Flags:"));
9958 if (entry
->d_un
.d_val
== 0)
9959 printf (_(" None\n"));
9962 unsigned long int val
= entry
->d_un
.d_val
;
9964 if (val
& DTF_1_PARINIT
)
9966 printf (" PARINIT");
9967 val
^= DTF_1_PARINIT
;
9969 if (val
& DTF_1_CONFEXP
)
9971 printf (" CONFEXP");
9972 val
^= DTF_1_CONFEXP
;
9975 printf (" %lx", val
);
9984 printf (_("Flags:"));
9986 if (entry
->d_un
.d_val
== 0)
9987 printf (_(" None\n"));
9990 unsigned long int val
= entry
->d_un
.d_val
;
9992 if (val
& DF_P1_LAZYLOAD
)
9994 printf (" LAZYLOAD");
9995 val
^= DF_P1_LAZYLOAD
;
9997 if (val
& DF_P1_GROUPPERM
)
9999 printf (" GROUPPERM");
10000 val
^= DF_P1_GROUPPERM
;
10003 printf (" %lx", val
);
10012 printf (_("Flags:"));
10013 if (entry
->d_un
.d_val
== 0)
10014 printf (_(" None\n"));
10017 unsigned long int val
= entry
->d_un
.d_val
;
10019 if (val
& DF_1_NOW
)
10024 if (val
& DF_1_GLOBAL
)
10026 printf (" GLOBAL");
10027 val
^= DF_1_GLOBAL
;
10029 if (val
& DF_1_GROUP
)
10034 if (val
& DF_1_NODELETE
)
10036 printf (" NODELETE");
10037 val
^= DF_1_NODELETE
;
10039 if (val
& DF_1_LOADFLTR
)
10041 printf (" LOADFLTR");
10042 val
^= DF_1_LOADFLTR
;
10044 if (val
& DF_1_INITFIRST
)
10046 printf (" INITFIRST");
10047 val
^= DF_1_INITFIRST
;
10049 if (val
& DF_1_NOOPEN
)
10051 printf (" NOOPEN");
10052 val
^= DF_1_NOOPEN
;
10054 if (val
& DF_1_ORIGIN
)
10056 printf (" ORIGIN");
10057 val
^= DF_1_ORIGIN
;
10059 if (val
& DF_1_DIRECT
)
10061 printf (" DIRECT");
10062 val
^= DF_1_DIRECT
;
10064 if (val
& DF_1_TRANS
)
10069 if (val
& DF_1_INTERPOSE
)
10071 printf (" INTERPOSE");
10072 val
^= DF_1_INTERPOSE
;
10074 if (val
& DF_1_NODEFLIB
)
10076 printf (" NODEFLIB");
10077 val
^= DF_1_NODEFLIB
;
10079 if (val
& DF_1_NODUMP
)
10081 printf (" NODUMP");
10082 val
^= DF_1_NODUMP
;
10084 if (val
& DF_1_CONFALT
)
10086 printf (" CONFALT");
10087 val
^= DF_1_CONFALT
;
10089 if (val
& DF_1_ENDFILTEE
)
10091 printf (" ENDFILTEE");
10092 val
^= DF_1_ENDFILTEE
;
10094 if (val
& DF_1_DISPRELDNE
)
10096 printf (" DISPRELDNE");
10097 val
^= DF_1_DISPRELDNE
;
10099 if (val
& DF_1_DISPRELPND
)
10101 printf (" DISPRELPND");
10102 val
^= DF_1_DISPRELPND
;
10104 if (val
& DF_1_NODIRECT
)
10106 printf (" NODIRECT");
10107 val
^= DF_1_NODIRECT
;
10109 if (val
& DF_1_IGNMULDEF
)
10111 printf (" IGNMULDEF");
10112 val
^= DF_1_IGNMULDEF
;
10114 if (val
& DF_1_NOKSYMS
)
10116 printf (" NOKSYMS");
10117 val
^= DF_1_NOKSYMS
;
10119 if (val
& DF_1_NOHDR
)
10124 if (val
& DF_1_EDITED
)
10126 printf (" EDITED");
10127 val
^= DF_1_EDITED
;
10129 if (val
& DF_1_NORELOC
)
10131 printf (" NORELOC");
10132 val
^= DF_1_NORELOC
;
10134 if (val
& DF_1_SYMINTPOSE
)
10136 printf (" SYMINTPOSE");
10137 val
^= DF_1_SYMINTPOSE
;
10139 if (val
& DF_1_GLOBAUDIT
)
10141 printf (" GLOBAUDIT");
10142 val
^= DF_1_GLOBAUDIT
;
10144 if (val
& DF_1_SINGLETON
)
10146 printf (" SINGLETON");
10147 val
^= DF_1_SINGLETON
;
10149 if (val
& DF_1_STUB
)
10154 if (val
& DF_1_PIE
)
10159 if (val
& DF_1_KMOD
)
10164 if (val
& DF_1_WEAKFILTER
)
10166 printf (" WEAKFILTER");
10167 val
^= DF_1_WEAKFILTER
;
10169 if (val
& DF_1_NOCOMMON
)
10171 printf (" NOCOMMON");
10172 val
^= DF_1_NOCOMMON
;
10175 printf (" %lx", val
);
10182 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10184 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10204 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10210 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10211 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10217 switch (entry
->d_tag
)
10220 printf (_("Shared library: [%s]"), name
);
10222 if (streq (name
, program_interpreter
))
10223 printf (_(" program interpreter"));
10227 printf (_("Library soname: [%s]"), name
);
10231 printf (_("Library rpath: [%s]"), name
);
10235 printf (_("Library runpath: [%s]"), name
);
10239 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10244 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10257 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10258 /* Fall through. */
10262 case DT_INIT_ARRAYSZ
:
10263 case DT_FINI_ARRAYSZ
:
10264 case DT_GNU_CONFLICTSZ
:
10265 case DT_GNU_LIBLISTSZ
:
10268 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10269 printf (_(" (bytes)\n"));
10274 case DT_VERNEEDNUM
:
10279 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10288 case DT_INIT_ARRAY
:
10289 case DT_FINI_ARRAY
:
10292 if (entry
->d_tag
== DT_USED
10293 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10295 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10299 printf (_("Not needed object: [%s]\n"), name
);
10304 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10310 /* The value of this entry is ignored. */
10315 case DT_GNU_PRELINKED
:
10319 time_t atime
= entry
->d_un
.d_val
;
10321 tmp
= gmtime (&atime
);
10322 /* PR 17533 file: 041-1244816-0.004. */
10324 printf (_("<corrupt time val: %lx"),
10325 (unsigned long) atime
);
10327 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10328 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10329 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10335 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10338 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10344 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10345 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10350 switch (filedata
->file_header
.e_machine
)
10353 case EM_MIPS_RS3_LE
:
10354 dynamic_section_mips_val (entry
);
10357 dynamic_section_parisc_val (entry
);
10360 dynamic_section_ia64_val (entry
);
10363 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10375 get_ver_flags (unsigned int flags
)
10377 static char buff
[128];
10384 if (flags
& VER_FLG_BASE
)
10385 strcat (buff
, "BASE");
10387 if (flags
& VER_FLG_WEAK
)
10389 if (flags
& VER_FLG_BASE
)
10390 strcat (buff
, " | ");
10392 strcat (buff
, "WEAK");
10395 if (flags
& VER_FLG_INFO
)
10397 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10398 strcat (buff
, " | ");
10400 strcat (buff
, "INFO");
10403 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10405 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10406 strcat (buff
, " | ");
10408 strcat (buff
, _("<unknown>"));
10414 /* Display the contents of the version sections. */
10417 process_version_sections (Filedata
* filedata
)
10419 Elf_Internal_Shdr
* section
;
10421 bfd_boolean found
= FALSE
;
10426 for (i
= 0, section
= filedata
->section_headers
;
10427 i
< filedata
->file_header
.e_shnum
;
10430 switch (section
->sh_type
)
10432 case SHT_GNU_verdef
:
10434 Elf_External_Verdef
* edefs
;
10441 printf (ngettext ("\nVersion definition section '%s' "
10442 "contains %u entry:\n",
10443 "\nVersion definition section '%s' "
10444 "contains %u entries:\n",
10446 printable_section_name (filedata
, section
),
10449 printf (_(" Addr: 0x"));
10450 printf_vma (section
->sh_addr
);
10451 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10452 (unsigned long) section
->sh_offset
, section
->sh_link
,
10453 printable_section_name_from_index (filedata
, section
->sh_link
));
10455 edefs
= (Elf_External_Verdef
*)
10456 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10457 _("version definition section"));
10460 endbuf
= (char *) edefs
+ section
->sh_size
;
10462 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10465 Elf_External_Verdef
* edef
;
10466 Elf_Internal_Verdef ent
;
10467 Elf_External_Verdaux
* eaux
;
10468 Elf_Internal_Verdaux aux
;
10469 unsigned long isum
;
10472 vstart
= ((char *) edefs
) + idx
;
10473 if (vstart
+ sizeof (*edef
) > endbuf
)
10476 edef
= (Elf_External_Verdef
*) vstart
;
10478 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10479 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10480 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10481 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10482 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10483 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10484 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10486 printf (_(" %#06lx: Rev: %d Flags: %s"),
10487 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10489 printf (_(" Index: %d Cnt: %d "),
10490 ent
.vd_ndx
, ent
.vd_cnt
);
10492 /* Check for overflow. */
10493 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10496 vstart
+= ent
.vd_aux
;
10498 if (vstart
+ sizeof (*eaux
) > endbuf
)
10500 eaux
= (Elf_External_Verdaux
*) vstart
;
10502 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10503 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10505 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10506 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10508 printf (_("Name index: %ld\n"), aux
.vda_name
);
10510 isum
= idx
+ ent
.vd_aux
;
10512 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10514 if (aux
.vda_next
< sizeof (*eaux
)
10515 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10517 warn (_("Invalid vda_next field of %lx\n"),
10522 /* Check for overflow. */
10523 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10526 isum
+= aux
.vda_next
;
10527 vstart
+= aux
.vda_next
;
10529 if (vstart
+ sizeof (*eaux
) > endbuf
)
10531 eaux
= (Elf_External_Verdaux
*) vstart
;
10533 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10534 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10536 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10537 printf (_(" %#06lx: Parent %d: %s\n"),
10538 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10540 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10541 isum
, j
, aux
.vda_name
);
10544 if (j
< ent
.vd_cnt
)
10545 printf (_(" Version def aux past end of section\n"));
10548 file: id:000001,src:000172+005151,op:splice,rep:2. */
10549 if (ent
.vd_next
< sizeof (*edef
)
10550 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10552 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10553 cnt
= section
->sh_info
;
10556 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10559 idx
+= ent
.vd_next
;
10562 if (cnt
< section
->sh_info
)
10563 printf (_(" Version definition past end of section\n"));
10569 case SHT_GNU_verneed
:
10571 Elf_External_Verneed
* eneed
;
10578 printf (ngettext ("\nVersion needs section '%s' "
10579 "contains %u entry:\n",
10580 "\nVersion needs section '%s' "
10581 "contains %u entries:\n",
10583 printable_section_name (filedata
, section
), section
->sh_info
);
10585 printf (_(" Addr: 0x"));
10586 printf_vma (section
->sh_addr
);
10587 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10588 (unsigned long) section
->sh_offset
, section
->sh_link
,
10589 printable_section_name_from_index (filedata
, section
->sh_link
));
10591 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10592 section
->sh_offset
, 1,
10594 _("Version Needs section"));
10597 endbuf
= (char *) eneed
+ section
->sh_size
;
10599 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10601 Elf_External_Verneed
* entry
;
10602 Elf_Internal_Verneed ent
;
10603 unsigned long isum
;
10607 vstart
= ((char *) eneed
) + idx
;
10608 if (vstart
+ sizeof (*entry
) > endbuf
)
10611 entry
= (Elf_External_Verneed
*) vstart
;
10613 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10614 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10615 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10616 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10617 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10619 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10621 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10622 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10624 printf (_(" File: %lx"), ent
.vn_file
);
10626 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10628 /* Check for overflow. */
10629 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10631 vstart
+= ent
.vn_aux
;
10633 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10635 Elf_External_Vernaux
* eaux
;
10636 Elf_Internal_Vernaux aux
;
10638 if (vstart
+ sizeof (*eaux
) > endbuf
)
10640 eaux
= (Elf_External_Vernaux
*) vstart
;
10642 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10643 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10644 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10645 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10646 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10648 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10649 printf (_(" %#06lx: Name: %s"),
10650 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10652 printf (_(" %#06lx: Name index: %lx"),
10653 isum
, aux
.vna_name
);
10655 printf (_(" Flags: %s Version: %d\n"),
10656 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10658 if (aux
.vna_next
< sizeof (*eaux
)
10659 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10661 warn (_("Invalid vna_next field of %lx\n"),
10666 /* Check for overflow. */
10667 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10669 isum
+= aux
.vna_next
;
10670 vstart
+= aux
.vna_next
;
10673 if (j
< ent
.vn_cnt
)
10674 warn (_("Missing Version Needs auxillary information\n"));
10676 if (ent
.vn_next
< sizeof (*entry
)
10677 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10679 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10680 cnt
= section
->sh_info
;
10683 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10685 idx
+= ent
.vn_next
;
10688 if (cnt
< section
->sh_info
)
10689 warn (_("Missing Version Needs information\n"));
10695 case SHT_GNU_versym
:
10697 Elf_Internal_Shdr
* link_section
;
10700 unsigned char * edata
;
10701 unsigned short * data
;
10703 Elf_Internal_Sym
* symbols
;
10704 Elf_Internal_Shdr
* string_sec
;
10705 unsigned long num_syms
;
10708 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10711 link_section
= filedata
->section_headers
+ section
->sh_link
;
10712 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10714 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10719 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10720 if (symbols
== NULL
)
10723 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10725 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10726 string_sec
->sh_size
,
10727 _("version string table"));
10734 printf (ngettext ("\nVersion symbols section '%s' "
10735 "contains %lu entry:\n",
10736 "\nVersion symbols section '%s' "
10737 "contains %lu entries:\n",
10739 printable_section_name (filedata
, section
), (unsigned long) total
);
10741 printf (_(" Addr: "));
10742 printf_vma (section
->sh_addr
);
10743 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10744 (unsigned long) section
->sh_offset
, section
->sh_link
,
10745 printable_section_name (filedata
, link_section
));
10747 off
= offset_from_vma (filedata
,
10748 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10749 total
* sizeof (short));
10750 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10752 _("version symbol data"));
10760 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10762 for (cnt
= total
; cnt
--;)
10763 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10768 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10772 char *invalid
= _("*invalid*");
10774 printf (" %03x:", cnt
);
10776 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10777 switch (data
[cnt
+ j
])
10780 fputs (_(" 0 (*local*) "), stdout
);
10784 fputs (_(" 1 (*global*) "), stdout
);
10788 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10789 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10791 /* If this index value is greater than the size of the symbols
10792 array, break to avoid an out-of-bounds read. */
10793 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10795 warn (_("invalid index into symbol array\n"));
10800 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10802 Elf_Internal_Verneed ivn
;
10803 unsigned long offset
;
10805 offset
= offset_from_vma
10806 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10807 sizeof (Elf_External_Verneed
));
10811 Elf_Internal_Vernaux ivna
;
10812 Elf_External_Verneed evn
;
10813 Elf_External_Vernaux evna
;
10814 unsigned long a_off
;
10816 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10817 _("version need")) == NULL
)
10820 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10821 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10823 a_off
= offset
+ ivn
.vn_aux
;
10827 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10828 1, _("version need aux (2)")) == NULL
)
10831 ivna
.vna_other
= 0;
10835 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10836 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10839 a_off
+= ivna
.vna_next
;
10841 while (ivna
.vna_other
!= data
[cnt
+ j
]
10842 && ivna
.vna_next
!= 0);
10844 if (ivna
.vna_other
== data
[cnt
+ j
])
10846 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10848 if (ivna
.vna_name
>= string_sec
->sh_size
)
10851 name
= strtab
+ ivna
.vna_name
;
10855 offset
+= ivn
.vn_next
;
10857 while (ivn
.vn_next
);
10860 if (data
[cnt
+ j
] != 0x8001
10861 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10863 Elf_Internal_Verdef ivd
;
10864 Elf_External_Verdef evd
;
10865 unsigned long offset
;
10867 offset
= offset_from_vma
10868 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10873 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10874 _("version def")) == NULL
)
10877 /* PR 17531: file: 046-1082287-0.004. */
10878 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10883 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10884 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10887 offset
+= ivd
.vd_next
;
10889 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10890 && ivd
.vd_next
!= 0);
10892 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10894 Elf_External_Verdaux evda
;
10895 Elf_Internal_Verdaux ivda
;
10897 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10899 if (get_data (&evda
, filedata
,
10900 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10902 _("version def aux")) == NULL
)
10905 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10907 if (ivda
.vda_name
>= string_sec
->sh_size
)
10909 else if (name
!= NULL
&& name
!= invalid
)
10910 name
= _("*both*");
10912 name
= strtab
+ ivda
.vda_name
;
10916 nn
+= printf ("(%s%-*s",
10918 12 - (int) strlen (name
),
10922 printf ("%*c", 18 - nn
, ' ');
10940 printf (_("\nNo version information found in this file.\n"));
10945 static const char *
10946 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10948 static char buff
[32];
10952 case STB_LOCAL
: return "LOCAL";
10953 case STB_GLOBAL
: return "GLOBAL";
10954 case STB_WEAK
: return "WEAK";
10956 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10957 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10959 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10961 if (binding
== STB_GNU_UNIQUE
10962 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10963 /* GNU is still using the default value 0. */
10964 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10966 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10969 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10974 static const char *
10975 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10977 static char buff
[32];
10981 case STT_NOTYPE
: return "NOTYPE";
10982 case STT_OBJECT
: return "OBJECT";
10983 case STT_FUNC
: return "FUNC";
10984 case STT_SECTION
: return "SECTION";
10985 case STT_FILE
: return "FILE";
10986 case STT_COMMON
: return "COMMON";
10987 case STT_TLS
: return "TLS";
10988 case STT_RELC
: return "RELC";
10989 case STT_SRELC
: return "SRELC";
10991 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10993 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10994 return "THUMB_FUNC";
10996 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10999 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11000 return "PARISC_MILLI";
11002 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11004 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11006 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11008 if (type
== STT_HP_OPAQUE
)
11009 return "HP_OPAQUE";
11010 if (type
== STT_HP_STUB
)
11014 if (type
== STT_GNU_IFUNC
11015 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11016 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
11017 /* GNU is still using the default value 0. */
11018 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
11021 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11024 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11029 static const char *
11030 get_symbol_visibility (unsigned int visibility
)
11032 switch (visibility
)
11034 case STV_DEFAULT
: return "DEFAULT";
11035 case STV_INTERNAL
: return "INTERNAL";
11036 case STV_HIDDEN
: return "HIDDEN";
11037 case STV_PROTECTED
: return "PROTECTED";
11039 error (_("Unrecognized visibility value: %u"), visibility
);
11040 return _("<unknown>");
11044 static const char *
11045 get_solaris_symbol_visibility (unsigned int visibility
)
11047 switch (visibility
)
11049 case 4: return "EXPORTED";
11050 case 5: return "SINGLETON";
11051 case 6: return "ELIMINATE";
11052 default: return get_symbol_visibility (visibility
);
11056 static const char *
11057 get_mips_symbol_other (unsigned int other
)
11061 case STO_OPTIONAL
: return "OPTIONAL";
11062 case STO_MIPS_PLT
: return "MIPS PLT";
11063 case STO_MIPS_PIC
: return "MIPS PIC";
11064 case STO_MICROMIPS
: return "MICROMIPS";
11065 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11066 case STO_MIPS16
: return "MIPS16";
11067 default: return NULL
;
11071 static const char *
11072 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11074 if (is_ia64_vms (filedata
))
11076 static char res
[32];
11080 /* Function types is for images and .STB files only. */
11081 switch (filedata
->file_header
.e_type
)
11085 switch (VMS_ST_FUNC_TYPE (other
))
11087 case VMS_SFT_CODE_ADDR
:
11088 strcat (res
, " CA");
11090 case VMS_SFT_SYMV_IDX
:
11091 strcat (res
, " VEC");
11094 strcat (res
, " FD");
11096 case VMS_SFT_RESERVE
:
11097 strcat (res
, " RSV");
11100 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11101 VMS_ST_FUNC_TYPE (other
));
11102 strcat (res
, " <unknown>");
11109 switch (VMS_ST_LINKAGE (other
))
11111 case VMS_STL_IGNORE
:
11112 strcat (res
, " IGN");
11114 case VMS_STL_RESERVE
:
11115 strcat (res
, " RSV");
11118 strcat (res
, " STD");
11121 strcat (res
, " LNK");
11124 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11125 VMS_ST_LINKAGE (other
));
11126 strcat (res
, " <unknown>");
11138 static const char *
11139 get_ppc64_symbol_other (unsigned int other
)
11141 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11144 other
>>= STO_PPC64_LOCAL_BIT
;
11147 static char buf
[32];
11149 other
= ppc64_decode_local_entry (other
);
11150 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11156 static const char *
11157 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11159 const char * result
= NULL
;
11160 static char buff
[32];
11165 switch (filedata
->file_header
.e_machine
)
11168 result
= get_mips_symbol_other (other
);
11171 result
= get_ia64_symbol_other (filedata
, other
);
11174 result
= get_ppc64_symbol_other (other
);
11184 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11188 static const char *
11189 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11191 static char buff
[32];
11195 case SHN_UNDEF
: return "UND";
11196 case SHN_ABS
: return "ABS";
11197 case SHN_COMMON
: return "COM";
11199 if (type
== SHN_IA_64_ANSI_COMMON
11200 && filedata
->file_header
.e_machine
== EM_IA_64
11201 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11203 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11204 || filedata
->file_header
.e_machine
== EM_L1OM
11205 || filedata
->file_header
.e_machine
== EM_K1OM
)
11206 && type
== SHN_X86_64_LCOMMON
)
11207 return "LARGE_COM";
11208 else if ((type
== SHN_MIPS_SCOMMON
11209 && filedata
->file_header
.e_machine
== EM_MIPS
)
11210 || (type
== SHN_TIC6X_SCOMMON
11211 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11213 else if (type
== SHN_MIPS_SUNDEFINED
11214 && filedata
->file_header
.e_machine
== EM_MIPS
)
11216 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11217 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11218 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11219 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11220 else if (type
>= SHN_LORESERVE
)
11221 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11222 else if (type
>= filedata
->file_header
.e_shnum
)
11223 sprintf (buff
, _("bad section index[%3d]"), type
);
11225 sprintf (buff
, "%3d", type
);
11233 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11235 unsigned char * e_data
;
11238 /* If the size_t type is smaller than the bfd_size_type, eg because
11239 you are building a 32-bit tool on a 64-bit host, then make sure
11240 that when (number) is cast to (size_t) no information is lost. */
11241 if (sizeof (size_t) < sizeof (bfd_size_type
)
11242 && (bfd_size_type
) ((size_t) number
) != number
)
11244 error (_("Size truncation prevents reading %s elements of size %u\n"),
11245 bfd_vmatoa ("u", number
), ent_size
);
11249 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11250 attempting to allocate memory when the read is bound to fail. */
11251 if (ent_size
* number
> filedata
->file_size
)
11253 error (_("Invalid number of dynamic entries: %s\n"),
11254 bfd_vmatoa ("u", number
));
11258 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11259 if (e_data
== NULL
)
11261 error (_("Out of memory reading %s dynamic entries\n"),
11262 bfd_vmatoa ("u", number
));
11266 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11268 error (_("Unable to read in %s bytes of dynamic data\n"),
11269 bfd_vmatoa ("u", number
* ent_size
));
11274 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11275 if (i_data
== NULL
)
11277 error (_("Out of memory allocating space for %s dynamic entries\n"),
11278 bfd_vmatoa ("u", number
));
11284 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11292 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11294 Elf_Internal_Sym
* psym
;
11297 n
= print_vma (si
, DEC_5
);
11299 fputs (&" "[n
], stdout
);
11300 printf (" %3lu: ", hn
);
11302 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11304 printf (_("<No info available for dynamic symbol number %lu>\n"),
11305 (unsigned long) si
);
11309 psym
= dynamic_symbols
+ si
;
11310 print_vma (psym
->st_value
, LONG_HEX
);
11312 print_vma (psym
->st_size
, DEC_5
);
11314 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11315 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11317 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11318 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11321 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11323 printf (" %-7s", get_symbol_visibility (vis
));
11324 /* Check to see if any other bits in the st_other field are set.
11325 Note - displaying this information disrupts the layout of the
11326 table being generated, but for the moment this case is very
11328 if (psym
->st_other
^ vis
)
11329 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11332 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11333 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11334 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11336 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11340 static const char *
11341 get_symbol_version_string (Filedata
* filedata
,
11342 bfd_boolean is_dynsym
,
11343 const char * strtab
,
11344 unsigned long int strtab_size
,
11346 Elf_Internal_Sym
* psym
,
11347 enum versioned_symbol_info
* sym_info
,
11348 unsigned short * vna_other
)
11350 unsigned char data
[2];
11351 unsigned short vers_data
;
11352 unsigned long offset
;
11353 unsigned short max_vd_ndx
;
11356 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11359 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11360 sizeof data
+ si
* sizeof (vers_data
));
11362 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11363 sizeof (data
), 1, _("version data")) == NULL
)
11366 vers_data
= byte_get (data
, 2);
11368 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11373 /* Usually we'd only see verdef for defined symbols, and verneed for
11374 undefined symbols. However, symbols defined by the linker in
11375 .dynbss for variables copied from a shared library in order to
11376 avoid text relocations are defined yet have verneed. We could
11377 use a heuristic to detect the special case, for example, check
11378 for verneed first on symbols defined in SHT_NOBITS sections, but
11379 it is simpler and more reliable to just look for both verdef and
11380 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11382 if (psym
->st_shndx
!= SHN_UNDEF
11383 && vers_data
!= 0x8001
11384 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11386 Elf_Internal_Verdef ivd
;
11387 Elf_Internal_Verdaux ivda
;
11388 Elf_External_Verdaux evda
;
11391 off
= offset_from_vma (filedata
,
11392 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11393 sizeof (Elf_External_Verdef
));
11397 Elf_External_Verdef evd
;
11399 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11400 _("version def")) == NULL
)
11409 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11410 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11411 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11412 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11415 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11416 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11418 off
+= ivd
.vd_next
;
11420 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11422 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11424 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11427 off
-= ivd
.vd_next
;
11430 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11431 _("version def aux")) != NULL
)
11433 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11435 if (psym
->st_name
!= ivda
.vda_name
)
11437 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11438 ? symbol_hidden
: symbol_public
);
11439 return (ivda
.vda_name
< strtab_size
11440 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11446 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11448 Elf_External_Verneed evn
;
11449 Elf_Internal_Verneed ivn
;
11450 Elf_Internal_Vernaux ivna
;
11452 offset
= offset_from_vma (filedata
,
11453 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11457 unsigned long vna_off
;
11459 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11460 _("version need")) == NULL
)
11463 ivna
.vna_other
= 0;
11468 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11469 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11471 vna_off
= offset
+ ivn
.vn_aux
;
11475 Elf_External_Vernaux evna
;
11477 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11478 _("version need aux (3)")) == NULL
)
11481 ivna
.vna_other
= 0;
11486 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11487 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11488 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11491 vna_off
+= ivna
.vna_next
;
11493 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11495 if (ivna
.vna_other
== vers_data
)
11498 offset
+= ivn
.vn_next
;
11500 while (ivn
.vn_next
!= 0);
11502 if (ivna
.vna_other
== vers_data
)
11504 *sym_info
= symbol_undefined
;
11505 *vna_other
= ivna
.vna_other
;
11506 return (ivna
.vna_name
< strtab_size
11507 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11509 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11510 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11511 return _("<corrupt>");
11516 /* Dump the symbol table. */
11518 process_symbol_table (Filedata
* filedata
)
11520 Elf_Internal_Shdr
* section
;
11521 bfd_size_type nbuckets
= 0;
11522 bfd_size_type nchains
= 0;
11523 bfd_vma
* buckets
= NULL
;
11524 bfd_vma
* chains
= NULL
;
11525 bfd_vma ngnubuckets
= 0;
11526 bfd_vma
* gnubuckets
= NULL
;
11527 bfd_vma
* gnuchains
= NULL
;
11528 bfd_vma gnusymidx
= 0;
11529 bfd_size_type ngnuchains
= 0;
11531 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11534 if (dynamic_info
[DT_HASH
]
11536 || (do_using_dynamic
11538 && dynamic_strings
!= NULL
)))
11540 unsigned char nb
[8];
11541 unsigned char nc
[8];
11542 unsigned int hash_ent_size
= 4;
11544 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11545 || filedata
->file_header
.e_machine
== EM_S390
11546 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11547 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11550 if (fseek (filedata
->handle
,
11551 (archive_file_offset
11552 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11553 sizeof nb
+ sizeof nc
)),
11556 error (_("Unable to seek to start of dynamic information\n"));
11560 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11562 error (_("Failed to read in number of buckets\n"));
11566 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11568 error (_("Failed to read in number of chains\n"));
11572 nbuckets
= byte_get (nb
, hash_ent_size
);
11573 nchains
= byte_get (nc
, hash_ent_size
);
11575 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11576 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11579 if (buckets
== NULL
|| chains
== NULL
)
11581 if (do_using_dynamic
)
11592 if (dynamic_info_DT_GNU_HASH
11594 || (do_using_dynamic
11596 && dynamic_strings
!= NULL
)))
11598 unsigned char nb
[16];
11599 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11600 bfd_vma buckets_vma
;
11602 if (fseek (filedata
->handle
,
11603 (archive_file_offset
11604 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11608 error (_("Unable to seek to start of dynamic information\n"));
11612 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11614 error (_("Failed to read in number of buckets\n"));
11618 ngnubuckets
= byte_get (nb
, 4);
11619 gnusymidx
= byte_get (nb
+ 4, 4);
11620 bitmaskwords
= byte_get (nb
+ 8, 4);
11621 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11623 buckets_vma
+= bitmaskwords
* 4;
11625 buckets_vma
+= bitmaskwords
* 8;
11627 if (fseek (filedata
->handle
,
11628 (archive_file_offset
11629 + offset_from_vma (filedata
, buckets_vma
, 4)),
11632 error (_("Unable to seek to start of dynamic information\n"));
11636 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11638 if (gnubuckets
== NULL
)
11641 for (i
= 0; i
< ngnubuckets
; i
++)
11642 if (gnubuckets
[i
] != 0)
11644 if (gnubuckets
[i
] < gnusymidx
)
11647 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11648 maxchain
= gnubuckets
[i
];
11651 if (maxchain
== 0xffffffff)
11654 maxchain
-= gnusymidx
;
11656 if (fseek (filedata
->handle
,
11657 (archive_file_offset
11658 + offset_from_vma (filedata
, buckets_vma
11659 + 4 * (ngnubuckets
+ maxchain
), 4)),
11662 error (_("Unable to seek to start of dynamic information\n"));
11668 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11670 error (_("Failed to determine last chain length\n"));
11674 if (maxchain
+ 1 == 0)
11679 while ((byte_get (nb
, 4) & 1) == 0);
11681 if (fseek (filedata
->handle
,
11682 (archive_file_offset
11683 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11686 error (_("Unable to seek to start of dynamic information\n"));
11690 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11691 ngnuchains
= maxchain
;
11694 if (gnuchains
== NULL
)
11699 if (do_using_dynamic
)
11704 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11706 && do_using_dynamic
11707 && dynamic_strings
!= NULL
11708 && dynamic_symbols
!= NULL
)
11712 if (dynamic_info
[DT_HASH
])
11717 printf (_("\nSymbol table for image:\n"));
11719 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11721 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11723 visited
= xcmalloc (nchains
, 1);
11724 memset (visited
, 0, nchains
);
11725 for (hn
= 0; hn
< nbuckets
; hn
++)
11727 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11729 print_dynamic_symbol (filedata
, si
, hn
);
11730 if (si
>= nchains
|| visited
[si
])
11732 error (_("histogram chain is corrupt\n"));
11741 if (dynamic_info_DT_GNU_HASH
)
11743 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11745 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11747 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11749 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11750 if (gnubuckets
[hn
] != 0)
11752 bfd_vma si
= gnubuckets
[hn
];
11753 bfd_vma off
= si
- gnusymidx
;
11757 print_dynamic_symbol (filedata
, si
, hn
);
11760 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11764 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11765 && filedata
->section_headers
!= NULL
)
11769 for (i
= 0, section
= filedata
->section_headers
;
11770 i
< filedata
->file_header
.e_shnum
;
11774 char * strtab
= NULL
;
11775 unsigned long int strtab_size
= 0;
11776 Elf_Internal_Sym
* symtab
;
11777 Elf_Internal_Sym
* psym
;
11778 unsigned long num_syms
;
11780 if ((section
->sh_type
!= SHT_SYMTAB
11781 && section
->sh_type
!= SHT_DYNSYM
)
11783 && section
->sh_type
== SHT_SYMTAB
))
11786 if (section
->sh_entsize
== 0)
11788 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11789 printable_section_name (filedata
, section
));
11793 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11794 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11795 "\nSymbol table '%s' contains %lu entries:\n",
11797 printable_section_name (filedata
, section
),
11801 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11803 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11805 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11806 if (symtab
== NULL
)
11809 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11811 strtab
= filedata
->string_table
;
11812 strtab_size
= filedata
->string_table_length
;
11814 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11816 Elf_Internal_Shdr
* string_sec
;
11818 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11820 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11821 1, string_sec
->sh_size
,
11822 _("string table"));
11823 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11826 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11828 const char *version_string
;
11829 enum versioned_symbol_info sym_info
;
11830 unsigned short vna_other
;
11832 printf ("%6d: ", si
);
11833 print_vma (psym
->st_value
, LONG_HEX
);
11835 print_vma (psym
->st_size
, DEC_5
);
11836 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11837 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11838 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11839 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11842 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11844 printf (" %-7s", get_symbol_visibility (vis
));
11845 /* Check to see if any other bits in the st_other field are set.
11846 Note - displaying this information disrupts the layout of the
11847 table being generated, but for the moment this case is very rare. */
11848 if (psym
->st_other
^ vis
)
11849 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11851 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11852 print_symbol (25, psym
->st_name
< strtab_size
11853 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11856 = get_symbol_version_string (filedata
,
11857 section
->sh_type
== SHT_DYNSYM
,
11858 strtab
, strtab_size
, si
,
11859 psym
, &sym_info
, &vna_other
);
11860 if (version_string
)
11862 if (sym_info
== symbol_undefined
)
11863 printf ("@%s (%d)", version_string
, vna_other
);
11865 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11871 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11872 && si
>= section
->sh_info
11873 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11874 && filedata
->file_header
.e_machine
!= EM_MIPS
11875 /* Solaris binaries have been found to violate this requirement as
11876 well. Not sure if this is a bug or an ABI requirement. */
11877 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11878 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11879 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11883 if (strtab
!= filedata
->string_table
)
11889 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11891 if (do_histogram
&& buckets
!= NULL
)
11893 unsigned long * lengths
;
11894 unsigned long * counts
;
11897 unsigned long maxlength
= 0;
11898 unsigned long nzero_counts
= 0;
11899 unsigned long nsyms
= 0;
11902 printf (ngettext ("\nHistogram for bucket list length "
11903 "(total of %lu bucket):\n",
11904 "\nHistogram for bucket list length "
11905 "(total of %lu buckets):\n",
11906 (unsigned long) nbuckets
),
11907 (unsigned long) nbuckets
);
11909 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11910 if (lengths
== NULL
)
11912 error (_("Out of memory allocating space for histogram buckets\n"));
11915 visited
= xcmalloc (nchains
, 1);
11916 memset (visited
, 0, nchains
);
11918 printf (_(" Length Number %% of total Coverage\n"));
11919 for (hn
= 0; hn
< nbuckets
; ++hn
)
11921 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11924 if (maxlength
< ++lengths
[hn
])
11926 if (si
>= nchains
|| visited
[si
])
11928 error (_("histogram chain is corrupt\n"));
11936 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11937 if (counts
== NULL
)
11940 error (_("Out of memory allocating space for histogram counts\n"));
11944 for (hn
= 0; hn
< nbuckets
; ++hn
)
11945 ++counts
[lengths
[hn
]];
11950 printf (" 0 %-10lu (%5.1f%%)\n",
11951 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11952 for (i
= 1; i
<= maxlength
; ++i
)
11954 nzero_counts
+= counts
[i
] * i
;
11955 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11956 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11957 (nzero_counts
* 100.0) / nsyms
);
11965 if (buckets
!= NULL
)
11971 if (do_histogram
&& gnubuckets
!= NULL
)
11973 unsigned long * lengths
;
11974 unsigned long * counts
;
11976 unsigned long maxlength
= 0;
11977 unsigned long nzero_counts
= 0;
11978 unsigned long nsyms
= 0;
11980 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11981 "(total of %lu bucket):\n",
11982 "\nHistogram for `.gnu.hash' bucket list length "
11983 "(total of %lu buckets):\n",
11984 (unsigned long) ngnubuckets
),
11985 (unsigned long) ngnubuckets
);
11987 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11988 if (lengths
== NULL
)
11990 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11994 printf (_(" Length Number %% of total Coverage\n"));
11996 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11997 if (gnubuckets
[hn
] != 0)
11999 bfd_vma off
, length
= 1;
12001 for (off
= gnubuckets
[hn
] - gnusymidx
;
12002 /* PR 17531 file: 010-77222-0.004. */
12003 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12006 lengths
[hn
] = length
;
12007 if (length
> maxlength
)
12008 maxlength
= length
;
12012 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12013 if (counts
== NULL
)
12016 error (_("Out of memory allocating space for gnu histogram counts\n"));
12020 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12021 ++counts
[lengths
[hn
]];
12023 if (ngnubuckets
> 0)
12026 printf (" 0 %-10lu (%5.1f%%)\n",
12027 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12028 for (j
= 1; j
<= maxlength
; ++j
)
12030 nzero_counts
+= counts
[j
] * j
;
12031 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12032 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12033 (nzero_counts
* 100.0) / nsyms
);
12047 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12051 if (dynamic_syminfo
== NULL
12053 /* No syminfo, this is ok. */
12056 /* There better should be a dynamic symbol section. */
12057 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12061 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12062 "contains %d entry:\n",
12063 "\nDynamic info segment at offset 0x%lx "
12064 "contains %d entries:\n",
12065 dynamic_syminfo_nent
),
12066 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12068 printf (_(" Num: Name BoundTo Flags\n"));
12069 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12071 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12073 printf ("%4d: ", i
);
12074 if (i
>= num_dynamic_syms
)
12075 printf (_("<corrupt index>"));
12076 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12077 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12079 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12082 switch (dynamic_syminfo
[i
].si_boundto
)
12084 case SYMINFO_BT_SELF
:
12085 fputs ("SELF ", stdout
);
12087 case SYMINFO_BT_PARENT
:
12088 fputs ("PARENT ", stdout
);
12091 if (dynamic_syminfo
[i
].si_boundto
> 0
12092 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12093 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12095 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12099 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12103 if (flags
& SYMINFO_FLG_DIRECT
)
12104 printf (" DIRECT");
12105 if (flags
& SYMINFO_FLG_PASSTHRU
)
12106 printf (" PASSTHRU");
12107 if (flags
& SYMINFO_FLG_COPY
)
12109 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12110 printf (" LAZYLOAD");
12118 #define IN_RANGE(START,END,ADDR,OFF) \
12119 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12121 /* Check to see if the given reloc needs to be handled in a target specific
12122 manner. If so then process the reloc and return TRUE otherwise return
12125 If called with reloc == NULL, then this is a signal that reloc processing
12126 for the current section has finished, and any saved state should be
12130 target_specific_reloc_handling (Filedata
* filedata
,
12131 Elf_Internal_Rela
* reloc
,
12132 unsigned char * start
,
12133 unsigned char * end
,
12134 Elf_Internal_Sym
* symtab
,
12135 unsigned long num_syms
)
12137 unsigned int reloc_type
= 0;
12138 unsigned long sym_index
= 0;
12142 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12143 sym_index
= get_reloc_symindex (reloc
->r_info
);
12146 switch (filedata
->file_header
.e_machine
)
12149 case EM_MSP430_OLD
:
12151 static Elf_Internal_Sym
* saved_sym
= NULL
;
12159 switch (reloc_type
)
12161 case 10: /* R_MSP430_SYM_DIFF */
12162 if (uses_msp430x_relocs (filedata
))
12164 /* Fall through. */
12165 case 21: /* R_MSP430X_SYM_DIFF */
12167 if (sym_index
>= num_syms
)
12168 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12171 saved_sym
= symtab
+ sym_index
;
12174 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12175 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12176 goto handle_sym_diff
;
12178 case 5: /* R_MSP430_16_BYTE */
12179 case 9: /* R_MSP430_8 */
12180 if (uses_msp430x_relocs (filedata
))
12182 goto handle_sym_diff
;
12184 case 2: /* R_MSP430_ABS16 */
12185 case 15: /* R_MSP430X_ABS16 */
12186 if (! uses_msp430x_relocs (filedata
))
12188 goto handle_sym_diff
;
12191 if (saved_sym
!= NULL
)
12193 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12196 if (sym_index
>= num_syms
)
12197 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12201 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12202 - saved_sym
->st_value
);
12204 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12205 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12208 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12209 (long) reloc
->r_offset
);
12218 if (saved_sym
!= NULL
)
12219 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12226 case EM_CYGNUS_MN10300
:
12228 static Elf_Internal_Sym
* saved_sym
= NULL
;
12236 switch (reloc_type
)
12238 case 34: /* R_MN10300_ALIGN */
12240 case 33: /* R_MN10300_SYM_DIFF */
12241 if (sym_index
>= num_syms
)
12242 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12245 saved_sym
= symtab
+ sym_index
;
12248 case 1: /* R_MN10300_32 */
12249 case 2: /* R_MN10300_16 */
12250 if (saved_sym
!= NULL
)
12252 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12255 if (sym_index
>= num_syms
)
12256 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12260 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12261 - saved_sym
->st_value
);
12263 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12264 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12266 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12267 (long) reloc
->r_offset
);
12275 if (saved_sym
!= NULL
)
12276 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12284 static bfd_vma saved_sym1
= 0;
12285 static bfd_vma saved_sym2
= 0;
12286 static bfd_vma value
;
12290 saved_sym1
= saved_sym2
= 0;
12294 switch (reloc_type
)
12296 case 0x80: /* R_RL78_SYM. */
12297 saved_sym1
= saved_sym2
;
12298 if (sym_index
>= num_syms
)
12299 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12303 saved_sym2
= symtab
[sym_index
].st_value
;
12304 saved_sym2
+= reloc
->r_addend
;
12308 case 0x83: /* R_RL78_OPsub. */
12309 value
= saved_sym1
- saved_sym2
;
12310 saved_sym2
= saved_sym1
= 0;
12314 case 0x41: /* R_RL78_ABS32. */
12315 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12316 byte_put (start
+ reloc
->r_offset
, value
, 4);
12318 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12319 (long) reloc
->r_offset
);
12323 case 0x43: /* R_RL78_ABS16. */
12324 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12325 byte_put (start
+ reloc
->r_offset
, value
, 2);
12327 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12328 (long) reloc
->r_offset
);
12342 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12343 DWARF debug sections. This is a target specific test. Note - we do not
12344 go through the whole including-target-headers-multiple-times route, (as
12345 we have already done with <elf/h8.h>) because this would become very
12346 messy and even then this function would have to contain target specific
12347 information (the names of the relocs instead of their numeric values).
12348 FIXME: This is not the correct way to solve this problem. The proper way
12349 is to have target specific reloc sizing and typing functions created by
12350 the reloc-macros.h header, in the same way that it already creates the
12351 reloc naming functions. */
12354 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12356 /* Please keep this table alpha-sorted for ease of visual lookup. */
12357 switch (filedata
->file_header
.e_machine
)
12361 return reloc_type
== 1; /* R_386_32. */
12363 return reloc_type
== 1; /* R_68K_32. */
12365 return reloc_type
== 1; /* R_860_32. */
12367 return reloc_type
== 2; /* R_960_32. */
12369 return (reloc_type
== 258
12370 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12371 case EM_ADAPTEVA_EPIPHANY
:
12372 return reloc_type
== 3;
12374 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12376 return reloc_type
== 1; /* R_ARC_32. */
12377 case EM_ARC_COMPACT
:
12378 case EM_ARC_COMPACT2
:
12379 return reloc_type
== 4; /* R_ARC_32. */
12381 return reloc_type
== 2; /* R_ARM_ABS32 */
12384 return reloc_type
== 1;
12386 return reloc_type
== 0x12; /* R_byte4_data. */
12388 return reloc_type
== 3; /* R_CRIS_32. */
12390 return reloc_type
== 3; /* R_CR16_NUM32. */
12392 return reloc_type
== 15; /* R_CRX_NUM32. */
12394 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12395 case EM_CYGNUS_FRV
:
12396 return reloc_type
== 1;
12397 case EM_CYGNUS_D10V
:
12399 return reloc_type
== 6; /* R_D10V_32. */
12400 case EM_CYGNUS_D30V
:
12402 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12404 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12405 case EM_CYGNUS_FR30
:
12407 return reloc_type
== 3; /* R_FR30_32. */
12409 return reloc_type
== 1; /* R_FT32_32. */
12413 return reloc_type
== 1; /* R_H8_DIR32. */
12415 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12416 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12417 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12418 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12421 return reloc_type
== 2; /* R_IP2K_32. */
12423 return reloc_type
== 2; /* R_IQ2000_32. */
12424 case EM_LATTICEMICO32
:
12425 return reloc_type
== 3; /* R_LM32_32. */
12428 return reloc_type
== 3; /* R_M32C_32. */
12430 return reloc_type
== 34; /* R_M32R_32_RELA. */
12433 return reloc_type
== 6; /* R_M68HC11_32. */
12435 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12436 reloc_type
== 6; /* R_S12Z_CW32. */
12438 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12439 case EM_CYGNUS_MEP
:
12440 return reloc_type
== 4; /* R_MEP_32. */
12442 return reloc_type
== 2; /* R_METAG_ADDR32. */
12443 case EM_MICROBLAZE
:
12444 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12446 return reloc_type
== 2; /* R_MIPS_32. */
12448 return reloc_type
== 4; /* R_MMIX_32. */
12449 case EM_CYGNUS_MN10200
:
12451 return reloc_type
== 1; /* R_MN10200_32. */
12452 case EM_CYGNUS_MN10300
:
12454 return reloc_type
== 1; /* R_MN10300_32. */
12456 return reloc_type
== 1; /* R_MOXIE_32. */
12457 case EM_MSP430_OLD
:
12459 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12461 return reloc_type
== 2; /* R_MT_32. */
12463 return reloc_type
== 20; /* R_NDS32_RELA. */
12464 case EM_ALTERA_NIOS2
:
12465 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12467 return reloc_type
== 1; /* R_NIOS_32. */
12469 return reloc_type
== 1; /* R_OR1K_32. */
12471 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12472 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12473 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12476 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12478 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12480 return reloc_type
== 1; /* R_PPC_ADDR32. */
12482 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12484 return reloc_type
== 1; /* R_RISCV_32. */
12486 return reloc_type
== 1; /* R_RL78_DIR32. */
12488 return reloc_type
== 1; /* R_RX_DIR32. */
12490 return reloc_type
== 1; /* R_I370_ADDR31. */
12493 return reloc_type
== 4; /* R_S390_32. */
12495 return reloc_type
== 8; /* R_SCORE_ABS32. */
12497 return reloc_type
== 1; /* R_SH_DIR32. */
12498 case EM_SPARC32PLUS
:
12501 return reloc_type
== 3 /* R_SPARC_32. */
12502 || reloc_type
== 23; /* R_SPARC_UA32. */
12504 return reloc_type
== 6; /* R_SPU_ADDR32 */
12506 return reloc_type
== 1; /* R_C6000_ABS32. */
12508 return reloc_type
== 2; /* R_TILEGX_32. */
12510 return reloc_type
== 1; /* R_TILEPRO_32. */
12511 case EM_CYGNUS_V850
:
12513 return reloc_type
== 6; /* R_V850_ABS32. */
12515 return reloc_type
== 0x33; /* R_V810_WORD. */
12517 return reloc_type
== 1; /* R_VAX_32. */
12519 return reloc_type
== 3; /* R_VISIUM_32. */
12520 case EM_WEBASSEMBLY
:
12521 return reloc_type
== 1; /* R_WASM32_32. */
12525 return reloc_type
== 10; /* R_X86_64_32. */
12528 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12530 return reloc_type
== 4; /* R_XGATE_32. */
12532 return reloc_type
== 1; /* R_XSTROMY16_32. */
12533 case EM_XTENSA_OLD
:
12535 return reloc_type
== 1; /* R_XTENSA_32. */
12538 static unsigned int prev_warn
= 0;
12540 /* Avoid repeating the same warning multiple times. */
12541 if (prev_warn
!= filedata
->file_header
.e_machine
)
12542 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12543 filedata
->file_header
.e_machine
);
12544 prev_warn
= filedata
->file_header
.e_machine
;
12550 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12551 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12554 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12556 switch (filedata
->file_header
.e_machine
)
12557 /* Please keep this table alpha-sorted for ease of visual lookup. */
12561 return reloc_type
== 2; /* R_386_PC32. */
12563 return reloc_type
== 4; /* R_68K_PC32. */
12565 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12566 case EM_ADAPTEVA_EPIPHANY
:
12567 return reloc_type
== 6;
12569 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12570 case EM_ARC_COMPACT
:
12571 case EM_ARC_COMPACT2
:
12572 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12574 return reloc_type
== 3; /* R_ARM_REL32 */
12577 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12578 case EM_MICROBLAZE
:
12579 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12581 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12583 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12585 return reloc_type
== 26; /* R_PPC_REL32. */
12587 return reloc_type
== 26; /* R_PPC64_REL32. */
12589 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12592 return reloc_type
== 5; /* R_390_PC32. */
12594 return reloc_type
== 2; /* R_SH_REL32. */
12595 case EM_SPARC32PLUS
:
12598 return reloc_type
== 6; /* R_SPARC_DISP32. */
12600 return reloc_type
== 13; /* R_SPU_REL32. */
12602 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12604 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12606 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12610 return reloc_type
== 2; /* R_X86_64_PC32. */
12611 case EM_XTENSA_OLD
:
12613 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12615 /* Do not abort or issue an error message here. Not all targets use
12616 pc-relative 32-bit relocs in their DWARF debug information and we
12617 have already tested for target coverage in is_32bit_abs_reloc. A
12618 more helpful warning message will be generated by apply_relocations
12619 anyway, so just return. */
12624 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12625 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12628 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12630 switch (filedata
->file_header
.e_machine
)
12633 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12635 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12637 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12638 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12640 return reloc_type
== 80; /* R_PARISC_DIR64. */
12642 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12644 return reloc_type
== 2; /* R_RISCV_64. */
12645 case EM_SPARC32PLUS
:
12648 return reloc_type
== 32 /* R_SPARC_64. */
12649 || reloc_type
== 54; /* R_SPARC_UA64. */
12653 return reloc_type
== 1; /* R_X86_64_64. */
12656 return reloc_type
== 22; /* R_S390_64. */
12658 return reloc_type
== 1; /* R_TILEGX_64. */
12660 return reloc_type
== 18; /* R_MIPS_64. */
12666 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12667 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12670 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12672 switch (filedata
->file_header
.e_machine
)
12675 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12677 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12679 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12680 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12682 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12684 return reloc_type
== 44; /* R_PPC64_REL64. */
12685 case EM_SPARC32PLUS
:
12688 return reloc_type
== 46; /* R_SPARC_DISP64. */
12692 return reloc_type
== 24; /* R_X86_64_PC64. */
12695 return reloc_type
== 23; /* R_S390_PC64. */
12697 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12703 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12704 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12707 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12709 switch (filedata
->file_header
.e_machine
)
12711 case EM_CYGNUS_MN10200
:
12713 return reloc_type
== 4; /* R_MN10200_24. */
12715 return reloc_type
== 5; /* R_FT32_20. */
12721 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12722 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12725 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12727 /* Please keep this table alpha-sorted for ease of visual lookup. */
12728 switch (filedata
->file_header
.e_machine
)
12731 case EM_ARC_COMPACT
:
12732 case EM_ARC_COMPACT2
:
12733 return reloc_type
== 2; /* R_ARC_16. */
12734 case EM_ADAPTEVA_EPIPHANY
:
12735 return reloc_type
== 5;
12738 return reloc_type
== 4; /* R_AVR_16. */
12739 case EM_CYGNUS_D10V
:
12741 return reloc_type
== 3; /* R_D10V_16. */
12743 return reloc_type
== 2; /* R_FT32_16. */
12747 return reloc_type
== R_H8_DIR16
;
12750 return reloc_type
== 1; /* R_IP2K_16. */
12753 return reloc_type
== 1; /* R_M32C_16 */
12754 case EM_CYGNUS_MN10200
:
12756 return reloc_type
== 2; /* R_MN10200_16. */
12757 case EM_CYGNUS_MN10300
:
12759 return reloc_type
== 2; /* R_MN10300_16. */
12761 if (uses_msp430x_relocs (filedata
))
12762 return reloc_type
== 2; /* R_MSP430_ABS16. */
12763 /* Fall through. */
12764 case EM_MSP430_OLD
:
12765 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12767 return reloc_type
== 19; /* R_NDS32_RELA. */
12768 case EM_ALTERA_NIOS2
:
12769 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12771 return reloc_type
== 9; /* R_NIOS_16. */
12773 return reloc_type
== 2; /* R_OR1K_16. */
12775 return reloc_type
== 55; /* R_RISCV_SET16. */
12777 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12779 return reloc_type
== 2; /* R_C6000_ABS16. */
12781 return reloc_type
== 2; /* R_VISIUM_16. */
12784 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12786 return reloc_type
== 3; /* R_XGATE_16. */
12792 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12793 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12796 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12798 switch (filedata
->file_header
.e_machine
)
12801 return reloc_type
== 54; /* R_RISCV_SET8. */
12807 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12808 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12811 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12813 switch (filedata
->file_header
.e_machine
)
12816 return reloc_type
== 53; /* R_RISCV_SET6. */
12822 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12823 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12826 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12828 /* Please keep this table alpha-sorted for ease of visual lookup. */
12829 switch (filedata
->file_header
.e_machine
)
12832 return reloc_type
== 35; /* R_RISCV_ADD32. */
12838 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12839 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12842 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12844 /* Please keep this table alpha-sorted for ease of visual lookup. */
12845 switch (filedata
->file_header
.e_machine
)
12848 return reloc_type
== 39; /* R_RISCV_SUB32. */
12854 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12855 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12858 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12860 /* Please keep this table alpha-sorted for ease of visual lookup. */
12861 switch (filedata
->file_header
.e_machine
)
12864 return reloc_type
== 36; /* R_RISCV_ADD64. */
12870 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12871 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12874 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12876 /* Please keep this table alpha-sorted for ease of visual lookup. */
12877 switch (filedata
->file_header
.e_machine
)
12880 return reloc_type
== 40; /* R_RISCV_SUB64. */
12886 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12887 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12890 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12892 /* Please keep this table alpha-sorted for ease of visual lookup. */
12893 switch (filedata
->file_header
.e_machine
)
12896 return reloc_type
== 34; /* R_RISCV_ADD16. */
12902 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12903 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12906 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12908 /* Please keep this table alpha-sorted for ease of visual lookup. */
12909 switch (filedata
->file_header
.e_machine
)
12912 return reloc_type
== 38; /* R_RISCV_SUB16. */
12918 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12919 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12922 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12924 /* Please keep this table alpha-sorted for ease of visual lookup. */
12925 switch (filedata
->file_header
.e_machine
)
12928 return reloc_type
== 33; /* R_RISCV_ADD8. */
12934 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12935 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12938 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12940 /* Please keep this table alpha-sorted for ease of visual lookup. */
12941 switch (filedata
->file_header
.e_machine
)
12944 return reloc_type
== 37; /* R_RISCV_SUB8. */
12950 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12951 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12954 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12956 switch (filedata
->file_header
.e_machine
)
12959 return reloc_type
== 52; /* R_RISCV_SUB6. */
12965 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12966 relocation entries (possibly formerly used for SHT_GROUP sections). */
12969 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12971 switch (filedata
->file_header
.e_machine
)
12973 case EM_386
: /* R_386_NONE. */
12974 case EM_68K
: /* R_68K_NONE. */
12975 case EM_ADAPTEVA_EPIPHANY
:
12976 case EM_ALPHA
: /* R_ALPHA_NONE. */
12977 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12978 case EM_ARC
: /* R_ARC_NONE. */
12979 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12980 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12981 case EM_ARM
: /* R_ARM_NONE. */
12982 case EM_C166
: /* R_XC16X_NONE. */
12983 case EM_CRIS
: /* R_CRIS_NONE. */
12984 case EM_FT32
: /* R_FT32_NONE. */
12985 case EM_IA_64
: /* R_IA64_NONE. */
12986 case EM_K1OM
: /* R_X86_64_NONE. */
12987 case EM_L1OM
: /* R_X86_64_NONE. */
12988 case EM_M32R
: /* R_M32R_NONE. */
12989 case EM_MIPS
: /* R_MIPS_NONE. */
12990 case EM_MN10300
: /* R_MN10300_NONE. */
12991 case EM_MOXIE
: /* R_MOXIE_NONE. */
12992 case EM_NIOS32
: /* R_NIOS_NONE. */
12993 case EM_OR1K
: /* R_OR1K_NONE. */
12994 case EM_PARISC
: /* R_PARISC_NONE. */
12995 case EM_PPC64
: /* R_PPC64_NONE. */
12996 case EM_PPC
: /* R_PPC_NONE. */
12997 case EM_RISCV
: /* R_RISCV_NONE. */
12998 case EM_S390
: /* R_390_NONE. */
13000 case EM_SH
: /* R_SH_NONE. */
13001 case EM_SPARC32PLUS
:
13002 case EM_SPARC
: /* R_SPARC_NONE. */
13004 case EM_TILEGX
: /* R_TILEGX_NONE. */
13005 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13006 case EM_TI_C6000
:/* R_C6000_NONE. */
13007 case EM_X86_64
: /* R_X86_64_NONE. */
13009 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13010 return reloc_type
== 0;
13013 return reloc_type
== 0 || reloc_type
== 256;
13016 return (reloc_type
== 0 /* R_AVR_NONE. */
13017 || reloc_type
== 30 /* R_AVR_DIFF8. */
13018 || reloc_type
== 31 /* R_AVR_DIFF16. */
13019 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13021 return reloc_type
== 3; /* R_METAG_NONE. */
13023 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13024 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13025 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13026 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13027 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13029 return (reloc_type
== 0 /* R_PRU_NONE. */
13030 || reloc_type
== 65 /* R_PRU_DIFF8. */
13031 || reloc_type
== 66 /* R_PRU_DIFF16. */
13032 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13033 case EM_XTENSA_OLD
:
13035 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13036 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13037 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13038 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13043 /* Returns TRUE if there is a relocation against
13044 section NAME at OFFSET bytes. */
13047 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13049 Elf_Internal_Rela
* relocs
;
13050 Elf_Internal_Rela
* rp
;
13052 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13055 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13057 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13058 if (rp
->r_offset
== offset
)
13064 /* Apply relocations to a section.
13065 Returns TRUE upon success, FALSE otherwise.
13066 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13067 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13068 will be set to the number of relocs loaded.
13070 Note: So far support has been added only for those relocations
13071 which can be found in debug sections. FIXME: Add support for
13072 more relocations ? */
13075 apply_relocations (Filedata
* filedata
,
13076 const Elf_Internal_Shdr
* section
,
13077 unsigned char * start
,
13078 bfd_size_type size
,
13079 void ** relocs_return
,
13080 unsigned long * num_relocs_return
)
13082 Elf_Internal_Shdr
* relsec
;
13083 unsigned char * end
= start
+ size
;
13085 if (relocs_return
!= NULL
)
13087 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13088 * num_relocs_return
= 0;
13091 if (filedata
->file_header
.e_type
!= ET_REL
)
13092 /* No relocs to apply. */
13095 /* Find the reloc section associated with the section. */
13096 for (relsec
= filedata
->section_headers
;
13097 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13100 bfd_boolean is_rela
;
13101 unsigned long num_relocs
;
13102 Elf_Internal_Rela
* relocs
;
13103 Elf_Internal_Rela
* rp
;
13104 Elf_Internal_Shdr
* symsec
;
13105 Elf_Internal_Sym
* symtab
;
13106 unsigned long num_syms
;
13107 Elf_Internal_Sym
* sym
;
13109 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13110 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13111 || filedata
->section_headers
+ relsec
->sh_info
!= section
13112 || relsec
->sh_size
== 0
13113 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13116 is_rela
= relsec
->sh_type
== SHT_RELA
;
13120 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13121 relsec
->sh_size
, & relocs
, & num_relocs
))
13126 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13127 relsec
->sh_size
, & relocs
, & num_relocs
))
13131 /* SH uses RELA but uses in place value instead of the addend field. */
13132 if (filedata
->file_header
.e_machine
== EM_SH
)
13135 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13136 if (symsec
->sh_type
!= SHT_SYMTAB
13137 && symsec
->sh_type
!= SHT_DYNSYM
)
13139 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13141 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13144 unsigned int reloc_type
;
13145 unsigned int reloc_size
;
13146 bfd_boolean reloc_inplace
= FALSE
;
13147 bfd_boolean reloc_subtract
= FALSE
;
13148 unsigned char * rloc
;
13149 unsigned long sym_index
;
13151 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13153 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13155 else if (is_none_reloc (filedata
, reloc_type
))
13157 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13158 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13160 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13161 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13163 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13165 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13167 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13168 || is_6bit_abs_reloc (filedata
, reloc_type
))
13170 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13172 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13175 reloc_inplace
= TRUE
;
13177 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13179 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13182 reloc_inplace
= TRUE
;
13184 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13186 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13189 reloc_inplace
= TRUE
;
13191 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13193 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13196 reloc_inplace
= TRUE
;
13198 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13202 reloc_inplace
= TRUE
;
13206 static unsigned int prev_reloc
= 0;
13208 if (reloc_type
!= prev_reloc
)
13209 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13210 reloc_type
, printable_section_name (filedata
, section
));
13211 prev_reloc
= reloc_type
;
13215 rloc
= start
+ rp
->r_offset
;
13216 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
13218 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13219 (unsigned long) rp
->r_offset
,
13220 printable_section_name (filedata
, section
));
13224 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13225 if (sym_index
>= num_syms
)
13227 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13228 sym_index
, printable_section_name (filedata
, section
));
13231 sym
= symtab
+ sym_index
;
13233 /* If the reloc has a symbol associated with it,
13234 make sure that it is of an appropriate type.
13236 Relocations against symbols without type can happen.
13237 Gcc -feliminate-dwarf2-dups may generate symbols
13238 without type for debug info.
13240 Icc generates relocations against function symbols
13241 instead of local labels.
13243 Relocations against object symbols can happen, eg when
13244 referencing a global array. For an example of this see
13245 the _clz.o binary in libgcc.a. */
13247 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13248 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13250 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13251 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13252 printable_section_name (filedata
, relsec
),
13253 (long int)(rp
- relocs
));
13259 addend
+= rp
->r_addend
;
13260 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13261 partial_inplace. */
13263 || (filedata
->file_header
.e_machine
== EM_XTENSA
13264 && reloc_type
== 1)
13265 || ((filedata
->file_header
.e_machine
== EM_PJ
13266 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13267 && reloc_type
== 1)
13268 || ((filedata
->file_header
.e_machine
== EM_D30V
13269 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13270 && reloc_type
== 12)
13273 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13274 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13276 addend
+= byte_get (rloc
, reloc_size
);
13279 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13280 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13282 /* On HPPA, all pc-relative relocations are biased by 8. */
13283 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13285 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13288 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13289 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13291 if (reloc_subtract
)
13292 addend
-= sym
->st_value
;
13294 addend
+= sym
->st_value
;
13295 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13296 byte_put (rloc
, addend
, reloc_size
);
13298 else if (reloc_subtract
)
13299 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13301 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13305 /* Let the target specific reloc processing code know that
13306 we have finished with these relocs. */
13307 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13311 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13312 * num_relocs_return
= num_relocs
;
13323 #ifdef SUPPORT_DISASSEMBLY
13325 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13327 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13329 /* FIXME: XXX -- to be done --- XXX */
13335 /* Reads in the contents of SECTION from FILE, returning a pointer
13336 to a malloc'ed buffer or NULL if something went wrong. */
13339 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13341 bfd_size_type num_bytes
= section
->sh_size
;
13343 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13345 printf (_("Section '%s' has no data to dump.\n"),
13346 printable_section_name (filedata
, section
));
13350 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13351 _("section contents"));
13354 /* Uncompresses a section that was compressed using zlib, in place. */
13357 uncompress_section_contents (unsigned char ** buffer
,
13358 dwarf_size_type uncompressed_size
,
13359 dwarf_size_type
* size
)
13361 dwarf_size_type compressed_size
= *size
;
13362 unsigned char * compressed_buffer
= *buffer
;
13363 unsigned char * uncompressed_buffer
;
13367 /* It is possible the section consists of several compressed
13368 buffers concatenated together, so we uncompress in a loop. */
13369 /* PR 18313: The state field in the z_stream structure is supposed
13370 to be invisible to the user (ie us), but some compilers will
13371 still complain about it being used without initialisation. So
13372 we first zero the entire z_stream structure and then set the fields
13374 memset (& strm
, 0, sizeof strm
);
13375 strm
.avail_in
= compressed_size
;
13376 strm
.next_in
= (Bytef
*) compressed_buffer
;
13377 strm
.avail_out
= uncompressed_size
;
13378 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13380 rc
= inflateInit (& strm
);
13381 while (strm
.avail_in
> 0)
13385 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13386 + (uncompressed_size
- strm
.avail_out
));
13387 rc
= inflate (&strm
, Z_FINISH
);
13388 if (rc
!= Z_STREAM_END
)
13390 rc
= inflateReset (& strm
);
13392 rc
= inflateEnd (& strm
);
13394 || strm
.avail_out
!= 0)
13397 *buffer
= uncompressed_buffer
;
13398 *size
= uncompressed_size
;
13402 free (uncompressed_buffer
);
13403 /* Indicate decompression failure. */
13409 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13411 Elf_Internal_Shdr
* relsec
;
13412 bfd_size_type num_bytes
;
13413 unsigned char * data
;
13414 unsigned char * end
;
13415 unsigned char * real_start
;
13416 unsigned char * start
;
13417 bfd_boolean some_strings_shown
;
13419 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13421 /* PR 21820: Do not fail if the section was empty. */
13422 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13424 num_bytes
= section
->sh_size
;
13426 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13428 if (decompress_dumps
)
13430 dwarf_size_type new_size
= num_bytes
;
13431 dwarf_size_type uncompressed_size
= 0;
13433 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13435 Elf_Internal_Chdr chdr
;
13436 unsigned int compression_header_size
13437 = get_compression_header (& chdr
, (unsigned char *) start
,
13440 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13442 warn (_("section '%s' has unsupported compress type: %d\n"),
13443 printable_section_name (filedata
, section
), chdr
.ch_type
);
13446 uncompressed_size
= chdr
.ch_size
;
13447 start
+= compression_header_size
;
13448 new_size
-= compression_header_size
;
13450 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13452 /* Read the zlib header. In this case, it should be "ZLIB"
13453 followed by the uncompressed section size, 8 bytes in
13454 big-endian order. */
13455 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13456 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13457 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13458 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13459 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13460 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13461 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13462 uncompressed_size
+= start
[11];
13467 if (uncompressed_size
)
13469 if (uncompress_section_contents (& start
,
13470 uncompressed_size
, & new_size
))
13471 num_bytes
= new_size
;
13474 error (_("Unable to decompress section %s\n"),
13475 printable_section_name (filedata
, section
));
13480 start
= real_start
;
13483 /* If the section being dumped has relocations against it the user might
13484 be expecting these relocations to have been applied. Check for this
13485 case and issue a warning message in order to avoid confusion.
13486 FIXME: Maybe we ought to have an option that dumps a section with
13487 relocs applied ? */
13488 for (relsec
= filedata
->section_headers
;
13489 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13492 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13493 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13494 || filedata
->section_headers
+ relsec
->sh_info
!= section
13495 || relsec
->sh_size
== 0
13496 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13499 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13504 end
= start
+ num_bytes
;
13505 some_strings_shown
= FALSE
;
13509 while (!ISPRINT (* data
))
13510 if (++ data
>= end
)
13515 size_t maxlen
= end
- data
;
13518 /* PR 11128: Use two separate invocations in order to work
13519 around bugs in the Solaris 8 implementation of printf. */
13520 printf (" [%6tx] ", data
- start
);
13522 printf (" [%6Ix] ", (size_t) (data
- start
));
13526 print_symbol ((int) maxlen
, (const char *) data
);
13528 data
+= strnlen ((const char *) data
, maxlen
);
13532 printf (_("<corrupt>\n"));
13535 some_strings_shown
= TRUE
;
13539 if (! some_strings_shown
)
13540 printf (_(" No strings found in this section."));
13549 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13550 Filedata
* filedata
,
13551 bfd_boolean relocate
)
13553 Elf_Internal_Shdr
* relsec
;
13554 bfd_size_type bytes
;
13555 bfd_size_type section_size
;
13557 unsigned char * data
;
13558 unsigned char * real_start
;
13559 unsigned char * start
;
13561 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13563 /* PR 21820: Do not fail if the section was empty. */
13564 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13566 section_size
= section
->sh_size
;
13568 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13570 if (decompress_dumps
)
13572 dwarf_size_type new_size
= section_size
;
13573 dwarf_size_type uncompressed_size
= 0;
13575 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13577 Elf_Internal_Chdr chdr
;
13578 unsigned int compression_header_size
13579 = get_compression_header (& chdr
, start
, section_size
);
13581 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13583 warn (_("section '%s' has unsupported compress type: %d\n"),
13584 printable_section_name (filedata
, section
), chdr
.ch_type
);
13587 uncompressed_size
= chdr
.ch_size
;
13588 start
+= compression_header_size
;
13589 new_size
-= compression_header_size
;
13591 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13593 /* Read the zlib header. In this case, it should be "ZLIB"
13594 followed by the uncompressed section size, 8 bytes in
13595 big-endian order. */
13596 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13597 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13598 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13599 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13600 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13601 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13602 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13603 uncompressed_size
+= start
[11];
13608 if (uncompressed_size
)
13610 if (uncompress_section_contents (& start
, uncompressed_size
,
13613 section_size
= new_size
;
13617 error (_("Unable to decompress section %s\n"),
13618 printable_section_name (filedata
, section
));
13619 /* FIXME: Print the section anyway ? */
13624 start
= real_start
;
13629 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13634 /* If the section being dumped has relocations against it the user might
13635 be expecting these relocations to have been applied. Check for this
13636 case and issue a warning message in order to avoid confusion.
13637 FIXME: Maybe we ought to have an option that dumps a section with
13638 relocs applied ? */
13639 for (relsec
= filedata
->section_headers
;
13640 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13643 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13644 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13645 || filedata
->section_headers
+ relsec
->sh_info
!= section
13646 || relsec
->sh_size
== 0
13647 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13650 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13655 addr
= section
->sh_addr
;
13656 bytes
= section_size
;
13665 lbytes
= (bytes
> 16 ? 16 : bytes
);
13667 printf (" 0x%8.8lx ", (unsigned long) addr
);
13669 for (j
= 0; j
< 16; j
++)
13672 printf ("%2.2x", data
[j
]);
13680 for (j
= 0; j
< lbytes
; j
++)
13683 if (k
>= ' ' && k
< 0x7f)
13703 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13704 const Elf_Internal_Shdr
* sec
,
13707 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13709 Filedata
* filedata
= (Filedata
*) data
;
13711 if (section
->start
!= NULL
)
13713 /* If it is already loaded, do nothing. */
13714 if (streq (section
->filename
, filedata
->file_name
))
13716 free (section
->start
);
13719 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13720 section
->address
= sec
->sh_addr
;
13721 section
->user_data
= NULL
;
13722 section
->filename
= filedata
->file_name
;
13723 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13725 sec
->sh_size
, buf
);
13726 if (section
->start
== NULL
)
13730 unsigned char *start
= section
->start
;
13731 dwarf_size_type size
= sec
->sh_size
;
13732 dwarf_size_type uncompressed_size
= 0;
13734 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13736 Elf_Internal_Chdr chdr
;
13737 unsigned int compression_header_size
;
13739 if (size
< (is_32bit_elf
13740 ? sizeof (Elf32_External_Chdr
)
13741 : sizeof (Elf64_External_Chdr
)))
13743 warn (_("compressed section %s is too small to contain a compression header"),
13748 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13750 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13752 warn (_("section '%s' has unsupported compress type: %d\n"),
13753 section
->name
, chdr
.ch_type
);
13756 uncompressed_size
= chdr
.ch_size
;
13757 start
+= compression_header_size
;
13758 size
-= compression_header_size
;
13760 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13762 /* Read the zlib header. In this case, it should be "ZLIB"
13763 followed by the uncompressed section size, 8 bytes in
13764 big-endian order. */
13765 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13766 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13767 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13768 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13769 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13770 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13771 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13772 uncompressed_size
+= start
[11];
13777 if (uncompressed_size
)
13779 if (uncompress_section_contents (&start
, uncompressed_size
,
13782 /* Free the compressed buffer, update the section buffer
13783 and the section size if uncompress is successful. */
13784 free (section
->start
);
13785 section
->start
= start
;
13789 error (_("Unable to decompress section %s\n"),
13790 printable_section_name (filedata
, sec
));
13795 section
->size
= size
;
13798 if (section
->start
== NULL
)
13801 if (debug_displays
[debug
].relocate
)
13803 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13804 & section
->reloc_info
, & section
->num_relocs
))
13809 section
->reloc_info
= NULL
;
13810 section
->num_relocs
= 0;
13816 /* If this is not NULL, load_debug_section will only look for sections
13817 within the list of sections given here. */
13818 static unsigned int * section_subset
= NULL
;
13821 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13823 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13824 Elf_Internal_Shdr
* sec
;
13825 Filedata
* filedata
= (Filedata
*) data
;
13827 /* Without section headers we cannot find any sections. */
13828 if (filedata
->section_headers
== NULL
)
13831 if (filedata
->string_table
== NULL
13832 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13833 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13835 Elf_Internal_Shdr
* strs
;
13837 /* Read in the string table, so that we have section names to scan. */
13838 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13840 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13842 filedata
->string_table
13843 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13844 1, strs
->sh_size
, _("string table"));
13846 filedata
->string_table_length
13847 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13851 /* Locate the debug section. */
13852 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13854 section
->name
= section
->uncompressed_name
;
13857 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13859 section
->name
= section
->compressed_name
;
13864 /* If we're loading from a subset of sections, and we've loaded
13865 a section matching this name before, it's likely that it's a
13867 if (section_subset
!= NULL
)
13868 free_debug_section (debug
);
13870 return load_specific_debug_section (debug
, sec
, data
);
13874 free_debug_section (enum dwarf_section_display_enum debug
)
13876 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13878 if (section
->start
== NULL
)
13881 free ((char *) section
->start
);
13882 section
->start
= NULL
;
13883 section
->address
= 0;
13888 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13890 char * name
= SECTION_NAME (section
);
13891 const char * print_name
= printable_section_name (filedata
, section
);
13892 bfd_size_type length
;
13893 bfd_boolean result
= TRUE
;
13896 length
= section
->sh_size
;
13899 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13902 if (section
->sh_type
== SHT_NOBITS
)
13904 /* There is no point in dumping the contents of a debugging section
13905 which has the NOBITS type - the bits in the file will be random.
13906 This can happen when a file containing a .eh_frame section is
13907 stripped with the --only-keep-debug command line option. */
13908 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13913 if (const_strneq (name
, ".gnu.linkonce.wi."))
13914 name
= ".debug_info";
13916 /* See if we know how to display the contents of this section. */
13917 for (i
= 0; i
< max
; i
++)
13919 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13920 struct dwarf_section_display
* display
= debug_displays
+ i
;
13921 struct dwarf_section
* sec
= & display
->section
;
13923 if (streq (sec
->uncompressed_name
, name
)
13924 || (id
== line
&& const_strneq (name
, ".debug_line."))
13925 || streq (sec
->compressed_name
, name
))
13927 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13930 free_debug_section (id
);
13932 if (i
== line
&& const_strneq (name
, ".debug_line."))
13934 else if (streq (sec
->uncompressed_name
, name
))
13935 sec
->name
= sec
->uncompressed_name
;
13937 sec
->name
= sec
->compressed_name
;
13939 if (load_specific_debug_section (id
, section
, filedata
))
13941 /* If this debug section is part of a CU/TU set in a .dwp file,
13942 restrict load_debug_section to the sections in that set. */
13943 section_subset
= find_cu_tu_set (filedata
, shndx
);
13945 result
&= display
->display (sec
, filedata
);
13947 section_subset
= NULL
;
13949 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13950 free_debug_section (id
);
13958 printf (_("Unrecognized debug section: %s\n"), print_name
);
13965 /* Set DUMP_SECTS for all sections where dumps were requested
13966 based on section name. */
13969 initialise_dumps_byname (Filedata
* filedata
)
13971 struct dump_list_entry
* cur
;
13973 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13976 bfd_boolean any
= FALSE
;
13978 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13979 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13981 request_dump_bynumber (filedata
, i
, cur
->type
);
13986 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13992 process_section_contents (Filedata
* filedata
)
13994 Elf_Internal_Shdr
* section
;
13996 bfd_boolean res
= TRUE
;
14001 initialise_dumps_byname (filedata
);
14003 for (i
= 0, section
= filedata
->section_headers
;
14004 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14007 dump_type dump
= filedata
->dump_sects
[i
];
14009 #ifdef SUPPORT_DISASSEMBLY
14010 if (dump
& DISASS_DUMP
)
14012 if (! disassemble_section (section
, filedata
))
14016 if (dump
& HEX_DUMP
)
14018 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14022 if (dump
& RELOC_DUMP
)
14024 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14028 if (dump
& STRING_DUMP
)
14030 if (! dump_section_as_strings (section
, filedata
))
14034 if (dump
& DEBUG_DUMP
)
14036 if (! display_debug_section (i
, section
, filedata
))
14041 /* Check to see if the user requested a
14042 dump of a section that does not exist. */
14043 while (i
< filedata
->num_dump_sects
)
14045 if (filedata
->dump_sects
[i
])
14047 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14057 process_mips_fpe_exception (int mask
)
14061 bfd_boolean first
= TRUE
;
14063 if (mask
& OEX_FPU_INEX
)
14064 fputs ("INEX", stdout
), first
= FALSE
;
14065 if (mask
& OEX_FPU_UFLO
)
14066 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14067 if (mask
& OEX_FPU_OFLO
)
14068 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14069 if (mask
& OEX_FPU_DIV0
)
14070 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14071 if (mask
& OEX_FPU_INVAL
)
14072 printf ("%sINVAL", first
? "" : "|");
14075 fputs ("0", stdout
);
14078 /* Display's the value of TAG at location P. If TAG is
14079 greater than 0 it is assumed to be an unknown tag, and
14080 a message is printed to this effect. Otherwise it is
14081 assumed that a message has already been printed.
14083 If the bottom bit of TAG is set it assumed to have a
14084 string value, otherwise it is assumed to have an integer
14087 Returns an updated P pointing to the first unread byte
14088 beyond the end of TAG's value.
14090 Reads at or beyond END will not be made. */
14092 static unsigned char *
14093 display_tag_value (signed int tag
,
14095 const unsigned char * const end
)
14100 printf (" Tag_unknown_%d: ", tag
);
14104 warn (_("<corrupt tag>\n"));
14108 /* PR 17531 file: 027-19978-0.004. */
14109 size_t maxlen
= (end
- p
) - 1;
14114 print_symbol ((int) maxlen
, (const char *) p
);
14115 p
+= strnlen ((char *) p
, maxlen
) + 1;
14119 printf (_("<corrupt string tag>"));
14120 p
= (unsigned char *) end
;
14128 val
= read_uleb128 (p
, &len
, end
);
14130 printf ("%ld (0x%lx)\n", val
, val
);
14137 /* ARC ABI attributes section. */
14139 static unsigned char *
14140 display_arc_attribute (unsigned char * p
,
14141 const unsigned char * const end
)
14147 tag
= read_uleb128 (p
, &len
, end
);
14152 case Tag_ARC_PCS_config
:
14153 val
= read_uleb128 (p
, &len
, end
);
14155 printf (" Tag_ARC_PCS_config: ");
14159 printf (_("Absent/Non standard\n"));
14162 printf (_("Bare metal/mwdt\n"));
14165 printf (_("Bare metal/newlib\n"));
14168 printf (_("Linux/uclibc\n"));
14171 printf (_("Linux/glibc\n"));
14174 printf (_("Unknown\n"));
14179 case Tag_ARC_CPU_base
:
14180 val
= read_uleb128 (p
, &len
, end
);
14182 printf (" Tag_ARC_CPU_base: ");
14187 printf (_("Absent\n"));
14189 case TAG_CPU_ARC6xx
:
14190 printf ("ARC6xx\n");
14192 case TAG_CPU_ARC7xx
:
14193 printf ("ARC7xx\n");
14195 case TAG_CPU_ARCEM
:
14196 printf ("ARCEM\n");
14198 case TAG_CPU_ARCHS
:
14199 printf ("ARCHS\n");
14204 case Tag_ARC_CPU_variation
:
14205 val
= read_uleb128 (p
, &len
, end
);
14207 printf (" Tag_ARC_CPU_variation: ");
14211 if (val
> 0 && val
< 16)
14212 printf ("Core%d\n", val
);
14214 printf ("Unknown\n");
14218 printf (_("Absent\n"));
14223 case Tag_ARC_CPU_name
:
14224 printf (" Tag_ARC_CPU_name: ");
14225 p
= display_tag_value (-1, p
, end
);
14228 case Tag_ARC_ABI_rf16
:
14229 val
= read_uleb128 (p
, &len
, end
);
14231 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14234 case Tag_ARC_ABI_osver
:
14235 val
= read_uleb128 (p
, &len
, end
);
14237 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14240 case Tag_ARC_ABI_pic
:
14241 case Tag_ARC_ABI_sda
:
14242 val
= read_uleb128 (p
, &len
, end
);
14244 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14245 : " Tag_ARC_ABI_pic: ");
14249 printf (_("Absent\n"));
14258 printf (_("Unknown\n"));
14263 case Tag_ARC_ABI_tls
:
14264 val
= read_uleb128 (p
, &len
, end
);
14266 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14269 case Tag_ARC_ABI_enumsize
:
14270 val
= read_uleb128 (p
, &len
, end
);
14272 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14276 case Tag_ARC_ABI_exceptions
:
14277 val
= read_uleb128 (p
, &len
, end
);
14279 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14283 case Tag_ARC_ABI_double_size
:
14284 val
= read_uleb128 (p
, &len
, end
);
14286 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14289 case Tag_ARC_ISA_config
:
14290 printf (" Tag_ARC_ISA_config: ");
14291 p
= display_tag_value (-1, p
, end
);
14294 case Tag_ARC_ISA_apex
:
14295 printf (" Tag_ARC_ISA_apex: ");
14296 p
= display_tag_value (-1, p
, end
);
14299 case Tag_ARC_ISA_mpy_option
:
14300 val
= read_uleb128 (p
, &len
, end
);
14302 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14305 case Tag_ARC_ATR_version
:
14306 val
= read_uleb128 (p
, &len
, end
);
14308 printf (" Tag_ARC_ATR_version: %d\n", val
);
14312 return display_tag_value (tag
& 1, p
, end
);
14318 /* ARM EABI attributes section. */
14323 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14325 const char ** table
;
14326 } arm_attr_public_tag
;
14328 static const char * arm_attr_tag_CPU_arch
[] =
14329 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14330 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14332 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14333 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14334 {"No", "Thumb-1", "Thumb-2", "Yes"};
14335 static const char * arm_attr_tag_FP_arch
[] =
14336 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14337 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14338 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14339 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14340 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14341 "NEON for ARMv8.1"};
14342 static const char * arm_attr_tag_PCS_config
[] =
14343 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14344 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14345 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14346 {"V6", "SB", "TLS", "Unused"};
14347 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14348 {"Absolute", "PC-relative", "SB-relative", "None"};
14349 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14350 {"Absolute", "PC-relative", "None"};
14351 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14352 {"None", "direct", "GOT-indirect"};
14353 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14354 {"None", "??? 1", "2", "??? 3", "4"};
14355 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14356 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14357 {"Unused", "Needed", "Sign only"};
14358 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14359 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14360 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14361 {"Unused", "Finite", "RTABI", "IEEE 754"};
14362 static const char * arm_attr_tag_ABI_enum_size
[] =
14363 {"Unused", "small", "int", "forced to int"};
14364 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14365 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14366 static const char * arm_attr_tag_ABI_VFP_args
[] =
14367 {"AAPCS", "VFP registers", "custom", "compatible"};
14368 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14369 {"AAPCS", "WMMX registers", "custom"};
14370 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14371 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14372 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14373 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14374 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14375 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14376 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14377 static const char * arm_attr_tag_FP_HP_extension
[] =
14378 {"Not Allowed", "Allowed"};
14379 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14380 {"None", "IEEE 754", "Alternative Format"};
14381 static const char * arm_attr_tag_DSP_extension
[] =
14382 {"Follow architecture", "Allowed"};
14383 static const char * arm_attr_tag_MPextension_use
[] =
14384 {"Not Allowed", "Allowed"};
14385 static const char * arm_attr_tag_DIV_use
[] =
14386 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14387 "Allowed in v7-A with integer division extension"};
14388 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14389 static const char * arm_attr_tag_Virtualization_use
[] =
14390 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14391 "TrustZone and Virtualization Extensions"};
14392 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14393 {"Not Allowed", "Allowed"};
14395 #define LOOKUP(id, name) \
14396 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14397 static arm_attr_public_tag arm_attr_public_tags
[] =
14399 {4, "CPU_raw_name", 1, NULL
},
14400 {5, "CPU_name", 1, NULL
},
14401 LOOKUP(6, CPU_arch
),
14402 {7, "CPU_arch_profile", 0, NULL
},
14403 LOOKUP(8, ARM_ISA_use
),
14404 LOOKUP(9, THUMB_ISA_use
),
14405 LOOKUP(10, FP_arch
),
14406 LOOKUP(11, WMMX_arch
),
14407 LOOKUP(12, Advanced_SIMD_arch
),
14408 LOOKUP(13, PCS_config
),
14409 LOOKUP(14, ABI_PCS_R9_use
),
14410 LOOKUP(15, ABI_PCS_RW_data
),
14411 LOOKUP(16, ABI_PCS_RO_data
),
14412 LOOKUP(17, ABI_PCS_GOT_use
),
14413 LOOKUP(18, ABI_PCS_wchar_t
),
14414 LOOKUP(19, ABI_FP_rounding
),
14415 LOOKUP(20, ABI_FP_denormal
),
14416 LOOKUP(21, ABI_FP_exceptions
),
14417 LOOKUP(22, ABI_FP_user_exceptions
),
14418 LOOKUP(23, ABI_FP_number_model
),
14419 {24, "ABI_align_needed", 0, NULL
},
14420 {25, "ABI_align_preserved", 0, NULL
},
14421 LOOKUP(26, ABI_enum_size
),
14422 LOOKUP(27, ABI_HardFP_use
),
14423 LOOKUP(28, ABI_VFP_args
),
14424 LOOKUP(29, ABI_WMMX_args
),
14425 LOOKUP(30, ABI_optimization_goals
),
14426 LOOKUP(31, ABI_FP_optimization_goals
),
14427 {32, "compatibility", 0, NULL
},
14428 LOOKUP(34, CPU_unaligned_access
),
14429 LOOKUP(36, FP_HP_extension
),
14430 LOOKUP(38, ABI_FP_16bit_format
),
14431 LOOKUP(42, MPextension_use
),
14432 LOOKUP(44, DIV_use
),
14433 LOOKUP(46, DSP_extension
),
14434 {64, "nodefaults", 0, NULL
},
14435 {65, "also_compatible_with", 0, NULL
},
14436 LOOKUP(66, T2EE_use
),
14437 {67, "conformance", 1, NULL
},
14438 LOOKUP(68, Virtualization_use
),
14439 LOOKUP(70, MPextension_use_legacy
)
14443 static unsigned char *
14444 display_arm_attribute (unsigned char * p
,
14445 const unsigned char * const end
)
14450 arm_attr_public_tag
* attr
;
14454 tag
= read_uleb128 (p
, &len
, end
);
14457 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14459 if (arm_attr_public_tags
[i
].tag
== tag
)
14461 attr
= &arm_attr_public_tags
[i
];
14468 printf (" Tag_%s: ", attr
->name
);
14469 switch (attr
->type
)
14474 case 7: /* Tag_CPU_arch_profile. */
14475 val
= read_uleb128 (p
, &len
, end
);
14479 case 0: printf (_("None\n")); break;
14480 case 'A': printf (_("Application\n")); break;
14481 case 'R': printf (_("Realtime\n")); break;
14482 case 'M': printf (_("Microcontroller\n")); break;
14483 case 'S': printf (_("Application or Realtime\n")); break;
14484 default: printf ("??? (%d)\n", val
); break;
14488 case 24: /* Tag_align_needed. */
14489 val
= read_uleb128 (p
, &len
, end
);
14493 case 0: printf (_("None\n")); break;
14494 case 1: printf (_("8-byte\n")); break;
14495 case 2: printf (_("4-byte\n")); break;
14496 case 3: printf ("??? 3\n"); break;
14499 printf (_("8-byte and up to %d-byte extended\n"),
14502 printf ("??? (%d)\n", val
);
14507 case 25: /* Tag_align_preserved. */
14508 val
= read_uleb128 (p
, &len
, end
);
14512 case 0: printf (_("None\n")); break;
14513 case 1: printf (_("8-byte, except leaf SP\n")); break;
14514 case 2: printf (_("8-byte\n")); break;
14515 case 3: printf ("??? 3\n"); break;
14518 printf (_("8-byte and up to %d-byte extended\n"),
14521 printf ("??? (%d)\n", val
);
14526 case 32: /* Tag_compatibility. */
14528 val
= read_uleb128 (p
, &len
, end
);
14530 printf (_("flag = %d, vendor = "), val
);
14533 size_t maxlen
= (end
- p
) - 1;
14535 print_symbol ((int) maxlen
, (const char *) p
);
14536 p
+= strnlen ((char *) p
, maxlen
) + 1;
14540 printf (_("<corrupt>"));
14541 p
= (unsigned char *) end
;
14547 case 64: /* Tag_nodefaults. */
14548 /* PR 17531: file: 001-505008-0.01. */
14551 printf (_("True\n"));
14554 case 65: /* Tag_also_compatible_with. */
14555 val
= read_uleb128 (p
, &len
, end
);
14557 if (val
== 6 /* Tag_CPU_arch. */)
14559 val
= read_uleb128 (p
, &len
, end
);
14561 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14562 printf ("??? (%d)\n", val
);
14564 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14568 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14573 printf (_("<unknown: %d>\n"), tag
);
14579 return display_tag_value (-1, p
, end
);
14581 return display_tag_value (0, p
, end
);
14584 assert (attr
->type
& 0x80);
14585 val
= read_uleb128 (p
, &len
, end
);
14587 type
= attr
->type
& 0x7f;
14589 printf ("??? (%d)\n", val
);
14591 printf ("%s\n", attr
->table
[val
]);
14596 return display_tag_value (tag
, p
, end
);
14599 static unsigned char *
14600 display_gnu_attribute (unsigned char * p
,
14601 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14602 const unsigned char * const end
)
14608 tag
= read_uleb128 (p
, &len
, end
);
14611 /* Tag_compatibility is the only generic GNU attribute defined at
14615 val
= read_uleb128 (p
, &len
, end
);
14618 printf (_("flag = %d, vendor = "), val
);
14621 printf (_("<corrupt>\n"));
14622 warn (_("corrupt vendor attribute\n"));
14628 size_t maxlen
= (end
- p
) - 1;
14630 print_symbol ((int) maxlen
, (const char *) p
);
14631 p
+= strnlen ((char *) p
, maxlen
) + 1;
14635 printf (_("<corrupt>"));
14636 p
= (unsigned char *) end
;
14643 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14644 return display_proc_gnu_attribute (p
, tag
, end
);
14646 return display_tag_value (tag
, p
, end
);
14649 static unsigned char *
14650 display_power_gnu_attribute (unsigned char * p
,
14652 const unsigned char * const end
)
14657 if (tag
== Tag_GNU_Power_ABI_FP
)
14659 val
= read_uleb128 (p
, &len
, end
);
14661 printf (" Tag_GNU_Power_ABI_FP: ");
14664 printf (_("<corrupt>\n"));
14669 printf ("(%#x), ", val
);
14674 printf (_("unspecified hard/soft float, "));
14677 printf (_("hard float, "));
14680 printf (_("soft float, "));
14683 printf (_("single-precision hard float, "));
14690 printf (_("unspecified long double\n"));
14693 printf (_("128-bit IBM long double\n"));
14696 printf (_("64-bit long double\n"));
14699 printf (_("128-bit IEEE long double\n"));
14705 if (tag
== Tag_GNU_Power_ABI_Vector
)
14707 val
= read_uleb128 (p
, &len
, end
);
14709 printf (" Tag_GNU_Power_ABI_Vector: ");
14712 printf (_("<corrupt>\n"));
14717 printf ("(%#x), ", val
);
14722 printf (_("unspecified\n"));
14725 printf (_("generic\n"));
14728 printf ("AltiVec\n");
14737 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14739 val
= read_uleb128 (p
, &len
, end
);
14741 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14744 printf (_("<corrupt>\n"));
14749 printf ("(%#x), ", val
);
14754 printf (_("unspecified\n"));
14757 printf ("r3/r4\n");
14760 printf (_("memory\n"));
14769 return display_tag_value (tag
& 1, p
, end
);
14772 static unsigned char *
14773 display_s390_gnu_attribute (unsigned char * p
,
14775 const unsigned char * const end
)
14780 if (tag
== Tag_GNU_S390_ABI_Vector
)
14782 val
= read_uleb128 (p
, &len
, end
);
14784 printf (" Tag_GNU_S390_ABI_Vector: ");
14789 printf (_("any\n"));
14792 printf (_("software\n"));
14795 printf (_("hardware\n"));
14798 printf ("??? (%d)\n", val
);
14804 return display_tag_value (tag
& 1, p
, end
);
14808 display_sparc_hwcaps (unsigned int mask
)
14812 bfd_boolean first
= TRUE
;
14814 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14815 fputs ("mul32", stdout
), first
= FALSE
;
14816 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14817 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14818 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14819 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14820 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14821 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14822 if (mask
& ELF_SPARC_HWCAP_POPC
)
14823 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14824 if (mask
& ELF_SPARC_HWCAP_VIS
)
14825 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14826 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14827 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14828 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14829 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14830 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14831 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14832 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14833 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14834 if (mask
& ELF_SPARC_HWCAP_HPC
)
14835 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14836 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14837 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14838 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14839 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14840 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14841 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14842 if (mask
& ELF_SPARC_HWCAP_IMA
)
14843 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14844 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14845 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14848 fputc ('0', stdout
);
14849 fputc ('\n', stdout
);
14853 display_sparc_hwcaps2 (unsigned int mask
)
14857 bfd_boolean first
= TRUE
;
14859 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14860 fputs ("fjathplus", stdout
), first
= FALSE
;
14861 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14862 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14863 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14864 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14865 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14866 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14867 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14868 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14869 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14870 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14871 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14872 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14873 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14874 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14875 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14876 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14877 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14878 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14879 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14880 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14883 fputc ('0', stdout
);
14884 fputc ('\n', stdout
);
14887 static unsigned char *
14888 display_sparc_gnu_attribute (unsigned char * p
,
14890 const unsigned char * const end
)
14895 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14897 val
= read_uleb128 (p
, &len
, end
);
14899 printf (" Tag_GNU_Sparc_HWCAPS: ");
14900 display_sparc_hwcaps (val
);
14903 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14905 val
= read_uleb128 (p
, &len
, end
);
14907 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14908 display_sparc_hwcaps2 (val
);
14912 return display_tag_value (tag
, p
, end
);
14916 print_mips_fp_abi_value (unsigned int val
)
14920 case Val_GNU_MIPS_ABI_FP_ANY
:
14921 printf (_("Hard or soft float\n"));
14923 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14924 printf (_("Hard float (double precision)\n"));
14926 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14927 printf (_("Hard float (single precision)\n"));
14929 case Val_GNU_MIPS_ABI_FP_SOFT
:
14930 printf (_("Soft float\n"));
14932 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14933 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14935 case Val_GNU_MIPS_ABI_FP_XX
:
14936 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14938 case Val_GNU_MIPS_ABI_FP_64
:
14939 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14941 case Val_GNU_MIPS_ABI_FP_64A
:
14942 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14944 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14945 printf (_("NaN 2008 compatibility\n"));
14948 printf ("??? (%d)\n", val
);
14953 static unsigned char *
14954 display_mips_gnu_attribute (unsigned char * p
,
14956 const unsigned char * const end
)
14958 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14963 val
= read_uleb128 (p
, &len
, end
);
14965 printf (" Tag_GNU_MIPS_ABI_FP: ");
14967 print_mips_fp_abi_value (val
);
14972 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14977 val
= read_uleb128 (p
, &len
, end
);
14979 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14983 case Val_GNU_MIPS_ABI_MSA_ANY
:
14984 printf (_("Any MSA or not\n"));
14986 case Val_GNU_MIPS_ABI_MSA_128
:
14987 printf (_("128-bit MSA\n"));
14990 printf ("??? (%d)\n", val
);
14996 return display_tag_value (tag
& 1, p
, end
);
14999 static unsigned char *
15000 display_tic6x_attribute (unsigned char * p
,
15001 const unsigned char * const end
)
15007 tag
= read_uleb128 (p
, &len
, end
);
15013 val
= read_uleb128 (p
, &len
, end
);
15015 printf (" Tag_ISA: ");
15019 case C6XABI_Tag_ISA_none
:
15020 printf (_("None\n"));
15022 case C6XABI_Tag_ISA_C62X
:
15025 case C6XABI_Tag_ISA_C67X
:
15028 case C6XABI_Tag_ISA_C67XP
:
15029 printf ("C67x+\n");
15031 case C6XABI_Tag_ISA_C64X
:
15034 case C6XABI_Tag_ISA_C64XP
:
15035 printf ("C64x+\n");
15037 case C6XABI_Tag_ISA_C674X
:
15038 printf ("C674x\n");
15041 printf ("??? (%d)\n", val
);
15046 case Tag_ABI_wchar_t
:
15047 val
= read_uleb128 (p
, &len
, end
);
15049 printf (" Tag_ABI_wchar_t: ");
15053 printf (_("Not used\n"));
15056 printf (_("2 bytes\n"));
15059 printf (_("4 bytes\n"));
15062 printf ("??? (%d)\n", val
);
15067 case Tag_ABI_stack_align_needed
:
15068 val
= read_uleb128 (p
, &len
, end
);
15070 printf (" Tag_ABI_stack_align_needed: ");
15074 printf (_("8-byte\n"));
15077 printf (_("16-byte\n"));
15080 printf ("??? (%d)\n", val
);
15085 case Tag_ABI_stack_align_preserved
:
15086 val
= read_uleb128 (p
, &len
, end
);
15088 printf (" Tag_ABI_stack_align_preserved: ");
15092 printf (_("8-byte\n"));
15095 printf (_("16-byte\n"));
15098 printf ("??? (%d)\n", val
);
15104 val
= read_uleb128 (p
, &len
, end
);
15106 printf (" Tag_ABI_DSBT: ");
15110 printf (_("DSBT addressing not used\n"));
15113 printf (_("DSBT addressing used\n"));
15116 printf ("??? (%d)\n", val
);
15122 val
= read_uleb128 (p
, &len
, end
);
15124 printf (" Tag_ABI_PID: ");
15128 printf (_("Data addressing position-dependent\n"));
15131 printf (_("Data addressing position-independent, GOT near DP\n"));
15134 printf (_("Data addressing position-independent, GOT far from DP\n"));
15137 printf ("??? (%d)\n", val
);
15143 val
= read_uleb128 (p
, &len
, end
);
15145 printf (" Tag_ABI_PIC: ");
15149 printf (_("Code addressing position-dependent\n"));
15152 printf (_("Code addressing position-independent\n"));
15155 printf ("??? (%d)\n", val
);
15160 case Tag_ABI_array_object_alignment
:
15161 val
= read_uleb128 (p
, &len
, end
);
15163 printf (" Tag_ABI_array_object_alignment: ");
15167 printf (_("8-byte\n"));
15170 printf (_("4-byte\n"));
15173 printf (_("16-byte\n"));
15176 printf ("??? (%d)\n", val
);
15181 case Tag_ABI_array_object_align_expected
:
15182 val
= read_uleb128 (p
, &len
, end
);
15184 printf (" Tag_ABI_array_object_align_expected: ");
15188 printf (_("8-byte\n"));
15191 printf (_("4-byte\n"));
15194 printf (_("16-byte\n"));
15197 printf ("??? (%d)\n", val
);
15202 case Tag_ABI_compatibility
:
15204 val
= read_uleb128 (p
, &len
, end
);
15206 printf (" Tag_ABI_compatibility: ");
15207 printf (_("flag = %d, vendor = "), val
);
15210 size_t maxlen
= (end
- p
) - 1;
15212 print_symbol ((int) maxlen
, (const char *) p
);
15213 p
+= strnlen ((char *) p
, maxlen
) + 1;
15217 printf (_("<corrupt>"));
15218 p
= (unsigned char *) end
;
15224 case Tag_ABI_conformance
:
15226 printf (" Tag_ABI_conformance: \"");
15229 size_t maxlen
= (end
- p
) - 1;
15231 print_symbol ((int) maxlen
, (const char *) p
);
15232 p
+= strnlen ((char *) p
, maxlen
) + 1;
15236 printf (_("<corrupt>"));
15237 p
= (unsigned char *) end
;
15244 return display_tag_value (tag
, p
, end
);
15248 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15250 unsigned long addr
= 0;
15251 size_t bytes
= end
- p
;
15258 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15260 printf (" 0x%8.8lx ", addr
);
15262 for (j
= 0; j
< 16; j
++)
15265 printf ("%2.2x", p
[j
]);
15273 for (j
= 0; j
< lbytes
; j
++)
15276 if (k
>= ' ' && k
< 0x7f)
15292 static unsigned char *
15293 display_msp430x_attribute (unsigned char * p
,
15294 const unsigned char * const end
)
15300 tag
= read_uleb128 (p
, & len
, end
);
15305 case OFBA_MSPABI_Tag_ISA
:
15306 val
= read_uleb128 (p
, &len
, end
);
15308 printf (" Tag_ISA: ");
15311 case 0: printf (_("None\n")); break;
15312 case 1: printf (_("MSP430\n")); break;
15313 case 2: printf (_("MSP430X\n")); break;
15314 default: printf ("??? (%d)\n", val
); break;
15318 case OFBA_MSPABI_Tag_Code_Model
:
15319 val
= read_uleb128 (p
, &len
, end
);
15321 printf (" Tag_Code_Model: ");
15324 case 0: printf (_("None\n")); break;
15325 case 1: printf (_("Small\n")); break;
15326 case 2: printf (_("Large\n")); break;
15327 default: printf ("??? (%d)\n", val
); break;
15331 case OFBA_MSPABI_Tag_Data_Model
:
15332 val
= read_uleb128 (p
, &len
, end
);
15334 printf (" Tag_Data_Model: ");
15337 case 0: printf (_("None\n")); break;
15338 case 1: printf (_("Small\n")); break;
15339 case 2: printf (_("Large\n")); break;
15340 case 3: printf (_("Restricted Large\n")); break;
15341 default: printf ("??? (%d)\n", val
); break;
15346 printf (_(" <unknown tag %d>: "), tag
);
15353 size_t maxlen
= (end
- p
) - 1;
15355 print_symbol ((int) maxlen
, (const char *) p
);
15356 p
+= strnlen ((char *) p
, maxlen
) + 1;
15360 printf (_("<corrupt>"));
15361 p
= (unsigned char *) end
;
15367 val
= read_uleb128 (p
, &len
, end
);
15369 printf ("%d (0x%x)\n", val
, val
);
15378 struct riscv_attr_tag_t
{
15383 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15385 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15388 T(priv_spec_minor
),
15389 T(priv_spec_revision
),
15390 T(unaligned_access
),
15395 static unsigned char *
15396 display_riscv_attribute (unsigned char *p
,
15397 const unsigned char * const end
)
15402 struct riscv_attr_tag_t
*attr
= NULL
;
15405 tag
= read_uleb128 (p
, &len
, end
);
15408 /* Find the name of attribute. */
15409 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
15411 if (riscv_attr_tag
[i
].tag
== tag
)
15413 attr
= &riscv_attr_tag
[i
];
15419 printf (" %s: ", attr
->name
);
15421 return display_tag_value (tag
, p
, end
);
15425 case Tag_RISCV_priv_spec
:
15426 case Tag_RISCV_priv_spec_minor
:
15427 case Tag_RISCV_priv_spec_revision
:
15428 val
= read_uleb128 (p
, &len
, end
);
15430 printf (_("%d\n"), val
);
15432 case Tag_RISCV_unaligned_access
:
15433 val
= read_uleb128 (p
, &len
, end
);
15438 printf (_("No unaligned access\n"));
15441 printf (_("Unaligned access\n"));
15445 case Tag_RISCV_stack_align
:
15446 val
= read_uleb128 (p
, &len
, end
);
15448 printf (_("%d-bytes\n"), val
);
15450 case Tag_RISCV_arch
:
15451 p
= display_tag_value (-1, p
, end
);
15454 return display_tag_value (tag
, p
, end
);
15461 process_attributes (Filedata
* filedata
,
15462 const char * public_name
,
15463 unsigned int proc_type
,
15464 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15465 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15467 Elf_Internal_Shdr
* sect
;
15469 bfd_boolean res
= TRUE
;
15471 /* Find the section header so that we get the size. */
15472 for (i
= 0, sect
= filedata
->section_headers
;
15473 i
< filedata
->file_header
.e_shnum
;
15476 unsigned char * contents
;
15479 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15482 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15483 sect
->sh_size
, _("attributes"));
15484 if (contents
== NULL
)
15491 /* The first character is the version of the attributes.
15492 Currently only version 1, (aka 'A') is recognised here. */
15495 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15500 bfd_vma section_len
;
15502 section_len
= sect
->sh_size
- 1;
15505 while (section_len
> 0)
15508 unsigned int namelen
;
15509 bfd_boolean public_section
;
15510 bfd_boolean gnu_section
;
15512 if (section_len
<= 4)
15514 error (_("Tag section ends prematurely\n"));
15518 attr_len
= byte_get (p
, 4);
15521 if (attr_len
> section_len
)
15523 error (_("Bad attribute length (%u > %u)\n"),
15524 (unsigned) attr_len
, (unsigned) section_len
);
15525 attr_len
= section_len
;
15528 /* PR 17531: file: 001-101425-0.004 */
15529 else if (attr_len
< 5)
15531 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15536 section_len
-= attr_len
;
15539 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15540 if (namelen
== 0 || namelen
>= attr_len
)
15542 error (_("Corrupt attribute section name\n"));
15547 printf (_("Attribute Section: "));
15548 print_symbol (INT_MAX
, (const char *) p
);
15551 if (public_name
&& streq ((char *) p
, public_name
))
15552 public_section
= TRUE
;
15554 public_section
= FALSE
;
15556 if (streq ((char *) p
, "gnu"))
15557 gnu_section
= TRUE
;
15559 gnu_section
= FALSE
;
15562 attr_len
-= namelen
;
15564 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15569 unsigned char * end
;
15571 /* PR binutils/17531: Safe handling of corrupt files. */
15574 error (_("Unused bytes at end of section\n"));
15581 size
= byte_get (p
, 4);
15582 if (size
> attr_len
)
15584 error (_("Bad subsection length (%u > %u)\n"),
15585 (unsigned) size
, (unsigned) attr_len
);
15589 /* PR binutils/17531: Safe handling of corrupt files. */
15592 error (_("Bad subsection length (%u < 6)\n"),
15600 end
= p
+ size
- 1;
15601 assert (end
<= contents
+ sect
->sh_size
);
15607 printf (_("File Attributes\n"));
15610 printf (_("Section Attributes:"));
15613 printf (_("Symbol Attributes:"));
15614 /* Fall through. */
15620 val
= read_uleb128 (p
, &j
, end
);
15624 printf (" %d", val
);
15629 printf (_("Unknown tag: %d\n"), tag
);
15630 public_section
= FALSE
;
15634 if (public_section
&& display_pub_attribute
!= NULL
)
15637 p
= display_pub_attribute (p
, end
);
15640 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15643 p
= display_gnu_attribute (p
,
15644 display_proc_gnu_attribute
,
15650 printf (_(" Unknown attribute:\n"));
15651 display_raw_attribute (p
, end
);
15666 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15667 Print the Address, Access and Initial fields of an entry at VMA ADDR
15668 and return the VMA of the next entry, or -1 if there was a problem.
15669 Does not read from DATA_END or beyond. */
15672 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15673 unsigned char * data_end
)
15676 print_vma (addr
, LONG_HEX
);
15678 if (addr
< pltgot
+ 0xfff0)
15679 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15681 printf ("%10s", "");
15684 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15688 unsigned char * from
= data
+ addr
- pltgot
;
15690 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15692 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15693 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15694 return (bfd_vma
) -1;
15698 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15699 print_vma (entry
, LONG_HEX
);
15702 return addr
+ (is_32bit_elf
? 4 : 8);
15705 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15706 PLTGOT. Print the Address and Initial fields of an entry at VMA
15707 ADDR and return the VMA of the next entry. */
15710 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15713 print_vma (addr
, LONG_HEX
);
15716 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15721 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15722 print_vma (entry
, LONG_HEX
);
15724 return addr
+ (is_32bit_elf
? 4 : 8);
15728 print_mips_ases (unsigned int mask
)
15730 if (mask
& AFL_ASE_DSP
)
15731 fputs ("\n\tDSP ASE", stdout
);
15732 if (mask
& AFL_ASE_DSPR2
)
15733 fputs ("\n\tDSP R2 ASE", stdout
);
15734 if (mask
& AFL_ASE_DSPR3
)
15735 fputs ("\n\tDSP R3 ASE", stdout
);
15736 if (mask
& AFL_ASE_EVA
)
15737 fputs ("\n\tEnhanced VA Scheme", stdout
);
15738 if (mask
& AFL_ASE_MCU
)
15739 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15740 if (mask
& AFL_ASE_MDMX
)
15741 fputs ("\n\tMDMX ASE", stdout
);
15742 if (mask
& AFL_ASE_MIPS3D
)
15743 fputs ("\n\tMIPS-3D ASE", stdout
);
15744 if (mask
& AFL_ASE_MT
)
15745 fputs ("\n\tMT ASE", stdout
);
15746 if (mask
& AFL_ASE_SMARTMIPS
)
15747 fputs ("\n\tSmartMIPS ASE", stdout
);
15748 if (mask
& AFL_ASE_VIRT
)
15749 fputs ("\n\tVZ ASE", stdout
);
15750 if (mask
& AFL_ASE_MSA
)
15751 fputs ("\n\tMSA ASE", stdout
);
15752 if (mask
& AFL_ASE_MIPS16
)
15753 fputs ("\n\tMIPS16 ASE", stdout
);
15754 if (mask
& AFL_ASE_MICROMIPS
)
15755 fputs ("\n\tMICROMIPS ASE", stdout
);
15756 if (mask
& AFL_ASE_XPA
)
15757 fputs ("\n\tXPA ASE", stdout
);
15758 if (mask
& AFL_ASE_MIPS16E2
)
15759 fputs ("\n\tMIPS16e2 ASE", stdout
);
15760 if (mask
& AFL_ASE_CRC
)
15761 fputs ("\n\tCRC ASE", stdout
);
15762 if (mask
& AFL_ASE_GINV
)
15763 fputs ("\n\tGINV ASE", stdout
);
15764 if (mask
& AFL_ASE_LOONGSON_MMI
)
15765 fputs ("\n\tLoongson MMI ASE", stdout
);
15766 if (mask
& AFL_ASE_LOONGSON_CAM
)
15767 fputs ("\n\tLoongson CAM ASE", stdout
);
15768 if (mask
& AFL_ASE_LOONGSON_EXT
)
15769 fputs ("\n\tLoongson EXT ASE", stdout
);
15770 if (mask
& AFL_ASE_LOONGSON_EXT2
)
15771 fputs ("\n\tLoongson EXT2 ASE", stdout
);
15773 fprintf (stdout
, "\n\t%s", _("None"));
15774 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15775 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15779 print_mips_isa_ext (unsigned int isa_ext
)
15784 fputs (_("None"), stdout
);
15787 fputs ("RMI XLR", stdout
);
15789 case AFL_EXT_OCTEON3
:
15790 fputs ("Cavium Networks Octeon3", stdout
);
15792 case AFL_EXT_OCTEON2
:
15793 fputs ("Cavium Networks Octeon2", stdout
);
15795 case AFL_EXT_OCTEONP
:
15796 fputs ("Cavium Networks OcteonP", stdout
);
15798 case AFL_EXT_OCTEON
:
15799 fputs ("Cavium Networks Octeon", stdout
);
15802 fputs ("Toshiba R5900", stdout
);
15805 fputs ("MIPS R4650", stdout
);
15808 fputs ("LSI R4010", stdout
);
15811 fputs ("NEC VR4100", stdout
);
15814 fputs ("Toshiba R3900", stdout
);
15816 case AFL_EXT_10000
:
15817 fputs ("MIPS R10000", stdout
);
15820 fputs ("Broadcom SB-1", stdout
);
15823 fputs ("NEC VR4111/VR4181", stdout
);
15826 fputs ("NEC VR4120", stdout
);
15829 fputs ("NEC VR5400", stdout
);
15832 fputs ("NEC VR5500", stdout
);
15834 case AFL_EXT_LOONGSON_2E
:
15835 fputs ("ST Microelectronics Loongson 2E", stdout
);
15837 case AFL_EXT_LOONGSON_2F
:
15838 fputs ("ST Microelectronics Loongson 2F", stdout
);
15840 case AFL_EXT_INTERAPTIV_MR2
:
15841 fputs ("Imagination interAptiv MR2", stdout
);
15844 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15849 get_mips_reg_size (int reg_size
)
15851 return (reg_size
== AFL_REG_NONE
) ? 0
15852 : (reg_size
== AFL_REG_32
) ? 32
15853 : (reg_size
== AFL_REG_64
) ? 64
15854 : (reg_size
== AFL_REG_128
) ? 128
15859 process_mips_specific (Filedata
* filedata
)
15861 Elf_Internal_Dyn
* entry
;
15862 Elf_Internal_Shdr
*sect
= NULL
;
15863 size_t liblist_offset
= 0;
15864 size_t liblistno
= 0;
15865 size_t conflictsno
= 0;
15866 size_t options_offset
= 0;
15867 size_t conflicts_offset
= 0;
15868 size_t pltrelsz
= 0;
15870 bfd_vma pltgot
= 0;
15871 bfd_vma mips_pltgot
= 0;
15872 bfd_vma jmprel
= 0;
15873 bfd_vma local_gotno
= 0;
15874 bfd_vma gotsym
= 0;
15875 bfd_vma symtabno
= 0;
15876 bfd_boolean res
= TRUE
;
15878 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15879 display_mips_gnu_attribute
))
15882 sect
= find_section (filedata
, ".MIPS.abiflags");
15886 Elf_External_ABIFlags_v0
*abiflags_ext
;
15887 Elf_Internal_ABIFlags_v0 abiflags_in
;
15889 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15891 error (_("Corrupt MIPS ABI Flags section.\n"));
15896 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15897 sect
->sh_size
, _("MIPS ABI Flags section"));
15900 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15901 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15902 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15903 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15904 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15905 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15906 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15907 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15908 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15909 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15910 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15912 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15913 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15914 if (abiflags_in
.isa_rev
> 1)
15915 printf ("r%d", abiflags_in
.isa_rev
);
15916 printf ("\nGPR size: %d",
15917 get_mips_reg_size (abiflags_in
.gpr_size
));
15918 printf ("\nCPR1 size: %d",
15919 get_mips_reg_size (abiflags_in
.cpr1_size
));
15920 printf ("\nCPR2 size: %d",
15921 get_mips_reg_size (abiflags_in
.cpr2_size
));
15922 fputs ("\nFP ABI: ", stdout
);
15923 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15924 fputs ("ISA Extension: ", stdout
);
15925 print_mips_isa_ext (abiflags_in
.isa_ext
);
15926 fputs ("\nASEs:", stdout
);
15927 print_mips_ases (abiflags_in
.ases
);
15928 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15929 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15930 fputc ('\n', stdout
);
15931 free (abiflags_ext
);
15936 /* We have a lot of special sections. Thanks SGI! */
15937 if (dynamic_section
== NULL
)
15939 /* No dynamic information available. See if there is static GOT. */
15940 sect
= find_section (filedata
, ".got");
15943 unsigned char *data_end
;
15944 unsigned char *data
;
15948 pltgot
= sect
->sh_addr
;
15951 addr_size
= (is_32bit_elf
? 4 : 8);
15952 end
= pltgot
+ sect
->sh_size
;
15954 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15956 _("Global Offset Table data"));
15957 /* PR 12855: Null data is handled gracefully throughout. */
15958 data_end
= data
+ (end
- pltgot
);
15960 printf (_("\nStatic GOT:\n"));
15961 printf (_(" Canonical gp value: "));
15962 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15965 /* In a dynamic binary GOT[0] is reserved for the dynamic
15966 loader to store the lazy resolver pointer, however in
15967 a static binary it may well have been omitted and GOT
15968 reduced to a table of addresses.
15969 PR 21344: Check for the entry being fully available
15970 before fetching it. */
15972 && data
+ ent
- pltgot
+ addr_size
<= data_end
15973 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15975 printf (_(" Reserved entries:\n"));
15976 printf (_(" %*s %10s %*s\n"),
15977 addr_size
* 2, _("Address"), _("Access"),
15978 addr_size
* 2, _("Value"));
15979 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15981 if (ent
== (bfd_vma
) -1)
15982 goto sgot_print_fail
;
15984 /* Check for the MSB of GOT[1] being set, identifying a
15985 GNU object. This entry will be used by some runtime
15986 loaders, to store the module pointer. Otherwise this
15987 is an ordinary local entry.
15988 PR 21344: Check for the entry being fully available
15989 before fetching it. */
15991 && data
+ ent
- pltgot
+ addr_size
<= data_end
15992 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15993 >> (addr_size
* 8 - 1)) != 0)
15995 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15997 if (ent
== (bfd_vma
) -1)
15998 goto sgot_print_fail
;
16003 if (data
!= NULL
&& ent
< end
)
16005 printf (_(" Local entries:\n"));
16006 printf (" %*s %10s %*s\n",
16007 addr_size
* 2, _("Address"), _("Access"),
16008 addr_size
* 2, _("Value"));
16011 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16013 if (ent
== (bfd_vma
) -1)
16014 goto sgot_print_fail
;
16026 for (entry
= dynamic_section
;
16027 /* PR 17531 file: 012-50589-0.004. */
16028 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16030 switch (entry
->d_tag
)
16032 case DT_MIPS_LIBLIST
:
16034 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16035 liblistno
* sizeof (Elf32_External_Lib
));
16037 case DT_MIPS_LIBLISTNO
:
16038 liblistno
= entry
->d_un
.d_val
;
16040 case DT_MIPS_OPTIONS
:
16041 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16043 case DT_MIPS_CONFLICT
:
16045 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16046 conflictsno
* sizeof (Elf32_External_Conflict
));
16048 case DT_MIPS_CONFLICTNO
:
16049 conflictsno
= entry
->d_un
.d_val
;
16052 pltgot
= entry
->d_un
.d_ptr
;
16054 case DT_MIPS_LOCAL_GOTNO
:
16055 local_gotno
= entry
->d_un
.d_val
;
16057 case DT_MIPS_GOTSYM
:
16058 gotsym
= entry
->d_un
.d_val
;
16060 case DT_MIPS_SYMTABNO
:
16061 symtabno
= entry
->d_un
.d_val
;
16063 case DT_MIPS_PLTGOT
:
16064 mips_pltgot
= entry
->d_un
.d_ptr
;
16067 pltrel
= entry
->d_un
.d_val
;
16070 pltrelsz
= entry
->d_un
.d_val
;
16073 jmprel
= entry
->d_un
.d_ptr
;
16079 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16081 Elf32_External_Lib
* elib
;
16084 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16086 sizeof (Elf32_External_Lib
),
16087 _("liblist section data"));
16090 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16091 "\nSection '.liblist' contains %lu entries:\n",
16092 (unsigned long) liblistno
),
16093 (unsigned long) liblistno
);
16094 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16097 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16104 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16105 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16106 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16107 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16108 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16110 tmp
= gmtime (&atime
);
16111 snprintf (timebuf
, sizeof (timebuf
),
16112 "%04u-%02u-%02uT%02u:%02u:%02u",
16113 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16114 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16116 printf ("%3lu: ", (unsigned long) cnt
);
16117 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16118 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16120 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16121 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16122 liblist
.l_version
);
16124 if (liblist
.l_flags
== 0)
16128 static const struct
16135 { " EXACT_MATCH", LL_EXACT_MATCH
},
16136 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16137 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16138 { " EXPORTS", LL_EXPORTS
},
16139 { " DELAY_LOAD", LL_DELAY_LOAD
},
16140 { " DELTA", LL_DELTA
}
16142 int flags
= liblist
.l_flags
;
16145 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16146 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16148 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16149 flags
^= l_flags_vals
[fcnt
].bit
;
16152 printf (" %#x", (unsigned int) flags
);
16164 if (options_offset
!= 0)
16166 Elf_External_Options
* eopt
;
16167 Elf_Internal_Options
* iopt
;
16168 Elf_Internal_Options
* option
;
16171 sect
= filedata
->section_headers
;
16173 /* Find the section header so that we get the size. */
16174 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16175 /* PR 17533 file: 012-277276-0.004. */
16178 error (_("No MIPS_OPTIONS header found\n"));
16182 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16183 sect
->sh_size
, _("options"));
16186 iopt
= (Elf_Internal_Options
*)
16187 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16190 error (_("Out of memory allocating space for MIPS options\n"));
16197 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16199 Elf_External_Options
* eoption
;
16201 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16203 option
->kind
= BYTE_GET (eoption
->kind
);
16204 option
->size
= BYTE_GET (eoption
->size
);
16205 option
->section
= BYTE_GET (eoption
->section
);
16206 option
->info
= BYTE_GET (eoption
->info
);
16208 /* PR 17531: file: ffa0fa3b. */
16209 if (option
->size
< sizeof (* eopt
)
16210 || offset
+ option
->size
> sect
->sh_size
)
16212 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16215 offset
+= option
->size
;
16221 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16222 "\nSection '%s' contains %d entries:\n",
16224 printable_section_name (filedata
, sect
), cnt
);
16233 switch (option
->kind
)
16236 /* This shouldn't happen. */
16237 printf (" NULL %d %lx", option
->section
, option
->info
);
16240 printf (" REGINFO ");
16241 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16244 Elf32_External_RegInfo
* ereg
;
16245 Elf32_RegInfo reginfo
;
16247 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16248 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16249 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16250 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16251 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16252 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16253 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16255 printf ("GPR %08lx GP 0x%lx\n",
16256 reginfo
.ri_gprmask
,
16257 (unsigned long) reginfo
.ri_gp_value
);
16258 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16259 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16260 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16265 Elf64_External_RegInfo
* ereg
;
16266 Elf64_Internal_RegInfo reginfo
;
16268 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16269 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16270 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16271 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16272 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16273 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16274 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16276 printf ("GPR %08lx GP 0x",
16277 reginfo
.ri_gprmask
);
16278 printf_vma (reginfo
.ri_gp_value
);
16281 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16282 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16283 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16287 case ODK_EXCEPTIONS
:
16288 fputs (" EXCEPTIONS fpe_min(", stdout
);
16289 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16290 fputs (") fpe_max(", stdout
);
16291 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16292 fputs (")", stdout
);
16294 if (option
->info
& OEX_PAGE0
)
16295 fputs (" PAGE0", stdout
);
16296 if (option
->info
& OEX_SMM
)
16297 fputs (" SMM", stdout
);
16298 if (option
->info
& OEX_FPDBUG
)
16299 fputs (" FPDBUG", stdout
);
16300 if (option
->info
& OEX_DISMISS
)
16301 fputs (" DISMISS", stdout
);
16304 fputs (" PAD ", stdout
);
16305 if (option
->info
& OPAD_PREFIX
)
16306 fputs (" PREFIX", stdout
);
16307 if (option
->info
& OPAD_POSTFIX
)
16308 fputs (" POSTFIX", stdout
);
16309 if (option
->info
& OPAD_SYMBOL
)
16310 fputs (" SYMBOL", stdout
);
16313 fputs (" HWPATCH ", stdout
);
16314 if (option
->info
& OHW_R4KEOP
)
16315 fputs (" R4KEOP", stdout
);
16316 if (option
->info
& OHW_R8KPFETCH
)
16317 fputs (" R8KPFETCH", stdout
);
16318 if (option
->info
& OHW_R5KEOP
)
16319 fputs (" R5KEOP", stdout
);
16320 if (option
->info
& OHW_R5KCVTL
)
16321 fputs (" R5KCVTL", stdout
);
16324 fputs (" FILL ", stdout
);
16325 /* XXX Print content of info word? */
16328 fputs (" TAGS ", stdout
);
16329 /* XXX Print content of info word? */
16332 fputs (" HWAND ", stdout
);
16333 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16334 fputs (" R4KEOP_CHECKED", stdout
);
16335 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16336 fputs (" R4KEOP_CLEAN", stdout
);
16339 fputs (" HWOR ", stdout
);
16340 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16341 fputs (" R4KEOP_CHECKED", stdout
);
16342 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16343 fputs (" R4KEOP_CLEAN", stdout
);
16346 printf (" GP_GROUP %#06lx self-contained %#06lx",
16347 option
->info
& OGP_GROUP
,
16348 (option
->info
& OGP_SELF
) >> 16);
16351 printf (" IDENT %#06lx self-contained %#06lx",
16352 option
->info
& OGP_GROUP
,
16353 (option
->info
& OGP_SELF
) >> 16);
16356 /* This shouldn't happen. */
16357 printf (" %3d ??? %d %lx",
16358 option
->kind
, option
->section
, option
->info
);
16362 len
= sizeof (* eopt
);
16363 while (len
< option
->size
)
16365 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16367 if (ISPRINT (datum
))
16368 printf ("%c", datum
);
16370 printf ("\\%03o", datum
);
16373 fputs ("\n", stdout
);
16375 offset
+= option
->size
;
16385 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16387 Elf32_Conflict
* iconf
;
16390 if (dynamic_symbols
== NULL
)
16392 error (_("conflict list found without a dynamic symbol table\n"));
16396 /* PR 21345 - print a slightly more helpful error message
16397 if we are sure that the cmalloc will fail. */
16398 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16400 error (_("Overlarge number of conflicts detected: %lx\n"),
16401 (long) conflictsno
);
16405 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16408 error (_("Out of memory allocating space for dynamic conflicts\n"));
16414 Elf32_External_Conflict
* econf32
;
16416 econf32
= (Elf32_External_Conflict
*)
16417 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16418 sizeof (* econf32
), _("conflict"));
16422 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16423 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16429 Elf64_External_Conflict
* econf64
;
16431 econf64
= (Elf64_External_Conflict
*)
16432 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16433 sizeof (* econf64
), _("conflict"));
16437 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16438 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16443 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16444 "\nSection '.conflict' contains %lu entries:\n",
16445 (unsigned long) conflictsno
),
16446 (unsigned long) conflictsno
);
16447 puts (_(" Num: Index Value Name"));
16449 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16451 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16453 if (iconf
[cnt
] >= num_dynamic_syms
)
16454 printf (_("<corrupt symbol index>"));
16457 Elf_Internal_Sym
* psym
;
16459 psym
= & dynamic_symbols
[iconf
[cnt
]];
16460 print_vma (psym
->st_value
, FULL_HEX
);
16462 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16463 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16465 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16473 if (pltgot
!= 0 && local_gotno
!= 0)
16475 bfd_vma ent
, local_end
, global_end
;
16477 unsigned char * data
;
16478 unsigned char * data_end
;
16482 addr_size
= (is_32bit_elf
? 4 : 8);
16483 local_end
= pltgot
+ local_gotno
* addr_size
;
16485 /* PR binutils/17533 file: 012-111227-0.004 */
16486 if (symtabno
< gotsym
)
16488 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16489 (unsigned long) gotsym
, (unsigned long) symtabno
);
16493 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16494 /* PR 17531: file: 54c91a34. */
16495 if (global_end
< local_end
)
16497 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16501 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16502 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16503 global_end
- pltgot
, 1,
16504 _("Global Offset Table data"));
16505 /* PR 12855: Null data is handled gracefully throughout. */
16506 data_end
= data
+ (global_end
- pltgot
);
16508 printf (_("\nPrimary GOT:\n"));
16509 printf (_(" Canonical gp value: "));
16510 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16513 printf (_(" Reserved entries:\n"));
16514 printf (_(" %*s %10s %*s Purpose\n"),
16515 addr_size
* 2, _("Address"), _("Access"),
16516 addr_size
* 2, _("Initial"));
16517 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16518 printf (_(" Lazy resolver\n"));
16519 if (ent
== (bfd_vma
) -1)
16520 goto got_print_fail
;
16522 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16523 This entry will be used by some runtime loaders, to store the
16524 module pointer. Otherwise this is an ordinary local entry.
16525 PR 21344: Check for the entry being fully available before
16528 && data
+ ent
- pltgot
+ addr_size
<= data_end
16529 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16530 >> (addr_size
* 8 - 1)) != 0)
16532 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16533 printf (_(" Module pointer (GNU extension)\n"));
16534 if (ent
== (bfd_vma
) -1)
16535 goto got_print_fail
;
16539 if (data
!= NULL
&& ent
< local_end
)
16541 printf (_(" Local entries:\n"));
16542 printf (" %*s %10s %*s\n",
16543 addr_size
* 2, _("Address"), _("Access"),
16544 addr_size
* 2, _("Initial"));
16545 while (ent
< local_end
)
16547 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16549 if (ent
== (bfd_vma
) -1)
16550 goto got_print_fail
;
16555 if (data
!= NULL
&& gotsym
< symtabno
)
16559 printf (_(" Global entries:\n"));
16560 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16561 addr_size
* 2, _("Address"),
16563 addr_size
* 2, _("Initial"),
16564 addr_size
* 2, _("Sym.Val."),
16566 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16567 _("Ndx"), _("Name"));
16569 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16571 for (i
= gotsym
; i
< symtabno
; i
++)
16573 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16576 if (dynamic_symbols
== NULL
)
16577 printf (_("<no dynamic symbols>"));
16578 else if (i
< num_dynamic_syms
)
16580 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16582 print_vma (psym
->st_value
, LONG_HEX
);
16583 printf (" %-7s %3s ",
16584 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16585 get_symbol_index_type (filedata
, psym
->st_shndx
));
16587 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16588 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16590 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16593 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16594 (unsigned long) i
);
16597 if (ent
== (bfd_vma
) -1)
16608 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16611 size_t offset
, rel_offset
;
16612 unsigned long count
, i
;
16613 unsigned char * data
;
16614 int addr_size
, sym_width
;
16615 Elf_Internal_Rela
* rels
;
16617 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16618 if (pltrel
== DT_RELA
)
16620 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16625 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16630 addr_size
= (is_32bit_elf
? 4 : 8);
16631 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16633 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16634 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16635 1, _("Procedure Linkage Table data"));
16639 printf ("\nPLT GOT:\n\n");
16640 printf (_(" Reserved entries:\n"));
16641 printf (_(" %*s %*s Purpose\n"),
16642 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16643 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16644 printf (_(" PLT lazy resolver\n"));
16645 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16646 printf (_(" Module pointer\n"));
16649 printf (_(" Entries:\n"));
16650 printf (" %*s %*s %*s %-7s %3s %s\n",
16651 addr_size
* 2, _("Address"),
16652 addr_size
* 2, _("Initial"),
16653 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16654 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16655 for (i
= 0; i
< count
; i
++)
16657 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16659 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16662 if (idx
>= num_dynamic_syms
)
16663 printf (_("<corrupt symbol index: %lu>"), idx
);
16666 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16668 print_vma (psym
->st_value
, LONG_HEX
);
16669 printf (" %-7s %3s ",
16670 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16671 get_symbol_index_type (filedata
, psym
->st_shndx
));
16672 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16673 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16675 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16690 process_nds32_specific (Filedata
* filedata
)
16692 Elf_Internal_Shdr
*sect
= NULL
;
16694 sect
= find_section (filedata
, ".nds32_e_flags");
16697 unsigned int *flag
;
16699 printf ("\nNDS32 elf flags section:\n");
16700 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16701 sect
->sh_size
, _("NDS32 elf flags section"));
16706 switch ((*flag
) & 0x3)
16709 printf ("(VEC_SIZE):\tNo entry.\n");
16712 printf ("(VEC_SIZE):\t4 bytes\n");
16715 printf ("(VEC_SIZE):\t16 bytes\n");
16718 printf ("(VEC_SIZE):\treserved\n");
16727 process_gnu_liblist (Filedata
* filedata
)
16729 Elf_Internal_Shdr
* section
;
16730 Elf_Internal_Shdr
* string_sec
;
16731 Elf32_External_Lib
* elib
;
16733 size_t strtab_size
;
16735 unsigned long num_liblist
;
16737 bfd_boolean res
= TRUE
;
16742 for (i
= 0, section
= filedata
->section_headers
;
16743 i
< filedata
->file_header
.e_shnum
;
16746 switch (section
->sh_type
)
16748 case SHT_GNU_LIBLIST
:
16749 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16752 elib
= (Elf32_External_Lib
*)
16753 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16754 _("liblist section data"));
16762 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16763 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16764 string_sec
->sh_size
,
16765 _("liblist string table"));
16767 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16774 strtab_size
= string_sec
->sh_size
;
16776 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16777 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16778 "\nLibrary list section '%s' contains %lu entries:\n",
16780 printable_section_name (filedata
, section
),
16783 puts (_(" Library Time Stamp Checksum Version Flags"));
16785 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16793 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16794 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16795 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16796 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16797 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16799 tmp
= gmtime (&atime
);
16800 snprintf (timebuf
, sizeof (timebuf
),
16801 "%04u-%02u-%02uT%02u:%02u:%02u",
16802 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16803 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16805 printf ("%3lu: ", (unsigned long) cnt
);
16807 printf ("%-20s", liblist
.l_name
< strtab_size
16808 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16810 printf ("%-20.20s", liblist
.l_name
< strtab_size
16811 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16812 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16813 liblist
.l_version
, liblist
.l_flags
);
16824 static const char *
16825 get_note_type (Filedata
* filedata
, unsigned e_type
)
16827 static char buff
[64];
16829 if (filedata
->file_header
.e_type
== ET_CORE
)
16833 return _("NT_AUXV (auxiliary vector)");
16835 return _("NT_PRSTATUS (prstatus structure)");
16837 return _("NT_FPREGSET (floating point registers)");
16839 return _("NT_PRPSINFO (prpsinfo structure)");
16840 case NT_TASKSTRUCT
:
16841 return _("NT_TASKSTRUCT (task structure)");
16843 return _("NT_PRXFPREG (user_xfpregs structure)");
16845 return _("NT_PPC_VMX (ppc Altivec registers)");
16847 return _("NT_PPC_VSX (ppc VSX registers)");
16849 return _("NT_PPC_TAR (ppc TAR register)");
16851 return _("NT_PPC_PPR (ppc PPR register)");
16853 return _("NT_PPC_DSCR (ppc DSCR register)");
16855 return _("NT_PPC_EBB (ppc EBB registers)");
16857 return _("NT_PPC_PMU (ppc PMU registers)");
16858 case NT_PPC_TM_CGPR
:
16859 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16860 case NT_PPC_TM_CFPR
:
16861 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16862 case NT_PPC_TM_CVMX
:
16863 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16864 case NT_PPC_TM_CVSX
:
16865 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16866 case NT_PPC_TM_SPR
:
16867 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16868 case NT_PPC_TM_CTAR
:
16869 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16870 case NT_PPC_TM_CPPR
:
16871 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16872 case NT_PPC_TM_CDSCR
:
16873 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16875 return _("NT_386_TLS (x86 TLS information)");
16876 case NT_386_IOPERM
:
16877 return _("NT_386_IOPERM (x86 I/O permissions)");
16878 case NT_X86_XSTATE
:
16879 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16880 case NT_S390_HIGH_GPRS
:
16881 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16882 case NT_S390_TIMER
:
16883 return _("NT_S390_TIMER (s390 timer register)");
16884 case NT_S390_TODCMP
:
16885 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16886 case NT_S390_TODPREG
:
16887 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16889 return _("NT_S390_CTRS (s390 control registers)");
16890 case NT_S390_PREFIX
:
16891 return _("NT_S390_PREFIX (s390 prefix register)");
16892 case NT_S390_LAST_BREAK
:
16893 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16894 case NT_S390_SYSTEM_CALL
:
16895 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16897 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16898 case NT_S390_VXRS_LOW
:
16899 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16900 case NT_S390_VXRS_HIGH
:
16901 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16902 case NT_S390_GS_CB
:
16903 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16904 case NT_S390_GS_BC
:
16905 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16907 return _("NT_ARM_VFP (arm VFP registers)");
16909 return _("NT_ARM_TLS (AArch TLS registers)");
16910 case NT_ARM_HW_BREAK
:
16911 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16912 case NT_ARM_HW_WATCH
:
16913 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16915 return _("NT_PSTATUS (pstatus structure)");
16917 return _("NT_FPREGS (floating point registers)");
16919 return _("NT_PSINFO (psinfo structure)");
16921 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16923 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16924 case NT_WIN32PSTATUS
:
16925 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16927 return _("NT_SIGINFO (siginfo_t data)");
16929 return _("NT_FILE (mapped files)");
16937 return _("NT_VERSION (version)");
16939 return _("NT_ARCH (architecture)");
16940 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16942 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16948 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16953 print_core_note (Elf_Internal_Note
*pnote
)
16955 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16956 bfd_vma count
, page_size
;
16957 unsigned char *descdata
, *filenames
, *descend
;
16959 if (pnote
->type
!= NT_FILE
)
16969 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16970 /* Still "successful". */
16975 if (pnote
->descsz
< 2 * addr_size
)
16977 error (_(" Malformed note - too short for header\n"));
16981 descdata
= (unsigned char *) pnote
->descdata
;
16982 descend
= descdata
+ pnote
->descsz
;
16984 if (descdata
[pnote
->descsz
- 1] != '\0')
16986 error (_(" Malformed note - does not end with \\0\n"));
16990 count
= byte_get (descdata
, addr_size
);
16991 descdata
+= addr_size
;
16993 page_size
= byte_get (descdata
, addr_size
);
16994 descdata
+= addr_size
;
16996 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16997 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16999 error (_(" Malformed note - too short for supplied file count\n"));
17003 printf (_(" Page size: "));
17004 print_vma (page_size
, DEC
);
17007 printf (_(" %*s%*s%*s\n"),
17008 (int) (2 + 2 * addr_size
), _("Start"),
17009 (int) (4 + 2 * addr_size
), _("End"),
17010 (int) (4 + 2 * addr_size
), _("Page Offset"));
17011 filenames
= descdata
+ count
* 3 * addr_size
;
17012 while (count
-- > 0)
17014 bfd_vma start
, end
, file_ofs
;
17016 if (filenames
== descend
)
17018 error (_(" Malformed note - filenames end too early\n"));
17022 start
= byte_get (descdata
, addr_size
);
17023 descdata
+= addr_size
;
17024 end
= byte_get (descdata
, addr_size
);
17025 descdata
+= addr_size
;
17026 file_ofs
= byte_get (descdata
, addr_size
);
17027 descdata
+= addr_size
;
17030 print_vma (start
, FULL_HEX
);
17032 print_vma (end
, FULL_HEX
);
17034 print_vma (file_ofs
, FULL_HEX
);
17035 printf ("\n %s\n", filenames
);
17037 filenames
+= 1 + strlen ((char *) filenames
);
17043 static const char *
17044 get_gnu_elf_note_type (unsigned e_type
)
17046 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17049 case NT_GNU_ABI_TAG
:
17050 return _("NT_GNU_ABI_TAG (ABI version tag)");
17052 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17053 case NT_GNU_BUILD_ID
:
17054 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17055 case NT_GNU_GOLD_VERSION
:
17056 return _("NT_GNU_GOLD_VERSION (gold version)");
17057 case NT_GNU_PROPERTY_TYPE_0
:
17058 return _("NT_GNU_PROPERTY_TYPE_0");
17059 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17060 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17061 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17062 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17065 static char buff
[64];
17067 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17074 decode_x86_compat_isa (unsigned int bitmask
)
17078 unsigned int bit
= bitmask
& (- bitmask
);
17083 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17086 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17089 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17092 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17095 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17098 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17101 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17104 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17107 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17110 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17113 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17116 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17117 printf ("AVX512F");
17119 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17120 printf ("AVX512CD");
17122 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17123 printf ("AVX512ER");
17125 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17126 printf ("AVX512PF");
17128 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17129 printf ("AVX512VL");
17131 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17132 printf ("AVX512DQ");
17134 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17135 printf ("AVX512BW");
17138 printf (_("<unknown: %x>"), bit
);
17147 decode_x86_isa (unsigned int bitmask
)
17151 printf (_("<None>"));
17157 unsigned int bit
= bitmask
& (- bitmask
);
17162 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17165 case GNU_PROPERTY_X86_ISA_1_SSE
:
17168 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17171 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17174 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17177 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17180 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17183 case GNU_PROPERTY_X86_ISA_1_AVX
:
17186 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17189 case GNU_PROPERTY_X86_ISA_1_FMA
:
17192 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17193 printf ("AVX512F");
17195 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17196 printf ("AVX512CD");
17198 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17199 printf ("AVX512ER");
17201 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17202 printf ("AVX512PF");
17204 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17205 printf ("AVX512VL");
17207 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17208 printf ("AVX512DQ");
17210 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17211 printf ("AVX512BW");
17213 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17214 printf ("AVX512_4FMAPS");
17216 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17217 printf ("AVX512_4VNNIW");
17219 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17220 printf ("AVX512_BITALG");
17222 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17223 printf ("AVX512_IFMA");
17225 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17226 printf ("AVX512_VBMI");
17228 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17229 printf ("AVX512_VBMI2");
17231 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17232 printf ("AVX512_VNNI");
17235 printf (_("<unknown: %x>"), bit
);
17244 decode_x86_feature_1 (unsigned int bitmask
)
17248 printf (_("<None>"));
17254 unsigned int bit
= bitmask
& (- bitmask
);
17259 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17262 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17266 printf (_("<unknown: %x>"), bit
);
17275 decode_x86_feature_2 (unsigned int bitmask
)
17279 printf (_("<None>"));
17285 unsigned int bit
= bitmask
& (- bitmask
);
17290 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17293 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17296 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17299 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17302 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17305 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17308 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17311 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17314 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17315 printf ("XSAVEOPT");
17317 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17321 printf (_("<unknown: %x>"), bit
);
17330 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17332 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17333 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17334 unsigned int size
= is_32bit_elf
? 4 : 8;
17336 printf (_(" Properties: "));
17338 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17340 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17344 while (ptr
< ptr_end
)
17348 unsigned int datasz
;
17350 if ((size_t) (ptr_end
- ptr
) < 8)
17352 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17356 type
= byte_get (ptr
, 4);
17357 datasz
= byte_get (ptr
+ 4, 4);
17361 if (datasz
> (size_t) (ptr_end
- ptr
))
17363 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17368 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17370 if (filedata
->file_header
.e_machine
== EM_X86_64
17371 || filedata
->file_header
.e_machine
== EM_IAMCU
17372 || filedata
->file_header
.e_machine
== EM_386
)
17374 unsigned int bitmask
;
17377 bitmask
= byte_get (ptr
, 4);
17383 case GNU_PROPERTY_X86_ISA_1_USED
:
17385 printf (_("x86 ISA used: <corrupt length: %#x> "),
17389 printf ("x86 ISA used: ");
17390 decode_x86_isa (bitmask
);
17394 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17396 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17400 printf ("x86 ISA needed: ");
17401 decode_x86_isa (bitmask
);
17405 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17407 printf (_("x86 feature: <corrupt length: %#x> "),
17411 printf ("x86 feature: ");
17412 decode_x86_feature_1 (bitmask
);
17416 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17418 printf (_("x86 feature used: <corrupt length: %#x> "),
17422 printf ("x86 feature used: ");
17423 decode_x86_feature_2 (bitmask
);
17427 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17429 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17432 printf ("x86 feature needed: ");
17433 decode_x86_feature_2 (bitmask
);
17437 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17439 printf (_("x86 ISA used: <corrupt length: %#x> "),
17443 printf ("x86 ISA used: ");
17444 decode_x86_compat_isa (bitmask
);
17448 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
17450 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17454 printf ("x86 ISA needed: ");
17455 decode_x86_compat_isa (bitmask
);
17468 case GNU_PROPERTY_STACK_SIZE
:
17469 printf (_("stack size: "));
17470 if (datasz
!= size
)
17471 printf (_("<corrupt length: %#x> "), datasz
);
17473 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17476 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17477 printf ("no copy on protected ");
17479 printf (_("<corrupt length: %#x> "), datasz
);
17487 if (type
< GNU_PROPERTY_LOPROC
)
17488 printf (_("<unknown type %#x data: "), type
);
17489 else if (type
< GNU_PROPERTY_LOUSER
)
17490 printf (_("<procesor-specific type %#x data: "), type
);
17492 printf (_("<application-specific type %#x data: "), type
);
17493 for (j
= 0; j
< datasz
; ++j
)
17494 printf ("%02x ", ptr
[j
] & 0xff);
17498 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17499 if (ptr
== ptr_end
)
17512 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17514 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17515 switch (pnote
->type
)
17517 case NT_GNU_BUILD_ID
:
17521 printf (_(" Build ID: "));
17522 for (i
= 0; i
< pnote
->descsz
; ++i
)
17523 printf ("%02x", pnote
->descdata
[i
] & 0xff);
17528 case NT_GNU_ABI_TAG
:
17530 unsigned long os
, major
, minor
, subminor
;
17531 const char *osname
;
17533 /* PR 17531: file: 030-599401-0.004. */
17534 if (pnote
->descsz
< 16)
17536 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17540 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17541 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17542 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
17543 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
17547 case GNU_ABI_TAG_LINUX
:
17550 case GNU_ABI_TAG_HURD
:
17553 case GNU_ABI_TAG_SOLARIS
:
17554 osname
= "Solaris";
17556 case GNU_ABI_TAG_FREEBSD
:
17557 osname
= "FreeBSD";
17559 case GNU_ABI_TAG_NETBSD
:
17562 case GNU_ABI_TAG_SYLLABLE
:
17563 osname
= "Syllable";
17565 case GNU_ABI_TAG_NACL
:
17569 osname
= "Unknown";
17573 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17574 major
, minor
, subminor
);
17578 case NT_GNU_GOLD_VERSION
:
17582 printf (_(" Version: "));
17583 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17584 printf ("%c", pnote
->descdata
[i
]);
17591 unsigned long num_entries
, mask
;
17593 /* Hardware capabilities information. Word 0 is the number of entries.
17594 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17595 is a series of entries, where each entry is a single byte followed
17596 by a nul terminated string. The byte gives the bit number to test
17597 if enabled in the bitmask. */
17598 printf (_(" Hardware Capabilities: "));
17599 if (pnote
->descsz
< 8)
17601 error (_("<corrupt GNU_HWCAP>\n"));
17604 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17605 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17606 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17607 /* FIXME: Add code to display the entries... */
17611 case NT_GNU_PROPERTY_TYPE_0
:
17612 print_gnu_property_note (filedata
, pnote
);
17616 /* Handle unrecognised types. An error message should have already been
17617 created by get_gnu_elf_note_type(), so all that we need to do is to
17618 display the data. */
17622 printf (_(" Description data: "));
17623 for (i
= 0; i
< pnote
->descsz
; ++i
)
17624 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17633 static const char *
17634 get_v850_elf_note_type (enum v850_notes n_type
)
17636 static char buff
[64];
17640 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17641 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17642 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17643 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17644 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17645 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17647 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17653 print_v850_note (Elf_Internal_Note
* pnote
)
17657 if (pnote
->descsz
!= 4)
17660 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17664 printf (_("not set\n"));
17668 switch (pnote
->type
)
17670 case V850_NOTE_ALIGNMENT
:
17673 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17674 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17678 case V850_NOTE_DATA_SIZE
:
17681 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17682 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17686 case V850_NOTE_FPU_INFO
:
17689 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17690 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17694 case V850_NOTE_MMU_INFO
:
17695 case V850_NOTE_CACHE_INFO
:
17696 case V850_NOTE_SIMD_INFO
:
17697 if (val
== EF_RH850_SIMD
)
17699 printf (_("yes\n"));
17705 /* An 'unknown note type' message will already have been displayed. */
17709 printf (_("unknown value: %x\n"), val
);
17714 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17716 unsigned int version
;
17718 switch (pnote
->type
)
17720 case NT_NETBSD_IDENT
:
17721 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17722 if ((version
/ 10000) % 100)
17723 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17724 version
, version
/ 100000000, (version
/ 1000000) % 100,
17725 (version
/ 10000) % 100 > 26 ? "Z" : "",
17726 'A' + (version
/ 10000) % 26);
17728 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17729 version
, version
/ 100000000, (version
/ 1000000) % 100,
17730 (version
/ 100) % 100);
17733 case NT_NETBSD_MARCH
:
17734 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17739 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17745 static const char *
17746 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17750 case NT_FREEBSD_THRMISC
:
17751 return _("NT_THRMISC (thrmisc structure)");
17752 case NT_FREEBSD_PROCSTAT_PROC
:
17753 return _("NT_PROCSTAT_PROC (proc data)");
17754 case NT_FREEBSD_PROCSTAT_FILES
:
17755 return _("NT_PROCSTAT_FILES (files data)");
17756 case NT_FREEBSD_PROCSTAT_VMMAP
:
17757 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17758 case NT_FREEBSD_PROCSTAT_GROUPS
:
17759 return _("NT_PROCSTAT_GROUPS (groups data)");
17760 case NT_FREEBSD_PROCSTAT_UMASK
:
17761 return _("NT_PROCSTAT_UMASK (umask data)");
17762 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17763 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17764 case NT_FREEBSD_PROCSTAT_OSREL
:
17765 return _("NT_PROCSTAT_OSREL (osreldate data)");
17766 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17767 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17768 case NT_FREEBSD_PROCSTAT_AUXV
:
17769 return _("NT_PROCSTAT_AUXV (auxv data)");
17770 case NT_FREEBSD_PTLWPINFO
:
17771 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17773 return get_note_type (filedata
, e_type
);
17776 static const char *
17777 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17779 static char buff
[64];
17781 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17782 return _("NetBSD procinfo structure");
17784 /* As of Jan 2002 there are no other machine-independent notes
17785 defined for NetBSD core files. If the note type is less
17786 than the start of the machine-dependent note types, we don't
17789 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17791 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17795 switch (filedata
->file_header
.e_machine
)
17797 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17798 and PT_GETFPREGS == mach+2. */
17803 case EM_SPARC32PLUS
:
17807 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17808 return _("PT_GETREGS (reg structure)");
17809 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17810 return _("PT_GETFPREGS (fpreg structure)");
17816 /* On all other arch's, PT_GETREGS == mach+1 and
17817 PT_GETFPREGS == mach+3. */
17821 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17822 return _("PT_GETREGS (reg structure)");
17823 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17824 return _("PT_GETFPREGS (fpreg structure)");
17830 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17831 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17835 static const char *
17836 get_stapsdt_note_type (unsigned e_type
)
17838 static char buff
[64];
17843 return _("NT_STAPSDT (SystemTap probe descriptors)");
17849 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17854 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17856 int addr_size
= is_32bit_elf
? 4 : 8;
17857 char *data
= pnote
->descdata
;
17858 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17859 bfd_vma pc
, base_addr
, semaphore
;
17860 char *provider
, *probe
, *arg_fmt
;
17862 pc
= byte_get ((unsigned char *) data
, addr_size
);
17864 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17866 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17870 data
+= strlen (data
) + 1;
17872 data
+= strlen (data
) + 1;
17874 data
+= strlen (data
) + 1;
17876 printf (_(" Provider: %s\n"), provider
);
17877 printf (_(" Name: %s\n"), probe
);
17878 printf (_(" Location: "));
17879 print_vma (pc
, FULL_HEX
);
17880 printf (_(", Base: "));
17881 print_vma (base_addr
, FULL_HEX
);
17882 printf (_(", Semaphore: "));
17883 print_vma (semaphore
, FULL_HEX
);
17885 printf (_(" Arguments: %s\n"), arg_fmt
);
17887 return data
== data_end
;
17890 static const char *
17891 get_ia64_vms_note_type (unsigned e_type
)
17893 static char buff
[64];
17898 return _("NT_VMS_MHD (module header)");
17900 return _("NT_VMS_LNM (language name)");
17902 return _("NT_VMS_SRC (source files)");
17904 return "NT_VMS_TITLE";
17906 return _("NT_VMS_EIDC (consistency check)");
17907 case NT_VMS_FPMODE
:
17908 return _("NT_VMS_FPMODE (FP mode)");
17909 case NT_VMS_LINKTIME
:
17910 return "NT_VMS_LINKTIME";
17911 case NT_VMS_IMGNAM
:
17912 return _("NT_VMS_IMGNAM (image name)");
17914 return _("NT_VMS_IMGID (image id)");
17915 case NT_VMS_LINKID
:
17916 return _("NT_VMS_LINKID (link id)");
17917 case NT_VMS_IMGBID
:
17918 return _("NT_VMS_IMGBID (build id)");
17919 case NT_VMS_GSTNAM
:
17920 return _("NT_VMS_GSTNAM (sym table name)");
17921 case NT_VMS_ORIG_DYN
:
17922 return "NT_VMS_ORIG_DYN";
17923 case NT_VMS_PATCHTIME
:
17924 return "NT_VMS_PATCHTIME";
17926 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17932 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17934 switch (pnote
->type
)
17937 if (pnote
->descsz
> 36)
17939 size_t l
= strlen (pnote
->descdata
+ 34);
17940 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17941 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17942 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17943 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17946 printf (_(" Invalid size\n"));
17949 printf (_(" Language: %s\n"), pnote
->descdata
);
17952 case NT_VMS_FPMODE
:
17953 printf (_(" Floating Point mode: "));
17954 printf ("0x%016" BFD_VMA_FMT
"x\n",
17955 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17957 case NT_VMS_LINKTIME
:
17958 printf (_(" Link time: "));
17960 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17963 case NT_VMS_PATCHTIME
:
17964 printf (_(" Patch time: "));
17966 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17969 case NT_VMS_ORIG_DYN
:
17970 printf (_(" Major id: %u, minor id: %u\n"),
17971 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17972 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17973 printf (_(" Last modified : "));
17975 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17976 printf (_("\n Link flags : "));
17977 printf ("0x%016" BFD_VMA_FMT
"x\n",
17978 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17979 printf (_(" Header flags: 0x%08x\n"),
17980 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17981 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17984 case NT_VMS_IMGNAM
:
17985 printf (_(" Image name: %s\n"), pnote
->descdata
);
17987 case NT_VMS_GSTNAM
:
17988 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17991 printf (_(" Image id: %s\n"), pnote
->descdata
);
17993 case NT_VMS_LINKID
:
17994 printf (_(" Linker id: %s\n"), pnote
->descdata
);
18002 /* Find the symbol associated with a build attribute that is attached
18003 to address OFFSET. If PNAME is non-NULL then store the name of
18004 the symbol (if found) in the provided pointer, Returns NULL if a
18005 symbol could not be found. */
18007 static Elf_Internal_Sym
*
18008 get_symbol_for_build_attribute (Filedata
* filedata
,
18009 unsigned long offset
,
18010 bfd_boolean is_open_attr
,
18011 const char ** pname
)
18013 static Filedata
* saved_filedata
= NULL
;
18014 static char * strtab
;
18015 static unsigned long strtablen
;
18016 static Elf_Internal_Sym
* symtab
;
18017 static unsigned long nsyms
;
18018 Elf_Internal_Sym
* saved_sym
= NULL
;
18019 Elf_Internal_Sym
* sym
;
18021 if (filedata
->section_headers
!= NULL
18022 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
18024 Elf_Internal_Shdr
* symsec
;
18026 /* Load the symbol and string sections. */
18027 for (symsec
= filedata
->section_headers
;
18028 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18031 if (symsec
->sh_type
== SHT_SYMTAB
)
18033 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
18035 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18037 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
18039 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18040 1, strtab_sec
->sh_size
,
18041 _("string table"));
18042 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
18046 saved_filedata
= filedata
;
18049 if (symtab
== NULL
|| strtab
== NULL
)
18052 /* Find a symbol whose value matches offset. */
18053 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
18054 if (sym
->st_value
== offset
)
18056 if (sym
->st_name
>= strtablen
)
18057 /* Huh ? This should not happen. */
18060 if (strtab
[sym
->st_name
] == 0)
18063 /* The AArch64 and ARM architectures define mapping symbols
18064 (eg $d, $x, $t) which we want to ignore. */
18065 if (strtab
[sym
->st_name
] == '$'
18066 && strtab
[sym
->st_name
+ 1] != 0
18067 && strtab
[sym
->st_name
+ 2] == 0)
18072 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18073 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18074 FUNC symbols entirely. */
18075 switch (ELF_ST_TYPE (sym
->st_info
))
18082 /* If the symbol has a size associated
18083 with it then we can stop searching. */
18084 sym
= symtab
+ nsyms
;
18089 /* Ignore function symbols. */
18096 switch (ELF_ST_BIND (sym
->st_info
))
18099 if (saved_sym
== NULL
18100 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18105 if (saved_sym
== NULL
)
18115 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18123 if (saved_sym
&& pname
)
18124 * pname
= strtab
+ saved_sym
->st_name
;
18129 /* Returns true iff addr1 and addr2 are in the same section. */
18132 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18134 Elf_Internal_Shdr
* a1
;
18135 Elf_Internal_Shdr
* a2
;
18137 a1
= find_section_by_address (filedata
, addr1
);
18138 a2
= find_section_by_address (filedata
, addr2
);
18140 return a1
== a2
&& a1
!= NULL
;
18144 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18145 Filedata
* filedata
)
18147 static unsigned long global_offset
= 0;
18148 static unsigned long global_end
= 0;
18149 static unsigned long func_offset
= 0;
18150 static unsigned long func_end
= 0;
18152 Elf_Internal_Sym
* sym
;
18154 unsigned long start
;
18156 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18158 switch (pnote
->descsz
)
18161 /* A zero-length description means that the range of
18162 the previous note of the same type should be used. */
18165 if (global_end
> global_offset
)
18166 printf (_(" Applies to region from %#lx to %#lx\n"),
18167 global_offset
, global_end
);
18169 printf (_(" Applies to region from %#lx\n"), global_offset
);
18173 if (func_end
> func_offset
)
18174 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18176 printf (_(" Applies to region from %#lx\n"), func_offset
);
18181 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18188 /* FIXME: We should check that version 3+ notes are being used here... */
18189 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18190 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18194 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18200 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18201 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18205 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18206 printf (_(" <invalid descsz>"));
18211 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18212 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18213 in order to avoid them being confused with the start address of the
18214 first function in the file... */
18215 if (sym
== NULL
&& is_open_attr
)
18216 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18219 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18220 end
= start
+ sym
->st_size
;
18224 /* FIXME: Need to properly allow for section alignment.
18225 16 is just the alignment used on x86_64. */
18227 && start
> BFD_ALIGN (global_end
, 16)
18228 /* Build notes are not guaranteed to be organised in order of
18229 increasing address, but we should find the all of the notes
18230 for one section in the same place. */
18231 && same_section (filedata
, start
, global_end
))
18232 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18233 global_end
+ 1, start
- 1);
18235 printf (_(" Applies to region from %#lx"), start
);
18236 global_offset
= start
;
18240 printf (_(" to %#lx"), end
);
18246 printf (_(" Applies to region from %#lx"), start
);
18247 func_offset
= start
;
18251 printf (_(" to %#lx"), end
);
18257 printf (_(" (%s)"), name
);
18264 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18266 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18267 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18268 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18270 char name_attribute
;
18271 const char * expected_types
;
18272 const char * name
= pnote
->namedata
;
18276 if (name
== NULL
|| pnote
->namesz
< 2)
18278 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18279 print_symbol (-20, _(" <corrupt name>"));
18288 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18289 if (name
[0] == 'G' && name
[1] == 'A')
18291 if (pnote
->namesz
< 4)
18293 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18294 print_symbol (-20, _(" <corrupt name>"));
18303 switch ((name_type
= * name
))
18305 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18306 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18307 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18308 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18309 printf ("%c", * name
);
18313 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
18314 print_symbol (-20, _("<unknown name type>"));
18321 switch ((name_attribute
= * name
))
18323 case GNU_BUILD_ATTRIBUTE_VERSION
:
18324 text
= _("<version>");
18325 expected_types
= string_expected
;
18328 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18329 text
= _("<stack prot>");
18330 expected_types
= "!+*";
18333 case GNU_BUILD_ATTRIBUTE_RELRO
:
18334 text
= _("<relro>");
18335 expected_types
= bool_expected
;
18338 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
18339 text
= _("<stack size>");
18340 expected_types
= number_expected
;
18343 case GNU_BUILD_ATTRIBUTE_TOOL
:
18344 text
= _("<tool>");
18345 expected_types
= string_expected
;
18348 case GNU_BUILD_ATTRIBUTE_ABI
:
18350 expected_types
= "$*";
18353 case GNU_BUILD_ATTRIBUTE_PIC
:
18355 expected_types
= number_expected
;
18358 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
18359 text
= _("<short enum>");
18360 expected_types
= bool_expected
;
18364 if (ISPRINT (* name
))
18366 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
18368 if (len
> left
&& ! do_wide
)
18370 printf ("%.*s:", len
, name
);
18376 static char tmpbuf
[128];
18378 error (_("unrecognised byte in name field: %d\n"), * name
);
18379 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
18383 expected_types
= "*$!+";
18388 left
-= printf ("%s", text
);
18390 if (strchr (expected_types
, name_type
) == NULL
)
18391 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
18393 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
18395 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18396 (unsigned long) pnote
->namesz
,
18397 (long) (name
- pnote
->namedata
));
18401 if (left
< 1 && ! do_wide
)
18406 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18408 unsigned int bytes
;
18409 unsigned long long val
= 0;
18410 unsigned int shift
= 0;
18411 char * decoded
= NULL
;
18413 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
18415 /* The -1 is because the name field is always 0 terminated, and we
18416 want to be able to ensure that the shift in the while loop below
18417 will not overflow. */
18420 if (bytes
> sizeof (val
))
18422 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18424 bytes
= sizeof (val
);
18426 /* We do not bother to warn if bytes == 0 as this can
18427 happen with some early versions of the gcc plugin. */
18431 unsigned long byte
= (* name
++) & 0xff;
18433 val
|= byte
<< shift
;
18437 switch (name_attribute
)
18439 case GNU_BUILD_ATTRIBUTE_PIC
:
18442 case 0: decoded
= "static"; break;
18443 case 1: decoded
= "pic"; break;
18444 case 2: decoded
= "PIC"; break;
18445 case 3: decoded
= "pie"; break;
18446 case 4: decoded
= "PIE"; break;
18450 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18453 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18454 case 0: decoded
= "off"; break;
18455 case 1: decoded
= "on"; break;
18456 case 2: decoded
= "all"; break;
18457 case 3: decoded
= "strong"; break;
18458 case 4: decoded
= "explicit"; break;
18466 if (decoded
!= NULL
)
18468 print_symbol (-left
, decoded
);
18479 left
-= printf ("0x%llx", val
);
18481 left
-= printf ("0x%-.*llx", left
, val
);
18485 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18486 left
-= print_symbol (- left
, name
);
18488 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18489 left
-= print_symbol (- left
, "true");
18491 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18492 left
-= print_symbol (- left
, "false");
18496 if (do_wide
&& left
> 0)
18497 printf ("%-*s", left
, " ");
18502 /* Note that by the ELF standard, the name field is already null byte
18503 terminated, and namesz includes the terminating null byte.
18504 I.E. the value of namesz for the name "FSF" is 4.
18506 If the value of namesz is zero, there is no name present. */
18509 process_note (Elf_Internal_Note
* pnote
,
18510 Filedata
* filedata
)
18512 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
18515 if (pnote
->namesz
== 0)
18516 /* If there is no note name, then use the default set of
18517 note type strings. */
18518 nt
= get_note_type (filedata
, pnote
->type
);
18520 else if (const_strneq (pnote
->namedata
, "GNU"))
18521 /* GNU-specific object file notes. */
18522 nt
= get_gnu_elf_note_type (pnote
->type
);
18524 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
18525 /* FreeBSD-specific core file notes. */
18526 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
18528 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
18529 /* NetBSD-specific core file notes. */
18530 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
18532 else if (const_strneq (pnote
->namedata
, "NetBSD"))
18533 /* NetBSD-specific core file notes. */
18534 return process_netbsd_elf_note (pnote
);
18536 else if (strneq (pnote
->namedata
, "SPU/", 4))
18538 /* SPU-specific core file notes. */
18539 nt
= pnote
->namedata
+ 4;
18543 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18544 /* VMS/ia64-specific file notes. */
18545 nt
= get_ia64_vms_note_type (pnote
->type
);
18547 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18548 nt
= get_stapsdt_note_type (pnote
->type
);
18551 /* Don't recognize this note name; just use the default set of
18552 note type strings. */
18553 nt
= get_note_type (filedata
, pnote
->type
);
18557 if (((const_strneq (pnote
->namedata
, "GA")
18558 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18559 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18560 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18561 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18562 print_gnu_build_attribute_name (pnote
);
18564 print_symbol (-20, name
);
18567 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
18569 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
18571 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18572 return print_ia64_vms_note (pnote
);
18573 else if (const_strneq (pnote
->namedata
, "GNU"))
18574 return print_gnu_note (filedata
, pnote
);
18575 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18576 return print_stapsdt_note (pnote
);
18577 else if (const_strneq (pnote
->namedata
, "CORE"))
18578 return print_core_note (pnote
);
18579 else if (((const_strneq (pnote
->namedata
, "GA")
18580 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18581 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18582 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18583 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18584 return print_gnu_build_attribute_description (pnote
, filedata
);
18590 printf (_(" description data: "));
18591 for (i
= 0; i
< pnote
->descsz
; i
++)
18592 printf ("%02x ", pnote
->descdata
[i
]);
18604 process_notes_at (Filedata
* filedata
,
18605 Elf_Internal_Shdr
* section
,
18610 Elf_External_Note
* pnotes
;
18611 Elf_External_Note
* external
;
18613 bfd_boolean res
= TRUE
;
18620 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18623 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18628 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18631 if (pnotes
== NULL
)
18637 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18639 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18640 (unsigned long) offset
, (unsigned long) length
);
18642 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18643 specifies that notes should be aligned to 4 bytes in 32-bit
18644 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18645 we also support 4 byte alignment in 64-bit objects. If section
18646 alignment is less than 4, we treate alignment as 4 bytes. */
18649 else if (align
!= 4 && align
!= 8)
18651 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18656 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18658 end
= (char *) pnotes
+ length
;
18659 while ((char *) external
< end
)
18661 Elf_Internal_Note inote
;
18664 char * temp
= NULL
;
18665 size_t data_remaining
= end
- (char *) external
;
18667 if (!is_ia64_vms (filedata
))
18669 /* PR binutils/15191
18670 Make sure that there is enough data to read. */
18671 min_notesz
= offsetof (Elf_External_Note
, name
);
18672 if (data_remaining
< min_notesz
)
18674 warn (ngettext ("Corrupt note: only %ld byte remains, "
18675 "not enough for a full note\n",
18676 "Corrupt note: only %ld bytes remain, "
18677 "not enough for a full note\n",
18679 (long) data_remaining
);
18682 data_remaining
-= min_notesz
;
18684 inote
.type
= BYTE_GET (external
->type
);
18685 inote
.namesz
= BYTE_GET (external
->namesz
);
18686 inote
.namedata
= external
->name
;
18687 inote
.descsz
= BYTE_GET (external
->descsz
);
18688 inote
.descdata
= ((char *) external
18689 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18690 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18691 next
= ((char *) external
18692 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18696 Elf64_External_VMS_Note
*vms_external
;
18698 /* PR binutils/15191
18699 Make sure that there is enough data to read. */
18700 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18701 if (data_remaining
< min_notesz
)
18703 warn (ngettext ("Corrupt note: only %ld byte remains, "
18704 "not enough for a full note\n",
18705 "Corrupt note: only %ld bytes remain, "
18706 "not enough for a full note\n",
18708 (long) data_remaining
);
18711 data_remaining
-= min_notesz
;
18713 vms_external
= (Elf64_External_VMS_Note
*) external
;
18714 inote
.type
= BYTE_GET (vms_external
->type
);
18715 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18716 inote
.namedata
= vms_external
->name
;
18717 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18718 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18719 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18720 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18723 /* PR 17531: file: 3443835e. */
18724 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18725 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18726 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18727 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18728 || ((size_t) (next
- inote
.descdata
)
18729 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18731 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18732 (unsigned long) ((char *) external
- (char *) pnotes
));
18733 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18734 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18738 external
= (Elf_External_Note
*) next
;
18740 /* Verify that name is null terminated. It appears that at least
18741 one version of Linux (RedHat 6.0) generates corefiles that don't
18742 comply with the ELF spec by failing to include the null byte in
18744 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18746 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18748 temp
= (char *) malloc (inote
.namesz
+ 1);
18751 error (_("Out of memory allocating space for inote name\n"));
18756 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18757 inote
.namedata
= temp
;
18759 inote
.namedata
[inote
.namesz
] = 0;
18762 if (! process_note (& inote
, filedata
))
18778 process_corefile_note_segments (Filedata
* filedata
)
18780 Elf_Internal_Phdr
* segment
;
18782 bfd_boolean res
= TRUE
;
18784 if (! get_program_headers (filedata
))
18787 for (i
= 0, segment
= filedata
->program_headers
;
18788 i
< filedata
->file_header
.e_phnum
;
18791 if (segment
->p_type
== PT_NOTE
)
18792 if (! process_notes_at (filedata
, NULL
,
18793 (bfd_vma
) segment
->p_offset
,
18794 (bfd_vma
) segment
->p_filesz
,
18795 (bfd_vma
) segment
->p_align
))
18803 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18805 Elf_External_Note
* pnotes
;
18806 Elf_External_Note
* external
;
18808 bfd_boolean res
= TRUE
;
18813 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18815 if (pnotes
== NULL
)
18819 end
= (char*) pnotes
+ length
;
18821 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18822 (unsigned long) offset
, (unsigned long) length
);
18824 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18826 Elf_External_Note
* next
;
18827 Elf_Internal_Note inote
;
18829 inote
.type
= BYTE_GET (external
->type
);
18830 inote
.namesz
= BYTE_GET (external
->namesz
);
18831 inote
.namedata
= external
->name
;
18832 inote
.descsz
= BYTE_GET (external
->descsz
);
18833 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18834 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18836 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18838 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18839 inote
.descdata
= inote
.namedata
;
18843 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18845 if ( ((char *) next
> end
)
18846 || ((char *) next
< (char *) pnotes
))
18848 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18849 (unsigned long) ((char *) external
- (char *) pnotes
));
18850 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18851 inote
.type
, inote
.namesz
, inote
.descsz
);
18857 /* Prevent out-of-bounds indexing. */
18858 if ( inote
.namedata
+ inote
.namesz
> end
18859 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18861 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18862 (unsigned long) ((char *) external
- (char *) pnotes
));
18863 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18864 inote
.type
, inote
.namesz
, inote
.descsz
);
18868 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18870 if (! print_v850_note (& inote
))
18873 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18874 inote
.namesz
, inote
.descsz
);
18884 process_note_sections (Filedata
* filedata
)
18886 Elf_Internal_Shdr
* section
;
18888 unsigned int n
= 0;
18889 bfd_boolean res
= TRUE
;
18891 for (i
= 0, section
= filedata
->section_headers
;
18892 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18895 if (section
->sh_type
== SHT_NOTE
)
18897 if (! process_notes_at (filedata
, section
,
18898 (bfd_vma
) section
->sh_offset
,
18899 (bfd_vma
) section
->sh_size
,
18900 (bfd_vma
) section
->sh_addralign
))
18905 if (( filedata
->file_header
.e_machine
== EM_V800
18906 || filedata
->file_header
.e_machine
== EM_V850
18907 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18908 && section
->sh_type
== SHT_RENESAS_INFO
)
18910 if (! process_v850_notes (filedata
,
18911 (bfd_vma
) section
->sh_offset
,
18912 (bfd_vma
) section
->sh_size
))
18919 /* Try processing NOTE segments instead. */
18920 return process_corefile_note_segments (filedata
);
18926 process_notes (Filedata
* filedata
)
18928 /* If we have not been asked to display the notes then do nothing. */
18932 if (filedata
->file_header
.e_type
!= ET_CORE
)
18933 return process_note_sections (filedata
);
18935 /* No program headers means no NOTE segment. */
18936 if (filedata
->file_header
.e_phnum
> 0)
18937 return process_corefile_note_segments (filedata
);
18939 printf (_("No note segments present in the core file.\n"));
18943 static unsigned char *
18944 display_public_gnu_attributes (unsigned char * start
,
18945 const unsigned char * const end
)
18947 printf (_(" Unknown GNU attribute: %s\n"), start
);
18949 start
+= strnlen ((char *) start
, end
- start
);
18950 display_raw_attribute (start
, end
);
18952 return (unsigned char *) end
;
18955 static unsigned char *
18956 display_generic_attribute (unsigned char * start
,
18958 const unsigned char * const end
)
18961 return (unsigned char *) end
;
18963 return display_tag_value (tag
, start
, end
);
18967 process_arch_specific (Filedata
* filedata
)
18972 switch (filedata
->file_header
.e_machine
)
18975 case EM_ARC_COMPACT
:
18976 case EM_ARC_COMPACT2
:
18977 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18978 display_arc_attribute
,
18979 display_generic_attribute
);
18981 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18982 display_arm_attribute
,
18983 display_generic_attribute
);
18986 case EM_MIPS_RS3_LE
:
18987 return process_mips_specific (filedata
);
18990 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18991 display_msp430x_attribute
,
18992 display_generic_attribute
);
18995 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
18996 display_riscv_attribute
,
18997 display_generic_attribute
);
19000 return process_nds32_specific (filedata
);
19004 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19005 display_power_gnu_attribute
);
19009 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19010 display_s390_gnu_attribute
);
19013 case EM_SPARC32PLUS
:
19015 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19016 display_sparc_gnu_attribute
);
19019 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19020 display_tic6x_attribute
,
19021 display_generic_attribute
);
19024 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19025 display_public_gnu_attributes
,
19026 display_generic_attribute
);
19031 get_file_header (Filedata
* filedata
)
19033 /* Read in the identity array. */
19034 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19037 /* Determine how to read the rest of the header. */
19038 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19043 byte_get
= byte_get_little_endian
;
19044 byte_put
= byte_put_little_endian
;
19047 byte_get
= byte_get_big_endian
;
19048 byte_put
= byte_put_big_endian
;
19052 /* For now we only support 32 bit and 64 bit ELF files. */
19053 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19055 /* Read in the rest of the header. */
19058 Elf32_External_Ehdr ehdr32
;
19060 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19063 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19064 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19065 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19066 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19067 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19068 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19069 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19070 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19071 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19072 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19073 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19074 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19075 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19079 Elf64_External_Ehdr ehdr64
;
19081 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19082 we will not be able to cope with the 64bit data found in
19083 64 ELF files. Detect this now and abort before we start
19084 overwriting things. */
19085 if (sizeof (bfd_vma
) < 8)
19087 error (_("This instance of readelf has been built without support for a\n\
19088 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19092 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19095 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19096 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19097 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19098 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19099 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19100 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19101 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19102 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19103 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19104 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19105 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19106 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19107 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19110 if (filedata
->file_header
.e_shoff
)
19112 /* There may be some extensions in the first section header. Don't
19113 bomb if we can't read it. */
19115 get_32bit_section_headers (filedata
, TRUE
);
19117 get_64bit_section_headers (filedata
, TRUE
);
19124 close_file (Filedata
* filedata
)
19128 if (filedata
->handle
)
19129 fclose (filedata
->handle
);
19135 close_debug_file (void * data
)
19137 close_file ((Filedata
*) data
);
19141 open_file (const char * pathname
)
19143 struct stat statbuf
;
19144 Filedata
* filedata
= NULL
;
19146 if (stat (pathname
, & statbuf
) < 0
19147 || ! S_ISREG (statbuf
.st_mode
))
19150 filedata
= calloc (1, sizeof * filedata
);
19151 if (filedata
== NULL
)
19154 filedata
->handle
= fopen (pathname
, "rb");
19155 if (filedata
->handle
== NULL
)
19158 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19159 filedata
->file_name
= pathname
;
19161 if (! get_file_header (filedata
))
19164 if (filedata
->file_header
.e_shoff
)
19168 /* Read the section headers again, this time for real. */
19170 res
= get_32bit_section_headers (filedata
, FALSE
);
19172 res
= get_64bit_section_headers (filedata
, FALSE
);
19183 if (filedata
->handle
)
19184 fclose (filedata
->handle
);
19191 open_debug_file (const char * pathname
)
19193 return open_file (pathname
);
19196 /* Process one ELF object file according to the command line options.
19197 This file may actually be stored in an archive. The file is
19198 positioned at the start of the ELF object. Returns TRUE if no
19199 problems were encountered, FALSE otherwise. */
19202 process_object (Filedata
* filedata
)
19204 Filedata
* separates
;
19206 bfd_boolean res
= TRUE
;
19208 if (! get_file_header (filedata
))
19210 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19214 /* Initialise per file variables. */
19215 for (i
= ARRAY_SIZE (version_info
); i
--;)
19216 version_info
[i
] = 0;
19218 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19219 dynamic_info
[i
] = 0;
19220 dynamic_info_DT_GNU_HASH
= 0;
19222 /* Process the file. */
19224 printf (_("\nFile: %s\n"), filedata
->file_name
);
19226 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19227 Note we do this even if cmdline_dump_sects is empty because we
19228 must make sure that the dump_sets array is zeroed out before each
19229 object file is processed. */
19230 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19231 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19233 if (cmdline
.num_dump_sects
> 0)
19235 if (filedata
->num_dump_sects
== 0)
19236 /* A sneaky way of allocating the dump_sects array. */
19237 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19239 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19240 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19241 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19244 if (! process_file_header (filedata
))
19247 if (! process_section_headers (filedata
))
19249 /* Without loaded section headers we cannot process lots of things. */
19250 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19252 if (! do_using_dynamic
)
19253 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19256 if (! process_section_groups (filedata
))
19257 /* Without loaded section groups we cannot process unwind. */
19260 if (process_program_headers (filedata
))
19261 process_dynamic_section (filedata
);
19265 if (! process_relocs (filedata
))
19268 if (! process_unwind (filedata
))
19271 if (! process_symbol_table (filedata
))
19274 if (! process_syminfo (filedata
))
19277 if (! process_version_sections (filedata
))
19280 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19281 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
19285 if (! process_section_contents (filedata
))
19290 if (! process_section_headers (separates
))
19292 else if (! process_section_contents (separates
))
19296 if (! process_notes (filedata
))
19299 if (! process_gnu_liblist (filedata
))
19302 if (! process_arch_specific (filedata
))
19305 free (filedata
->program_headers
);
19306 filedata
->program_headers
= NULL
;
19308 free (filedata
->section_headers
);
19309 filedata
->section_headers
= NULL
;
19311 free (filedata
->string_table
);
19312 filedata
->string_table
= NULL
;
19313 filedata
->string_table_length
= 0;
19315 if (dynamic_strings
)
19317 free (dynamic_strings
);
19318 dynamic_strings
= NULL
;
19319 dynamic_strings_length
= 0;
19322 if (dynamic_symbols
)
19324 free (dynamic_symbols
);
19325 dynamic_symbols
= NULL
;
19326 num_dynamic_syms
= 0;
19329 if (dynamic_syminfo
)
19331 free (dynamic_syminfo
);
19332 dynamic_syminfo
= NULL
;
19335 if (dynamic_section
)
19337 free (dynamic_section
);
19338 dynamic_section
= NULL
;
19341 if (section_headers_groups
)
19343 free (section_headers_groups
);
19344 section_headers_groups
= NULL
;
19347 if (section_groups
)
19349 struct group_list
* g
;
19350 struct group_list
* next
;
19352 for (i
= 0; i
< group_count
; i
++)
19354 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
19361 free (section_groups
);
19362 section_groups
= NULL
;
19365 free_debug_memory ();
19370 /* Process an ELF archive.
19371 On entry the file is positioned just after the ARMAG string.
19372 Returns TRUE upon success, FALSE otherwise. */
19375 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
19377 struct archive_info arch
;
19378 struct archive_info nested_arch
;
19380 bfd_boolean ret
= TRUE
;
19384 /* The ARCH structure is used to hold information about this archive. */
19385 arch
.file_name
= NULL
;
19387 arch
.index_array
= NULL
;
19388 arch
.sym_table
= NULL
;
19389 arch
.longnames
= NULL
;
19391 /* The NESTED_ARCH structure is used as a single-item cache of information
19392 about a nested archive (when members of a thin archive reside within
19393 another regular archive file). */
19394 nested_arch
.file_name
= NULL
;
19395 nested_arch
.file
= NULL
;
19396 nested_arch
.index_array
= NULL
;
19397 nested_arch
.sym_table
= NULL
;
19398 nested_arch
.longnames
= NULL
;
19400 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
19401 is_thin_archive
, do_archive_index
) != 0)
19407 if (do_archive_index
)
19409 if (arch
.sym_table
== NULL
)
19410 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
19413 unsigned long i
, l
;
19414 unsigned long current_pos
;
19416 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19417 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
19419 current_pos
= ftell (filedata
->handle
);
19421 for (i
= l
= 0; i
< arch
.index_num
; i
++)
19423 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
19425 char * member_name
;
19427 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
19429 if (member_name
!= NULL
)
19431 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
19433 if (qualified_name
!= NULL
)
19435 printf (_("Contents of binary %s at offset "), qualified_name
);
19436 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
19438 free (qualified_name
);
19443 if (l
>= arch
.sym_size
)
19445 error (_("%s: end of the symbol table reached before the end of the index\n"),
19446 filedata
->file_name
);
19450 /* PR 17531: file: 0b6630b2. */
19451 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
19452 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
19455 if (arch
.uses_64bit_indices
)
19460 if (l
< arch
.sym_size
)
19462 error (ngettext ("%s: %ld byte remains in the symbol table, "
19463 "but without corresponding entries in "
19464 "the index table\n",
19465 "%s: %ld bytes remain in the symbol table, "
19466 "but without corresponding entries in "
19467 "the index table\n",
19468 arch
.sym_size
- l
),
19469 filedata
->file_name
, arch
.sym_size
- l
);
19473 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
19475 error (_("%s: failed to seek back to start of object files in the archive\n"),
19476 filedata
->file_name
);
19482 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
19483 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
19484 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
19485 && !do_section_groups
&& !do_dyn_syms
)
19487 ret
= TRUE
; /* Archive index only. */
19496 char * qualified_name
;
19498 /* Read the next archive header. */
19499 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
19501 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
19504 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
19505 if (got
!= sizeof arch
.arhdr
)
19509 /* PR 24049 - we cannot use filedata->file_name as this will
19510 have already been freed. */
19511 error (_("%s: failed to read archive header\n"), arch
.file_name
);
19516 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
19518 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
19523 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
19525 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
19526 if (archive_file_size
& 01)
19527 ++archive_file_size
;
19529 name
= get_archive_member_name (&arch
, &nested_arch
);
19532 error (_("%s: bad archive file name\n"), arch
.file_name
);
19536 namelen
= strlen (name
);
19538 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
19539 if (qualified_name
== NULL
)
19541 error (_("%s: bad archive file name\n"), arch
.file_name
);
19546 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
19548 /* This is a proxy for an external member of a thin archive. */
19549 Filedata
* member_filedata
;
19550 char * member_file_name
= adjust_relative_path
19551 (filedata
->file_name
, name
, namelen
);
19553 if (member_file_name
== NULL
)
19559 member_filedata
= open_file (member_file_name
);
19560 if (member_filedata
== NULL
)
19562 error (_("Input file '%s' is not readable.\n"), member_file_name
);
19563 free (member_file_name
);
19568 archive_file_offset
= arch
.nested_member_origin
;
19569 member_filedata
->file_name
= qualified_name
;
19571 if (! process_object (member_filedata
))
19574 close_file (member_filedata
);
19575 free (member_file_name
);
19577 else if (is_thin_archive
)
19579 Filedata thin_filedata
;
19581 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
19583 /* PR 15140: Allow for corrupt thin archives. */
19584 if (nested_arch
.file
== NULL
)
19586 error (_("%s: contains corrupt thin archive: %s\n"),
19587 qualified_name
, name
);
19592 /* This is a proxy for a member of a nested archive. */
19593 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19595 /* The nested archive file will have been opened and setup by
19596 get_archive_member_name. */
19597 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19599 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19604 thin_filedata
.handle
= nested_arch
.file
;
19605 thin_filedata
.file_name
= qualified_name
;
19607 if (! process_object (& thin_filedata
))
19612 archive_file_offset
= arch
.next_arhdr_offset
;
19613 arch
.next_arhdr_offset
+= archive_file_size
;
19615 filedata
->file_name
= qualified_name
;
19616 if (! process_object (filedata
))
19620 if (filedata
->dump_sects
!= NULL
)
19622 free (filedata
->dump_sects
);
19623 filedata
->dump_sects
= NULL
;
19624 filedata
->num_dump_sects
= 0;
19627 free (qualified_name
);
19631 if (nested_arch
.file
!= NULL
)
19632 fclose (nested_arch
.file
);
19633 release_archive (&nested_arch
);
19634 release_archive (&arch
);
19640 process_file (char * file_name
)
19642 Filedata
* filedata
= NULL
;
19643 struct stat statbuf
;
19644 char armag
[SARMAG
];
19645 bfd_boolean ret
= TRUE
;
19647 if (stat (file_name
, &statbuf
) < 0)
19649 if (errno
== ENOENT
)
19650 error (_("'%s': No such file\n"), file_name
);
19652 error (_("Could not locate '%s'. System error message: %s\n"),
19653 file_name
, strerror (errno
));
19657 if (! S_ISREG (statbuf
.st_mode
))
19659 error (_("'%s' is not an ordinary file\n"), file_name
);
19663 filedata
= calloc (1, sizeof * filedata
);
19664 if (filedata
== NULL
)
19666 error (_("Out of memory allocating file data structure\n"));
19670 filedata
->file_name
= file_name
;
19671 filedata
->handle
= fopen (file_name
, "rb");
19672 if (filedata
->handle
== NULL
)
19674 error (_("Input file '%s' is not readable.\n"), file_name
);
19679 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19681 error (_("%s: Failed to read file's magic number\n"), file_name
);
19682 fclose (filedata
->handle
);
19687 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19689 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19691 if (! process_archive (filedata
, FALSE
))
19694 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19696 if ( ! process_archive (filedata
, TRUE
))
19701 if (do_archive_index
)
19702 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19705 rewind (filedata
->handle
);
19706 archive_file_size
= archive_file_offset
= 0;
19708 if (! process_object (filedata
))
19712 fclose (filedata
->handle
);
19718 #ifdef SUPPORT_DISASSEMBLY
19719 /* Needed by the i386 disassembler. For extra credit, someone could
19720 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19724 print_address (unsigned int addr
, FILE * outfile
)
19726 fprintf (outfile
,"0x%8.8x", addr
);
19729 /* Needed by the i386 disassembler. */
19732 db_task_printsym (unsigned int addr
)
19734 print_address (addr
, stderr
);
19739 main (int argc
, char ** argv
)
19743 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19744 setlocale (LC_MESSAGES
, "");
19746 #if defined (HAVE_SETLOCALE)
19747 setlocale (LC_CTYPE
, "");
19749 bindtextdomain (PACKAGE
, LOCALEDIR
);
19750 textdomain (PACKAGE
);
19752 expandargv (&argc
, &argv
);
19754 cmdline
.file_name
= "<cmdline>";
19755 parse_args (& cmdline
, argc
, argv
);
19757 if (optind
< (argc
- 1))
19759 else if (optind
>= argc
)
19761 warn (_("Nothing to do.\n"));
19766 while (optind
< argc
)
19767 if (! process_file (argv
[optind
++]))
19770 if (cmdline
.dump_sects
!= NULL
)
19771 free (cmdline
.dump_sects
);
19773 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;