1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2018 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/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");
3695 if (e_flags
& EF_S390_HIGH_GPRS
)
3696 strcat (buf
, ", highgprs");
3700 if ((e_flags
& EF_C6000_REL
))
3701 strcat (buf
, ", relocatable module");
3705 strcat (buf
, _(": architecture variant: "));
3706 switch (e_flags
& EF_MSP430_MACH
)
3708 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3709 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3710 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3711 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3712 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3713 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3714 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3715 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3716 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3717 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3718 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3719 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3720 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3721 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3722 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3724 strcat (buf
, _(": unknown")); break;
3727 if (e_flags
& ~ EF_MSP430_MACH
)
3728 strcat (buf
, _(": unknown extra flag bits also present"));
3736 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3738 static char buff
[32];
3742 case ELFOSABI_NONE
: return "UNIX - System V";
3743 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3744 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3745 case ELFOSABI_GNU
: return "UNIX - GNU";
3746 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3747 case ELFOSABI_AIX
: return "UNIX - AIX";
3748 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3749 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3750 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3751 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3752 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3753 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3754 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3755 case ELFOSABI_AROS
: return "AROS";
3756 case ELFOSABI_FENIXOS
: return "FenixOS";
3757 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3758 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3761 switch (filedata
->file_header
.e_machine
)
3766 case ELFOSABI_ARM
: return "ARM";
3767 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3778 case ELFOSABI_STANDALONE
: return _("Standalone App");
3787 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3788 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3797 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3803 get_aarch64_segment_type (unsigned long type
)
3807 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3808 default: return NULL
;
3813 get_arm_segment_type (unsigned long type
)
3817 case PT_ARM_EXIDX
: return "EXIDX";
3818 default: return NULL
;
3823 get_s390_segment_type (unsigned long type
)
3827 case PT_S390_PGSTE
: return "S390_PGSTE";
3828 default: return NULL
;
3833 get_mips_segment_type (unsigned long type
)
3837 case PT_MIPS_REGINFO
: return "REGINFO";
3838 case PT_MIPS_RTPROC
: return "RTPROC";
3839 case PT_MIPS_OPTIONS
: return "OPTIONS";
3840 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3841 default: return NULL
;
3846 get_parisc_segment_type (unsigned long type
)
3850 case PT_HP_TLS
: return "HP_TLS";
3851 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3852 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3853 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3854 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3855 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3856 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3857 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3858 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3859 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3860 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3861 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3862 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3863 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3864 case PT_HP_STACK
: return "HP_STACK";
3865 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3866 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3867 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3868 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3869 default: return NULL
;
3874 get_ia64_segment_type (unsigned long type
)
3878 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3879 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3880 case PT_HP_TLS
: return "HP_TLS";
3881 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3882 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3883 case PT_IA_64_HP_STACK
: return "HP_STACK";
3884 default: return NULL
;
3889 get_tic6x_segment_type (unsigned long type
)
3893 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3894 default: return NULL
;
3899 get_solaris_segment_type (unsigned long type
)
3903 case 0x6464e550: return "PT_SUNW_UNWIND";
3904 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3905 case 0x6ffffff7: return "PT_LOSUNW";
3906 case 0x6ffffffa: return "PT_SUNWBSS";
3907 case 0x6ffffffb: return "PT_SUNWSTACK";
3908 case 0x6ffffffc: return "PT_SUNWDTRACE";
3909 case 0x6ffffffd: return "PT_SUNWCAP";
3910 case 0x6fffffff: return "PT_HISUNW";
3911 default: return NULL
;
3916 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3918 static char buff
[32];
3922 case PT_NULL
: return "NULL";
3923 case PT_LOAD
: return "LOAD";
3924 case PT_DYNAMIC
: return "DYNAMIC";
3925 case PT_INTERP
: return "INTERP";
3926 case PT_NOTE
: return "NOTE";
3927 case PT_SHLIB
: return "SHLIB";
3928 case PT_PHDR
: return "PHDR";
3929 case PT_TLS
: return "TLS";
3930 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3931 case PT_GNU_STACK
: return "GNU_STACK";
3932 case PT_GNU_RELRO
: return "GNU_RELRO";
3935 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3937 sprintf (buff
, "GNU_MBIND+%#lx",
3938 p_type
- PT_GNU_MBIND_LO
);
3940 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3942 const char * result
;
3944 switch (filedata
->file_header
.e_machine
)
3947 result
= get_aarch64_segment_type (p_type
);
3950 result
= get_arm_segment_type (p_type
);
3953 case EM_MIPS_RS3_LE
:
3954 result
= get_mips_segment_type (p_type
);
3957 result
= get_parisc_segment_type (p_type
);
3960 result
= get_ia64_segment_type (p_type
);
3963 result
= get_tic6x_segment_type (p_type
);
3967 result
= get_s390_segment_type (p_type
);
3977 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3979 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3981 const char * result
;
3983 switch (filedata
->file_header
.e_machine
)
3986 result
= get_parisc_segment_type (p_type
);
3989 result
= get_ia64_segment_type (p_type
);
3992 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3993 result
= get_solaris_segment_type (p_type
);
4002 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4005 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4012 get_arc_section_type_name (unsigned int sh_type
)
4016 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4024 get_mips_section_type_name (unsigned int sh_type
)
4028 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4029 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4030 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4031 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4032 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4033 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4034 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4035 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4036 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4037 case SHT_MIPS_RELD
: return "MIPS_RELD";
4038 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4039 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4040 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4041 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4042 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4043 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4044 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4045 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4046 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4047 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4048 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4049 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4050 case SHT_MIPS_LINE
: return "MIPS_LINE";
4051 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4052 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4053 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4054 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4055 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4056 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4057 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4058 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4059 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4060 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4061 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4062 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4063 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4064 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4065 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4066 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4067 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4075 get_parisc_section_type_name (unsigned int sh_type
)
4079 case SHT_PARISC_EXT
: return "PARISC_EXT";
4080 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4081 case SHT_PARISC_DOC
: return "PARISC_DOC";
4082 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4083 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4084 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4085 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4086 default: return NULL
;
4091 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4093 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4094 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4095 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4099 case SHT_IA_64_EXT
: return "IA_64_EXT";
4100 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4101 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4102 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4103 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4104 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4105 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4106 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4107 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4108 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4116 get_x86_64_section_type_name (unsigned int sh_type
)
4120 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4121 default: return NULL
;
4126 get_aarch64_section_type_name (unsigned int sh_type
)
4130 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4131 default: return NULL
;
4136 get_arm_section_type_name (unsigned int sh_type
)
4140 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4141 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4142 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4143 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4144 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4145 default: return NULL
;
4150 get_tic6x_section_type_name (unsigned int sh_type
)
4154 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4155 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4156 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4157 case SHT_TI_ICODE
: return "TI_ICODE";
4158 case SHT_TI_XREF
: return "TI_XREF";
4159 case SHT_TI_HANDLER
: return "TI_HANDLER";
4160 case SHT_TI_INITINFO
: return "TI_INITINFO";
4161 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4162 default: return NULL
;
4167 get_msp430x_section_type_name (unsigned int sh_type
)
4171 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4172 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4173 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4174 default: return NULL
;
4179 get_nfp_section_type_name (unsigned int sh_type
)
4183 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4184 case SHT_NFP_INITREG
: return "NFP_INITREG";
4185 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4186 default: return NULL
;
4191 get_v850_section_type_name (unsigned int sh_type
)
4195 case SHT_V850_SCOMMON
: return "V850 Small Common";
4196 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4197 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4198 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4199 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4200 default: return NULL
;
4205 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4207 static char buff
[32];
4208 const char * result
;
4212 case SHT_NULL
: return "NULL";
4213 case SHT_PROGBITS
: return "PROGBITS";
4214 case SHT_SYMTAB
: return "SYMTAB";
4215 case SHT_STRTAB
: return "STRTAB";
4216 case SHT_RELA
: return "RELA";
4217 case SHT_HASH
: return "HASH";
4218 case SHT_DYNAMIC
: return "DYNAMIC";
4219 case SHT_NOTE
: return "NOTE";
4220 case SHT_NOBITS
: return "NOBITS";
4221 case SHT_REL
: return "REL";
4222 case SHT_SHLIB
: return "SHLIB";
4223 case SHT_DYNSYM
: return "DYNSYM";
4224 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4225 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4226 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4227 case SHT_GNU_HASH
: return "GNU_HASH";
4228 case SHT_GROUP
: return "GROUP";
4229 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4230 case SHT_GNU_verdef
: return "VERDEF";
4231 case SHT_GNU_verneed
: return "VERNEED";
4232 case SHT_GNU_versym
: return "VERSYM";
4233 case 0x6ffffff0: return "VERSYM";
4234 case 0x6ffffffc: return "VERDEF";
4235 case 0x7ffffffd: return "AUXILIARY";
4236 case 0x7fffffff: return "FILTER";
4237 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4240 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4242 switch (filedata
->file_header
.e_machine
)
4245 case EM_ARC_COMPACT
:
4246 case EM_ARC_COMPACT2
:
4247 result
= get_arc_section_type_name (sh_type
);
4250 case EM_MIPS_RS3_LE
:
4251 result
= get_mips_section_type_name (sh_type
);
4254 result
= get_parisc_section_type_name (sh_type
);
4257 result
= get_ia64_section_type_name (filedata
, sh_type
);
4262 result
= get_x86_64_section_type_name (sh_type
);
4265 result
= get_aarch64_section_type_name (sh_type
);
4268 result
= get_arm_section_type_name (sh_type
);
4271 result
= get_tic6x_section_type_name (sh_type
);
4274 result
= get_msp430x_section_type_name (sh_type
);
4277 result
= get_nfp_section_type_name (sh_type
);
4281 case EM_CYGNUS_V850
:
4282 result
= get_v850_section_type_name (sh_type
);
4292 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4294 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4296 switch (filedata
->file_header
.e_machine
)
4299 result
= get_ia64_section_type_name (filedata
, sh_type
);
4302 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4303 result
= get_solaris_section_type (sh_type
);
4308 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4309 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4310 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4311 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4323 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4325 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4327 switch (filedata
->file_header
.e_machine
)
4331 case EM_CYGNUS_V850
:
4332 result
= get_v850_section_type_name (sh_type
);
4342 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4345 /* This message is probably going to be displayed in a 15
4346 character wide field, so put the hex value first. */
4347 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4353 #define OPTION_DEBUG_DUMP 512
4354 #define OPTION_DYN_SYMS 513
4355 #define OPTION_DWARF_DEPTH 514
4356 #define OPTION_DWARF_START 515
4357 #define OPTION_DWARF_CHECK 516
4359 static struct option options
[] =
4361 {"all", no_argument
, 0, 'a'},
4362 {"file-header", no_argument
, 0, 'h'},
4363 {"program-headers", no_argument
, 0, 'l'},
4364 {"headers", no_argument
, 0, 'e'},
4365 {"histogram", no_argument
, 0, 'I'},
4366 {"segments", no_argument
, 0, 'l'},
4367 {"sections", no_argument
, 0, 'S'},
4368 {"section-headers", no_argument
, 0, 'S'},
4369 {"section-groups", no_argument
, 0, 'g'},
4370 {"section-details", no_argument
, 0, 't'},
4371 {"full-section-name",no_argument
, 0, 'N'},
4372 {"symbols", no_argument
, 0, 's'},
4373 {"syms", no_argument
, 0, 's'},
4374 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4375 {"relocs", no_argument
, 0, 'r'},
4376 {"notes", no_argument
, 0, 'n'},
4377 {"dynamic", no_argument
, 0, 'd'},
4378 {"arch-specific", no_argument
, 0, 'A'},
4379 {"version-info", no_argument
, 0, 'V'},
4380 {"use-dynamic", no_argument
, 0, 'D'},
4381 {"unwind", no_argument
, 0, 'u'},
4382 {"archive-index", no_argument
, 0, 'c'},
4383 {"hex-dump", required_argument
, 0, 'x'},
4384 {"relocated-dump", required_argument
, 0, 'R'},
4385 {"string-dump", required_argument
, 0, 'p'},
4386 {"decompress", no_argument
, 0, 'z'},
4387 #ifdef SUPPORT_DISASSEMBLY
4388 {"instruction-dump", required_argument
, 0, 'i'},
4390 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4392 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4393 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4394 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4396 {"version", no_argument
, 0, 'v'},
4397 {"wide", no_argument
, 0, 'W'},
4398 {"help", no_argument
, 0, 'H'},
4399 {0, no_argument
, 0, 0}
4403 usage (FILE * stream
)
4405 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4406 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4407 fprintf (stream
, _(" Options are:\n\
4408 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4409 -h --file-header Display the ELF file header\n\
4410 -l --program-headers Display the program headers\n\
4411 --segments An alias for --program-headers\n\
4412 -S --section-headers Display the sections' header\n\
4413 --sections An alias for --section-headers\n\
4414 -g --section-groups Display the section groups\n\
4415 -t --section-details Display the section details\n\
4416 -e --headers Equivalent to: -h -l -S\n\
4417 -s --syms Display the symbol table\n\
4418 --symbols An alias for --syms\n\
4419 --dyn-syms Display the dynamic symbol table\n\
4420 -n --notes Display the core notes (if present)\n\
4421 -r --relocs Display the relocations (if present)\n\
4422 -u --unwind Display the unwind info (if present)\n\
4423 -d --dynamic Display the dynamic section (if present)\n\
4424 -V --version-info Display the version sections (if present)\n\
4425 -A --arch-specific Display architecture specific information (if any)\n\
4426 -c --archive-index Display the symbol/file index in an archive\n\
4427 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4428 -x --hex-dump=<number|name>\n\
4429 Dump the contents of section <number|name> as bytes\n\
4430 -p --string-dump=<number|name>\n\
4431 Dump the contents of section <number|name> as strings\n\
4432 -R --relocated-dump=<number|name>\n\
4433 Dump the contents of section <number|name> as relocated bytes\n\
4434 -z --decompress Decompress section before dumping it\n\
4435 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4436 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4437 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4438 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4439 =addr,=cu_index,=links,=follow-links]\n\
4440 Display the contents of DWARF debug sections\n"));
4441 fprintf (stream
, _("\
4442 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4443 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4445 #ifdef SUPPORT_DISASSEMBLY
4446 fprintf (stream
, _("\
4447 -i --instruction-dump=<number|name>\n\
4448 Disassemble the contents of section <number|name>\n"));
4450 fprintf (stream
, _("\
4451 -I --histogram Display histogram of bucket list lengths\n\
4452 -W --wide Allow output width to exceed 80 characters\n\
4453 @<file> Read options from <file>\n\
4454 -H --help Display this information\n\
4455 -v --version Display the version number of readelf\n"));
4457 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4458 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4460 exit (stream
== stdout
? 0 : 1);
4463 /* Record the fact that the user wants the contents of section number
4464 SECTION to be displayed using the method(s) encoded as flags bits
4465 in TYPE. Note, TYPE can be zero if we are creating the array for
4469 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4471 if (section
>= filedata
->num_dump_sects
)
4473 dump_type
* new_dump_sects
;
4475 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4476 sizeof (* new_dump_sects
));
4478 if (new_dump_sects
== NULL
)
4479 error (_("Out of memory allocating dump request table.\n"));
4482 if (filedata
->dump_sects
)
4484 /* Copy current flag settings. */
4485 memcpy (new_dump_sects
, filedata
->dump_sects
,
4486 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4488 free (filedata
->dump_sects
);
4491 filedata
->dump_sects
= new_dump_sects
;
4492 filedata
->num_dump_sects
= section
+ 1;
4496 if (filedata
->dump_sects
)
4497 filedata
->dump_sects
[section
] |= type
;
4500 /* Request a dump by section name. */
4503 request_dump_byname (const char * section
, dump_type type
)
4505 struct dump_list_entry
* new_request
;
4507 new_request
= (struct dump_list_entry
*)
4508 malloc (sizeof (struct dump_list_entry
));
4510 error (_("Out of memory allocating dump request table.\n"));
4512 new_request
->name
= strdup (section
);
4513 if (!new_request
->name
)
4514 error (_("Out of memory allocating dump request table.\n"));
4516 new_request
->type
= type
;
4518 new_request
->next
= dump_sects_byname
;
4519 dump_sects_byname
= new_request
;
4523 request_dump (Filedata
* filedata
, dump_type type
)
4529 section
= strtoul (optarg
, & cp
, 0);
4531 if (! *cp
&& section
>= 0)
4532 request_dump_bynumber (filedata
, section
, type
);
4534 request_dump_byname (optarg
, type
);
4538 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4545 while ((c
= getopt_long
4546 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4564 do_section_groups
= TRUE
;
4567 do_histogram
= TRUE
;
4572 do_section_groups
= TRUE
;
4577 do_section_details
= TRUE
;
4588 do_using_dynamic
= TRUE
;
4612 do_histogram
= TRUE
;
4618 do_archive_index
= TRUE
;
4621 request_dump (filedata
, HEX_DUMP
);
4624 request_dump (filedata
, STRING_DUMP
);
4627 request_dump (filedata
, RELOC_DUMP
);
4630 decompress_dumps
= TRUE
;
4636 do_debugging
= TRUE
;
4637 dwarf_select_sections_all ();
4641 do_debugging
= FALSE
;
4642 dwarf_select_sections_by_letters (optarg
);
4645 case OPTION_DEBUG_DUMP
:
4648 do_debugging
= TRUE
;
4651 do_debugging
= FALSE
;
4652 dwarf_select_sections_by_names (optarg
);
4655 case OPTION_DWARF_DEPTH
:
4659 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4662 case OPTION_DWARF_START
:
4666 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4669 case OPTION_DWARF_CHECK
:
4672 case OPTION_DYN_SYMS
:
4675 #ifdef SUPPORT_DISASSEMBLY
4677 request_dump (filedata
, DISASS_DUMP
);
4681 print_version (program_name
);
4690 /* xgettext:c-format */
4691 error (_("Invalid option '-%c'\n"), c
);
4698 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4699 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4700 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4701 && !do_section_groups
&& !do_archive_index
4707 get_elf_class (unsigned int elf_class
)
4709 static char buff
[32];
4713 case ELFCLASSNONE
: return _("none");
4714 case ELFCLASS32
: return "ELF32";
4715 case ELFCLASS64
: return "ELF64";
4717 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4723 get_data_encoding (unsigned int encoding
)
4725 static char buff
[32];
4729 case ELFDATANONE
: return _("none");
4730 case ELFDATA2LSB
: return _("2's complement, little endian");
4731 case ELFDATA2MSB
: return _("2's complement, big endian");
4733 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4738 /* Decode the data held in 'filedata->file_header'. */
4741 process_file_header (Filedata
* filedata
)
4743 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4745 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4746 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4747 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4748 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4751 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4755 init_dwarf_regnames (header
->e_machine
);
4761 printf (_("ELF Header:\n"));
4762 printf (_(" Magic: "));
4763 for (i
= 0; i
< EI_NIDENT
; i
++)
4764 printf ("%2.2x ", header
->e_ident
[i
]);
4766 printf (_(" Class: %s\n"),
4767 get_elf_class (header
->e_ident
[EI_CLASS
]));
4768 printf (_(" Data: %s\n"),
4769 get_data_encoding (header
->e_ident
[EI_DATA
]));
4770 printf (_(" Version: %d%s\n"),
4771 header
->e_ident
[EI_VERSION
],
4772 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4774 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4777 printf (_(" OS/ABI: %s\n"),
4778 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4779 printf (_(" ABI Version: %d\n"),
4780 header
->e_ident
[EI_ABIVERSION
]);
4781 printf (_(" Type: %s\n"),
4782 get_file_type (header
->e_type
));
4783 printf (_(" Machine: %s\n"),
4784 get_machine_name (header
->e_machine
));
4785 printf (_(" Version: 0x%lx\n"),
4788 printf (_(" Entry point address: "));
4789 print_vma (header
->e_entry
, PREFIX_HEX
);
4790 printf (_("\n Start of program headers: "));
4791 print_vma (header
->e_phoff
, DEC
);
4792 printf (_(" (bytes into file)\n Start of section headers: "));
4793 print_vma (header
->e_shoff
, DEC
);
4794 printf (_(" (bytes into file)\n"));
4796 printf (_(" Flags: 0x%lx%s\n"),
4798 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4799 printf (_(" Size of this header: %u (bytes)\n"),
4801 printf (_(" Size of program headers: %u (bytes)\n"),
4802 header
->e_phentsize
);
4803 printf (_(" Number of program headers: %u"),
4805 if (filedata
->section_headers
!= NULL
4806 && header
->e_phnum
== PN_XNUM
4807 && filedata
->section_headers
[0].sh_info
!= 0)
4809 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4810 printf (" (%u)", header
->e_phnum
);
4812 putc ('\n', stdout
);
4813 printf (_(" Size of section headers: %u (bytes)\n"),
4814 header
->e_shentsize
);
4815 printf (_(" Number of section headers: %u"),
4817 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4819 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4820 printf (" (%u)", header
->e_shnum
);
4822 putc ('\n', stdout
);
4823 printf (_(" Section header string table index: %u"),
4824 header
->e_shstrndx
);
4825 if (filedata
->section_headers
!= NULL
4826 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4828 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4829 printf (" (%u)", header
->e_shstrndx
);
4831 if (header
->e_shstrndx
!= SHN_UNDEF
4832 && header
->e_shstrndx
>= header
->e_shnum
)
4834 header
->e_shstrndx
= SHN_UNDEF
;
4835 printf (_(" <corrupt: out of range>"));
4837 putc ('\n', stdout
);
4840 if (filedata
->section_headers
!= NULL
)
4842 if (header
->e_phnum
== PN_XNUM
4843 && filedata
->section_headers
[0].sh_info
!= 0)
4844 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4845 if (header
->e_shnum
== SHN_UNDEF
)
4846 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4847 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4848 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4849 if (header
->e_shstrndx
>= header
->e_shnum
)
4850 header
->e_shstrndx
= SHN_UNDEF
;
4851 free (filedata
->section_headers
);
4852 filedata
->section_headers
= NULL
;
4858 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4859 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4862 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4864 Elf32_External_Phdr
* phdrs
;
4865 Elf32_External_Phdr
* external
;
4866 Elf_Internal_Phdr
* internal
;
4868 unsigned int size
= filedata
->file_header
.e_phentsize
;
4869 unsigned int num
= filedata
->file_header
.e_phnum
;
4871 /* PR binutils/17531: Cope with unexpected section header sizes. */
4872 if (size
== 0 || num
== 0)
4874 if (size
< sizeof * phdrs
)
4876 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4879 if (size
> sizeof * phdrs
)
4880 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4882 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4883 size
, num
, _("program headers"));
4887 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4888 i
< filedata
->file_header
.e_phnum
;
4889 i
++, internal
++, external
++)
4891 internal
->p_type
= BYTE_GET (external
->p_type
);
4892 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4893 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4894 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4895 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4896 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4897 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4898 internal
->p_align
= BYTE_GET (external
->p_align
);
4905 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4906 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4909 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4911 Elf64_External_Phdr
* phdrs
;
4912 Elf64_External_Phdr
* external
;
4913 Elf_Internal_Phdr
* internal
;
4915 unsigned int size
= filedata
->file_header
.e_phentsize
;
4916 unsigned int num
= filedata
->file_header
.e_phnum
;
4918 /* PR binutils/17531: Cope with unexpected section header sizes. */
4919 if (size
== 0 || num
== 0)
4921 if (size
< sizeof * phdrs
)
4923 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4926 if (size
> sizeof * phdrs
)
4927 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4929 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4930 size
, num
, _("program headers"));
4934 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4935 i
< filedata
->file_header
.e_phnum
;
4936 i
++, internal
++, external
++)
4938 internal
->p_type
= BYTE_GET (external
->p_type
);
4939 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4940 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4941 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4942 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4943 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4944 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4945 internal
->p_align
= BYTE_GET (external
->p_align
);
4952 /* Returns TRUE if the program headers were read into `program_headers'. */
4955 get_program_headers (Filedata
* filedata
)
4957 Elf_Internal_Phdr
* phdrs
;
4959 /* Check cache of prior read. */
4960 if (filedata
->program_headers
!= NULL
)
4963 /* Be kind to memory checkers by looking for
4964 e_phnum values which we know must be invalid. */
4965 if (filedata
->file_header
.e_phnum
4966 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4967 >= filedata
->file_size
)
4969 error (_("Too many program headers - %#x - the file is not that big\n"),
4970 filedata
->file_header
.e_phnum
);
4974 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4975 sizeof (Elf_Internal_Phdr
));
4978 error (_("Out of memory reading %u program headers\n"),
4979 filedata
->file_header
.e_phnum
);
4984 ? get_32bit_program_headers (filedata
, phdrs
)
4985 : get_64bit_program_headers (filedata
, phdrs
))
4987 filedata
->program_headers
= phdrs
;
4995 /* Returns TRUE if the program headers were loaded. */
4998 process_program_headers (Filedata
* filedata
)
5000 Elf_Internal_Phdr
* segment
;
5002 Elf_Internal_Phdr
* previous_load
= NULL
;
5004 if (filedata
->file_header
.e_phnum
== 0)
5006 /* PR binutils/12467. */
5007 if (filedata
->file_header
.e_phoff
!= 0)
5009 warn (_("possibly corrupt ELF header - it has a non-zero program"
5010 " header offset, but no program headers\n"));
5013 else if (do_segments
)
5014 printf (_("\nThere are no program headers in this file.\n"));
5018 if (do_segments
&& !do_header
)
5020 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5021 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5022 printf (ngettext ("There is %d program header, starting at offset %s\n",
5023 "There are %d program headers, starting at offset %s\n",
5024 filedata
->file_header
.e_phnum
),
5025 filedata
->file_header
.e_phnum
,
5026 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5029 if (! get_program_headers (filedata
))
5034 if (filedata
->file_header
.e_phnum
> 1)
5035 printf (_("\nProgram Headers:\n"));
5037 printf (_("\nProgram Headers:\n"));
5041 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5044 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5048 (_(" Type Offset VirtAddr PhysAddr\n"));
5050 (_(" FileSiz MemSiz Flags Align\n"));
5057 for (i
= 0, segment
= filedata
->program_headers
;
5058 i
< filedata
->file_header
.e_phnum
;
5063 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5067 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5068 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5069 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5070 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5071 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5073 (segment
->p_flags
& PF_R
? 'R' : ' '),
5074 (segment
->p_flags
& PF_W
? 'W' : ' '),
5075 (segment
->p_flags
& PF_X
? 'E' : ' '));
5076 printf ("%#lx", (unsigned long) segment
->p_align
);
5080 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5081 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5084 print_vma (segment
->p_offset
, FULL_HEX
);
5088 print_vma (segment
->p_vaddr
, FULL_HEX
);
5090 print_vma (segment
->p_paddr
, FULL_HEX
);
5093 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5094 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5097 print_vma (segment
->p_filesz
, FULL_HEX
);
5101 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5102 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5105 print_vma (segment
->p_memsz
, FULL_HEX
);
5109 (segment
->p_flags
& PF_R
? 'R' : ' '),
5110 (segment
->p_flags
& PF_W
? 'W' : ' '),
5111 (segment
->p_flags
& PF_X
? 'E' : ' '));
5113 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5114 printf ("%#lx", (unsigned long) segment
->p_align
);
5117 print_vma (segment
->p_align
, PREFIX_HEX
);
5122 print_vma (segment
->p_offset
, FULL_HEX
);
5124 print_vma (segment
->p_vaddr
, FULL_HEX
);
5126 print_vma (segment
->p_paddr
, FULL_HEX
);
5128 print_vma (segment
->p_filesz
, FULL_HEX
);
5130 print_vma (segment
->p_memsz
, FULL_HEX
);
5132 (segment
->p_flags
& PF_R
? 'R' : ' '),
5133 (segment
->p_flags
& PF_W
? 'W' : ' '),
5134 (segment
->p_flags
& PF_X
? 'E' : ' '));
5135 print_vma (segment
->p_align
, PREFIX_HEX
);
5138 putc ('\n', stdout
);
5141 switch (segment
->p_type
)
5144 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5145 required by the ELF standard, several programs, including the Linux
5146 kernel, make use of non-ordered segments. */
5148 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5149 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5151 if (segment
->p_memsz
< segment
->p_filesz
)
5152 error (_("the segment's file size is larger than its memory size\n"));
5153 previous_load
= segment
;
5157 /* PR 20815 - Verify that the program header is loaded into memory. */
5158 if (i
> 0 && previous_load
!= NULL
)
5159 error (_("the PHDR segment must occur before any LOAD segment\n"));
5160 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5164 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5165 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5166 && (filedata
->program_headers
[j
].p_vaddr
5167 + filedata
->program_headers
[j
].p_memsz
)
5168 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5170 if (j
== filedata
->file_header
.e_phnum
)
5171 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5177 error (_("more than one dynamic segment\n"));
5179 /* By default, assume that the .dynamic section is the first
5180 section in the DYNAMIC segment. */
5181 dynamic_addr
= segment
->p_offset
;
5182 dynamic_size
= segment
->p_filesz
;
5184 /* Try to locate the .dynamic section. If there is
5185 a section header table, we can easily locate it. */
5186 if (filedata
->section_headers
!= NULL
)
5188 Elf_Internal_Shdr
* sec
;
5190 sec
= find_section (filedata
, ".dynamic");
5191 if (sec
== NULL
|| sec
->sh_size
== 0)
5193 /* A corresponding .dynamic section is expected, but on
5194 IA-64/OpenVMS it is OK for it to be missing. */
5195 if (!is_ia64_vms (filedata
))
5196 error (_("no .dynamic section in the dynamic segment\n"));
5200 if (sec
->sh_type
== SHT_NOBITS
)
5206 dynamic_addr
= sec
->sh_offset
;
5207 dynamic_size
= sec
->sh_size
;
5209 if (dynamic_addr
< segment
->p_offset
5210 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5211 warn (_("the .dynamic section is not contained"
5212 " within the dynamic segment\n"));
5213 else if (dynamic_addr
> segment
->p_offset
)
5214 warn (_("the .dynamic section is not the first section"
5215 " in the dynamic segment.\n"));
5218 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5219 segment. Check this after matching against the section headers
5220 so we don't warn on debuginfo file (which have NOBITS .dynamic
5222 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5224 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5225 dynamic_addr
= dynamic_size
= 0;
5230 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5232 error (_("Unable to find program interpreter name\n"));
5236 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5238 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5239 error (_("Internal error: failed to create format string to display program interpreter\n"));
5241 program_interpreter
[0] = 0;
5242 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5243 error (_("Unable to read program interpreter name\n"));
5246 printf (_(" [Requesting program interpreter: %s]\n"),
5247 program_interpreter
);
5254 && filedata
->section_headers
!= NULL
5255 && filedata
->string_table
!= NULL
)
5257 printf (_("\n Section to Segment mapping:\n"));
5258 printf (_(" Segment Sections...\n"));
5260 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5263 Elf_Internal_Shdr
* section
;
5265 segment
= filedata
->program_headers
+ i
;
5266 section
= filedata
->section_headers
+ 1;
5268 printf (" %2.2d ", i
);
5270 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5272 if (!ELF_TBSS_SPECIAL (section
, segment
)
5273 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5274 printf ("%s ", printable_section_name (filedata
, section
));
5285 /* Find the file offset corresponding to VMA by using the program headers. */
5288 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5290 Elf_Internal_Phdr
* seg
;
5292 if (! get_program_headers (filedata
))
5294 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5298 for (seg
= filedata
->program_headers
;
5299 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5302 if (seg
->p_type
!= PT_LOAD
)
5305 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5306 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5307 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5310 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5311 (unsigned long) vma
);
5316 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5317 If PROBE is true, this is just a probe and we do not generate any error
5318 messages if the load fails. */
5321 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5323 Elf32_External_Shdr
* shdrs
;
5324 Elf_Internal_Shdr
* internal
;
5326 unsigned int size
= filedata
->file_header
.e_shentsize
;
5327 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5329 /* PR binutils/17531: Cope with unexpected section header sizes. */
5330 if (size
== 0 || num
== 0)
5332 if (size
< sizeof * shdrs
)
5335 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5338 if (!probe
&& size
> sizeof * shdrs
)
5339 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5341 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5343 probe
? NULL
: _("section headers"));
5347 free (filedata
->section_headers
);
5348 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5349 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5350 if (filedata
->section_headers
== NULL
)
5353 error (_("Out of memory reading %u section headers\n"), num
);
5358 for (i
= 0, internal
= filedata
->section_headers
;
5362 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5363 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5364 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5365 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5366 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5367 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5368 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5369 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5370 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5371 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5372 if (!probe
&& internal
->sh_link
> num
)
5373 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5374 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5375 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5382 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5385 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5387 Elf64_External_Shdr
* shdrs
;
5388 Elf_Internal_Shdr
* internal
;
5390 unsigned int size
= filedata
->file_header
.e_shentsize
;
5391 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5393 /* PR binutils/17531: Cope with unexpected section header sizes. */
5394 if (size
== 0 || num
== 0)
5397 if (size
< sizeof * shdrs
)
5400 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5404 if (! probe
&& size
> sizeof * shdrs
)
5405 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5407 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5408 filedata
->file_header
.e_shoff
,
5410 probe
? NULL
: _("section headers"));
5414 free (filedata
->section_headers
);
5415 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5416 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5417 if (filedata
->section_headers
== NULL
)
5420 error (_("Out of memory reading %u section headers\n"), num
);
5425 for (i
= 0, internal
= filedata
->section_headers
;
5429 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5430 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5431 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5432 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5433 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5434 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5435 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5436 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5437 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5438 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5439 if (!probe
&& internal
->sh_link
> num
)
5440 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5441 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5442 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5449 static Elf_Internal_Sym
*
5450 get_32bit_elf_symbols (Filedata
* filedata
,
5451 Elf_Internal_Shdr
* section
,
5452 unsigned long * num_syms_return
)
5454 unsigned long number
= 0;
5455 Elf32_External_Sym
* esyms
= NULL
;
5456 Elf_External_Sym_Shndx
* shndx
= NULL
;
5457 Elf_Internal_Sym
* isyms
= NULL
;
5458 Elf_Internal_Sym
* psym
;
5460 elf_section_list
* entry
;
5462 if (section
->sh_size
== 0)
5464 if (num_syms_return
!= NULL
)
5465 * num_syms_return
= 0;
5469 /* Run some sanity checks first. */
5470 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5472 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5473 printable_section_name (filedata
, section
),
5474 (unsigned long) section
->sh_entsize
);
5478 if (section
->sh_size
> filedata
->file_size
)
5480 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5481 printable_section_name (filedata
, section
),
5482 (unsigned long) section
->sh_size
);
5486 number
= section
->sh_size
/ section
->sh_entsize
;
5488 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5490 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5491 (unsigned long) section
->sh_size
,
5492 printable_section_name (filedata
, section
),
5493 (unsigned long) section
->sh_entsize
);
5497 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5498 section
->sh_size
, _("symbols"));
5503 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5505 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5510 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5514 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5515 entry
->hdr
->sh_offset
,
5516 1, entry
->hdr
->sh_size
,
5517 _("symbol table section indices"));
5521 /* PR17531: file: heap-buffer-overflow */
5522 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5524 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5525 printable_section_name (filedata
, entry
->hdr
),
5526 (unsigned long) entry
->hdr
->sh_size
,
5527 (unsigned long) section
->sh_size
);
5532 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5536 error (_("Out of memory reading %lu symbols\n"),
5537 (unsigned long) number
);
5541 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5543 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5544 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5545 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5546 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5547 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5549 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5550 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5551 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5552 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5553 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5560 if (num_syms_return
!= NULL
)
5561 * num_syms_return
= isyms
== NULL
? 0 : number
;
5566 static Elf_Internal_Sym
*
5567 get_64bit_elf_symbols (Filedata
* filedata
,
5568 Elf_Internal_Shdr
* section
,
5569 unsigned long * num_syms_return
)
5571 unsigned long number
= 0;
5572 Elf64_External_Sym
* esyms
= NULL
;
5573 Elf_External_Sym_Shndx
* shndx
= NULL
;
5574 Elf_Internal_Sym
* isyms
= NULL
;
5575 Elf_Internal_Sym
* psym
;
5577 elf_section_list
* entry
;
5579 if (section
->sh_size
== 0)
5581 if (num_syms_return
!= NULL
)
5582 * num_syms_return
= 0;
5586 /* Run some sanity checks first. */
5587 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5589 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5590 printable_section_name (filedata
, section
),
5591 (unsigned long) section
->sh_entsize
);
5595 if (section
->sh_size
> filedata
->file_size
)
5597 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5598 printable_section_name (filedata
, section
),
5599 (unsigned long) section
->sh_size
);
5603 number
= section
->sh_size
/ section
->sh_entsize
;
5605 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5607 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5608 (unsigned long) section
->sh_size
,
5609 printable_section_name (filedata
, section
),
5610 (unsigned long) section
->sh_entsize
);
5614 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5615 section
->sh_size
, _("symbols"));
5620 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5622 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5627 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5631 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5632 entry
->hdr
->sh_offset
,
5633 1, entry
->hdr
->sh_size
,
5634 _("symbol table section indices"));
5638 /* PR17531: file: heap-buffer-overflow */
5639 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5641 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5642 printable_section_name (filedata
, entry
->hdr
),
5643 (unsigned long) entry
->hdr
->sh_size
,
5644 (unsigned long) section
->sh_size
);
5649 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5653 error (_("Out of memory reading %lu symbols\n"),
5654 (unsigned long) number
);
5658 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5660 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5661 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5662 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5663 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5665 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5667 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5668 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5669 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5671 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5672 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5679 if (num_syms_return
!= NULL
)
5680 * num_syms_return
= isyms
== NULL
? 0 : number
;
5686 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5688 static char buff
[1024];
5690 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5692 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5693 bfd_vma os_flags
= 0;
5694 bfd_vma proc_flags
= 0;
5695 bfd_vma unknown_flags
= 0;
5703 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5704 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5705 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5706 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5707 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5708 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5709 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5710 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5711 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5712 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5713 /* IA-64 specific. */
5714 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5715 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5716 /* IA-64 OpenVMS specific. */
5717 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5718 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5719 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5720 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5721 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5722 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5724 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5725 /* SPARC specific. */
5726 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5727 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5729 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5730 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5731 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5733 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5735 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5738 if (do_section_details
)
5740 sprintf (buff
, "[%*.*lx]: ",
5741 field_size
, field_size
, (unsigned long) sh_flags
);
5742 p
+= field_size
+ 4;
5749 flag
= sh_flags
& - sh_flags
;
5752 if (do_section_details
)
5756 case SHF_WRITE
: sindex
= 0; break;
5757 case SHF_ALLOC
: sindex
= 1; break;
5758 case SHF_EXECINSTR
: sindex
= 2; break;
5759 case SHF_MERGE
: sindex
= 3; break;
5760 case SHF_STRINGS
: sindex
= 4; break;
5761 case SHF_INFO_LINK
: sindex
= 5; break;
5762 case SHF_LINK_ORDER
: sindex
= 6; break;
5763 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5764 case SHF_GROUP
: sindex
= 8; break;
5765 case SHF_TLS
: sindex
= 9; break;
5766 case SHF_EXCLUDE
: sindex
= 18; break;
5767 case SHF_COMPRESSED
: sindex
= 20; break;
5768 case SHF_GNU_MBIND
: sindex
= 24; break;
5772 switch (filedata
->file_header
.e_machine
)
5775 if (flag
== SHF_IA_64_SHORT
)
5777 else if (flag
== SHF_IA_64_NORECOV
)
5780 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5783 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5784 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5785 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5786 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5787 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5788 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5799 case EM_OLD_SPARCV9
:
5800 case EM_SPARC32PLUS
:
5803 if (flag
== SHF_ORDERED
)
5810 case SHF_ENTRYSECT
: sindex
= 21; break;
5811 case SHF_ARM_PURECODE
: sindex
= 22; break;
5812 case SHF_COMDEF
: sindex
= 23; break;
5817 if (flag
== SHF_PPC_VLE
)
5828 if (p
!= buff
+ field_size
+ 4)
5830 if (size
< (10 + 2))
5832 warn (_("Internal error: not enough buffer room for section flag info"));
5833 return _("<unknown>");
5840 size
-= flags
[sindex
].len
;
5841 p
= stpcpy (p
, flags
[sindex
].str
);
5843 else if (flag
& SHF_MASKOS
)
5845 else if (flag
& SHF_MASKPROC
)
5848 unknown_flags
|= flag
;
5854 case SHF_WRITE
: *p
= 'W'; break;
5855 case SHF_ALLOC
: *p
= 'A'; break;
5856 case SHF_EXECINSTR
: *p
= 'X'; break;
5857 case SHF_MERGE
: *p
= 'M'; break;
5858 case SHF_STRINGS
: *p
= 'S'; break;
5859 case SHF_INFO_LINK
: *p
= 'I'; break;
5860 case SHF_LINK_ORDER
: *p
= 'L'; break;
5861 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5862 case SHF_GROUP
: *p
= 'G'; break;
5863 case SHF_TLS
: *p
= 'T'; break;
5864 case SHF_EXCLUDE
: *p
= 'E'; break;
5865 case SHF_COMPRESSED
: *p
= 'C'; break;
5866 case SHF_GNU_MBIND
: *p
= 'D'; break;
5869 if ((filedata
->file_header
.e_machine
== EM_X86_64
5870 || filedata
->file_header
.e_machine
== EM_L1OM
5871 || filedata
->file_header
.e_machine
== EM_K1OM
)
5872 && flag
== SHF_X86_64_LARGE
)
5874 else if (filedata
->file_header
.e_machine
== EM_ARM
5875 && flag
== SHF_ARM_PURECODE
)
5877 else if (filedata
->file_header
.e_machine
== EM_PPC
5878 && flag
== SHF_PPC_VLE
)
5880 else if (flag
& SHF_MASKOS
)
5883 sh_flags
&= ~ SHF_MASKOS
;
5885 else if (flag
& SHF_MASKPROC
)
5888 sh_flags
&= ~ SHF_MASKPROC
;
5898 if (do_section_details
)
5902 size
-= 5 + field_size
;
5903 if (p
!= buff
+ field_size
+ 4)
5907 warn (_("Internal error: not enough buffer room for section flag info"));
5908 return _("<unknown>");
5914 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5915 (unsigned long) os_flags
);
5916 p
+= 5 + field_size
;
5920 size
-= 7 + field_size
;
5921 if (p
!= buff
+ field_size
+ 4)
5925 warn (_("Internal error: not enough buffer room for section flag info"));
5926 return _("<unknown>");
5932 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5933 (unsigned long) proc_flags
);
5934 p
+= 7 + field_size
;
5938 size
-= 10 + field_size
;
5939 if (p
!= buff
+ field_size
+ 4)
5943 warn (_("Internal error: not enough buffer room for section flag info"));
5944 return _("<unknown>");
5950 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5951 (unsigned long) unknown_flags
);
5952 p
+= 10 + field_size
;
5961 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5965 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5967 if (size
< sizeof (* echdr
))
5969 error (_("Compressed section is too small even for a compression header\n"));
5973 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5974 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5975 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5976 return sizeof (*echdr
);
5980 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5982 if (size
< sizeof (* echdr
))
5984 error (_("Compressed section is too small even for a compression header\n"));
5988 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5989 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5990 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5991 return sizeof (*echdr
);
5996 process_section_headers (Filedata
* filedata
)
5998 Elf_Internal_Shdr
* section
;
6001 filedata
->section_headers
= NULL
;
6003 if (filedata
->file_header
.e_shnum
== 0)
6005 /* PR binutils/12467. */
6006 if (filedata
->file_header
.e_shoff
!= 0)
6008 warn (_("possibly corrupt ELF file header - it has a non-zero"
6009 " section header offset, but no section headers\n"));
6012 else if (do_sections
)
6013 printf (_("\nThere are no sections in this file.\n"));
6018 if (do_sections
&& !do_header
)
6019 printf (ngettext ("There is %d section header, "
6020 "starting at offset 0x%lx:\n",
6021 "There are %d section headers, "
6022 "starting at offset 0x%lx:\n",
6023 filedata
->file_header
.e_shnum
),
6024 filedata
->file_header
.e_shnum
,
6025 (unsigned long) filedata
->file_header
.e_shoff
);
6029 if (! get_32bit_section_headers (filedata
, FALSE
))
6034 if (! get_64bit_section_headers (filedata
, FALSE
))
6038 /* Read in the string table, so that we have names to display. */
6039 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6040 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6042 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6044 if (section
->sh_size
!= 0)
6046 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6047 1, section
->sh_size
,
6050 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6054 /* Scan the sections for the dynamic symbol table
6055 and dynamic string table and debug sections. */
6056 dynamic_symbols
= NULL
;
6057 dynamic_strings
= NULL
;
6058 dynamic_syminfo
= NULL
;
6059 symtab_shndx_list
= NULL
;
6061 eh_addr_size
= is_32bit_elf
? 4 : 8;
6062 switch (filedata
->file_header
.e_machine
)
6065 case EM_MIPS_RS3_LE
:
6066 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6067 FDE addresses. However, the ABI also has a semi-official ILP32
6068 variant for which the normal FDE address size rules apply.
6070 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6071 section, where XX is the size of longs in bits. Unfortunately,
6072 earlier compilers provided no way of distinguishing ILP32 objects
6073 from LP64 objects, so if there's any doubt, we should assume that
6074 the official LP64 form is being used. */
6075 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6076 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6082 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6084 case E_H8_MACH_H8300
:
6085 case E_H8_MACH_H8300HN
:
6086 case E_H8_MACH_H8300SN
:
6087 case E_H8_MACH_H8300SXN
:
6090 case E_H8_MACH_H8300H
:
6091 case E_H8_MACH_H8300S
:
6092 case E_H8_MACH_H8300SX
:
6100 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6102 case EF_M32C_CPU_M16C
:
6109 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6112 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6113 if (section->sh_entsize != expected_entsize) \
6116 sprintf_vma (buf, section->sh_entsize); \
6117 /* Note: coded this way so that there is a single string for \
6119 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6120 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6121 (unsigned) expected_entsize); \
6122 section->sh_entsize = expected_entsize; \
6127 #define CHECK_ENTSIZE(section, i, type) \
6128 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6129 sizeof (Elf64_External_##type))
6131 for (i
= 0, section
= filedata
->section_headers
;
6132 i
< filedata
->file_header
.e_shnum
;
6135 char * name
= SECTION_NAME (section
);
6137 if (section
->sh_type
== SHT_DYNSYM
)
6139 if (dynamic_symbols
!= NULL
)
6141 error (_("File contains multiple dynamic symbol tables\n"));
6145 CHECK_ENTSIZE (section
, i
, Sym
);
6146 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6148 else if (section
->sh_type
== SHT_STRTAB
6149 && streq (name
, ".dynstr"))
6151 if (dynamic_strings
!= NULL
)
6153 error (_("File contains multiple dynamic string tables\n"));
6157 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6158 1, section
->sh_size
,
6159 _("dynamic strings"));
6160 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6162 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6164 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6166 entry
->hdr
= section
;
6167 entry
->next
= symtab_shndx_list
;
6168 symtab_shndx_list
= entry
;
6170 else if (section
->sh_type
== SHT_SYMTAB
)
6171 CHECK_ENTSIZE (section
, i
, Sym
);
6172 else if (section
->sh_type
== SHT_GROUP
)
6173 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6174 else if (section
->sh_type
== SHT_REL
)
6175 CHECK_ENTSIZE (section
, i
, Rel
);
6176 else if (section
->sh_type
== SHT_RELA
)
6177 CHECK_ENTSIZE (section
, i
, Rela
);
6178 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6179 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6180 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6181 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6182 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6183 && (const_strneq (name
, ".debug_")
6184 || const_strneq (name
, ".zdebug_")))
6187 name
+= sizeof (".zdebug_") - 1;
6189 name
+= sizeof (".debug_") - 1;
6192 || (do_debug_info
&& const_strneq (name
, "info"))
6193 || (do_debug_info
&& const_strneq (name
, "types"))
6194 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6195 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6196 || (do_debug_lines
&& const_strneq (name
, "line."))
6197 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6198 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6199 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6200 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6201 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6202 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6203 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6204 || (do_debug_frames
&& const_strneq (name
, "frame"))
6205 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6206 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6207 || (do_debug_str
&& const_strneq (name
, "str"))
6208 || (do_debug_loc
&& const_strneq (name
, "loc"))
6209 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6210 || (do_debug_addr
&& const_strneq (name
, "addr"))
6211 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6212 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6214 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6216 /* Linkonce section to be combined with .debug_info at link time. */
6217 else if ((do_debugging
|| do_debug_info
)
6218 && const_strneq (name
, ".gnu.linkonce.wi."))
6219 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6220 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6221 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6222 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6223 || streq (name
, ".debug_names")))
6224 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6225 /* Trace sections for Itanium VMS. */
6226 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6227 || do_trace_aranges
)
6228 && const_strneq (name
, ".trace_"))
6230 name
+= sizeof (".trace_") - 1;
6233 || (do_trace_info
&& streq (name
, "info"))
6234 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6235 || (do_trace_aranges
&& streq (name
, "aranges"))
6237 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6239 else if ((do_debugging
|| do_debug_links
)
6240 && (const_strneq (name
, ".gnu_debuglink")
6241 || const_strneq (name
, ".gnu_debugaltlink")))
6242 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6248 if (filedata
->file_header
.e_shnum
> 1)
6249 printf (_("\nSection Headers:\n"));
6251 printf (_("\nSection Header:\n"));
6255 if (do_section_details
)
6257 printf (_(" [Nr] Name\n"));
6258 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6262 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6266 if (do_section_details
)
6268 printf (_(" [Nr] Name\n"));
6269 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6273 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6277 if (do_section_details
)
6279 printf (_(" [Nr] Name\n"));
6280 printf (_(" Type Address Offset Link\n"));
6281 printf (_(" Size EntSize Info Align\n"));
6285 printf (_(" [Nr] Name Type Address Offset\n"));
6286 printf (_(" Size EntSize Flags Link Info Align\n"));
6290 if (do_section_details
)
6291 printf (_(" Flags\n"));
6293 for (i
= 0, section
= filedata
->section_headers
;
6294 i
< filedata
->file_header
.e_shnum
;
6297 /* Run some sanity checks on the section header. */
6299 /* Check the sh_link field. */
6300 switch (section
->sh_type
)
6304 if (section
->sh_link
== 0
6305 && (filedata
->file_header
.e_type
== ET_EXEC
6306 || filedata
->file_header
.e_type
== ET_DYN
))
6307 /* A dynamic relocation section where all entries use a
6308 zero symbol index need not specify a symtab section. */
6311 case SHT_SYMTAB_SHNDX
:
6315 case SHT_GNU_versym
:
6316 if (section
->sh_link
== 0
6317 || section
->sh_link
>= filedata
->file_header
.e_shnum
6318 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6319 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6320 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6321 i
, section
->sh_link
);
6327 case SHT_GNU_verneed
:
6328 case SHT_GNU_verdef
:
6329 case SHT_GNU_LIBLIST
:
6330 if (section
->sh_link
== 0
6331 || section
->sh_link
>= filedata
->file_header
.e_shnum
6332 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6333 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6334 i
, section
->sh_link
);
6337 case SHT_INIT_ARRAY
:
6338 case SHT_FINI_ARRAY
:
6339 case SHT_PREINIT_ARRAY
:
6340 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6341 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6342 i
, section
->sh_link
);
6346 /* FIXME: Add support for target specific section types. */
6347 #if 0 /* Currently we do not check other section types as there are too
6348 many special cases. Stab sections for example have a type
6349 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6351 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6352 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6353 i
, section
->sh_link
);
6358 /* Check the sh_info field. */
6359 switch (section
->sh_type
)
6363 if (section
->sh_info
== 0
6364 && (filedata
->file_header
.e_type
== ET_EXEC
6365 || filedata
->file_header
.e_type
== ET_DYN
))
6366 /* Dynamic relocations apply to segments, so they do not
6367 need to specify the section they relocate. */
6369 if (section
->sh_info
== 0
6370 || section
->sh_info
>= filedata
->file_header
.e_shnum
6371 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6372 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6373 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6374 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6375 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6376 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6377 /* FIXME: Are other section types valid ? */
6378 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6379 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6380 i
, section
->sh_info
);
6385 case SHT_SYMTAB_SHNDX
:
6386 case SHT_INIT_ARRAY
:
6387 case SHT_FINI_ARRAY
:
6388 case SHT_PREINIT_ARRAY
:
6389 if (section
->sh_info
!= 0)
6390 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6391 i
, section
->sh_info
);
6397 /* A symbol index - we assume that it is valid. */
6401 /* FIXME: Add support for target specific section types. */
6402 if (section
->sh_type
== SHT_NOBITS
)
6403 /* NOBITS section headers with non-zero sh_info fields can be
6404 created when a binary is stripped of everything but its debug
6405 information. The stripped sections have their headers
6406 preserved but their types set to SHT_NOBITS. So do not check
6407 this type of section. */
6409 else if (section
->sh_flags
& SHF_INFO_LINK
)
6411 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6412 warn (_("[%2u]: Expected link to another section in info field"), i
);
6414 else if (section
->sh_type
< SHT_LOOS
6415 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6416 && section
->sh_info
!= 0)
6417 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6418 i
, section
->sh_info
);
6422 /* Check the sh_size field. */
6423 if (section
->sh_size
> filedata
->file_size
6424 && section
->sh_type
!= SHT_NOBITS
6425 && section
->sh_type
!= SHT_NULL
6426 && section
->sh_type
< SHT_LOOS
)
6427 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6429 printf (" [%2u] ", i
);
6430 if (do_section_details
)
6431 printf ("%s\n ", printable_section_name (filedata
, section
));
6433 print_symbol (-17, SECTION_NAME (section
));
6435 printf (do_wide
? " %-15s " : " %-15.15s ",
6436 get_section_type_name (filedata
, section
->sh_type
));
6440 const char * link_too_big
= NULL
;
6442 print_vma (section
->sh_addr
, LONG_HEX
);
6444 printf ( " %6.6lx %6.6lx %2.2lx",
6445 (unsigned long) section
->sh_offset
,
6446 (unsigned long) section
->sh_size
,
6447 (unsigned long) section
->sh_entsize
);
6449 if (do_section_details
)
6450 fputs (" ", stdout
);
6452 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6454 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6457 /* The sh_link value is out of range. Normally this indicates
6458 an error but it can have special values in Solaris binaries. */
6459 switch (filedata
->file_header
.e_machine
)
6466 case EM_OLD_SPARCV9
:
6467 case EM_SPARC32PLUS
:
6470 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6471 link_too_big
= "BEFORE";
6472 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6473 link_too_big
= "AFTER";
6480 if (do_section_details
)
6482 if (link_too_big
!= NULL
&& * link_too_big
)
6483 printf ("<%s> ", link_too_big
);
6485 printf ("%2u ", section
->sh_link
);
6486 printf ("%3u %2lu\n", section
->sh_info
,
6487 (unsigned long) section
->sh_addralign
);
6490 printf ("%2u %3u %2lu\n",
6493 (unsigned long) section
->sh_addralign
);
6495 if (link_too_big
&& ! * link_too_big
)
6496 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6497 i
, section
->sh_link
);
6501 print_vma (section
->sh_addr
, LONG_HEX
);
6503 if ((long) section
->sh_offset
== section
->sh_offset
)
6504 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6508 print_vma (section
->sh_offset
, LONG_HEX
);
6511 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6512 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6516 print_vma (section
->sh_size
, LONG_HEX
);
6519 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6520 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6524 print_vma (section
->sh_entsize
, LONG_HEX
);
6527 if (do_section_details
)
6528 fputs (" ", stdout
);
6530 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6532 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6534 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6535 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6538 print_vma (section
->sh_addralign
, DEC
);
6542 else if (do_section_details
)
6545 print_vma (section
->sh_addr
, LONG_HEX
);
6546 if ((long) section
->sh_offset
== section
->sh_offset
)
6547 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6551 print_vma (section
->sh_offset
, LONG_HEX
);
6553 printf (" %u\n ", section
->sh_link
);
6554 print_vma (section
->sh_size
, LONG_HEX
);
6556 print_vma (section
->sh_entsize
, LONG_HEX
);
6558 printf (" %-16u %lu\n",
6560 (unsigned long) section
->sh_addralign
);
6565 print_vma (section
->sh_addr
, LONG_HEX
);
6566 if ((long) section
->sh_offset
== section
->sh_offset
)
6567 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6571 print_vma (section
->sh_offset
, LONG_HEX
);
6574 print_vma (section
->sh_size
, LONG_HEX
);
6576 print_vma (section
->sh_entsize
, LONG_HEX
);
6578 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6580 printf (" %2u %3u %lu\n",
6583 (unsigned long) section
->sh_addralign
);
6586 if (do_section_details
)
6588 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6589 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6591 /* Minimum section size is 12 bytes for 32-bit compression
6592 header + 12 bytes for compressed data header. */
6593 unsigned char buf
[24];
6595 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6596 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6597 sizeof (buf
), _("compression header")))
6599 Elf_Internal_Chdr chdr
;
6601 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6603 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6606 printf (_(" [<unknown>: 0x%x], "),
6608 print_vma (chdr
.ch_size
, LONG_HEX
);
6609 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6615 if (!do_section_details
)
6617 /* The ordering of the letters shown here matches the ordering of the
6618 corresponding SHF_xxx values, and hence the order in which these
6619 letters will be displayed to the user. */
6620 printf (_("Key to Flags:\n\
6621 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6622 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6623 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6624 if (filedata
->file_header
.e_machine
== EM_X86_64
6625 || filedata
->file_header
.e_machine
== EM_L1OM
6626 || filedata
->file_header
.e_machine
== EM_K1OM
)
6627 printf (_("l (large), "));
6628 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6629 printf (_("y (purecode), "));
6630 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6631 printf (_("v (VLE), "));
6632 printf ("p (processor specific)\n");
6639 get_group_flags (unsigned int flags
)
6641 static char buff
[128];
6645 else if (flags
== GRP_COMDAT
)
6648 snprintf (buff
, 14, _("[0x%x: "), flags
);
6650 flags
&= ~ GRP_COMDAT
;
6651 if (flags
& GRP_MASKOS
)
6653 strcat (buff
, "<OS specific>");
6654 flags
&= ~ GRP_MASKOS
;
6657 if (flags
& GRP_MASKPROC
)
6659 strcat (buff
, "<PROC specific>");
6660 flags
&= ~ GRP_MASKPROC
;
6664 strcat (buff
, "<unknown>");
6671 process_section_groups (Filedata
* filedata
)
6673 Elf_Internal_Shdr
* section
;
6675 struct group
* group
;
6676 Elf_Internal_Shdr
* symtab_sec
;
6677 Elf_Internal_Shdr
* strtab_sec
;
6678 Elf_Internal_Sym
* symtab
;
6679 unsigned long num_syms
;
6683 /* Don't process section groups unless needed. */
6684 if (!do_unwind
&& !do_section_groups
)
6687 if (filedata
->file_header
.e_shnum
== 0)
6689 if (do_section_groups
)
6690 printf (_("\nThere are no sections to group in this file.\n"));
6695 if (filedata
->section_headers
== NULL
)
6697 error (_("Section headers are not available!\n"));
6698 /* PR 13622: This can happen with a corrupt ELF header. */
6702 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6703 sizeof (struct group
*));
6705 if (section_headers_groups
== NULL
)
6707 error (_("Out of memory reading %u section group headers\n"),
6708 filedata
->file_header
.e_shnum
);
6712 /* Scan the sections for the group section. */
6714 for (i
= 0, section
= filedata
->section_headers
;
6715 i
< filedata
->file_header
.e_shnum
;
6717 if (section
->sh_type
== SHT_GROUP
)
6720 if (group_count
== 0)
6722 if (do_section_groups
)
6723 printf (_("\nThere are no section groups in this file.\n"));
6728 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6730 if (section_groups
== NULL
)
6732 error (_("Out of memory reading %lu groups\n"),
6733 (unsigned long) group_count
);
6743 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6744 i
< filedata
->file_header
.e_shnum
;
6747 if (section
->sh_type
== SHT_GROUP
)
6749 const char * name
= printable_section_name (filedata
, section
);
6750 const char * group_name
;
6751 unsigned char * start
;
6752 unsigned char * indices
;
6753 unsigned int entry
, j
, size
;
6754 Elf_Internal_Shdr
* sec
;
6755 Elf_Internal_Sym
* sym
;
6757 /* Get the symbol table. */
6758 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6759 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6762 error (_("Bad sh_link in group section `%s'\n"), name
);
6766 if (symtab_sec
!= sec
)
6771 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6776 error (_("Corrupt header in group section `%s'\n"), name
);
6780 if (section
->sh_info
>= num_syms
)
6782 error (_("Bad sh_info in group section `%s'\n"), name
);
6786 sym
= symtab
+ section
->sh_info
;
6788 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6790 if (sym
->st_shndx
== 0
6791 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6793 error (_("Bad sh_info in group section `%s'\n"), name
);
6797 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6806 /* Get the string table. */
6807 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6816 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6822 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6823 1, strtab_sec
->sh_size
,
6825 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6827 group_name
= sym
->st_name
< strtab_size
6828 ? strtab
+ sym
->st_name
: _("<corrupt>");
6831 /* PR 17531: file: loop. */
6832 if (section
->sh_entsize
> section
->sh_size
)
6834 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6835 printable_section_name (filedata
, section
),
6836 (unsigned long) section
->sh_entsize
,
6837 (unsigned long) section
->sh_size
);
6841 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6842 1, section
->sh_size
,
6848 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6849 entry
= byte_get (indices
, 4);
6852 if (do_section_groups
)
6854 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6855 get_group_flags (entry
), i
, name
, group_name
, size
);
6857 printf (_(" [Index] Name\n"));
6860 group
->group_index
= i
;
6862 for (j
= 0; j
< size
; j
++)
6864 struct group_list
* g
;
6866 entry
= byte_get (indices
, 4);
6869 if (entry
>= filedata
->file_header
.e_shnum
)
6871 static unsigned num_group_errors
= 0;
6873 if (num_group_errors
++ < 10)
6875 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6876 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6877 if (num_group_errors
== 10)
6878 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6883 if (section_headers_groups
[entry
] != NULL
)
6887 static unsigned num_errs
= 0;
6889 if (num_errs
++ < 10)
6891 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6893 section_headers_groups
[entry
]->group_index
);
6895 warn (_("Further error messages about already contained group sections suppressed\n"));
6901 /* Intel C/C++ compiler may put section 0 in a
6902 section group. We just warn it the first time
6903 and ignore it afterwards. */
6904 static bfd_boolean warned
= FALSE
;
6907 error (_("section 0 in group section [%5u]\n"),
6908 section_headers_groups
[entry
]->group_index
);
6914 section_headers_groups
[entry
] = group
;
6916 if (do_section_groups
)
6918 sec
= filedata
->section_headers
+ entry
;
6919 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6922 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6923 g
->section_index
= entry
;
6924 g
->next
= group
->root
;
6942 /* Data used to display dynamic fixups. */
6944 struct ia64_vms_dynfixup
6946 bfd_vma needed_ident
; /* Library ident number. */
6947 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6948 bfd_vma fixup_needed
; /* Index of the library. */
6949 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6950 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6953 /* Data used to display dynamic relocations. */
6955 struct ia64_vms_dynimgrela
6957 bfd_vma img_rela_cnt
; /* Number of relocations. */
6958 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6961 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6965 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6966 struct ia64_vms_dynfixup
* fixup
,
6967 const char * strtab
,
6968 unsigned int strtab_sz
)
6970 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6972 const char * lib_name
;
6974 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6975 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6976 _("dynamic section image fixups"));
6980 if (fixup
->needed
< strtab_sz
)
6981 lib_name
= strtab
+ fixup
->needed
;
6984 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6985 (unsigned long) fixup
->needed
);
6988 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6989 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6991 (_("Seg Offset Type SymVec DataType\n"));
6993 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6998 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6999 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7000 type
= BYTE_GET (imfs
[i
].type
);
7001 rtype
= elf_ia64_reloc_type (type
);
7003 printf (" 0x%08x ", type
);
7005 printf (" %-32s ", rtype
);
7006 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7007 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7014 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7017 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7019 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7022 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7023 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7024 _("dynamic section image relocations"));
7028 printf (_("\nImage relocs\n"));
7030 (_("Seg Offset Type Addend Seg Sym Off\n"));
7032 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7037 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7038 printf ("%08" BFD_VMA_FMT
"x ",
7039 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7040 type
= BYTE_GET (imrs
[i
].type
);
7041 rtype
= elf_ia64_reloc_type (type
);
7043 printf ("0x%08x ", type
);
7045 printf ("%-31s ", rtype
);
7046 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7047 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7048 printf ("%08" BFD_VMA_FMT
"x\n",
7049 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7056 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7059 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7061 struct ia64_vms_dynfixup fixup
;
7062 struct ia64_vms_dynimgrela imgrela
;
7063 Elf_Internal_Dyn
*entry
;
7064 bfd_vma strtab_off
= 0;
7065 bfd_vma strtab_sz
= 0;
7066 char *strtab
= NULL
;
7067 bfd_boolean res
= TRUE
;
7069 memset (&fixup
, 0, sizeof (fixup
));
7070 memset (&imgrela
, 0, sizeof (imgrela
));
7072 /* Note: the order of the entries is specified by the OpenVMS specs. */
7073 for (entry
= dynamic_section
;
7074 entry
< dynamic_section
+ dynamic_nent
;
7077 switch (entry
->d_tag
)
7079 case DT_IA_64_VMS_STRTAB_OFFSET
:
7080 strtab_off
= entry
->d_un
.d_val
;
7083 strtab_sz
= entry
->d_un
.d_val
;
7085 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7086 1, strtab_sz
, _("dynamic string section"));
7089 case DT_IA_64_VMS_NEEDED_IDENT
:
7090 fixup
.needed_ident
= entry
->d_un
.d_val
;
7093 fixup
.needed
= entry
->d_un
.d_val
;
7095 case DT_IA_64_VMS_FIXUP_NEEDED
:
7096 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7098 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7099 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7101 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7102 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7103 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7106 case DT_IA_64_VMS_IMG_RELA_CNT
:
7107 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7109 case DT_IA_64_VMS_IMG_RELA_OFF
:
7110 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7111 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7133 dynamic_relocations
[] =
7135 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7136 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7137 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7140 /* Process the reloc section. */
7143 process_relocs (Filedata
* filedata
)
7145 unsigned long rel_size
;
7146 unsigned long rel_offset
;
7151 if (do_using_dynamic
)
7155 bfd_boolean has_dynamic_reloc
;
7158 has_dynamic_reloc
= FALSE
;
7160 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7162 is_rela
= dynamic_relocations
[i
].rela
;
7163 name
= dynamic_relocations
[i
].name
;
7164 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7165 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7168 has_dynamic_reloc
= TRUE
;
7170 if (is_rela
== UNKNOWN
)
7172 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7173 switch (dynamic_info
[DT_PLTREL
])
7187 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7188 name
, rel_offset
, rel_size
);
7190 dump_relocations (filedata
,
7191 offset_from_vma (filedata
, rel_offset
, rel_size
),
7193 dynamic_symbols
, num_dynamic_syms
,
7194 dynamic_strings
, dynamic_strings_length
,
7195 is_rela
, TRUE
/* is_dynamic */);
7199 if (is_ia64_vms (filedata
))
7200 if (process_ia64_vms_dynamic_relocs (filedata
))
7201 has_dynamic_reloc
= TRUE
;
7203 if (! has_dynamic_reloc
)
7204 printf (_("\nThere are no dynamic relocations in this file.\n"));
7208 Elf_Internal_Shdr
* section
;
7210 bfd_boolean found
= FALSE
;
7212 for (i
= 0, section
= filedata
->section_headers
;
7213 i
< filedata
->file_header
.e_shnum
;
7216 if ( section
->sh_type
!= SHT_RELA
7217 && section
->sh_type
!= SHT_REL
)
7220 rel_offset
= section
->sh_offset
;
7221 rel_size
= section
->sh_size
;
7225 Elf_Internal_Shdr
* strsec
;
7227 unsigned long num_rela
;
7229 printf (_("\nRelocation section "));
7231 if (filedata
->string_table
== NULL
)
7232 printf ("%d", section
->sh_name
);
7234 printf ("'%s'", printable_section_name (filedata
, section
));
7236 num_rela
= rel_size
/ section
->sh_entsize
;
7237 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7238 " at offset 0x%lx contains %lu entries:\n",
7240 rel_offset
, num_rela
);
7242 is_rela
= section
->sh_type
== SHT_RELA
;
7244 if (section
->sh_link
!= 0
7245 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7247 Elf_Internal_Shdr
* symsec
;
7248 Elf_Internal_Sym
* symtab
;
7249 unsigned long nsyms
;
7250 unsigned long strtablen
= 0;
7251 char * strtab
= NULL
;
7253 symsec
= filedata
->section_headers
+ section
->sh_link
;
7254 if (symsec
->sh_type
!= SHT_SYMTAB
7255 && symsec
->sh_type
!= SHT_DYNSYM
)
7258 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7263 if (symsec
->sh_link
!= 0
7264 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7266 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7268 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7271 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7274 dump_relocations (filedata
, rel_offset
, rel_size
,
7275 symtab
, nsyms
, strtab
, strtablen
,
7277 symsec
->sh_type
== SHT_DYNSYM
);
7283 dump_relocations (filedata
, rel_offset
, rel_size
,
7284 NULL
, 0, NULL
, 0, is_rela
,
7285 FALSE
/* is_dynamic */);
7293 /* Users sometimes forget the -D option, so try to be helpful. */
7294 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7296 if (dynamic_info
[dynamic_relocations
[i
].size
])
7298 printf (_("\nThere are no static relocations in this file."));
7299 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7304 if (i
== ARRAY_SIZE (dynamic_relocations
))
7305 printf (_("\nThere are no relocations in this file.\n"));
7312 /* An absolute address consists of a section and an offset. If the
7313 section is NULL, the offset itself is the address, otherwise, the
7314 address equals to LOAD_ADDRESS(section) + offset. */
7318 unsigned short section
;
7322 #define ABSADDR(a) \
7324 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7327 /* Find the nearest symbol at or below ADDR. Returns the symbol
7328 name, if found, and the offset from the symbol to ADDR. */
7331 find_symbol_for_address (Filedata
* filedata
,
7332 Elf_Internal_Sym
* symtab
,
7333 unsigned long nsyms
,
7334 const char * strtab
,
7335 unsigned long strtab_size
,
7336 struct absaddr addr
,
7337 const char ** symname
,
7340 bfd_vma dist
= 0x100000;
7341 Elf_Internal_Sym
* sym
;
7342 Elf_Internal_Sym
* beg
;
7343 Elf_Internal_Sym
* end
;
7344 Elf_Internal_Sym
* best
= NULL
;
7346 REMOVE_ARCH_BITS (addr
.offset
);
7348 end
= symtab
+ nsyms
;
7354 sym
= beg
+ (end
- beg
) / 2;
7356 value
= sym
->st_value
;
7357 REMOVE_ARCH_BITS (value
);
7359 if (sym
->st_name
!= 0
7360 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7361 && addr
.offset
>= value
7362 && addr
.offset
- value
< dist
)
7365 dist
= addr
.offset
- value
;
7370 if (addr
.offset
< value
)
7378 *symname
= (best
->st_name
>= strtab_size
7379 ? _("<corrupt>") : strtab
+ best
->st_name
);
7385 *offset
= addr
.offset
;
7388 static /* signed */ int
7389 symcmp (const void *p
, const void *q
)
7391 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7392 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7394 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7397 /* Process the unwind section. */
7399 #include "unwind-ia64.h"
7401 struct ia64_unw_table_entry
7403 struct absaddr start
;
7405 struct absaddr info
;
7408 struct ia64_unw_aux_info
7410 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7411 unsigned long table_len
; /* Length of unwind table. */
7412 unsigned char * info
; /* Unwind info. */
7413 unsigned long info_size
; /* Size of unwind info. */
7414 bfd_vma info_addr
; /* Starting address of unwind info. */
7415 bfd_vma seg_base
; /* Starting address of segment. */
7416 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7417 unsigned long nsyms
; /* Number of symbols. */
7418 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7419 unsigned long nfuns
; /* Number of entries in funtab. */
7420 char * strtab
; /* The string table. */
7421 unsigned long strtab_size
; /* Size of string table. */
7425 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7427 struct ia64_unw_table_entry
* tp
;
7428 unsigned long j
, nfuns
;
7430 bfd_boolean res
= TRUE
;
7432 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7433 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7434 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7435 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7437 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7439 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7443 const unsigned char * dp
;
7444 const unsigned char * head
;
7445 const unsigned char * end
;
7446 const char * procname
;
7448 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7449 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7451 fputs ("\n<", stdout
);
7455 fputs (procname
, stdout
);
7458 printf ("+%lx", (unsigned long) offset
);
7461 fputs (">: [", stdout
);
7462 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7463 fputc ('-', stdout
);
7464 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7465 printf ("], info at +0x%lx\n",
7466 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7468 /* PR 17531: file: 86232b32. */
7469 if (aux
->info
== NULL
)
7472 /* PR 17531: file: 0997b4d1. */
7473 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7475 warn (_("Invalid offset %lx in table entry %ld\n"),
7476 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7481 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7482 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7484 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7485 (unsigned) UNW_VER (stamp
),
7486 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7487 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7488 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7489 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7491 if (UNW_VER (stamp
) != 1)
7493 printf (_("\tUnknown version.\n"));
7498 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7499 /* PR 17531: file: 16ceda89. */
7500 if (end
> aux
->info
+ aux
->info_size
)
7501 end
= aux
->info
+ aux
->info_size
;
7502 for (dp
= head
+ 8; dp
< end
;)
7503 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7512 slurp_ia64_unwind_table (Filedata
* filedata
,
7513 struct ia64_unw_aux_info
* aux
,
7514 Elf_Internal_Shdr
* sec
)
7516 unsigned long size
, nrelas
, i
;
7517 Elf_Internal_Phdr
* seg
;
7518 struct ia64_unw_table_entry
* tep
;
7519 Elf_Internal_Shdr
* relsec
;
7520 Elf_Internal_Rela
* rela
;
7521 Elf_Internal_Rela
* rp
;
7522 unsigned char * table
;
7524 Elf_Internal_Sym
* sym
;
7525 const char * relname
;
7529 /* First, find the starting address of the segment that includes
7532 if (filedata
->file_header
.e_phnum
)
7534 if (! get_program_headers (filedata
))
7537 for (seg
= filedata
->program_headers
;
7538 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7541 if (seg
->p_type
!= PT_LOAD
)
7544 if (sec
->sh_addr
>= seg
->p_vaddr
7545 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7547 aux
->seg_base
= seg
->p_vaddr
;
7553 /* Second, build the unwind table from the contents of the unwind section: */
7554 size
= sec
->sh_size
;
7555 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7560 aux
->table_len
= size
/ (3 * eh_addr_size
);
7561 aux
->table
= (struct ia64_unw_table_entry
*)
7562 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7565 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7567 tep
->start
.section
= SHN_UNDEF
;
7568 tep
->end
.section
= SHN_UNDEF
;
7569 tep
->info
.section
= SHN_UNDEF
;
7570 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7571 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7572 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7573 tep
->start
.offset
+= aux
->seg_base
;
7574 tep
->end
.offset
+= aux
->seg_base
;
7575 tep
->info
.offset
+= aux
->seg_base
;
7579 /* Third, apply any relocations to the unwind table: */
7580 for (relsec
= filedata
->section_headers
;
7581 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7584 if (relsec
->sh_type
!= SHT_RELA
7585 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7586 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7589 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7598 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7600 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7601 relname
= elf_ia64_reloc_type (r_type
);
7602 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7604 /* PR 17531: file: 9fa67536. */
7605 if (relname
== NULL
)
7607 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7611 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7613 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7617 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7619 /* PR 17531: file: 5bc8d9bf. */
7620 if (i
>= aux
->table_len
)
7622 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7626 switch (rp
->r_offset
/ eh_addr_size
% 3)
7629 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7630 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7633 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7634 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7637 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7638 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7652 ia64_process_unwind (Filedata
* filedata
)
7654 Elf_Internal_Shdr
* sec
;
7655 Elf_Internal_Shdr
* unwsec
= NULL
;
7656 Elf_Internal_Shdr
* strsec
;
7657 unsigned long i
, unwcount
= 0, unwstart
= 0;
7658 struct ia64_unw_aux_info aux
;
7659 bfd_boolean res
= TRUE
;
7661 memset (& aux
, 0, sizeof (aux
));
7663 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7665 if (sec
->sh_type
== SHT_SYMTAB
7666 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7668 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7670 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7671 if (aux
.strtab
!= NULL
)
7673 error (_("Multiple auxillary string tables encountered\n"));
7677 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7680 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7682 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7687 printf (_("\nThere are no unwind sections in this file.\n"));
7689 while (unwcount
-- > 0)
7694 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7695 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7696 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7701 /* We have already counted the number of SHT_IA64_UNWIND
7702 sections so the loop above should never fail. */
7703 assert (unwsec
!= NULL
);
7706 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7708 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7710 /* We need to find which section group it is in. */
7711 struct group_list
* g
;
7713 if (section_headers_groups
== NULL
7714 || section_headers_groups
[i
] == NULL
)
7715 i
= filedata
->file_header
.e_shnum
;
7718 g
= section_headers_groups
[i
]->root
;
7720 for (; g
!= NULL
; g
= g
->next
)
7722 sec
= filedata
->section_headers
+ g
->section_index
;
7724 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7729 i
= filedata
->file_header
.e_shnum
;
7732 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7734 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7735 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7736 suffix
= SECTION_NAME (unwsec
) + len
;
7737 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7739 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7740 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7745 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7746 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7747 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7748 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7750 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7751 suffix
= SECTION_NAME (unwsec
) + len
;
7752 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7754 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7755 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7759 if (i
== filedata
->file_header
.e_shnum
)
7761 printf (_("\nCould not find unwind info section for "));
7763 if (filedata
->string_table
== NULL
)
7764 printf ("%d", unwsec
->sh_name
);
7766 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7770 aux
.info_addr
= sec
->sh_addr
;
7771 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7774 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7776 printf (_("\nUnwind section "));
7778 if (filedata
->string_table
== NULL
)
7779 printf ("%d", unwsec
->sh_name
);
7781 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7783 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7784 (unsigned long) unwsec
->sh_offset
,
7785 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7787 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7788 && aux
.table_len
> 0)
7789 dump_ia64_unwind (filedata
, & aux
);
7792 free ((char *) aux
.table
);
7794 free ((char *) aux
.info
);
7803 free ((char *) aux
.strtab
);
7808 struct hppa_unw_table_entry
7810 struct absaddr start
;
7812 unsigned int Cannot_unwind
:1; /* 0 */
7813 unsigned int Millicode
:1; /* 1 */
7814 unsigned int Millicode_save_sr0
:1; /* 2 */
7815 unsigned int Region_description
:2; /* 3..4 */
7816 unsigned int reserved1
:1; /* 5 */
7817 unsigned int Entry_SR
:1; /* 6 */
7818 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7819 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7820 unsigned int Args_stored
:1; /* 16 */
7821 unsigned int Variable_Frame
:1; /* 17 */
7822 unsigned int Separate_Package_Body
:1; /* 18 */
7823 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7824 unsigned int Stack_Overflow_Check
:1; /* 20 */
7825 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7826 unsigned int Ada_Region
:1; /* 22 */
7827 unsigned int cxx_info
:1; /* 23 */
7828 unsigned int cxx_try_catch
:1; /* 24 */
7829 unsigned int sched_entry_seq
:1; /* 25 */
7830 unsigned int reserved2
:1; /* 26 */
7831 unsigned int Save_SP
:1; /* 27 */
7832 unsigned int Save_RP
:1; /* 28 */
7833 unsigned int Save_MRP_in_frame
:1; /* 29 */
7834 unsigned int extn_ptr_defined
:1; /* 30 */
7835 unsigned int Cleanup_defined
:1; /* 31 */
7837 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7838 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7839 unsigned int Large_frame
:1; /* 2 */
7840 unsigned int Pseudo_SP_Set
:1; /* 3 */
7841 unsigned int reserved4
:1; /* 4 */
7842 unsigned int Total_frame_size
:27; /* 5..31 */
7845 struct hppa_unw_aux_info
7847 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7848 unsigned long table_len
; /* Length of unwind table. */
7849 bfd_vma seg_base
; /* Starting address of segment. */
7850 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7851 unsigned long nsyms
; /* Number of symbols. */
7852 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7853 unsigned long nfuns
; /* Number of entries in funtab. */
7854 char * strtab
; /* The string table. */
7855 unsigned long strtab_size
; /* Size of string table. */
7859 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7861 struct hppa_unw_table_entry
* tp
;
7862 unsigned long j
, nfuns
;
7863 bfd_boolean res
= TRUE
;
7865 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7866 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7867 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7868 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7870 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7872 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7875 const char * procname
;
7877 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7878 aux
->strtab_size
, tp
->start
, &procname
,
7881 fputs ("\n<", stdout
);
7885 fputs (procname
, stdout
);
7888 printf ("+%lx", (unsigned long) offset
);
7891 fputs (">: [", stdout
);
7892 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7893 fputc ('-', stdout
);
7894 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7897 #define PF(_m) if (tp->_m) printf (#_m " ");
7898 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7901 PF(Millicode_save_sr0
);
7902 /* PV(Region_description); */
7908 PF(Separate_Package_Body
);
7909 PF(Frame_Extension_Millicode
);
7910 PF(Stack_Overflow_Check
);
7911 PF(Two_Instruction_SP_Increment
);
7915 PF(sched_entry_seq
);
7918 PF(Save_MRP_in_frame
);
7919 PF(extn_ptr_defined
);
7920 PF(Cleanup_defined
);
7921 PF(MPE_XL_interrupt_marker
);
7922 PF(HP_UX_interrupt_marker
);
7925 PV(Total_frame_size
);
7938 slurp_hppa_unwind_table (Filedata
* filedata
,
7939 struct hppa_unw_aux_info
* aux
,
7940 Elf_Internal_Shdr
* sec
)
7942 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7943 Elf_Internal_Phdr
* seg
;
7944 struct hppa_unw_table_entry
* tep
;
7945 Elf_Internal_Shdr
* relsec
;
7946 Elf_Internal_Rela
* rela
;
7947 Elf_Internal_Rela
* rp
;
7948 unsigned char * table
;
7950 Elf_Internal_Sym
* sym
;
7951 const char * relname
;
7953 /* First, find the starting address of the segment that includes
7955 if (filedata
->file_header
.e_phnum
)
7957 if (! get_program_headers (filedata
))
7960 for (seg
= filedata
->program_headers
;
7961 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7964 if (seg
->p_type
!= PT_LOAD
)
7967 if (sec
->sh_addr
>= seg
->p_vaddr
7968 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7970 aux
->seg_base
= seg
->p_vaddr
;
7976 /* Second, build the unwind table from the contents of the unwind
7978 size
= sec
->sh_size
;
7979 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7985 nentries
= size
/ unw_ent_size
;
7986 size
= unw_ent_size
* nentries
;
7988 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7989 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7991 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7993 unsigned int tmp1
, tmp2
;
7995 tep
->start
.section
= SHN_UNDEF
;
7996 tep
->end
.section
= SHN_UNDEF
;
7998 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7999 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8000 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8001 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8003 tep
->start
.offset
+= aux
->seg_base
;
8004 tep
->end
.offset
+= aux
->seg_base
;
8006 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8007 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8008 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8009 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8010 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8011 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8012 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8013 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8014 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8015 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8016 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8017 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8018 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8019 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8020 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8021 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8022 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8023 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8024 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8025 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8026 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8027 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8028 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8029 tep
->Cleanup_defined
= tmp1
& 0x1;
8031 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8032 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8033 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8034 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8035 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8036 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8040 /* Third, apply any relocations to the unwind table. */
8041 for (relsec
= filedata
->section_headers
;
8042 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8045 if (relsec
->sh_type
!= SHT_RELA
8046 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8047 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8050 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8054 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8056 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8057 relname
= elf_hppa_reloc_type (r_type
);
8058 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
8060 if (relname
== NULL
)
8062 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8066 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8067 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8069 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8073 i
= rp
->r_offset
/ unw_ent_size
;
8074 if (i
>= aux
->table_len
)
8076 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8080 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8083 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8084 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8087 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8088 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8098 aux
->table_len
= nentries
;
8104 hppa_process_unwind (Filedata
* filedata
)
8106 struct hppa_unw_aux_info aux
;
8107 Elf_Internal_Shdr
* unwsec
= NULL
;
8108 Elf_Internal_Shdr
* strsec
;
8109 Elf_Internal_Shdr
* sec
;
8111 bfd_boolean res
= TRUE
;
8113 if (filedata
->string_table
== NULL
)
8116 memset (& aux
, 0, sizeof (aux
));
8118 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8120 if (sec
->sh_type
== SHT_SYMTAB
8121 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8123 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8125 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8126 if (aux
.strtab
!= NULL
)
8128 error (_("Multiple auxillary string tables encountered\n"));
8132 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8135 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8137 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8142 printf (_("\nThere are no unwind sections in this file.\n"));
8144 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8146 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8148 unsigned long num_unwind
= sec
->sh_size
/ 16;
8150 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8151 "contains %lu entry:\n",
8152 "\nUnwind section '%s' at offset 0x%lx "
8153 "contains %lu entries:\n",
8155 printable_section_name (filedata
, sec
),
8156 (unsigned long) sec
->sh_offset
,
8159 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8162 if (res
&& aux
.table_len
> 0)
8164 if (! dump_hppa_unwind (filedata
, &aux
))
8169 free ((char *) aux
.table
);
8177 free ((char *) aux
.strtab
);
8184 unsigned char * data
; /* The unwind data. */
8185 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8186 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8187 unsigned long nrelas
; /* The number of relocations. */
8188 unsigned int rel_type
; /* REL or RELA ? */
8189 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8192 struct arm_unw_aux_info
8194 Filedata
* filedata
; /* The file containing the unwind sections. */
8195 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8196 unsigned long nsyms
; /* Number of symbols. */
8197 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8198 unsigned long nfuns
; /* Number of these symbols. */
8199 char * strtab
; /* The file's string table. */
8200 unsigned long strtab_size
; /* Size of string table. */
8204 arm_print_vma_and_name (Filedata
* filedata
,
8205 struct arm_unw_aux_info
* aux
,
8207 struct absaddr addr
)
8209 const char *procname
;
8212 if (addr
.section
== SHN_UNDEF
)
8215 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8216 aux
->strtab_size
, addr
, &procname
,
8219 print_vma (fn
, PREFIX_HEX
);
8223 fputs (" <", stdout
);
8224 fputs (procname
, stdout
);
8227 printf ("+0x%lx", (unsigned long) sym_offset
);
8228 fputc ('>', stdout
);
8235 arm_free_section (struct arm_section
*arm_sec
)
8237 if (arm_sec
->data
!= NULL
)
8238 free (arm_sec
->data
);
8240 if (arm_sec
->rela
!= NULL
)
8241 free (arm_sec
->rela
);
8244 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8245 cached section and install SEC instead.
8246 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8247 and return its valued in * WORDP, relocating if necessary.
8248 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8249 relocation's offset in ADDR.
8250 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8251 into the string table of the symbol associated with the reloc. If no
8252 reloc was applied store -1 there.
8253 5) Return TRUE upon success, FALSE otherwise. */
8256 get_unwind_section_word (Filedata
* filedata
,
8257 struct arm_unw_aux_info
* aux
,
8258 struct arm_section
* arm_sec
,
8259 Elf_Internal_Shdr
* sec
,
8260 bfd_vma word_offset
,
8261 unsigned int * wordp
,
8262 struct absaddr
* addr
,
8265 Elf_Internal_Rela
*rp
;
8266 Elf_Internal_Sym
*sym
;
8267 const char * relname
;
8269 bfd_boolean wrapped
;
8271 if (sec
== NULL
|| arm_sec
== NULL
)
8274 addr
->section
= SHN_UNDEF
;
8277 if (sym_name
!= NULL
)
8278 *sym_name
= (bfd_vma
) -1;
8280 /* If necessary, update the section cache. */
8281 if (sec
!= arm_sec
->sec
)
8283 Elf_Internal_Shdr
*relsec
;
8285 arm_free_section (arm_sec
);
8288 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8289 sec
->sh_size
, _("unwind data"));
8290 arm_sec
->rela
= NULL
;
8291 arm_sec
->nrelas
= 0;
8293 for (relsec
= filedata
->section_headers
;
8294 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8297 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8298 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8299 /* PR 15745: Check the section type as well. */
8300 || (relsec
->sh_type
!= SHT_REL
8301 && relsec
->sh_type
!= SHT_RELA
))
8304 arm_sec
->rel_type
= relsec
->sh_type
;
8305 if (relsec
->sh_type
== SHT_REL
)
8307 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8309 & arm_sec
->rela
, & arm_sec
->nrelas
))
8312 else /* relsec->sh_type == SHT_RELA */
8314 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8316 & arm_sec
->rela
, & arm_sec
->nrelas
))
8322 arm_sec
->next_rela
= arm_sec
->rela
;
8325 /* If there is no unwind data we can do nothing. */
8326 if (arm_sec
->data
== NULL
)
8329 /* If the offset is invalid then fail. */
8330 if (/* PR 21343 *//* PR 18879 */
8332 || word_offset
> (sec
->sh_size
- 4)
8333 || ((bfd_signed_vma
) word_offset
) < 0)
8336 /* Get the word at the required offset. */
8337 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8339 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8340 if (arm_sec
->rela
== NULL
)
8346 /* Look through the relocs to find the one that applies to the provided offset. */
8348 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8350 bfd_vma prelval
, offset
;
8352 if (rp
->r_offset
> word_offset
&& !wrapped
)
8357 if (rp
->r_offset
> word_offset
)
8360 if (rp
->r_offset
& 3)
8362 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8363 (unsigned long) rp
->r_offset
);
8367 if (rp
->r_offset
< word_offset
)
8370 /* PR 17531: file: 027-161405-0.004 */
8371 if (aux
->symtab
== NULL
)
8374 if (arm_sec
->rel_type
== SHT_REL
)
8376 offset
= word
& 0x7fffffff;
8377 if (offset
& 0x40000000)
8378 offset
|= ~ (bfd_vma
) 0x7fffffff;
8380 else if (arm_sec
->rel_type
== SHT_RELA
)
8381 offset
= rp
->r_addend
;
8384 error (_("Unknown section relocation type %d encountered\n"),
8389 /* PR 17531 file: 027-1241568-0.004. */
8390 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8392 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8393 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8397 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8398 offset
+= sym
->st_value
;
8399 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8401 /* Check that we are processing the expected reloc type. */
8402 if (filedata
->file_header
.e_machine
== EM_ARM
)
8404 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8405 if (relname
== NULL
)
8407 warn (_("Skipping unknown ARM relocation type: %d\n"),
8408 (int) ELF32_R_TYPE (rp
->r_info
));
8412 if (streq (relname
, "R_ARM_NONE"))
8415 if (! streq (relname
, "R_ARM_PREL31"))
8417 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8421 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8423 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8424 if (relname
== NULL
)
8426 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8427 (int) ELF32_R_TYPE (rp
->r_info
));
8431 if (streq (relname
, "R_C6000_NONE"))
8434 if (! streq (relname
, "R_C6000_PREL31"))
8436 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8444 /* This function currently only supports ARM and TI unwinders. */
8445 warn (_("Only TI and ARM unwinders are currently supported\n"));
8449 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8450 addr
->section
= sym
->st_shndx
;
8451 addr
->offset
= offset
;
8454 * sym_name
= sym
->st_name
;
8459 arm_sec
->next_rela
= rp
;
8464 static const char *tic6x_unwind_regnames
[16] =
8466 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8467 "A14", "A13", "A12", "A11", "A10",
8468 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8472 decode_tic6x_unwind_regmask (unsigned int mask
)
8476 for (i
= 12; mask
; mask
>>= 1, i
--)
8480 fputs (tic6x_unwind_regnames
[i
], stdout
);
8482 fputs (", ", stdout
);
8488 if (remaining == 0 && more_words) \
8491 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8492 data_offset, & word, & addr, NULL)) \
8498 #define GET_OP(OP) \
8503 (OP) = word >> 24; \
8508 printf (_("[Truncated opcode]\n")); \
8511 printf ("0x%02x ", OP)
8514 decode_arm_unwind_bytecode (Filedata
* filedata
,
8515 struct arm_unw_aux_info
* aux
,
8517 unsigned int remaining
,
8518 unsigned int more_words
,
8519 bfd_vma data_offset
,
8520 Elf_Internal_Shdr
* data_sec
,
8521 struct arm_section
* data_arm_sec
)
8523 struct absaddr addr
;
8524 bfd_boolean res
= TRUE
;
8526 /* Decode the unwinding instructions. */
8529 unsigned int op
, op2
;
8538 printf (" 0x%02x ", op
);
8540 if ((op
& 0xc0) == 0x00)
8542 int offset
= ((op
& 0x3f) << 2) + 4;
8544 printf (" vsp = vsp + %d", offset
);
8546 else if ((op
& 0xc0) == 0x40)
8548 int offset
= ((op
& 0x3f) << 2) + 4;
8550 printf (" vsp = vsp - %d", offset
);
8552 else if ((op
& 0xf0) == 0x80)
8555 if (op
== 0x80 && op2
== 0)
8556 printf (_("Refuse to unwind"));
8559 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8560 bfd_boolean first
= TRUE
;
8564 for (i
= 0; i
< 12; i
++)
8565 if (mask
& (1 << i
))
8571 printf ("r%d", 4 + i
);
8576 else if ((op
& 0xf0) == 0x90)
8578 if (op
== 0x9d || op
== 0x9f)
8579 printf (_(" [Reserved]"));
8581 printf (" vsp = r%d", op
& 0x0f);
8583 else if ((op
& 0xf0) == 0xa0)
8585 int end
= 4 + (op
& 0x07);
8586 bfd_boolean first
= TRUE
;
8590 for (i
= 4; i
<= end
; i
++)
8606 else if (op
== 0xb0)
8607 printf (_(" finish"));
8608 else if (op
== 0xb1)
8611 if (op2
== 0 || (op2
& 0xf0) != 0)
8612 printf (_("[Spare]"));
8615 unsigned int mask
= op2
& 0x0f;
8616 bfd_boolean first
= TRUE
;
8620 for (i
= 0; i
< 12; i
++)
8621 if (mask
& (1 << i
))
8632 else if (op
== 0xb2)
8634 unsigned char buf
[9];
8635 unsigned int i
, len
;
8636 unsigned long offset
;
8638 for (i
= 0; i
< sizeof (buf
); i
++)
8641 if ((buf
[i
] & 0x80) == 0)
8644 if (i
== sizeof (buf
))
8646 error (_("corrupt change to vsp"));
8651 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8652 assert (len
== i
+ 1);
8653 offset
= offset
* 4 + 0x204;
8654 printf ("vsp = vsp + %ld", offset
);
8657 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8659 unsigned int first
, last
;
8666 printf ("pop {D%d", first
);
8668 printf ("-D%d", first
+ last
);
8671 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8673 unsigned int count
= op
& 0x07;
8677 printf ("-D%d", 8 + count
);
8680 else if (op
>= 0xc0 && op
<= 0xc5)
8682 unsigned int count
= op
& 0x07;
8684 printf (" pop {wR10");
8686 printf ("-wR%d", 10 + count
);
8689 else if (op
== 0xc6)
8691 unsigned int first
, last
;
8696 printf ("pop {wR%d", first
);
8698 printf ("-wR%d", first
+ last
);
8701 else if (op
== 0xc7)
8704 if (op2
== 0 || (op2
& 0xf0) != 0)
8705 printf (_("[Spare]"));
8708 unsigned int mask
= op2
& 0x0f;
8709 bfd_boolean first
= TRUE
;
8713 for (i
= 0; i
< 4; i
++)
8714 if (mask
& (1 << i
))
8720 printf ("wCGR%d", i
);
8727 printf (_(" [unsupported opcode]"));
8738 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8739 struct arm_unw_aux_info
* aux
,
8741 unsigned int remaining
,
8742 unsigned int more_words
,
8743 bfd_vma data_offset
,
8744 Elf_Internal_Shdr
* data_sec
,
8745 struct arm_section
* data_arm_sec
)
8747 struct absaddr addr
;
8749 /* Decode the unwinding instructions. */
8752 unsigned int op
, op2
;
8761 printf (" 0x%02x ", op
);
8763 if ((op
& 0xc0) == 0x00)
8765 int offset
= ((op
& 0x3f) << 3) + 8;
8766 printf (" sp = sp + %d", offset
);
8768 else if ((op
& 0xc0) == 0x80)
8771 if (op
== 0x80 && op2
== 0)
8772 printf (_("Refuse to unwind"));
8775 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8777 printf ("pop compact {");
8781 decode_tic6x_unwind_regmask (mask
);
8785 else if ((op
& 0xf0) == 0xc0)
8793 unsigned int offset
;
8797 /* Scan entire instruction first so that GET_OP output is not
8798 interleaved with disassembly. */
8800 for (i
= 0; nregs
< (op
& 0xf); i
++)
8806 regpos
[nregs
].offset
= i
* 2;
8807 regpos
[nregs
].reg
= reg
;
8814 regpos
[nregs
].offset
= i
* 2 + 1;
8815 regpos
[nregs
].reg
= reg
;
8820 printf (_("pop frame {"));
8822 for (i
= i
* 2; i
> 0; i
--)
8824 if (regpos
[reg
].offset
== i
- 1)
8826 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8833 fputs (name
, stdout
);
8840 else if (op
== 0xd0)
8841 printf (" MOV FP, SP");
8842 else if (op
== 0xd1)
8843 printf (" __c6xabi_pop_rts");
8844 else if (op
== 0xd2)
8846 unsigned char buf
[9];
8847 unsigned int i
, len
;
8848 unsigned long offset
;
8850 for (i
= 0; i
< sizeof (buf
); i
++)
8853 if ((buf
[i
] & 0x80) == 0)
8856 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8857 if (i
== sizeof (buf
))
8859 warn (_("Corrupt stack pointer adjustment detected\n"));
8863 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8864 assert (len
== i
+ 1);
8865 offset
= offset
* 8 + 0x408;
8866 printf (_("sp = sp + %ld"), offset
);
8868 else if ((op
& 0xf0) == 0xe0)
8870 if ((op
& 0x0f) == 7)
8873 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8877 printf (_(" [unsupported opcode]"));
8886 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8890 offset
= word
& 0x7fffffff;
8891 if (offset
& 0x40000000)
8892 offset
|= ~ (bfd_vma
) 0x7fffffff;
8894 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8897 return offset
+ where
;
8901 decode_arm_unwind (Filedata
* filedata
,
8902 struct arm_unw_aux_info
* aux
,
8904 unsigned int remaining
,
8905 bfd_vma data_offset
,
8906 Elf_Internal_Shdr
* data_sec
,
8907 struct arm_section
* data_arm_sec
)
8910 unsigned int more_words
= 0;
8911 struct absaddr addr
;
8912 bfd_vma sym_name
= (bfd_vma
) -1;
8913 bfd_boolean res
= TRUE
;
8917 /* Fetch the first word.
8918 Note - when decoding an object file the address extracted
8919 here will always be 0. So we also pass in the sym_name
8920 parameter so that we can find the symbol associated with
8921 the personality routine. */
8922 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8923 & word
, & addr
, & sym_name
))
8929 if ((word
& 0x80000000) == 0)
8931 /* Expand prel31 for personality routine. */
8933 const char *procname
;
8935 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8936 printf (_(" Personality routine: "));
8938 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8939 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8941 procname
= aux
->strtab
+ sym_name
;
8942 print_vma (fn
, PREFIX_HEX
);
8945 fputs (" <", stdout
);
8946 fputs (procname
, stdout
);
8947 fputc ('>', stdout
);
8951 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8952 fputc ('\n', stdout
);
8954 /* The GCC personality routines use the standard compact
8955 encoding, starting with one byte giving the number of
8957 if (procname
!= NULL
8958 && (const_strneq (procname
, "__gcc_personality_v0")
8959 || const_strneq (procname
, "__gxx_personality_v0")
8960 || const_strneq (procname
, "__gcj_personality_v0")
8961 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8968 printf (_(" [Truncated data]\n"));
8971 more_words
= word
>> 24;
8981 /* ARM EHABI Section 6.3:
8983 An exception-handling table entry for the compact model looks like:
8987 1 0 index Data for personalityRoutine[index] */
8989 if (filedata
->file_header
.e_machine
== EM_ARM
8990 && (word
& 0x70000000))
8992 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8996 per_index
= (word
>> 24) & 0x7f;
8997 printf (_(" Compact model index: %d\n"), per_index
);
9004 else if (per_index
< 3)
9006 more_words
= (word
>> 16) & 0xff;
9012 switch (filedata
->file_header
.e_machine
)
9017 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9018 data_offset
, data_sec
, data_arm_sec
))
9023 warn (_("Unknown ARM compact model index encountered\n"));
9024 printf (_(" [reserved]\n"));
9032 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9033 data_offset
, data_sec
, data_arm_sec
))
9036 else if (per_index
< 5)
9038 if (((word
>> 17) & 0x7f) == 0x7f)
9039 printf (_(" Restore stack from frame pointer\n"));
9041 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9042 printf (_(" Registers restored: "));
9044 printf (" (compact) ");
9045 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9047 printf (_(" Return register: %s\n"),
9048 tic6x_unwind_regnames
[word
& 0xf]);
9051 printf (_(" [reserved (%d)]\n"), per_index
);
9055 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9056 filedata
->file_header
.e_machine
);
9060 /* Decode the descriptors. Not implemented. */
9066 dump_arm_unwind (Filedata
* filedata
,
9067 struct arm_unw_aux_info
* aux
,
9068 Elf_Internal_Shdr
* exidx_sec
)
9070 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9071 unsigned int i
, exidx_len
;
9072 unsigned long j
, nfuns
;
9073 bfd_boolean res
= TRUE
;
9075 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9076 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9077 exidx_len
= exidx_sec
->sh_size
/ 8;
9079 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9080 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9081 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9082 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9084 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9086 for (i
= 0; i
< exidx_len
; i
++)
9088 unsigned int exidx_fn
, exidx_entry
;
9089 struct absaddr fn_addr
, entry_addr
;
9092 fputc ('\n', stdout
);
9094 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9095 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9096 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9097 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9100 arm_free_section (& exidx_arm_sec
);
9101 arm_free_section (& extab_arm_sec
);
9105 /* ARM EHABI, Section 5:
9106 An index table entry consists of 2 words.
9107 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9108 if (exidx_fn
& 0x80000000)
9110 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9114 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9116 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9117 fputs (": ", stdout
);
9119 if (exidx_entry
== 1)
9121 print_vma (exidx_entry
, PREFIX_HEX
);
9122 fputs (" [cantunwind]\n", stdout
);
9124 else if (exidx_entry
& 0x80000000)
9126 print_vma (exidx_entry
, PREFIX_HEX
);
9127 fputc ('\n', stdout
);
9128 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9132 bfd_vma table
, table_offset
= 0;
9133 Elf_Internal_Shdr
*table_sec
;
9135 fputs ("@", stdout
);
9136 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9137 print_vma (table
, PREFIX_HEX
);
9140 /* Locate the matching .ARM.extab. */
9141 if (entry_addr
.section
!= SHN_UNDEF
9142 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9144 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9145 table_offset
= entry_addr
.offset
;
9147 if (table_offset
> table_sec
->sh_size
9148 || ((bfd_signed_vma
) table_offset
) < 0)
9150 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9151 (unsigned long) table_offset
,
9152 printable_section_name (filedata
, table_sec
));
9159 table_sec
= find_section_by_address (filedata
, table
);
9160 if (table_sec
!= NULL
)
9161 table_offset
= table
- table_sec
->sh_addr
;
9164 if (table_sec
== NULL
)
9166 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9167 (unsigned long) table
);
9172 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9181 arm_free_section (&exidx_arm_sec
);
9182 arm_free_section (&extab_arm_sec
);
9187 /* Used for both ARM and C6X unwinding tables. */
9190 arm_process_unwind (Filedata
* filedata
)
9192 struct arm_unw_aux_info aux
;
9193 Elf_Internal_Shdr
*unwsec
= NULL
;
9194 Elf_Internal_Shdr
*strsec
;
9195 Elf_Internal_Shdr
*sec
;
9197 unsigned int sec_type
;
9198 bfd_boolean res
= TRUE
;
9200 switch (filedata
->file_header
.e_machine
)
9203 sec_type
= SHT_ARM_EXIDX
;
9207 sec_type
= SHT_C6000_UNWIND
;
9211 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9212 filedata
->file_header
.e_machine
);
9216 if (filedata
->string_table
== NULL
)
9219 memset (& aux
, 0, sizeof (aux
));
9220 aux
.filedata
= filedata
;
9222 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9224 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9226 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9228 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9230 /* PR binutils/17531 file: 011-12666-0.004. */
9231 if (aux
.strtab
!= NULL
)
9233 error (_("Multiple string tables found in file.\n"));
9237 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9238 1, strsec
->sh_size
, _("string table"));
9239 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9241 else if (sec
->sh_type
== sec_type
)
9246 printf (_("\nThere are no unwind sections in this file.\n"));
9248 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9250 if (sec
->sh_type
== sec_type
)
9252 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9253 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9254 "contains %lu entry:\n",
9255 "\nUnwind section '%s' at offset 0x%lx "
9256 "contains %lu entries:\n",
9258 printable_section_name (filedata
, sec
),
9259 (unsigned long) sec
->sh_offset
,
9262 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9270 free ((char *) aux
.strtab
);
9276 process_unwind (Filedata
* filedata
)
9278 struct unwind_handler
9280 unsigned int machtype
;
9281 bfd_boolean (* handler
)(Filedata
*);
9284 { EM_ARM
, arm_process_unwind
},
9285 { EM_IA_64
, ia64_process_unwind
},
9286 { EM_PARISC
, hppa_process_unwind
},
9287 { EM_TI_C6000
, arm_process_unwind
},
9295 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9296 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9297 return handlers
[i
].handler (filedata
);
9299 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9300 get_machine_name (filedata
->file_header
.e_machine
));
9305 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9307 switch (entry
->d_tag
)
9310 if (entry
->d_un
.d_val
== 0)
9314 static const char * opts
[] =
9316 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9317 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9318 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9319 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9323 bfd_boolean first
= TRUE
;
9325 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9326 if (entry
->d_un
.d_val
& (1 << cnt
))
9328 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9334 case DT_MIPS_IVERSION
:
9335 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9336 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9340 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9341 /* Note: coded this way so that there is a single string for translation. */
9342 printf (_("<corrupt: %s>"), buf
);
9346 case DT_MIPS_TIME_STAMP
:
9350 time_t atime
= entry
->d_un
.d_val
;
9352 tmp
= gmtime (&atime
);
9353 /* PR 17531: file: 6accc532. */
9355 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9357 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9358 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9359 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9360 printf (_("Time Stamp: %s"), timebuf
);
9364 case DT_MIPS_RLD_VERSION
:
9365 case DT_MIPS_LOCAL_GOTNO
:
9366 case DT_MIPS_CONFLICTNO
:
9367 case DT_MIPS_LIBLISTNO
:
9368 case DT_MIPS_SYMTABNO
:
9369 case DT_MIPS_UNREFEXTNO
:
9370 case DT_MIPS_HIPAGENO
:
9371 case DT_MIPS_DELTA_CLASS_NO
:
9372 case DT_MIPS_DELTA_INSTANCE_NO
:
9373 case DT_MIPS_DELTA_RELOC_NO
:
9374 case DT_MIPS_DELTA_SYM_NO
:
9375 case DT_MIPS_DELTA_CLASSSYM_NO
:
9376 case DT_MIPS_COMPACT_SIZE
:
9377 print_vma (entry
->d_un
.d_val
, DEC
);
9381 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9387 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9389 switch (entry
->d_tag
)
9391 case DT_HP_DLD_FLAGS
:
9400 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9401 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9402 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9403 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9404 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9405 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9406 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9407 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9408 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9409 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9410 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9411 { DT_HP_GST
, "HP_GST" },
9412 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9413 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9414 { DT_HP_NODELETE
, "HP_NODELETE" },
9415 { DT_HP_GROUP
, "HP_GROUP" },
9416 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9418 bfd_boolean first
= TRUE
;
9420 bfd_vma val
= entry
->d_un
.d_val
;
9422 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9423 if (val
& flags
[cnt
].bit
)
9427 fputs (flags
[cnt
].str
, stdout
);
9429 val
^= flags
[cnt
].bit
;
9432 if (val
!= 0 || first
)
9436 print_vma (val
, HEX
);
9442 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9450 /* VMS vs Unix time offset and factor. */
9452 #define VMS_EPOCH_OFFSET 35067168000000000LL
9453 #define VMS_GRANULARITY_FACTOR 10000000
9455 /* Display a VMS time in a human readable format. */
9458 print_vms_time (bfd_int64_t vmstime
)
9463 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9464 tm
= gmtime (&unxtime
);
9465 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9466 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9467 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9472 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9474 switch (entry
->d_tag
)
9476 case DT_IA_64_PLT_RESERVE
:
9477 /* First 3 slots reserved. */
9478 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9480 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9483 case DT_IA_64_VMS_LINKTIME
:
9485 print_vms_time (entry
->d_un
.d_val
);
9489 case DT_IA_64_VMS_LNKFLAGS
:
9490 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9491 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9492 printf (" CALL_DEBUG");
9493 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9494 printf (" NOP0BUFS");
9495 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9496 printf (" P0IMAGE");
9497 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9498 printf (" MKTHREADS");
9499 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9500 printf (" UPCALLS");
9501 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9503 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9504 printf (" INITIALIZE");
9505 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9507 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9508 printf (" EXE_INIT");
9509 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9510 printf (" TBK_IN_IMG");
9511 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9512 printf (" DBG_IN_IMG");
9513 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9514 printf (" TBK_IN_DSF");
9515 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9516 printf (" DBG_IN_DSF");
9517 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9518 printf (" SIGNATURES");
9519 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9520 printf (" REL_SEG_OFF");
9524 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9531 get_32bit_dynamic_section (Filedata
* filedata
)
9533 Elf32_External_Dyn
* edyn
;
9534 Elf32_External_Dyn
* ext
;
9535 Elf_Internal_Dyn
* entry
;
9537 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9538 dynamic_size
, _("dynamic section"));
9542 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9543 might not have the luxury of section headers. Look for the DT_NULL
9544 terminator to determine the number of entries. */
9545 for (ext
= edyn
, dynamic_nent
= 0;
9546 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9550 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9554 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9556 if (dynamic_section
== NULL
)
9558 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9559 (unsigned long) dynamic_nent
);
9564 for (ext
= edyn
, entry
= dynamic_section
;
9565 entry
< dynamic_section
+ dynamic_nent
;
9568 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9569 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9578 get_64bit_dynamic_section (Filedata
* filedata
)
9580 Elf64_External_Dyn
* edyn
;
9581 Elf64_External_Dyn
* ext
;
9582 Elf_Internal_Dyn
* entry
;
9584 /* Read in the data. */
9585 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9586 dynamic_size
, _("dynamic section"));
9590 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9591 might not have the luxury of section headers. Look for the DT_NULL
9592 terminator to determine the number of entries. */
9593 for (ext
= edyn
, dynamic_nent
= 0;
9594 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9595 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9599 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9603 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9605 if (dynamic_section
== NULL
)
9607 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9608 (unsigned long) dynamic_nent
);
9613 /* Convert from external to internal formats. */
9614 for (ext
= edyn
, entry
= dynamic_section
;
9615 entry
< dynamic_section
+ dynamic_nent
;
9618 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9619 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9628 print_dynamic_flags (bfd_vma flags
)
9630 bfd_boolean first
= TRUE
;
9636 flag
= flags
& - flags
;
9646 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9647 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9648 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9649 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9650 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9651 default: fputs (_("unknown"), stdout
); break;
9657 /* Parse and display the contents of the dynamic section. */
9660 process_dynamic_section (Filedata
* filedata
)
9662 Elf_Internal_Dyn
* entry
;
9664 if (dynamic_size
== 0)
9667 printf (_("\nThere is no dynamic section in this file.\n"));
9674 if (! get_32bit_dynamic_section (filedata
))
9679 if (! get_64bit_dynamic_section (filedata
))
9683 /* Find the appropriate symbol table. */
9684 if (dynamic_symbols
== NULL
)
9686 for (entry
= dynamic_section
;
9687 entry
< dynamic_section
+ dynamic_nent
;
9690 Elf_Internal_Shdr section
;
9692 if (entry
->d_tag
!= DT_SYMTAB
)
9695 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9697 /* Since we do not know how big the symbol table is,
9698 we default to reading in the entire file (!) and
9699 processing that. This is overkill, I know, but it
9701 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9702 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9704 /* See PR 21379 for a reproducer. */
9705 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9709 if (archive_file_offset
!= 0)
9710 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9712 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9715 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9717 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9718 section
.sh_name
= filedata
->string_table_length
;
9720 if (dynamic_symbols
!= NULL
)
9722 error (_("Multiple dynamic symbol table sections found\n"));
9723 free (dynamic_symbols
);
9725 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9726 if (num_dynamic_syms
< 1)
9728 error (_("Unable to determine the number of symbols to load\n"));
9734 /* Similarly find a string table. */
9735 if (dynamic_strings
== NULL
)
9737 for (entry
= dynamic_section
;
9738 entry
< dynamic_section
+ dynamic_nent
;
9741 unsigned long offset
;
9744 if (entry
->d_tag
!= DT_STRTAB
)
9747 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9749 /* Since we do not know how big the string table is,
9750 we default to reading in the entire file (!) and
9751 processing that. This is overkill, I know, but it
9754 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9756 if (archive_file_offset
!= 0)
9757 str_tab_len
= archive_file_size
- offset
;
9759 str_tab_len
= filedata
->file_size
- offset
;
9761 if (str_tab_len
< 1)
9764 (_("Unable to determine the length of the dynamic string table\n"));
9768 if (dynamic_strings
!= NULL
)
9770 error (_("Multiple dynamic string tables found\n"));
9771 free (dynamic_strings
);
9774 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9776 _("dynamic string table"));
9777 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9781 /* And find the syminfo section if available. */
9782 if (dynamic_syminfo
== NULL
)
9784 unsigned long syminsz
= 0;
9786 for (entry
= dynamic_section
;
9787 entry
< dynamic_section
+ dynamic_nent
;
9790 if (entry
->d_tag
== DT_SYMINENT
)
9792 /* Note: these braces are necessary to avoid a syntax
9793 error from the SunOS4 C compiler. */
9794 /* PR binutils/17531: A corrupt file can trigger this test.
9795 So do not use an assert, instead generate an error message. */
9796 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9797 error (_("Bad value (%d) for SYMINENT entry\n"),
9798 (int) entry
->d_un
.d_val
);
9800 else if (entry
->d_tag
== DT_SYMINSZ
)
9801 syminsz
= entry
->d_un
.d_val
;
9802 else if (entry
->d_tag
== DT_SYMINFO
)
9803 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9807 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9809 Elf_External_Syminfo
* extsyminfo
;
9810 Elf_External_Syminfo
* extsym
;
9811 Elf_Internal_Syminfo
* syminfo
;
9813 /* There is a syminfo section. Read the data. */
9814 extsyminfo
= (Elf_External_Syminfo
*)
9815 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9816 _("symbol information"));
9820 if (dynamic_syminfo
!= NULL
)
9822 error (_("Multiple dynamic symbol information sections found\n"));
9823 free (dynamic_syminfo
);
9825 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9826 if (dynamic_syminfo
== NULL
)
9828 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9829 (unsigned long) syminsz
);
9833 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9834 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9835 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9836 ++syminfo
, ++extsym
)
9838 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9839 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9846 if (do_dynamic
&& dynamic_addr
)
9847 printf (ngettext ("\nDynamic section at offset 0x%lx "
9848 "contains %lu entry:\n",
9849 "\nDynamic section at offset 0x%lx "
9850 "contains %lu entries:\n",
9852 dynamic_addr
, (unsigned long) dynamic_nent
);
9854 printf (_(" Tag Type Name/Value\n"));
9856 for (entry
= dynamic_section
;
9857 entry
< dynamic_section
+ dynamic_nent
;
9865 print_vma (entry
->d_tag
, FULL_HEX
);
9866 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9867 printf (" (%s)%*s", dtype
,
9868 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9871 switch (entry
->d_tag
)
9875 print_dynamic_flags (entry
->d_un
.d_val
);
9885 switch (entry
->d_tag
)
9888 printf (_("Auxiliary library"));
9892 printf (_("Filter library"));
9896 printf (_("Configuration file"));
9900 printf (_("Dependency audit library"));
9904 printf (_("Audit library"));
9908 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9909 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9913 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9922 printf (_("Flags:"));
9924 if (entry
->d_un
.d_val
== 0)
9925 printf (_(" None\n"));
9928 unsigned long int val
= entry
->d_un
.d_val
;
9930 if (val
& DTF_1_PARINIT
)
9932 printf (" PARINIT");
9933 val
^= DTF_1_PARINIT
;
9935 if (val
& DTF_1_CONFEXP
)
9937 printf (" CONFEXP");
9938 val
^= DTF_1_CONFEXP
;
9941 printf (" %lx", val
);
9950 printf (_("Flags:"));
9952 if (entry
->d_un
.d_val
== 0)
9953 printf (_(" None\n"));
9956 unsigned long int val
= entry
->d_un
.d_val
;
9958 if (val
& DF_P1_LAZYLOAD
)
9960 printf (" LAZYLOAD");
9961 val
^= DF_P1_LAZYLOAD
;
9963 if (val
& DF_P1_GROUPPERM
)
9965 printf (" GROUPPERM");
9966 val
^= DF_P1_GROUPPERM
;
9969 printf (" %lx", val
);
9978 printf (_("Flags:"));
9979 if (entry
->d_un
.d_val
== 0)
9980 printf (_(" None\n"));
9983 unsigned long int val
= entry
->d_un
.d_val
;
9990 if (val
& DF_1_GLOBAL
)
9995 if (val
& DF_1_GROUP
)
10000 if (val
& DF_1_NODELETE
)
10002 printf (" NODELETE");
10003 val
^= DF_1_NODELETE
;
10005 if (val
& DF_1_LOADFLTR
)
10007 printf (" LOADFLTR");
10008 val
^= DF_1_LOADFLTR
;
10010 if (val
& DF_1_INITFIRST
)
10012 printf (" INITFIRST");
10013 val
^= DF_1_INITFIRST
;
10015 if (val
& DF_1_NOOPEN
)
10017 printf (" NOOPEN");
10018 val
^= DF_1_NOOPEN
;
10020 if (val
& DF_1_ORIGIN
)
10022 printf (" ORIGIN");
10023 val
^= DF_1_ORIGIN
;
10025 if (val
& DF_1_DIRECT
)
10027 printf (" DIRECT");
10028 val
^= DF_1_DIRECT
;
10030 if (val
& DF_1_TRANS
)
10035 if (val
& DF_1_INTERPOSE
)
10037 printf (" INTERPOSE");
10038 val
^= DF_1_INTERPOSE
;
10040 if (val
& DF_1_NODEFLIB
)
10042 printf (" NODEFLIB");
10043 val
^= DF_1_NODEFLIB
;
10045 if (val
& DF_1_NODUMP
)
10047 printf (" NODUMP");
10048 val
^= DF_1_NODUMP
;
10050 if (val
& DF_1_CONFALT
)
10052 printf (" CONFALT");
10053 val
^= DF_1_CONFALT
;
10055 if (val
& DF_1_ENDFILTEE
)
10057 printf (" ENDFILTEE");
10058 val
^= DF_1_ENDFILTEE
;
10060 if (val
& DF_1_DISPRELDNE
)
10062 printf (" DISPRELDNE");
10063 val
^= DF_1_DISPRELDNE
;
10065 if (val
& DF_1_DISPRELPND
)
10067 printf (" DISPRELPND");
10068 val
^= DF_1_DISPRELPND
;
10070 if (val
& DF_1_NODIRECT
)
10072 printf (" NODIRECT");
10073 val
^= DF_1_NODIRECT
;
10075 if (val
& DF_1_IGNMULDEF
)
10077 printf (" IGNMULDEF");
10078 val
^= DF_1_IGNMULDEF
;
10080 if (val
& DF_1_NOKSYMS
)
10082 printf (" NOKSYMS");
10083 val
^= DF_1_NOKSYMS
;
10085 if (val
& DF_1_NOHDR
)
10090 if (val
& DF_1_EDITED
)
10092 printf (" EDITED");
10093 val
^= DF_1_EDITED
;
10095 if (val
& DF_1_NORELOC
)
10097 printf (" NORELOC");
10098 val
^= DF_1_NORELOC
;
10100 if (val
& DF_1_SYMINTPOSE
)
10102 printf (" SYMINTPOSE");
10103 val
^= DF_1_SYMINTPOSE
;
10105 if (val
& DF_1_GLOBAUDIT
)
10107 printf (" GLOBAUDIT");
10108 val
^= DF_1_GLOBAUDIT
;
10110 if (val
& DF_1_SINGLETON
)
10112 printf (" SINGLETON");
10113 val
^= DF_1_SINGLETON
;
10115 if (val
& DF_1_STUB
)
10120 if (val
& DF_1_PIE
)
10125 if (val
& DF_1_KMOD
)
10130 if (val
& DF_1_WEAKFILTER
)
10132 printf (" WEAKFILTER");
10133 val
^= DF_1_WEAKFILTER
;
10135 if (val
& DF_1_NOCOMMON
)
10137 printf (" NOCOMMON");
10138 val
^= DF_1_NOCOMMON
;
10141 printf (" %lx", val
);
10148 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10150 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10170 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10176 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10177 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10183 switch (entry
->d_tag
)
10186 printf (_("Shared library: [%s]"), name
);
10188 if (streq (name
, program_interpreter
))
10189 printf (_(" program interpreter"));
10193 printf (_("Library soname: [%s]"), name
);
10197 printf (_("Library rpath: [%s]"), name
);
10201 printf (_("Library runpath: [%s]"), name
);
10205 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10210 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10223 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10224 /* Fall through. */
10228 case DT_INIT_ARRAYSZ
:
10229 case DT_FINI_ARRAYSZ
:
10230 case DT_GNU_CONFLICTSZ
:
10231 case DT_GNU_LIBLISTSZ
:
10234 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10235 printf (_(" (bytes)\n"));
10240 case DT_VERNEEDNUM
:
10245 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10254 case DT_INIT_ARRAY
:
10255 case DT_FINI_ARRAY
:
10258 if (entry
->d_tag
== DT_USED
10259 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10261 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10265 printf (_("Not needed object: [%s]\n"), name
);
10270 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10276 /* The value of this entry is ignored. */
10281 case DT_GNU_PRELINKED
:
10285 time_t atime
= entry
->d_un
.d_val
;
10287 tmp
= gmtime (&atime
);
10288 /* PR 17533 file: 041-1244816-0.004. */
10290 printf (_("<corrupt time val: %lx"),
10291 (unsigned long) atime
);
10293 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10294 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10295 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10301 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10304 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10310 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10311 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10316 switch (filedata
->file_header
.e_machine
)
10319 case EM_MIPS_RS3_LE
:
10320 dynamic_section_mips_val (entry
);
10323 dynamic_section_parisc_val (entry
);
10326 dynamic_section_ia64_val (entry
);
10329 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10341 get_ver_flags (unsigned int flags
)
10343 static char buff
[128];
10350 if (flags
& VER_FLG_BASE
)
10351 strcat (buff
, "BASE");
10353 if (flags
& VER_FLG_WEAK
)
10355 if (flags
& VER_FLG_BASE
)
10356 strcat (buff
, " | ");
10358 strcat (buff
, "WEAK");
10361 if (flags
& VER_FLG_INFO
)
10363 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10364 strcat (buff
, " | ");
10366 strcat (buff
, "INFO");
10369 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10371 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10372 strcat (buff
, " | ");
10374 strcat (buff
, _("<unknown>"));
10380 /* Display the contents of the version sections. */
10383 process_version_sections (Filedata
* filedata
)
10385 Elf_Internal_Shdr
* section
;
10387 bfd_boolean found
= FALSE
;
10392 for (i
= 0, section
= filedata
->section_headers
;
10393 i
< filedata
->file_header
.e_shnum
;
10396 switch (section
->sh_type
)
10398 case SHT_GNU_verdef
:
10400 Elf_External_Verdef
* edefs
;
10407 printf (ngettext ("\nVersion definition section '%s' "
10408 "contains %u entry:\n",
10409 "\nVersion definition section '%s' "
10410 "contains %u entries:\n",
10412 printable_section_name (filedata
, section
),
10415 printf (_(" Addr: 0x"));
10416 printf_vma (section
->sh_addr
);
10417 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10418 (unsigned long) section
->sh_offset
, section
->sh_link
,
10419 printable_section_name_from_index (filedata
, section
->sh_link
));
10421 edefs
= (Elf_External_Verdef
*)
10422 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10423 _("version definition section"));
10426 endbuf
= (char *) edefs
+ section
->sh_size
;
10428 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10431 Elf_External_Verdef
* edef
;
10432 Elf_Internal_Verdef ent
;
10433 Elf_External_Verdaux
* eaux
;
10434 Elf_Internal_Verdaux aux
;
10435 unsigned long isum
;
10438 vstart
= ((char *) edefs
) + idx
;
10439 if (vstart
+ sizeof (*edef
) > endbuf
)
10442 edef
= (Elf_External_Verdef
*) vstart
;
10444 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10445 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10446 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10447 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10448 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10449 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10450 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10452 printf (_(" %#06lx: Rev: %d Flags: %s"),
10453 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10455 printf (_(" Index: %d Cnt: %d "),
10456 ent
.vd_ndx
, ent
.vd_cnt
);
10458 /* Check for overflow. */
10459 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10462 vstart
+= ent
.vd_aux
;
10464 if (vstart
+ sizeof (*eaux
) > endbuf
)
10466 eaux
= (Elf_External_Verdaux
*) vstart
;
10468 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10469 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10471 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10472 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10474 printf (_("Name index: %ld\n"), aux
.vda_name
);
10476 isum
= idx
+ ent
.vd_aux
;
10478 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10480 if (aux
.vda_next
< sizeof (*eaux
)
10481 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10483 warn (_("Invalid vda_next field of %lx\n"),
10488 /* Check for overflow. */
10489 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10492 isum
+= aux
.vda_next
;
10493 vstart
+= aux
.vda_next
;
10495 if (vstart
+ sizeof (*eaux
) > endbuf
)
10497 eaux
= (Elf_External_Verdaux
*) vstart
;
10499 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10500 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10502 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10503 printf (_(" %#06lx: Parent %d: %s\n"),
10504 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10506 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10507 isum
, j
, aux
.vda_name
);
10510 if (j
< ent
.vd_cnt
)
10511 printf (_(" Version def aux past end of section\n"));
10514 file: id:000001,src:000172+005151,op:splice,rep:2. */
10515 if (ent
.vd_next
< sizeof (*edef
)
10516 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10518 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10519 cnt
= section
->sh_info
;
10522 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10525 idx
+= ent
.vd_next
;
10528 if (cnt
< section
->sh_info
)
10529 printf (_(" Version definition past end of section\n"));
10535 case SHT_GNU_verneed
:
10537 Elf_External_Verneed
* eneed
;
10544 printf (ngettext ("\nVersion needs section '%s' "
10545 "contains %u entry:\n",
10546 "\nVersion needs section '%s' "
10547 "contains %u entries:\n",
10549 printable_section_name (filedata
, section
), section
->sh_info
);
10551 printf (_(" Addr: 0x"));
10552 printf_vma (section
->sh_addr
);
10553 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10554 (unsigned long) section
->sh_offset
, section
->sh_link
,
10555 printable_section_name_from_index (filedata
, section
->sh_link
));
10557 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10558 section
->sh_offset
, 1,
10560 _("Version Needs section"));
10563 endbuf
= (char *) eneed
+ section
->sh_size
;
10565 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10567 Elf_External_Verneed
* entry
;
10568 Elf_Internal_Verneed ent
;
10569 unsigned long isum
;
10573 vstart
= ((char *) eneed
) + idx
;
10574 if (vstart
+ sizeof (*entry
) > endbuf
)
10577 entry
= (Elf_External_Verneed
*) vstart
;
10579 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10580 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10581 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10582 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10583 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10585 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10587 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10588 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10590 printf (_(" File: %lx"), ent
.vn_file
);
10592 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10594 /* Check for overflow. */
10595 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10597 vstart
+= ent
.vn_aux
;
10599 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10601 Elf_External_Vernaux
* eaux
;
10602 Elf_Internal_Vernaux aux
;
10604 if (vstart
+ sizeof (*eaux
) > endbuf
)
10606 eaux
= (Elf_External_Vernaux
*) vstart
;
10608 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10609 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10610 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10611 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10612 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10614 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10615 printf (_(" %#06lx: Name: %s"),
10616 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10618 printf (_(" %#06lx: Name index: %lx"),
10619 isum
, aux
.vna_name
);
10621 printf (_(" Flags: %s Version: %d\n"),
10622 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10624 if (aux
.vna_next
< sizeof (*eaux
)
10625 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10627 warn (_("Invalid vna_next field of %lx\n"),
10632 /* Check for overflow. */
10633 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10635 isum
+= aux
.vna_next
;
10636 vstart
+= aux
.vna_next
;
10639 if (j
< ent
.vn_cnt
)
10640 warn (_("Missing Version Needs auxillary information\n"));
10642 if (ent
.vn_next
< sizeof (*entry
)
10643 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10645 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10646 cnt
= section
->sh_info
;
10649 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10651 idx
+= ent
.vn_next
;
10654 if (cnt
< section
->sh_info
)
10655 warn (_("Missing Version Needs information\n"));
10661 case SHT_GNU_versym
:
10663 Elf_Internal_Shdr
* link_section
;
10666 unsigned char * edata
;
10667 unsigned short * data
;
10669 Elf_Internal_Sym
* symbols
;
10670 Elf_Internal_Shdr
* string_sec
;
10671 unsigned long num_syms
;
10674 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10677 link_section
= filedata
->section_headers
+ section
->sh_link
;
10678 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10680 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10685 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10686 if (symbols
== NULL
)
10689 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10691 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10692 string_sec
->sh_size
,
10693 _("version string table"));
10700 printf (ngettext ("\nVersion symbols section '%s' "
10701 "contains %lu entry:\n",
10702 "\nVersion symbols section '%s' "
10703 "contains %lu entries:\n",
10705 printable_section_name (filedata
, section
), (unsigned long) total
);
10707 printf (_(" Addr: "));
10708 printf_vma (section
->sh_addr
);
10709 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10710 (unsigned long) section
->sh_offset
, section
->sh_link
,
10711 printable_section_name (filedata
, link_section
));
10713 off
= offset_from_vma (filedata
,
10714 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10715 total
* sizeof (short));
10716 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10718 _("version symbol data"));
10726 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10728 for (cnt
= total
; cnt
--;)
10729 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10734 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10738 char *invalid
= _("*invalid*");
10740 printf (" %03x:", cnt
);
10742 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10743 switch (data
[cnt
+ j
])
10746 fputs (_(" 0 (*local*) "), stdout
);
10750 fputs (_(" 1 (*global*) "), stdout
);
10754 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10755 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10757 /* If this index value is greater than the size of the symbols
10758 array, break to avoid an out-of-bounds read. */
10759 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10761 warn (_("invalid index into symbol array\n"));
10766 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10768 Elf_Internal_Verneed ivn
;
10769 unsigned long offset
;
10771 offset
= offset_from_vma
10772 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10773 sizeof (Elf_External_Verneed
));
10777 Elf_Internal_Vernaux ivna
;
10778 Elf_External_Verneed evn
;
10779 Elf_External_Vernaux evna
;
10780 unsigned long a_off
;
10782 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10783 _("version need")) == NULL
)
10786 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10787 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10789 a_off
= offset
+ ivn
.vn_aux
;
10793 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10794 1, _("version need aux (2)")) == NULL
)
10797 ivna
.vna_other
= 0;
10801 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10802 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10805 a_off
+= ivna
.vna_next
;
10807 while (ivna
.vna_other
!= data
[cnt
+ j
]
10808 && ivna
.vna_next
!= 0);
10810 if (ivna
.vna_other
== data
[cnt
+ j
])
10812 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10814 if (ivna
.vna_name
>= string_sec
->sh_size
)
10817 name
= strtab
+ ivna
.vna_name
;
10821 offset
+= ivn
.vn_next
;
10823 while (ivn
.vn_next
);
10826 if (data
[cnt
+ j
] != 0x8001
10827 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10829 Elf_Internal_Verdef ivd
;
10830 Elf_External_Verdef evd
;
10831 unsigned long offset
;
10833 offset
= offset_from_vma
10834 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10839 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10840 _("version def")) == NULL
)
10843 /* PR 17531: file: 046-1082287-0.004. */
10844 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10849 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10850 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10853 offset
+= ivd
.vd_next
;
10855 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10856 && ivd
.vd_next
!= 0);
10858 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10860 Elf_External_Verdaux evda
;
10861 Elf_Internal_Verdaux ivda
;
10863 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10865 if (get_data (&evda
, filedata
,
10866 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10868 _("version def aux")) == NULL
)
10871 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10873 if (ivda
.vda_name
>= string_sec
->sh_size
)
10875 else if (name
!= NULL
&& name
!= invalid
)
10876 name
= _("*both*");
10878 name
= strtab
+ ivda
.vda_name
;
10882 nn
+= printf ("(%s%-*s",
10884 12 - (int) strlen (name
),
10888 printf ("%*c", 18 - nn
, ' ');
10906 printf (_("\nNo version information found in this file.\n"));
10911 static const char *
10912 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10914 static char buff
[32];
10918 case STB_LOCAL
: return "LOCAL";
10919 case STB_GLOBAL
: return "GLOBAL";
10920 case STB_WEAK
: return "WEAK";
10922 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10923 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10925 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10927 if (binding
== STB_GNU_UNIQUE
10928 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10929 /* GNU is still using the default value 0. */
10930 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10932 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10935 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10940 static const char *
10941 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10943 static char buff
[32];
10947 case STT_NOTYPE
: return "NOTYPE";
10948 case STT_OBJECT
: return "OBJECT";
10949 case STT_FUNC
: return "FUNC";
10950 case STT_SECTION
: return "SECTION";
10951 case STT_FILE
: return "FILE";
10952 case STT_COMMON
: return "COMMON";
10953 case STT_TLS
: return "TLS";
10954 case STT_RELC
: return "RELC";
10955 case STT_SRELC
: return "SRELC";
10957 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10959 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10960 return "THUMB_FUNC";
10962 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10965 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10966 return "PARISC_MILLI";
10968 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10970 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10972 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10974 if (type
== STT_HP_OPAQUE
)
10975 return "HP_OPAQUE";
10976 if (type
== STT_HP_STUB
)
10980 if (type
== STT_GNU_IFUNC
10981 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10982 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10983 /* GNU is still using the default value 0. */
10984 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10987 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10990 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10995 static const char *
10996 get_symbol_visibility (unsigned int visibility
)
10998 switch (visibility
)
11000 case STV_DEFAULT
: return "DEFAULT";
11001 case STV_INTERNAL
: return "INTERNAL";
11002 case STV_HIDDEN
: return "HIDDEN";
11003 case STV_PROTECTED
: return "PROTECTED";
11005 error (_("Unrecognized visibility value: %u"), visibility
);
11006 return _("<unknown>");
11010 static const char *
11011 get_solaris_symbol_visibility (unsigned int visibility
)
11013 switch (visibility
)
11015 case 4: return "EXPORTED";
11016 case 5: return "SINGLETON";
11017 case 6: return "ELIMINATE";
11018 default: return get_symbol_visibility (visibility
);
11022 static const char *
11023 get_mips_symbol_other (unsigned int other
)
11027 case STO_OPTIONAL
: return "OPTIONAL";
11028 case STO_MIPS_PLT
: return "MIPS PLT";
11029 case STO_MIPS_PIC
: return "MIPS PIC";
11030 case STO_MICROMIPS
: return "MICROMIPS";
11031 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11032 case STO_MIPS16
: return "MIPS16";
11033 default: return NULL
;
11037 static const char *
11038 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11040 if (is_ia64_vms (filedata
))
11042 static char res
[32];
11046 /* Function types is for images and .STB files only. */
11047 switch (filedata
->file_header
.e_type
)
11051 switch (VMS_ST_FUNC_TYPE (other
))
11053 case VMS_SFT_CODE_ADDR
:
11054 strcat (res
, " CA");
11056 case VMS_SFT_SYMV_IDX
:
11057 strcat (res
, " VEC");
11060 strcat (res
, " FD");
11062 case VMS_SFT_RESERVE
:
11063 strcat (res
, " RSV");
11066 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11067 VMS_ST_FUNC_TYPE (other
));
11068 strcat (res
, " <unknown>");
11075 switch (VMS_ST_LINKAGE (other
))
11077 case VMS_STL_IGNORE
:
11078 strcat (res
, " IGN");
11080 case VMS_STL_RESERVE
:
11081 strcat (res
, " RSV");
11084 strcat (res
, " STD");
11087 strcat (res
, " LNK");
11090 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11091 VMS_ST_LINKAGE (other
));
11092 strcat (res
, " <unknown>");
11104 static const char *
11105 get_ppc64_symbol_other (unsigned int other
)
11107 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11110 other
>>= STO_PPC64_LOCAL_BIT
;
11113 static char buf
[32];
11115 other
= ppc64_decode_local_entry (other
);
11116 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11122 static const char *
11123 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11125 const char * result
= NULL
;
11126 static char buff
[32];
11131 switch (filedata
->file_header
.e_machine
)
11134 result
= get_mips_symbol_other (other
);
11137 result
= get_ia64_symbol_other (filedata
, other
);
11140 result
= get_ppc64_symbol_other (other
);
11150 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11154 static const char *
11155 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11157 static char buff
[32];
11161 case SHN_UNDEF
: return "UND";
11162 case SHN_ABS
: return "ABS";
11163 case SHN_COMMON
: return "COM";
11165 if (type
== SHN_IA_64_ANSI_COMMON
11166 && filedata
->file_header
.e_machine
== EM_IA_64
11167 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11169 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11170 || filedata
->file_header
.e_machine
== EM_L1OM
11171 || filedata
->file_header
.e_machine
== EM_K1OM
)
11172 && type
== SHN_X86_64_LCOMMON
)
11173 return "LARGE_COM";
11174 else if ((type
== SHN_MIPS_SCOMMON
11175 && filedata
->file_header
.e_machine
== EM_MIPS
)
11176 || (type
== SHN_TIC6X_SCOMMON
11177 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11179 else if (type
== SHN_MIPS_SUNDEFINED
11180 && filedata
->file_header
.e_machine
== EM_MIPS
)
11182 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11183 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11184 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11185 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11186 else if (type
>= SHN_LORESERVE
)
11187 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11188 else if (type
>= filedata
->file_header
.e_shnum
)
11189 sprintf (buff
, _("bad section index[%3d]"), type
);
11191 sprintf (buff
, "%3d", type
);
11199 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11201 unsigned char * e_data
;
11204 /* If the size_t type is smaller than the bfd_size_type, eg because
11205 you are building a 32-bit tool on a 64-bit host, then make sure
11206 that when (number) is cast to (size_t) no information is lost. */
11207 if (sizeof (size_t) < sizeof (bfd_size_type
)
11208 && (bfd_size_type
) ((size_t) number
) != number
)
11210 error (_("Size truncation prevents reading %s elements of size %u\n"),
11211 bfd_vmatoa ("u", number
), ent_size
);
11215 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11216 attempting to allocate memory when the read is bound to fail. */
11217 if (ent_size
* number
> filedata
->file_size
)
11219 error (_("Invalid number of dynamic entries: %s\n"),
11220 bfd_vmatoa ("u", number
));
11224 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11225 if (e_data
== NULL
)
11227 error (_("Out of memory reading %s dynamic entries\n"),
11228 bfd_vmatoa ("u", number
));
11232 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11234 error (_("Unable to read in %s bytes of dynamic data\n"),
11235 bfd_vmatoa ("u", number
* ent_size
));
11240 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11241 if (i_data
== NULL
)
11243 error (_("Out of memory allocating space for %s dynamic entries\n"),
11244 bfd_vmatoa ("u", number
));
11250 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11258 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11260 Elf_Internal_Sym
* psym
;
11263 n
= print_vma (si
, DEC_5
);
11265 fputs (&" "[n
], stdout
);
11266 printf (" %3lu: ", hn
);
11268 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11270 printf (_("<No info available for dynamic symbol number %lu>\n"),
11271 (unsigned long) si
);
11275 psym
= dynamic_symbols
+ si
;
11276 print_vma (psym
->st_value
, LONG_HEX
);
11278 print_vma (psym
->st_size
, DEC_5
);
11280 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11281 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11283 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11284 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11287 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11289 printf (" %-7s", get_symbol_visibility (vis
));
11290 /* Check to see if any other bits in the st_other field are set.
11291 Note - displaying this information disrupts the layout of the
11292 table being generated, but for the moment this case is very
11294 if (psym
->st_other
^ vis
)
11295 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11298 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11299 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11300 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11302 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11306 static const char *
11307 get_symbol_version_string (Filedata
* filedata
,
11308 bfd_boolean is_dynsym
,
11309 const char * strtab
,
11310 unsigned long int strtab_size
,
11312 Elf_Internal_Sym
* psym
,
11313 enum versioned_symbol_info
* sym_info
,
11314 unsigned short * vna_other
)
11316 unsigned char data
[2];
11317 unsigned short vers_data
;
11318 unsigned long offset
;
11319 unsigned short max_vd_ndx
;
11322 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11325 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11326 sizeof data
+ si
* sizeof (vers_data
));
11328 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11329 sizeof (data
), 1, _("version data")) == NULL
)
11332 vers_data
= byte_get (data
, 2);
11334 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11339 /* Usually we'd only see verdef for defined symbols, and verneed for
11340 undefined symbols. However, symbols defined by the linker in
11341 .dynbss for variables copied from a shared library in order to
11342 avoid text relocations are defined yet have verneed. We could
11343 use a heuristic to detect the special case, for example, check
11344 for verneed first on symbols defined in SHT_NOBITS sections, but
11345 it is simpler and more reliable to just look for both verdef and
11346 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11348 if (psym
->st_shndx
!= SHN_UNDEF
11349 && vers_data
!= 0x8001
11350 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11352 Elf_Internal_Verdef ivd
;
11353 Elf_Internal_Verdaux ivda
;
11354 Elf_External_Verdaux evda
;
11357 off
= offset_from_vma (filedata
,
11358 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11359 sizeof (Elf_External_Verdef
));
11363 Elf_External_Verdef evd
;
11365 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11366 _("version def")) == NULL
)
11375 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11376 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11377 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11378 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11381 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11382 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11384 off
+= ivd
.vd_next
;
11386 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11388 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11390 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11393 off
-= ivd
.vd_next
;
11396 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11397 _("version def aux")) != NULL
)
11399 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11401 if (psym
->st_name
!= ivda
.vda_name
)
11403 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11404 ? symbol_hidden
: symbol_public
);
11405 return (ivda
.vda_name
< strtab_size
11406 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11412 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11414 Elf_External_Verneed evn
;
11415 Elf_Internal_Verneed ivn
;
11416 Elf_Internal_Vernaux ivna
;
11418 offset
= offset_from_vma (filedata
,
11419 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11423 unsigned long vna_off
;
11425 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11426 _("version need")) == NULL
)
11429 ivna
.vna_other
= 0;
11434 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11435 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11437 vna_off
= offset
+ ivn
.vn_aux
;
11441 Elf_External_Vernaux evna
;
11443 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11444 _("version need aux (3)")) == NULL
)
11447 ivna
.vna_other
= 0;
11452 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11453 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11454 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11457 vna_off
+= ivna
.vna_next
;
11459 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11461 if (ivna
.vna_other
== vers_data
)
11464 offset
+= ivn
.vn_next
;
11466 while (ivn
.vn_next
!= 0);
11468 if (ivna
.vna_other
== vers_data
)
11470 *sym_info
= symbol_undefined
;
11471 *vna_other
= ivna
.vna_other
;
11472 return (ivna
.vna_name
< strtab_size
11473 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11475 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11476 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11477 return _("<corrupt>");
11482 /* Dump the symbol table. */
11484 process_symbol_table (Filedata
* filedata
)
11486 Elf_Internal_Shdr
* section
;
11487 bfd_size_type nbuckets
= 0;
11488 bfd_size_type nchains
= 0;
11489 bfd_vma
* buckets
= NULL
;
11490 bfd_vma
* chains
= NULL
;
11491 bfd_vma ngnubuckets
= 0;
11492 bfd_vma
* gnubuckets
= NULL
;
11493 bfd_vma
* gnuchains
= NULL
;
11494 bfd_vma gnusymidx
= 0;
11495 bfd_size_type ngnuchains
= 0;
11497 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11500 if (dynamic_info
[DT_HASH
]
11502 || (do_using_dynamic
11504 && dynamic_strings
!= NULL
)))
11506 unsigned char nb
[8];
11507 unsigned char nc
[8];
11508 unsigned int hash_ent_size
= 4;
11510 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11511 || filedata
->file_header
.e_machine
== EM_S390
11512 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11513 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11516 if (fseek (filedata
->handle
,
11517 (archive_file_offset
11518 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11519 sizeof nb
+ sizeof nc
)),
11522 error (_("Unable to seek to start of dynamic information\n"));
11526 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11528 error (_("Failed to read in number of buckets\n"));
11532 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11534 error (_("Failed to read in number of chains\n"));
11538 nbuckets
= byte_get (nb
, hash_ent_size
);
11539 nchains
= byte_get (nc
, hash_ent_size
);
11541 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11542 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11545 if (buckets
== NULL
|| chains
== NULL
)
11547 if (do_using_dynamic
)
11558 if (dynamic_info_DT_GNU_HASH
11560 || (do_using_dynamic
11562 && dynamic_strings
!= NULL
)))
11564 unsigned char nb
[16];
11565 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11566 bfd_vma buckets_vma
;
11568 if (fseek (filedata
->handle
,
11569 (archive_file_offset
11570 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11574 error (_("Unable to seek to start of dynamic information\n"));
11578 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11580 error (_("Failed to read in number of buckets\n"));
11584 ngnubuckets
= byte_get (nb
, 4);
11585 gnusymidx
= byte_get (nb
+ 4, 4);
11586 bitmaskwords
= byte_get (nb
+ 8, 4);
11587 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11589 buckets_vma
+= bitmaskwords
* 4;
11591 buckets_vma
+= bitmaskwords
* 8;
11593 if (fseek (filedata
->handle
,
11594 (archive_file_offset
11595 + offset_from_vma (filedata
, buckets_vma
, 4)),
11598 error (_("Unable to seek to start of dynamic information\n"));
11602 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11604 if (gnubuckets
== NULL
)
11607 for (i
= 0; i
< ngnubuckets
; i
++)
11608 if (gnubuckets
[i
] != 0)
11610 if (gnubuckets
[i
] < gnusymidx
)
11613 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11614 maxchain
= gnubuckets
[i
];
11617 if (maxchain
== 0xffffffff)
11620 maxchain
-= gnusymidx
;
11622 if (fseek (filedata
->handle
,
11623 (archive_file_offset
11624 + offset_from_vma (filedata
, buckets_vma
11625 + 4 * (ngnubuckets
+ maxchain
), 4)),
11628 error (_("Unable to seek to start of dynamic information\n"));
11634 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11636 error (_("Failed to determine last chain length\n"));
11640 if (maxchain
+ 1 == 0)
11645 while ((byte_get (nb
, 4) & 1) == 0);
11647 if (fseek (filedata
->handle
,
11648 (archive_file_offset
11649 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11652 error (_("Unable to seek to start of dynamic information\n"));
11656 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11657 ngnuchains
= maxchain
;
11660 if (gnuchains
== NULL
)
11665 if (do_using_dynamic
)
11670 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11672 && do_using_dynamic
11673 && dynamic_strings
!= NULL
11674 && dynamic_symbols
!= NULL
)
11678 if (dynamic_info
[DT_HASH
])
11683 printf (_("\nSymbol table for image:\n"));
11685 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11687 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11689 visited
= xcmalloc (nchains
, 1);
11690 memset (visited
, 0, nchains
);
11691 for (hn
= 0; hn
< nbuckets
; hn
++)
11693 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11695 print_dynamic_symbol (filedata
, si
, hn
);
11696 if (si
>= nchains
|| visited
[si
])
11698 error (_("histogram chain is corrupt\n"));
11707 if (dynamic_info_DT_GNU_HASH
)
11709 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11711 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11713 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11715 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11716 if (gnubuckets
[hn
] != 0)
11718 bfd_vma si
= gnubuckets
[hn
];
11719 bfd_vma off
= si
- gnusymidx
;
11723 print_dynamic_symbol (filedata
, si
, hn
);
11726 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11730 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11731 && filedata
->section_headers
!= NULL
)
11735 for (i
= 0, section
= filedata
->section_headers
;
11736 i
< filedata
->file_header
.e_shnum
;
11740 char * strtab
= NULL
;
11741 unsigned long int strtab_size
= 0;
11742 Elf_Internal_Sym
* symtab
;
11743 Elf_Internal_Sym
* psym
;
11744 unsigned long num_syms
;
11746 if ((section
->sh_type
!= SHT_SYMTAB
11747 && section
->sh_type
!= SHT_DYNSYM
)
11749 && section
->sh_type
== SHT_SYMTAB
))
11752 if (section
->sh_entsize
== 0)
11754 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11755 printable_section_name (filedata
, section
));
11759 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11760 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11761 "\nSymbol table '%s' contains %lu entries:\n",
11763 printable_section_name (filedata
, section
),
11767 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11769 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11771 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11772 if (symtab
== NULL
)
11775 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11777 strtab
= filedata
->string_table
;
11778 strtab_size
= filedata
->string_table_length
;
11780 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11782 Elf_Internal_Shdr
* string_sec
;
11784 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11786 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11787 1, string_sec
->sh_size
,
11788 _("string table"));
11789 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11792 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11794 const char *version_string
;
11795 enum versioned_symbol_info sym_info
;
11796 unsigned short vna_other
;
11798 printf ("%6d: ", si
);
11799 print_vma (psym
->st_value
, LONG_HEX
);
11801 print_vma (psym
->st_size
, DEC_5
);
11802 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11803 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11804 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11805 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11808 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11810 printf (" %-7s", get_symbol_visibility (vis
));
11811 /* Check to see if any other bits in the st_other field are set.
11812 Note - displaying this information disrupts the layout of the
11813 table being generated, but for the moment this case is very rare. */
11814 if (psym
->st_other
^ vis
)
11815 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11817 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11818 print_symbol (25, psym
->st_name
< strtab_size
11819 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11822 = get_symbol_version_string (filedata
,
11823 section
->sh_type
== SHT_DYNSYM
,
11824 strtab
, strtab_size
, si
,
11825 psym
, &sym_info
, &vna_other
);
11826 if (version_string
)
11828 if (sym_info
== symbol_undefined
)
11829 printf ("@%s (%d)", version_string
, vna_other
);
11831 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11837 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11838 && si
>= section
->sh_info
11839 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11840 && filedata
->file_header
.e_machine
!= EM_MIPS
11841 /* Solaris binaries have been found to violate this requirement as
11842 well. Not sure if this is a bug or an ABI requirement. */
11843 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11844 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11845 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11849 if (strtab
!= filedata
->string_table
)
11855 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11857 if (do_histogram
&& buckets
!= NULL
)
11859 unsigned long * lengths
;
11860 unsigned long * counts
;
11863 unsigned long maxlength
= 0;
11864 unsigned long nzero_counts
= 0;
11865 unsigned long nsyms
= 0;
11868 printf (ngettext ("\nHistogram for bucket list length "
11869 "(total of %lu bucket):\n",
11870 "\nHistogram for bucket list length "
11871 "(total of %lu buckets):\n",
11872 (unsigned long) nbuckets
),
11873 (unsigned long) nbuckets
);
11875 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11876 if (lengths
== NULL
)
11878 error (_("Out of memory allocating space for histogram buckets\n"));
11881 visited
= xcmalloc (nchains
, 1);
11882 memset (visited
, 0, nchains
);
11884 printf (_(" Length Number %% of total Coverage\n"));
11885 for (hn
= 0; hn
< nbuckets
; ++hn
)
11887 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11890 if (maxlength
< ++lengths
[hn
])
11892 if (si
>= nchains
|| visited
[si
])
11894 error (_("histogram chain is corrupt\n"));
11902 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11903 if (counts
== NULL
)
11906 error (_("Out of memory allocating space for histogram counts\n"));
11910 for (hn
= 0; hn
< nbuckets
; ++hn
)
11911 ++counts
[lengths
[hn
]];
11916 printf (" 0 %-10lu (%5.1f%%)\n",
11917 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11918 for (i
= 1; i
<= maxlength
; ++i
)
11920 nzero_counts
+= counts
[i
] * i
;
11921 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11922 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11923 (nzero_counts
* 100.0) / nsyms
);
11931 if (buckets
!= NULL
)
11937 if (do_histogram
&& gnubuckets
!= NULL
)
11939 unsigned long * lengths
;
11940 unsigned long * counts
;
11942 unsigned long maxlength
= 0;
11943 unsigned long nzero_counts
= 0;
11944 unsigned long nsyms
= 0;
11946 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11947 "(total of %lu bucket):\n",
11948 "\nHistogram for `.gnu.hash' bucket list length "
11949 "(total of %lu buckets):\n",
11950 (unsigned long) ngnubuckets
),
11951 (unsigned long) ngnubuckets
);
11953 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11954 if (lengths
== NULL
)
11956 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11960 printf (_(" Length Number %% of total Coverage\n"));
11962 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11963 if (gnubuckets
[hn
] != 0)
11965 bfd_vma off
, length
= 1;
11967 for (off
= gnubuckets
[hn
] - gnusymidx
;
11968 /* PR 17531 file: 010-77222-0.004. */
11969 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11972 lengths
[hn
] = length
;
11973 if (length
> maxlength
)
11974 maxlength
= length
;
11978 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11979 if (counts
== NULL
)
11982 error (_("Out of memory allocating space for gnu histogram counts\n"));
11986 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11987 ++counts
[lengths
[hn
]];
11989 if (ngnubuckets
> 0)
11992 printf (" 0 %-10lu (%5.1f%%)\n",
11993 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11994 for (j
= 1; j
<= maxlength
; ++j
)
11996 nzero_counts
+= counts
[j
] * j
;
11997 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11998 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11999 (nzero_counts
* 100.0) / nsyms
);
12013 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12017 if (dynamic_syminfo
== NULL
12019 /* No syminfo, this is ok. */
12022 /* There better should be a dynamic symbol section. */
12023 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12027 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12028 "contains %d entry:\n",
12029 "\nDynamic info segment at offset 0x%lx "
12030 "contains %d entries:\n",
12031 dynamic_syminfo_nent
),
12032 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12034 printf (_(" Num: Name BoundTo Flags\n"));
12035 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12037 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12039 printf ("%4d: ", i
);
12040 if (i
>= num_dynamic_syms
)
12041 printf (_("<corrupt index>"));
12042 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12043 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12045 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12048 switch (dynamic_syminfo
[i
].si_boundto
)
12050 case SYMINFO_BT_SELF
:
12051 fputs ("SELF ", stdout
);
12053 case SYMINFO_BT_PARENT
:
12054 fputs ("PARENT ", stdout
);
12057 if (dynamic_syminfo
[i
].si_boundto
> 0
12058 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12059 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12061 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12065 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12069 if (flags
& SYMINFO_FLG_DIRECT
)
12070 printf (" DIRECT");
12071 if (flags
& SYMINFO_FLG_PASSTHRU
)
12072 printf (" PASSTHRU");
12073 if (flags
& SYMINFO_FLG_COPY
)
12075 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12076 printf (" LAZYLOAD");
12084 #define IN_RANGE(START,END,ADDR,OFF) \
12085 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12087 /* Check to see if the given reloc needs to be handled in a target specific
12088 manner. If so then process the reloc and return TRUE otherwise return
12091 If called with reloc == NULL, then this is a signal that reloc processing
12092 for the current section has finished, and any saved state should be
12096 target_specific_reloc_handling (Filedata
* filedata
,
12097 Elf_Internal_Rela
* reloc
,
12098 unsigned char * start
,
12099 unsigned char * end
,
12100 Elf_Internal_Sym
* symtab
,
12101 unsigned long num_syms
)
12103 unsigned int reloc_type
= 0;
12104 unsigned long sym_index
= 0;
12108 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12109 sym_index
= get_reloc_symindex (reloc
->r_info
);
12112 switch (filedata
->file_header
.e_machine
)
12115 case EM_MSP430_OLD
:
12117 static Elf_Internal_Sym
* saved_sym
= NULL
;
12125 switch (reloc_type
)
12127 case 10: /* R_MSP430_SYM_DIFF */
12128 if (uses_msp430x_relocs (filedata
))
12130 /* Fall through. */
12131 case 21: /* R_MSP430X_SYM_DIFF */
12133 if (sym_index
>= num_syms
)
12134 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12137 saved_sym
= symtab
+ sym_index
;
12140 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12141 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12142 goto handle_sym_diff
;
12144 case 5: /* R_MSP430_16_BYTE */
12145 case 9: /* R_MSP430_8 */
12146 if (uses_msp430x_relocs (filedata
))
12148 goto handle_sym_diff
;
12150 case 2: /* R_MSP430_ABS16 */
12151 case 15: /* R_MSP430X_ABS16 */
12152 if (! uses_msp430x_relocs (filedata
))
12154 goto handle_sym_diff
;
12157 if (saved_sym
!= NULL
)
12159 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12162 if (sym_index
>= num_syms
)
12163 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12167 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12168 - saved_sym
->st_value
);
12170 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12171 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12174 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12175 (long) reloc
->r_offset
);
12184 if (saved_sym
!= NULL
)
12185 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12192 case EM_CYGNUS_MN10300
:
12194 static Elf_Internal_Sym
* saved_sym
= NULL
;
12202 switch (reloc_type
)
12204 case 34: /* R_MN10300_ALIGN */
12206 case 33: /* R_MN10300_SYM_DIFF */
12207 if (sym_index
>= num_syms
)
12208 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12211 saved_sym
= symtab
+ sym_index
;
12214 case 1: /* R_MN10300_32 */
12215 case 2: /* R_MN10300_16 */
12216 if (saved_sym
!= NULL
)
12218 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12221 if (sym_index
>= num_syms
)
12222 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12226 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12227 - saved_sym
->st_value
);
12229 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12230 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12232 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12233 (long) reloc
->r_offset
);
12241 if (saved_sym
!= NULL
)
12242 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12250 static bfd_vma saved_sym1
= 0;
12251 static bfd_vma saved_sym2
= 0;
12252 static bfd_vma value
;
12256 saved_sym1
= saved_sym2
= 0;
12260 switch (reloc_type
)
12262 case 0x80: /* R_RL78_SYM. */
12263 saved_sym1
= saved_sym2
;
12264 if (sym_index
>= num_syms
)
12265 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12269 saved_sym2
= symtab
[sym_index
].st_value
;
12270 saved_sym2
+= reloc
->r_addend
;
12274 case 0x83: /* R_RL78_OPsub. */
12275 value
= saved_sym1
- saved_sym2
;
12276 saved_sym2
= saved_sym1
= 0;
12280 case 0x41: /* R_RL78_ABS32. */
12281 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12282 byte_put (start
+ reloc
->r_offset
, value
, 4);
12284 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12285 (long) reloc
->r_offset
);
12289 case 0x43: /* R_RL78_ABS16. */
12290 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12291 byte_put (start
+ reloc
->r_offset
, value
, 2);
12293 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12294 (long) reloc
->r_offset
);
12308 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12309 DWARF debug sections. This is a target specific test. Note - we do not
12310 go through the whole including-target-headers-multiple-times route, (as
12311 we have already done with <elf/h8.h>) because this would become very
12312 messy and even then this function would have to contain target specific
12313 information (the names of the relocs instead of their numeric values).
12314 FIXME: This is not the correct way to solve this problem. The proper way
12315 is to have target specific reloc sizing and typing functions created by
12316 the reloc-macros.h header, in the same way that it already creates the
12317 reloc naming functions. */
12320 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12322 /* Please keep this table alpha-sorted for ease of visual lookup. */
12323 switch (filedata
->file_header
.e_machine
)
12327 return reloc_type
== 1; /* R_386_32. */
12329 return reloc_type
== 1; /* R_68K_32. */
12331 return reloc_type
== 1; /* R_860_32. */
12333 return reloc_type
== 2; /* R_960_32. */
12335 return (reloc_type
== 258
12336 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12337 case EM_ADAPTEVA_EPIPHANY
:
12338 return reloc_type
== 3;
12340 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12342 return reloc_type
== 1; /* R_ARC_32. */
12343 case EM_ARC_COMPACT
:
12344 case EM_ARC_COMPACT2
:
12345 return reloc_type
== 4; /* R_ARC_32. */
12347 return reloc_type
== 2; /* R_ARM_ABS32 */
12350 return reloc_type
== 1;
12352 return reloc_type
== 0x12; /* R_byte4_data. */
12354 return reloc_type
== 3; /* R_CRIS_32. */
12356 return reloc_type
== 3; /* R_CR16_NUM32. */
12358 return reloc_type
== 15; /* R_CRX_NUM32. */
12360 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12361 case EM_CYGNUS_FRV
:
12362 return reloc_type
== 1;
12363 case EM_CYGNUS_D10V
:
12365 return reloc_type
== 6; /* R_D10V_32. */
12366 case EM_CYGNUS_D30V
:
12368 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12370 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12371 case EM_CYGNUS_FR30
:
12373 return reloc_type
== 3; /* R_FR30_32. */
12375 return reloc_type
== 1; /* R_FT32_32. */
12379 return reloc_type
== 1; /* R_H8_DIR32. */
12381 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12382 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12383 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12384 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12387 return reloc_type
== 2; /* R_IP2K_32. */
12389 return reloc_type
== 2; /* R_IQ2000_32. */
12390 case EM_LATTICEMICO32
:
12391 return reloc_type
== 3; /* R_LM32_32. */
12394 return reloc_type
== 3; /* R_M32C_32. */
12396 return reloc_type
== 34; /* R_M32R_32_RELA. */
12399 return reloc_type
== 6; /* R_M68HC11_32. */
12401 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12402 reloc_type
== 6; /* R_S12Z_CW32. */
12404 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12405 case EM_CYGNUS_MEP
:
12406 return reloc_type
== 4; /* R_MEP_32. */
12408 return reloc_type
== 2; /* R_METAG_ADDR32. */
12409 case EM_MICROBLAZE
:
12410 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12412 return reloc_type
== 2; /* R_MIPS_32. */
12414 return reloc_type
== 4; /* R_MMIX_32. */
12415 case EM_CYGNUS_MN10200
:
12417 return reloc_type
== 1; /* R_MN10200_32. */
12418 case EM_CYGNUS_MN10300
:
12420 return reloc_type
== 1; /* R_MN10300_32. */
12422 return reloc_type
== 1; /* R_MOXIE_32. */
12423 case EM_MSP430_OLD
:
12425 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12427 return reloc_type
== 2; /* R_MT_32. */
12429 return reloc_type
== 20; /* R_NDS32_RELA. */
12430 case EM_ALTERA_NIOS2
:
12431 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12433 return reloc_type
== 1; /* R_NIOS_32. */
12435 return reloc_type
== 1; /* R_OR1K_32. */
12437 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12438 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12439 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12442 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12444 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12446 return reloc_type
== 1; /* R_PPC_ADDR32. */
12448 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12450 return reloc_type
== 1; /* R_RISCV_32. */
12452 return reloc_type
== 1; /* R_RL78_DIR32. */
12454 return reloc_type
== 1; /* R_RX_DIR32. */
12456 return reloc_type
== 1; /* R_I370_ADDR31. */
12459 return reloc_type
== 4; /* R_S390_32. */
12461 return reloc_type
== 8; /* R_SCORE_ABS32. */
12463 return reloc_type
== 1; /* R_SH_DIR32. */
12464 case EM_SPARC32PLUS
:
12467 return reloc_type
== 3 /* R_SPARC_32. */
12468 || reloc_type
== 23; /* R_SPARC_UA32. */
12470 return reloc_type
== 6; /* R_SPU_ADDR32 */
12472 return reloc_type
== 1; /* R_C6000_ABS32. */
12474 return reloc_type
== 2; /* R_TILEGX_32. */
12476 return reloc_type
== 1; /* R_TILEPRO_32. */
12477 case EM_CYGNUS_V850
:
12479 return reloc_type
== 6; /* R_V850_ABS32. */
12481 return reloc_type
== 0x33; /* R_V810_WORD. */
12483 return reloc_type
== 1; /* R_VAX_32. */
12485 return reloc_type
== 3; /* R_VISIUM_32. */
12486 case EM_WEBASSEMBLY
:
12487 return reloc_type
== 1; /* R_WASM32_32. */
12491 return reloc_type
== 10; /* R_X86_64_32. */
12494 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12496 return reloc_type
== 4; /* R_XGATE_32. */
12498 return reloc_type
== 1; /* R_XSTROMY16_32. */
12499 case EM_XTENSA_OLD
:
12501 return reloc_type
== 1; /* R_XTENSA_32. */
12504 static unsigned int prev_warn
= 0;
12506 /* Avoid repeating the same warning multiple times. */
12507 if (prev_warn
!= filedata
->file_header
.e_machine
)
12508 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12509 filedata
->file_header
.e_machine
);
12510 prev_warn
= filedata
->file_header
.e_machine
;
12516 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12517 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12520 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12522 switch (filedata
->file_header
.e_machine
)
12523 /* Please keep this table alpha-sorted for ease of visual lookup. */
12527 return reloc_type
== 2; /* R_386_PC32. */
12529 return reloc_type
== 4; /* R_68K_PC32. */
12531 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12532 case EM_ADAPTEVA_EPIPHANY
:
12533 return reloc_type
== 6;
12535 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12536 case EM_ARC_COMPACT
:
12537 case EM_ARC_COMPACT2
:
12538 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12540 return reloc_type
== 3; /* R_ARM_REL32 */
12543 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12544 case EM_MICROBLAZE
:
12545 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12547 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12549 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12551 return reloc_type
== 26; /* R_PPC_REL32. */
12553 return reloc_type
== 26; /* R_PPC64_REL32. */
12555 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12558 return reloc_type
== 5; /* R_390_PC32. */
12560 return reloc_type
== 2; /* R_SH_REL32. */
12561 case EM_SPARC32PLUS
:
12564 return reloc_type
== 6; /* R_SPARC_DISP32. */
12566 return reloc_type
== 13; /* R_SPU_REL32. */
12568 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12570 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12572 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12576 return reloc_type
== 2; /* R_X86_64_PC32. */
12577 case EM_XTENSA_OLD
:
12579 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12581 /* Do not abort or issue an error message here. Not all targets use
12582 pc-relative 32-bit relocs in their DWARF debug information and we
12583 have already tested for target coverage in is_32bit_abs_reloc. A
12584 more helpful warning message will be generated by apply_relocations
12585 anyway, so just return. */
12590 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12591 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12594 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12596 switch (filedata
->file_header
.e_machine
)
12599 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12601 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12603 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12604 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12606 return reloc_type
== 80; /* R_PARISC_DIR64. */
12608 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12610 return reloc_type
== 2; /* R_RISCV_64. */
12611 case EM_SPARC32PLUS
:
12614 return reloc_type
== 32 /* R_SPARC_64. */
12615 || reloc_type
== 54; /* R_SPARC_UA64. */
12619 return reloc_type
== 1; /* R_X86_64_64. */
12622 return reloc_type
== 22; /* R_S390_64. */
12624 return reloc_type
== 1; /* R_TILEGX_64. */
12626 return reloc_type
== 18; /* R_MIPS_64. */
12632 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12633 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12636 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12638 switch (filedata
->file_header
.e_machine
)
12641 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12643 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12645 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12646 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12648 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12650 return reloc_type
== 44; /* R_PPC64_REL64. */
12651 case EM_SPARC32PLUS
:
12654 return reloc_type
== 46; /* R_SPARC_DISP64. */
12658 return reloc_type
== 24; /* R_X86_64_PC64. */
12661 return reloc_type
== 23; /* R_S390_PC64. */
12663 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12669 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12670 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12673 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12675 switch (filedata
->file_header
.e_machine
)
12677 case EM_CYGNUS_MN10200
:
12679 return reloc_type
== 4; /* R_MN10200_24. */
12681 return reloc_type
== 5; /* R_FT32_20. */
12687 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12688 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12691 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12693 /* Please keep this table alpha-sorted for ease of visual lookup. */
12694 switch (filedata
->file_header
.e_machine
)
12697 case EM_ARC_COMPACT
:
12698 case EM_ARC_COMPACT2
:
12699 return reloc_type
== 2; /* R_ARC_16. */
12700 case EM_ADAPTEVA_EPIPHANY
:
12701 return reloc_type
== 5;
12704 return reloc_type
== 4; /* R_AVR_16. */
12705 case EM_CYGNUS_D10V
:
12707 return reloc_type
== 3; /* R_D10V_16. */
12709 return reloc_type
== 2; /* R_FT32_16. */
12713 return reloc_type
== R_H8_DIR16
;
12716 return reloc_type
== 1; /* R_IP2K_16. */
12719 return reloc_type
== 1; /* R_M32C_16 */
12720 case EM_CYGNUS_MN10200
:
12722 return reloc_type
== 2; /* R_MN10200_16. */
12723 case EM_CYGNUS_MN10300
:
12725 return reloc_type
== 2; /* R_MN10300_16. */
12727 if (uses_msp430x_relocs (filedata
))
12728 return reloc_type
== 2; /* R_MSP430_ABS16. */
12729 /* Fall through. */
12730 case EM_MSP430_OLD
:
12731 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12733 return reloc_type
== 19; /* R_NDS32_RELA. */
12734 case EM_ALTERA_NIOS2
:
12735 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12737 return reloc_type
== 9; /* R_NIOS_16. */
12739 return reloc_type
== 2; /* R_OR1K_16. */
12741 return reloc_type
== 55; /* R_RISCV_SET16. */
12743 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12745 return reloc_type
== 2; /* R_C6000_ABS16. */
12747 return reloc_type
== 2; /* R_VISIUM_16. */
12750 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12752 return reloc_type
== 3; /* R_XGATE_16. */
12758 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12759 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12762 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12764 switch (filedata
->file_header
.e_machine
)
12767 return reloc_type
== 54; /* R_RISCV_SET8. */
12773 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12774 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12777 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12779 switch (filedata
->file_header
.e_machine
)
12782 return reloc_type
== 53; /* R_RISCV_SET6. */
12788 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12789 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12792 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12794 /* Please keep this table alpha-sorted for ease of visual lookup. */
12795 switch (filedata
->file_header
.e_machine
)
12798 return reloc_type
== 35; /* R_RISCV_ADD32. */
12804 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12805 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12808 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12810 /* Please keep this table alpha-sorted for ease of visual lookup. */
12811 switch (filedata
->file_header
.e_machine
)
12814 return reloc_type
== 39; /* R_RISCV_SUB32. */
12820 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12821 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12824 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12826 /* Please keep this table alpha-sorted for ease of visual lookup. */
12827 switch (filedata
->file_header
.e_machine
)
12830 return reloc_type
== 36; /* R_RISCV_ADD64. */
12836 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12837 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12840 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12842 /* Please keep this table alpha-sorted for ease of visual lookup. */
12843 switch (filedata
->file_header
.e_machine
)
12846 return reloc_type
== 40; /* R_RISCV_SUB64. */
12852 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12853 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12856 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12858 /* Please keep this table alpha-sorted for ease of visual lookup. */
12859 switch (filedata
->file_header
.e_machine
)
12862 return reloc_type
== 34; /* R_RISCV_ADD16. */
12868 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12869 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12872 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12874 /* Please keep this table alpha-sorted for ease of visual lookup. */
12875 switch (filedata
->file_header
.e_machine
)
12878 return reloc_type
== 38; /* R_RISCV_SUB16. */
12884 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12885 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12888 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12890 /* Please keep this table alpha-sorted for ease of visual lookup. */
12891 switch (filedata
->file_header
.e_machine
)
12894 return reloc_type
== 33; /* R_RISCV_ADD8. */
12900 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12901 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12904 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12906 /* Please keep this table alpha-sorted for ease of visual lookup. */
12907 switch (filedata
->file_header
.e_machine
)
12910 return reloc_type
== 37; /* R_RISCV_SUB8. */
12916 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12917 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12920 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12922 switch (filedata
->file_header
.e_machine
)
12925 return reloc_type
== 52; /* R_RISCV_SUB6. */
12931 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12932 relocation entries (possibly formerly used for SHT_GROUP sections). */
12935 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12937 switch (filedata
->file_header
.e_machine
)
12939 case EM_386
: /* R_386_NONE. */
12940 case EM_68K
: /* R_68K_NONE. */
12941 case EM_ADAPTEVA_EPIPHANY
:
12942 case EM_ALPHA
: /* R_ALPHA_NONE. */
12943 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12944 case EM_ARC
: /* R_ARC_NONE. */
12945 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12946 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12947 case EM_ARM
: /* R_ARM_NONE. */
12948 case EM_C166
: /* R_XC16X_NONE. */
12949 case EM_CRIS
: /* R_CRIS_NONE. */
12950 case EM_FT32
: /* R_FT32_NONE. */
12951 case EM_IA_64
: /* R_IA64_NONE. */
12952 case EM_K1OM
: /* R_X86_64_NONE. */
12953 case EM_L1OM
: /* R_X86_64_NONE. */
12954 case EM_M32R
: /* R_M32R_NONE. */
12955 case EM_MIPS
: /* R_MIPS_NONE. */
12956 case EM_MN10300
: /* R_MN10300_NONE. */
12957 case EM_MOXIE
: /* R_MOXIE_NONE. */
12958 case EM_NIOS32
: /* R_NIOS_NONE. */
12959 case EM_OR1K
: /* R_OR1K_NONE. */
12960 case EM_PARISC
: /* R_PARISC_NONE. */
12961 case EM_PPC64
: /* R_PPC64_NONE. */
12962 case EM_PPC
: /* R_PPC_NONE. */
12963 case EM_RISCV
: /* R_RISCV_NONE. */
12964 case EM_S390
: /* R_390_NONE. */
12966 case EM_SH
: /* R_SH_NONE. */
12967 case EM_SPARC32PLUS
:
12968 case EM_SPARC
: /* R_SPARC_NONE. */
12970 case EM_TILEGX
: /* R_TILEGX_NONE. */
12971 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12972 case EM_TI_C6000
:/* R_C6000_NONE. */
12973 case EM_X86_64
: /* R_X86_64_NONE. */
12975 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12976 return reloc_type
== 0;
12979 return reloc_type
== 0 || reloc_type
== 256;
12982 return (reloc_type
== 0 /* R_AVR_NONE. */
12983 || reloc_type
== 30 /* R_AVR_DIFF8. */
12984 || reloc_type
== 31 /* R_AVR_DIFF16. */
12985 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12987 return reloc_type
== 3; /* R_METAG_NONE. */
12989 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12990 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12991 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12992 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12993 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12995 return (reloc_type
== 0 /* R_PRU_NONE. */
12996 || reloc_type
== 65 /* R_PRU_DIFF8. */
12997 || reloc_type
== 66 /* R_PRU_DIFF16. */
12998 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12999 case EM_XTENSA_OLD
:
13001 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13002 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13003 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13004 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13009 /* Returns TRUE if there is a relocation against
13010 section NAME at OFFSET bytes. */
13013 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13015 Elf_Internal_Rela
* relocs
;
13016 Elf_Internal_Rela
* rp
;
13018 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13021 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13023 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13024 if (rp
->r_offset
== offset
)
13030 /* Apply relocations to a section.
13031 Returns TRUE upon success, FALSE otherwise.
13032 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13033 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13034 will be set to the number of relocs loaded.
13036 Note: So far support has been added only for those relocations
13037 which can be found in debug sections. FIXME: Add support for
13038 more relocations ? */
13041 apply_relocations (Filedata
* filedata
,
13042 const Elf_Internal_Shdr
* section
,
13043 unsigned char * start
,
13044 bfd_size_type size
,
13045 void ** relocs_return
,
13046 unsigned long * num_relocs_return
)
13048 Elf_Internal_Shdr
* relsec
;
13049 unsigned char * end
= start
+ size
;
13051 if (relocs_return
!= NULL
)
13053 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13054 * num_relocs_return
= 0;
13057 if (filedata
->file_header
.e_type
!= ET_REL
)
13058 /* No relocs to apply. */
13061 /* Find the reloc section associated with the section. */
13062 for (relsec
= filedata
->section_headers
;
13063 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13066 bfd_boolean is_rela
;
13067 unsigned long num_relocs
;
13068 Elf_Internal_Rela
* relocs
;
13069 Elf_Internal_Rela
* rp
;
13070 Elf_Internal_Shdr
* symsec
;
13071 Elf_Internal_Sym
* symtab
;
13072 unsigned long num_syms
;
13073 Elf_Internal_Sym
* sym
;
13075 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13076 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13077 || filedata
->section_headers
+ relsec
->sh_info
!= section
13078 || relsec
->sh_size
== 0
13079 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13082 is_rela
= relsec
->sh_type
== SHT_RELA
;
13086 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13087 relsec
->sh_size
, & relocs
, & num_relocs
))
13092 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13093 relsec
->sh_size
, & relocs
, & num_relocs
))
13097 /* SH uses RELA but uses in place value instead of the addend field. */
13098 if (filedata
->file_header
.e_machine
== EM_SH
)
13101 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13102 if (symsec
->sh_type
!= SHT_SYMTAB
13103 && symsec
->sh_type
!= SHT_DYNSYM
)
13105 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13107 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13110 unsigned int reloc_type
;
13111 unsigned int reloc_size
;
13112 bfd_boolean reloc_inplace
= FALSE
;
13113 bfd_boolean reloc_subtract
= FALSE
;
13114 unsigned char * rloc
;
13115 unsigned long sym_index
;
13117 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13119 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13121 else if (is_none_reloc (filedata
, reloc_type
))
13123 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13124 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13126 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13127 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13129 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13131 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13133 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13134 || is_6bit_abs_reloc (filedata
, reloc_type
))
13136 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13138 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13141 reloc_inplace
= TRUE
;
13143 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13145 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13148 reloc_inplace
= TRUE
;
13150 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13152 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13155 reloc_inplace
= TRUE
;
13157 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13159 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13162 reloc_inplace
= TRUE
;
13164 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13168 reloc_inplace
= TRUE
;
13172 static unsigned int prev_reloc
= 0;
13174 if (reloc_type
!= prev_reloc
)
13175 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13176 reloc_type
, printable_section_name (filedata
, section
));
13177 prev_reloc
= reloc_type
;
13181 rloc
= start
+ rp
->r_offset
;
13182 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
13184 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13185 (unsigned long) rp
->r_offset
,
13186 printable_section_name (filedata
, section
));
13190 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13191 if (sym_index
>= num_syms
)
13193 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13194 sym_index
, printable_section_name (filedata
, section
));
13197 sym
= symtab
+ sym_index
;
13199 /* If the reloc has a symbol associated with it,
13200 make sure that it is of an appropriate type.
13202 Relocations against symbols without type can happen.
13203 Gcc -feliminate-dwarf2-dups may generate symbols
13204 without type for debug info.
13206 Icc generates relocations against function symbols
13207 instead of local labels.
13209 Relocations against object symbols can happen, eg when
13210 referencing a global array. For an example of this see
13211 the _clz.o binary in libgcc.a. */
13213 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13214 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13216 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13217 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13218 printable_section_name (filedata
, relsec
),
13219 (long int)(rp
- relocs
));
13225 addend
+= rp
->r_addend
;
13226 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13227 partial_inplace. */
13229 || (filedata
->file_header
.e_machine
== EM_XTENSA
13230 && reloc_type
== 1)
13231 || ((filedata
->file_header
.e_machine
== EM_PJ
13232 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13233 && reloc_type
== 1)
13234 || ((filedata
->file_header
.e_machine
== EM_D30V
13235 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13236 && reloc_type
== 12)
13239 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13240 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13242 addend
+= byte_get (rloc
, reloc_size
);
13245 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13246 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13248 /* On HPPA, all pc-relative relocations are biased by 8. */
13249 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13251 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13254 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13255 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13257 if (reloc_subtract
)
13258 addend
-= sym
->st_value
;
13260 addend
+= sym
->st_value
;
13261 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13262 byte_put (rloc
, addend
, reloc_size
);
13264 else if (reloc_subtract
)
13265 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13267 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13271 /* Let the target specific reloc processing code know that
13272 we have finished with these relocs. */
13273 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13277 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13278 * num_relocs_return
= num_relocs
;
13289 #ifdef SUPPORT_DISASSEMBLY
13291 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13293 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13295 /* FIXME: XXX -- to be done --- XXX */
13301 /* Reads in the contents of SECTION from FILE, returning a pointer
13302 to a malloc'ed buffer or NULL if something went wrong. */
13305 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13307 bfd_size_type num_bytes
= section
->sh_size
;
13309 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13311 printf (_("Section '%s' has no data to dump.\n"),
13312 printable_section_name (filedata
, section
));
13316 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13317 _("section contents"));
13320 /* Uncompresses a section that was compressed using zlib, in place. */
13323 uncompress_section_contents (unsigned char ** buffer
,
13324 dwarf_size_type uncompressed_size
,
13325 dwarf_size_type
* size
)
13327 dwarf_size_type compressed_size
= *size
;
13328 unsigned char * compressed_buffer
= *buffer
;
13329 unsigned char * uncompressed_buffer
;
13333 /* It is possible the section consists of several compressed
13334 buffers concatenated together, so we uncompress in a loop. */
13335 /* PR 18313: The state field in the z_stream structure is supposed
13336 to be invisible to the user (ie us), but some compilers will
13337 still complain about it being used without initialisation. So
13338 we first zero the entire z_stream structure and then set the fields
13340 memset (& strm
, 0, sizeof strm
);
13341 strm
.avail_in
= compressed_size
;
13342 strm
.next_in
= (Bytef
*) compressed_buffer
;
13343 strm
.avail_out
= uncompressed_size
;
13344 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13346 rc
= inflateInit (& strm
);
13347 while (strm
.avail_in
> 0)
13351 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13352 + (uncompressed_size
- strm
.avail_out
));
13353 rc
= inflate (&strm
, Z_FINISH
);
13354 if (rc
!= Z_STREAM_END
)
13356 rc
= inflateReset (& strm
);
13358 rc
= inflateEnd (& strm
);
13360 || strm
.avail_out
!= 0)
13363 *buffer
= uncompressed_buffer
;
13364 *size
= uncompressed_size
;
13368 free (uncompressed_buffer
);
13369 /* Indicate decompression failure. */
13375 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13377 Elf_Internal_Shdr
* relsec
;
13378 bfd_size_type num_bytes
;
13379 unsigned char * data
;
13380 unsigned char * end
;
13381 unsigned char * real_start
;
13382 unsigned char * start
;
13383 bfd_boolean some_strings_shown
;
13385 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13387 /* PR 21820: Do not fail if the section was empty. */
13388 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13390 num_bytes
= section
->sh_size
;
13392 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13394 if (decompress_dumps
)
13396 dwarf_size_type new_size
= num_bytes
;
13397 dwarf_size_type uncompressed_size
= 0;
13399 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13401 Elf_Internal_Chdr chdr
;
13402 unsigned int compression_header_size
13403 = get_compression_header (& chdr
, (unsigned char *) start
,
13406 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13408 warn (_("section '%s' has unsupported compress type: %d\n"),
13409 printable_section_name (filedata
, section
), chdr
.ch_type
);
13412 uncompressed_size
= chdr
.ch_size
;
13413 start
+= compression_header_size
;
13414 new_size
-= compression_header_size
;
13416 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13418 /* Read the zlib header. In this case, it should be "ZLIB"
13419 followed by the uncompressed section size, 8 bytes in
13420 big-endian order. */
13421 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13422 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13423 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13424 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13425 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13426 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13427 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13428 uncompressed_size
+= start
[11];
13433 if (uncompressed_size
)
13435 if (uncompress_section_contents (& start
,
13436 uncompressed_size
, & new_size
))
13437 num_bytes
= new_size
;
13440 error (_("Unable to decompress section %s\n"),
13441 printable_section_name (filedata
, section
));
13446 start
= real_start
;
13449 /* If the section being dumped has relocations against it the user might
13450 be expecting these relocations to have been applied. Check for this
13451 case and issue a warning message in order to avoid confusion.
13452 FIXME: Maybe we ought to have an option that dumps a section with
13453 relocs applied ? */
13454 for (relsec
= filedata
->section_headers
;
13455 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13458 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13459 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13460 || filedata
->section_headers
+ relsec
->sh_info
!= section
13461 || relsec
->sh_size
== 0
13462 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13465 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13470 end
= start
+ num_bytes
;
13471 some_strings_shown
= FALSE
;
13475 while (!ISPRINT (* data
))
13476 if (++ data
>= end
)
13481 size_t maxlen
= end
- data
;
13484 /* PR 11128: Use two separate invocations in order to work
13485 around bugs in the Solaris 8 implementation of printf. */
13486 printf (" [%6tx] ", data
- start
);
13488 printf (" [%6Ix] ", (size_t) (data
- start
));
13492 print_symbol ((int) maxlen
, (const char *) data
);
13494 data
+= strnlen ((const char *) data
, maxlen
);
13498 printf (_("<corrupt>\n"));
13501 some_strings_shown
= TRUE
;
13505 if (! some_strings_shown
)
13506 printf (_(" No strings found in this section."));
13515 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13516 Filedata
* filedata
,
13517 bfd_boolean relocate
)
13519 Elf_Internal_Shdr
* relsec
;
13520 bfd_size_type bytes
;
13521 bfd_size_type section_size
;
13523 unsigned char * data
;
13524 unsigned char * real_start
;
13525 unsigned char * start
;
13527 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13529 /* PR 21820: Do not fail if the section was empty. */
13530 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13532 section_size
= section
->sh_size
;
13534 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13536 if (decompress_dumps
)
13538 dwarf_size_type new_size
= section_size
;
13539 dwarf_size_type uncompressed_size
= 0;
13541 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13543 Elf_Internal_Chdr chdr
;
13544 unsigned int compression_header_size
13545 = get_compression_header (& chdr
, start
, section_size
);
13547 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13549 warn (_("section '%s' has unsupported compress type: %d\n"),
13550 printable_section_name (filedata
, section
), chdr
.ch_type
);
13553 uncompressed_size
= chdr
.ch_size
;
13554 start
+= compression_header_size
;
13555 new_size
-= compression_header_size
;
13557 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13559 /* Read the zlib header. In this case, it should be "ZLIB"
13560 followed by the uncompressed section size, 8 bytes in
13561 big-endian order. */
13562 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13563 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13564 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13565 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13566 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13567 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13568 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13569 uncompressed_size
+= start
[11];
13574 if (uncompressed_size
)
13576 if (uncompress_section_contents (& start
, uncompressed_size
,
13579 section_size
= new_size
;
13583 error (_("Unable to decompress section %s\n"),
13584 printable_section_name (filedata
, section
));
13585 /* FIXME: Print the section anyway ? */
13590 start
= real_start
;
13595 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13600 /* If the section being dumped has relocations against it the user might
13601 be expecting these relocations to have been applied. Check for this
13602 case and issue a warning message in order to avoid confusion.
13603 FIXME: Maybe we ought to have an option that dumps a section with
13604 relocs applied ? */
13605 for (relsec
= filedata
->section_headers
;
13606 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13609 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13610 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13611 || filedata
->section_headers
+ relsec
->sh_info
!= section
13612 || relsec
->sh_size
== 0
13613 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13616 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13621 addr
= section
->sh_addr
;
13622 bytes
= section_size
;
13631 lbytes
= (bytes
> 16 ? 16 : bytes
);
13633 printf (" 0x%8.8lx ", (unsigned long) addr
);
13635 for (j
= 0; j
< 16; j
++)
13638 printf ("%2.2x", data
[j
]);
13646 for (j
= 0; j
< lbytes
; j
++)
13649 if (k
>= ' ' && k
< 0x7f)
13669 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13670 const Elf_Internal_Shdr
* sec
,
13673 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13675 Filedata
* filedata
= (Filedata
*) data
;
13677 if (section
->start
!= NULL
)
13679 /* If it is already loaded, do nothing. */
13680 if (streq (section
->filename
, filedata
->file_name
))
13682 free (section
->start
);
13685 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13686 section
->address
= sec
->sh_addr
;
13687 section
->user_data
= NULL
;
13688 section
->filename
= filedata
->file_name
;
13689 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13691 sec
->sh_size
, buf
);
13692 if (section
->start
== NULL
)
13696 unsigned char *start
= section
->start
;
13697 dwarf_size_type size
= sec
->sh_size
;
13698 dwarf_size_type uncompressed_size
= 0;
13700 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13702 Elf_Internal_Chdr chdr
;
13703 unsigned int compression_header_size
;
13705 if (size
< (is_32bit_elf
13706 ? sizeof (Elf32_External_Chdr
)
13707 : sizeof (Elf64_External_Chdr
)))
13709 warn (_("compressed section %s is too small to contain a compression header"),
13714 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13716 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13718 warn (_("section '%s' has unsupported compress type: %d\n"),
13719 section
->name
, chdr
.ch_type
);
13722 uncompressed_size
= chdr
.ch_size
;
13723 start
+= compression_header_size
;
13724 size
-= compression_header_size
;
13726 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13728 /* Read the zlib header. In this case, it should be "ZLIB"
13729 followed by the uncompressed section size, 8 bytes in
13730 big-endian order. */
13731 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13732 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13733 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13734 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13735 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13736 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13737 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13738 uncompressed_size
+= start
[11];
13743 if (uncompressed_size
)
13745 if (uncompress_section_contents (&start
, uncompressed_size
,
13748 /* Free the compressed buffer, update the section buffer
13749 and the section size if uncompress is successful. */
13750 free (section
->start
);
13751 section
->start
= start
;
13755 error (_("Unable to decompress section %s\n"),
13756 printable_section_name (filedata
, sec
));
13761 section
->size
= size
;
13764 if (section
->start
== NULL
)
13767 if (debug_displays
[debug
].relocate
)
13769 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13770 & section
->reloc_info
, & section
->num_relocs
))
13775 section
->reloc_info
= NULL
;
13776 section
->num_relocs
= 0;
13782 /* If this is not NULL, load_debug_section will only look for sections
13783 within the list of sections given here. */
13784 static unsigned int * section_subset
= NULL
;
13787 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13789 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13790 Elf_Internal_Shdr
* sec
;
13791 Filedata
* filedata
= (Filedata
*) data
;
13793 /* Without section headers we cannot find any sections. */
13794 if (filedata
->section_headers
== NULL
)
13797 if (filedata
->string_table
== NULL
13798 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13799 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13801 Elf_Internal_Shdr
* strs
;
13803 /* Read in the string table, so that we have section names to scan. */
13804 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13806 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13808 filedata
->string_table
13809 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13810 1, strs
->sh_size
, _("string table"));
13812 filedata
->string_table_length
13813 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13817 /* Locate the debug section. */
13818 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13820 section
->name
= section
->uncompressed_name
;
13823 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13825 section
->name
= section
->compressed_name
;
13830 /* If we're loading from a subset of sections, and we've loaded
13831 a section matching this name before, it's likely that it's a
13833 if (section_subset
!= NULL
)
13834 free_debug_section (debug
);
13836 return load_specific_debug_section (debug
, sec
, data
);
13840 free_debug_section (enum dwarf_section_display_enum debug
)
13842 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13844 if (section
->start
== NULL
)
13847 free ((char *) section
->start
);
13848 section
->start
= NULL
;
13849 section
->address
= 0;
13854 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13856 char * name
= SECTION_NAME (section
);
13857 const char * print_name
= printable_section_name (filedata
, section
);
13858 bfd_size_type length
;
13859 bfd_boolean result
= TRUE
;
13862 length
= section
->sh_size
;
13865 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13868 if (section
->sh_type
== SHT_NOBITS
)
13870 /* There is no point in dumping the contents of a debugging section
13871 which has the NOBITS type - the bits in the file will be random.
13872 This can happen when a file containing a .eh_frame section is
13873 stripped with the --only-keep-debug command line option. */
13874 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13879 if (const_strneq (name
, ".gnu.linkonce.wi."))
13880 name
= ".debug_info";
13882 /* See if we know how to display the contents of this section. */
13883 for (i
= 0; i
< max
; i
++)
13885 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13886 struct dwarf_section_display
* display
= debug_displays
+ i
;
13887 struct dwarf_section
* sec
= & display
->section
;
13889 if (streq (sec
->uncompressed_name
, name
)
13890 || (id
== line
&& const_strneq (name
, ".debug_line."))
13891 || streq (sec
->compressed_name
, name
))
13893 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13896 free_debug_section (id
);
13898 if (i
== line
&& const_strneq (name
, ".debug_line."))
13900 else if (streq (sec
->uncompressed_name
, name
))
13901 sec
->name
= sec
->uncompressed_name
;
13903 sec
->name
= sec
->compressed_name
;
13905 if (load_specific_debug_section (id
, section
, filedata
))
13907 /* If this debug section is part of a CU/TU set in a .dwp file,
13908 restrict load_debug_section to the sections in that set. */
13909 section_subset
= find_cu_tu_set (filedata
, shndx
);
13911 result
&= display
->display (sec
, filedata
);
13913 section_subset
= NULL
;
13915 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13916 free_debug_section (id
);
13924 printf (_("Unrecognized debug section: %s\n"), print_name
);
13931 /* Set DUMP_SECTS for all sections where dumps were requested
13932 based on section name. */
13935 initialise_dumps_byname (Filedata
* filedata
)
13937 struct dump_list_entry
* cur
;
13939 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13942 bfd_boolean any
= FALSE
;
13944 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13945 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13947 request_dump_bynumber (filedata
, i
, cur
->type
);
13952 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13958 process_section_contents (Filedata
* filedata
)
13960 Elf_Internal_Shdr
* section
;
13962 bfd_boolean res
= TRUE
;
13967 initialise_dumps_byname (filedata
);
13969 for (i
= 0, section
= filedata
->section_headers
;
13970 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13973 dump_type dump
= filedata
->dump_sects
[i
];
13975 #ifdef SUPPORT_DISASSEMBLY
13976 if (dump
& DISASS_DUMP
)
13978 if (! disassemble_section (section
, filedata
))
13982 if (dump
& HEX_DUMP
)
13984 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13988 if (dump
& RELOC_DUMP
)
13990 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13994 if (dump
& STRING_DUMP
)
13996 if (! dump_section_as_strings (section
, filedata
))
14000 if (dump
& DEBUG_DUMP
)
14002 if (! display_debug_section (i
, section
, filedata
))
14007 /* Check to see if the user requested a
14008 dump of a section that does not exist. */
14009 while (i
< filedata
->num_dump_sects
)
14011 if (filedata
->dump_sects
[i
])
14013 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14023 process_mips_fpe_exception (int mask
)
14027 bfd_boolean first
= TRUE
;
14029 if (mask
& OEX_FPU_INEX
)
14030 fputs ("INEX", stdout
), first
= FALSE
;
14031 if (mask
& OEX_FPU_UFLO
)
14032 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14033 if (mask
& OEX_FPU_OFLO
)
14034 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14035 if (mask
& OEX_FPU_DIV0
)
14036 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14037 if (mask
& OEX_FPU_INVAL
)
14038 printf ("%sINVAL", first
? "" : "|");
14041 fputs ("0", stdout
);
14044 /* Display's the value of TAG at location P. If TAG is
14045 greater than 0 it is assumed to be an unknown tag, and
14046 a message is printed to this effect. Otherwise it is
14047 assumed that a message has already been printed.
14049 If the bottom bit of TAG is set it assumed to have a
14050 string value, otherwise it is assumed to have an integer
14053 Returns an updated P pointing to the first unread byte
14054 beyond the end of TAG's value.
14056 Reads at or beyond END will not be made. */
14058 static unsigned char *
14059 display_tag_value (signed int tag
,
14061 const unsigned char * const end
)
14066 printf (" Tag_unknown_%d: ", tag
);
14070 warn (_("<corrupt tag>\n"));
14074 /* PR 17531 file: 027-19978-0.004. */
14075 size_t maxlen
= (end
- p
) - 1;
14080 print_symbol ((int) maxlen
, (const char *) p
);
14081 p
+= strnlen ((char *) p
, maxlen
) + 1;
14085 printf (_("<corrupt string tag>"));
14086 p
= (unsigned char *) end
;
14094 val
= read_uleb128 (p
, &len
, end
);
14096 printf ("%ld (0x%lx)\n", val
, val
);
14103 /* ARC ABI attributes section. */
14105 static unsigned char *
14106 display_arc_attribute (unsigned char * p
,
14107 const unsigned char * const end
)
14113 tag
= read_uleb128 (p
, &len
, end
);
14118 case Tag_ARC_PCS_config
:
14119 val
= read_uleb128 (p
, &len
, end
);
14121 printf (" Tag_ARC_PCS_config: ");
14125 printf (_("Absent/Non standard\n"));
14128 printf (_("Bare metal/mwdt\n"));
14131 printf (_("Bare metal/newlib\n"));
14134 printf (_("Linux/uclibc\n"));
14137 printf (_("Linux/glibc\n"));
14140 printf (_("Unknown\n"));
14145 case Tag_ARC_CPU_base
:
14146 val
= read_uleb128 (p
, &len
, end
);
14148 printf (" Tag_ARC_CPU_base: ");
14153 printf (_("Absent\n"));
14155 case TAG_CPU_ARC6xx
:
14156 printf ("ARC6xx\n");
14158 case TAG_CPU_ARC7xx
:
14159 printf ("ARC7xx\n");
14161 case TAG_CPU_ARCEM
:
14162 printf ("ARCEM\n");
14164 case TAG_CPU_ARCHS
:
14165 printf ("ARCHS\n");
14170 case Tag_ARC_CPU_variation
:
14171 val
= read_uleb128 (p
, &len
, end
);
14173 printf (" Tag_ARC_CPU_variation: ");
14177 if (val
> 0 && val
< 16)
14178 printf ("Core%d\n", val
);
14180 printf ("Unknown\n");
14184 printf (_("Absent\n"));
14189 case Tag_ARC_CPU_name
:
14190 printf (" Tag_ARC_CPU_name: ");
14191 p
= display_tag_value (-1, p
, end
);
14194 case Tag_ARC_ABI_rf16
:
14195 val
= read_uleb128 (p
, &len
, end
);
14197 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14200 case Tag_ARC_ABI_osver
:
14201 val
= read_uleb128 (p
, &len
, end
);
14203 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14206 case Tag_ARC_ABI_pic
:
14207 case Tag_ARC_ABI_sda
:
14208 val
= read_uleb128 (p
, &len
, end
);
14210 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14211 : " Tag_ARC_ABI_pic: ");
14215 printf (_("Absent\n"));
14224 printf (_("Unknown\n"));
14229 case Tag_ARC_ABI_tls
:
14230 val
= read_uleb128 (p
, &len
, end
);
14232 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14235 case Tag_ARC_ABI_enumsize
:
14236 val
= read_uleb128 (p
, &len
, end
);
14238 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14242 case Tag_ARC_ABI_exceptions
:
14243 val
= read_uleb128 (p
, &len
, end
);
14245 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14249 case Tag_ARC_ABI_double_size
:
14250 val
= read_uleb128 (p
, &len
, end
);
14252 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14255 case Tag_ARC_ISA_config
:
14256 printf (" Tag_ARC_ISA_config: ");
14257 p
= display_tag_value (-1, p
, end
);
14260 case Tag_ARC_ISA_apex
:
14261 printf (" Tag_ARC_ISA_apex: ");
14262 p
= display_tag_value (-1, p
, end
);
14265 case Tag_ARC_ISA_mpy_option
:
14266 val
= read_uleb128 (p
, &len
, end
);
14268 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14271 case Tag_ARC_ATR_version
:
14272 val
= read_uleb128 (p
, &len
, end
);
14274 printf (" Tag_ARC_ATR_version: %d\n", val
);
14278 return display_tag_value (tag
& 1, p
, end
);
14284 /* ARM EABI attributes section. */
14289 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14291 const char ** table
;
14292 } arm_attr_public_tag
;
14294 static const char * arm_attr_tag_CPU_arch
[] =
14295 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14296 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14298 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14299 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14300 {"No", "Thumb-1", "Thumb-2", "Yes"};
14301 static const char * arm_attr_tag_FP_arch
[] =
14302 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14303 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14304 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14305 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14306 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14307 "NEON for ARMv8.1"};
14308 static const char * arm_attr_tag_PCS_config
[] =
14309 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14310 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14311 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14312 {"V6", "SB", "TLS", "Unused"};
14313 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14314 {"Absolute", "PC-relative", "SB-relative", "None"};
14315 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14316 {"Absolute", "PC-relative", "None"};
14317 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14318 {"None", "direct", "GOT-indirect"};
14319 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14320 {"None", "??? 1", "2", "??? 3", "4"};
14321 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14322 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14323 {"Unused", "Needed", "Sign only"};
14324 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14325 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14326 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14327 {"Unused", "Finite", "RTABI", "IEEE 754"};
14328 static const char * arm_attr_tag_ABI_enum_size
[] =
14329 {"Unused", "small", "int", "forced to int"};
14330 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14331 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14332 static const char * arm_attr_tag_ABI_VFP_args
[] =
14333 {"AAPCS", "VFP registers", "custom", "compatible"};
14334 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14335 {"AAPCS", "WMMX registers", "custom"};
14336 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14337 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14338 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14339 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14340 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14341 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14342 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14343 static const char * arm_attr_tag_FP_HP_extension
[] =
14344 {"Not Allowed", "Allowed"};
14345 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14346 {"None", "IEEE 754", "Alternative Format"};
14347 static const char * arm_attr_tag_DSP_extension
[] =
14348 {"Follow architecture", "Allowed"};
14349 static const char * arm_attr_tag_MPextension_use
[] =
14350 {"Not Allowed", "Allowed"};
14351 static const char * arm_attr_tag_DIV_use
[] =
14352 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14353 "Allowed in v7-A with integer division extension"};
14354 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14355 static const char * arm_attr_tag_Virtualization_use
[] =
14356 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14357 "TrustZone and Virtualization Extensions"};
14358 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14359 {"Not Allowed", "Allowed"};
14361 #define LOOKUP(id, name) \
14362 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14363 static arm_attr_public_tag arm_attr_public_tags
[] =
14365 {4, "CPU_raw_name", 1, NULL
},
14366 {5, "CPU_name", 1, NULL
},
14367 LOOKUP(6, CPU_arch
),
14368 {7, "CPU_arch_profile", 0, NULL
},
14369 LOOKUP(8, ARM_ISA_use
),
14370 LOOKUP(9, THUMB_ISA_use
),
14371 LOOKUP(10, FP_arch
),
14372 LOOKUP(11, WMMX_arch
),
14373 LOOKUP(12, Advanced_SIMD_arch
),
14374 LOOKUP(13, PCS_config
),
14375 LOOKUP(14, ABI_PCS_R9_use
),
14376 LOOKUP(15, ABI_PCS_RW_data
),
14377 LOOKUP(16, ABI_PCS_RO_data
),
14378 LOOKUP(17, ABI_PCS_GOT_use
),
14379 LOOKUP(18, ABI_PCS_wchar_t
),
14380 LOOKUP(19, ABI_FP_rounding
),
14381 LOOKUP(20, ABI_FP_denormal
),
14382 LOOKUP(21, ABI_FP_exceptions
),
14383 LOOKUP(22, ABI_FP_user_exceptions
),
14384 LOOKUP(23, ABI_FP_number_model
),
14385 {24, "ABI_align_needed", 0, NULL
},
14386 {25, "ABI_align_preserved", 0, NULL
},
14387 LOOKUP(26, ABI_enum_size
),
14388 LOOKUP(27, ABI_HardFP_use
),
14389 LOOKUP(28, ABI_VFP_args
),
14390 LOOKUP(29, ABI_WMMX_args
),
14391 LOOKUP(30, ABI_optimization_goals
),
14392 LOOKUP(31, ABI_FP_optimization_goals
),
14393 {32, "compatibility", 0, NULL
},
14394 LOOKUP(34, CPU_unaligned_access
),
14395 LOOKUP(36, FP_HP_extension
),
14396 LOOKUP(38, ABI_FP_16bit_format
),
14397 LOOKUP(42, MPextension_use
),
14398 LOOKUP(44, DIV_use
),
14399 LOOKUP(46, DSP_extension
),
14400 {64, "nodefaults", 0, NULL
},
14401 {65, "also_compatible_with", 0, NULL
},
14402 LOOKUP(66, T2EE_use
),
14403 {67, "conformance", 1, NULL
},
14404 LOOKUP(68, Virtualization_use
),
14405 LOOKUP(70, MPextension_use_legacy
)
14409 static unsigned char *
14410 display_arm_attribute (unsigned char * p
,
14411 const unsigned char * const end
)
14416 arm_attr_public_tag
* attr
;
14420 tag
= read_uleb128 (p
, &len
, end
);
14423 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14425 if (arm_attr_public_tags
[i
].tag
== tag
)
14427 attr
= &arm_attr_public_tags
[i
];
14434 printf (" Tag_%s: ", attr
->name
);
14435 switch (attr
->type
)
14440 case 7: /* Tag_CPU_arch_profile. */
14441 val
= read_uleb128 (p
, &len
, end
);
14445 case 0: printf (_("None\n")); break;
14446 case 'A': printf (_("Application\n")); break;
14447 case 'R': printf (_("Realtime\n")); break;
14448 case 'M': printf (_("Microcontroller\n")); break;
14449 case 'S': printf (_("Application or Realtime\n")); break;
14450 default: printf ("??? (%d)\n", val
); break;
14454 case 24: /* Tag_align_needed. */
14455 val
= read_uleb128 (p
, &len
, end
);
14459 case 0: printf (_("None\n")); break;
14460 case 1: printf (_("8-byte\n")); break;
14461 case 2: printf (_("4-byte\n")); break;
14462 case 3: printf ("??? 3\n"); break;
14465 printf (_("8-byte and up to %d-byte extended\n"),
14468 printf ("??? (%d)\n", val
);
14473 case 25: /* Tag_align_preserved. */
14474 val
= read_uleb128 (p
, &len
, end
);
14478 case 0: printf (_("None\n")); break;
14479 case 1: printf (_("8-byte, except leaf SP\n")); break;
14480 case 2: printf (_("8-byte\n")); break;
14481 case 3: printf ("??? 3\n"); break;
14484 printf (_("8-byte and up to %d-byte extended\n"),
14487 printf ("??? (%d)\n", val
);
14492 case 32: /* Tag_compatibility. */
14494 val
= read_uleb128 (p
, &len
, end
);
14496 printf (_("flag = %d, vendor = "), val
);
14499 size_t maxlen
= (end
- p
) - 1;
14501 print_symbol ((int) maxlen
, (const char *) p
);
14502 p
+= strnlen ((char *) p
, maxlen
) + 1;
14506 printf (_("<corrupt>"));
14507 p
= (unsigned char *) end
;
14513 case 64: /* Tag_nodefaults. */
14514 /* PR 17531: file: 001-505008-0.01. */
14517 printf (_("True\n"));
14520 case 65: /* Tag_also_compatible_with. */
14521 val
= read_uleb128 (p
, &len
, end
);
14523 if (val
== 6 /* Tag_CPU_arch. */)
14525 val
= read_uleb128 (p
, &len
, end
);
14527 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14528 printf ("??? (%d)\n", val
);
14530 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14534 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14539 printf (_("<unknown: %d>\n"), tag
);
14545 return display_tag_value (-1, p
, end
);
14547 return display_tag_value (0, p
, end
);
14550 assert (attr
->type
& 0x80);
14551 val
= read_uleb128 (p
, &len
, end
);
14553 type
= attr
->type
& 0x7f;
14555 printf ("??? (%d)\n", val
);
14557 printf ("%s\n", attr
->table
[val
]);
14562 return display_tag_value (tag
, p
, end
);
14565 static unsigned char *
14566 display_gnu_attribute (unsigned char * p
,
14567 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14568 const unsigned char * const end
)
14574 tag
= read_uleb128 (p
, &len
, end
);
14577 /* Tag_compatibility is the only generic GNU attribute defined at
14581 val
= read_uleb128 (p
, &len
, end
);
14584 printf (_("flag = %d, vendor = "), val
);
14587 printf (_("<corrupt>\n"));
14588 warn (_("corrupt vendor attribute\n"));
14594 size_t maxlen
= (end
- p
) - 1;
14596 print_symbol ((int) maxlen
, (const char *) p
);
14597 p
+= strnlen ((char *) p
, maxlen
) + 1;
14601 printf (_("<corrupt>"));
14602 p
= (unsigned char *) end
;
14609 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14610 return display_proc_gnu_attribute (p
, tag
, end
);
14612 return display_tag_value (tag
, p
, end
);
14615 static unsigned char *
14616 display_power_gnu_attribute (unsigned char * p
,
14618 const unsigned char * const end
)
14623 if (tag
== Tag_GNU_Power_ABI_FP
)
14625 val
= read_uleb128 (p
, &len
, end
);
14627 printf (" Tag_GNU_Power_ABI_FP: ");
14630 printf (_("<corrupt>\n"));
14635 printf ("(%#x), ", val
);
14640 printf (_("unspecified hard/soft float, "));
14643 printf (_("hard float, "));
14646 printf (_("soft float, "));
14649 printf (_("single-precision hard float, "));
14656 printf (_("unspecified long double\n"));
14659 printf (_("128-bit IBM long double\n"));
14662 printf (_("64-bit long double\n"));
14665 printf (_("128-bit IEEE long double\n"));
14671 if (tag
== Tag_GNU_Power_ABI_Vector
)
14673 val
= read_uleb128 (p
, &len
, end
);
14675 printf (" Tag_GNU_Power_ABI_Vector: ");
14678 printf (_("<corrupt>\n"));
14683 printf ("(%#x), ", val
);
14688 printf (_("unspecified\n"));
14691 printf (_("generic\n"));
14694 printf ("AltiVec\n");
14703 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14705 val
= read_uleb128 (p
, &len
, end
);
14707 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14710 printf (_("<corrupt>\n"));
14715 printf ("(%#x), ", val
);
14720 printf (_("unspecified\n"));
14723 printf ("r3/r4\n");
14726 printf (_("memory\n"));
14735 return display_tag_value (tag
& 1, p
, end
);
14738 static unsigned char *
14739 display_s390_gnu_attribute (unsigned char * p
,
14741 const unsigned char * const end
)
14746 if (tag
== Tag_GNU_S390_ABI_Vector
)
14748 val
= read_uleb128 (p
, &len
, end
);
14750 printf (" Tag_GNU_S390_ABI_Vector: ");
14755 printf (_("any\n"));
14758 printf (_("software\n"));
14761 printf (_("hardware\n"));
14764 printf ("??? (%d)\n", val
);
14770 return display_tag_value (tag
& 1, p
, end
);
14774 display_sparc_hwcaps (unsigned int mask
)
14778 bfd_boolean first
= TRUE
;
14780 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14781 fputs ("mul32", stdout
), first
= FALSE
;
14782 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14783 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14784 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14785 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14786 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14787 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14788 if (mask
& ELF_SPARC_HWCAP_POPC
)
14789 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14790 if (mask
& ELF_SPARC_HWCAP_VIS
)
14791 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14792 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14793 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14794 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14795 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14796 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14797 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14798 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14799 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14800 if (mask
& ELF_SPARC_HWCAP_HPC
)
14801 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14802 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14803 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14804 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14805 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14806 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14807 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14808 if (mask
& ELF_SPARC_HWCAP_IMA
)
14809 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14810 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14811 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14814 fputc ('0', stdout
);
14815 fputc ('\n', stdout
);
14819 display_sparc_hwcaps2 (unsigned int mask
)
14823 bfd_boolean first
= TRUE
;
14825 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14826 fputs ("fjathplus", stdout
), first
= FALSE
;
14827 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14828 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14829 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14830 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14831 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14832 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14833 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14834 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14835 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14836 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14837 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14838 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14839 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14840 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14841 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14842 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14843 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14844 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14845 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14846 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14849 fputc ('0', stdout
);
14850 fputc ('\n', stdout
);
14853 static unsigned char *
14854 display_sparc_gnu_attribute (unsigned char * p
,
14856 const unsigned char * const end
)
14861 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14863 val
= read_uleb128 (p
, &len
, end
);
14865 printf (" Tag_GNU_Sparc_HWCAPS: ");
14866 display_sparc_hwcaps (val
);
14869 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14871 val
= read_uleb128 (p
, &len
, end
);
14873 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14874 display_sparc_hwcaps2 (val
);
14878 return display_tag_value (tag
, p
, end
);
14882 print_mips_fp_abi_value (unsigned int val
)
14886 case Val_GNU_MIPS_ABI_FP_ANY
:
14887 printf (_("Hard or soft float\n"));
14889 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14890 printf (_("Hard float (double precision)\n"));
14892 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14893 printf (_("Hard float (single precision)\n"));
14895 case Val_GNU_MIPS_ABI_FP_SOFT
:
14896 printf (_("Soft float\n"));
14898 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14899 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14901 case Val_GNU_MIPS_ABI_FP_XX
:
14902 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14904 case Val_GNU_MIPS_ABI_FP_64
:
14905 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14907 case Val_GNU_MIPS_ABI_FP_64A
:
14908 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14910 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14911 printf (_("NaN 2008 compatibility\n"));
14914 printf ("??? (%d)\n", val
);
14919 static unsigned char *
14920 display_mips_gnu_attribute (unsigned char * p
,
14922 const unsigned char * const end
)
14924 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14929 val
= read_uleb128 (p
, &len
, end
);
14931 printf (" Tag_GNU_MIPS_ABI_FP: ");
14933 print_mips_fp_abi_value (val
);
14938 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14943 val
= read_uleb128 (p
, &len
, end
);
14945 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14949 case Val_GNU_MIPS_ABI_MSA_ANY
:
14950 printf (_("Any MSA or not\n"));
14952 case Val_GNU_MIPS_ABI_MSA_128
:
14953 printf (_("128-bit MSA\n"));
14956 printf ("??? (%d)\n", val
);
14962 return display_tag_value (tag
& 1, p
, end
);
14965 static unsigned char *
14966 display_tic6x_attribute (unsigned char * p
,
14967 const unsigned char * const end
)
14973 tag
= read_uleb128 (p
, &len
, end
);
14979 val
= read_uleb128 (p
, &len
, end
);
14981 printf (" Tag_ISA: ");
14985 case C6XABI_Tag_ISA_none
:
14986 printf (_("None\n"));
14988 case C6XABI_Tag_ISA_C62X
:
14991 case C6XABI_Tag_ISA_C67X
:
14994 case C6XABI_Tag_ISA_C67XP
:
14995 printf ("C67x+\n");
14997 case C6XABI_Tag_ISA_C64X
:
15000 case C6XABI_Tag_ISA_C64XP
:
15001 printf ("C64x+\n");
15003 case C6XABI_Tag_ISA_C674X
:
15004 printf ("C674x\n");
15007 printf ("??? (%d)\n", val
);
15012 case Tag_ABI_wchar_t
:
15013 val
= read_uleb128 (p
, &len
, end
);
15015 printf (" Tag_ABI_wchar_t: ");
15019 printf (_("Not used\n"));
15022 printf (_("2 bytes\n"));
15025 printf (_("4 bytes\n"));
15028 printf ("??? (%d)\n", val
);
15033 case Tag_ABI_stack_align_needed
:
15034 val
= read_uleb128 (p
, &len
, end
);
15036 printf (" Tag_ABI_stack_align_needed: ");
15040 printf (_("8-byte\n"));
15043 printf (_("16-byte\n"));
15046 printf ("??? (%d)\n", val
);
15051 case Tag_ABI_stack_align_preserved
:
15052 val
= read_uleb128 (p
, &len
, end
);
15054 printf (" Tag_ABI_stack_align_preserved: ");
15058 printf (_("8-byte\n"));
15061 printf (_("16-byte\n"));
15064 printf ("??? (%d)\n", val
);
15070 val
= read_uleb128 (p
, &len
, end
);
15072 printf (" Tag_ABI_DSBT: ");
15076 printf (_("DSBT addressing not used\n"));
15079 printf (_("DSBT addressing used\n"));
15082 printf ("??? (%d)\n", val
);
15088 val
= read_uleb128 (p
, &len
, end
);
15090 printf (" Tag_ABI_PID: ");
15094 printf (_("Data addressing position-dependent\n"));
15097 printf (_("Data addressing position-independent, GOT near DP\n"));
15100 printf (_("Data addressing position-independent, GOT far from DP\n"));
15103 printf ("??? (%d)\n", val
);
15109 val
= read_uleb128 (p
, &len
, end
);
15111 printf (" Tag_ABI_PIC: ");
15115 printf (_("Code addressing position-dependent\n"));
15118 printf (_("Code addressing position-independent\n"));
15121 printf ("??? (%d)\n", val
);
15126 case Tag_ABI_array_object_alignment
:
15127 val
= read_uleb128 (p
, &len
, end
);
15129 printf (" Tag_ABI_array_object_alignment: ");
15133 printf (_("8-byte\n"));
15136 printf (_("4-byte\n"));
15139 printf (_("16-byte\n"));
15142 printf ("??? (%d)\n", val
);
15147 case Tag_ABI_array_object_align_expected
:
15148 val
= read_uleb128 (p
, &len
, end
);
15150 printf (" Tag_ABI_array_object_align_expected: ");
15154 printf (_("8-byte\n"));
15157 printf (_("4-byte\n"));
15160 printf (_("16-byte\n"));
15163 printf ("??? (%d)\n", val
);
15168 case Tag_ABI_compatibility
:
15170 val
= read_uleb128 (p
, &len
, end
);
15172 printf (" Tag_ABI_compatibility: ");
15173 printf (_("flag = %d, vendor = "), val
);
15176 size_t maxlen
= (end
- p
) - 1;
15178 print_symbol ((int) maxlen
, (const char *) p
);
15179 p
+= strnlen ((char *) p
, maxlen
) + 1;
15183 printf (_("<corrupt>"));
15184 p
= (unsigned char *) end
;
15190 case Tag_ABI_conformance
:
15192 printf (" Tag_ABI_conformance: \"");
15195 size_t maxlen
= (end
- p
) - 1;
15197 print_symbol ((int) maxlen
, (const char *) p
);
15198 p
+= strnlen ((char *) p
, maxlen
) + 1;
15202 printf (_("<corrupt>"));
15203 p
= (unsigned char *) end
;
15210 return display_tag_value (tag
, p
, end
);
15214 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15216 unsigned long addr
= 0;
15217 size_t bytes
= end
- p
;
15224 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15226 printf (" 0x%8.8lx ", addr
);
15228 for (j
= 0; j
< 16; j
++)
15231 printf ("%2.2x", p
[j
]);
15239 for (j
= 0; j
< lbytes
; j
++)
15242 if (k
>= ' ' && k
< 0x7f)
15258 static unsigned char *
15259 display_msp430x_attribute (unsigned char * p
,
15260 const unsigned char * const end
)
15266 tag
= read_uleb128 (p
, & len
, end
);
15271 case OFBA_MSPABI_Tag_ISA
:
15272 val
= read_uleb128 (p
, &len
, end
);
15274 printf (" Tag_ISA: ");
15277 case 0: printf (_("None\n")); break;
15278 case 1: printf (_("MSP430\n")); break;
15279 case 2: printf (_("MSP430X\n")); break;
15280 default: printf ("??? (%d)\n", val
); break;
15284 case OFBA_MSPABI_Tag_Code_Model
:
15285 val
= read_uleb128 (p
, &len
, end
);
15287 printf (" Tag_Code_Model: ");
15290 case 0: printf (_("None\n")); break;
15291 case 1: printf (_("Small\n")); break;
15292 case 2: printf (_("Large\n")); break;
15293 default: printf ("??? (%d)\n", val
); break;
15297 case OFBA_MSPABI_Tag_Data_Model
:
15298 val
= read_uleb128 (p
, &len
, end
);
15300 printf (" Tag_Data_Model: ");
15303 case 0: printf (_("None\n")); break;
15304 case 1: printf (_("Small\n")); break;
15305 case 2: printf (_("Large\n")); break;
15306 case 3: printf (_("Restricted Large\n")); break;
15307 default: printf ("??? (%d)\n", val
); break;
15312 printf (_(" <unknown tag %d>: "), tag
);
15319 size_t maxlen
= (end
- p
) - 1;
15321 print_symbol ((int) maxlen
, (const char *) p
);
15322 p
+= strnlen ((char *) p
, maxlen
) + 1;
15326 printf (_("<corrupt>"));
15327 p
= (unsigned char *) end
;
15333 val
= read_uleb128 (p
, &len
, end
);
15335 printf ("%d (0x%x)\n", val
, val
);
15345 process_attributes (Filedata
* filedata
,
15346 const char * public_name
,
15347 unsigned int proc_type
,
15348 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15349 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15351 Elf_Internal_Shdr
* sect
;
15353 bfd_boolean res
= TRUE
;
15355 /* Find the section header so that we get the size. */
15356 for (i
= 0, sect
= filedata
->section_headers
;
15357 i
< filedata
->file_header
.e_shnum
;
15360 unsigned char * contents
;
15363 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15366 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15367 sect
->sh_size
, _("attributes"));
15368 if (contents
== NULL
)
15375 /* The first character is the version of the attributes.
15376 Currently only version 1, (aka 'A') is recognised here. */
15379 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15384 bfd_vma section_len
;
15386 section_len
= sect
->sh_size
- 1;
15389 while (section_len
> 0)
15392 unsigned int namelen
;
15393 bfd_boolean public_section
;
15394 bfd_boolean gnu_section
;
15396 if (section_len
<= 4)
15398 error (_("Tag section ends prematurely\n"));
15402 attr_len
= byte_get (p
, 4);
15405 if (attr_len
> section_len
)
15407 error (_("Bad attribute length (%u > %u)\n"),
15408 (unsigned) attr_len
, (unsigned) section_len
);
15409 attr_len
= section_len
;
15412 /* PR 17531: file: 001-101425-0.004 */
15413 else if (attr_len
< 5)
15415 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15420 section_len
-= attr_len
;
15423 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15424 if (namelen
== 0 || namelen
>= attr_len
)
15426 error (_("Corrupt attribute section name\n"));
15431 printf (_("Attribute Section: "));
15432 print_symbol (INT_MAX
, (const char *) p
);
15435 if (public_name
&& streq ((char *) p
, public_name
))
15436 public_section
= TRUE
;
15438 public_section
= FALSE
;
15440 if (streq ((char *) p
, "gnu"))
15441 gnu_section
= TRUE
;
15443 gnu_section
= FALSE
;
15446 attr_len
-= namelen
;
15448 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15453 unsigned char * end
;
15455 /* PR binutils/17531: Safe handling of corrupt files. */
15458 error (_("Unused bytes at end of section\n"));
15465 size
= byte_get (p
, 4);
15466 if (size
> attr_len
)
15468 error (_("Bad subsection length (%u > %u)\n"),
15469 (unsigned) size
, (unsigned) attr_len
);
15473 /* PR binutils/17531: Safe handling of corrupt files. */
15476 error (_("Bad subsection length (%u < 6)\n"),
15484 end
= p
+ size
- 1;
15485 assert (end
<= contents
+ sect
->sh_size
);
15491 printf (_("File Attributes\n"));
15494 printf (_("Section Attributes:"));
15497 printf (_("Symbol Attributes:"));
15498 /* Fall through. */
15504 val
= read_uleb128 (p
, &j
, end
);
15508 printf (" %d", val
);
15513 printf (_("Unknown tag: %d\n"), tag
);
15514 public_section
= FALSE
;
15518 if (public_section
&& display_pub_attribute
!= NULL
)
15521 p
= display_pub_attribute (p
, end
);
15524 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15527 p
= display_gnu_attribute (p
,
15528 display_proc_gnu_attribute
,
15534 printf (_(" Unknown attribute:\n"));
15535 display_raw_attribute (p
, end
);
15550 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15551 Print the Address, Access and Initial fields of an entry at VMA ADDR
15552 and return the VMA of the next entry, or -1 if there was a problem.
15553 Does not read from DATA_END or beyond. */
15556 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15557 unsigned char * data_end
)
15560 print_vma (addr
, LONG_HEX
);
15562 if (addr
< pltgot
+ 0xfff0)
15563 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15565 printf ("%10s", "");
15568 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15572 unsigned char * from
= data
+ addr
- pltgot
;
15574 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15576 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15577 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15578 return (bfd_vma
) -1;
15582 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15583 print_vma (entry
, LONG_HEX
);
15586 return addr
+ (is_32bit_elf
? 4 : 8);
15589 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15590 PLTGOT. Print the Address and Initial fields of an entry at VMA
15591 ADDR and return the VMA of the next entry. */
15594 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15597 print_vma (addr
, LONG_HEX
);
15600 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15605 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15606 print_vma (entry
, LONG_HEX
);
15608 return addr
+ (is_32bit_elf
? 4 : 8);
15612 print_mips_ases (unsigned int mask
)
15614 if (mask
& AFL_ASE_DSP
)
15615 fputs ("\n\tDSP ASE", stdout
);
15616 if (mask
& AFL_ASE_DSPR2
)
15617 fputs ("\n\tDSP R2 ASE", stdout
);
15618 if (mask
& AFL_ASE_DSPR3
)
15619 fputs ("\n\tDSP R3 ASE", stdout
);
15620 if (mask
& AFL_ASE_EVA
)
15621 fputs ("\n\tEnhanced VA Scheme", stdout
);
15622 if (mask
& AFL_ASE_MCU
)
15623 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15624 if (mask
& AFL_ASE_MDMX
)
15625 fputs ("\n\tMDMX ASE", stdout
);
15626 if (mask
& AFL_ASE_MIPS3D
)
15627 fputs ("\n\tMIPS-3D ASE", stdout
);
15628 if (mask
& AFL_ASE_MT
)
15629 fputs ("\n\tMT ASE", stdout
);
15630 if (mask
& AFL_ASE_SMARTMIPS
)
15631 fputs ("\n\tSmartMIPS ASE", stdout
);
15632 if (mask
& AFL_ASE_VIRT
)
15633 fputs ("\n\tVZ ASE", stdout
);
15634 if (mask
& AFL_ASE_MSA
)
15635 fputs ("\n\tMSA ASE", stdout
);
15636 if (mask
& AFL_ASE_MIPS16
)
15637 fputs ("\n\tMIPS16 ASE", stdout
);
15638 if (mask
& AFL_ASE_MICROMIPS
)
15639 fputs ("\n\tMICROMIPS ASE", stdout
);
15640 if (mask
& AFL_ASE_XPA
)
15641 fputs ("\n\tXPA ASE", stdout
);
15642 if (mask
& AFL_ASE_MIPS16E2
)
15643 fputs ("\n\tMIPS16e2 ASE", stdout
);
15644 if (mask
& AFL_ASE_CRC
)
15645 fputs ("\n\tCRC ASE", stdout
);
15646 if (mask
& AFL_ASE_GINV
)
15647 fputs ("\n\tGINV ASE", stdout
);
15648 if (mask
& AFL_ASE_LOONGSON_MMI
)
15649 fputs ("\n\tLoongson MMI ASE", stdout
);
15650 if (mask
& AFL_ASE_LOONGSON_CAM
)
15651 fputs ("\n\tLoongson CAM ASE", stdout
);
15652 if (mask
& AFL_ASE_LOONGSON_EXT
)
15653 fputs ("\n\tLoongson EXT ASE", stdout
);
15654 if (mask
& AFL_ASE_LOONGSON_EXT2
)
15655 fputs ("\n\tLoongson EXT2 ASE", stdout
);
15657 fprintf (stdout
, "\n\t%s", _("None"));
15658 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15659 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15663 print_mips_isa_ext (unsigned int isa_ext
)
15668 fputs (_("None"), stdout
);
15671 fputs ("RMI XLR", stdout
);
15673 case AFL_EXT_OCTEON3
:
15674 fputs ("Cavium Networks Octeon3", stdout
);
15676 case AFL_EXT_OCTEON2
:
15677 fputs ("Cavium Networks Octeon2", stdout
);
15679 case AFL_EXT_OCTEONP
:
15680 fputs ("Cavium Networks OcteonP", stdout
);
15682 case AFL_EXT_OCTEON
:
15683 fputs ("Cavium Networks Octeon", stdout
);
15686 fputs ("Toshiba R5900", stdout
);
15689 fputs ("MIPS R4650", stdout
);
15692 fputs ("LSI R4010", stdout
);
15695 fputs ("NEC VR4100", stdout
);
15698 fputs ("Toshiba R3900", stdout
);
15700 case AFL_EXT_10000
:
15701 fputs ("MIPS R10000", stdout
);
15704 fputs ("Broadcom SB-1", stdout
);
15707 fputs ("NEC VR4111/VR4181", stdout
);
15710 fputs ("NEC VR4120", stdout
);
15713 fputs ("NEC VR5400", stdout
);
15716 fputs ("NEC VR5500", stdout
);
15718 case AFL_EXT_LOONGSON_2E
:
15719 fputs ("ST Microelectronics Loongson 2E", stdout
);
15721 case AFL_EXT_LOONGSON_2F
:
15722 fputs ("ST Microelectronics Loongson 2F", stdout
);
15724 case AFL_EXT_INTERAPTIV_MR2
:
15725 fputs ("Imagination interAptiv MR2", stdout
);
15728 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15733 get_mips_reg_size (int reg_size
)
15735 return (reg_size
== AFL_REG_NONE
) ? 0
15736 : (reg_size
== AFL_REG_32
) ? 32
15737 : (reg_size
== AFL_REG_64
) ? 64
15738 : (reg_size
== AFL_REG_128
) ? 128
15743 process_mips_specific (Filedata
* filedata
)
15745 Elf_Internal_Dyn
* entry
;
15746 Elf_Internal_Shdr
*sect
= NULL
;
15747 size_t liblist_offset
= 0;
15748 size_t liblistno
= 0;
15749 size_t conflictsno
= 0;
15750 size_t options_offset
= 0;
15751 size_t conflicts_offset
= 0;
15752 size_t pltrelsz
= 0;
15754 bfd_vma pltgot
= 0;
15755 bfd_vma mips_pltgot
= 0;
15756 bfd_vma jmprel
= 0;
15757 bfd_vma local_gotno
= 0;
15758 bfd_vma gotsym
= 0;
15759 bfd_vma symtabno
= 0;
15760 bfd_boolean res
= TRUE
;
15762 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15763 display_mips_gnu_attribute
))
15766 sect
= find_section (filedata
, ".MIPS.abiflags");
15770 Elf_External_ABIFlags_v0
*abiflags_ext
;
15771 Elf_Internal_ABIFlags_v0 abiflags_in
;
15773 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15775 error (_("Corrupt MIPS ABI Flags section.\n"));
15780 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15781 sect
->sh_size
, _("MIPS ABI Flags section"));
15784 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15785 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15786 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15787 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15788 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15789 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15790 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15791 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15792 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15793 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15794 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15796 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15797 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15798 if (abiflags_in
.isa_rev
> 1)
15799 printf ("r%d", abiflags_in
.isa_rev
);
15800 printf ("\nGPR size: %d",
15801 get_mips_reg_size (abiflags_in
.gpr_size
));
15802 printf ("\nCPR1 size: %d",
15803 get_mips_reg_size (abiflags_in
.cpr1_size
));
15804 printf ("\nCPR2 size: %d",
15805 get_mips_reg_size (abiflags_in
.cpr2_size
));
15806 fputs ("\nFP ABI: ", stdout
);
15807 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15808 fputs ("ISA Extension: ", stdout
);
15809 print_mips_isa_ext (abiflags_in
.isa_ext
);
15810 fputs ("\nASEs:", stdout
);
15811 print_mips_ases (abiflags_in
.ases
);
15812 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15813 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15814 fputc ('\n', stdout
);
15815 free (abiflags_ext
);
15820 /* We have a lot of special sections. Thanks SGI! */
15821 if (dynamic_section
== NULL
)
15823 /* No dynamic information available. See if there is static GOT. */
15824 sect
= find_section (filedata
, ".got");
15827 unsigned char *data_end
;
15828 unsigned char *data
;
15832 pltgot
= sect
->sh_addr
;
15835 addr_size
= (is_32bit_elf
? 4 : 8);
15836 end
= pltgot
+ sect
->sh_size
;
15838 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15840 _("Global Offset Table data"));
15841 /* PR 12855: Null data is handled gracefully throughout. */
15842 data_end
= data
+ (end
- pltgot
);
15844 printf (_("\nStatic GOT:\n"));
15845 printf (_(" Canonical gp value: "));
15846 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15849 /* In a dynamic binary GOT[0] is reserved for the dynamic
15850 loader to store the lazy resolver pointer, however in
15851 a static binary it may well have been omitted and GOT
15852 reduced to a table of addresses.
15853 PR 21344: Check for the entry being fully available
15854 before fetching it. */
15856 && data
+ ent
- pltgot
+ addr_size
<= data_end
15857 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15859 printf (_(" Reserved entries:\n"));
15860 printf (_(" %*s %10s %*s\n"),
15861 addr_size
* 2, _("Address"), _("Access"),
15862 addr_size
* 2, _("Value"));
15863 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15865 if (ent
== (bfd_vma
) -1)
15866 goto sgot_print_fail
;
15868 /* Check for the MSB of GOT[1] being set, identifying a
15869 GNU object. This entry will be used by some runtime
15870 loaders, to store the module pointer. Otherwise this
15871 is an ordinary local entry.
15872 PR 21344: Check for the entry being fully available
15873 before fetching it. */
15875 && data
+ ent
- pltgot
+ addr_size
<= data_end
15876 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15877 >> (addr_size
* 8 - 1)) != 0)
15879 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15881 if (ent
== (bfd_vma
) -1)
15882 goto sgot_print_fail
;
15887 if (data
!= NULL
&& ent
< end
)
15889 printf (_(" Local entries:\n"));
15890 printf (" %*s %10s %*s\n",
15891 addr_size
* 2, _("Address"), _("Access"),
15892 addr_size
* 2, _("Value"));
15895 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15897 if (ent
== (bfd_vma
) -1)
15898 goto sgot_print_fail
;
15910 for (entry
= dynamic_section
;
15911 /* PR 17531 file: 012-50589-0.004. */
15912 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15914 switch (entry
->d_tag
)
15916 case DT_MIPS_LIBLIST
:
15918 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15919 liblistno
* sizeof (Elf32_External_Lib
));
15921 case DT_MIPS_LIBLISTNO
:
15922 liblistno
= entry
->d_un
.d_val
;
15924 case DT_MIPS_OPTIONS
:
15925 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15927 case DT_MIPS_CONFLICT
:
15929 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15930 conflictsno
* sizeof (Elf32_External_Conflict
));
15932 case DT_MIPS_CONFLICTNO
:
15933 conflictsno
= entry
->d_un
.d_val
;
15936 pltgot
= entry
->d_un
.d_ptr
;
15938 case DT_MIPS_LOCAL_GOTNO
:
15939 local_gotno
= entry
->d_un
.d_val
;
15941 case DT_MIPS_GOTSYM
:
15942 gotsym
= entry
->d_un
.d_val
;
15944 case DT_MIPS_SYMTABNO
:
15945 symtabno
= entry
->d_un
.d_val
;
15947 case DT_MIPS_PLTGOT
:
15948 mips_pltgot
= entry
->d_un
.d_ptr
;
15951 pltrel
= entry
->d_un
.d_val
;
15954 pltrelsz
= entry
->d_un
.d_val
;
15957 jmprel
= entry
->d_un
.d_ptr
;
15963 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15965 Elf32_External_Lib
* elib
;
15968 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15970 sizeof (Elf32_External_Lib
),
15971 _("liblist section data"));
15974 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15975 "\nSection '.liblist' contains %lu entries:\n",
15976 (unsigned long) liblistno
),
15977 (unsigned long) liblistno
);
15978 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15981 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15988 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15989 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15990 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15991 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15992 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15994 tmp
= gmtime (&atime
);
15995 snprintf (timebuf
, sizeof (timebuf
),
15996 "%04u-%02u-%02uT%02u:%02u:%02u",
15997 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15998 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16000 printf ("%3lu: ", (unsigned long) cnt
);
16001 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16002 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16004 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16005 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16006 liblist
.l_version
);
16008 if (liblist
.l_flags
== 0)
16012 static const struct
16019 { " EXACT_MATCH", LL_EXACT_MATCH
},
16020 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16021 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16022 { " EXPORTS", LL_EXPORTS
},
16023 { " DELAY_LOAD", LL_DELAY_LOAD
},
16024 { " DELTA", LL_DELTA
}
16026 int flags
= liblist
.l_flags
;
16029 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16030 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16032 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16033 flags
^= l_flags_vals
[fcnt
].bit
;
16036 printf (" %#x", (unsigned int) flags
);
16048 if (options_offset
!= 0)
16050 Elf_External_Options
* eopt
;
16051 Elf_Internal_Options
* iopt
;
16052 Elf_Internal_Options
* option
;
16055 sect
= filedata
->section_headers
;
16057 /* Find the section header so that we get the size. */
16058 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16059 /* PR 17533 file: 012-277276-0.004. */
16062 error (_("No MIPS_OPTIONS header found\n"));
16066 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16067 sect
->sh_size
, _("options"));
16070 iopt
= (Elf_Internal_Options
*)
16071 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16074 error (_("Out of memory allocating space for MIPS options\n"));
16081 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16083 Elf_External_Options
* eoption
;
16085 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16087 option
->kind
= BYTE_GET (eoption
->kind
);
16088 option
->size
= BYTE_GET (eoption
->size
);
16089 option
->section
= BYTE_GET (eoption
->section
);
16090 option
->info
= BYTE_GET (eoption
->info
);
16092 /* PR 17531: file: ffa0fa3b. */
16093 if (option
->size
< sizeof (* eopt
)
16094 || offset
+ option
->size
> sect
->sh_size
)
16096 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16099 offset
+= option
->size
;
16105 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16106 "\nSection '%s' contains %d entries:\n",
16108 printable_section_name (filedata
, sect
), cnt
);
16117 switch (option
->kind
)
16120 /* This shouldn't happen. */
16121 printf (" NULL %d %lx", option
->section
, option
->info
);
16124 printf (" REGINFO ");
16125 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16128 Elf32_External_RegInfo
* ereg
;
16129 Elf32_RegInfo reginfo
;
16131 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16132 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16133 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16134 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16135 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16136 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16137 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16139 printf ("GPR %08lx GP 0x%lx\n",
16140 reginfo
.ri_gprmask
,
16141 (unsigned long) reginfo
.ri_gp_value
);
16142 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16143 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16144 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16149 Elf64_External_RegInfo
* ereg
;
16150 Elf64_Internal_RegInfo reginfo
;
16152 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16153 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16154 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16155 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16156 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16157 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16158 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16160 printf ("GPR %08lx GP 0x",
16161 reginfo
.ri_gprmask
);
16162 printf_vma (reginfo
.ri_gp_value
);
16165 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16166 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16167 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16171 case ODK_EXCEPTIONS
:
16172 fputs (" EXCEPTIONS fpe_min(", stdout
);
16173 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16174 fputs (") fpe_max(", stdout
);
16175 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16176 fputs (")", stdout
);
16178 if (option
->info
& OEX_PAGE0
)
16179 fputs (" PAGE0", stdout
);
16180 if (option
->info
& OEX_SMM
)
16181 fputs (" SMM", stdout
);
16182 if (option
->info
& OEX_FPDBUG
)
16183 fputs (" FPDBUG", stdout
);
16184 if (option
->info
& OEX_DISMISS
)
16185 fputs (" DISMISS", stdout
);
16188 fputs (" PAD ", stdout
);
16189 if (option
->info
& OPAD_PREFIX
)
16190 fputs (" PREFIX", stdout
);
16191 if (option
->info
& OPAD_POSTFIX
)
16192 fputs (" POSTFIX", stdout
);
16193 if (option
->info
& OPAD_SYMBOL
)
16194 fputs (" SYMBOL", stdout
);
16197 fputs (" HWPATCH ", stdout
);
16198 if (option
->info
& OHW_R4KEOP
)
16199 fputs (" R4KEOP", stdout
);
16200 if (option
->info
& OHW_R8KPFETCH
)
16201 fputs (" R8KPFETCH", stdout
);
16202 if (option
->info
& OHW_R5KEOP
)
16203 fputs (" R5KEOP", stdout
);
16204 if (option
->info
& OHW_R5KCVTL
)
16205 fputs (" R5KCVTL", stdout
);
16208 fputs (" FILL ", stdout
);
16209 /* XXX Print content of info word? */
16212 fputs (" TAGS ", stdout
);
16213 /* XXX Print content of info word? */
16216 fputs (" HWAND ", stdout
);
16217 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16218 fputs (" R4KEOP_CHECKED", stdout
);
16219 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16220 fputs (" R4KEOP_CLEAN", stdout
);
16223 fputs (" HWOR ", stdout
);
16224 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16225 fputs (" R4KEOP_CHECKED", stdout
);
16226 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16227 fputs (" R4KEOP_CLEAN", stdout
);
16230 printf (" GP_GROUP %#06lx self-contained %#06lx",
16231 option
->info
& OGP_GROUP
,
16232 (option
->info
& OGP_SELF
) >> 16);
16235 printf (" IDENT %#06lx self-contained %#06lx",
16236 option
->info
& OGP_GROUP
,
16237 (option
->info
& OGP_SELF
) >> 16);
16240 /* This shouldn't happen. */
16241 printf (" %3d ??? %d %lx",
16242 option
->kind
, option
->section
, option
->info
);
16246 len
= sizeof (* eopt
);
16247 while (len
< option
->size
)
16249 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16251 if (ISPRINT (datum
))
16252 printf ("%c", datum
);
16254 printf ("\\%03o", datum
);
16257 fputs ("\n", stdout
);
16259 offset
+= option
->size
;
16269 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16271 Elf32_Conflict
* iconf
;
16274 if (dynamic_symbols
== NULL
)
16276 error (_("conflict list found without a dynamic symbol table\n"));
16280 /* PR 21345 - print a slightly more helpful error message
16281 if we are sure that the cmalloc will fail. */
16282 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16284 error (_("Overlarge number of conflicts detected: %lx\n"),
16285 (long) conflictsno
);
16289 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16292 error (_("Out of memory allocating space for dynamic conflicts\n"));
16298 Elf32_External_Conflict
* econf32
;
16300 econf32
= (Elf32_External_Conflict
*)
16301 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16302 sizeof (* econf32
), _("conflict"));
16306 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16307 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16313 Elf64_External_Conflict
* econf64
;
16315 econf64
= (Elf64_External_Conflict
*)
16316 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16317 sizeof (* econf64
), _("conflict"));
16321 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16322 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16327 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16328 "\nSection '.conflict' contains %lu entries:\n",
16329 (unsigned long) conflictsno
),
16330 (unsigned long) conflictsno
);
16331 puts (_(" Num: Index Value Name"));
16333 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16335 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16337 if (iconf
[cnt
] >= num_dynamic_syms
)
16338 printf (_("<corrupt symbol index>"));
16341 Elf_Internal_Sym
* psym
;
16343 psym
= & dynamic_symbols
[iconf
[cnt
]];
16344 print_vma (psym
->st_value
, FULL_HEX
);
16346 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16347 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16349 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16357 if (pltgot
!= 0 && local_gotno
!= 0)
16359 bfd_vma ent
, local_end
, global_end
;
16361 unsigned char * data
;
16362 unsigned char * data_end
;
16366 addr_size
= (is_32bit_elf
? 4 : 8);
16367 local_end
= pltgot
+ local_gotno
* addr_size
;
16369 /* PR binutils/17533 file: 012-111227-0.004 */
16370 if (symtabno
< gotsym
)
16372 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16373 (unsigned long) gotsym
, (unsigned long) symtabno
);
16377 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16378 /* PR 17531: file: 54c91a34. */
16379 if (global_end
< local_end
)
16381 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16385 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16386 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16387 global_end
- pltgot
, 1,
16388 _("Global Offset Table data"));
16389 /* PR 12855: Null data is handled gracefully throughout. */
16390 data_end
= data
+ (global_end
- pltgot
);
16392 printf (_("\nPrimary GOT:\n"));
16393 printf (_(" Canonical gp value: "));
16394 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16397 printf (_(" Reserved entries:\n"));
16398 printf (_(" %*s %10s %*s Purpose\n"),
16399 addr_size
* 2, _("Address"), _("Access"),
16400 addr_size
* 2, _("Initial"));
16401 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16402 printf (_(" Lazy resolver\n"));
16403 if (ent
== (bfd_vma
) -1)
16404 goto got_print_fail
;
16406 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16407 This entry will be used by some runtime loaders, to store the
16408 module pointer. Otherwise this is an ordinary local entry.
16409 PR 21344: Check for the entry being fully available before
16412 && data
+ ent
- pltgot
+ addr_size
<= data_end
16413 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16414 >> (addr_size
* 8 - 1)) != 0)
16416 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16417 printf (_(" Module pointer (GNU extension)\n"));
16418 if (ent
== (bfd_vma
) -1)
16419 goto got_print_fail
;
16423 if (data
!= NULL
&& ent
< local_end
)
16425 printf (_(" Local entries:\n"));
16426 printf (" %*s %10s %*s\n",
16427 addr_size
* 2, _("Address"), _("Access"),
16428 addr_size
* 2, _("Initial"));
16429 while (ent
< local_end
)
16431 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16433 if (ent
== (bfd_vma
) -1)
16434 goto got_print_fail
;
16439 if (data
!= NULL
&& gotsym
< symtabno
)
16443 printf (_(" Global entries:\n"));
16444 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16445 addr_size
* 2, _("Address"),
16447 addr_size
* 2, _("Initial"),
16448 addr_size
* 2, _("Sym.Val."),
16450 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16451 _("Ndx"), _("Name"));
16453 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16455 for (i
= gotsym
; i
< symtabno
; i
++)
16457 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16460 if (dynamic_symbols
== NULL
)
16461 printf (_("<no dynamic symbols>"));
16462 else if (i
< num_dynamic_syms
)
16464 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16466 print_vma (psym
->st_value
, LONG_HEX
);
16467 printf (" %-7s %3s ",
16468 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16469 get_symbol_index_type (filedata
, psym
->st_shndx
));
16471 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16472 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16474 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16477 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16478 (unsigned long) i
);
16481 if (ent
== (bfd_vma
) -1)
16492 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16495 size_t offset
, rel_offset
;
16496 unsigned long count
, i
;
16497 unsigned char * data
;
16498 int addr_size
, sym_width
;
16499 Elf_Internal_Rela
* rels
;
16501 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16502 if (pltrel
== DT_RELA
)
16504 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16509 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16514 addr_size
= (is_32bit_elf
? 4 : 8);
16515 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16517 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16518 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16519 1, _("Procedure Linkage Table data"));
16523 printf ("\nPLT GOT:\n\n");
16524 printf (_(" Reserved entries:\n"));
16525 printf (_(" %*s %*s Purpose\n"),
16526 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16527 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16528 printf (_(" PLT lazy resolver\n"));
16529 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16530 printf (_(" Module pointer\n"));
16533 printf (_(" Entries:\n"));
16534 printf (" %*s %*s %*s %-7s %3s %s\n",
16535 addr_size
* 2, _("Address"),
16536 addr_size
* 2, _("Initial"),
16537 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16538 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16539 for (i
= 0; i
< count
; i
++)
16541 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16543 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16546 if (idx
>= num_dynamic_syms
)
16547 printf (_("<corrupt symbol index: %lu>"), idx
);
16550 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16552 print_vma (psym
->st_value
, LONG_HEX
);
16553 printf (" %-7s %3s ",
16554 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16555 get_symbol_index_type (filedata
, psym
->st_shndx
));
16556 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16557 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16559 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16574 process_nds32_specific (Filedata
* filedata
)
16576 Elf_Internal_Shdr
*sect
= NULL
;
16578 sect
= find_section (filedata
, ".nds32_e_flags");
16581 unsigned int *flag
;
16583 printf ("\nNDS32 elf flags section:\n");
16584 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16585 sect
->sh_size
, _("NDS32 elf flags section"));
16590 switch ((*flag
) & 0x3)
16593 printf ("(VEC_SIZE):\tNo entry.\n");
16596 printf ("(VEC_SIZE):\t4 bytes\n");
16599 printf ("(VEC_SIZE):\t16 bytes\n");
16602 printf ("(VEC_SIZE):\treserved\n");
16611 process_gnu_liblist (Filedata
* filedata
)
16613 Elf_Internal_Shdr
* section
;
16614 Elf_Internal_Shdr
* string_sec
;
16615 Elf32_External_Lib
* elib
;
16617 size_t strtab_size
;
16619 unsigned long num_liblist
;
16621 bfd_boolean res
= TRUE
;
16626 for (i
= 0, section
= filedata
->section_headers
;
16627 i
< filedata
->file_header
.e_shnum
;
16630 switch (section
->sh_type
)
16632 case SHT_GNU_LIBLIST
:
16633 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16636 elib
= (Elf32_External_Lib
*)
16637 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16638 _("liblist section data"));
16646 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16647 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16648 string_sec
->sh_size
,
16649 _("liblist string table"));
16651 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16658 strtab_size
= string_sec
->sh_size
;
16660 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16661 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16662 "\nLibrary list section '%s' contains %lu entries:\n",
16664 printable_section_name (filedata
, section
),
16667 puts (_(" Library Time Stamp Checksum Version Flags"));
16669 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16677 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16678 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16679 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16680 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16681 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16683 tmp
= gmtime (&atime
);
16684 snprintf (timebuf
, sizeof (timebuf
),
16685 "%04u-%02u-%02uT%02u:%02u:%02u",
16686 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16687 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16689 printf ("%3lu: ", (unsigned long) cnt
);
16691 printf ("%-20s", liblist
.l_name
< strtab_size
16692 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16694 printf ("%-20.20s", liblist
.l_name
< strtab_size
16695 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16696 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16697 liblist
.l_version
, liblist
.l_flags
);
16708 static const char *
16709 get_note_type (Filedata
* filedata
, unsigned e_type
)
16711 static char buff
[64];
16713 if (filedata
->file_header
.e_type
== ET_CORE
)
16717 return _("NT_AUXV (auxiliary vector)");
16719 return _("NT_PRSTATUS (prstatus structure)");
16721 return _("NT_FPREGSET (floating point registers)");
16723 return _("NT_PRPSINFO (prpsinfo structure)");
16724 case NT_TASKSTRUCT
:
16725 return _("NT_TASKSTRUCT (task structure)");
16727 return _("NT_PRXFPREG (user_xfpregs structure)");
16729 return _("NT_PPC_VMX (ppc Altivec registers)");
16731 return _("NT_PPC_VSX (ppc VSX registers)");
16733 return _("NT_PPC_TAR (ppc TAR register)");
16735 return _("NT_PPC_PPR (ppc PPR register)");
16737 return _("NT_PPC_DSCR (ppc DSCR register)");
16739 return _("NT_PPC_EBB (ppc EBB registers)");
16741 return _("NT_PPC_PMU (ppc PMU registers)");
16742 case NT_PPC_TM_CGPR
:
16743 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16744 case NT_PPC_TM_CFPR
:
16745 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16746 case NT_PPC_TM_CVMX
:
16747 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16748 case NT_PPC_TM_CVSX
:
16749 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16750 case NT_PPC_TM_SPR
:
16751 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16752 case NT_PPC_TM_CTAR
:
16753 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16754 case NT_PPC_TM_CPPR
:
16755 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16756 case NT_PPC_TM_CDSCR
:
16757 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16759 return _("NT_386_TLS (x86 TLS information)");
16760 case NT_386_IOPERM
:
16761 return _("NT_386_IOPERM (x86 I/O permissions)");
16762 case NT_X86_XSTATE
:
16763 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16764 case NT_S390_HIGH_GPRS
:
16765 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16766 case NT_S390_TIMER
:
16767 return _("NT_S390_TIMER (s390 timer register)");
16768 case NT_S390_TODCMP
:
16769 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16770 case NT_S390_TODPREG
:
16771 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16773 return _("NT_S390_CTRS (s390 control registers)");
16774 case NT_S390_PREFIX
:
16775 return _("NT_S390_PREFIX (s390 prefix register)");
16776 case NT_S390_LAST_BREAK
:
16777 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16778 case NT_S390_SYSTEM_CALL
:
16779 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16781 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16782 case NT_S390_VXRS_LOW
:
16783 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16784 case NT_S390_VXRS_HIGH
:
16785 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16786 case NT_S390_GS_CB
:
16787 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16788 case NT_S390_GS_BC
:
16789 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16791 return _("NT_ARM_VFP (arm VFP registers)");
16793 return _("NT_ARM_TLS (AArch TLS registers)");
16794 case NT_ARM_HW_BREAK
:
16795 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16796 case NT_ARM_HW_WATCH
:
16797 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16799 return _("NT_PSTATUS (pstatus structure)");
16801 return _("NT_FPREGS (floating point registers)");
16803 return _("NT_PSINFO (psinfo structure)");
16805 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16807 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16808 case NT_WIN32PSTATUS
:
16809 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16811 return _("NT_SIGINFO (siginfo_t data)");
16813 return _("NT_FILE (mapped files)");
16821 return _("NT_VERSION (version)");
16823 return _("NT_ARCH (architecture)");
16824 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16826 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16832 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16837 print_core_note (Elf_Internal_Note
*pnote
)
16839 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16840 bfd_vma count
, page_size
;
16841 unsigned char *descdata
, *filenames
, *descend
;
16843 if (pnote
->type
!= NT_FILE
)
16853 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16854 /* Still "successful". */
16859 if (pnote
->descsz
< 2 * addr_size
)
16861 error (_(" Malformed note - too short for header\n"));
16865 descdata
= (unsigned char *) pnote
->descdata
;
16866 descend
= descdata
+ pnote
->descsz
;
16868 if (descdata
[pnote
->descsz
- 1] != '\0')
16870 error (_(" Malformed note - does not end with \\0\n"));
16874 count
= byte_get (descdata
, addr_size
);
16875 descdata
+= addr_size
;
16877 page_size
= byte_get (descdata
, addr_size
);
16878 descdata
+= addr_size
;
16880 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16881 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16883 error (_(" Malformed note - too short for supplied file count\n"));
16887 printf (_(" Page size: "));
16888 print_vma (page_size
, DEC
);
16891 printf (_(" %*s%*s%*s\n"),
16892 (int) (2 + 2 * addr_size
), _("Start"),
16893 (int) (4 + 2 * addr_size
), _("End"),
16894 (int) (4 + 2 * addr_size
), _("Page Offset"));
16895 filenames
= descdata
+ count
* 3 * addr_size
;
16896 while (count
-- > 0)
16898 bfd_vma start
, end
, file_ofs
;
16900 if (filenames
== descend
)
16902 error (_(" Malformed note - filenames end too early\n"));
16906 start
= byte_get (descdata
, addr_size
);
16907 descdata
+= addr_size
;
16908 end
= byte_get (descdata
, addr_size
);
16909 descdata
+= addr_size
;
16910 file_ofs
= byte_get (descdata
, addr_size
);
16911 descdata
+= addr_size
;
16914 print_vma (start
, FULL_HEX
);
16916 print_vma (end
, FULL_HEX
);
16918 print_vma (file_ofs
, FULL_HEX
);
16919 printf ("\n %s\n", filenames
);
16921 filenames
+= 1 + strlen ((char *) filenames
);
16927 static const char *
16928 get_gnu_elf_note_type (unsigned e_type
)
16930 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16933 case NT_GNU_ABI_TAG
:
16934 return _("NT_GNU_ABI_TAG (ABI version tag)");
16936 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16937 case NT_GNU_BUILD_ID
:
16938 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16939 case NT_GNU_GOLD_VERSION
:
16940 return _("NT_GNU_GOLD_VERSION (gold version)");
16941 case NT_GNU_PROPERTY_TYPE_0
:
16942 return _("NT_GNU_PROPERTY_TYPE_0");
16943 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16944 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16945 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16946 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16949 static char buff
[64];
16951 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16958 decode_x86_compat_isa (unsigned int bitmask
)
16962 unsigned int bit
= bitmask
& (- bitmask
);
16967 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
16970 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
16973 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
16976 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
16979 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
16982 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
16985 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
16988 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
16991 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
16994 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
16997 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17000 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17001 printf ("AVX512F");
17003 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17004 printf ("AVX512CD");
17006 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17007 printf ("AVX512ER");
17009 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17010 printf ("AVX512PF");
17012 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17013 printf ("AVX512VL");
17015 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17016 printf ("AVX512DQ");
17018 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17019 printf ("AVX512BW");
17022 printf (_("<unknown: %x>"), bit
);
17031 decode_x86_isa (unsigned int bitmask
)
17033 if (bitmask
== GNU_PROPERTY_X86_UINT32_VALID
)
17035 printf (_("<None>"));
17039 bitmask
&= ~GNU_PROPERTY_X86_UINT32_VALID
;
17043 unsigned int bit
= bitmask
& (- bitmask
);
17048 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17051 case GNU_PROPERTY_X86_ISA_1_SSE
:
17054 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17057 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17060 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17063 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17066 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17069 case GNU_PROPERTY_X86_ISA_1_AVX
:
17072 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17075 case GNU_PROPERTY_X86_ISA_1_FMA
:
17078 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17079 printf ("AVX512F");
17081 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17082 printf ("AVX512CD");
17084 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17085 printf ("AVX512ER");
17087 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17088 printf ("AVX512PF");
17090 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17091 printf ("AVX512VL");
17093 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17094 printf ("AVX512DQ");
17096 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17097 printf ("AVX512BW");
17099 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17100 printf ("AVX512_4FMAPS");
17102 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17103 printf ("AVX512_4VNNIW");
17105 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17106 printf ("AVX512_BITALG");
17108 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17109 printf ("AVX512_IFMA");
17111 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17112 printf ("AVX512_VBMI");
17114 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17115 printf ("AVX512_VBMI2");
17117 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17118 printf ("AVX512_VNNI");
17121 printf (_("<unknown: %x>"), bit
);
17130 decode_x86_feature_1 (unsigned int bitmask
)
17132 if (bitmask
== GNU_PROPERTY_X86_UINT32_VALID
)
17134 printf (_("<None>"));
17138 bitmask
&= ~GNU_PROPERTY_X86_UINT32_VALID
;
17142 unsigned int bit
= bitmask
& (- bitmask
);
17147 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17150 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17154 printf (_("<unknown: %x>"), bit
);
17163 decode_x86_feature_2 (unsigned int bitmask
)
17165 if (bitmask
== GNU_PROPERTY_X86_UINT32_VALID
)
17167 printf (_("<None>"));
17171 bitmask
&= ~GNU_PROPERTY_X86_UINT32_VALID
;
17175 unsigned int bit
= bitmask
& (- bitmask
);
17180 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17183 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17186 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17189 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17192 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17195 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17198 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17201 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17204 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17205 printf ("XSAVEOPT");
17207 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17211 printf (_("<unknown: %x>"), bit
);
17220 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17222 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17223 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17224 unsigned int size
= is_32bit_elf
? 4 : 8;
17226 printf (_(" Properties: "));
17228 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17230 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17234 while (ptr
< ptr_end
)
17238 unsigned int datasz
;
17240 if ((size_t) (ptr_end
- ptr
) < 8)
17242 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17246 type
= byte_get (ptr
, 4);
17247 datasz
= byte_get (ptr
+ 4, 4);
17251 if (datasz
> (size_t) (ptr_end
- ptr
))
17253 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17258 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17260 if (filedata
->file_header
.e_machine
== EM_X86_64
17261 || filedata
->file_header
.e_machine
== EM_IAMCU
17262 || filedata
->file_header
.e_machine
== EM_386
)
17264 unsigned int bitmask
;
17268 bitmask
= byte_get (ptr
, 4);
17269 if ((filedata
->file_header
.e_type
== ET_EXEC
17270 || filedata
->file_header
.e_type
== ET_DYN
)
17271 && !(bitmask
& GNU_PROPERTY_X86_UINT32_VALID
))
17272 printf ("Invalid ");
17279 case GNU_PROPERTY_X86_ISA_1_USED
:
17281 printf (_("x86 ISA used: <corrupt length: %#x> "),
17285 printf ("x86 ISA used: ");
17286 decode_x86_isa (bitmask
);
17290 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17292 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17296 printf ("x86 ISA needed: ");
17297 decode_x86_isa (bitmask
);
17301 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17303 printf (_("x86 feature: <corrupt length: %#x> "),
17307 printf ("x86 feature: ");
17308 decode_x86_feature_1 (bitmask
);
17312 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17314 printf (_("x86 feature used: <corrupt length: %#x> "),
17318 printf ("x86 feature used: ");
17319 decode_x86_feature_2 (bitmask
);
17323 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17325 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17328 printf ("x86 feature needed: ");
17329 decode_x86_feature_2 (bitmask
);
17333 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17335 printf (_("x86 ISA used: <corrupt length: %#x> "),
17339 printf ("x86 ISA used: ");
17340 decode_x86_compat_isa (bitmask
);
17344 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
17346 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17350 printf ("x86 ISA needed: ");
17351 decode_x86_compat_isa (bitmask
);
17364 case GNU_PROPERTY_STACK_SIZE
:
17365 printf (_("stack size: "));
17366 if (datasz
!= size
)
17367 printf (_("<corrupt length: %#x> "), datasz
);
17369 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17372 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17373 printf ("no copy on protected ");
17375 printf (_("<corrupt length: %#x> "), datasz
);
17383 if (type
< GNU_PROPERTY_LOPROC
)
17384 printf (_("<unknown type %#x data: "), type
);
17385 else if (type
< GNU_PROPERTY_LOUSER
)
17386 printf (_("<procesor-specific type %#x data: "), type
);
17388 printf (_("<application-specific type %#x data: "), type
);
17389 for (j
= 0; j
< datasz
; ++j
)
17390 printf ("%02x ", ptr
[j
] & 0xff);
17394 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17395 if (ptr
== ptr_end
)
17408 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17410 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17411 switch (pnote
->type
)
17413 case NT_GNU_BUILD_ID
:
17417 printf (_(" Build ID: "));
17418 for (i
= 0; i
< pnote
->descsz
; ++i
)
17419 printf ("%02x", pnote
->descdata
[i
] & 0xff);
17424 case NT_GNU_ABI_TAG
:
17426 unsigned long os
, major
, minor
, subminor
;
17427 const char *osname
;
17429 /* PR 17531: file: 030-599401-0.004. */
17430 if (pnote
->descsz
< 16)
17432 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17436 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17437 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17438 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
17439 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
17443 case GNU_ABI_TAG_LINUX
:
17446 case GNU_ABI_TAG_HURD
:
17449 case GNU_ABI_TAG_SOLARIS
:
17450 osname
= "Solaris";
17452 case GNU_ABI_TAG_FREEBSD
:
17453 osname
= "FreeBSD";
17455 case GNU_ABI_TAG_NETBSD
:
17458 case GNU_ABI_TAG_SYLLABLE
:
17459 osname
= "Syllable";
17461 case GNU_ABI_TAG_NACL
:
17465 osname
= "Unknown";
17469 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17470 major
, minor
, subminor
);
17474 case NT_GNU_GOLD_VERSION
:
17478 printf (_(" Version: "));
17479 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17480 printf ("%c", pnote
->descdata
[i
]);
17487 unsigned long num_entries
, mask
;
17489 /* Hardware capabilities information. Word 0 is the number of entries.
17490 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17491 is a series of entries, where each entry is a single byte followed
17492 by a nul terminated string. The byte gives the bit number to test
17493 if enabled in the bitmask. */
17494 printf (_(" Hardware Capabilities: "));
17495 if (pnote
->descsz
< 8)
17497 error (_("<corrupt GNU_HWCAP>\n"));
17500 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17501 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17502 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17503 /* FIXME: Add code to display the entries... */
17507 case NT_GNU_PROPERTY_TYPE_0
:
17508 print_gnu_property_note (filedata
, pnote
);
17512 /* Handle unrecognised types. An error message should have already been
17513 created by get_gnu_elf_note_type(), so all that we need to do is to
17514 display the data. */
17518 printf (_(" Description data: "));
17519 for (i
= 0; i
< pnote
->descsz
; ++i
)
17520 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17529 static const char *
17530 get_v850_elf_note_type (enum v850_notes n_type
)
17532 static char buff
[64];
17536 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17537 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17538 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17539 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17540 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17541 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17543 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17549 print_v850_note (Elf_Internal_Note
* pnote
)
17553 if (pnote
->descsz
!= 4)
17556 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17560 printf (_("not set\n"));
17564 switch (pnote
->type
)
17566 case V850_NOTE_ALIGNMENT
:
17569 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17570 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17574 case V850_NOTE_DATA_SIZE
:
17577 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17578 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17582 case V850_NOTE_FPU_INFO
:
17585 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17586 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17590 case V850_NOTE_MMU_INFO
:
17591 case V850_NOTE_CACHE_INFO
:
17592 case V850_NOTE_SIMD_INFO
:
17593 if (val
== EF_RH850_SIMD
)
17595 printf (_("yes\n"));
17601 /* An 'unknown note type' message will already have been displayed. */
17605 printf (_("unknown value: %x\n"), val
);
17610 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17612 unsigned int version
;
17614 switch (pnote
->type
)
17616 case NT_NETBSD_IDENT
:
17617 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17618 if ((version
/ 10000) % 100)
17619 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17620 version
, version
/ 100000000, (version
/ 1000000) % 100,
17621 (version
/ 10000) % 100 > 26 ? "Z" : "",
17622 'A' + (version
/ 10000) % 26);
17624 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17625 version
, version
/ 100000000, (version
/ 1000000) % 100,
17626 (version
/ 100) % 100);
17629 case NT_NETBSD_MARCH
:
17630 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17635 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17641 static const char *
17642 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17646 case NT_FREEBSD_THRMISC
:
17647 return _("NT_THRMISC (thrmisc structure)");
17648 case NT_FREEBSD_PROCSTAT_PROC
:
17649 return _("NT_PROCSTAT_PROC (proc data)");
17650 case NT_FREEBSD_PROCSTAT_FILES
:
17651 return _("NT_PROCSTAT_FILES (files data)");
17652 case NT_FREEBSD_PROCSTAT_VMMAP
:
17653 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17654 case NT_FREEBSD_PROCSTAT_GROUPS
:
17655 return _("NT_PROCSTAT_GROUPS (groups data)");
17656 case NT_FREEBSD_PROCSTAT_UMASK
:
17657 return _("NT_PROCSTAT_UMASK (umask data)");
17658 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17659 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17660 case NT_FREEBSD_PROCSTAT_OSREL
:
17661 return _("NT_PROCSTAT_OSREL (osreldate data)");
17662 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17663 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17664 case NT_FREEBSD_PROCSTAT_AUXV
:
17665 return _("NT_PROCSTAT_AUXV (auxv data)");
17666 case NT_FREEBSD_PTLWPINFO
:
17667 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17669 return get_note_type (filedata
, e_type
);
17672 static const char *
17673 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17675 static char buff
[64];
17677 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17678 return _("NetBSD procinfo structure");
17680 /* As of Jan 2002 there are no other machine-independent notes
17681 defined for NetBSD core files. If the note type is less
17682 than the start of the machine-dependent note types, we don't
17685 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17687 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17691 switch (filedata
->file_header
.e_machine
)
17693 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17694 and PT_GETFPREGS == mach+2. */
17699 case EM_SPARC32PLUS
:
17703 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17704 return _("PT_GETREGS (reg structure)");
17705 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17706 return _("PT_GETFPREGS (fpreg structure)");
17712 /* On all other arch's, PT_GETREGS == mach+1 and
17713 PT_GETFPREGS == mach+3. */
17717 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17718 return _("PT_GETREGS (reg structure)");
17719 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17720 return _("PT_GETFPREGS (fpreg structure)");
17726 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17727 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17731 static const char *
17732 get_stapsdt_note_type (unsigned e_type
)
17734 static char buff
[64];
17739 return _("NT_STAPSDT (SystemTap probe descriptors)");
17745 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17750 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17752 int addr_size
= is_32bit_elf
? 4 : 8;
17753 char *data
= pnote
->descdata
;
17754 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17755 bfd_vma pc
, base_addr
, semaphore
;
17756 char *provider
, *probe
, *arg_fmt
;
17758 pc
= byte_get ((unsigned char *) data
, addr_size
);
17760 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17762 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17766 data
+= strlen (data
) + 1;
17768 data
+= strlen (data
) + 1;
17770 data
+= strlen (data
) + 1;
17772 printf (_(" Provider: %s\n"), provider
);
17773 printf (_(" Name: %s\n"), probe
);
17774 printf (_(" Location: "));
17775 print_vma (pc
, FULL_HEX
);
17776 printf (_(", Base: "));
17777 print_vma (base_addr
, FULL_HEX
);
17778 printf (_(", Semaphore: "));
17779 print_vma (semaphore
, FULL_HEX
);
17781 printf (_(" Arguments: %s\n"), arg_fmt
);
17783 return data
== data_end
;
17786 static const char *
17787 get_ia64_vms_note_type (unsigned e_type
)
17789 static char buff
[64];
17794 return _("NT_VMS_MHD (module header)");
17796 return _("NT_VMS_LNM (language name)");
17798 return _("NT_VMS_SRC (source files)");
17800 return "NT_VMS_TITLE";
17802 return _("NT_VMS_EIDC (consistency check)");
17803 case NT_VMS_FPMODE
:
17804 return _("NT_VMS_FPMODE (FP mode)");
17805 case NT_VMS_LINKTIME
:
17806 return "NT_VMS_LINKTIME";
17807 case NT_VMS_IMGNAM
:
17808 return _("NT_VMS_IMGNAM (image name)");
17810 return _("NT_VMS_IMGID (image id)");
17811 case NT_VMS_LINKID
:
17812 return _("NT_VMS_LINKID (link id)");
17813 case NT_VMS_IMGBID
:
17814 return _("NT_VMS_IMGBID (build id)");
17815 case NT_VMS_GSTNAM
:
17816 return _("NT_VMS_GSTNAM (sym table name)");
17817 case NT_VMS_ORIG_DYN
:
17818 return "NT_VMS_ORIG_DYN";
17819 case NT_VMS_PATCHTIME
:
17820 return "NT_VMS_PATCHTIME";
17822 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17828 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17830 switch (pnote
->type
)
17833 if (pnote
->descsz
> 36)
17835 size_t l
= strlen (pnote
->descdata
+ 34);
17836 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17837 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17838 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17839 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17842 printf (_(" Invalid size\n"));
17845 printf (_(" Language: %s\n"), pnote
->descdata
);
17848 case NT_VMS_FPMODE
:
17849 printf (_(" Floating Point mode: "));
17850 printf ("0x%016" BFD_VMA_FMT
"x\n",
17851 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17853 case NT_VMS_LINKTIME
:
17854 printf (_(" Link time: "));
17856 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17859 case NT_VMS_PATCHTIME
:
17860 printf (_(" Patch time: "));
17862 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17865 case NT_VMS_ORIG_DYN
:
17866 printf (_(" Major id: %u, minor id: %u\n"),
17867 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17868 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17869 printf (_(" Last modified : "));
17871 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17872 printf (_("\n Link flags : "));
17873 printf ("0x%016" BFD_VMA_FMT
"x\n",
17874 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17875 printf (_(" Header flags: 0x%08x\n"),
17876 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17877 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17880 case NT_VMS_IMGNAM
:
17881 printf (_(" Image name: %s\n"), pnote
->descdata
);
17883 case NT_VMS_GSTNAM
:
17884 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17887 printf (_(" Image id: %s\n"), pnote
->descdata
);
17889 case NT_VMS_LINKID
:
17890 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17898 /* Find the symbol associated with a build attribute that is attached
17899 to address OFFSET. If PNAME is non-NULL then store the name of
17900 the symbol (if found) in the provided pointer, Returns NULL if a
17901 symbol could not be found. */
17903 static Elf_Internal_Sym
*
17904 get_symbol_for_build_attribute (Filedata
* filedata
,
17905 unsigned long offset
,
17906 bfd_boolean is_open_attr
,
17907 const char ** pname
)
17909 static Filedata
* saved_filedata
= NULL
;
17910 static char * strtab
;
17911 static unsigned long strtablen
;
17912 static Elf_Internal_Sym
* symtab
;
17913 static unsigned long nsyms
;
17914 Elf_Internal_Sym
* saved_sym
= NULL
;
17915 Elf_Internal_Sym
* sym
;
17917 if (filedata
->section_headers
!= NULL
17918 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17920 Elf_Internal_Shdr
* symsec
;
17922 /* Load the symbol and string sections. */
17923 for (symsec
= filedata
->section_headers
;
17924 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17927 if (symsec
->sh_type
== SHT_SYMTAB
)
17929 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17931 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17933 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17935 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17936 1, strtab_sec
->sh_size
,
17937 _("string table"));
17938 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17942 saved_filedata
= filedata
;
17945 if (symtab
== NULL
|| strtab
== NULL
)
17948 /* Find a symbol whose value matches offset. */
17949 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17950 if (sym
->st_value
== offset
)
17952 if (sym
->st_name
>= strtablen
)
17953 /* Huh ? This should not happen. */
17956 if (strtab
[sym
->st_name
] == 0)
17959 /* The AArch64 and ARM architectures define mapping symbols
17960 (eg $d, $x, $t) which we want to ignore. */
17961 if (strtab
[sym
->st_name
] == '$'
17962 && strtab
[sym
->st_name
+ 1] != 0
17963 && strtab
[sym
->st_name
+ 2] == 0)
17968 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17969 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17970 FUNC symbols entirely. */
17971 switch (ELF_ST_TYPE (sym
->st_info
))
17978 /* If the symbol has a size associated
17979 with it then we can stop searching. */
17980 sym
= symtab
+ nsyms
;
17985 /* Ignore function symbols. */
17992 switch (ELF_ST_BIND (sym
->st_info
))
17995 if (saved_sym
== NULL
17996 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18001 if (saved_sym
== NULL
)
18011 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18019 if (saved_sym
&& pname
)
18020 * pname
= strtab
+ saved_sym
->st_name
;
18025 /* Returns true iff addr1 and addr2 are in the same section. */
18028 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18030 Elf_Internal_Shdr
* a1
;
18031 Elf_Internal_Shdr
* a2
;
18033 a1
= find_section_by_address (filedata
, addr1
);
18034 a2
= find_section_by_address (filedata
, addr2
);
18036 return a1
== a2
&& a1
!= NULL
;
18040 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18041 Filedata
* filedata
)
18043 static unsigned long global_offset
= 0;
18044 static unsigned long global_end
= 0;
18045 static unsigned long func_offset
= 0;
18046 static unsigned long func_end
= 0;
18048 Elf_Internal_Sym
* sym
;
18050 unsigned long start
;
18052 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18054 switch (pnote
->descsz
)
18057 /* A zero-length description means that the range of
18058 the previous note of the same type should be used. */
18061 if (global_end
> global_offset
)
18062 printf (_(" Applies to region from %#lx to %#lx\n"),
18063 global_offset
, global_end
);
18065 printf (_(" Applies to region from %#lx\n"), global_offset
);
18069 if (func_end
> func_offset
)
18070 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18072 printf (_(" Applies to region from %#lx\n"), func_offset
);
18077 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18084 /* FIXME: We should check that version 3+ notes are being used here... */
18085 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18086 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18090 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18096 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18097 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18101 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18102 printf (_(" <invalid descsz>"));
18107 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18108 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18109 in order to avoid them being confused with the start address of the
18110 first function in the file... */
18111 if (sym
== NULL
&& is_open_attr
)
18112 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18115 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18116 end
= start
+ sym
->st_size
;
18120 /* FIXME: Need to properly allow for section alignment.
18121 16 is just the alignment used on x86_64. */
18123 && start
> BFD_ALIGN (global_end
, 16)
18124 /* Build notes are not guaranteed to be organised in order of
18125 increasing address, but we should find the all of the notes
18126 for one section in the same place. */
18127 && same_section (filedata
, start
, global_end
))
18128 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18129 global_end
+ 1, start
- 1);
18131 printf (_(" Applies to region from %#lx"), start
);
18132 global_offset
= start
;
18136 printf (_(" to %#lx"), end
);
18142 printf (_(" Applies to region from %#lx"), start
);
18143 func_offset
= start
;
18147 printf (_(" to %#lx"), end
);
18153 printf (_(" (%s)"), name
);
18160 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18162 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18163 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18164 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18166 char name_attribute
;
18167 const char * expected_types
;
18168 const char * name
= pnote
->namedata
;
18172 if (name
== NULL
|| pnote
->namesz
< 2)
18174 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18175 print_symbol (-20, _(" <corrupt name>"));
18184 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18185 if (name
[0] == 'G' && name
[1] == 'A')
18187 if (pnote
->namesz
< 4)
18189 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18190 print_symbol (-20, _(" <corrupt name>"));
18199 switch ((name_type
= * name
))
18201 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18202 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18203 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18204 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18205 printf ("%c", * name
);
18209 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
18210 print_symbol (-20, _("<unknown name type>"));
18217 switch ((name_attribute
= * name
))
18219 case GNU_BUILD_ATTRIBUTE_VERSION
:
18220 text
= _("<version>");
18221 expected_types
= string_expected
;
18224 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18225 text
= _("<stack prot>");
18226 expected_types
= "!+*";
18229 case GNU_BUILD_ATTRIBUTE_RELRO
:
18230 text
= _("<relro>");
18231 expected_types
= bool_expected
;
18234 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
18235 text
= _("<stack size>");
18236 expected_types
= number_expected
;
18239 case GNU_BUILD_ATTRIBUTE_TOOL
:
18240 text
= _("<tool>");
18241 expected_types
= string_expected
;
18244 case GNU_BUILD_ATTRIBUTE_ABI
:
18246 expected_types
= "$*";
18249 case GNU_BUILD_ATTRIBUTE_PIC
:
18251 expected_types
= number_expected
;
18254 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
18255 text
= _("<short enum>");
18256 expected_types
= bool_expected
;
18260 if (ISPRINT (* name
))
18262 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
18264 if (len
> left
&& ! do_wide
)
18266 printf ("%.*s:", len
, name
);
18272 static char tmpbuf
[128];
18274 error (_("unrecognised byte in name field: %d\n"), * name
);
18275 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
18279 expected_types
= "*$!+";
18284 left
-= printf ("%s", text
);
18286 if (strchr (expected_types
, name_type
) == NULL
)
18287 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
18289 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
18291 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18292 (unsigned long) pnote
->namesz
,
18293 (long) (name
- pnote
->namedata
));
18297 if (left
< 1 && ! do_wide
)
18302 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18304 unsigned int bytes
;
18305 unsigned long long val
= 0;
18306 unsigned int shift
= 0;
18307 char * decoded
= NULL
;
18309 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
18311 /* The -1 is because the name field is always 0 terminated, and we
18312 want to be able to ensure that the shift in the while loop below
18313 will not overflow. */
18316 if (bytes
> sizeof (val
))
18318 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18320 bytes
= sizeof (val
);
18322 /* We do not bother to warn if bytes == 0 as this can
18323 happen with some early versions of the gcc plugin. */
18327 unsigned long byte
= (* name
++) & 0xff;
18329 val
|= byte
<< shift
;
18333 switch (name_attribute
)
18335 case GNU_BUILD_ATTRIBUTE_PIC
:
18338 case 0: decoded
= "static"; break;
18339 case 1: decoded
= "pic"; break;
18340 case 2: decoded
= "PIC"; break;
18341 case 3: decoded
= "pie"; break;
18342 case 4: decoded
= "PIE"; break;
18346 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18349 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18350 case 0: decoded
= "off"; break;
18351 case 1: decoded
= "on"; break;
18352 case 2: decoded
= "all"; break;
18353 case 3: decoded
= "strong"; break;
18354 case 4: decoded
= "explicit"; break;
18362 if (decoded
!= NULL
)
18364 print_symbol (-left
, decoded
);
18375 left
-= printf ("0x%llx", val
);
18377 left
-= printf ("0x%-.*llx", left
, val
);
18381 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18382 left
-= print_symbol (- left
, name
);
18384 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18385 left
-= print_symbol (- left
, "true");
18387 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18388 left
-= print_symbol (- left
, "false");
18392 if (do_wide
&& left
> 0)
18393 printf ("%-*s", left
, " ");
18398 /* Note that by the ELF standard, the name field is already null byte
18399 terminated, and namesz includes the terminating null byte.
18400 I.E. the value of namesz for the name "FSF" is 4.
18402 If the value of namesz is zero, there is no name present. */
18405 process_note (Elf_Internal_Note
* pnote
,
18406 Filedata
* filedata
)
18408 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
18411 if (pnote
->namesz
== 0)
18412 /* If there is no note name, then use the default set of
18413 note type strings. */
18414 nt
= get_note_type (filedata
, pnote
->type
);
18416 else if (const_strneq (pnote
->namedata
, "GNU"))
18417 /* GNU-specific object file notes. */
18418 nt
= get_gnu_elf_note_type (pnote
->type
);
18420 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
18421 /* FreeBSD-specific core file notes. */
18422 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
18424 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
18425 /* NetBSD-specific core file notes. */
18426 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
18428 else if (const_strneq (pnote
->namedata
, "NetBSD"))
18429 /* NetBSD-specific core file notes. */
18430 return process_netbsd_elf_note (pnote
);
18432 else if (strneq (pnote
->namedata
, "SPU/", 4))
18434 /* SPU-specific core file notes. */
18435 nt
= pnote
->namedata
+ 4;
18439 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18440 /* VMS/ia64-specific file notes. */
18441 nt
= get_ia64_vms_note_type (pnote
->type
);
18443 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18444 nt
= get_stapsdt_note_type (pnote
->type
);
18447 /* Don't recognize this note name; just use the default set of
18448 note type strings. */
18449 nt
= get_note_type (filedata
, pnote
->type
);
18453 if (((const_strneq (pnote
->namedata
, "GA")
18454 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18455 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18456 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18457 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18458 print_gnu_build_attribute_name (pnote
);
18460 print_symbol (-20, name
);
18463 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
18465 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
18467 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18468 return print_ia64_vms_note (pnote
);
18469 else if (const_strneq (pnote
->namedata
, "GNU"))
18470 return print_gnu_note (filedata
, pnote
);
18471 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18472 return print_stapsdt_note (pnote
);
18473 else if (const_strneq (pnote
->namedata
, "CORE"))
18474 return print_core_note (pnote
);
18475 else if (((const_strneq (pnote
->namedata
, "GA")
18476 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18477 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18478 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18479 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18480 return print_gnu_build_attribute_description (pnote
, filedata
);
18486 printf (_(" description data: "));
18487 for (i
= 0; i
< pnote
->descsz
; i
++)
18488 printf ("%02x ", pnote
->descdata
[i
]);
18500 process_notes_at (Filedata
* filedata
,
18501 Elf_Internal_Shdr
* section
,
18506 Elf_External_Note
* pnotes
;
18507 Elf_External_Note
* external
;
18509 bfd_boolean res
= TRUE
;
18516 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18519 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18524 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18527 if (pnotes
== NULL
)
18533 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18535 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18536 (unsigned long) offset
, (unsigned long) length
);
18538 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18539 specifies that notes should be aligned to 4 bytes in 32-bit
18540 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18541 we also support 4 byte alignment in 64-bit objects. If section
18542 alignment is less than 4, we treate alignment as 4 bytes. */
18545 else if (align
!= 4 && align
!= 8)
18547 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18552 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18554 end
= (char *) pnotes
+ length
;
18555 while ((char *) external
< end
)
18557 Elf_Internal_Note inote
;
18560 char * temp
= NULL
;
18561 size_t data_remaining
= end
- (char *) external
;
18563 if (!is_ia64_vms (filedata
))
18565 /* PR binutils/15191
18566 Make sure that there is enough data to read. */
18567 min_notesz
= offsetof (Elf_External_Note
, name
);
18568 if (data_remaining
< min_notesz
)
18570 warn (ngettext ("Corrupt note: only %ld byte remains, "
18571 "not enough for a full note\n",
18572 "Corrupt note: only %ld bytes remain, "
18573 "not enough for a full note\n",
18575 (long) data_remaining
);
18578 data_remaining
-= min_notesz
;
18580 inote
.type
= BYTE_GET (external
->type
);
18581 inote
.namesz
= BYTE_GET (external
->namesz
);
18582 inote
.namedata
= external
->name
;
18583 inote
.descsz
= BYTE_GET (external
->descsz
);
18584 inote
.descdata
= ((char *) external
18585 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18586 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18587 next
= ((char *) external
18588 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18592 Elf64_External_VMS_Note
*vms_external
;
18594 /* PR binutils/15191
18595 Make sure that there is enough data to read. */
18596 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18597 if (data_remaining
< min_notesz
)
18599 warn (ngettext ("Corrupt note: only %ld byte remains, "
18600 "not enough for a full note\n",
18601 "Corrupt note: only %ld bytes remain, "
18602 "not enough for a full note\n",
18604 (long) data_remaining
);
18607 data_remaining
-= min_notesz
;
18609 vms_external
= (Elf64_External_VMS_Note
*) external
;
18610 inote
.type
= BYTE_GET (vms_external
->type
);
18611 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18612 inote
.namedata
= vms_external
->name
;
18613 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18614 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18615 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18616 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18619 /* PR 17531: file: 3443835e. */
18620 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18621 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18622 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18623 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18624 || ((size_t) (next
- inote
.descdata
)
18625 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18627 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18628 (unsigned long) ((char *) external
- (char *) pnotes
));
18629 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18630 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18634 external
= (Elf_External_Note
*) next
;
18636 /* Verify that name is null terminated. It appears that at least
18637 one version of Linux (RedHat 6.0) generates corefiles that don't
18638 comply with the ELF spec by failing to include the null byte in
18640 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18642 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18644 temp
= (char *) malloc (inote
.namesz
+ 1);
18647 error (_("Out of memory allocating space for inote name\n"));
18652 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18653 inote
.namedata
= temp
;
18655 inote
.namedata
[inote
.namesz
] = 0;
18658 if (! process_note (& inote
, filedata
))
18674 process_corefile_note_segments (Filedata
* filedata
)
18676 Elf_Internal_Phdr
* segment
;
18678 bfd_boolean res
= TRUE
;
18680 if (! get_program_headers (filedata
))
18683 for (i
= 0, segment
= filedata
->program_headers
;
18684 i
< filedata
->file_header
.e_phnum
;
18687 if (segment
->p_type
== PT_NOTE
)
18688 if (! process_notes_at (filedata
, NULL
,
18689 (bfd_vma
) segment
->p_offset
,
18690 (bfd_vma
) segment
->p_filesz
,
18691 (bfd_vma
) segment
->p_align
))
18699 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18701 Elf_External_Note
* pnotes
;
18702 Elf_External_Note
* external
;
18704 bfd_boolean res
= TRUE
;
18709 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18711 if (pnotes
== NULL
)
18715 end
= (char*) pnotes
+ length
;
18717 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18718 (unsigned long) offset
, (unsigned long) length
);
18720 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18722 Elf_External_Note
* next
;
18723 Elf_Internal_Note inote
;
18725 inote
.type
= BYTE_GET (external
->type
);
18726 inote
.namesz
= BYTE_GET (external
->namesz
);
18727 inote
.namedata
= external
->name
;
18728 inote
.descsz
= BYTE_GET (external
->descsz
);
18729 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18730 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18732 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18734 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18735 inote
.descdata
= inote
.namedata
;
18739 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18741 if ( ((char *) next
> end
)
18742 || ((char *) next
< (char *) pnotes
))
18744 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18745 (unsigned long) ((char *) external
- (char *) pnotes
));
18746 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18747 inote
.type
, inote
.namesz
, inote
.descsz
);
18753 /* Prevent out-of-bounds indexing. */
18754 if ( inote
.namedata
+ inote
.namesz
> end
18755 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18757 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18758 (unsigned long) ((char *) external
- (char *) pnotes
));
18759 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18760 inote
.type
, inote
.namesz
, inote
.descsz
);
18764 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18766 if (! print_v850_note (& inote
))
18769 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18770 inote
.namesz
, inote
.descsz
);
18780 process_note_sections (Filedata
* filedata
)
18782 Elf_Internal_Shdr
* section
;
18784 unsigned int n
= 0;
18785 bfd_boolean res
= TRUE
;
18787 for (i
= 0, section
= filedata
->section_headers
;
18788 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18791 if (section
->sh_type
== SHT_NOTE
)
18793 if (! process_notes_at (filedata
, section
,
18794 (bfd_vma
) section
->sh_offset
,
18795 (bfd_vma
) section
->sh_size
,
18796 (bfd_vma
) section
->sh_addralign
))
18801 if (( filedata
->file_header
.e_machine
== EM_V800
18802 || filedata
->file_header
.e_machine
== EM_V850
18803 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18804 && section
->sh_type
== SHT_RENESAS_INFO
)
18806 if (! process_v850_notes (filedata
,
18807 (bfd_vma
) section
->sh_offset
,
18808 (bfd_vma
) section
->sh_size
))
18815 /* Try processing NOTE segments instead. */
18816 return process_corefile_note_segments (filedata
);
18822 process_notes (Filedata
* filedata
)
18824 /* If we have not been asked to display the notes then do nothing. */
18828 if (filedata
->file_header
.e_type
!= ET_CORE
)
18829 return process_note_sections (filedata
);
18831 /* No program headers means no NOTE segment. */
18832 if (filedata
->file_header
.e_phnum
> 0)
18833 return process_corefile_note_segments (filedata
);
18835 printf (_("No note segments present in the core file.\n"));
18839 static unsigned char *
18840 display_public_gnu_attributes (unsigned char * start
,
18841 const unsigned char * const end
)
18843 printf (_(" Unknown GNU attribute: %s\n"), start
);
18845 start
+= strnlen ((char *) start
, end
- start
);
18846 display_raw_attribute (start
, end
);
18848 return (unsigned char *) end
;
18851 static unsigned char *
18852 display_generic_attribute (unsigned char * start
,
18854 const unsigned char * const end
)
18857 return (unsigned char *) end
;
18859 return display_tag_value (tag
, start
, end
);
18863 process_arch_specific (Filedata
* filedata
)
18868 switch (filedata
->file_header
.e_machine
)
18871 case EM_ARC_COMPACT
:
18872 case EM_ARC_COMPACT2
:
18873 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18874 display_arc_attribute
,
18875 display_generic_attribute
);
18877 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18878 display_arm_attribute
,
18879 display_generic_attribute
);
18882 case EM_MIPS_RS3_LE
:
18883 return process_mips_specific (filedata
);
18886 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18887 display_msp430x_attribute
,
18888 display_generic_attribute
);
18891 return process_nds32_specific (filedata
);
18895 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18896 display_power_gnu_attribute
);
18900 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18901 display_s390_gnu_attribute
);
18904 case EM_SPARC32PLUS
:
18906 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18907 display_sparc_gnu_attribute
);
18910 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18911 display_tic6x_attribute
,
18912 display_generic_attribute
);
18915 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18916 display_public_gnu_attributes
,
18917 display_generic_attribute
);
18922 get_file_header (Filedata
* filedata
)
18924 /* Read in the identity array. */
18925 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18928 /* Determine how to read the rest of the header. */
18929 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18934 byte_get
= byte_get_little_endian
;
18935 byte_put
= byte_put_little_endian
;
18938 byte_get
= byte_get_big_endian
;
18939 byte_put
= byte_put_big_endian
;
18943 /* For now we only support 32 bit and 64 bit ELF files. */
18944 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18946 /* Read in the rest of the header. */
18949 Elf32_External_Ehdr ehdr32
;
18951 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18954 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18955 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18956 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18957 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18958 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18959 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18960 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18961 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18962 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18963 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18964 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18965 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18966 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18970 Elf64_External_Ehdr ehdr64
;
18972 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18973 we will not be able to cope with the 64bit data found in
18974 64 ELF files. Detect this now and abort before we start
18975 overwriting things. */
18976 if (sizeof (bfd_vma
) < 8)
18978 error (_("This instance of readelf has been built without support for a\n\
18979 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18983 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18986 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18987 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18988 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18989 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18990 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18991 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18992 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18993 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18994 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18995 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18996 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18997 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18998 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19001 if (filedata
->file_header
.e_shoff
)
19003 /* There may be some extensions in the first section header. Don't
19004 bomb if we can't read it. */
19006 get_32bit_section_headers (filedata
, TRUE
);
19008 get_64bit_section_headers (filedata
, TRUE
);
19015 close_file (Filedata
* filedata
)
19019 if (filedata
->handle
)
19020 fclose (filedata
->handle
);
19026 close_debug_file (void * data
)
19028 close_file ((Filedata
*) data
);
19032 open_file (const char * pathname
)
19034 struct stat statbuf
;
19035 Filedata
* filedata
= NULL
;
19037 if (stat (pathname
, & statbuf
) < 0
19038 || ! S_ISREG (statbuf
.st_mode
))
19041 filedata
= calloc (1, sizeof * filedata
);
19042 if (filedata
== NULL
)
19045 filedata
->handle
= fopen (pathname
, "rb");
19046 if (filedata
->handle
== NULL
)
19049 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19050 filedata
->file_name
= pathname
;
19052 if (! get_file_header (filedata
))
19055 if (filedata
->file_header
.e_shoff
)
19059 /* Read the section headers again, this time for real. */
19061 res
= get_32bit_section_headers (filedata
, FALSE
);
19063 res
= get_64bit_section_headers (filedata
, FALSE
);
19074 if (filedata
->handle
)
19075 fclose (filedata
->handle
);
19082 open_debug_file (const char * pathname
)
19084 return open_file (pathname
);
19087 /* Process one ELF object file according to the command line options.
19088 This file may actually be stored in an archive. The file is
19089 positioned at the start of the ELF object. Returns TRUE if no
19090 problems were encountered, FALSE otherwise. */
19093 process_object (Filedata
* filedata
)
19095 Filedata
* separates
;
19097 bfd_boolean res
= TRUE
;
19099 if (! get_file_header (filedata
))
19101 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19105 /* Initialise per file variables. */
19106 for (i
= ARRAY_SIZE (version_info
); i
--;)
19107 version_info
[i
] = 0;
19109 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19110 dynamic_info
[i
] = 0;
19111 dynamic_info_DT_GNU_HASH
= 0;
19113 /* Process the file. */
19115 printf (_("\nFile: %s\n"), filedata
->file_name
);
19117 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19118 Note we do this even if cmdline_dump_sects is empty because we
19119 must make sure that the dump_sets array is zeroed out before each
19120 object file is processed. */
19121 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19122 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19124 if (cmdline
.num_dump_sects
> 0)
19126 if (filedata
->num_dump_sects
== 0)
19127 /* A sneaky way of allocating the dump_sects array. */
19128 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19130 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19131 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19132 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19135 if (! process_file_header (filedata
))
19138 if (! process_section_headers (filedata
))
19140 /* Without loaded section headers we cannot process lots of things. */
19141 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19143 if (! do_using_dynamic
)
19144 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19147 if (! process_section_groups (filedata
))
19148 /* Without loaded section groups we cannot process unwind. */
19151 if (process_program_headers (filedata
))
19152 process_dynamic_section (filedata
);
19156 if (! process_relocs (filedata
))
19159 if (! process_unwind (filedata
))
19162 if (! process_symbol_table (filedata
))
19165 if (! process_syminfo (filedata
))
19168 if (! process_version_sections (filedata
))
19171 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19172 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
19176 if (! process_section_contents (filedata
))
19181 if (! process_section_headers (separates
))
19183 else if (! process_section_contents (separates
))
19187 if (! process_notes (filedata
))
19190 if (! process_gnu_liblist (filedata
))
19193 if (! process_arch_specific (filedata
))
19196 free (filedata
->program_headers
);
19197 filedata
->program_headers
= NULL
;
19199 free (filedata
->section_headers
);
19200 filedata
->section_headers
= NULL
;
19202 free (filedata
->string_table
);
19203 filedata
->string_table
= NULL
;
19204 filedata
->string_table_length
= 0;
19206 if (dynamic_strings
)
19208 free (dynamic_strings
);
19209 dynamic_strings
= NULL
;
19210 dynamic_strings_length
= 0;
19213 if (dynamic_symbols
)
19215 free (dynamic_symbols
);
19216 dynamic_symbols
= NULL
;
19217 num_dynamic_syms
= 0;
19220 if (dynamic_syminfo
)
19222 free (dynamic_syminfo
);
19223 dynamic_syminfo
= NULL
;
19226 if (dynamic_section
)
19228 free (dynamic_section
);
19229 dynamic_section
= NULL
;
19232 if (section_headers_groups
)
19234 free (section_headers_groups
);
19235 section_headers_groups
= NULL
;
19238 if (section_groups
)
19240 struct group_list
* g
;
19241 struct group_list
* next
;
19243 for (i
= 0; i
< group_count
; i
++)
19245 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
19252 free (section_groups
);
19253 section_groups
= NULL
;
19256 free_debug_memory ();
19261 /* Process an ELF archive.
19262 On entry the file is positioned just after the ARMAG string.
19263 Returns TRUE upon success, FALSE otherwise. */
19266 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
19268 struct archive_info arch
;
19269 struct archive_info nested_arch
;
19271 bfd_boolean ret
= TRUE
;
19275 /* The ARCH structure is used to hold information about this archive. */
19276 arch
.file_name
= NULL
;
19278 arch
.index_array
= NULL
;
19279 arch
.sym_table
= NULL
;
19280 arch
.longnames
= NULL
;
19282 /* The NESTED_ARCH structure is used as a single-item cache of information
19283 about a nested archive (when members of a thin archive reside within
19284 another regular archive file). */
19285 nested_arch
.file_name
= NULL
;
19286 nested_arch
.file
= NULL
;
19287 nested_arch
.index_array
= NULL
;
19288 nested_arch
.sym_table
= NULL
;
19289 nested_arch
.longnames
= NULL
;
19291 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
19292 is_thin_archive
, do_archive_index
) != 0)
19298 if (do_archive_index
)
19300 if (arch
.sym_table
== NULL
)
19301 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
19304 unsigned long i
, l
;
19305 unsigned long current_pos
;
19307 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19308 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
19310 current_pos
= ftell (filedata
->handle
);
19312 for (i
= l
= 0; i
< arch
.index_num
; i
++)
19314 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
19316 char * member_name
;
19318 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
19320 if (member_name
!= NULL
)
19322 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
19324 if (qualified_name
!= NULL
)
19326 printf (_("Contents of binary %s at offset "), qualified_name
);
19327 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
19329 free (qualified_name
);
19334 if (l
>= arch
.sym_size
)
19336 error (_("%s: end of the symbol table reached before the end of the index\n"),
19337 filedata
->file_name
);
19341 /* PR 17531: file: 0b6630b2. */
19342 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
19343 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
19346 if (arch
.uses_64bit_indices
)
19351 if (l
< arch
.sym_size
)
19353 error (ngettext ("%s: %ld byte remains in the symbol table, "
19354 "but without corresponding entries in "
19355 "the index table\n",
19356 "%s: %ld bytes remain in the symbol table, "
19357 "but without corresponding entries in "
19358 "the index table\n",
19359 arch
.sym_size
- l
),
19360 filedata
->file_name
, arch
.sym_size
- l
);
19364 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
19366 error (_("%s: failed to seek back to start of object files in the archive\n"),
19367 filedata
->file_name
);
19373 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
19374 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
19375 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
19376 && !do_section_groups
&& !do_dyn_syms
)
19378 ret
= TRUE
; /* Archive index only. */
19387 char * qualified_name
;
19389 /* Read the next archive header. */
19390 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
19392 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
19395 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
19396 if (got
!= sizeof arch
.arhdr
)
19400 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
19404 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
19406 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
19411 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
19413 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
19414 if (archive_file_size
& 01)
19415 ++archive_file_size
;
19417 name
= get_archive_member_name (&arch
, &nested_arch
);
19420 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19424 namelen
= strlen (name
);
19426 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
19427 if (qualified_name
== NULL
)
19429 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19434 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
19436 /* This is a proxy for an external member of a thin archive. */
19437 Filedata
* member_filedata
;
19438 char * member_file_name
= adjust_relative_path
19439 (filedata
->file_name
, name
, namelen
);
19441 if (member_file_name
== NULL
)
19447 member_filedata
= open_file (member_file_name
);
19448 if (member_filedata
== NULL
)
19450 error (_("Input file '%s' is not readable.\n"), member_file_name
);
19451 free (member_file_name
);
19456 archive_file_offset
= arch
.nested_member_origin
;
19457 member_filedata
->file_name
= qualified_name
;
19459 if (! process_object (member_filedata
))
19462 close_file (member_filedata
);
19463 free (member_file_name
);
19465 else if (is_thin_archive
)
19467 Filedata thin_filedata
;
19469 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
19471 /* PR 15140: Allow for corrupt thin archives. */
19472 if (nested_arch
.file
== NULL
)
19474 error (_("%s: contains corrupt thin archive: %s\n"),
19475 filedata
->file_name
, name
);
19480 /* This is a proxy for a member of a nested archive. */
19481 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19483 /* The nested archive file will have been opened and setup by
19484 get_archive_member_name. */
19485 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19487 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19492 thin_filedata
.handle
= nested_arch
.file
;
19493 thin_filedata
.file_name
= qualified_name
;
19495 if (! process_object (& thin_filedata
))
19500 archive_file_offset
= arch
.next_arhdr_offset
;
19501 arch
.next_arhdr_offset
+= archive_file_size
;
19503 filedata
->file_name
= qualified_name
;
19504 if (! process_object (filedata
))
19508 if (filedata
->dump_sects
!= NULL
)
19510 free (filedata
->dump_sects
);
19511 filedata
->dump_sects
= NULL
;
19512 filedata
->num_dump_sects
= 0;
19515 free (qualified_name
);
19519 if (nested_arch
.file
!= NULL
)
19520 fclose (nested_arch
.file
);
19521 release_archive (&nested_arch
);
19522 release_archive (&arch
);
19528 process_file (char * file_name
)
19530 Filedata
* filedata
= NULL
;
19531 struct stat statbuf
;
19532 char armag
[SARMAG
];
19533 bfd_boolean ret
= TRUE
;
19535 if (stat (file_name
, &statbuf
) < 0)
19537 if (errno
== ENOENT
)
19538 error (_("'%s': No such file\n"), file_name
);
19540 error (_("Could not locate '%s'. System error message: %s\n"),
19541 file_name
, strerror (errno
));
19545 if (! S_ISREG (statbuf
.st_mode
))
19547 error (_("'%s' is not an ordinary file\n"), file_name
);
19551 filedata
= calloc (1, sizeof * filedata
);
19552 if (filedata
== NULL
)
19554 error (_("Out of memory allocating file data structure\n"));
19558 filedata
->file_name
= file_name
;
19559 filedata
->handle
= fopen (file_name
, "rb");
19560 if (filedata
->handle
== NULL
)
19562 error (_("Input file '%s' is not readable.\n"), file_name
);
19567 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19569 error (_("%s: Failed to read file's magic number\n"), file_name
);
19570 fclose (filedata
->handle
);
19575 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19577 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19579 if (! process_archive (filedata
, FALSE
))
19582 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19584 if ( ! process_archive (filedata
, TRUE
))
19589 if (do_archive_index
)
19590 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19593 rewind (filedata
->handle
);
19594 archive_file_size
= archive_file_offset
= 0;
19596 if (! process_object (filedata
))
19600 fclose (filedata
->handle
);
19606 #ifdef SUPPORT_DISASSEMBLY
19607 /* Needed by the i386 disassembler. For extra credit, someone could
19608 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19612 print_address (unsigned int addr
, FILE * outfile
)
19614 fprintf (outfile
,"0x%8.8x", addr
);
19617 /* Needed by the i386 disassembler. */
19620 db_task_printsym (unsigned int addr
)
19622 print_address (addr
, stderr
);
19627 main (int argc
, char ** argv
)
19631 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19632 setlocale (LC_MESSAGES
, "");
19634 #if defined (HAVE_SETLOCALE)
19635 setlocale (LC_CTYPE
, "");
19637 bindtextdomain (PACKAGE
, LOCALEDIR
);
19638 textdomain (PACKAGE
);
19640 expandargv (&argc
, &argv
);
19642 cmdline
.file_name
= "<cmdline>";
19643 parse_args (& cmdline
, argc
, argv
);
19645 if (optind
< (argc
- 1))
19647 else if (optind
>= argc
)
19649 warn (_("Nothing to do.\n"));
19654 while (optind
< argc
)
19655 if (! process_file (argv
[optind
++]))
19658 if (cmdline
.dump_sects
!= NULL
)
19659 free (cmdline
.dump_sects
);
19661 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;