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_OCTEON
: strcat (buf
, ", octeon"); break;
3410 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3411 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3412 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3413 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3415 /* We simply ignore the field in this case to avoid confusion:
3416 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3419 default: strcat (buf
, _(", unknown CPU")); break;
3422 switch ((e_flags
& EF_MIPS_ABI
))
3424 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3425 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3426 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3427 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3429 /* We simply ignore the field in this case to avoid confusion:
3430 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3431 This means it is likely to be an o32 file, but not for
3434 default: strcat (buf
, _(", unknown ABI")); break;
3437 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3438 strcat (buf
, ", mdmx");
3440 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3441 strcat (buf
, ", mips16");
3443 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3444 strcat (buf
, ", micromips");
3446 switch ((e_flags
& EF_MIPS_ARCH
))
3448 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3449 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3450 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3451 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3452 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3453 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3454 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3455 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3456 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3457 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3458 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3459 default: strcat (buf
, _(", unknown ISA")); break;
3464 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3468 switch (EF_NFP_MACH (e_flags
))
3470 case E_NFP_MACH_3200
:
3471 strcat (buf
, ", NFP-32xx");
3473 case E_NFP_MACH_6000
:
3474 strcat (buf
, ", NFP-6xxx");
3480 if (e_flags
& EF_RISCV_RVC
)
3481 strcat (buf
, ", RVC");
3483 if (e_flags
& EF_RISCV_RVE
)
3484 strcat (buf
, ", RVE");
3486 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3488 case EF_RISCV_FLOAT_ABI_SOFT
:
3489 strcat (buf
, ", soft-float ABI");
3492 case EF_RISCV_FLOAT_ABI_SINGLE
:
3493 strcat (buf
, ", single-float ABI");
3496 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3497 strcat (buf
, ", double-float ABI");
3500 case EF_RISCV_FLOAT_ABI_QUAD
:
3501 strcat (buf
, ", quad-float ABI");
3507 switch ((e_flags
& EF_SH_MACH_MASK
))
3509 case EF_SH1
: strcat (buf
, ", sh1"); break;
3510 case EF_SH2
: strcat (buf
, ", sh2"); break;
3511 case EF_SH3
: strcat (buf
, ", sh3"); break;
3512 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3513 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3514 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3515 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3516 case EF_SH4
: strcat (buf
, ", sh4"); break;
3517 case EF_SH5
: strcat (buf
, ", sh5"); break;
3518 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3519 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3520 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3521 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3522 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3523 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3524 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3525 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3526 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3527 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3528 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3529 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3530 default: strcat (buf
, _(", unknown ISA")); break;
3533 if (e_flags
& EF_SH_PIC
)
3534 strcat (buf
, ", pic");
3536 if (e_flags
& EF_SH_FDPIC
)
3537 strcat (buf
, ", fdpic");
3541 if (e_flags
& EF_OR1K_NODELAY
)
3542 strcat (buf
, ", no delay");
3546 if (e_flags
& EF_SPARC_32PLUS
)
3547 strcat (buf
, ", v8+");
3549 if (e_flags
& EF_SPARC_SUN_US1
)
3550 strcat (buf
, ", ultrasparcI");
3552 if (e_flags
& EF_SPARC_SUN_US3
)
3553 strcat (buf
, ", ultrasparcIII");
3555 if (e_flags
& EF_SPARC_HAL_R1
)
3556 strcat (buf
, ", halr1");
3558 if (e_flags
& EF_SPARC_LEDATA
)
3559 strcat (buf
, ", ledata");
3561 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3562 strcat (buf
, ", tso");
3564 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3565 strcat (buf
, ", pso");
3567 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3568 strcat (buf
, ", rmo");
3572 switch (e_flags
& EF_PARISC_ARCH
)
3574 case EFA_PARISC_1_0
:
3575 strcpy (buf
, ", PA-RISC 1.0");
3577 case EFA_PARISC_1_1
:
3578 strcpy (buf
, ", PA-RISC 1.1");
3580 case EFA_PARISC_2_0
:
3581 strcpy (buf
, ", PA-RISC 2.0");
3586 if (e_flags
& EF_PARISC_TRAPNIL
)
3587 strcat (buf
, ", trapnil");
3588 if (e_flags
& EF_PARISC_EXT
)
3589 strcat (buf
, ", ext");
3590 if (e_flags
& EF_PARISC_LSB
)
3591 strcat (buf
, ", lsb");
3592 if (e_flags
& EF_PARISC_WIDE
)
3593 strcat (buf
, ", wide");
3594 if (e_flags
& EF_PARISC_NO_KABP
)
3595 strcat (buf
, ", no kabp");
3596 if (e_flags
& EF_PARISC_LAZYSWAP
)
3597 strcat (buf
, ", lazyswap");
3602 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3603 strcat (buf
, ", new calling convention");
3605 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3606 strcat (buf
, ", gnu calling convention");
3610 if ((e_flags
& EF_IA_64_ABI64
))
3611 strcat (buf
, ", 64-bit");
3613 strcat (buf
, ", 32-bit");
3614 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3615 strcat (buf
, ", reduced fp model");
3616 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3617 strcat (buf
, ", no function descriptors, constant gp");
3618 else if ((e_flags
& EF_IA_64_CONS_GP
))
3619 strcat (buf
, ", constant gp");
3620 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3621 strcat (buf
, ", absolute");
3622 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3624 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3625 strcat (buf
, ", vms_linkages");
3626 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3628 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3630 case EF_IA_64_VMS_COMCOD_WARNING
:
3631 strcat (buf
, ", warning");
3633 case EF_IA_64_VMS_COMCOD_ERROR
:
3634 strcat (buf
, ", error");
3636 case EF_IA_64_VMS_COMCOD_ABORT
:
3637 strcat (buf
, ", abort");
3640 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3641 e_flags
& EF_IA_64_VMS_COMCOD
);
3642 strcat (buf
, ", <unknown>");
3648 if ((e_flags
& EF_VAX_NONPIC
))
3649 strcat (buf
, ", non-PIC");
3650 if ((e_flags
& EF_VAX_DFLOAT
))
3651 strcat (buf
, ", D-Float");
3652 if ((e_flags
& EF_VAX_GFLOAT
))
3653 strcat (buf
, ", G-Float");
3657 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3658 strcat (buf
, ", mcm");
3659 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3660 strcat (buf
, ", mcm24");
3661 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3662 strcat (buf
, ", gr6");
3666 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3668 case E_FLAG_RL78_ANY_CPU
: break;
3669 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3670 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3671 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3673 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3674 strcat (buf
, ", 64-bit doubles");
3678 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3679 strcat (buf
, ", 64-bit doubles");
3680 if (e_flags
& E_FLAG_RX_DSP
)
3681 strcat (buf
, ", dsp");
3682 if (e_flags
& E_FLAG_RX_PID
)
3683 strcat (buf
, ", pid");
3684 if (e_flags
& E_FLAG_RX_ABI
)
3685 strcat (buf
, ", RX ABI");
3686 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3687 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3688 ? ", uses String instructions" : ", bans String instructions");
3689 if (e_flags
& E_FLAG_RX_V2
)
3690 strcat (buf
, ", V2");
3694 if (e_flags
& EF_S390_HIGH_GPRS
)
3695 strcat (buf
, ", highgprs");
3699 if ((e_flags
& EF_C6000_REL
))
3700 strcat (buf
, ", relocatable module");
3704 strcat (buf
, _(": architecture variant: "));
3705 switch (e_flags
& EF_MSP430_MACH
)
3707 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3708 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3709 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3710 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3711 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3712 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3713 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3714 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3715 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3716 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3717 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3718 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3719 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3720 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3721 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3723 strcat (buf
, _(": unknown")); break;
3726 if (e_flags
& ~ EF_MSP430_MACH
)
3727 strcat (buf
, _(": unknown extra flag bits also present"));
3735 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3737 static char buff
[32];
3741 case ELFOSABI_NONE
: return "UNIX - System V";
3742 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3743 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3744 case ELFOSABI_GNU
: return "UNIX - GNU";
3745 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3746 case ELFOSABI_AIX
: return "UNIX - AIX";
3747 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3748 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3749 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3750 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3751 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3752 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3753 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3754 case ELFOSABI_AROS
: return "AROS";
3755 case ELFOSABI_FENIXOS
: return "FenixOS";
3756 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3757 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3760 switch (filedata
->file_header
.e_machine
)
3765 case ELFOSABI_ARM
: return "ARM";
3766 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3777 case ELFOSABI_STANDALONE
: return _("Standalone App");
3786 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3787 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3796 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3802 get_aarch64_segment_type (unsigned long type
)
3806 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3807 default: return NULL
;
3812 get_arm_segment_type (unsigned long type
)
3816 case PT_ARM_EXIDX
: return "EXIDX";
3817 default: return NULL
;
3822 get_s390_segment_type (unsigned long type
)
3826 case PT_S390_PGSTE
: return "S390_PGSTE";
3827 default: return NULL
;
3832 get_mips_segment_type (unsigned long type
)
3836 case PT_MIPS_REGINFO
: return "REGINFO";
3837 case PT_MIPS_RTPROC
: return "RTPROC";
3838 case PT_MIPS_OPTIONS
: return "OPTIONS";
3839 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3840 default: return NULL
;
3845 get_parisc_segment_type (unsigned long type
)
3849 case PT_HP_TLS
: return "HP_TLS";
3850 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3851 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3852 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3853 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3854 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3855 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3856 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3857 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3858 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3859 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3860 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3861 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3862 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3863 case PT_HP_STACK
: return "HP_STACK";
3864 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3865 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3866 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3867 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3868 default: return NULL
;
3873 get_ia64_segment_type (unsigned long type
)
3877 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3878 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3879 case PT_HP_TLS
: return "HP_TLS";
3880 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3881 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3882 case PT_IA_64_HP_STACK
: return "HP_STACK";
3883 default: return NULL
;
3888 get_tic6x_segment_type (unsigned long type
)
3892 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3893 default: return NULL
;
3898 get_solaris_segment_type (unsigned long type
)
3902 case 0x6464e550: return "PT_SUNW_UNWIND";
3903 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3904 case 0x6ffffff7: return "PT_LOSUNW";
3905 case 0x6ffffffa: return "PT_SUNWBSS";
3906 case 0x6ffffffb: return "PT_SUNWSTACK";
3907 case 0x6ffffffc: return "PT_SUNWDTRACE";
3908 case 0x6ffffffd: return "PT_SUNWCAP";
3909 case 0x6fffffff: return "PT_HISUNW";
3910 default: return NULL
;
3915 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3917 static char buff
[32];
3921 case PT_NULL
: return "NULL";
3922 case PT_LOAD
: return "LOAD";
3923 case PT_DYNAMIC
: return "DYNAMIC";
3924 case PT_INTERP
: return "INTERP";
3925 case PT_NOTE
: return "NOTE";
3926 case PT_SHLIB
: return "SHLIB";
3927 case PT_PHDR
: return "PHDR";
3928 case PT_TLS
: return "TLS";
3929 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3930 case PT_GNU_STACK
: return "GNU_STACK";
3931 case PT_GNU_RELRO
: return "GNU_RELRO";
3934 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3936 sprintf (buff
, "GNU_MBIND+%#lx",
3937 p_type
- PT_GNU_MBIND_LO
);
3939 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3941 const char * result
;
3943 switch (filedata
->file_header
.e_machine
)
3946 result
= get_aarch64_segment_type (p_type
);
3949 result
= get_arm_segment_type (p_type
);
3952 case EM_MIPS_RS3_LE
:
3953 result
= get_mips_segment_type (p_type
);
3956 result
= get_parisc_segment_type (p_type
);
3959 result
= get_ia64_segment_type (p_type
);
3962 result
= get_tic6x_segment_type (p_type
);
3966 result
= get_s390_segment_type (p_type
);
3976 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3978 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3980 const char * result
;
3982 switch (filedata
->file_header
.e_machine
)
3985 result
= get_parisc_segment_type (p_type
);
3988 result
= get_ia64_segment_type (p_type
);
3991 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3992 result
= get_solaris_segment_type (p_type
);
4001 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4004 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4011 get_arc_section_type_name (unsigned int sh_type
)
4015 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4023 get_mips_section_type_name (unsigned int sh_type
)
4027 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4028 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4029 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4030 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4031 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4032 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4033 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4034 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4035 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4036 case SHT_MIPS_RELD
: return "MIPS_RELD";
4037 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4038 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4039 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4040 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4041 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4042 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4043 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4044 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4045 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4046 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4047 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4048 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4049 case SHT_MIPS_LINE
: return "MIPS_LINE";
4050 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4051 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4052 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4053 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4054 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4055 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4056 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4057 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4058 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4059 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4060 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4061 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4062 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4063 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4064 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4065 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4066 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4074 get_parisc_section_type_name (unsigned int sh_type
)
4078 case SHT_PARISC_EXT
: return "PARISC_EXT";
4079 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4080 case SHT_PARISC_DOC
: return "PARISC_DOC";
4081 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4082 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4083 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4084 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4085 default: return NULL
;
4090 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4092 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4093 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4094 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4098 case SHT_IA_64_EXT
: return "IA_64_EXT";
4099 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4100 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4101 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4102 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4103 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4104 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4105 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4106 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4107 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4115 get_x86_64_section_type_name (unsigned int sh_type
)
4119 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4120 default: return NULL
;
4125 get_aarch64_section_type_name (unsigned int sh_type
)
4129 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4130 default: return NULL
;
4135 get_arm_section_type_name (unsigned int sh_type
)
4139 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4140 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4141 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4142 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4143 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4144 default: return NULL
;
4149 get_tic6x_section_type_name (unsigned int sh_type
)
4153 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4154 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4155 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4156 case SHT_TI_ICODE
: return "TI_ICODE";
4157 case SHT_TI_XREF
: return "TI_XREF";
4158 case SHT_TI_HANDLER
: return "TI_HANDLER";
4159 case SHT_TI_INITINFO
: return "TI_INITINFO";
4160 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4161 default: return NULL
;
4166 get_msp430x_section_type_name (unsigned int sh_type
)
4170 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4171 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4172 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4173 default: return NULL
;
4178 get_nfp_section_type_name (unsigned int sh_type
)
4182 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4183 case SHT_NFP_INITREG
: return "NFP_INITREG";
4184 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4185 default: return NULL
;
4190 get_v850_section_type_name (unsigned int sh_type
)
4194 case SHT_V850_SCOMMON
: return "V850 Small Common";
4195 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4196 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4197 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4198 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4199 default: return NULL
;
4204 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4206 static char buff
[32];
4207 const char * result
;
4211 case SHT_NULL
: return "NULL";
4212 case SHT_PROGBITS
: return "PROGBITS";
4213 case SHT_SYMTAB
: return "SYMTAB";
4214 case SHT_STRTAB
: return "STRTAB";
4215 case SHT_RELA
: return "RELA";
4216 case SHT_HASH
: return "HASH";
4217 case SHT_DYNAMIC
: return "DYNAMIC";
4218 case SHT_NOTE
: return "NOTE";
4219 case SHT_NOBITS
: return "NOBITS";
4220 case SHT_REL
: return "REL";
4221 case SHT_SHLIB
: return "SHLIB";
4222 case SHT_DYNSYM
: return "DYNSYM";
4223 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4224 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4225 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4226 case SHT_GNU_HASH
: return "GNU_HASH";
4227 case SHT_GROUP
: return "GROUP";
4228 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4229 case SHT_GNU_verdef
: return "VERDEF";
4230 case SHT_GNU_verneed
: return "VERNEED";
4231 case SHT_GNU_versym
: return "VERSYM";
4232 case 0x6ffffff0: return "VERSYM";
4233 case 0x6ffffffc: return "VERDEF";
4234 case 0x7ffffffd: return "AUXILIARY";
4235 case 0x7fffffff: return "FILTER";
4236 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4239 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4241 switch (filedata
->file_header
.e_machine
)
4244 case EM_ARC_COMPACT
:
4245 case EM_ARC_COMPACT2
:
4246 result
= get_arc_section_type_name (sh_type
);
4249 case EM_MIPS_RS3_LE
:
4250 result
= get_mips_section_type_name (sh_type
);
4253 result
= get_parisc_section_type_name (sh_type
);
4256 result
= get_ia64_section_type_name (filedata
, sh_type
);
4261 result
= get_x86_64_section_type_name (sh_type
);
4264 result
= get_aarch64_section_type_name (sh_type
);
4267 result
= get_arm_section_type_name (sh_type
);
4270 result
= get_tic6x_section_type_name (sh_type
);
4273 result
= get_msp430x_section_type_name (sh_type
);
4276 result
= get_nfp_section_type_name (sh_type
);
4280 case EM_CYGNUS_V850
:
4281 result
= get_v850_section_type_name (sh_type
);
4291 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4293 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4295 switch (filedata
->file_header
.e_machine
)
4298 result
= get_ia64_section_type_name (filedata
, sh_type
);
4301 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4302 result
= get_solaris_section_type (sh_type
);
4307 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4308 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4309 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4310 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4322 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4324 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4326 switch (filedata
->file_header
.e_machine
)
4330 case EM_CYGNUS_V850
:
4331 result
= get_v850_section_type_name (sh_type
);
4341 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4344 /* This message is probably going to be displayed in a 15
4345 character wide field, so put the hex value first. */
4346 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4352 #define OPTION_DEBUG_DUMP 512
4353 #define OPTION_DYN_SYMS 513
4354 #define OPTION_DWARF_DEPTH 514
4355 #define OPTION_DWARF_START 515
4356 #define OPTION_DWARF_CHECK 516
4358 static struct option options
[] =
4360 {"all", no_argument
, 0, 'a'},
4361 {"file-header", no_argument
, 0, 'h'},
4362 {"program-headers", no_argument
, 0, 'l'},
4363 {"headers", no_argument
, 0, 'e'},
4364 {"histogram", no_argument
, 0, 'I'},
4365 {"segments", no_argument
, 0, 'l'},
4366 {"sections", no_argument
, 0, 'S'},
4367 {"section-headers", no_argument
, 0, 'S'},
4368 {"section-groups", no_argument
, 0, 'g'},
4369 {"section-details", no_argument
, 0, 't'},
4370 {"full-section-name",no_argument
, 0, 'N'},
4371 {"symbols", no_argument
, 0, 's'},
4372 {"syms", no_argument
, 0, 's'},
4373 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4374 {"relocs", no_argument
, 0, 'r'},
4375 {"notes", no_argument
, 0, 'n'},
4376 {"dynamic", no_argument
, 0, 'd'},
4377 {"arch-specific", no_argument
, 0, 'A'},
4378 {"version-info", no_argument
, 0, 'V'},
4379 {"use-dynamic", no_argument
, 0, 'D'},
4380 {"unwind", no_argument
, 0, 'u'},
4381 {"archive-index", no_argument
, 0, 'c'},
4382 {"hex-dump", required_argument
, 0, 'x'},
4383 {"relocated-dump", required_argument
, 0, 'R'},
4384 {"string-dump", required_argument
, 0, 'p'},
4385 {"decompress", no_argument
, 0, 'z'},
4386 #ifdef SUPPORT_DISASSEMBLY
4387 {"instruction-dump", required_argument
, 0, 'i'},
4389 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4391 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4392 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4393 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4395 {"version", no_argument
, 0, 'v'},
4396 {"wide", no_argument
, 0, 'W'},
4397 {"help", no_argument
, 0, 'H'},
4398 {0, no_argument
, 0, 0}
4402 usage (FILE * stream
)
4404 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4405 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4406 fprintf (stream
, _(" Options are:\n\
4407 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4408 -h --file-header Display the ELF file header\n\
4409 -l --program-headers Display the program headers\n\
4410 --segments An alias for --program-headers\n\
4411 -S --section-headers Display the sections' header\n\
4412 --sections An alias for --section-headers\n\
4413 -g --section-groups Display the section groups\n\
4414 -t --section-details Display the section details\n\
4415 -e --headers Equivalent to: -h -l -S\n\
4416 -s --syms Display the symbol table\n\
4417 --symbols An alias for --syms\n\
4418 --dyn-syms Display the dynamic symbol table\n\
4419 -n --notes Display the core notes (if present)\n\
4420 -r --relocs Display the relocations (if present)\n\
4421 -u --unwind Display the unwind info (if present)\n\
4422 -d --dynamic Display the dynamic section (if present)\n\
4423 -V --version-info Display the version sections (if present)\n\
4424 -A --arch-specific Display architecture specific information (if any)\n\
4425 -c --archive-index Display the symbol/file index in an archive\n\
4426 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4427 -x --hex-dump=<number|name>\n\
4428 Dump the contents of section <number|name> as bytes\n\
4429 -p --string-dump=<number|name>\n\
4430 Dump the contents of section <number|name> as strings\n\
4431 -R --relocated-dump=<number|name>\n\
4432 Dump the contents of section <number|name> as relocated bytes\n\
4433 -z --decompress Decompress section before dumping it\n\
4434 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4435 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4436 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4437 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4438 =addr,=cu_index,=links,=follow-links]\n\
4439 Display the contents of DWARF debug sections\n"));
4440 fprintf (stream
, _("\
4441 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4442 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4444 #ifdef SUPPORT_DISASSEMBLY
4445 fprintf (stream
, _("\
4446 -i --instruction-dump=<number|name>\n\
4447 Disassemble the contents of section <number|name>\n"));
4449 fprintf (stream
, _("\
4450 -I --histogram Display histogram of bucket list lengths\n\
4451 -W --wide Allow output width to exceed 80 characters\n\
4452 @<file> Read options from <file>\n\
4453 -H --help Display this information\n\
4454 -v --version Display the version number of readelf\n"));
4456 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4457 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4459 exit (stream
== stdout
? 0 : 1);
4462 /* Record the fact that the user wants the contents of section number
4463 SECTION to be displayed using the method(s) encoded as flags bits
4464 in TYPE. Note, TYPE can be zero if we are creating the array for
4468 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4470 if (section
>= filedata
->num_dump_sects
)
4472 dump_type
* new_dump_sects
;
4474 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4475 sizeof (* new_dump_sects
));
4477 if (new_dump_sects
== NULL
)
4478 error (_("Out of memory allocating dump request table.\n"));
4481 if (filedata
->dump_sects
)
4483 /* Copy current flag settings. */
4484 memcpy (new_dump_sects
, filedata
->dump_sects
,
4485 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4487 free (filedata
->dump_sects
);
4490 filedata
->dump_sects
= new_dump_sects
;
4491 filedata
->num_dump_sects
= section
+ 1;
4495 if (filedata
->dump_sects
)
4496 filedata
->dump_sects
[section
] |= type
;
4499 /* Request a dump by section name. */
4502 request_dump_byname (const char * section
, dump_type type
)
4504 struct dump_list_entry
* new_request
;
4506 new_request
= (struct dump_list_entry
*)
4507 malloc (sizeof (struct dump_list_entry
));
4509 error (_("Out of memory allocating dump request table.\n"));
4511 new_request
->name
= strdup (section
);
4512 if (!new_request
->name
)
4513 error (_("Out of memory allocating dump request table.\n"));
4515 new_request
->type
= type
;
4517 new_request
->next
= dump_sects_byname
;
4518 dump_sects_byname
= new_request
;
4522 request_dump (Filedata
* filedata
, dump_type type
)
4528 section
= strtoul (optarg
, & cp
, 0);
4530 if (! *cp
&& section
>= 0)
4531 request_dump_bynumber (filedata
, section
, type
);
4533 request_dump_byname (optarg
, type
);
4537 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4544 while ((c
= getopt_long
4545 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4563 do_section_groups
= TRUE
;
4566 do_histogram
= TRUE
;
4571 do_section_groups
= TRUE
;
4576 do_section_details
= TRUE
;
4587 do_using_dynamic
= TRUE
;
4611 do_histogram
= TRUE
;
4617 do_archive_index
= TRUE
;
4620 request_dump (filedata
, HEX_DUMP
);
4623 request_dump (filedata
, STRING_DUMP
);
4626 request_dump (filedata
, RELOC_DUMP
);
4629 decompress_dumps
= TRUE
;
4635 do_debugging
= TRUE
;
4636 dwarf_select_sections_all ();
4640 do_debugging
= FALSE
;
4641 dwarf_select_sections_by_letters (optarg
);
4644 case OPTION_DEBUG_DUMP
:
4647 do_debugging
= TRUE
;
4650 do_debugging
= FALSE
;
4651 dwarf_select_sections_by_names (optarg
);
4654 case OPTION_DWARF_DEPTH
:
4658 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4661 case OPTION_DWARF_START
:
4665 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4668 case OPTION_DWARF_CHECK
:
4671 case OPTION_DYN_SYMS
:
4674 #ifdef SUPPORT_DISASSEMBLY
4676 request_dump (filedata
, DISASS_DUMP
);
4680 print_version (program_name
);
4689 /* xgettext:c-format */
4690 error (_("Invalid option '-%c'\n"), c
);
4697 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4698 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4699 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4700 && !do_section_groups
&& !do_archive_index
4706 get_elf_class (unsigned int elf_class
)
4708 static char buff
[32];
4712 case ELFCLASSNONE
: return _("none");
4713 case ELFCLASS32
: return "ELF32";
4714 case ELFCLASS64
: return "ELF64";
4716 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4722 get_data_encoding (unsigned int encoding
)
4724 static char buff
[32];
4728 case ELFDATANONE
: return _("none");
4729 case ELFDATA2LSB
: return _("2's complement, little endian");
4730 case ELFDATA2MSB
: return _("2's complement, big endian");
4732 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4737 /* Decode the data held in 'filedata->file_header'. */
4740 process_file_header (Filedata
* filedata
)
4742 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4744 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4745 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4746 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4747 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4750 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4754 init_dwarf_regnames (header
->e_machine
);
4760 printf (_("ELF Header:\n"));
4761 printf (_(" Magic: "));
4762 for (i
= 0; i
< EI_NIDENT
; i
++)
4763 printf ("%2.2x ", header
->e_ident
[i
]);
4765 printf (_(" Class: %s\n"),
4766 get_elf_class (header
->e_ident
[EI_CLASS
]));
4767 printf (_(" Data: %s\n"),
4768 get_data_encoding (header
->e_ident
[EI_DATA
]));
4769 printf (_(" Version: %d%s\n"),
4770 header
->e_ident
[EI_VERSION
],
4771 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4773 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4776 printf (_(" OS/ABI: %s\n"),
4777 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4778 printf (_(" ABI Version: %d\n"),
4779 header
->e_ident
[EI_ABIVERSION
]);
4780 printf (_(" Type: %s\n"),
4781 get_file_type (header
->e_type
));
4782 printf (_(" Machine: %s\n"),
4783 get_machine_name (header
->e_machine
));
4784 printf (_(" Version: 0x%lx\n"),
4787 printf (_(" Entry point address: "));
4788 print_vma (header
->e_entry
, PREFIX_HEX
);
4789 printf (_("\n Start of program headers: "));
4790 print_vma (header
->e_phoff
, DEC
);
4791 printf (_(" (bytes into file)\n Start of section headers: "));
4792 print_vma (header
->e_shoff
, DEC
);
4793 printf (_(" (bytes into file)\n"));
4795 printf (_(" Flags: 0x%lx%s\n"),
4797 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4798 printf (_(" Size of this header: %u (bytes)\n"),
4800 printf (_(" Size of program headers: %u (bytes)\n"),
4801 header
->e_phentsize
);
4802 printf (_(" Number of program headers: %u"),
4804 if (filedata
->section_headers
!= NULL
4805 && header
->e_phnum
== PN_XNUM
4806 && filedata
->section_headers
[0].sh_info
!= 0)
4808 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4809 printf (" (%u)", header
->e_phnum
);
4811 putc ('\n', stdout
);
4812 printf (_(" Size of section headers: %u (bytes)\n"),
4813 header
->e_shentsize
);
4814 printf (_(" Number of section headers: %u"),
4816 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4818 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4819 printf (" (%u)", header
->e_shnum
);
4821 putc ('\n', stdout
);
4822 printf (_(" Section header string table index: %u"),
4823 header
->e_shstrndx
);
4824 if (filedata
->section_headers
!= NULL
4825 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4827 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4828 printf (" (%u)", header
->e_shstrndx
);
4830 if (header
->e_shstrndx
!= SHN_UNDEF
4831 && header
->e_shstrndx
>= header
->e_shnum
)
4833 header
->e_shstrndx
= SHN_UNDEF
;
4834 printf (_(" <corrupt: out of range>"));
4836 putc ('\n', stdout
);
4839 if (filedata
->section_headers
!= NULL
)
4841 if (header
->e_phnum
== PN_XNUM
4842 && filedata
->section_headers
[0].sh_info
!= 0)
4843 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4844 if (header
->e_shnum
== SHN_UNDEF
)
4845 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4846 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4847 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4848 if (header
->e_shstrndx
>= header
->e_shnum
)
4849 header
->e_shstrndx
= SHN_UNDEF
;
4850 free (filedata
->section_headers
);
4851 filedata
->section_headers
= NULL
;
4857 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4858 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4861 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4863 Elf32_External_Phdr
* phdrs
;
4864 Elf32_External_Phdr
* external
;
4865 Elf_Internal_Phdr
* internal
;
4867 unsigned int size
= filedata
->file_header
.e_phentsize
;
4868 unsigned int num
= filedata
->file_header
.e_phnum
;
4870 /* PR binutils/17531: Cope with unexpected section header sizes. */
4871 if (size
== 0 || num
== 0)
4873 if (size
< sizeof * phdrs
)
4875 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4878 if (size
> sizeof * phdrs
)
4879 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4881 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4882 size
, num
, _("program headers"));
4886 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4887 i
< filedata
->file_header
.e_phnum
;
4888 i
++, internal
++, external
++)
4890 internal
->p_type
= BYTE_GET (external
->p_type
);
4891 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4892 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4893 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4894 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4895 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4896 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4897 internal
->p_align
= BYTE_GET (external
->p_align
);
4904 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4905 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4908 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4910 Elf64_External_Phdr
* phdrs
;
4911 Elf64_External_Phdr
* external
;
4912 Elf_Internal_Phdr
* internal
;
4914 unsigned int size
= filedata
->file_header
.e_phentsize
;
4915 unsigned int num
= filedata
->file_header
.e_phnum
;
4917 /* PR binutils/17531: Cope with unexpected section header sizes. */
4918 if (size
== 0 || num
== 0)
4920 if (size
< sizeof * phdrs
)
4922 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4925 if (size
> sizeof * phdrs
)
4926 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4928 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4929 size
, num
, _("program headers"));
4933 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4934 i
< filedata
->file_header
.e_phnum
;
4935 i
++, internal
++, external
++)
4937 internal
->p_type
= BYTE_GET (external
->p_type
);
4938 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4939 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4940 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4941 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4942 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4943 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4944 internal
->p_align
= BYTE_GET (external
->p_align
);
4951 /* Returns TRUE if the program headers were read into `program_headers'. */
4954 get_program_headers (Filedata
* filedata
)
4956 Elf_Internal_Phdr
* phdrs
;
4958 /* Check cache of prior read. */
4959 if (filedata
->program_headers
!= NULL
)
4962 /* Be kind to memory checkers by looking for
4963 e_phnum values which we know must be invalid. */
4964 if (filedata
->file_header
.e_phnum
4965 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4966 >= filedata
->file_size
)
4968 error (_("Too many program headers - %#x - the file is not that big\n"),
4969 filedata
->file_header
.e_phnum
);
4973 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4974 sizeof (Elf_Internal_Phdr
));
4977 error (_("Out of memory reading %u program headers\n"),
4978 filedata
->file_header
.e_phnum
);
4983 ? get_32bit_program_headers (filedata
, phdrs
)
4984 : get_64bit_program_headers (filedata
, phdrs
))
4986 filedata
->program_headers
= phdrs
;
4994 /* Returns TRUE if the program headers were loaded. */
4997 process_program_headers (Filedata
* filedata
)
4999 Elf_Internal_Phdr
* segment
;
5001 Elf_Internal_Phdr
* previous_load
= NULL
;
5003 if (filedata
->file_header
.e_phnum
== 0)
5005 /* PR binutils/12467. */
5006 if (filedata
->file_header
.e_phoff
!= 0)
5008 warn (_("possibly corrupt ELF header - it has a non-zero program"
5009 " header offset, but no program headers\n"));
5012 else if (do_segments
)
5013 printf (_("\nThere are no program headers in this file.\n"));
5017 if (do_segments
&& !do_header
)
5019 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5020 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5021 printf (ngettext ("There is %d program header, starting at offset %s\n",
5022 "There are %d program headers, starting at offset %s\n",
5023 filedata
->file_header
.e_phnum
),
5024 filedata
->file_header
.e_phnum
,
5025 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5028 if (! get_program_headers (filedata
))
5033 if (filedata
->file_header
.e_phnum
> 1)
5034 printf (_("\nProgram Headers:\n"));
5036 printf (_("\nProgram Headers:\n"));
5040 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5043 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5047 (_(" Type Offset VirtAddr PhysAddr\n"));
5049 (_(" FileSiz MemSiz Flags Align\n"));
5056 for (i
= 0, segment
= filedata
->program_headers
;
5057 i
< filedata
->file_header
.e_phnum
;
5062 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5066 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5067 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5068 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5069 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5070 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5072 (segment
->p_flags
& PF_R
? 'R' : ' '),
5073 (segment
->p_flags
& PF_W
? 'W' : ' '),
5074 (segment
->p_flags
& PF_X
? 'E' : ' '));
5075 printf ("%#lx", (unsigned long) segment
->p_align
);
5079 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5080 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5083 print_vma (segment
->p_offset
, FULL_HEX
);
5087 print_vma (segment
->p_vaddr
, FULL_HEX
);
5089 print_vma (segment
->p_paddr
, FULL_HEX
);
5092 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5093 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5096 print_vma (segment
->p_filesz
, FULL_HEX
);
5100 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5101 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5104 print_vma (segment
->p_memsz
, FULL_HEX
);
5108 (segment
->p_flags
& PF_R
? 'R' : ' '),
5109 (segment
->p_flags
& PF_W
? 'W' : ' '),
5110 (segment
->p_flags
& PF_X
? 'E' : ' '));
5112 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5113 printf ("%#lx", (unsigned long) segment
->p_align
);
5116 print_vma (segment
->p_align
, PREFIX_HEX
);
5121 print_vma (segment
->p_offset
, FULL_HEX
);
5123 print_vma (segment
->p_vaddr
, FULL_HEX
);
5125 print_vma (segment
->p_paddr
, FULL_HEX
);
5127 print_vma (segment
->p_filesz
, FULL_HEX
);
5129 print_vma (segment
->p_memsz
, FULL_HEX
);
5131 (segment
->p_flags
& PF_R
? 'R' : ' '),
5132 (segment
->p_flags
& PF_W
? 'W' : ' '),
5133 (segment
->p_flags
& PF_X
? 'E' : ' '));
5134 print_vma (segment
->p_align
, PREFIX_HEX
);
5137 putc ('\n', stdout
);
5140 switch (segment
->p_type
)
5143 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5144 required by the ELF standard, several programs, including the Linux
5145 kernel, make use of non-ordered segments. */
5147 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5148 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5150 if (segment
->p_memsz
< segment
->p_filesz
)
5151 error (_("the segment's file size is larger than its memory size\n"));
5152 previous_load
= segment
;
5156 /* PR 20815 - Verify that the program header is loaded into memory. */
5157 if (i
> 0 && previous_load
!= NULL
)
5158 error (_("the PHDR segment must occur before any LOAD segment\n"));
5159 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5163 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5164 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5165 && (filedata
->program_headers
[j
].p_vaddr
5166 + filedata
->program_headers
[j
].p_memsz
)
5167 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5169 if (j
== filedata
->file_header
.e_phnum
)
5170 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5176 error (_("more than one dynamic segment\n"));
5178 /* By default, assume that the .dynamic section is the first
5179 section in the DYNAMIC segment. */
5180 dynamic_addr
= segment
->p_offset
;
5181 dynamic_size
= segment
->p_filesz
;
5183 /* Try to locate the .dynamic section. If there is
5184 a section header table, we can easily locate it. */
5185 if (filedata
->section_headers
!= NULL
)
5187 Elf_Internal_Shdr
* sec
;
5189 sec
= find_section (filedata
, ".dynamic");
5190 if (sec
== NULL
|| sec
->sh_size
== 0)
5192 /* A corresponding .dynamic section is expected, but on
5193 IA-64/OpenVMS it is OK for it to be missing. */
5194 if (!is_ia64_vms (filedata
))
5195 error (_("no .dynamic section in the dynamic segment\n"));
5199 if (sec
->sh_type
== SHT_NOBITS
)
5205 dynamic_addr
= sec
->sh_offset
;
5206 dynamic_size
= sec
->sh_size
;
5208 if (dynamic_addr
< segment
->p_offset
5209 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5210 warn (_("the .dynamic section is not contained"
5211 " within the dynamic segment\n"));
5212 else if (dynamic_addr
> segment
->p_offset
)
5213 warn (_("the .dynamic section is not the first section"
5214 " in the dynamic segment.\n"));
5217 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5218 segment. Check this after matching against the section headers
5219 so we don't warn on debuginfo file (which have NOBITS .dynamic
5221 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5223 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5224 dynamic_addr
= dynamic_size
= 0;
5229 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5231 error (_("Unable to find program interpreter name\n"));
5235 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5237 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5238 error (_("Internal error: failed to create format string to display program interpreter\n"));
5240 program_interpreter
[0] = 0;
5241 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5242 error (_("Unable to read program interpreter name\n"));
5245 printf (_(" [Requesting program interpreter: %s]\n"),
5246 program_interpreter
);
5253 && filedata
->section_headers
!= NULL
5254 && filedata
->string_table
!= NULL
)
5256 printf (_("\n Section to Segment mapping:\n"));
5257 printf (_(" Segment Sections...\n"));
5259 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5262 Elf_Internal_Shdr
* section
;
5264 segment
= filedata
->program_headers
+ i
;
5265 section
= filedata
->section_headers
+ 1;
5267 printf (" %2.2d ", i
);
5269 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5271 if (!ELF_TBSS_SPECIAL (section
, segment
)
5272 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5273 printf ("%s ", printable_section_name (filedata
, section
));
5284 /* Find the file offset corresponding to VMA by using the program headers. */
5287 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5289 Elf_Internal_Phdr
* seg
;
5291 if (! get_program_headers (filedata
))
5293 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5297 for (seg
= filedata
->program_headers
;
5298 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5301 if (seg
->p_type
!= PT_LOAD
)
5304 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5305 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5306 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5309 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5310 (unsigned long) vma
);
5315 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5316 If PROBE is true, this is just a probe and we do not generate any error
5317 messages if the load fails. */
5320 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5322 Elf32_External_Shdr
* shdrs
;
5323 Elf_Internal_Shdr
* internal
;
5325 unsigned int size
= filedata
->file_header
.e_shentsize
;
5326 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5328 /* PR binutils/17531: Cope with unexpected section header sizes. */
5329 if (size
== 0 || num
== 0)
5331 if (size
< sizeof * shdrs
)
5334 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5337 if (!probe
&& size
> sizeof * shdrs
)
5338 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5340 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5342 probe
? NULL
: _("section headers"));
5346 free (filedata
->section_headers
);
5347 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5348 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5349 if (filedata
->section_headers
== NULL
)
5352 error (_("Out of memory reading %u section headers\n"), num
);
5357 for (i
= 0, internal
= filedata
->section_headers
;
5361 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5362 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5363 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5364 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5365 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5366 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5367 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5368 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5369 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5370 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5371 if (!probe
&& internal
->sh_link
> num
)
5372 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5373 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5374 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5381 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5384 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5386 Elf64_External_Shdr
* shdrs
;
5387 Elf_Internal_Shdr
* internal
;
5389 unsigned int size
= filedata
->file_header
.e_shentsize
;
5390 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5392 /* PR binutils/17531: Cope with unexpected section header sizes. */
5393 if (size
== 0 || num
== 0)
5396 if (size
< sizeof * shdrs
)
5399 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5403 if (! probe
&& size
> sizeof * shdrs
)
5404 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5406 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5407 filedata
->file_header
.e_shoff
,
5409 probe
? NULL
: _("section headers"));
5413 free (filedata
->section_headers
);
5414 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5415 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5416 if (filedata
->section_headers
== NULL
)
5419 error (_("Out of memory reading %u section headers\n"), num
);
5424 for (i
= 0, internal
= filedata
->section_headers
;
5428 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5429 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5430 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5431 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5432 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5433 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5434 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5435 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5436 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5437 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5438 if (!probe
&& internal
->sh_link
> num
)
5439 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5440 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5441 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5448 static Elf_Internal_Sym
*
5449 get_32bit_elf_symbols (Filedata
* filedata
,
5450 Elf_Internal_Shdr
* section
,
5451 unsigned long * num_syms_return
)
5453 unsigned long number
= 0;
5454 Elf32_External_Sym
* esyms
= NULL
;
5455 Elf_External_Sym_Shndx
* shndx
= NULL
;
5456 Elf_Internal_Sym
* isyms
= NULL
;
5457 Elf_Internal_Sym
* psym
;
5459 elf_section_list
* entry
;
5461 if (section
->sh_size
== 0)
5463 if (num_syms_return
!= NULL
)
5464 * num_syms_return
= 0;
5468 /* Run some sanity checks first. */
5469 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5471 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5472 printable_section_name (filedata
, section
),
5473 (unsigned long) section
->sh_entsize
);
5477 if (section
->sh_size
> filedata
->file_size
)
5479 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5480 printable_section_name (filedata
, section
),
5481 (unsigned long) section
->sh_size
);
5485 number
= section
->sh_size
/ section
->sh_entsize
;
5487 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5489 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5490 (unsigned long) section
->sh_size
,
5491 printable_section_name (filedata
, section
),
5492 (unsigned long) section
->sh_entsize
);
5496 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5497 section
->sh_size
, _("symbols"));
5502 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5504 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5509 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5513 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5514 entry
->hdr
->sh_offset
,
5515 1, entry
->hdr
->sh_size
,
5516 _("symbol table section indices"));
5520 /* PR17531: file: heap-buffer-overflow */
5521 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5523 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5524 printable_section_name (filedata
, entry
->hdr
),
5525 (unsigned long) entry
->hdr
->sh_size
,
5526 (unsigned long) section
->sh_size
);
5531 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5535 error (_("Out of memory reading %lu symbols\n"),
5536 (unsigned long) number
);
5540 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5542 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5543 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5544 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5545 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5546 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5548 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5549 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5550 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5551 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5552 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5559 if (num_syms_return
!= NULL
)
5560 * num_syms_return
= isyms
== NULL
? 0 : number
;
5565 static Elf_Internal_Sym
*
5566 get_64bit_elf_symbols (Filedata
* filedata
,
5567 Elf_Internal_Shdr
* section
,
5568 unsigned long * num_syms_return
)
5570 unsigned long number
= 0;
5571 Elf64_External_Sym
* esyms
= NULL
;
5572 Elf_External_Sym_Shndx
* shndx
= NULL
;
5573 Elf_Internal_Sym
* isyms
= NULL
;
5574 Elf_Internal_Sym
* psym
;
5576 elf_section_list
* entry
;
5578 if (section
->sh_size
== 0)
5580 if (num_syms_return
!= NULL
)
5581 * num_syms_return
= 0;
5585 /* Run some sanity checks first. */
5586 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5588 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5589 printable_section_name (filedata
, section
),
5590 (unsigned long) section
->sh_entsize
);
5594 if (section
->sh_size
> filedata
->file_size
)
5596 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5597 printable_section_name (filedata
, section
),
5598 (unsigned long) section
->sh_size
);
5602 number
= section
->sh_size
/ section
->sh_entsize
;
5604 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5606 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5607 (unsigned long) section
->sh_size
,
5608 printable_section_name (filedata
, section
),
5609 (unsigned long) section
->sh_entsize
);
5613 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5614 section
->sh_size
, _("symbols"));
5619 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5621 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5626 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5630 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5631 entry
->hdr
->sh_offset
,
5632 1, entry
->hdr
->sh_size
,
5633 _("symbol table section indices"));
5637 /* PR17531: file: heap-buffer-overflow */
5638 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5640 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5641 printable_section_name (filedata
, entry
->hdr
),
5642 (unsigned long) entry
->hdr
->sh_size
,
5643 (unsigned long) section
->sh_size
);
5648 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5652 error (_("Out of memory reading %lu symbols\n"),
5653 (unsigned long) number
);
5657 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5659 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5660 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5661 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5662 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5664 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5666 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5667 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5668 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5670 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5671 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5678 if (num_syms_return
!= NULL
)
5679 * num_syms_return
= isyms
== NULL
? 0 : number
;
5685 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5687 static char buff
[1024];
5689 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5691 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5692 bfd_vma os_flags
= 0;
5693 bfd_vma proc_flags
= 0;
5694 bfd_vma unknown_flags
= 0;
5702 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5703 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5704 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5705 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5706 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5707 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5708 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5709 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5710 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5711 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5712 /* IA-64 specific. */
5713 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5714 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5715 /* IA-64 OpenVMS specific. */
5716 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5717 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5718 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5719 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5720 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5721 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5723 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5724 /* SPARC specific. */
5725 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5726 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5728 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5729 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5730 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5732 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5734 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5737 if (do_section_details
)
5739 sprintf (buff
, "[%*.*lx]: ",
5740 field_size
, field_size
, (unsigned long) sh_flags
);
5741 p
+= field_size
+ 4;
5748 flag
= sh_flags
& - sh_flags
;
5751 if (do_section_details
)
5755 case SHF_WRITE
: sindex
= 0; break;
5756 case SHF_ALLOC
: sindex
= 1; break;
5757 case SHF_EXECINSTR
: sindex
= 2; break;
5758 case SHF_MERGE
: sindex
= 3; break;
5759 case SHF_STRINGS
: sindex
= 4; break;
5760 case SHF_INFO_LINK
: sindex
= 5; break;
5761 case SHF_LINK_ORDER
: sindex
= 6; break;
5762 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5763 case SHF_GROUP
: sindex
= 8; break;
5764 case SHF_TLS
: sindex
= 9; break;
5765 case SHF_EXCLUDE
: sindex
= 18; break;
5766 case SHF_COMPRESSED
: sindex
= 20; break;
5767 case SHF_GNU_MBIND
: sindex
= 24; break;
5771 switch (filedata
->file_header
.e_machine
)
5774 if (flag
== SHF_IA_64_SHORT
)
5776 else if (flag
== SHF_IA_64_NORECOV
)
5779 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5782 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5783 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5784 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5785 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5786 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5787 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5798 case EM_OLD_SPARCV9
:
5799 case EM_SPARC32PLUS
:
5802 if (flag
== SHF_ORDERED
)
5809 case SHF_ENTRYSECT
: sindex
= 21; break;
5810 case SHF_ARM_PURECODE
: sindex
= 22; break;
5811 case SHF_COMDEF
: sindex
= 23; break;
5816 if (flag
== SHF_PPC_VLE
)
5827 if (p
!= buff
+ field_size
+ 4)
5829 if (size
< (10 + 2))
5831 warn (_("Internal error: not enough buffer room for section flag info"));
5832 return _("<unknown>");
5839 size
-= flags
[sindex
].len
;
5840 p
= stpcpy (p
, flags
[sindex
].str
);
5842 else if (flag
& SHF_MASKOS
)
5844 else if (flag
& SHF_MASKPROC
)
5847 unknown_flags
|= flag
;
5853 case SHF_WRITE
: *p
= 'W'; break;
5854 case SHF_ALLOC
: *p
= 'A'; break;
5855 case SHF_EXECINSTR
: *p
= 'X'; break;
5856 case SHF_MERGE
: *p
= 'M'; break;
5857 case SHF_STRINGS
: *p
= 'S'; break;
5858 case SHF_INFO_LINK
: *p
= 'I'; break;
5859 case SHF_LINK_ORDER
: *p
= 'L'; break;
5860 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5861 case SHF_GROUP
: *p
= 'G'; break;
5862 case SHF_TLS
: *p
= 'T'; break;
5863 case SHF_EXCLUDE
: *p
= 'E'; break;
5864 case SHF_COMPRESSED
: *p
= 'C'; break;
5865 case SHF_GNU_MBIND
: *p
= 'D'; break;
5868 if ((filedata
->file_header
.e_machine
== EM_X86_64
5869 || filedata
->file_header
.e_machine
== EM_L1OM
5870 || filedata
->file_header
.e_machine
== EM_K1OM
)
5871 && flag
== SHF_X86_64_LARGE
)
5873 else if (filedata
->file_header
.e_machine
== EM_ARM
5874 && flag
== SHF_ARM_PURECODE
)
5876 else if (filedata
->file_header
.e_machine
== EM_PPC
5877 && flag
== SHF_PPC_VLE
)
5879 else if (flag
& SHF_MASKOS
)
5882 sh_flags
&= ~ SHF_MASKOS
;
5884 else if (flag
& SHF_MASKPROC
)
5887 sh_flags
&= ~ SHF_MASKPROC
;
5897 if (do_section_details
)
5901 size
-= 5 + field_size
;
5902 if (p
!= buff
+ field_size
+ 4)
5906 warn (_("Internal error: not enough buffer room for section flag info"));
5907 return _("<unknown>");
5913 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5914 (unsigned long) os_flags
);
5915 p
+= 5 + field_size
;
5919 size
-= 7 + field_size
;
5920 if (p
!= buff
+ field_size
+ 4)
5924 warn (_("Internal error: not enough buffer room for section flag info"));
5925 return _("<unknown>");
5931 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5932 (unsigned long) proc_flags
);
5933 p
+= 7 + field_size
;
5937 size
-= 10 + field_size
;
5938 if (p
!= buff
+ field_size
+ 4)
5942 warn (_("Internal error: not enough buffer room for section flag info"));
5943 return _("<unknown>");
5949 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5950 (unsigned long) unknown_flags
);
5951 p
+= 10 + field_size
;
5960 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5964 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5966 if (size
< sizeof (* echdr
))
5968 error (_("Compressed section is too small even for a compression header\n"));
5972 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5973 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5974 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5975 return sizeof (*echdr
);
5979 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5981 if (size
< sizeof (* echdr
))
5983 error (_("Compressed section is too small even for a compression header\n"));
5987 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5988 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5989 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5990 return sizeof (*echdr
);
5995 process_section_headers (Filedata
* filedata
)
5997 Elf_Internal_Shdr
* section
;
6000 filedata
->section_headers
= NULL
;
6002 if (filedata
->file_header
.e_shnum
== 0)
6004 /* PR binutils/12467. */
6005 if (filedata
->file_header
.e_shoff
!= 0)
6007 warn (_("possibly corrupt ELF file header - it has a non-zero"
6008 " section header offset, but no section headers\n"));
6011 else if (do_sections
)
6012 printf (_("\nThere are no sections in this file.\n"));
6017 if (do_sections
&& !do_header
)
6018 printf (ngettext ("There is %d section header, "
6019 "starting at offset 0x%lx:\n",
6020 "There are %d section headers, "
6021 "starting at offset 0x%lx:\n",
6022 filedata
->file_header
.e_shnum
),
6023 filedata
->file_header
.e_shnum
,
6024 (unsigned long) filedata
->file_header
.e_shoff
);
6028 if (! get_32bit_section_headers (filedata
, FALSE
))
6033 if (! get_64bit_section_headers (filedata
, FALSE
))
6037 /* Read in the string table, so that we have names to display. */
6038 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6039 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6041 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6043 if (section
->sh_size
!= 0)
6045 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6046 1, section
->sh_size
,
6049 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6053 /* Scan the sections for the dynamic symbol table
6054 and dynamic string table and debug sections. */
6055 dynamic_symbols
= NULL
;
6056 dynamic_strings
= NULL
;
6057 dynamic_syminfo
= NULL
;
6058 symtab_shndx_list
= NULL
;
6060 eh_addr_size
= is_32bit_elf
? 4 : 8;
6061 switch (filedata
->file_header
.e_machine
)
6064 case EM_MIPS_RS3_LE
:
6065 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6066 FDE addresses. However, the ABI also has a semi-official ILP32
6067 variant for which the normal FDE address size rules apply.
6069 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6070 section, where XX is the size of longs in bits. Unfortunately,
6071 earlier compilers provided no way of distinguishing ILP32 objects
6072 from LP64 objects, so if there's any doubt, we should assume that
6073 the official LP64 form is being used. */
6074 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6075 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6081 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6083 case E_H8_MACH_H8300
:
6084 case E_H8_MACH_H8300HN
:
6085 case E_H8_MACH_H8300SN
:
6086 case E_H8_MACH_H8300SXN
:
6089 case E_H8_MACH_H8300H
:
6090 case E_H8_MACH_H8300S
:
6091 case E_H8_MACH_H8300SX
:
6099 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6101 case EF_M32C_CPU_M16C
:
6108 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6111 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6112 if (section->sh_entsize != expected_entsize) \
6115 sprintf_vma (buf, section->sh_entsize); \
6116 /* Note: coded this way so that there is a single string for \
6118 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6119 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6120 (unsigned) expected_entsize); \
6121 section->sh_entsize = expected_entsize; \
6126 #define CHECK_ENTSIZE(section, i, type) \
6127 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6128 sizeof (Elf64_External_##type))
6130 for (i
= 0, section
= filedata
->section_headers
;
6131 i
< filedata
->file_header
.e_shnum
;
6134 char * name
= SECTION_NAME (section
);
6136 if (section
->sh_type
== SHT_DYNSYM
)
6138 if (dynamic_symbols
!= NULL
)
6140 error (_("File contains multiple dynamic symbol tables\n"));
6144 CHECK_ENTSIZE (section
, i
, Sym
);
6145 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6147 else if (section
->sh_type
== SHT_STRTAB
6148 && streq (name
, ".dynstr"))
6150 if (dynamic_strings
!= NULL
)
6152 error (_("File contains multiple dynamic string tables\n"));
6156 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6157 1, section
->sh_size
,
6158 _("dynamic strings"));
6159 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6161 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6163 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6165 entry
->hdr
= section
;
6166 entry
->next
= symtab_shndx_list
;
6167 symtab_shndx_list
= entry
;
6169 else if (section
->sh_type
== SHT_SYMTAB
)
6170 CHECK_ENTSIZE (section
, i
, Sym
);
6171 else if (section
->sh_type
== SHT_GROUP
)
6172 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6173 else if (section
->sh_type
== SHT_REL
)
6174 CHECK_ENTSIZE (section
, i
, Rel
);
6175 else if (section
->sh_type
== SHT_RELA
)
6176 CHECK_ENTSIZE (section
, i
, Rela
);
6177 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6178 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6179 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6180 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6181 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6182 && (const_strneq (name
, ".debug_")
6183 || const_strneq (name
, ".zdebug_")))
6186 name
+= sizeof (".zdebug_") - 1;
6188 name
+= sizeof (".debug_") - 1;
6191 || (do_debug_info
&& const_strneq (name
, "info"))
6192 || (do_debug_info
&& const_strneq (name
, "types"))
6193 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6194 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6195 || (do_debug_lines
&& const_strneq (name
, "line."))
6196 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6197 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6198 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6199 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6200 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6201 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6202 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6203 || (do_debug_frames
&& const_strneq (name
, "frame"))
6204 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6205 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6206 || (do_debug_str
&& const_strneq (name
, "str"))
6207 || (do_debug_loc
&& const_strneq (name
, "loc"))
6208 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6209 || (do_debug_addr
&& const_strneq (name
, "addr"))
6210 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6211 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6213 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6215 /* Linkonce section to be combined with .debug_info at link time. */
6216 else if ((do_debugging
|| do_debug_info
)
6217 && const_strneq (name
, ".gnu.linkonce.wi."))
6218 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6219 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6220 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6221 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6222 || streq (name
, ".debug_names")))
6223 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6224 /* Trace sections for Itanium VMS. */
6225 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6226 || do_trace_aranges
)
6227 && const_strneq (name
, ".trace_"))
6229 name
+= sizeof (".trace_") - 1;
6232 || (do_trace_info
&& streq (name
, "info"))
6233 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6234 || (do_trace_aranges
&& streq (name
, "aranges"))
6236 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6238 else if ((do_debugging
|| do_debug_links
)
6239 && (const_strneq (name
, ".gnu_debuglink")
6240 || const_strneq (name
, ".gnu_debugaltlink")))
6241 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6247 if (filedata
->file_header
.e_shnum
> 1)
6248 printf (_("\nSection Headers:\n"));
6250 printf (_("\nSection Header:\n"));
6254 if (do_section_details
)
6256 printf (_(" [Nr] Name\n"));
6257 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6261 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6265 if (do_section_details
)
6267 printf (_(" [Nr] Name\n"));
6268 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6272 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6276 if (do_section_details
)
6278 printf (_(" [Nr] Name\n"));
6279 printf (_(" Type Address Offset Link\n"));
6280 printf (_(" Size EntSize Info Align\n"));
6284 printf (_(" [Nr] Name Type Address Offset\n"));
6285 printf (_(" Size EntSize Flags Link Info Align\n"));
6289 if (do_section_details
)
6290 printf (_(" Flags\n"));
6292 for (i
= 0, section
= filedata
->section_headers
;
6293 i
< filedata
->file_header
.e_shnum
;
6296 /* Run some sanity checks on the section header. */
6298 /* Check the sh_link field. */
6299 switch (section
->sh_type
)
6301 case SHT_SYMTAB_SHNDX
:
6305 case SHT_GNU_versym
:
6308 if (section
->sh_link
< 1
6309 || section
->sh_link
>= filedata
->file_header
.e_shnum
6310 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6311 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6312 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6313 i
, section
->sh_link
);
6319 case SHT_GNU_verneed
:
6320 case SHT_GNU_verdef
:
6321 case SHT_GNU_LIBLIST
:
6322 if (section
->sh_link
< 1
6323 || section
->sh_link
>= filedata
->file_header
.e_shnum
6324 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6325 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6326 i
, section
->sh_link
);
6329 case SHT_INIT_ARRAY
:
6330 case SHT_FINI_ARRAY
:
6331 case SHT_PREINIT_ARRAY
:
6332 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6333 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6334 i
, section
->sh_link
);
6338 /* FIXME: Add support for target specific section types. */
6339 #if 0 /* Currently we do not check other section types as there are too
6340 many special cases. Stab sections for example have a type
6341 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6343 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6344 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6345 i
, section
->sh_link
);
6350 /* Check the sh_info field. */
6351 switch (section
->sh_type
)
6355 if (section
->sh_info
< 1
6356 || section
->sh_info
>= filedata
->file_header
.e_shnum
6357 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6358 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6359 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6360 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6361 /* FIXME: Are other section types valid ? */
6362 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6364 if (section
->sh_info
== 0
6365 && (filedata
->file_header
.e_type
== ET_EXEC
6366 || filedata
->file_header
.e_type
== ET_DYN
6367 /* These next two tests may be redundant, but
6368 they have been left in for paranoia's sake. */
6369 || streq (SECTION_NAME (section
), ".rel.dyn")
6370 || streq (SECTION_NAME (section
), ".rela.dyn")))
6371 /* Dynamic relocations apply to segments, not sections, so
6372 they do not need an sh_info value. */
6375 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6376 i
, section
->sh_info
);
6382 case SHT_SYMTAB_SHNDX
:
6383 case SHT_INIT_ARRAY
:
6384 case SHT_FINI_ARRAY
:
6385 case SHT_PREINIT_ARRAY
:
6386 if (section
->sh_info
!= 0)
6387 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6388 i
, section
->sh_info
);
6394 /* A symbol index - we assume that it is valid. */
6398 /* FIXME: Add support for target specific section types. */
6399 if (section
->sh_type
== SHT_NOBITS
)
6400 /* NOBITS section headers with non-zero sh_info fields can be
6401 created when a binary is stripped of everything but its debug
6402 information. The stripped sections have their headers
6403 preserved but their types set to SHT_NOBITS. So do not check
6404 this type of section. */
6406 else if (section
->sh_flags
& SHF_INFO_LINK
)
6408 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6409 warn (_("[%2u]: Expected link to another section in info field"), i
);
6411 else if (section
->sh_type
< SHT_LOOS
6412 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6413 && section
->sh_info
!= 0)
6414 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6415 i
, section
->sh_info
);
6419 /* Check the sh_size field. */
6420 if (section
->sh_size
> filedata
->file_size
6421 && section
->sh_type
!= SHT_NOBITS
6422 && section
->sh_type
!= SHT_NULL
6423 && section
->sh_type
< SHT_LOOS
)
6424 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6426 printf (" [%2u] ", i
);
6427 if (do_section_details
)
6428 printf ("%s\n ", printable_section_name (filedata
, section
));
6430 print_symbol (-17, SECTION_NAME (section
));
6432 printf (do_wide
? " %-15s " : " %-15.15s ",
6433 get_section_type_name (filedata
, section
->sh_type
));
6437 const char * link_too_big
= NULL
;
6439 print_vma (section
->sh_addr
, LONG_HEX
);
6441 printf ( " %6.6lx %6.6lx %2.2lx",
6442 (unsigned long) section
->sh_offset
,
6443 (unsigned long) section
->sh_size
,
6444 (unsigned long) section
->sh_entsize
);
6446 if (do_section_details
)
6447 fputs (" ", stdout
);
6449 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6451 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6454 /* The sh_link value is out of range. Normally this indicates
6455 an error but it can have special values in Solaris binaries. */
6456 switch (filedata
->file_header
.e_machine
)
6463 case EM_OLD_SPARCV9
:
6464 case EM_SPARC32PLUS
:
6467 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6468 link_too_big
= "BEFORE";
6469 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6470 link_too_big
= "AFTER";
6477 if (do_section_details
)
6479 if (link_too_big
!= NULL
&& * link_too_big
)
6480 printf ("<%s> ", link_too_big
);
6482 printf ("%2u ", section
->sh_link
);
6483 printf ("%3u %2lu\n", section
->sh_info
,
6484 (unsigned long) section
->sh_addralign
);
6487 printf ("%2u %3u %2lu\n",
6490 (unsigned long) section
->sh_addralign
);
6492 if (link_too_big
&& ! * link_too_big
)
6493 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6494 i
, section
->sh_link
);
6498 print_vma (section
->sh_addr
, LONG_HEX
);
6500 if ((long) section
->sh_offset
== section
->sh_offset
)
6501 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6505 print_vma (section
->sh_offset
, LONG_HEX
);
6508 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6509 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6513 print_vma (section
->sh_size
, LONG_HEX
);
6516 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6517 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6521 print_vma (section
->sh_entsize
, LONG_HEX
);
6524 if (do_section_details
)
6525 fputs (" ", stdout
);
6527 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6529 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6531 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6532 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6535 print_vma (section
->sh_addralign
, DEC
);
6539 else if (do_section_details
)
6542 print_vma (section
->sh_addr
, LONG_HEX
);
6543 if ((long) section
->sh_offset
== section
->sh_offset
)
6544 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6548 print_vma (section
->sh_offset
, LONG_HEX
);
6550 printf (" %u\n ", section
->sh_link
);
6551 print_vma (section
->sh_size
, LONG_HEX
);
6553 print_vma (section
->sh_entsize
, LONG_HEX
);
6555 printf (" %-16u %lu\n",
6557 (unsigned long) section
->sh_addralign
);
6562 print_vma (section
->sh_addr
, LONG_HEX
);
6563 if ((long) section
->sh_offset
== section
->sh_offset
)
6564 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6568 print_vma (section
->sh_offset
, LONG_HEX
);
6571 print_vma (section
->sh_size
, LONG_HEX
);
6573 print_vma (section
->sh_entsize
, LONG_HEX
);
6575 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6577 printf (" %2u %3u %lu\n",
6580 (unsigned long) section
->sh_addralign
);
6583 if (do_section_details
)
6585 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6586 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6588 /* Minimum section size is 12 bytes for 32-bit compression
6589 header + 12 bytes for compressed data header. */
6590 unsigned char buf
[24];
6592 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6593 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6594 sizeof (buf
), _("compression header")))
6596 Elf_Internal_Chdr chdr
;
6598 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6600 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6603 printf (_(" [<unknown>: 0x%x], "),
6605 print_vma (chdr
.ch_size
, LONG_HEX
);
6606 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6612 if (!do_section_details
)
6614 /* The ordering of the letters shown here matches the ordering of the
6615 corresponding SHF_xxx values, and hence the order in which these
6616 letters will be displayed to the user. */
6617 printf (_("Key to Flags:\n\
6618 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6619 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6620 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6621 if (filedata
->file_header
.e_machine
== EM_X86_64
6622 || filedata
->file_header
.e_machine
== EM_L1OM
6623 || filedata
->file_header
.e_machine
== EM_K1OM
)
6624 printf (_("l (large), "));
6625 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6626 printf (_("y (purecode), "));
6627 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6628 printf (_("v (VLE), "));
6629 printf ("p (processor specific)\n");
6636 get_group_flags (unsigned int flags
)
6638 static char buff
[128];
6642 else if (flags
== GRP_COMDAT
)
6645 snprintf (buff
, 14, _("[0x%x: "), flags
);
6647 flags
&= ~ GRP_COMDAT
;
6648 if (flags
& GRP_MASKOS
)
6650 strcat (buff
, "<OS specific>");
6651 flags
&= ~ GRP_MASKOS
;
6654 if (flags
& GRP_MASKPROC
)
6656 strcat (buff
, "<PROC specific>");
6657 flags
&= ~ GRP_MASKPROC
;
6661 strcat (buff
, "<unknown>");
6668 process_section_groups (Filedata
* filedata
)
6670 Elf_Internal_Shdr
* section
;
6672 struct group
* group
;
6673 Elf_Internal_Shdr
* symtab_sec
;
6674 Elf_Internal_Shdr
* strtab_sec
;
6675 Elf_Internal_Sym
* symtab
;
6676 unsigned long num_syms
;
6680 /* Don't process section groups unless needed. */
6681 if (!do_unwind
&& !do_section_groups
)
6684 if (filedata
->file_header
.e_shnum
== 0)
6686 if (do_section_groups
)
6687 printf (_("\nThere are no sections to group in this file.\n"));
6692 if (filedata
->section_headers
== NULL
)
6694 error (_("Section headers are not available!\n"));
6695 /* PR 13622: This can happen with a corrupt ELF header. */
6699 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6700 sizeof (struct group
*));
6702 if (section_headers_groups
== NULL
)
6704 error (_("Out of memory reading %u section group headers\n"),
6705 filedata
->file_header
.e_shnum
);
6709 /* Scan the sections for the group section. */
6711 for (i
= 0, section
= filedata
->section_headers
;
6712 i
< filedata
->file_header
.e_shnum
;
6714 if (section
->sh_type
== SHT_GROUP
)
6717 if (group_count
== 0)
6719 if (do_section_groups
)
6720 printf (_("\nThere are no section groups in this file.\n"));
6725 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6727 if (section_groups
== NULL
)
6729 error (_("Out of memory reading %lu groups\n"),
6730 (unsigned long) group_count
);
6740 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6741 i
< filedata
->file_header
.e_shnum
;
6744 if (section
->sh_type
== SHT_GROUP
)
6746 const char * name
= printable_section_name (filedata
, section
);
6747 const char * group_name
;
6748 unsigned char * start
;
6749 unsigned char * indices
;
6750 unsigned int entry
, j
, size
;
6751 Elf_Internal_Shdr
* sec
;
6752 Elf_Internal_Sym
* sym
;
6754 /* Get the symbol table. */
6755 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6756 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6759 error (_("Bad sh_link in group section `%s'\n"), name
);
6763 if (symtab_sec
!= sec
)
6768 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6773 error (_("Corrupt header in group section `%s'\n"), name
);
6777 if (section
->sh_info
>= num_syms
)
6779 error (_("Bad sh_info in group section `%s'\n"), name
);
6783 sym
= symtab
+ section
->sh_info
;
6785 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6787 if (sym
->st_shndx
== 0
6788 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6790 error (_("Bad sh_info in group section `%s'\n"), name
);
6794 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6803 /* Get the string table. */
6804 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6813 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6819 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6820 1, strtab_sec
->sh_size
,
6822 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6824 group_name
= sym
->st_name
< strtab_size
6825 ? strtab
+ sym
->st_name
: _("<corrupt>");
6828 /* PR 17531: file: loop. */
6829 if (section
->sh_entsize
> section
->sh_size
)
6831 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6832 printable_section_name (filedata
, section
),
6833 (unsigned long) section
->sh_entsize
,
6834 (unsigned long) section
->sh_size
);
6838 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6839 1, section
->sh_size
,
6845 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6846 entry
= byte_get (indices
, 4);
6849 if (do_section_groups
)
6851 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6852 get_group_flags (entry
), i
, name
, group_name
, size
);
6854 printf (_(" [Index] Name\n"));
6857 group
->group_index
= i
;
6859 for (j
= 0; j
< size
; j
++)
6861 struct group_list
* g
;
6863 entry
= byte_get (indices
, 4);
6866 if (entry
>= filedata
->file_header
.e_shnum
)
6868 static unsigned num_group_errors
= 0;
6870 if (num_group_errors
++ < 10)
6872 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6873 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6874 if (num_group_errors
== 10)
6875 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6880 if (section_headers_groups
[entry
] != NULL
)
6884 static unsigned num_errs
= 0;
6886 if (num_errs
++ < 10)
6888 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6890 section_headers_groups
[entry
]->group_index
);
6892 warn (_("Further error messages about already contained group sections suppressed\n"));
6898 /* Intel C/C++ compiler may put section 0 in a
6899 section group. We just warn it the first time
6900 and ignore it afterwards. */
6901 static bfd_boolean warned
= FALSE
;
6904 error (_("section 0 in group section [%5u]\n"),
6905 section_headers_groups
[entry
]->group_index
);
6911 section_headers_groups
[entry
] = group
;
6913 if (do_section_groups
)
6915 sec
= filedata
->section_headers
+ entry
;
6916 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6919 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6920 g
->section_index
= entry
;
6921 g
->next
= group
->root
;
6939 /* Data used to display dynamic fixups. */
6941 struct ia64_vms_dynfixup
6943 bfd_vma needed_ident
; /* Library ident number. */
6944 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6945 bfd_vma fixup_needed
; /* Index of the library. */
6946 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6947 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6950 /* Data used to display dynamic relocations. */
6952 struct ia64_vms_dynimgrela
6954 bfd_vma img_rela_cnt
; /* Number of relocations. */
6955 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6958 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6962 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6963 struct ia64_vms_dynfixup
* fixup
,
6964 const char * strtab
,
6965 unsigned int strtab_sz
)
6967 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6969 const char * lib_name
;
6971 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6972 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6973 _("dynamic section image fixups"));
6977 if (fixup
->needed
< strtab_sz
)
6978 lib_name
= strtab
+ fixup
->needed
;
6981 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6982 (unsigned long) fixup
->needed
);
6985 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6986 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6988 (_("Seg Offset Type SymVec DataType\n"));
6990 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6995 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6996 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6997 type
= BYTE_GET (imfs
[i
].type
);
6998 rtype
= elf_ia64_reloc_type (type
);
7000 printf (" 0x%08x ", type
);
7002 printf (" %-32s ", rtype
);
7003 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7004 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7011 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7014 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7016 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7019 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7020 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7021 _("dynamic section image relocations"));
7025 printf (_("\nImage relocs\n"));
7027 (_("Seg Offset Type Addend Seg Sym Off\n"));
7029 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7034 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7035 printf ("%08" BFD_VMA_FMT
"x ",
7036 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7037 type
= BYTE_GET (imrs
[i
].type
);
7038 rtype
= elf_ia64_reloc_type (type
);
7040 printf ("0x%08x ", type
);
7042 printf ("%-31s ", rtype
);
7043 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7044 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7045 printf ("%08" BFD_VMA_FMT
"x\n",
7046 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7053 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7056 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7058 struct ia64_vms_dynfixup fixup
;
7059 struct ia64_vms_dynimgrela imgrela
;
7060 Elf_Internal_Dyn
*entry
;
7061 bfd_vma strtab_off
= 0;
7062 bfd_vma strtab_sz
= 0;
7063 char *strtab
= NULL
;
7064 bfd_boolean res
= TRUE
;
7066 memset (&fixup
, 0, sizeof (fixup
));
7067 memset (&imgrela
, 0, sizeof (imgrela
));
7069 /* Note: the order of the entries is specified by the OpenVMS specs. */
7070 for (entry
= dynamic_section
;
7071 entry
< dynamic_section
+ dynamic_nent
;
7074 switch (entry
->d_tag
)
7076 case DT_IA_64_VMS_STRTAB_OFFSET
:
7077 strtab_off
= entry
->d_un
.d_val
;
7080 strtab_sz
= entry
->d_un
.d_val
;
7082 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7083 1, strtab_sz
, _("dynamic string section"));
7086 case DT_IA_64_VMS_NEEDED_IDENT
:
7087 fixup
.needed_ident
= entry
->d_un
.d_val
;
7090 fixup
.needed
= entry
->d_un
.d_val
;
7092 case DT_IA_64_VMS_FIXUP_NEEDED
:
7093 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7095 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7096 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7098 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7099 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7100 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7103 case DT_IA_64_VMS_IMG_RELA_CNT
:
7104 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7106 case DT_IA_64_VMS_IMG_RELA_OFF
:
7107 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7108 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7130 dynamic_relocations
[] =
7132 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7133 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7134 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7137 /* Process the reloc section. */
7140 process_relocs (Filedata
* filedata
)
7142 unsigned long rel_size
;
7143 unsigned long rel_offset
;
7148 if (do_using_dynamic
)
7152 bfd_boolean has_dynamic_reloc
;
7155 has_dynamic_reloc
= FALSE
;
7157 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7159 is_rela
= dynamic_relocations
[i
].rela
;
7160 name
= dynamic_relocations
[i
].name
;
7161 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7162 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7165 has_dynamic_reloc
= TRUE
;
7167 if (is_rela
== UNKNOWN
)
7169 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7170 switch (dynamic_info
[DT_PLTREL
])
7184 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7185 name
, rel_offset
, rel_size
);
7187 dump_relocations (filedata
,
7188 offset_from_vma (filedata
, rel_offset
, rel_size
),
7190 dynamic_symbols
, num_dynamic_syms
,
7191 dynamic_strings
, dynamic_strings_length
,
7192 is_rela
, TRUE
/* is_dynamic */);
7196 if (is_ia64_vms (filedata
))
7197 if (process_ia64_vms_dynamic_relocs (filedata
))
7198 has_dynamic_reloc
= TRUE
;
7200 if (! has_dynamic_reloc
)
7201 printf (_("\nThere are no dynamic relocations in this file.\n"));
7205 Elf_Internal_Shdr
* section
;
7207 bfd_boolean found
= FALSE
;
7209 for (i
= 0, section
= filedata
->section_headers
;
7210 i
< filedata
->file_header
.e_shnum
;
7213 if ( section
->sh_type
!= SHT_RELA
7214 && section
->sh_type
!= SHT_REL
)
7217 rel_offset
= section
->sh_offset
;
7218 rel_size
= section
->sh_size
;
7222 Elf_Internal_Shdr
* strsec
;
7224 unsigned long num_rela
;
7226 printf (_("\nRelocation section "));
7228 if (filedata
->string_table
== NULL
)
7229 printf ("%d", section
->sh_name
);
7231 printf ("'%s'", printable_section_name (filedata
, section
));
7233 num_rela
= rel_size
/ section
->sh_entsize
;
7234 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7235 " at offset 0x%lx contains %lu entries:\n",
7237 rel_offset
, num_rela
);
7239 is_rela
= section
->sh_type
== SHT_RELA
;
7241 if (section
->sh_link
!= 0
7242 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7244 Elf_Internal_Shdr
* symsec
;
7245 Elf_Internal_Sym
* symtab
;
7246 unsigned long nsyms
;
7247 unsigned long strtablen
= 0;
7248 char * strtab
= NULL
;
7250 symsec
= filedata
->section_headers
+ section
->sh_link
;
7251 if (symsec
->sh_type
!= SHT_SYMTAB
7252 && symsec
->sh_type
!= SHT_DYNSYM
)
7255 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7260 if (symsec
->sh_link
!= 0
7261 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7263 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7265 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7268 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7271 dump_relocations (filedata
, rel_offset
, rel_size
,
7272 symtab
, nsyms
, strtab
, strtablen
,
7274 symsec
->sh_type
== SHT_DYNSYM
);
7280 dump_relocations (filedata
, rel_offset
, rel_size
,
7281 NULL
, 0, NULL
, 0, is_rela
,
7282 FALSE
/* is_dynamic */);
7290 /* Users sometimes forget the -D option, so try to be helpful. */
7291 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7293 if (dynamic_info
[dynamic_relocations
[i
].size
])
7295 printf (_("\nThere are no static relocations in this file."));
7296 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7301 if (i
== ARRAY_SIZE (dynamic_relocations
))
7302 printf (_("\nThere are no relocations in this file.\n"));
7309 /* An absolute address consists of a section and an offset. If the
7310 section is NULL, the offset itself is the address, otherwise, the
7311 address equals to LOAD_ADDRESS(section) + offset. */
7315 unsigned short section
;
7319 #define ABSADDR(a) \
7321 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7324 /* Find the nearest symbol at or below ADDR. Returns the symbol
7325 name, if found, and the offset from the symbol to ADDR. */
7328 find_symbol_for_address (Filedata
* filedata
,
7329 Elf_Internal_Sym
* symtab
,
7330 unsigned long nsyms
,
7331 const char * strtab
,
7332 unsigned long strtab_size
,
7333 struct absaddr addr
,
7334 const char ** symname
,
7337 bfd_vma dist
= 0x100000;
7338 Elf_Internal_Sym
* sym
;
7339 Elf_Internal_Sym
* beg
;
7340 Elf_Internal_Sym
* end
;
7341 Elf_Internal_Sym
* best
= NULL
;
7343 REMOVE_ARCH_BITS (addr
.offset
);
7345 end
= symtab
+ nsyms
;
7351 sym
= beg
+ (end
- beg
) / 2;
7353 value
= sym
->st_value
;
7354 REMOVE_ARCH_BITS (value
);
7356 if (sym
->st_name
!= 0
7357 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7358 && addr
.offset
>= value
7359 && addr
.offset
- value
< dist
)
7362 dist
= addr
.offset
- value
;
7367 if (addr
.offset
< value
)
7375 *symname
= (best
->st_name
>= strtab_size
7376 ? _("<corrupt>") : strtab
+ best
->st_name
);
7382 *offset
= addr
.offset
;
7385 static /* signed */ int
7386 symcmp (const void *p
, const void *q
)
7388 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7389 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7391 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7394 /* Process the unwind section. */
7396 #include "unwind-ia64.h"
7398 struct ia64_unw_table_entry
7400 struct absaddr start
;
7402 struct absaddr info
;
7405 struct ia64_unw_aux_info
7407 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7408 unsigned long table_len
; /* Length of unwind table. */
7409 unsigned char * info
; /* Unwind info. */
7410 unsigned long info_size
; /* Size of unwind info. */
7411 bfd_vma info_addr
; /* Starting address of unwind info. */
7412 bfd_vma seg_base
; /* Starting address of segment. */
7413 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7414 unsigned long nsyms
; /* Number of symbols. */
7415 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7416 unsigned long nfuns
; /* Number of entries in funtab. */
7417 char * strtab
; /* The string table. */
7418 unsigned long strtab_size
; /* Size of string table. */
7422 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7424 struct ia64_unw_table_entry
* tp
;
7425 unsigned long j
, nfuns
;
7427 bfd_boolean res
= TRUE
;
7429 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7430 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7431 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7432 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7434 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7436 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7440 const unsigned char * dp
;
7441 const unsigned char * head
;
7442 const unsigned char * end
;
7443 const char * procname
;
7445 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7446 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7448 fputs ("\n<", stdout
);
7452 fputs (procname
, stdout
);
7455 printf ("+%lx", (unsigned long) offset
);
7458 fputs (">: [", stdout
);
7459 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7460 fputc ('-', stdout
);
7461 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7462 printf ("], info at +0x%lx\n",
7463 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7465 /* PR 17531: file: 86232b32. */
7466 if (aux
->info
== NULL
)
7469 /* PR 17531: file: 0997b4d1. */
7470 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7472 warn (_("Invalid offset %lx in table entry %ld\n"),
7473 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7478 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7479 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7481 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7482 (unsigned) UNW_VER (stamp
),
7483 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7484 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7485 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7486 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7488 if (UNW_VER (stamp
) != 1)
7490 printf (_("\tUnknown version.\n"));
7495 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7496 /* PR 17531: file: 16ceda89. */
7497 if (end
> aux
->info
+ aux
->info_size
)
7498 end
= aux
->info
+ aux
->info_size
;
7499 for (dp
= head
+ 8; dp
< end
;)
7500 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7509 slurp_ia64_unwind_table (Filedata
* filedata
,
7510 struct ia64_unw_aux_info
* aux
,
7511 Elf_Internal_Shdr
* sec
)
7513 unsigned long size
, nrelas
, i
;
7514 Elf_Internal_Phdr
* seg
;
7515 struct ia64_unw_table_entry
* tep
;
7516 Elf_Internal_Shdr
* relsec
;
7517 Elf_Internal_Rela
* rela
;
7518 Elf_Internal_Rela
* rp
;
7519 unsigned char * table
;
7521 Elf_Internal_Sym
* sym
;
7522 const char * relname
;
7526 /* First, find the starting address of the segment that includes
7529 if (filedata
->file_header
.e_phnum
)
7531 if (! get_program_headers (filedata
))
7534 for (seg
= filedata
->program_headers
;
7535 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7538 if (seg
->p_type
!= PT_LOAD
)
7541 if (sec
->sh_addr
>= seg
->p_vaddr
7542 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7544 aux
->seg_base
= seg
->p_vaddr
;
7550 /* Second, build the unwind table from the contents of the unwind section: */
7551 size
= sec
->sh_size
;
7552 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7557 aux
->table_len
= size
/ (3 * eh_addr_size
);
7558 aux
->table
= (struct ia64_unw_table_entry
*)
7559 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7562 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7564 tep
->start
.section
= SHN_UNDEF
;
7565 tep
->end
.section
= SHN_UNDEF
;
7566 tep
->info
.section
= SHN_UNDEF
;
7567 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7568 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7569 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7570 tep
->start
.offset
+= aux
->seg_base
;
7571 tep
->end
.offset
+= aux
->seg_base
;
7572 tep
->info
.offset
+= aux
->seg_base
;
7576 /* Third, apply any relocations to the unwind table: */
7577 for (relsec
= filedata
->section_headers
;
7578 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7581 if (relsec
->sh_type
!= SHT_RELA
7582 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7583 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7586 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7595 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7597 relname
= elf_ia64_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7598 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7600 /* PR 17531: file: 9fa67536. */
7601 if (relname
== NULL
)
7603 warn (_("Skipping unknown relocation type: %u\n"),
7604 get_reloc_type (filedata
, rp
->r_info
));
7608 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7610 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7614 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7616 /* PR 17531: file: 5bc8d9bf. */
7617 if (i
>= aux
->table_len
)
7619 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7623 switch (rp
->r_offset
/ eh_addr_size
% 3)
7626 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7627 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7630 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7631 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7634 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7635 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7649 ia64_process_unwind (Filedata
* filedata
)
7651 Elf_Internal_Shdr
* sec
;
7652 Elf_Internal_Shdr
* unwsec
= NULL
;
7653 Elf_Internal_Shdr
* strsec
;
7654 unsigned long i
, unwcount
= 0, unwstart
= 0;
7655 struct ia64_unw_aux_info aux
;
7656 bfd_boolean res
= TRUE
;
7658 memset (& aux
, 0, sizeof (aux
));
7660 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7662 if (sec
->sh_type
== SHT_SYMTAB
7663 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7665 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7667 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7668 if (aux
.strtab
!= NULL
)
7670 error (_("Multiple auxillary string tables encountered\n"));
7674 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7677 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7679 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7684 printf (_("\nThere are no unwind sections in this file.\n"));
7686 while (unwcount
-- > 0)
7691 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7692 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7693 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7698 /* We have already counted the number of SHT_IA64_UNWIND
7699 sections so the loop above should never fail. */
7700 assert (unwsec
!= NULL
);
7703 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7705 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7707 /* We need to find which section group it is in. */
7708 struct group_list
* g
;
7710 if (section_headers_groups
== NULL
7711 || section_headers_groups
[i
] == NULL
)
7712 i
= filedata
->file_header
.e_shnum
;
7715 g
= section_headers_groups
[i
]->root
;
7717 for (; g
!= NULL
; g
= g
->next
)
7719 sec
= filedata
->section_headers
+ g
->section_index
;
7721 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7726 i
= filedata
->file_header
.e_shnum
;
7729 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7731 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7732 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7733 suffix
= SECTION_NAME (unwsec
) + len
;
7734 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7736 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7737 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7742 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7743 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7744 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7745 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7747 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7748 suffix
= SECTION_NAME (unwsec
) + len
;
7749 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7751 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7752 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7756 if (i
== filedata
->file_header
.e_shnum
)
7758 printf (_("\nCould not find unwind info section for "));
7760 if (filedata
->string_table
== NULL
)
7761 printf ("%d", unwsec
->sh_name
);
7763 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7767 aux
.info_addr
= sec
->sh_addr
;
7768 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7771 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7773 printf (_("\nUnwind section "));
7775 if (filedata
->string_table
== NULL
)
7776 printf ("%d", unwsec
->sh_name
);
7778 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7780 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7781 (unsigned long) unwsec
->sh_offset
,
7782 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7784 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7785 && aux
.table_len
> 0)
7786 dump_ia64_unwind (filedata
, & aux
);
7789 free ((char *) aux
.table
);
7791 free ((char *) aux
.info
);
7800 free ((char *) aux
.strtab
);
7805 struct hppa_unw_table_entry
7807 struct absaddr start
;
7809 unsigned int Cannot_unwind
:1; /* 0 */
7810 unsigned int Millicode
:1; /* 1 */
7811 unsigned int Millicode_save_sr0
:1; /* 2 */
7812 unsigned int Region_description
:2; /* 3..4 */
7813 unsigned int reserved1
:1; /* 5 */
7814 unsigned int Entry_SR
:1; /* 6 */
7815 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7816 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7817 unsigned int Args_stored
:1; /* 16 */
7818 unsigned int Variable_Frame
:1; /* 17 */
7819 unsigned int Separate_Package_Body
:1; /* 18 */
7820 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7821 unsigned int Stack_Overflow_Check
:1; /* 20 */
7822 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7823 unsigned int Ada_Region
:1; /* 22 */
7824 unsigned int cxx_info
:1; /* 23 */
7825 unsigned int cxx_try_catch
:1; /* 24 */
7826 unsigned int sched_entry_seq
:1; /* 25 */
7827 unsigned int reserved2
:1; /* 26 */
7828 unsigned int Save_SP
:1; /* 27 */
7829 unsigned int Save_RP
:1; /* 28 */
7830 unsigned int Save_MRP_in_frame
:1; /* 29 */
7831 unsigned int extn_ptr_defined
:1; /* 30 */
7832 unsigned int Cleanup_defined
:1; /* 31 */
7834 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7835 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7836 unsigned int Large_frame
:1; /* 2 */
7837 unsigned int Pseudo_SP_Set
:1; /* 3 */
7838 unsigned int reserved4
:1; /* 4 */
7839 unsigned int Total_frame_size
:27; /* 5..31 */
7842 struct hppa_unw_aux_info
7844 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7845 unsigned long table_len
; /* Length of unwind table. */
7846 bfd_vma seg_base
; /* Starting address of segment. */
7847 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7848 unsigned long nsyms
; /* Number of symbols. */
7849 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7850 unsigned long nfuns
; /* Number of entries in funtab. */
7851 char * strtab
; /* The string table. */
7852 unsigned long strtab_size
; /* Size of string table. */
7856 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7858 struct hppa_unw_table_entry
* tp
;
7859 unsigned long j
, nfuns
;
7860 bfd_boolean res
= TRUE
;
7862 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7863 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7864 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7865 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7867 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7869 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7872 const char * procname
;
7874 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7875 aux
->strtab_size
, tp
->start
, &procname
,
7878 fputs ("\n<", stdout
);
7882 fputs (procname
, stdout
);
7885 printf ("+%lx", (unsigned long) offset
);
7888 fputs (">: [", stdout
);
7889 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7890 fputc ('-', stdout
);
7891 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7894 #define PF(_m) if (tp->_m) printf (#_m " ");
7895 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7898 PF(Millicode_save_sr0
);
7899 /* PV(Region_description); */
7905 PF(Separate_Package_Body
);
7906 PF(Frame_Extension_Millicode
);
7907 PF(Stack_Overflow_Check
);
7908 PF(Two_Instruction_SP_Increment
);
7912 PF(sched_entry_seq
);
7915 PF(Save_MRP_in_frame
);
7916 PF(extn_ptr_defined
);
7917 PF(Cleanup_defined
);
7918 PF(MPE_XL_interrupt_marker
);
7919 PF(HP_UX_interrupt_marker
);
7922 PV(Total_frame_size
);
7935 slurp_hppa_unwind_table (Filedata
* filedata
,
7936 struct hppa_unw_aux_info
* aux
,
7937 Elf_Internal_Shdr
* sec
)
7939 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7940 Elf_Internal_Phdr
* seg
;
7941 struct hppa_unw_table_entry
* tep
;
7942 Elf_Internal_Shdr
* relsec
;
7943 Elf_Internal_Rela
* rela
;
7944 Elf_Internal_Rela
* rp
;
7945 unsigned char * table
;
7947 Elf_Internal_Sym
* sym
;
7948 const char * relname
;
7950 /* First, find the starting address of the segment that includes
7952 if (filedata
->file_header
.e_phnum
)
7954 if (! get_program_headers (filedata
))
7957 for (seg
= filedata
->program_headers
;
7958 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7961 if (seg
->p_type
!= PT_LOAD
)
7964 if (sec
->sh_addr
>= seg
->p_vaddr
7965 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7967 aux
->seg_base
= seg
->p_vaddr
;
7973 /* Second, build the unwind table from the contents of the unwind
7975 size
= sec
->sh_size
;
7976 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7982 nentries
= size
/ unw_ent_size
;
7983 size
= unw_ent_size
* nentries
;
7985 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7986 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7988 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7990 unsigned int tmp1
, tmp2
;
7992 tep
->start
.section
= SHN_UNDEF
;
7993 tep
->end
.section
= SHN_UNDEF
;
7995 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7996 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7997 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7998 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8000 tep
->start
.offset
+= aux
->seg_base
;
8001 tep
->end
.offset
+= aux
->seg_base
;
8003 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8004 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8005 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8006 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8007 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8008 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8009 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8010 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8011 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8012 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8013 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8014 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8015 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8016 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8017 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8018 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8019 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8020 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8021 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8022 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8023 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8024 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8025 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8026 tep
->Cleanup_defined
= tmp1
& 0x1;
8028 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8029 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8030 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8031 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8032 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8033 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8037 /* Third, apply any relocations to the unwind table. */
8038 for (relsec
= filedata
->section_headers
;
8039 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8042 if (relsec
->sh_type
!= SHT_RELA
8043 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8044 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8047 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8051 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8053 relname
= elf_hppa_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
8054 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
8056 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8057 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8059 warn (_("Skipping unexpected relocation type %s\n"), relname
);
8063 i
= rp
->r_offset
/ unw_ent_size
;
8065 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
8068 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8069 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8072 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8073 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8083 aux
->table_len
= nentries
;
8089 hppa_process_unwind (Filedata
* filedata
)
8091 struct hppa_unw_aux_info aux
;
8092 Elf_Internal_Shdr
* unwsec
= NULL
;
8093 Elf_Internal_Shdr
* strsec
;
8094 Elf_Internal_Shdr
* sec
;
8096 bfd_boolean res
= TRUE
;
8098 if (filedata
->string_table
== NULL
)
8101 memset (& aux
, 0, sizeof (aux
));
8103 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8105 if (sec
->sh_type
== SHT_SYMTAB
8106 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8108 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8110 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8111 if (aux
.strtab
!= NULL
)
8113 error (_("Multiple auxillary string tables encountered\n"));
8117 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8120 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8122 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8127 printf (_("\nThere are no unwind sections in this file.\n"));
8129 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8131 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8133 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8135 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8136 "contains %lu entry:\n",
8137 "\nUnwind section '%s' at offset 0x%lx "
8138 "contains %lu entries:\n",
8140 printable_section_name (filedata
, sec
),
8141 (unsigned long) sec
->sh_offset
,
8144 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8147 if (res
&& aux
.table_len
> 0)
8149 if (! dump_hppa_unwind (filedata
, &aux
))
8154 free ((char *) aux
.table
);
8162 free ((char *) aux
.strtab
);
8169 unsigned char * data
; /* The unwind data. */
8170 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8171 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8172 unsigned long nrelas
; /* The number of relocations. */
8173 unsigned int rel_type
; /* REL or RELA ? */
8174 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8177 struct arm_unw_aux_info
8179 Filedata
* filedata
; /* The file containing the unwind sections. */
8180 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8181 unsigned long nsyms
; /* Number of symbols. */
8182 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8183 unsigned long nfuns
; /* Number of these symbols. */
8184 char * strtab
; /* The file's string table. */
8185 unsigned long strtab_size
; /* Size of string table. */
8189 arm_print_vma_and_name (Filedata
* filedata
,
8190 struct arm_unw_aux_info
* aux
,
8192 struct absaddr addr
)
8194 const char *procname
;
8197 if (addr
.section
== SHN_UNDEF
)
8200 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8201 aux
->strtab_size
, addr
, &procname
,
8204 print_vma (fn
, PREFIX_HEX
);
8208 fputs (" <", stdout
);
8209 fputs (procname
, stdout
);
8212 printf ("+0x%lx", (unsigned long) sym_offset
);
8213 fputc ('>', stdout
);
8220 arm_free_section (struct arm_section
*arm_sec
)
8222 if (arm_sec
->data
!= NULL
)
8223 free (arm_sec
->data
);
8225 if (arm_sec
->rela
!= NULL
)
8226 free (arm_sec
->rela
);
8229 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8230 cached section and install SEC instead.
8231 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8232 and return its valued in * WORDP, relocating if necessary.
8233 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8234 relocation's offset in ADDR.
8235 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8236 into the string table of the symbol associated with the reloc. If no
8237 reloc was applied store -1 there.
8238 5) Return TRUE upon success, FALSE otherwise. */
8241 get_unwind_section_word (Filedata
* filedata
,
8242 struct arm_unw_aux_info
* aux
,
8243 struct arm_section
* arm_sec
,
8244 Elf_Internal_Shdr
* sec
,
8245 bfd_vma word_offset
,
8246 unsigned int * wordp
,
8247 struct absaddr
* addr
,
8250 Elf_Internal_Rela
*rp
;
8251 Elf_Internal_Sym
*sym
;
8252 const char * relname
;
8254 bfd_boolean wrapped
;
8256 if (sec
== NULL
|| arm_sec
== NULL
)
8259 addr
->section
= SHN_UNDEF
;
8262 if (sym_name
!= NULL
)
8263 *sym_name
= (bfd_vma
) -1;
8265 /* If necessary, update the section cache. */
8266 if (sec
!= arm_sec
->sec
)
8268 Elf_Internal_Shdr
*relsec
;
8270 arm_free_section (arm_sec
);
8273 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8274 sec
->sh_size
, _("unwind data"));
8275 arm_sec
->rela
= NULL
;
8276 arm_sec
->nrelas
= 0;
8278 for (relsec
= filedata
->section_headers
;
8279 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8282 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8283 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8284 /* PR 15745: Check the section type as well. */
8285 || (relsec
->sh_type
!= SHT_REL
8286 && relsec
->sh_type
!= SHT_RELA
))
8289 arm_sec
->rel_type
= relsec
->sh_type
;
8290 if (relsec
->sh_type
== SHT_REL
)
8292 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8294 & arm_sec
->rela
, & arm_sec
->nrelas
))
8297 else /* relsec->sh_type == SHT_RELA */
8299 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8301 & arm_sec
->rela
, & arm_sec
->nrelas
))
8307 arm_sec
->next_rela
= arm_sec
->rela
;
8310 /* If there is no unwind data we can do nothing. */
8311 if (arm_sec
->data
== NULL
)
8314 /* If the offset is invalid then fail. */
8315 if (/* PR 21343 *//* PR 18879 */
8317 || word_offset
> (sec
->sh_size
- 4)
8318 || ((bfd_signed_vma
) word_offset
) < 0)
8321 /* Get the word at the required offset. */
8322 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8324 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8325 if (arm_sec
->rela
== NULL
)
8331 /* Look through the relocs to find the one that applies to the provided offset. */
8333 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8335 bfd_vma prelval
, offset
;
8337 if (rp
->r_offset
> word_offset
&& !wrapped
)
8342 if (rp
->r_offset
> word_offset
)
8345 if (rp
->r_offset
& 3)
8347 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8348 (unsigned long) rp
->r_offset
);
8352 if (rp
->r_offset
< word_offset
)
8355 /* PR 17531: file: 027-161405-0.004 */
8356 if (aux
->symtab
== NULL
)
8359 if (arm_sec
->rel_type
== SHT_REL
)
8361 offset
= word
& 0x7fffffff;
8362 if (offset
& 0x40000000)
8363 offset
|= ~ (bfd_vma
) 0x7fffffff;
8365 else if (arm_sec
->rel_type
== SHT_RELA
)
8366 offset
= rp
->r_addend
;
8369 error (_("Unknown section relocation type %d encountered\n"),
8374 /* PR 17531 file: 027-1241568-0.004. */
8375 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8377 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8378 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8382 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8383 offset
+= sym
->st_value
;
8384 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8386 /* Check that we are processing the expected reloc type. */
8387 if (filedata
->file_header
.e_machine
== EM_ARM
)
8389 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8390 if (relname
== NULL
)
8392 warn (_("Skipping unknown ARM relocation type: %d\n"),
8393 (int) ELF32_R_TYPE (rp
->r_info
));
8397 if (streq (relname
, "R_ARM_NONE"))
8400 if (! streq (relname
, "R_ARM_PREL31"))
8402 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8406 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8408 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8409 if (relname
== NULL
)
8411 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8412 (int) ELF32_R_TYPE (rp
->r_info
));
8416 if (streq (relname
, "R_C6000_NONE"))
8419 if (! streq (relname
, "R_C6000_PREL31"))
8421 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8429 /* This function currently only supports ARM and TI unwinders. */
8430 warn (_("Only TI and ARM unwinders are currently supported\n"));
8434 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8435 addr
->section
= sym
->st_shndx
;
8436 addr
->offset
= offset
;
8439 * sym_name
= sym
->st_name
;
8444 arm_sec
->next_rela
= rp
;
8449 static const char *tic6x_unwind_regnames
[16] =
8451 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8452 "A14", "A13", "A12", "A11", "A10",
8453 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8457 decode_tic6x_unwind_regmask (unsigned int mask
)
8461 for (i
= 12; mask
; mask
>>= 1, i
--)
8465 fputs (tic6x_unwind_regnames
[i
], stdout
);
8467 fputs (", ", stdout
);
8473 if (remaining == 0 && more_words) \
8476 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8477 data_offset, & word, & addr, NULL)) \
8483 #define GET_OP(OP) \
8488 (OP) = word >> 24; \
8493 printf (_("[Truncated opcode]\n")); \
8496 printf ("0x%02x ", OP)
8499 decode_arm_unwind_bytecode (Filedata
* filedata
,
8500 struct arm_unw_aux_info
* aux
,
8502 unsigned int remaining
,
8503 unsigned int more_words
,
8504 bfd_vma data_offset
,
8505 Elf_Internal_Shdr
* data_sec
,
8506 struct arm_section
* data_arm_sec
)
8508 struct absaddr addr
;
8509 bfd_boolean res
= TRUE
;
8511 /* Decode the unwinding instructions. */
8514 unsigned int op
, op2
;
8523 printf (" 0x%02x ", op
);
8525 if ((op
& 0xc0) == 0x00)
8527 int offset
= ((op
& 0x3f) << 2) + 4;
8529 printf (" vsp = vsp + %d", offset
);
8531 else if ((op
& 0xc0) == 0x40)
8533 int offset
= ((op
& 0x3f) << 2) + 4;
8535 printf (" vsp = vsp - %d", offset
);
8537 else if ((op
& 0xf0) == 0x80)
8540 if (op
== 0x80 && op2
== 0)
8541 printf (_("Refuse to unwind"));
8544 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8545 bfd_boolean first
= TRUE
;
8549 for (i
= 0; i
< 12; i
++)
8550 if (mask
& (1 << i
))
8556 printf ("r%d", 4 + i
);
8561 else if ((op
& 0xf0) == 0x90)
8563 if (op
== 0x9d || op
== 0x9f)
8564 printf (_(" [Reserved]"));
8566 printf (" vsp = r%d", op
& 0x0f);
8568 else if ((op
& 0xf0) == 0xa0)
8570 int end
= 4 + (op
& 0x07);
8571 bfd_boolean first
= TRUE
;
8575 for (i
= 4; i
<= end
; i
++)
8591 else if (op
== 0xb0)
8592 printf (_(" finish"));
8593 else if (op
== 0xb1)
8596 if (op2
== 0 || (op2
& 0xf0) != 0)
8597 printf (_("[Spare]"));
8600 unsigned int mask
= op2
& 0x0f;
8601 bfd_boolean first
= TRUE
;
8605 for (i
= 0; i
< 12; i
++)
8606 if (mask
& (1 << i
))
8617 else if (op
== 0xb2)
8619 unsigned char buf
[9];
8620 unsigned int i
, len
;
8621 unsigned long offset
;
8623 for (i
= 0; i
< sizeof (buf
); i
++)
8626 if ((buf
[i
] & 0x80) == 0)
8629 if (i
== sizeof (buf
))
8631 error (_("corrupt change to vsp"));
8636 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8637 assert (len
== i
+ 1);
8638 offset
= offset
* 4 + 0x204;
8639 printf ("vsp = vsp + %ld", offset
);
8642 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8644 unsigned int first
, last
;
8651 printf ("pop {D%d", first
);
8653 printf ("-D%d", first
+ last
);
8656 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8658 unsigned int count
= op
& 0x07;
8662 printf ("-D%d", 8 + count
);
8665 else if (op
>= 0xc0 && op
<= 0xc5)
8667 unsigned int count
= op
& 0x07;
8669 printf (" pop {wR10");
8671 printf ("-wR%d", 10 + count
);
8674 else if (op
== 0xc6)
8676 unsigned int first
, last
;
8681 printf ("pop {wR%d", first
);
8683 printf ("-wR%d", first
+ last
);
8686 else if (op
== 0xc7)
8689 if (op2
== 0 || (op2
& 0xf0) != 0)
8690 printf (_("[Spare]"));
8693 unsigned int mask
= op2
& 0x0f;
8694 bfd_boolean first
= TRUE
;
8698 for (i
= 0; i
< 4; i
++)
8699 if (mask
& (1 << i
))
8705 printf ("wCGR%d", i
);
8712 printf (_(" [unsupported opcode]"));
8723 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8724 struct arm_unw_aux_info
* aux
,
8726 unsigned int remaining
,
8727 unsigned int more_words
,
8728 bfd_vma data_offset
,
8729 Elf_Internal_Shdr
* data_sec
,
8730 struct arm_section
* data_arm_sec
)
8732 struct absaddr addr
;
8734 /* Decode the unwinding instructions. */
8737 unsigned int op
, op2
;
8746 printf (" 0x%02x ", op
);
8748 if ((op
& 0xc0) == 0x00)
8750 int offset
= ((op
& 0x3f) << 3) + 8;
8751 printf (" sp = sp + %d", offset
);
8753 else if ((op
& 0xc0) == 0x80)
8756 if (op
== 0x80 && op2
== 0)
8757 printf (_("Refuse to unwind"));
8760 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8762 printf ("pop compact {");
8766 decode_tic6x_unwind_regmask (mask
);
8770 else if ((op
& 0xf0) == 0xc0)
8778 unsigned int offset
;
8782 /* Scan entire instruction first so that GET_OP output is not
8783 interleaved with disassembly. */
8785 for (i
= 0; nregs
< (op
& 0xf); i
++)
8791 regpos
[nregs
].offset
= i
* 2;
8792 regpos
[nregs
].reg
= reg
;
8799 regpos
[nregs
].offset
= i
* 2 + 1;
8800 regpos
[nregs
].reg
= reg
;
8805 printf (_("pop frame {"));
8807 for (i
= i
* 2; i
> 0; i
--)
8809 if (regpos
[reg
].offset
== i
- 1)
8811 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8818 fputs (name
, stdout
);
8825 else if (op
== 0xd0)
8826 printf (" MOV FP, SP");
8827 else if (op
== 0xd1)
8828 printf (" __c6xabi_pop_rts");
8829 else if (op
== 0xd2)
8831 unsigned char buf
[9];
8832 unsigned int i
, len
;
8833 unsigned long offset
;
8835 for (i
= 0; i
< sizeof (buf
); i
++)
8838 if ((buf
[i
] & 0x80) == 0)
8841 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8842 if (i
== sizeof (buf
))
8844 warn (_("Corrupt stack pointer adjustment detected\n"));
8848 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8849 assert (len
== i
+ 1);
8850 offset
= offset
* 8 + 0x408;
8851 printf (_("sp = sp + %ld"), offset
);
8853 else if ((op
& 0xf0) == 0xe0)
8855 if ((op
& 0x0f) == 7)
8858 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8862 printf (_(" [unsupported opcode]"));
8871 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8875 offset
= word
& 0x7fffffff;
8876 if (offset
& 0x40000000)
8877 offset
|= ~ (bfd_vma
) 0x7fffffff;
8879 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8882 return offset
+ where
;
8886 decode_arm_unwind (Filedata
* filedata
,
8887 struct arm_unw_aux_info
* aux
,
8889 unsigned int remaining
,
8890 bfd_vma data_offset
,
8891 Elf_Internal_Shdr
* data_sec
,
8892 struct arm_section
* data_arm_sec
)
8895 unsigned int more_words
= 0;
8896 struct absaddr addr
;
8897 bfd_vma sym_name
= (bfd_vma
) -1;
8898 bfd_boolean res
= TRUE
;
8902 /* Fetch the first word.
8903 Note - when decoding an object file the address extracted
8904 here will always be 0. So we also pass in the sym_name
8905 parameter so that we can find the symbol associated with
8906 the personality routine. */
8907 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8908 & word
, & addr
, & sym_name
))
8914 if ((word
& 0x80000000) == 0)
8916 /* Expand prel31 for personality routine. */
8918 const char *procname
;
8920 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8921 printf (_(" Personality routine: "));
8923 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8924 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8926 procname
= aux
->strtab
+ sym_name
;
8927 print_vma (fn
, PREFIX_HEX
);
8930 fputs (" <", stdout
);
8931 fputs (procname
, stdout
);
8932 fputc ('>', stdout
);
8936 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8937 fputc ('\n', stdout
);
8939 /* The GCC personality routines use the standard compact
8940 encoding, starting with one byte giving the number of
8942 if (procname
!= NULL
8943 && (const_strneq (procname
, "__gcc_personality_v0")
8944 || const_strneq (procname
, "__gxx_personality_v0")
8945 || const_strneq (procname
, "__gcj_personality_v0")
8946 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8953 printf (_(" [Truncated data]\n"));
8956 more_words
= word
>> 24;
8966 /* ARM EHABI Section 6.3:
8968 An exception-handling table entry for the compact model looks like:
8972 1 0 index Data for personalityRoutine[index] */
8974 if (filedata
->file_header
.e_machine
== EM_ARM
8975 && (word
& 0x70000000))
8977 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8981 per_index
= (word
>> 24) & 0x7f;
8982 printf (_(" Compact model index: %d\n"), per_index
);
8989 else if (per_index
< 3)
8991 more_words
= (word
>> 16) & 0xff;
8997 switch (filedata
->file_header
.e_machine
)
9002 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9003 data_offset
, data_sec
, data_arm_sec
))
9008 warn (_("Unknown ARM compact model index encountered\n"));
9009 printf (_(" [reserved]\n"));
9017 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9018 data_offset
, data_sec
, data_arm_sec
))
9021 else if (per_index
< 5)
9023 if (((word
>> 17) & 0x7f) == 0x7f)
9024 printf (_(" Restore stack from frame pointer\n"));
9026 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9027 printf (_(" Registers restored: "));
9029 printf (" (compact) ");
9030 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9032 printf (_(" Return register: %s\n"),
9033 tic6x_unwind_regnames
[word
& 0xf]);
9036 printf (_(" [reserved (%d)]\n"), per_index
);
9040 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9041 filedata
->file_header
.e_machine
);
9045 /* Decode the descriptors. Not implemented. */
9051 dump_arm_unwind (Filedata
* filedata
,
9052 struct arm_unw_aux_info
* aux
,
9053 Elf_Internal_Shdr
* exidx_sec
)
9055 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9056 unsigned int i
, exidx_len
;
9057 unsigned long j
, nfuns
;
9058 bfd_boolean res
= TRUE
;
9060 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9061 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9062 exidx_len
= exidx_sec
->sh_size
/ 8;
9064 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9065 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9066 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9067 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9069 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9071 for (i
= 0; i
< exidx_len
; i
++)
9073 unsigned int exidx_fn
, exidx_entry
;
9074 struct absaddr fn_addr
, entry_addr
;
9077 fputc ('\n', stdout
);
9079 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9080 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9081 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9082 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9085 arm_free_section (& exidx_arm_sec
);
9086 arm_free_section (& extab_arm_sec
);
9090 /* ARM EHABI, Section 5:
9091 An index table entry consists of 2 words.
9092 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9093 if (exidx_fn
& 0x80000000)
9095 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9099 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9101 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9102 fputs (": ", stdout
);
9104 if (exidx_entry
== 1)
9106 print_vma (exidx_entry
, PREFIX_HEX
);
9107 fputs (" [cantunwind]\n", stdout
);
9109 else if (exidx_entry
& 0x80000000)
9111 print_vma (exidx_entry
, PREFIX_HEX
);
9112 fputc ('\n', stdout
);
9113 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9117 bfd_vma table
, table_offset
= 0;
9118 Elf_Internal_Shdr
*table_sec
;
9120 fputs ("@", stdout
);
9121 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9122 print_vma (table
, PREFIX_HEX
);
9125 /* Locate the matching .ARM.extab. */
9126 if (entry_addr
.section
!= SHN_UNDEF
9127 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9129 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9130 table_offset
= entry_addr
.offset
;
9132 if (table_offset
> table_sec
->sh_size
9133 || ((bfd_signed_vma
) table_offset
) < 0)
9135 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9136 (unsigned long) table_offset
,
9137 printable_section_name (filedata
, table_sec
));
9144 table_sec
= find_section_by_address (filedata
, table
);
9145 if (table_sec
!= NULL
)
9146 table_offset
= table
- table_sec
->sh_addr
;
9149 if (table_sec
== NULL
)
9151 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9152 (unsigned long) table
);
9157 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9166 arm_free_section (&exidx_arm_sec
);
9167 arm_free_section (&extab_arm_sec
);
9172 /* Used for both ARM and C6X unwinding tables. */
9175 arm_process_unwind (Filedata
* filedata
)
9177 struct arm_unw_aux_info aux
;
9178 Elf_Internal_Shdr
*unwsec
= NULL
;
9179 Elf_Internal_Shdr
*strsec
;
9180 Elf_Internal_Shdr
*sec
;
9182 unsigned int sec_type
;
9183 bfd_boolean res
= TRUE
;
9185 switch (filedata
->file_header
.e_machine
)
9188 sec_type
= SHT_ARM_EXIDX
;
9192 sec_type
= SHT_C6000_UNWIND
;
9196 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9197 filedata
->file_header
.e_machine
);
9201 if (filedata
->string_table
== NULL
)
9204 memset (& aux
, 0, sizeof (aux
));
9205 aux
.filedata
= filedata
;
9207 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9209 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9211 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9213 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9215 /* PR binutils/17531 file: 011-12666-0.004. */
9216 if (aux
.strtab
!= NULL
)
9218 error (_("Multiple string tables found in file.\n"));
9222 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9223 1, strsec
->sh_size
, _("string table"));
9224 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9226 else if (sec
->sh_type
== sec_type
)
9231 printf (_("\nThere are no unwind sections in this file.\n"));
9233 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9235 if (sec
->sh_type
== sec_type
)
9237 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9238 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9239 "contains %lu entry:\n",
9240 "\nUnwind section '%s' at offset 0x%lx "
9241 "contains %lu entries:\n",
9243 printable_section_name (filedata
, sec
),
9244 (unsigned long) sec
->sh_offset
,
9247 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9255 free ((char *) aux
.strtab
);
9261 process_unwind (Filedata
* filedata
)
9263 struct unwind_handler
9265 unsigned int machtype
;
9266 bfd_boolean (* handler
)(Filedata
*);
9269 { EM_ARM
, arm_process_unwind
},
9270 { EM_IA_64
, ia64_process_unwind
},
9271 { EM_PARISC
, hppa_process_unwind
},
9272 { EM_TI_C6000
, arm_process_unwind
},
9280 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9281 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9282 return handlers
[i
].handler (filedata
);
9284 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9285 get_machine_name (filedata
->file_header
.e_machine
));
9290 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9292 switch (entry
->d_tag
)
9295 if (entry
->d_un
.d_val
== 0)
9299 static const char * opts
[] =
9301 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9302 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9303 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9304 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9308 bfd_boolean first
= TRUE
;
9310 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9311 if (entry
->d_un
.d_val
& (1 << cnt
))
9313 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9319 case DT_MIPS_IVERSION
:
9320 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9321 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9325 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9326 /* Note: coded this way so that there is a single string for translation. */
9327 printf (_("<corrupt: %s>"), buf
);
9331 case DT_MIPS_TIME_STAMP
:
9335 time_t atime
= entry
->d_un
.d_val
;
9337 tmp
= gmtime (&atime
);
9338 /* PR 17531: file: 6accc532. */
9340 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9342 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9343 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9344 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9345 printf (_("Time Stamp: %s"), timebuf
);
9349 case DT_MIPS_RLD_VERSION
:
9350 case DT_MIPS_LOCAL_GOTNO
:
9351 case DT_MIPS_CONFLICTNO
:
9352 case DT_MIPS_LIBLISTNO
:
9353 case DT_MIPS_SYMTABNO
:
9354 case DT_MIPS_UNREFEXTNO
:
9355 case DT_MIPS_HIPAGENO
:
9356 case DT_MIPS_DELTA_CLASS_NO
:
9357 case DT_MIPS_DELTA_INSTANCE_NO
:
9358 case DT_MIPS_DELTA_RELOC_NO
:
9359 case DT_MIPS_DELTA_SYM_NO
:
9360 case DT_MIPS_DELTA_CLASSSYM_NO
:
9361 case DT_MIPS_COMPACT_SIZE
:
9362 print_vma (entry
->d_un
.d_val
, DEC
);
9366 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9372 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9374 switch (entry
->d_tag
)
9376 case DT_HP_DLD_FLAGS
:
9385 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9386 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9387 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9388 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9389 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9390 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9391 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9392 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9393 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9394 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9395 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9396 { DT_HP_GST
, "HP_GST" },
9397 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9398 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9399 { DT_HP_NODELETE
, "HP_NODELETE" },
9400 { DT_HP_GROUP
, "HP_GROUP" },
9401 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9403 bfd_boolean first
= TRUE
;
9405 bfd_vma val
= entry
->d_un
.d_val
;
9407 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9408 if (val
& flags
[cnt
].bit
)
9412 fputs (flags
[cnt
].str
, stdout
);
9414 val
^= flags
[cnt
].bit
;
9417 if (val
!= 0 || first
)
9421 print_vma (val
, HEX
);
9427 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9435 /* VMS vs Unix time offset and factor. */
9437 #define VMS_EPOCH_OFFSET 35067168000000000LL
9438 #define VMS_GRANULARITY_FACTOR 10000000
9440 /* Display a VMS time in a human readable format. */
9443 print_vms_time (bfd_int64_t vmstime
)
9448 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9449 tm
= gmtime (&unxtime
);
9450 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9451 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9452 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9457 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9459 switch (entry
->d_tag
)
9461 case DT_IA_64_PLT_RESERVE
:
9462 /* First 3 slots reserved. */
9463 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9465 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9468 case DT_IA_64_VMS_LINKTIME
:
9470 print_vms_time (entry
->d_un
.d_val
);
9474 case DT_IA_64_VMS_LNKFLAGS
:
9475 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9476 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9477 printf (" CALL_DEBUG");
9478 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9479 printf (" NOP0BUFS");
9480 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9481 printf (" P0IMAGE");
9482 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9483 printf (" MKTHREADS");
9484 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9485 printf (" UPCALLS");
9486 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9488 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9489 printf (" INITIALIZE");
9490 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9492 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9493 printf (" EXE_INIT");
9494 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9495 printf (" TBK_IN_IMG");
9496 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9497 printf (" DBG_IN_IMG");
9498 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9499 printf (" TBK_IN_DSF");
9500 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9501 printf (" DBG_IN_DSF");
9502 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9503 printf (" SIGNATURES");
9504 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9505 printf (" REL_SEG_OFF");
9509 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9516 get_32bit_dynamic_section (Filedata
* filedata
)
9518 Elf32_External_Dyn
* edyn
;
9519 Elf32_External_Dyn
* ext
;
9520 Elf_Internal_Dyn
* entry
;
9522 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9523 dynamic_size
, _("dynamic section"));
9527 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9528 might not have the luxury of section headers. Look for the DT_NULL
9529 terminator to determine the number of entries. */
9530 for (ext
= edyn
, dynamic_nent
= 0;
9531 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9535 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9539 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9541 if (dynamic_section
== NULL
)
9543 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9544 (unsigned long) dynamic_nent
);
9549 for (ext
= edyn
, entry
= dynamic_section
;
9550 entry
< dynamic_section
+ dynamic_nent
;
9553 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9554 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9563 get_64bit_dynamic_section (Filedata
* filedata
)
9565 Elf64_External_Dyn
* edyn
;
9566 Elf64_External_Dyn
* ext
;
9567 Elf_Internal_Dyn
* entry
;
9569 /* Read in the data. */
9570 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9571 dynamic_size
, _("dynamic section"));
9575 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9576 might not have the luxury of section headers. Look for the DT_NULL
9577 terminator to determine the number of entries. */
9578 for (ext
= edyn
, dynamic_nent
= 0;
9579 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9580 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9584 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9588 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9590 if (dynamic_section
== NULL
)
9592 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9593 (unsigned long) dynamic_nent
);
9598 /* Convert from external to internal formats. */
9599 for (ext
= edyn
, entry
= dynamic_section
;
9600 entry
< dynamic_section
+ dynamic_nent
;
9603 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9604 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9613 print_dynamic_flags (bfd_vma flags
)
9615 bfd_boolean first
= TRUE
;
9621 flag
= flags
& - flags
;
9631 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9632 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9633 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9634 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9635 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9636 default: fputs (_("unknown"), stdout
); break;
9642 /* Parse and display the contents of the dynamic section. */
9645 process_dynamic_section (Filedata
* filedata
)
9647 Elf_Internal_Dyn
* entry
;
9649 if (dynamic_size
== 0)
9652 printf (_("\nThere is no dynamic section in this file.\n"));
9659 if (! get_32bit_dynamic_section (filedata
))
9664 if (! get_64bit_dynamic_section (filedata
))
9668 /* Find the appropriate symbol table. */
9669 if (dynamic_symbols
== NULL
)
9671 for (entry
= dynamic_section
;
9672 entry
< dynamic_section
+ dynamic_nent
;
9675 Elf_Internal_Shdr section
;
9677 if (entry
->d_tag
!= DT_SYMTAB
)
9680 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9682 /* Since we do not know how big the symbol table is,
9683 we default to reading in the entire file (!) and
9684 processing that. This is overkill, I know, but it
9686 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9687 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9689 /* See PR 21379 for a reproducer. */
9690 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9694 if (archive_file_offset
!= 0)
9695 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9697 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9700 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9702 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9703 section
.sh_name
= filedata
->string_table_length
;
9705 if (dynamic_symbols
!= NULL
)
9707 error (_("Multiple dynamic symbol table sections found\n"));
9708 free (dynamic_symbols
);
9710 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9711 if (num_dynamic_syms
< 1)
9713 error (_("Unable to determine the number of symbols to load\n"));
9719 /* Similarly find a string table. */
9720 if (dynamic_strings
== NULL
)
9722 for (entry
= dynamic_section
;
9723 entry
< dynamic_section
+ dynamic_nent
;
9726 unsigned long offset
;
9729 if (entry
->d_tag
!= DT_STRTAB
)
9732 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9734 /* Since we do not know how big the string table is,
9735 we default to reading in the entire file (!) and
9736 processing that. This is overkill, I know, but it
9739 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9741 if (archive_file_offset
!= 0)
9742 str_tab_len
= archive_file_size
- offset
;
9744 str_tab_len
= filedata
->file_size
- offset
;
9746 if (str_tab_len
< 1)
9749 (_("Unable to determine the length of the dynamic string table\n"));
9753 if (dynamic_strings
!= NULL
)
9755 error (_("Multiple dynamic string tables found\n"));
9756 free (dynamic_strings
);
9759 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9761 _("dynamic string table"));
9762 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9766 /* And find the syminfo section if available. */
9767 if (dynamic_syminfo
== NULL
)
9769 unsigned long syminsz
= 0;
9771 for (entry
= dynamic_section
;
9772 entry
< dynamic_section
+ dynamic_nent
;
9775 if (entry
->d_tag
== DT_SYMINENT
)
9777 /* Note: these braces are necessary to avoid a syntax
9778 error from the SunOS4 C compiler. */
9779 /* PR binutils/17531: A corrupt file can trigger this test.
9780 So do not use an assert, instead generate an error message. */
9781 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9782 error (_("Bad value (%d) for SYMINENT entry\n"),
9783 (int) entry
->d_un
.d_val
);
9785 else if (entry
->d_tag
== DT_SYMINSZ
)
9786 syminsz
= entry
->d_un
.d_val
;
9787 else if (entry
->d_tag
== DT_SYMINFO
)
9788 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9792 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9794 Elf_External_Syminfo
* extsyminfo
;
9795 Elf_External_Syminfo
* extsym
;
9796 Elf_Internal_Syminfo
* syminfo
;
9798 /* There is a syminfo section. Read the data. */
9799 extsyminfo
= (Elf_External_Syminfo
*)
9800 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9801 _("symbol information"));
9805 if (dynamic_syminfo
!= NULL
)
9807 error (_("Multiple dynamic symbol information sections found\n"));
9808 free (dynamic_syminfo
);
9810 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9811 if (dynamic_syminfo
== NULL
)
9813 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9814 (unsigned long) syminsz
);
9818 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9819 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9820 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9821 ++syminfo
, ++extsym
)
9823 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9824 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9831 if (do_dynamic
&& dynamic_addr
)
9832 printf (ngettext ("\nDynamic section at offset 0x%lx "
9833 "contains %lu entry:\n",
9834 "\nDynamic section at offset 0x%lx "
9835 "contains %lu entries:\n",
9837 dynamic_addr
, (unsigned long) dynamic_nent
);
9839 printf (_(" Tag Type Name/Value\n"));
9841 for (entry
= dynamic_section
;
9842 entry
< dynamic_section
+ dynamic_nent
;
9850 print_vma (entry
->d_tag
, FULL_HEX
);
9851 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9852 printf (" (%s)%*s", dtype
,
9853 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9856 switch (entry
->d_tag
)
9860 print_dynamic_flags (entry
->d_un
.d_val
);
9870 switch (entry
->d_tag
)
9873 printf (_("Auxiliary library"));
9877 printf (_("Filter library"));
9881 printf (_("Configuration file"));
9885 printf (_("Dependency audit library"));
9889 printf (_("Audit library"));
9893 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9894 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9898 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9907 printf (_("Flags:"));
9909 if (entry
->d_un
.d_val
== 0)
9910 printf (_(" None\n"));
9913 unsigned long int val
= entry
->d_un
.d_val
;
9915 if (val
& DTF_1_PARINIT
)
9917 printf (" PARINIT");
9918 val
^= DTF_1_PARINIT
;
9920 if (val
& DTF_1_CONFEXP
)
9922 printf (" CONFEXP");
9923 val
^= DTF_1_CONFEXP
;
9926 printf (" %lx", val
);
9935 printf (_("Flags:"));
9937 if (entry
->d_un
.d_val
== 0)
9938 printf (_(" None\n"));
9941 unsigned long int val
= entry
->d_un
.d_val
;
9943 if (val
& DF_P1_LAZYLOAD
)
9945 printf (" LAZYLOAD");
9946 val
^= DF_P1_LAZYLOAD
;
9948 if (val
& DF_P1_GROUPPERM
)
9950 printf (" GROUPPERM");
9951 val
^= DF_P1_GROUPPERM
;
9954 printf (" %lx", val
);
9963 printf (_("Flags:"));
9964 if (entry
->d_un
.d_val
== 0)
9965 printf (_(" None\n"));
9968 unsigned long int val
= entry
->d_un
.d_val
;
9975 if (val
& DF_1_GLOBAL
)
9980 if (val
& DF_1_GROUP
)
9985 if (val
& DF_1_NODELETE
)
9987 printf (" NODELETE");
9988 val
^= DF_1_NODELETE
;
9990 if (val
& DF_1_LOADFLTR
)
9992 printf (" LOADFLTR");
9993 val
^= DF_1_LOADFLTR
;
9995 if (val
& DF_1_INITFIRST
)
9997 printf (" INITFIRST");
9998 val
^= DF_1_INITFIRST
;
10000 if (val
& DF_1_NOOPEN
)
10002 printf (" NOOPEN");
10003 val
^= DF_1_NOOPEN
;
10005 if (val
& DF_1_ORIGIN
)
10007 printf (" ORIGIN");
10008 val
^= DF_1_ORIGIN
;
10010 if (val
& DF_1_DIRECT
)
10012 printf (" DIRECT");
10013 val
^= DF_1_DIRECT
;
10015 if (val
& DF_1_TRANS
)
10020 if (val
& DF_1_INTERPOSE
)
10022 printf (" INTERPOSE");
10023 val
^= DF_1_INTERPOSE
;
10025 if (val
& DF_1_NODEFLIB
)
10027 printf (" NODEFLIB");
10028 val
^= DF_1_NODEFLIB
;
10030 if (val
& DF_1_NODUMP
)
10032 printf (" NODUMP");
10033 val
^= DF_1_NODUMP
;
10035 if (val
& DF_1_CONFALT
)
10037 printf (" CONFALT");
10038 val
^= DF_1_CONFALT
;
10040 if (val
& DF_1_ENDFILTEE
)
10042 printf (" ENDFILTEE");
10043 val
^= DF_1_ENDFILTEE
;
10045 if (val
& DF_1_DISPRELDNE
)
10047 printf (" DISPRELDNE");
10048 val
^= DF_1_DISPRELDNE
;
10050 if (val
& DF_1_DISPRELPND
)
10052 printf (" DISPRELPND");
10053 val
^= DF_1_DISPRELPND
;
10055 if (val
& DF_1_NODIRECT
)
10057 printf (" NODIRECT");
10058 val
^= DF_1_NODIRECT
;
10060 if (val
& DF_1_IGNMULDEF
)
10062 printf (" IGNMULDEF");
10063 val
^= DF_1_IGNMULDEF
;
10065 if (val
& DF_1_NOKSYMS
)
10067 printf (" NOKSYMS");
10068 val
^= DF_1_NOKSYMS
;
10070 if (val
& DF_1_NOHDR
)
10075 if (val
& DF_1_EDITED
)
10077 printf (" EDITED");
10078 val
^= DF_1_EDITED
;
10080 if (val
& DF_1_NORELOC
)
10082 printf (" NORELOC");
10083 val
^= DF_1_NORELOC
;
10085 if (val
& DF_1_SYMINTPOSE
)
10087 printf (" SYMINTPOSE");
10088 val
^= DF_1_SYMINTPOSE
;
10090 if (val
& DF_1_GLOBAUDIT
)
10092 printf (" GLOBAUDIT");
10093 val
^= DF_1_GLOBAUDIT
;
10095 if (val
& DF_1_SINGLETON
)
10097 printf (" SINGLETON");
10098 val
^= DF_1_SINGLETON
;
10100 if (val
& DF_1_STUB
)
10105 if (val
& DF_1_PIE
)
10110 if (val
& DF_1_KMOD
)
10115 if (val
& DF_1_WEAKFILTER
)
10117 printf (" WEAKFILTER");
10118 val
^= DF_1_WEAKFILTER
;
10120 if (val
& DF_1_NOCOMMON
)
10122 printf (" NOCOMMON");
10123 val
^= DF_1_NOCOMMON
;
10126 printf (" %lx", val
);
10133 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10135 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10155 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10161 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10162 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10168 switch (entry
->d_tag
)
10171 printf (_("Shared library: [%s]"), name
);
10173 if (streq (name
, program_interpreter
))
10174 printf (_(" program interpreter"));
10178 printf (_("Library soname: [%s]"), name
);
10182 printf (_("Library rpath: [%s]"), name
);
10186 printf (_("Library runpath: [%s]"), name
);
10190 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10195 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10208 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10209 /* Fall through. */
10213 case DT_INIT_ARRAYSZ
:
10214 case DT_FINI_ARRAYSZ
:
10215 case DT_GNU_CONFLICTSZ
:
10216 case DT_GNU_LIBLISTSZ
:
10219 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10220 printf (_(" (bytes)\n"));
10225 case DT_VERNEEDNUM
:
10230 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10239 case DT_INIT_ARRAY
:
10240 case DT_FINI_ARRAY
:
10243 if (entry
->d_tag
== DT_USED
10244 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10246 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10250 printf (_("Not needed object: [%s]\n"), name
);
10255 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10261 /* The value of this entry is ignored. */
10266 case DT_GNU_PRELINKED
:
10270 time_t atime
= entry
->d_un
.d_val
;
10272 tmp
= gmtime (&atime
);
10273 /* PR 17533 file: 041-1244816-0.004. */
10275 printf (_("<corrupt time val: %lx"),
10276 (unsigned long) atime
);
10278 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10279 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10280 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10286 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10289 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10295 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10296 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10301 switch (filedata
->file_header
.e_machine
)
10304 case EM_MIPS_RS3_LE
:
10305 dynamic_section_mips_val (entry
);
10308 dynamic_section_parisc_val (entry
);
10311 dynamic_section_ia64_val (entry
);
10314 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10326 get_ver_flags (unsigned int flags
)
10328 static char buff
[128];
10335 if (flags
& VER_FLG_BASE
)
10336 strcat (buff
, "BASE");
10338 if (flags
& VER_FLG_WEAK
)
10340 if (flags
& VER_FLG_BASE
)
10341 strcat (buff
, " | ");
10343 strcat (buff
, "WEAK");
10346 if (flags
& VER_FLG_INFO
)
10348 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10349 strcat (buff
, " | ");
10351 strcat (buff
, "INFO");
10354 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10356 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10357 strcat (buff
, " | ");
10359 strcat (buff
, _("<unknown>"));
10365 /* Display the contents of the version sections. */
10368 process_version_sections (Filedata
* filedata
)
10370 Elf_Internal_Shdr
* section
;
10372 bfd_boolean found
= FALSE
;
10377 for (i
= 0, section
= filedata
->section_headers
;
10378 i
< filedata
->file_header
.e_shnum
;
10381 switch (section
->sh_type
)
10383 case SHT_GNU_verdef
:
10385 Elf_External_Verdef
* edefs
;
10392 printf (ngettext ("\nVersion definition section '%s' "
10393 "contains %u entry:\n",
10394 "\nVersion definition section '%s' "
10395 "contains %u entries:\n",
10397 printable_section_name (filedata
, section
),
10400 printf (_(" Addr: 0x"));
10401 printf_vma (section
->sh_addr
);
10402 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10403 (unsigned long) section
->sh_offset
, section
->sh_link
,
10404 printable_section_name_from_index (filedata
, section
->sh_link
));
10406 edefs
= (Elf_External_Verdef
*)
10407 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10408 _("version definition section"));
10411 endbuf
= (char *) edefs
+ section
->sh_size
;
10413 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10416 Elf_External_Verdef
* edef
;
10417 Elf_Internal_Verdef ent
;
10418 Elf_External_Verdaux
* eaux
;
10419 Elf_Internal_Verdaux aux
;
10420 unsigned long isum
;
10423 vstart
= ((char *) edefs
) + idx
;
10424 if (vstart
+ sizeof (*edef
) > endbuf
)
10427 edef
= (Elf_External_Verdef
*) vstart
;
10429 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10430 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10431 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10432 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10433 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10434 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10435 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10437 printf (_(" %#06lx: Rev: %d Flags: %s"),
10438 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10440 printf (_(" Index: %d Cnt: %d "),
10441 ent
.vd_ndx
, ent
.vd_cnt
);
10443 /* Check for overflow. */
10444 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10447 vstart
+= ent
.vd_aux
;
10449 if (vstart
+ sizeof (*eaux
) > endbuf
)
10451 eaux
= (Elf_External_Verdaux
*) vstart
;
10453 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10454 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10456 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10457 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10459 printf (_("Name index: %ld\n"), aux
.vda_name
);
10461 isum
= idx
+ ent
.vd_aux
;
10463 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10465 if (aux
.vda_next
< sizeof (*eaux
)
10466 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10468 warn (_("Invalid vda_next field of %lx\n"),
10473 /* Check for overflow. */
10474 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10477 isum
+= aux
.vda_next
;
10478 vstart
+= aux
.vda_next
;
10480 if (vstart
+ sizeof (*eaux
) > endbuf
)
10482 eaux
= (Elf_External_Verdaux
*) vstart
;
10484 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10485 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10487 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10488 printf (_(" %#06lx: Parent %d: %s\n"),
10489 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10491 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10492 isum
, j
, aux
.vda_name
);
10495 if (j
< ent
.vd_cnt
)
10496 printf (_(" Version def aux past end of section\n"));
10499 file: id:000001,src:000172+005151,op:splice,rep:2. */
10500 if (ent
.vd_next
< sizeof (*edef
)
10501 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10503 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10504 cnt
= section
->sh_info
;
10507 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10510 idx
+= ent
.vd_next
;
10513 if (cnt
< section
->sh_info
)
10514 printf (_(" Version definition past end of section\n"));
10520 case SHT_GNU_verneed
:
10522 Elf_External_Verneed
* eneed
;
10529 printf (ngettext ("\nVersion needs section '%s' "
10530 "contains %u entry:\n",
10531 "\nVersion needs section '%s' "
10532 "contains %u entries:\n",
10534 printable_section_name (filedata
, section
), section
->sh_info
);
10536 printf (_(" Addr: 0x"));
10537 printf_vma (section
->sh_addr
);
10538 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10539 (unsigned long) section
->sh_offset
, section
->sh_link
,
10540 printable_section_name_from_index (filedata
, section
->sh_link
));
10542 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10543 section
->sh_offset
, 1,
10545 _("Version Needs section"));
10548 endbuf
= (char *) eneed
+ section
->sh_size
;
10550 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10552 Elf_External_Verneed
* entry
;
10553 Elf_Internal_Verneed ent
;
10554 unsigned long isum
;
10558 vstart
= ((char *) eneed
) + idx
;
10559 if (vstart
+ sizeof (*entry
) > endbuf
)
10562 entry
= (Elf_External_Verneed
*) vstart
;
10564 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10565 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10566 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10567 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10568 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10570 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10572 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10573 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10575 printf (_(" File: %lx"), ent
.vn_file
);
10577 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10579 /* Check for overflow. */
10580 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10582 vstart
+= ent
.vn_aux
;
10584 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10586 Elf_External_Vernaux
* eaux
;
10587 Elf_Internal_Vernaux aux
;
10589 if (vstart
+ sizeof (*eaux
) > endbuf
)
10591 eaux
= (Elf_External_Vernaux
*) vstart
;
10593 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10594 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10595 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10596 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10597 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10599 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10600 printf (_(" %#06lx: Name: %s"),
10601 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10603 printf (_(" %#06lx: Name index: %lx"),
10604 isum
, aux
.vna_name
);
10606 printf (_(" Flags: %s Version: %d\n"),
10607 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10609 if (aux
.vna_next
< sizeof (*eaux
)
10610 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10612 warn (_("Invalid vna_next field of %lx\n"),
10617 /* Check for overflow. */
10618 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10620 isum
+= aux
.vna_next
;
10621 vstart
+= aux
.vna_next
;
10624 if (j
< ent
.vn_cnt
)
10625 warn (_("Missing Version Needs auxillary information\n"));
10627 if (ent
.vn_next
< sizeof (*entry
)
10628 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10630 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10631 cnt
= section
->sh_info
;
10634 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10636 idx
+= ent
.vn_next
;
10639 if (cnt
< section
->sh_info
)
10640 warn (_("Missing Version Needs information\n"));
10646 case SHT_GNU_versym
:
10648 Elf_Internal_Shdr
* link_section
;
10651 unsigned char * edata
;
10652 unsigned short * data
;
10654 Elf_Internal_Sym
* symbols
;
10655 Elf_Internal_Shdr
* string_sec
;
10656 unsigned long num_syms
;
10659 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10662 link_section
= filedata
->section_headers
+ section
->sh_link
;
10663 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10665 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10670 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10671 if (symbols
== NULL
)
10674 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10676 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10677 string_sec
->sh_size
,
10678 _("version string table"));
10685 printf (ngettext ("\nVersion symbols section '%s' "
10686 "contains %lu entry:\n",
10687 "\nVersion symbols section '%s' "
10688 "contains %lu entries:\n",
10690 printable_section_name (filedata
, section
), (unsigned long) total
);
10692 printf (_(" Addr: "));
10693 printf_vma (section
->sh_addr
);
10694 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10695 (unsigned long) section
->sh_offset
, section
->sh_link
,
10696 printable_section_name (filedata
, link_section
));
10698 off
= offset_from_vma (filedata
,
10699 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10700 total
* sizeof (short));
10701 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10703 _("version symbol data"));
10711 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10713 for (cnt
= total
; cnt
--;)
10714 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10719 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10723 char *invalid
= _("*invalid*");
10725 printf (" %03x:", cnt
);
10727 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10728 switch (data
[cnt
+ j
])
10731 fputs (_(" 0 (*local*) "), stdout
);
10735 fputs (_(" 1 (*global*) "), stdout
);
10739 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10740 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10742 /* If this index value is greater than the size of the symbols
10743 array, break to avoid an out-of-bounds read. */
10744 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10746 warn (_("invalid index into symbol array\n"));
10751 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10753 Elf_Internal_Verneed ivn
;
10754 unsigned long offset
;
10756 offset
= offset_from_vma
10757 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10758 sizeof (Elf_External_Verneed
));
10762 Elf_Internal_Vernaux ivna
;
10763 Elf_External_Verneed evn
;
10764 Elf_External_Vernaux evna
;
10765 unsigned long a_off
;
10767 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10768 _("version need")) == NULL
)
10771 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10772 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10774 a_off
= offset
+ ivn
.vn_aux
;
10778 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10779 1, _("version need aux (2)")) == NULL
)
10782 ivna
.vna_other
= 0;
10786 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10787 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10790 a_off
+= ivna
.vna_next
;
10792 while (ivna
.vna_other
!= data
[cnt
+ j
]
10793 && ivna
.vna_next
!= 0);
10795 if (ivna
.vna_other
== data
[cnt
+ j
])
10797 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10799 if (ivna
.vna_name
>= string_sec
->sh_size
)
10802 name
= strtab
+ ivna
.vna_name
;
10806 offset
+= ivn
.vn_next
;
10808 while (ivn
.vn_next
);
10811 if (data
[cnt
+ j
] != 0x8001
10812 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10814 Elf_Internal_Verdef ivd
;
10815 Elf_External_Verdef evd
;
10816 unsigned long offset
;
10818 offset
= offset_from_vma
10819 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10824 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10825 _("version def")) == NULL
)
10828 /* PR 17531: file: 046-1082287-0.004. */
10829 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10834 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10835 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10838 offset
+= ivd
.vd_next
;
10840 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10841 && ivd
.vd_next
!= 0);
10843 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10845 Elf_External_Verdaux evda
;
10846 Elf_Internal_Verdaux ivda
;
10848 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10850 if (get_data (&evda
, filedata
,
10851 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10853 _("version def aux")) == NULL
)
10856 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10858 if (ivda
.vda_name
>= string_sec
->sh_size
)
10860 else if (name
!= NULL
&& name
!= invalid
)
10861 name
= _("*both*");
10863 name
= strtab
+ ivda
.vda_name
;
10867 nn
+= printf ("(%s%-*s",
10869 12 - (int) strlen (name
),
10873 printf ("%*c", 18 - nn
, ' ');
10891 printf (_("\nNo version information found in this file.\n"));
10896 static const char *
10897 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10899 static char buff
[32];
10903 case STB_LOCAL
: return "LOCAL";
10904 case STB_GLOBAL
: return "GLOBAL";
10905 case STB_WEAK
: return "WEAK";
10907 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10908 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10910 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10912 if (binding
== STB_GNU_UNIQUE
10913 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10914 /* GNU is still using the default value 0. */
10915 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10917 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10920 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10925 static const char *
10926 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10928 static char buff
[32];
10932 case STT_NOTYPE
: return "NOTYPE";
10933 case STT_OBJECT
: return "OBJECT";
10934 case STT_FUNC
: return "FUNC";
10935 case STT_SECTION
: return "SECTION";
10936 case STT_FILE
: return "FILE";
10937 case STT_COMMON
: return "COMMON";
10938 case STT_TLS
: return "TLS";
10939 case STT_RELC
: return "RELC";
10940 case STT_SRELC
: return "SRELC";
10942 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10944 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10945 return "THUMB_FUNC";
10947 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10950 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10951 return "PARISC_MILLI";
10953 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10955 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10957 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10959 if (type
== STT_HP_OPAQUE
)
10960 return "HP_OPAQUE";
10961 if (type
== STT_HP_STUB
)
10965 if (type
== STT_GNU_IFUNC
10966 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10967 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10968 /* GNU is still using the default value 0. */
10969 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10972 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10975 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10980 static const char *
10981 get_symbol_visibility (unsigned int visibility
)
10983 switch (visibility
)
10985 case STV_DEFAULT
: return "DEFAULT";
10986 case STV_INTERNAL
: return "INTERNAL";
10987 case STV_HIDDEN
: return "HIDDEN";
10988 case STV_PROTECTED
: return "PROTECTED";
10990 error (_("Unrecognized visibility value: %u"), visibility
);
10991 return _("<unknown>");
10995 static const char *
10996 get_solaris_symbol_visibility (unsigned int visibility
)
10998 switch (visibility
)
11000 case 4: return "EXPORTED";
11001 case 5: return "SINGLETON";
11002 case 6: return "ELIMINATE";
11003 default: return get_symbol_visibility (visibility
);
11007 static const char *
11008 get_mips_symbol_other (unsigned int other
)
11012 case STO_OPTIONAL
: return "OPTIONAL";
11013 case STO_MIPS_PLT
: return "MIPS PLT";
11014 case STO_MIPS_PIC
: return "MIPS PIC";
11015 case STO_MICROMIPS
: return "MICROMIPS";
11016 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11017 case STO_MIPS16
: return "MIPS16";
11018 default: return NULL
;
11022 static const char *
11023 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11025 if (is_ia64_vms (filedata
))
11027 static char res
[32];
11031 /* Function types is for images and .STB files only. */
11032 switch (filedata
->file_header
.e_type
)
11036 switch (VMS_ST_FUNC_TYPE (other
))
11038 case VMS_SFT_CODE_ADDR
:
11039 strcat (res
, " CA");
11041 case VMS_SFT_SYMV_IDX
:
11042 strcat (res
, " VEC");
11045 strcat (res
, " FD");
11047 case VMS_SFT_RESERVE
:
11048 strcat (res
, " RSV");
11051 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11052 VMS_ST_FUNC_TYPE (other
));
11053 strcat (res
, " <unknown>");
11060 switch (VMS_ST_LINKAGE (other
))
11062 case VMS_STL_IGNORE
:
11063 strcat (res
, " IGN");
11065 case VMS_STL_RESERVE
:
11066 strcat (res
, " RSV");
11069 strcat (res
, " STD");
11072 strcat (res
, " LNK");
11075 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11076 VMS_ST_LINKAGE (other
));
11077 strcat (res
, " <unknown>");
11089 static const char *
11090 get_ppc64_symbol_other (unsigned int other
)
11092 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11095 other
>>= STO_PPC64_LOCAL_BIT
;
11098 static char buf
[32];
11100 other
= ppc64_decode_local_entry (other
);
11101 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11107 static const char *
11108 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11110 const char * result
= NULL
;
11111 static char buff
[32];
11116 switch (filedata
->file_header
.e_machine
)
11119 result
= get_mips_symbol_other (other
);
11122 result
= get_ia64_symbol_other (filedata
, other
);
11125 result
= get_ppc64_symbol_other (other
);
11135 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11139 static const char *
11140 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11142 static char buff
[32];
11146 case SHN_UNDEF
: return "UND";
11147 case SHN_ABS
: return "ABS";
11148 case SHN_COMMON
: return "COM";
11150 if (type
== SHN_IA_64_ANSI_COMMON
11151 && filedata
->file_header
.e_machine
== EM_IA_64
11152 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11154 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11155 || filedata
->file_header
.e_machine
== EM_L1OM
11156 || filedata
->file_header
.e_machine
== EM_K1OM
)
11157 && type
== SHN_X86_64_LCOMMON
)
11158 return "LARGE_COM";
11159 else if ((type
== SHN_MIPS_SCOMMON
11160 && filedata
->file_header
.e_machine
== EM_MIPS
)
11161 || (type
== SHN_TIC6X_SCOMMON
11162 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11164 else if (type
== SHN_MIPS_SUNDEFINED
11165 && filedata
->file_header
.e_machine
== EM_MIPS
)
11167 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11168 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11169 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11170 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11171 else if (type
>= SHN_LORESERVE
)
11172 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11173 else if (type
>= filedata
->file_header
.e_shnum
)
11174 sprintf (buff
, _("bad section index[%3d]"), type
);
11176 sprintf (buff
, "%3d", type
);
11184 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11186 unsigned char * e_data
;
11189 /* If the size_t type is smaller than the bfd_size_type, eg because
11190 you are building a 32-bit tool on a 64-bit host, then make sure
11191 that when (number) is cast to (size_t) no information is lost. */
11192 if (sizeof (size_t) < sizeof (bfd_size_type
)
11193 && (bfd_size_type
) ((size_t) number
) != number
)
11195 error (_("Size truncation prevents reading %s elements of size %u\n"),
11196 bfd_vmatoa ("u", number
), ent_size
);
11200 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11201 attempting to allocate memory when the read is bound to fail. */
11202 if (ent_size
* number
> filedata
->file_size
)
11204 error (_("Invalid number of dynamic entries: %s\n"),
11205 bfd_vmatoa ("u", number
));
11209 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11210 if (e_data
== NULL
)
11212 error (_("Out of memory reading %s dynamic entries\n"),
11213 bfd_vmatoa ("u", number
));
11217 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11219 error (_("Unable to read in %s bytes of dynamic data\n"),
11220 bfd_vmatoa ("u", number
* ent_size
));
11225 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11226 if (i_data
== NULL
)
11228 error (_("Out of memory allocating space for %s dynamic entries\n"),
11229 bfd_vmatoa ("u", number
));
11235 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11243 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11245 Elf_Internal_Sym
* psym
;
11248 n
= print_vma (si
, DEC_5
);
11250 fputs (&" "[n
], stdout
);
11251 printf (" %3lu: ", hn
);
11253 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11255 printf (_("<No info available for dynamic symbol number %lu>\n"),
11256 (unsigned long) si
);
11260 psym
= dynamic_symbols
+ si
;
11261 print_vma (psym
->st_value
, LONG_HEX
);
11263 print_vma (psym
->st_size
, DEC_5
);
11265 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11266 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11268 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11269 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11272 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11274 printf (" %-7s", get_symbol_visibility (vis
));
11275 /* Check to see if any other bits in the st_other field are set.
11276 Note - displaying this information disrupts the layout of the
11277 table being generated, but for the moment this case is very
11279 if (psym
->st_other
^ vis
)
11280 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11283 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11284 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11285 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11287 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11291 static const char *
11292 get_symbol_version_string (Filedata
* filedata
,
11293 bfd_boolean is_dynsym
,
11294 const char * strtab
,
11295 unsigned long int strtab_size
,
11297 Elf_Internal_Sym
* psym
,
11298 enum versioned_symbol_info
* sym_info
,
11299 unsigned short * vna_other
)
11301 unsigned char data
[2];
11302 unsigned short vers_data
;
11303 unsigned long offset
;
11304 unsigned short max_vd_ndx
;
11307 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11310 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11311 sizeof data
+ si
* sizeof (vers_data
));
11313 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11314 sizeof (data
), 1, _("version data")) == NULL
)
11317 vers_data
= byte_get (data
, 2);
11319 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11324 /* Usually we'd only see verdef for defined symbols, and verneed for
11325 undefined symbols. However, symbols defined by the linker in
11326 .dynbss for variables copied from a shared library in order to
11327 avoid text relocations are defined yet have verneed. We could
11328 use a heuristic to detect the special case, for example, check
11329 for verneed first on symbols defined in SHT_NOBITS sections, but
11330 it is simpler and more reliable to just look for both verdef and
11331 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11333 if (psym
->st_shndx
!= SHN_UNDEF
11334 && vers_data
!= 0x8001
11335 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11337 Elf_Internal_Verdef ivd
;
11338 Elf_Internal_Verdaux ivda
;
11339 Elf_External_Verdaux evda
;
11342 off
= offset_from_vma (filedata
,
11343 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11344 sizeof (Elf_External_Verdef
));
11348 Elf_External_Verdef evd
;
11350 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11351 _("version def")) == NULL
)
11360 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11361 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11362 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11363 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11366 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11367 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11369 off
+= ivd
.vd_next
;
11371 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11373 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11375 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11378 off
-= ivd
.vd_next
;
11381 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11382 _("version def aux")) != NULL
)
11384 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11386 if (psym
->st_name
!= ivda
.vda_name
)
11388 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11389 ? symbol_hidden
: symbol_public
);
11390 return (ivda
.vda_name
< strtab_size
11391 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11397 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11399 Elf_External_Verneed evn
;
11400 Elf_Internal_Verneed ivn
;
11401 Elf_Internal_Vernaux ivna
;
11403 offset
= offset_from_vma (filedata
,
11404 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11408 unsigned long vna_off
;
11410 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11411 _("version need")) == NULL
)
11414 ivna
.vna_other
= 0;
11419 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11420 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11422 vna_off
= offset
+ ivn
.vn_aux
;
11426 Elf_External_Vernaux evna
;
11428 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11429 _("version need aux (3)")) == NULL
)
11432 ivna
.vna_other
= 0;
11437 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11438 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11439 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11442 vna_off
+= ivna
.vna_next
;
11444 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11446 if (ivna
.vna_other
== vers_data
)
11449 offset
+= ivn
.vn_next
;
11451 while (ivn
.vn_next
!= 0);
11453 if (ivna
.vna_other
== vers_data
)
11455 *sym_info
= symbol_undefined
;
11456 *vna_other
= ivna
.vna_other
;
11457 return (ivna
.vna_name
< strtab_size
11458 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11460 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11461 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11462 return _("<corrupt>");
11467 /* Dump the symbol table. */
11469 process_symbol_table (Filedata
* filedata
)
11471 Elf_Internal_Shdr
* section
;
11472 bfd_size_type nbuckets
= 0;
11473 bfd_size_type nchains
= 0;
11474 bfd_vma
* buckets
= NULL
;
11475 bfd_vma
* chains
= NULL
;
11476 bfd_vma ngnubuckets
= 0;
11477 bfd_vma
* gnubuckets
= NULL
;
11478 bfd_vma
* gnuchains
= NULL
;
11479 bfd_vma gnusymidx
= 0;
11480 bfd_size_type ngnuchains
= 0;
11482 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11485 if (dynamic_info
[DT_HASH
]
11487 || (do_using_dynamic
11489 && dynamic_strings
!= NULL
)))
11491 unsigned char nb
[8];
11492 unsigned char nc
[8];
11493 unsigned int hash_ent_size
= 4;
11495 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11496 || filedata
->file_header
.e_machine
== EM_S390
11497 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11498 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11501 if (fseek (filedata
->handle
,
11502 (archive_file_offset
11503 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11504 sizeof nb
+ sizeof nc
)),
11507 error (_("Unable to seek to start of dynamic information\n"));
11511 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11513 error (_("Failed to read in number of buckets\n"));
11517 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11519 error (_("Failed to read in number of chains\n"));
11523 nbuckets
= byte_get (nb
, hash_ent_size
);
11524 nchains
= byte_get (nc
, hash_ent_size
);
11526 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11527 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11530 if (buckets
== NULL
|| chains
== NULL
)
11532 if (do_using_dynamic
)
11543 if (dynamic_info_DT_GNU_HASH
11545 || (do_using_dynamic
11547 && dynamic_strings
!= NULL
)))
11549 unsigned char nb
[16];
11550 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11551 bfd_vma buckets_vma
;
11553 if (fseek (filedata
->handle
,
11554 (archive_file_offset
11555 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11559 error (_("Unable to seek to start of dynamic information\n"));
11563 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11565 error (_("Failed to read in number of buckets\n"));
11569 ngnubuckets
= byte_get (nb
, 4);
11570 gnusymidx
= byte_get (nb
+ 4, 4);
11571 bitmaskwords
= byte_get (nb
+ 8, 4);
11572 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11574 buckets_vma
+= bitmaskwords
* 4;
11576 buckets_vma
+= bitmaskwords
* 8;
11578 if (fseek (filedata
->handle
,
11579 (archive_file_offset
11580 + offset_from_vma (filedata
, buckets_vma
, 4)),
11583 error (_("Unable to seek to start of dynamic information\n"));
11587 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11589 if (gnubuckets
== NULL
)
11592 for (i
= 0; i
< ngnubuckets
; i
++)
11593 if (gnubuckets
[i
] != 0)
11595 if (gnubuckets
[i
] < gnusymidx
)
11598 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11599 maxchain
= gnubuckets
[i
];
11602 if (maxchain
== 0xffffffff)
11605 maxchain
-= gnusymidx
;
11607 if (fseek (filedata
->handle
,
11608 (archive_file_offset
11609 + offset_from_vma (filedata
, buckets_vma
11610 + 4 * (ngnubuckets
+ maxchain
), 4)),
11613 error (_("Unable to seek to start of dynamic information\n"));
11619 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11621 error (_("Failed to determine last chain length\n"));
11625 if (maxchain
+ 1 == 0)
11630 while ((byte_get (nb
, 4) & 1) == 0);
11632 if (fseek (filedata
->handle
,
11633 (archive_file_offset
11634 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11637 error (_("Unable to seek to start of dynamic information\n"));
11641 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11642 ngnuchains
= maxchain
;
11645 if (gnuchains
== NULL
)
11650 if (do_using_dynamic
)
11655 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11657 && do_using_dynamic
11658 && dynamic_strings
!= NULL
11659 && dynamic_symbols
!= NULL
)
11663 if (dynamic_info
[DT_HASH
])
11668 printf (_("\nSymbol table for image:\n"));
11670 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11672 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11674 visited
= xcmalloc (nchains
, 1);
11675 memset (visited
, 0, nchains
);
11676 for (hn
= 0; hn
< nbuckets
; hn
++)
11678 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11680 print_dynamic_symbol (filedata
, si
, hn
);
11681 if (si
>= nchains
|| visited
[si
])
11683 error (_("histogram chain is corrupt\n"));
11692 if (dynamic_info_DT_GNU_HASH
)
11694 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11696 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11698 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11700 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11701 if (gnubuckets
[hn
] != 0)
11703 bfd_vma si
= gnubuckets
[hn
];
11704 bfd_vma off
= si
- gnusymidx
;
11708 print_dynamic_symbol (filedata
, si
, hn
);
11711 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11715 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11716 && filedata
->section_headers
!= NULL
)
11720 for (i
= 0, section
= filedata
->section_headers
;
11721 i
< filedata
->file_header
.e_shnum
;
11725 char * strtab
= NULL
;
11726 unsigned long int strtab_size
= 0;
11727 Elf_Internal_Sym
* symtab
;
11728 Elf_Internal_Sym
* psym
;
11729 unsigned long num_syms
;
11731 if ((section
->sh_type
!= SHT_SYMTAB
11732 && section
->sh_type
!= SHT_DYNSYM
)
11734 && section
->sh_type
== SHT_SYMTAB
))
11737 if (section
->sh_entsize
== 0)
11739 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11740 printable_section_name (filedata
, section
));
11744 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11745 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11746 "\nSymbol table '%s' contains %lu entries:\n",
11748 printable_section_name (filedata
, section
),
11752 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11754 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11756 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11757 if (symtab
== NULL
)
11760 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11762 strtab
= filedata
->string_table
;
11763 strtab_size
= filedata
->string_table_length
;
11765 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11767 Elf_Internal_Shdr
* string_sec
;
11769 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11771 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11772 1, string_sec
->sh_size
,
11773 _("string table"));
11774 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11777 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11779 const char *version_string
;
11780 enum versioned_symbol_info sym_info
;
11781 unsigned short vna_other
;
11783 printf ("%6d: ", si
);
11784 print_vma (psym
->st_value
, LONG_HEX
);
11786 print_vma (psym
->st_size
, DEC_5
);
11787 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11788 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11789 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11790 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11793 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11795 printf (" %-7s", get_symbol_visibility (vis
));
11796 /* Check to see if any other bits in the st_other field are set.
11797 Note - displaying this information disrupts the layout of the
11798 table being generated, but for the moment this case is very rare. */
11799 if (psym
->st_other
^ vis
)
11800 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11802 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11803 print_symbol (25, psym
->st_name
< strtab_size
11804 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11807 = get_symbol_version_string (filedata
,
11808 section
->sh_type
== SHT_DYNSYM
,
11809 strtab
, strtab_size
, si
,
11810 psym
, &sym_info
, &vna_other
);
11811 if (version_string
)
11813 if (sym_info
== symbol_undefined
)
11814 printf ("@%s (%d)", version_string
, vna_other
);
11816 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11822 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11823 && si
>= section
->sh_info
11824 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11825 && filedata
->file_header
.e_machine
!= EM_MIPS
11826 /* Solaris binaries have been found to violate this requirement as
11827 well. Not sure if this is a bug or an ABI requirement. */
11828 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11829 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11830 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11834 if (strtab
!= filedata
->string_table
)
11840 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11842 if (do_histogram
&& buckets
!= NULL
)
11844 unsigned long * lengths
;
11845 unsigned long * counts
;
11848 unsigned long maxlength
= 0;
11849 unsigned long nzero_counts
= 0;
11850 unsigned long nsyms
= 0;
11853 printf (ngettext ("\nHistogram for bucket list length "
11854 "(total of %lu bucket):\n",
11855 "\nHistogram for bucket list length "
11856 "(total of %lu buckets):\n",
11857 (unsigned long) nbuckets
),
11858 (unsigned long) nbuckets
);
11860 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11861 if (lengths
== NULL
)
11863 error (_("Out of memory allocating space for histogram buckets\n"));
11866 visited
= xcmalloc (nchains
, 1);
11867 memset (visited
, 0, nchains
);
11869 printf (_(" Length Number %% of total Coverage\n"));
11870 for (hn
= 0; hn
< nbuckets
; ++hn
)
11872 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11875 if (maxlength
< ++lengths
[hn
])
11877 if (si
>= nchains
|| visited
[si
])
11879 error (_("histogram chain is corrupt\n"));
11887 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11888 if (counts
== NULL
)
11891 error (_("Out of memory allocating space for histogram counts\n"));
11895 for (hn
= 0; hn
< nbuckets
; ++hn
)
11896 ++counts
[lengths
[hn
]];
11901 printf (" 0 %-10lu (%5.1f%%)\n",
11902 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11903 for (i
= 1; i
<= maxlength
; ++i
)
11905 nzero_counts
+= counts
[i
] * i
;
11906 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11907 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11908 (nzero_counts
* 100.0) / nsyms
);
11916 if (buckets
!= NULL
)
11922 if (do_histogram
&& gnubuckets
!= NULL
)
11924 unsigned long * lengths
;
11925 unsigned long * counts
;
11927 unsigned long maxlength
= 0;
11928 unsigned long nzero_counts
= 0;
11929 unsigned long nsyms
= 0;
11931 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11932 "(total of %lu bucket):\n",
11933 "\nHistogram for `.gnu.hash' bucket list length "
11934 "(total of %lu buckets):\n",
11935 (unsigned long) ngnubuckets
),
11936 (unsigned long) ngnubuckets
);
11938 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11939 if (lengths
== NULL
)
11941 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11945 printf (_(" Length Number %% of total Coverage\n"));
11947 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11948 if (gnubuckets
[hn
] != 0)
11950 bfd_vma off
, length
= 1;
11952 for (off
= gnubuckets
[hn
] - gnusymidx
;
11953 /* PR 17531 file: 010-77222-0.004. */
11954 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11957 lengths
[hn
] = length
;
11958 if (length
> maxlength
)
11959 maxlength
= length
;
11963 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11964 if (counts
== NULL
)
11967 error (_("Out of memory allocating space for gnu histogram counts\n"));
11971 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11972 ++counts
[lengths
[hn
]];
11974 if (ngnubuckets
> 0)
11977 printf (" 0 %-10lu (%5.1f%%)\n",
11978 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11979 for (j
= 1; j
<= maxlength
; ++j
)
11981 nzero_counts
+= counts
[j
] * j
;
11982 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11983 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11984 (nzero_counts
* 100.0) / nsyms
);
11998 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12002 if (dynamic_syminfo
== NULL
12004 /* No syminfo, this is ok. */
12007 /* There better should be a dynamic symbol section. */
12008 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12012 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12013 "contains %d entry:\n",
12014 "\nDynamic info segment at offset 0x%lx "
12015 "contains %d entries:\n",
12016 dynamic_syminfo_nent
),
12017 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12019 printf (_(" Num: Name BoundTo Flags\n"));
12020 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12022 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12024 printf ("%4d: ", i
);
12025 if (i
>= num_dynamic_syms
)
12026 printf (_("<corrupt index>"));
12027 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12028 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12030 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12033 switch (dynamic_syminfo
[i
].si_boundto
)
12035 case SYMINFO_BT_SELF
:
12036 fputs ("SELF ", stdout
);
12038 case SYMINFO_BT_PARENT
:
12039 fputs ("PARENT ", stdout
);
12042 if (dynamic_syminfo
[i
].si_boundto
> 0
12043 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12044 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12046 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12050 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12054 if (flags
& SYMINFO_FLG_DIRECT
)
12055 printf (" DIRECT");
12056 if (flags
& SYMINFO_FLG_PASSTHRU
)
12057 printf (" PASSTHRU");
12058 if (flags
& SYMINFO_FLG_COPY
)
12060 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12061 printf (" LAZYLOAD");
12069 #define IN_RANGE(START,END,ADDR,OFF) \
12070 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12072 /* Check to see if the given reloc needs to be handled in a target specific
12073 manner. If so then process the reloc and return TRUE otherwise return
12076 If called with reloc == NULL, then this is a signal that reloc processing
12077 for the current section has finished, and any saved state should be
12081 target_specific_reloc_handling (Filedata
* filedata
,
12082 Elf_Internal_Rela
* reloc
,
12083 unsigned char * start
,
12084 unsigned char * end
,
12085 Elf_Internal_Sym
* symtab
,
12086 unsigned long num_syms
)
12088 unsigned int reloc_type
= 0;
12089 unsigned long sym_index
= 0;
12093 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12094 sym_index
= get_reloc_symindex (reloc
->r_info
);
12097 switch (filedata
->file_header
.e_machine
)
12100 case EM_MSP430_OLD
:
12102 static Elf_Internal_Sym
* saved_sym
= NULL
;
12110 switch (reloc_type
)
12112 case 10: /* R_MSP430_SYM_DIFF */
12113 if (uses_msp430x_relocs (filedata
))
12115 /* Fall through. */
12116 case 21: /* R_MSP430X_SYM_DIFF */
12118 if (sym_index
>= num_syms
)
12119 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12122 saved_sym
= symtab
+ sym_index
;
12125 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12126 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12127 goto handle_sym_diff
;
12129 case 5: /* R_MSP430_16_BYTE */
12130 case 9: /* R_MSP430_8 */
12131 if (uses_msp430x_relocs (filedata
))
12133 goto handle_sym_diff
;
12135 case 2: /* R_MSP430_ABS16 */
12136 case 15: /* R_MSP430X_ABS16 */
12137 if (! uses_msp430x_relocs (filedata
))
12139 goto handle_sym_diff
;
12142 if (saved_sym
!= NULL
)
12144 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12147 if (sym_index
>= num_syms
)
12148 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12152 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12153 - saved_sym
->st_value
);
12155 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12156 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12159 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12160 (long) reloc
->r_offset
);
12169 if (saved_sym
!= NULL
)
12170 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12177 case EM_CYGNUS_MN10300
:
12179 static Elf_Internal_Sym
* saved_sym
= NULL
;
12187 switch (reloc_type
)
12189 case 34: /* R_MN10300_ALIGN */
12191 case 33: /* R_MN10300_SYM_DIFF */
12192 if (sym_index
>= num_syms
)
12193 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12196 saved_sym
= symtab
+ sym_index
;
12199 case 1: /* R_MN10300_32 */
12200 case 2: /* R_MN10300_16 */
12201 if (saved_sym
!= NULL
)
12203 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12206 if (sym_index
>= num_syms
)
12207 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12211 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12212 - saved_sym
->st_value
);
12214 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12215 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12217 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12218 (long) reloc
->r_offset
);
12226 if (saved_sym
!= NULL
)
12227 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12235 static bfd_vma saved_sym1
= 0;
12236 static bfd_vma saved_sym2
= 0;
12237 static bfd_vma value
;
12241 saved_sym1
= saved_sym2
= 0;
12245 switch (reloc_type
)
12247 case 0x80: /* R_RL78_SYM. */
12248 saved_sym1
= saved_sym2
;
12249 if (sym_index
>= num_syms
)
12250 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12254 saved_sym2
= symtab
[sym_index
].st_value
;
12255 saved_sym2
+= reloc
->r_addend
;
12259 case 0x83: /* R_RL78_OPsub. */
12260 value
= saved_sym1
- saved_sym2
;
12261 saved_sym2
= saved_sym1
= 0;
12265 case 0x41: /* R_RL78_ABS32. */
12266 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12267 byte_put (start
+ reloc
->r_offset
, value
, 4);
12269 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12270 (long) reloc
->r_offset
);
12274 case 0x43: /* R_RL78_ABS16. */
12275 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12276 byte_put (start
+ reloc
->r_offset
, value
, 2);
12278 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12279 (long) reloc
->r_offset
);
12293 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12294 DWARF debug sections. This is a target specific test. Note - we do not
12295 go through the whole including-target-headers-multiple-times route, (as
12296 we have already done with <elf/h8.h>) because this would become very
12297 messy and even then this function would have to contain target specific
12298 information (the names of the relocs instead of their numeric values).
12299 FIXME: This is not the correct way to solve this problem. The proper way
12300 is to have target specific reloc sizing and typing functions created by
12301 the reloc-macros.h header, in the same way that it already creates the
12302 reloc naming functions. */
12305 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12307 /* Please keep this table alpha-sorted for ease of visual lookup. */
12308 switch (filedata
->file_header
.e_machine
)
12312 return reloc_type
== 1; /* R_386_32. */
12314 return reloc_type
== 1; /* R_68K_32. */
12316 return reloc_type
== 1; /* R_860_32. */
12318 return reloc_type
== 2; /* R_960_32. */
12320 return (reloc_type
== 258
12321 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12322 case EM_ADAPTEVA_EPIPHANY
:
12323 return reloc_type
== 3;
12325 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12327 return reloc_type
== 1; /* R_ARC_32. */
12328 case EM_ARC_COMPACT
:
12329 case EM_ARC_COMPACT2
:
12330 return reloc_type
== 4; /* R_ARC_32. */
12332 return reloc_type
== 2; /* R_ARM_ABS32 */
12335 return reloc_type
== 1;
12337 return reloc_type
== 0x12; /* R_byte4_data. */
12339 return reloc_type
== 3; /* R_CRIS_32. */
12341 return reloc_type
== 3; /* R_CR16_NUM32. */
12343 return reloc_type
== 15; /* R_CRX_NUM32. */
12345 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12346 case EM_CYGNUS_FRV
:
12347 return reloc_type
== 1;
12348 case EM_CYGNUS_D10V
:
12350 return reloc_type
== 6; /* R_D10V_32. */
12351 case EM_CYGNUS_D30V
:
12353 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12355 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12356 case EM_CYGNUS_FR30
:
12358 return reloc_type
== 3; /* R_FR30_32. */
12360 return reloc_type
== 1; /* R_FT32_32. */
12364 return reloc_type
== 1; /* R_H8_DIR32. */
12366 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12367 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12368 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12369 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12372 return reloc_type
== 2; /* R_IP2K_32. */
12374 return reloc_type
== 2; /* R_IQ2000_32. */
12375 case EM_LATTICEMICO32
:
12376 return reloc_type
== 3; /* R_LM32_32. */
12379 return reloc_type
== 3; /* R_M32C_32. */
12381 return reloc_type
== 34; /* R_M32R_32_RELA. */
12384 return reloc_type
== 6; /* R_M68HC11_32. */
12386 return reloc_type
== 6; /* R_S12Z_EXT32. */
12388 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12389 case EM_CYGNUS_MEP
:
12390 return reloc_type
== 4; /* R_MEP_32. */
12392 return reloc_type
== 2; /* R_METAG_ADDR32. */
12393 case EM_MICROBLAZE
:
12394 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12396 return reloc_type
== 2; /* R_MIPS_32. */
12398 return reloc_type
== 4; /* R_MMIX_32. */
12399 case EM_CYGNUS_MN10200
:
12401 return reloc_type
== 1; /* R_MN10200_32. */
12402 case EM_CYGNUS_MN10300
:
12404 return reloc_type
== 1; /* R_MN10300_32. */
12406 return reloc_type
== 1; /* R_MOXIE_32. */
12407 case EM_MSP430_OLD
:
12409 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12411 return reloc_type
== 2; /* R_MT_32. */
12413 return reloc_type
== 20; /* R_NDS32_RELA. */
12414 case EM_ALTERA_NIOS2
:
12415 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12417 return reloc_type
== 1; /* R_NIOS_32. */
12419 return reloc_type
== 1; /* R_OR1K_32. */
12421 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12422 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12423 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12426 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12428 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12430 return reloc_type
== 1; /* R_PPC_ADDR32. */
12432 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12434 return reloc_type
== 1; /* R_RISCV_32. */
12436 return reloc_type
== 1; /* R_RL78_DIR32. */
12438 return reloc_type
== 1; /* R_RX_DIR32. */
12440 return reloc_type
== 1; /* R_I370_ADDR31. */
12443 return reloc_type
== 4; /* R_S390_32. */
12445 return reloc_type
== 8; /* R_SCORE_ABS32. */
12447 return reloc_type
== 1; /* R_SH_DIR32. */
12448 case EM_SPARC32PLUS
:
12451 return reloc_type
== 3 /* R_SPARC_32. */
12452 || reloc_type
== 23; /* R_SPARC_UA32. */
12454 return reloc_type
== 6; /* R_SPU_ADDR32 */
12456 return reloc_type
== 1; /* R_C6000_ABS32. */
12458 return reloc_type
== 2; /* R_TILEGX_32. */
12460 return reloc_type
== 1; /* R_TILEPRO_32. */
12461 case EM_CYGNUS_V850
:
12463 return reloc_type
== 6; /* R_V850_ABS32. */
12465 return reloc_type
== 0x33; /* R_V810_WORD. */
12467 return reloc_type
== 1; /* R_VAX_32. */
12469 return reloc_type
== 3; /* R_VISIUM_32. */
12470 case EM_WEBASSEMBLY
:
12471 return reloc_type
== 1; /* R_WASM32_32. */
12475 return reloc_type
== 10; /* R_X86_64_32. */
12478 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12480 return reloc_type
== 4; /* R_XGATE_32. */
12482 return reloc_type
== 1; /* R_XSTROMY16_32. */
12483 case EM_XTENSA_OLD
:
12485 return reloc_type
== 1; /* R_XTENSA_32. */
12488 static unsigned int prev_warn
= 0;
12490 /* Avoid repeating the same warning multiple times. */
12491 if (prev_warn
!= filedata
->file_header
.e_machine
)
12492 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12493 filedata
->file_header
.e_machine
);
12494 prev_warn
= filedata
->file_header
.e_machine
;
12500 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12501 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12504 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12506 switch (filedata
->file_header
.e_machine
)
12507 /* Please keep this table alpha-sorted for ease of visual lookup. */
12511 return reloc_type
== 2; /* R_386_PC32. */
12513 return reloc_type
== 4; /* R_68K_PC32. */
12515 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12516 case EM_ADAPTEVA_EPIPHANY
:
12517 return reloc_type
== 6;
12519 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12520 case EM_ARC_COMPACT
:
12521 case EM_ARC_COMPACT2
:
12522 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12524 return reloc_type
== 3; /* R_ARM_REL32 */
12527 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12528 case EM_MICROBLAZE
:
12529 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12531 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12533 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12535 return reloc_type
== 26; /* R_PPC_REL32. */
12537 return reloc_type
== 26; /* R_PPC64_REL32. */
12540 return reloc_type
== 5; /* R_390_PC32. */
12542 return reloc_type
== 2; /* R_SH_REL32. */
12543 case EM_SPARC32PLUS
:
12546 return reloc_type
== 6; /* R_SPARC_DISP32. */
12548 return reloc_type
== 13; /* R_SPU_REL32. */
12550 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12552 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12554 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12558 return reloc_type
== 2; /* R_X86_64_PC32. */
12559 case EM_XTENSA_OLD
:
12561 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12563 /* Do not abort or issue an error message here. Not all targets use
12564 pc-relative 32-bit relocs in their DWARF debug information and we
12565 have already tested for target coverage in is_32bit_abs_reloc. A
12566 more helpful warning message will be generated by apply_relocations
12567 anyway, so just return. */
12572 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12573 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12576 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12578 switch (filedata
->file_header
.e_machine
)
12581 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12583 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12585 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12586 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12588 return reloc_type
== 80; /* R_PARISC_DIR64. */
12590 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12592 return reloc_type
== 2; /* R_RISCV_64. */
12593 case EM_SPARC32PLUS
:
12596 return reloc_type
== 32 /* R_SPARC_64. */
12597 || reloc_type
== 54; /* R_SPARC_UA64. */
12601 return reloc_type
== 1; /* R_X86_64_64. */
12604 return reloc_type
== 22; /* R_S390_64. */
12606 return reloc_type
== 1; /* R_TILEGX_64. */
12608 return reloc_type
== 18; /* R_MIPS_64. */
12614 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12615 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12618 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12620 switch (filedata
->file_header
.e_machine
)
12623 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12625 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12627 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12628 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12630 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12632 return reloc_type
== 44; /* R_PPC64_REL64. */
12633 case EM_SPARC32PLUS
:
12636 return reloc_type
== 46; /* R_SPARC_DISP64. */
12640 return reloc_type
== 24; /* R_X86_64_PC64. */
12643 return reloc_type
== 23; /* R_S390_PC64. */
12645 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12651 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12652 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12655 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12657 switch (filedata
->file_header
.e_machine
)
12659 case EM_CYGNUS_MN10200
:
12661 return reloc_type
== 4; /* R_MN10200_24. */
12663 return reloc_type
== 5; /* R_FT32_20. */
12669 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12670 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12673 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12675 /* Please keep this table alpha-sorted for ease of visual lookup. */
12676 switch (filedata
->file_header
.e_machine
)
12679 case EM_ARC_COMPACT
:
12680 case EM_ARC_COMPACT2
:
12681 return reloc_type
== 2; /* R_ARC_16. */
12682 case EM_ADAPTEVA_EPIPHANY
:
12683 return reloc_type
== 5;
12686 return reloc_type
== 4; /* R_AVR_16. */
12687 case EM_CYGNUS_D10V
:
12689 return reloc_type
== 3; /* R_D10V_16. */
12691 return reloc_type
== 2; /* R_FT32_16. */
12695 return reloc_type
== R_H8_DIR16
;
12698 return reloc_type
== 1; /* R_IP2K_16. */
12701 return reloc_type
== 1; /* R_M32C_16 */
12702 case EM_CYGNUS_MN10200
:
12704 return reloc_type
== 2; /* R_MN10200_16. */
12705 case EM_CYGNUS_MN10300
:
12707 return reloc_type
== 2; /* R_MN10300_16. */
12709 if (uses_msp430x_relocs (filedata
))
12710 return reloc_type
== 2; /* R_MSP430_ABS16. */
12711 /* Fall through. */
12712 case EM_MSP430_OLD
:
12713 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12715 return reloc_type
== 19; /* R_NDS32_RELA. */
12716 case EM_ALTERA_NIOS2
:
12717 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12719 return reloc_type
== 9; /* R_NIOS_16. */
12721 return reloc_type
== 2; /* R_OR1K_16. */
12723 return reloc_type
== 55; /* R_RISCV_SET16. */
12725 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12727 return reloc_type
== 2; /* R_C6000_ABS16. */
12729 return reloc_type
== 2; /* R_VISIUM_16. */
12732 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12734 return reloc_type
== 3; /* R_XGATE_16. */
12740 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12741 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12744 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12746 switch (filedata
->file_header
.e_machine
)
12749 return reloc_type
== 54; /* R_RISCV_SET8. */
12755 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12756 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12759 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12761 switch (filedata
->file_header
.e_machine
)
12764 return reloc_type
== 53; /* R_RISCV_SET6. */
12770 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12771 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12774 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12776 /* Please keep this table alpha-sorted for ease of visual lookup. */
12777 switch (filedata
->file_header
.e_machine
)
12780 return reloc_type
== 35; /* R_RISCV_ADD32. */
12786 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12787 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12790 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12792 /* Please keep this table alpha-sorted for ease of visual lookup. */
12793 switch (filedata
->file_header
.e_machine
)
12796 return reloc_type
== 39; /* R_RISCV_SUB32. */
12802 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12803 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12806 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12808 /* Please keep this table alpha-sorted for ease of visual lookup. */
12809 switch (filedata
->file_header
.e_machine
)
12812 return reloc_type
== 36; /* R_RISCV_ADD64. */
12818 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12819 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12822 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12824 /* Please keep this table alpha-sorted for ease of visual lookup. */
12825 switch (filedata
->file_header
.e_machine
)
12828 return reloc_type
== 40; /* R_RISCV_SUB64. */
12834 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12835 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12838 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12840 /* Please keep this table alpha-sorted for ease of visual lookup. */
12841 switch (filedata
->file_header
.e_machine
)
12844 return reloc_type
== 34; /* R_RISCV_ADD16. */
12850 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12851 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12854 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12856 /* Please keep this table alpha-sorted for ease of visual lookup. */
12857 switch (filedata
->file_header
.e_machine
)
12860 return reloc_type
== 38; /* R_RISCV_SUB16. */
12866 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12867 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12870 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12872 /* Please keep this table alpha-sorted for ease of visual lookup. */
12873 switch (filedata
->file_header
.e_machine
)
12876 return reloc_type
== 33; /* R_RISCV_ADD8. */
12882 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12883 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12886 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12888 /* Please keep this table alpha-sorted for ease of visual lookup. */
12889 switch (filedata
->file_header
.e_machine
)
12892 return reloc_type
== 37; /* R_RISCV_SUB8. */
12898 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12899 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12902 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12904 switch (filedata
->file_header
.e_machine
)
12907 return reloc_type
== 52; /* R_RISCV_SUB6. */
12913 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12914 relocation entries (possibly formerly used for SHT_GROUP sections). */
12917 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12919 switch (filedata
->file_header
.e_machine
)
12921 case EM_386
: /* R_386_NONE. */
12922 case EM_68K
: /* R_68K_NONE. */
12923 case EM_ADAPTEVA_EPIPHANY
:
12924 case EM_ALPHA
: /* R_ALPHA_NONE. */
12925 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12926 case EM_ARC
: /* R_ARC_NONE. */
12927 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12928 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12929 case EM_ARM
: /* R_ARM_NONE. */
12930 case EM_C166
: /* R_XC16X_NONE. */
12931 case EM_CRIS
: /* R_CRIS_NONE. */
12932 case EM_FT32
: /* R_FT32_NONE. */
12933 case EM_IA_64
: /* R_IA64_NONE. */
12934 case EM_K1OM
: /* R_X86_64_NONE. */
12935 case EM_L1OM
: /* R_X86_64_NONE. */
12936 case EM_M32R
: /* R_M32R_NONE. */
12937 case EM_MIPS
: /* R_MIPS_NONE. */
12938 case EM_MN10300
: /* R_MN10300_NONE. */
12939 case EM_MOXIE
: /* R_MOXIE_NONE. */
12940 case EM_NIOS32
: /* R_NIOS_NONE. */
12941 case EM_OR1K
: /* R_OR1K_NONE. */
12942 case EM_PARISC
: /* R_PARISC_NONE. */
12943 case EM_PPC64
: /* R_PPC64_NONE. */
12944 case EM_PPC
: /* R_PPC_NONE. */
12945 case EM_RISCV
: /* R_RISCV_NONE. */
12946 case EM_S390
: /* R_390_NONE. */
12948 case EM_SH
: /* R_SH_NONE. */
12949 case EM_SPARC32PLUS
:
12950 case EM_SPARC
: /* R_SPARC_NONE. */
12952 case EM_TILEGX
: /* R_TILEGX_NONE. */
12953 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12954 case EM_TI_C6000
:/* R_C6000_NONE. */
12955 case EM_X86_64
: /* R_X86_64_NONE. */
12957 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12958 return reloc_type
== 0;
12961 return reloc_type
== 0 || reloc_type
== 256;
12964 return (reloc_type
== 0 /* R_AVR_NONE. */
12965 || reloc_type
== 30 /* R_AVR_DIFF8. */
12966 || reloc_type
== 31 /* R_AVR_DIFF16. */
12967 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12969 return reloc_type
== 3; /* R_METAG_NONE. */
12971 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12972 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12973 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12974 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12975 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12977 return (reloc_type
== 0 /* R_PRU_NONE. */
12978 || reloc_type
== 65 /* R_PRU_DIFF8. */
12979 || reloc_type
== 66 /* R_PRU_DIFF16. */
12980 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12981 case EM_XTENSA_OLD
:
12983 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12984 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12985 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12986 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12991 /* Returns TRUE if there is a relocation against
12992 section NAME at OFFSET bytes. */
12995 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12997 Elf_Internal_Rela
* relocs
;
12998 Elf_Internal_Rela
* rp
;
13000 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13003 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13005 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13006 if (rp
->r_offset
== offset
)
13012 /* Apply relocations to a section.
13013 Returns TRUE upon success, FALSE otherwise.
13014 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13015 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13016 will be set to the number of relocs loaded.
13018 Note: So far support has been added only for those relocations
13019 which can be found in debug sections. FIXME: Add support for
13020 more relocations ? */
13023 apply_relocations (Filedata
* filedata
,
13024 const Elf_Internal_Shdr
* section
,
13025 unsigned char * start
,
13026 bfd_size_type size
,
13027 void ** relocs_return
,
13028 unsigned long * num_relocs_return
)
13030 Elf_Internal_Shdr
* relsec
;
13031 unsigned char * end
= start
+ size
;
13032 bfd_boolean res
= TRUE
;
13034 if (relocs_return
!= NULL
)
13036 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13037 * num_relocs_return
= 0;
13040 if (filedata
->file_header
.e_type
!= ET_REL
)
13041 /* No relocs to apply. */
13044 /* Find the reloc section associated with the section. */
13045 for (relsec
= filedata
->section_headers
;
13046 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13049 bfd_boolean is_rela
;
13050 unsigned long num_relocs
;
13051 Elf_Internal_Rela
* relocs
;
13052 Elf_Internal_Rela
* rp
;
13053 Elf_Internal_Shdr
* symsec
;
13054 Elf_Internal_Sym
* symtab
;
13055 unsigned long num_syms
;
13056 Elf_Internal_Sym
* sym
;
13058 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13059 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13060 || filedata
->section_headers
+ relsec
->sh_info
!= section
13061 || relsec
->sh_size
== 0
13062 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13065 is_rela
= relsec
->sh_type
== SHT_RELA
;
13069 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13070 relsec
->sh_size
, & relocs
, & num_relocs
))
13075 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13076 relsec
->sh_size
, & relocs
, & num_relocs
))
13080 /* SH uses RELA but uses in place value instead of the addend field. */
13081 if (filedata
->file_header
.e_machine
== EM_SH
)
13084 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13085 if (symsec
->sh_type
!= SHT_SYMTAB
13086 && symsec
->sh_type
!= SHT_DYNSYM
)
13088 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13090 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13093 unsigned int reloc_type
;
13094 unsigned int reloc_size
;
13095 bfd_boolean reloc_inplace
= FALSE
;
13096 bfd_boolean reloc_subtract
= FALSE
;
13097 unsigned char * rloc
;
13098 unsigned long sym_index
;
13100 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13102 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13104 else if (is_none_reloc (filedata
, reloc_type
))
13106 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13107 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13109 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13110 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13112 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13114 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13116 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13117 || is_6bit_abs_reloc (filedata
, reloc_type
))
13119 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13121 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13124 reloc_inplace
= TRUE
;
13126 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13128 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13131 reloc_inplace
= TRUE
;
13133 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13135 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13138 reloc_inplace
= TRUE
;
13140 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13142 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13145 reloc_inplace
= TRUE
;
13147 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13151 reloc_inplace
= TRUE
;
13155 static unsigned int prev_reloc
= 0;
13157 if (reloc_type
!= prev_reloc
)
13158 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13159 reloc_type
, printable_section_name (filedata
, section
));
13160 prev_reloc
= reloc_type
;
13165 rloc
= start
+ rp
->r_offset
;
13166 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
13168 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13169 (unsigned long) rp
->r_offset
,
13170 printable_section_name (filedata
, section
));
13175 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13176 if (sym_index
>= num_syms
)
13178 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13179 sym_index
, printable_section_name (filedata
, section
));
13183 sym
= symtab
+ sym_index
;
13185 /* If the reloc has a symbol associated with it,
13186 make sure that it is of an appropriate type.
13188 Relocations against symbols without type can happen.
13189 Gcc -feliminate-dwarf2-dups may generate symbols
13190 without type for debug info.
13192 Icc generates relocations against function symbols
13193 instead of local labels.
13195 Relocations against object symbols can happen, eg when
13196 referencing a global array. For an example of this see
13197 the _clz.o binary in libgcc.a. */
13199 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13200 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13202 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13203 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13204 printable_section_name (filedata
, relsec
),
13205 (long int)(rp
- relocs
));
13212 addend
+= rp
->r_addend
;
13213 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13214 partial_inplace. */
13216 || (filedata
->file_header
.e_machine
== EM_XTENSA
13217 && reloc_type
== 1)
13218 || ((filedata
->file_header
.e_machine
== EM_PJ
13219 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13220 && reloc_type
== 1)
13221 || ((filedata
->file_header
.e_machine
== EM_D30V
13222 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13223 && reloc_type
== 12)
13226 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13227 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13229 addend
+= byte_get (rloc
, reloc_size
);
13232 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13233 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13235 /* On HPPA, all pc-relative relocations are biased by 8. */
13236 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13238 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13241 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13242 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13244 if (reloc_subtract
)
13245 addend
-= sym
->st_value
;
13247 addend
+= sym
->st_value
;
13248 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13249 byte_put (rloc
, addend
, reloc_size
);
13251 else if (reloc_subtract
)
13252 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13254 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13258 /* Let the target specific reloc processing code know that
13259 we have finished with these relocs. */
13260 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13264 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13265 * num_relocs_return
= num_relocs
;
13276 #ifdef SUPPORT_DISASSEMBLY
13278 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13280 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13282 /* FIXME: XXX -- to be done --- XXX */
13288 /* Reads in the contents of SECTION from FILE, returning a pointer
13289 to a malloc'ed buffer or NULL if something went wrong. */
13292 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13294 bfd_size_type num_bytes
= section
->sh_size
;
13296 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13298 printf (_("Section '%s' has no data to dump.\n"),
13299 printable_section_name (filedata
, section
));
13303 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13304 _("section contents"));
13307 /* Uncompresses a section that was compressed using zlib, in place. */
13310 uncompress_section_contents (unsigned char ** buffer
,
13311 dwarf_size_type uncompressed_size
,
13312 dwarf_size_type
* size
)
13314 dwarf_size_type compressed_size
= *size
;
13315 unsigned char * compressed_buffer
= *buffer
;
13316 unsigned char * uncompressed_buffer
;
13320 /* It is possible the section consists of several compressed
13321 buffers concatenated together, so we uncompress in a loop. */
13322 /* PR 18313: The state field in the z_stream structure is supposed
13323 to be invisible to the user (ie us), but some compilers will
13324 still complain about it being used without initialisation. So
13325 we first zero the entire z_stream structure and then set the fields
13327 memset (& strm
, 0, sizeof strm
);
13328 strm
.avail_in
= compressed_size
;
13329 strm
.next_in
= (Bytef
*) compressed_buffer
;
13330 strm
.avail_out
= uncompressed_size
;
13331 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13333 rc
= inflateInit (& strm
);
13334 while (strm
.avail_in
> 0)
13338 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13339 + (uncompressed_size
- strm
.avail_out
));
13340 rc
= inflate (&strm
, Z_FINISH
);
13341 if (rc
!= Z_STREAM_END
)
13343 rc
= inflateReset (& strm
);
13345 rc
= inflateEnd (& strm
);
13347 || strm
.avail_out
!= 0)
13350 *buffer
= uncompressed_buffer
;
13351 *size
= uncompressed_size
;
13355 free (uncompressed_buffer
);
13356 /* Indicate decompression failure. */
13362 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13364 Elf_Internal_Shdr
* relsec
;
13365 bfd_size_type num_bytes
;
13366 unsigned char * data
;
13367 unsigned char * end
;
13368 unsigned char * real_start
;
13369 unsigned char * start
;
13370 bfd_boolean some_strings_shown
;
13372 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13374 /* PR 21820: Do not fail if the section was empty. */
13375 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13377 num_bytes
= section
->sh_size
;
13379 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13381 if (decompress_dumps
)
13383 dwarf_size_type new_size
= num_bytes
;
13384 dwarf_size_type uncompressed_size
= 0;
13386 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13388 Elf_Internal_Chdr chdr
;
13389 unsigned int compression_header_size
13390 = get_compression_header (& chdr
, (unsigned char *) start
,
13393 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13395 warn (_("section '%s' has unsupported compress type: %d\n"),
13396 printable_section_name (filedata
, section
), chdr
.ch_type
);
13399 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13401 warn (_("compressed section '%s' is corrupted\n"),
13402 printable_section_name (filedata
, section
));
13405 uncompressed_size
= chdr
.ch_size
;
13406 start
+= compression_header_size
;
13407 new_size
-= compression_header_size
;
13409 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13411 /* Read the zlib header. In this case, it should be "ZLIB"
13412 followed by the uncompressed section size, 8 bytes in
13413 big-endian order. */
13414 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13415 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13416 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13417 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13418 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13419 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13420 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13421 uncompressed_size
+= start
[11];
13426 if (uncompressed_size
)
13428 if (uncompress_section_contents (& start
,
13429 uncompressed_size
, & new_size
))
13430 num_bytes
= new_size
;
13433 error (_("Unable to decompress section %s\n"),
13434 printable_section_name (filedata
, section
));
13439 start
= real_start
;
13442 /* If the section being dumped has relocations against it the user might
13443 be expecting these relocations to have been applied. Check for this
13444 case and issue a warning message in order to avoid confusion.
13445 FIXME: Maybe we ought to have an option that dumps a section with
13446 relocs applied ? */
13447 for (relsec
= filedata
->section_headers
;
13448 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13451 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13452 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13453 || filedata
->section_headers
+ relsec
->sh_info
!= section
13454 || relsec
->sh_size
== 0
13455 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13458 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13463 end
= start
+ num_bytes
;
13464 some_strings_shown
= FALSE
;
13468 while (!ISPRINT (* data
))
13469 if (++ data
>= end
)
13474 size_t maxlen
= end
- data
;
13477 /* PR 11128: Use two separate invocations in order to work
13478 around bugs in the Solaris 8 implementation of printf. */
13479 printf (" [%6tx] ", data
- start
);
13481 printf (" [%6Ix] ", (size_t) (data
- start
));
13485 print_symbol ((int) maxlen
, (const char *) data
);
13487 data
+= strnlen ((const char *) data
, maxlen
);
13491 printf (_("<corrupt>\n"));
13494 some_strings_shown
= TRUE
;
13498 if (! some_strings_shown
)
13499 printf (_(" No strings found in this section."));
13508 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13509 Filedata
* filedata
,
13510 bfd_boolean relocate
)
13512 Elf_Internal_Shdr
* relsec
;
13513 bfd_size_type bytes
;
13514 bfd_size_type section_size
;
13516 unsigned char * data
;
13517 unsigned char * real_start
;
13518 unsigned char * start
;
13520 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13522 /* PR 21820: Do not fail if the section was empty. */
13523 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13525 section_size
= section
->sh_size
;
13527 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13529 if (decompress_dumps
)
13531 dwarf_size_type new_size
= section_size
;
13532 dwarf_size_type uncompressed_size
= 0;
13534 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13536 Elf_Internal_Chdr chdr
;
13537 unsigned int compression_header_size
13538 = get_compression_header (& chdr
, start
, section_size
);
13540 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13542 warn (_("section '%s' has unsupported compress type: %d\n"),
13543 printable_section_name (filedata
, section
), chdr
.ch_type
);
13546 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13548 warn (_("compressed section '%s' is corrupted\n"),
13549 printable_section_name (filedata
, section
));
13552 uncompressed_size
= chdr
.ch_size
;
13553 start
+= compression_header_size
;
13554 new_size
-= compression_header_size
;
13556 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13558 /* Read the zlib header. In this case, it should be "ZLIB"
13559 followed by the uncompressed section size, 8 bytes in
13560 big-endian order. */
13561 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13562 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13563 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13564 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13565 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13566 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13567 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13568 uncompressed_size
+= start
[11];
13573 if (uncompressed_size
)
13575 if (uncompress_section_contents (& start
, uncompressed_size
,
13578 section_size
= new_size
;
13582 error (_("Unable to decompress section %s\n"),
13583 printable_section_name (filedata
, section
));
13584 /* FIXME: Print the section anyway ? */
13589 start
= real_start
;
13594 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13599 /* If the section being dumped has relocations against it the user might
13600 be expecting these relocations to have been applied. Check for this
13601 case and issue a warning message in order to avoid confusion.
13602 FIXME: Maybe we ought to have an option that dumps a section with
13603 relocs applied ? */
13604 for (relsec
= filedata
->section_headers
;
13605 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13608 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13609 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13610 || filedata
->section_headers
+ relsec
->sh_info
!= section
13611 || relsec
->sh_size
== 0
13612 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13615 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13620 addr
= section
->sh_addr
;
13621 bytes
= section_size
;
13630 lbytes
= (bytes
> 16 ? 16 : bytes
);
13632 printf (" 0x%8.8lx ", (unsigned long) addr
);
13634 for (j
= 0; j
< 16; j
++)
13637 printf ("%2.2x", data
[j
]);
13645 for (j
= 0; j
< lbytes
; j
++)
13648 if (k
>= ' ' && k
< 0x7f)
13668 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13669 const Elf_Internal_Shdr
* sec
,
13672 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13674 Filedata
* filedata
= (Filedata
*) data
;
13676 if (section
->start
!= NULL
)
13678 /* If it is already loaded, do nothing. */
13679 if (streq (section
->filename
, filedata
->file_name
))
13681 free (section
->start
);
13684 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13685 section
->address
= sec
->sh_addr
;
13686 section
->user_data
= NULL
;
13687 section
->filename
= filedata
->file_name
;
13688 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13690 sec
->sh_size
, buf
);
13691 if (section
->start
== NULL
)
13695 unsigned char *start
= section
->start
;
13696 dwarf_size_type size
= sec
->sh_size
;
13697 dwarf_size_type uncompressed_size
= 0;
13699 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13701 Elf_Internal_Chdr chdr
;
13702 unsigned int compression_header_size
;
13704 if (size
< (is_32bit_elf
13705 ? sizeof (Elf32_External_Chdr
)
13706 : sizeof (Elf64_External_Chdr
)))
13708 warn (_("compressed section %s is too small to contain a compression header"),
13713 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13715 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13717 warn (_("section '%s' has unsupported compress type: %d\n"),
13718 section
->name
, chdr
.ch_type
);
13721 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13723 warn (_("compressed section '%s' is corrupted\n"),
13727 uncompressed_size
= chdr
.ch_size
;
13728 start
+= compression_header_size
;
13729 size
-= compression_header_size
;
13731 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13733 /* Read the zlib header. In this case, it should be "ZLIB"
13734 followed by the uncompressed section size, 8 bytes in
13735 big-endian order. */
13736 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13737 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13738 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13739 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13740 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13741 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13742 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13743 uncompressed_size
+= start
[11];
13748 if (uncompressed_size
)
13750 if (uncompress_section_contents (&start
, uncompressed_size
,
13753 /* Free the compressed buffer, update the section buffer
13754 and the section size if uncompress is successful. */
13755 free (section
->start
);
13756 section
->start
= start
;
13760 error (_("Unable to decompress section %s\n"),
13761 printable_section_name (filedata
, sec
));
13766 section
->size
= size
;
13769 if (section
->start
== NULL
)
13772 if (debug_displays
[debug
].relocate
)
13774 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13775 & section
->reloc_info
, & section
->num_relocs
))
13780 section
->reloc_info
= NULL
;
13781 section
->num_relocs
= 0;
13787 /* If this is not NULL, load_debug_section will only look for sections
13788 within the list of sections given here. */
13789 static unsigned int * section_subset
= NULL
;
13792 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13794 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13795 Elf_Internal_Shdr
* sec
;
13796 Filedata
* filedata
= (Filedata
*) data
;
13798 /* Without section headers we cannot find any sections. */
13799 if (filedata
->section_headers
== NULL
)
13802 if (filedata
->string_table
== NULL
13803 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13804 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13806 Elf_Internal_Shdr
* strs
;
13808 /* Read in the string table, so that we have section names to scan. */
13809 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13811 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13813 filedata
->string_table
13814 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13815 1, strs
->sh_size
, _("string table"));
13817 filedata
->string_table_length
13818 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13822 /* Locate the debug section. */
13823 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13825 section
->name
= section
->uncompressed_name
;
13828 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13830 section
->name
= section
->compressed_name
;
13835 /* If we're loading from a subset of sections, and we've loaded
13836 a section matching this name before, it's likely that it's a
13838 if (section_subset
!= NULL
)
13839 free_debug_section (debug
);
13841 return load_specific_debug_section (debug
, sec
, data
);
13845 free_debug_section (enum dwarf_section_display_enum debug
)
13847 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13849 if (section
->start
== NULL
)
13852 free ((char *) section
->start
);
13853 section
->start
= NULL
;
13854 section
->address
= 0;
13859 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13861 char * name
= SECTION_NAME (section
);
13862 const char * print_name
= printable_section_name (filedata
, section
);
13863 bfd_size_type length
;
13864 bfd_boolean result
= TRUE
;
13867 length
= section
->sh_size
;
13870 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13873 if (section
->sh_type
== SHT_NOBITS
)
13875 /* There is no point in dumping the contents of a debugging section
13876 which has the NOBITS type - the bits in the file will be random.
13877 This can happen when a file containing a .eh_frame section is
13878 stripped with the --only-keep-debug command line option. */
13879 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13884 if (const_strneq (name
, ".gnu.linkonce.wi."))
13885 name
= ".debug_info";
13887 /* See if we know how to display the contents of this section. */
13888 for (i
= 0; i
< max
; i
++)
13890 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13891 struct dwarf_section_display
* display
= debug_displays
+ i
;
13892 struct dwarf_section
* sec
= & display
->section
;
13894 if (streq (sec
->uncompressed_name
, name
)
13895 || (id
== line
&& const_strneq (name
, ".debug_line."))
13896 || streq (sec
->compressed_name
, name
))
13898 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13901 free_debug_section (id
);
13903 if (i
== line
&& const_strneq (name
, ".debug_line."))
13905 else if (streq (sec
->uncompressed_name
, name
))
13906 sec
->name
= sec
->uncompressed_name
;
13908 sec
->name
= sec
->compressed_name
;
13910 if (load_specific_debug_section (id
, section
, filedata
))
13912 /* If this debug section is part of a CU/TU set in a .dwp file,
13913 restrict load_debug_section to the sections in that set. */
13914 section_subset
= find_cu_tu_set (filedata
, shndx
);
13916 result
&= display
->display (sec
, filedata
);
13918 section_subset
= NULL
;
13920 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13921 free_debug_section (id
);
13929 printf (_("Unrecognized debug section: %s\n"), print_name
);
13936 /* Set DUMP_SECTS for all sections where dumps were requested
13937 based on section name. */
13940 initialise_dumps_byname (Filedata
* filedata
)
13942 struct dump_list_entry
* cur
;
13944 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13947 bfd_boolean any
= FALSE
;
13949 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13950 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13952 request_dump_bynumber (filedata
, i
, cur
->type
);
13957 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13963 process_section_contents (Filedata
* filedata
)
13965 Elf_Internal_Shdr
* section
;
13967 bfd_boolean res
= TRUE
;
13972 initialise_dumps_byname (filedata
);
13974 for (i
= 0, section
= filedata
->section_headers
;
13975 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13978 dump_type dump
= filedata
->dump_sects
[i
];
13980 #ifdef SUPPORT_DISASSEMBLY
13981 if (dump
& DISASS_DUMP
)
13983 if (! disassemble_section (section
, filedata
))
13987 if (dump
& HEX_DUMP
)
13989 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13993 if (dump
& RELOC_DUMP
)
13995 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13999 if (dump
& STRING_DUMP
)
14001 if (! dump_section_as_strings (section
, filedata
))
14005 if (dump
& DEBUG_DUMP
)
14007 if (! display_debug_section (i
, section
, filedata
))
14012 /* Check to see if the user requested a
14013 dump of a section that does not exist. */
14014 while (i
< filedata
->num_dump_sects
)
14016 if (filedata
->dump_sects
[i
])
14018 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14028 process_mips_fpe_exception (int mask
)
14032 bfd_boolean first
= TRUE
;
14034 if (mask
& OEX_FPU_INEX
)
14035 fputs ("INEX", stdout
), first
= FALSE
;
14036 if (mask
& OEX_FPU_UFLO
)
14037 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14038 if (mask
& OEX_FPU_OFLO
)
14039 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14040 if (mask
& OEX_FPU_DIV0
)
14041 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14042 if (mask
& OEX_FPU_INVAL
)
14043 printf ("%sINVAL", first
? "" : "|");
14046 fputs ("0", stdout
);
14049 /* Display's the value of TAG at location P. If TAG is
14050 greater than 0 it is assumed to be an unknown tag, and
14051 a message is printed to this effect. Otherwise it is
14052 assumed that a message has already been printed.
14054 If the bottom bit of TAG is set it assumed to have a
14055 string value, otherwise it is assumed to have an integer
14058 Returns an updated P pointing to the first unread byte
14059 beyond the end of TAG's value.
14061 Reads at or beyond END will not be made. */
14063 static unsigned char *
14064 display_tag_value (signed int tag
,
14066 const unsigned char * const end
)
14071 printf (" Tag_unknown_%d: ", tag
);
14075 warn (_("<corrupt tag>\n"));
14079 /* PR 17531 file: 027-19978-0.004. */
14080 size_t maxlen
= (end
- p
) - 1;
14085 print_symbol ((int) maxlen
, (const char *) p
);
14086 p
+= strnlen ((char *) p
, maxlen
) + 1;
14090 printf (_("<corrupt string tag>"));
14091 p
= (unsigned char *) end
;
14099 val
= read_uleb128 (p
, &len
, end
);
14101 printf ("%ld (0x%lx)\n", val
, val
);
14108 /* ARC ABI attributes section. */
14110 static unsigned char *
14111 display_arc_attribute (unsigned char * p
,
14112 const unsigned char * const end
)
14118 tag
= read_uleb128 (p
, &len
, end
);
14123 case Tag_ARC_PCS_config
:
14124 val
= read_uleb128 (p
, &len
, end
);
14126 printf (" Tag_ARC_PCS_config: ");
14130 printf (_("Absent/Non standard\n"));
14133 printf (_("Bare metal/mwdt\n"));
14136 printf (_("Bare metal/newlib\n"));
14139 printf (_("Linux/uclibc\n"));
14142 printf (_("Linux/glibc\n"));
14145 printf (_("Unknown\n"));
14150 case Tag_ARC_CPU_base
:
14151 val
= read_uleb128 (p
, &len
, end
);
14153 printf (" Tag_ARC_CPU_base: ");
14158 printf (_("Absent\n"));
14160 case TAG_CPU_ARC6xx
:
14161 printf ("ARC6xx\n");
14163 case TAG_CPU_ARC7xx
:
14164 printf ("ARC7xx\n");
14166 case TAG_CPU_ARCEM
:
14167 printf ("ARCEM\n");
14169 case TAG_CPU_ARCHS
:
14170 printf ("ARCHS\n");
14175 case Tag_ARC_CPU_variation
:
14176 val
= read_uleb128 (p
, &len
, end
);
14178 printf (" Tag_ARC_CPU_variation: ");
14182 if (val
> 0 && val
< 16)
14183 printf ("Core%d\n", val
);
14185 printf ("Unknown\n");
14189 printf (_("Absent\n"));
14194 case Tag_ARC_CPU_name
:
14195 printf (" Tag_ARC_CPU_name: ");
14196 p
= display_tag_value (-1, p
, end
);
14199 case Tag_ARC_ABI_rf16
:
14200 val
= read_uleb128 (p
, &len
, end
);
14202 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14205 case Tag_ARC_ABI_osver
:
14206 val
= read_uleb128 (p
, &len
, end
);
14208 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14211 case Tag_ARC_ABI_pic
:
14212 case Tag_ARC_ABI_sda
:
14213 val
= read_uleb128 (p
, &len
, end
);
14215 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14216 : " Tag_ARC_ABI_pic: ");
14220 printf (_("Absent\n"));
14229 printf (_("Unknown\n"));
14234 case Tag_ARC_ABI_tls
:
14235 val
= read_uleb128 (p
, &len
, end
);
14237 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14240 case Tag_ARC_ABI_enumsize
:
14241 val
= read_uleb128 (p
, &len
, end
);
14243 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14247 case Tag_ARC_ABI_exceptions
:
14248 val
= read_uleb128 (p
, &len
, end
);
14250 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14254 case Tag_ARC_ABI_double_size
:
14255 val
= read_uleb128 (p
, &len
, end
);
14257 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14260 case Tag_ARC_ISA_config
:
14261 printf (" Tag_ARC_ISA_config: ");
14262 p
= display_tag_value (-1, p
, end
);
14265 case Tag_ARC_ISA_apex
:
14266 printf (" Tag_ARC_ISA_apex: ");
14267 p
= display_tag_value (-1, p
, end
);
14270 case Tag_ARC_ISA_mpy_option
:
14271 val
= read_uleb128 (p
, &len
, end
);
14273 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14276 case Tag_ARC_ATR_version
:
14277 val
= read_uleb128 (p
, &len
, end
);
14279 printf (" Tag_ARC_ATR_version: %d\n", val
);
14283 return display_tag_value (tag
& 1, p
, end
);
14289 /* ARM EABI attributes section. */
14294 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14296 const char ** table
;
14297 } arm_attr_public_tag
;
14299 static const char * arm_attr_tag_CPU_arch
[] =
14300 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14301 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14303 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14304 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14305 {"No", "Thumb-1", "Thumb-2", "Yes"};
14306 static const char * arm_attr_tag_FP_arch
[] =
14307 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14308 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14309 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14310 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14311 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14312 "NEON for ARMv8.1"};
14313 static const char * arm_attr_tag_PCS_config
[] =
14314 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14315 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14316 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14317 {"V6", "SB", "TLS", "Unused"};
14318 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14319 {"Absolute", "PC-relative", "SB-relative", "None"};
14320 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14321 {"Absolute", "PC-relative", "None"};
14322 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14323 {"None", "direct", "GOT-indirect"};
14324 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14325 {"None", "??? 1", "2", "??? 3", "4"};
14326 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14327 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14328 {"Unused", "Needed", "Sign only"};
14329 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14330 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14331 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14332 {"Unused", "Finite", "RTABI", "IEEE 754"};
14333 static const char * arm_attr_tag_ABI_enum_size
[] =
14334 {"Unused", "small", "int", "forced to int"};
14335 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14336 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14337 static const char * arm_attr_tag_ABI_VFP_args
[] =
14338 {"AAPCS", "VFP registers", "custom", "compatible"};
14339 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14340 {"AAPCS", "WMMX registers", "custom"};
14341 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14342 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14343 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14344 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14345 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14346 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14347 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14348 static const char * arm_attr_tag_FP_HP_extension
[] =
14349 {"Not Allowed", "Allowed"};
14350 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14351 {"None", "IEEE 754", "Alternative Format"};
14352 static const char * arm_attr_tag_DSP_extension
[] =
14353 {"Follow architecture", "Allowed"};
14354 static const char * arm_attr_tag_MPextension_use
[] =
14355 {"Not Allowed", "Allowed"};
14356 static const char * arm_attr_tag_DIV_use
[] =
14357 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14358 "Allowed in v7-A with integer division extension"};
14359 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14360 static const char * arm_attr_tag_Virtualization_use
[] =
14361 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14362 "TrustZone and Virtualization Extensions"};
14363 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14364 {"Not Allowed", "Allowed"};
14366 #define LOOKUP(id, name) \
14367 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14368 static arm_attr_public_tag arm_attr_public_tags
[] =
14370 {4, "CPU_raw_name", 1, NULL
},
14371 {5, "CPU_name", 1, NULL
},
14372 LOOKUP(6, CPU_arch
),
14373 {7, "CPU_arch_profile", 0, NULL
},
14374 LOOKUP(8, ARM_ISA_use
),
14375 LOOKUP(9, THUMB_ISA_use
),
14376 LOOKUP(10, FP_arch
),
14377 LOOKUP(11, WMMX_arch
),
14378 LOOKUP(12, Advanced_SIMD_arch
),
14379 LOOKUP(13, PCS_config
),
14380 LOOKUP(14, ABI_PCS_R9_use
),
14381 LOOKUP(15, ABI_PCS_RW_data
),
14382 LOOKUP(16, ABI_PCS_RO_data
),
14383 LOOKUP(17, ABI_PCS_GOT_use
),
14384 LOOKUP(18, ABI_PCS_wchar_t
),
14385 LOOKUP(19, ABI_FP_rounding
),
14386 LOOKUP(20, ABI_FP_denormal
),
14387 LOOKUP(21, ABI_FP_exceptions
),
14388 LOOKUP(22, ABI_FP_user_exceptions
),
14389 LOOKUP(23, ABI_FP_number_model
),
14390 {24, "ABI_align_needed", 0, NULL
},
14391 {25, "ABI_align_preserved", 0, NULL
},
14392 LOOKUP(26, ABI_enum_size
),
14393 LOOKUP(27, ABI_HardFP_use
),
14394 LOOKUP(28, ABI_VFP_args
),
14395 LOOKUP(29, ABI_WMMX_args
),
14396 LOOKUP(30, ABI_optimization_goals
),
14397 LOOKUP(31, ABI_FP_optimization_goals
),
14398 {32, "compatibility", 0, NULL
},
14399 LOOKUP(34, CPU_unaligned_access
),
14400 LOOKUP(36, FP_HP_extension
),
14401 LOOKUP(38, ABI_FP_16bit_format
),
14402 LOOKUP(42, MPextension_use
),
14403 LOOKUP(44, DIV_use
),
14404 LOOKUP(46, DSP_extension
),
14405 {64, "nodefaults", 0, NULL
},
14406 {65, "also_compatible_with", 0, NULL
},
14407 LOOKUP(66, T2EE_use
),
14408 {67, "conformance", 1, NULL
},
14409 LOOKUP(68, Virtualization_use
),
14410 LOOKUP(70, MPextension_use_legacy
)
14414 static unsigned char *
14415 display_arm_attribute (unsigned char * p
,
14416 const unsigned char * const end
)
14421 arm_attr_public_tag
* attr
;
14425 tag
= read_uleb128 (p
, &len
, end
);
14428 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14430 if (arm_attr_public_tags
[i
].tag
== tag
)
14432 attr
= &arm_attr_public_tags
[i
];
14439 printf (" Tag_%s: ", attr
->name
);
14440 switch (attr
->type
)
14445 case 7: /* Tag_CPU_arch_profile. */
14446 val
= read_uleb128 (p
, &len
, end
);
14450 case 0: printf (_("None\n")); break;
14451 case 'A': printf (_("Application\n")); break;
14452 case 'R': printf (_("Realtime\n")); break;
14453 case 'M': printf (_("Microcontroller\n")); break;
14454 case 'S': printf (_("Application or Realtime\n")); break;
14455 default: printf ("??? (%d)\n", val
); break;
14459 case 24: /* Tag_align_needed. */
14460 val
= read_uleb128 (p
, &len
, end
);
14464 case 0: printf (_("None\n")); break;
14465 case 1: printf (_("8-byte\n")); break;
14466 case 2: printf (_("4-byte\n")); break;
14467 case 3: printf ("??? 3\n"); break;
14470 printf (_("8-byte and up to %d-byte extended\n"),
14473 printf ("??? (%d)\n", val
);
14478 case 25: /* Tag_align_preserved. */
14479 val
= read_uleb128 (p
, &len
, end
);
14483 case 0: printf (_("None\n")); break;
14484 case 1: printf (_("8-byte, except leaf SP\n")); break;
14485 case 2: printf (_("8-byte\n")); break;
14486 case 3: printf ("??? 3\n"); break;
14489 printf (_("8-byte and up to %d-byte extended\n"),
14492 printf ("??? (%d)\n", val
);
14497 case 32: /* Tag_compatibility. */
14499 val
= read_uleb128 (p
, &len
, end
);
14501 printf (_("flag = %d, vendor = "), val
);
14504 size_t maxlen
= (end
- p
) - 1;
14506 print_symbol ((int) maxlen
, (const char *) p
);
14507 p
+= strnlen ((char *) p
, maxlen
) + 1;
14511 printf (_("<corrupt>"));
14512 p
= (unsigned char *) end
;
14518 case 64: /* Tag_nodefaults. */
14519 /* PR 17531: file: 001-505008-0.01. */
14522 printf (_("True\n"));
14525 case 65: /* Tag_also_compatible_with. */
14526 val
= read_uleb128 (p
, &len
, end
);
14528 if (val
== 6 /* Tag_CPU_arch. */)
14530 val
= read_uleb128 (p
, &len
, end
);
14532 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14533 printf ("??? (%d)\n", val
);
14535 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14539 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14544 printf (_("<unknown: %d>\n"), tag
);
14550 return display_tag_value (-1, p
, end
);
14552 return display_tag_value (0, p
, end
);
14555 assert (attr
->type
& 0x80);
14556 val
= read_uleb128 (p
, &len
, end
);
14558 type
= attr
->type
& 0x7f;
14560 printf ("??? (%d)\n", val
);
14562 printf ("%s\n", attr
->table
[val
]);
14567 return display_tag_value (tag
, p
, end
);
14570 static unsigned char *
14571 display_gnu_attribute (unsigned char * p
,
14572 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14573 const unsigned char * const end
)
14579 tag
= read_uleb128 (p
, &len
, end
);
14582 /* Tag_compatibility is the only generic GNU attribute defined at
14586 val
= read_uleb128 (p
, &len
, end
);
14589 printf (_("flag = %d, vendor = "), val
);
14592 printf (_("<corrupt>\n"));
14593 warn (_("corrupt vendor attribute\n"));
14599 size_t maxlen
= (end
- p
) - 1;
14601 print_symbol ((int) maxlen
, (const char *) p
);
14602 p
+= strnlen ((char *) p
, maxlen
) + 1;
14606 printf (_("<corrupt>"));
14607 p
= (unsigned char *) end
;
14614 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14615 return display_proc_gnu_attribute (p
, tag
, end
);
14617 return display_tag_value (tag
, p
, end
);
14620 static unsigned char *
14621 display_power_gnu_attribute (unsigned char * p
,
14623 const unsigned char * const end
)
14628 if (tag
== Tag_GNU_Power_ABI_FP
)
14630 val
= read_uleb128 (p
, &len
, end
);
14632 printf (" Tag_GNU_Power_ABI_FP: ");
14635 printf (_("<corrupt>\n"));
14640 printf ("(%#x), ", val
);
14645 printf (_("unspecified hard/soft float, "));
14648 printf (_("hard float, "));
14651 printf (_("soft float, "));
14654 printf (_("single-precision hard float, "));
14661 printf (_("unspecified long double\n"));
14664 printf (_("128-bit IBM long double\n"));
14667 printf (_("64-bit long double\n"));
14670 printf (_("128-bit IEEE long double\n"));
14676 if (tag
== Tag_GNU_Power_ABI_Vector
)
14678 val
= read_uleb128 (p
, &len
, end
);
14680 printf (" Tag_GNU_Power_ABI_Vector: ");
14683 printf (_("<corrupt>\n"));
14688 printf ("(%#x), ", val
);
14693 printf (_("unspecified\n"));
14696 printf (_("generic\n"));
14699 printf ("AltiVec\n");
14708 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14710 val
= read_uleb128 (p
, &len
, end
);
14712 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14715 printf (_("<corrupt>\n"));
14720 printf ("(%#x), ", val
);
14725 printf (_("unspecified\n"));
14728 printf ("r3/r4\n");
14731 printf (_("memory\n"));
14740 return display_tag_value (tag
& 1, p
, end
);
14743 static unsigned char *
14744 display_s390_gnu_attribute (unsigned char * p
,
14746 const unsigned char * const end
)
14751 if (tag
== Tag_GNU_S390_ABI_Vector
)
14753 val
= read_uleb128 (p
, &len
, end
);
14755 printf (" Tag_GNU_S390_ABI_Vector: ");
14760 printf (_("any\n"));
14763 printf (_("software\n"));
14766 printf (_("hardware\n"));
14769 printf ("??? (%d)\n", val
);
14775 return display_tag_value (tag
& 1, p
, end
);
14779 display_sparc_hwcaps (unsigned int mask
)
14783 bfd_boolean first
= TRUE
;
14785 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14786 fputs ("mul32", stdout
), first
= FALSE
;
14787 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14788 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14789 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14790 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14791 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14792 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14793 if (mask
& ELF_SPARC_HWCAP_POPC
)
14794 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14795 if (mask
& ELF_SPARC_HWCAP_VIS
)
14796 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14797 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14798 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14799 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14800 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14801 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14802 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14803 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14804 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14805 if (mask
& ELF_SPARC_HWCAP_HPC
)
14806 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14807 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14808 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14809 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14810 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14811 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14812 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14813 if (mask
& ELF_SPARC_HWCAP_IMA
)
14814 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14815 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14816 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14819 fputc ('0', stdout
);
14820 fputc ('\n', stdout
);
14824 display_sparc_hwcaps2 (unsigned int mask
)
14828 bfd_boolean first
= TRUE
;
14830 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14831 fputs ("fjathplus", stdout
), first
= FALSE
;
14832 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14833 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14834 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14835 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14836 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14837 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14838 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14839 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14840 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14841 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14842 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14843 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14844 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14845 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14846 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14847 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14848 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14849 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14850 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14851 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14854 fputc ('0', stdout
);
14855 fputc ('\n', stdout
);
14858 static unsigned char *
14859 display_sparc_gnu_attribute (unsigned char * p
,
14861 const unsigned char * const end
)
14866 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14868 val
= read_uleb128 (p
, &len
, end
);
14870 printf (" Tag_GNU_Sparc_HWCAPS: ");
14871 display_sparc_hwcaps (val
);
14874 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14876 val
= read_uleb128 (p
, &len
, end
);
14878 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14879 display_sparc_hwcaps2 (val
);
14883 return display_tag_value (tag
, p
, end
);
14887 print_mips_fp_abi_value (unsigned int val
)
14891 case Val_GNU_MIPS_ABI_FP_ANY
:
14892 printf (_("Hard or soft float\n"));
14894 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14895 printf (_("Hard float (double precision)\n"));
14897 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14898 printf (_("Hard float (single precision)\n"));
14900 case Val_GNU_MIPS_ABI_FP_SOFT
:
14901 printf (_("Soft float\n"));
14903 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14904 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14906 case Val_GNU_MIPS_ABI_FP_XX
:
14907 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14909 case Val_GNU_MIPS_ABI_FP_64
:
14910 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14912 case Val_GNU_MIPS_ABI_FP_64A
:
14913 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14915 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14916 printf (_("NaN 2008 compatibility\n"));
14919 printf ("??? (%d)\n", val
);
14924 static unsigned char *
14925 display_mips_gnu_attribute (unsigned char * p
,
14927 const unsigned char * const end
)
14929 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14934 val
= read_uleb128 (p
, &len
, end
);
14936 printf (" Tag_GNU_MIPS_ABI_FP: ");
14938 print_mips_fp_abi_value (val
);
14943 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14948 val
= read_uleb128 (p
, &len
, end
);
14950 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14954 case Val_GNU_MIPS_ABI_MSA_ANY
:
14955 printf (_("Any MSA or not\n"));
14957 case Val_GNU_MIPS_ABI_MSA_128
:
14958 printf (_("128-bit MSA\n"));
14961 printf ("??? (%d)\n", val
);
14967 return display_tag_value (tag
& 1, p
, end
);
14970 static unsigned char *
14971 display_tic6x_attribute (unsigned char * p
,
14972 const unsigned char * const end
)
14978 tag
= read_uleb128 (p
, &len
, end
);
14984 val
= read_uleb128 (p
, &len
, end
);
14986 printf (" Tag_ISA: ");
14990 case C6XABI_Tag_ISA_none
:
14991 printf (_("None\n"));
14993 case C6XABI_Tag_ISA_C62X
:
14996 case C6XABI_Tag_ISA_C67X
:
14999 case C6XABI_Tag_ISA_C67XP
:
15000 printf ("C67x+\n");
15002 case C6XABI_Tag_ISA_C64X
:
15005 case C6XABI_Tag_ISA_C64XP
:
15006 printf ("C64x+\n");
15008 case C6XABI_Tag_ISA_C674X
:
15009 printf ("C674x\n");
15012 printf ("??? (%d)\n", val
);
15017 case Tag_ABI_wchar_t
:
15018 val
= read_uleb128 (p
, &len
, end
);
15020 printf (" Tag_ABI_wchar_t: ");
15024 printf (_("Not used\n"));
15027 printf (_("2 bytes\n"));
15030 printf (_("4 bytes\n"));
15033 printf ("??? (%d)\n", val
);
15038 case Tag_ABI_stack_align_needed
:
15039 val
= read_uleb128 (p
, &len
, end
);
15041 printf (" Tag_ABI_stack_align_needed: ");
15045 printf (_("8-byte\n"));
15048 printf (_("16-byte\n"));
15051 printf ("??? (%d)\n", val
);
15056 case Tag_ABI_stack_align_preserved
:
15057 val
= read_uleb128 (p
, &len
, end
);
15059 printf (" Tag_ABI_stack_align_preserved: ");
15063 printf (_("8-byte\n"));
15066 printf (_("16-byte\n"));
15069 printf ("??? (%d)\n", val
);
15075 val
= read_uleb128 (p
, &len
, end
);
15077 printf (" Tag_ABI_DSBT: ");
15081 printf (_("DSBT addressing not used\n"));
15084 printf (_("DSBT addressing used\n"));
15087 printf ("??? (%d)\n", val
);
15093 val
= read_uleb128 (p
, &len
, end
);
15095 printf (" Tag_ABI_PID: ");
15099 printf (_("Data addressing position-dependent\n"));
15102 printf (_("Data addressing position-independent, GOT near DP\n"));
15105 printf (_("Data addressing position-independent, GOT far from DP\n"));
15108 printf ("??? (%d)\n", val
);
15114 val
= read_uleb128 (p
, &len
, end
);
15116 printf (" Tag_ABI_PIC: ");
15120 printf (_("Code addressing position-dependent\n"));
15123 printf (_("Code addressing position-independent\n"));
15126 printf ("??? (%d)\n", val
);
15131 case Tag_ABI_array_object_alignment
:
15132 val
= read_uleb128 (p
, &len
, end
);
15134 printf (" Tag_ABI_array_object_alignment: ");
15138 printf (_("8-byte\n"));
15141 printf (_("4-byte\n"));
15144 printf (_("16-byte\n"));
15147 printf ("??? (%d)\n", val
);
15152 case Tag_ABI_array_object_align_expected
:
15153 val
= read_uleb128 (p
, &len
, end
);
15155 printf (" Tag_ABI_array_object_align_expected: ");
15159 printf (_("8-byte\n"));
15162 printf (_("4-byte\n"));
15165 printf (_("16-byte\n"));
15168 printf ("??? (%d)\n", val
);
15173 case Tag_ABI_compatibility
:
15175 val
= read_uleb128 (p
, &len
, end
);
15177 printf (" Tag_ABI_compatibility: ");
15178 printf (_("flag = %d, vendor = "), val
);
15181 size_t maxlen
= (end
- p
) - 1;
15183 print_symbol ((int) maxlen
, (const char *) p
);
15184 p
+= strnlen ((char *) p
, maxlen
) + 1;
15188 printf (_("<corrupt>"));
15189 p
= (unsigned char *) end
;
15195 case Tag_ABI_conformance
:
15197 printf (" Tag_ABI_conformance: \"");
15200 size_t maxlen
= (end
- p
) - 1;
15202 print_symbol ((int) maxlen
, (const char *) p
);
15203 p
+= strnlen ((char *) p
, maxlen
) + 1;
15207 printf (_("<corrupt>"));
15208 p
= (unsigned char *) end
;
15215 return display_tag_value (tag
, p
, end
);
15219 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15221 unsigned long addr
= 0;
15222 size_t bytes
= end
- p
;
15229 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15231 printf (" 0x%8.8lx ", addr
);
15233 for (j
= 0; j
< 16; j
++)
15236 printf ("%2.2x", p
[j
]);
15244 for (j
= 0; j
< lbytes
; j
++)
15247 if (k
>= ' ' && k
< 0x7f)
15263 static unsigned char *
15264 display_msp430x_attribute (unsigned char * p
,
15265 const unsigned char * const end
)
15271 tag
= read_uleb128 (p
, & len
, end
);
15276 case OFBA_MSPABI_Tag_ISA
:
15277 val
= read_uleb128 (p
, &len
, end
);
15279 printf (" Tag_ISA: ");
15282 case 0: printf (_("None\n")); break;
15283 case 1: printf (_("MSP430\n")); break;
15284 case 2: printf (_("MSP430X\n")); break;
15285 default: printf ("??? (%d)\n", val
); break;
15289 case OFBA_MSPABI_Tag_Code_Model
:
15290 val
= read_uleb128 (p
, &len
, end
);
15292 printf (" Tag_Code_Model: ");
15295 case 0: printf (_("None\n")); break;
15296 case 1: printf (_("Small\n")); break;
15297 case 2: printf (_("Large\n")); break;
15298 default: printf ("??? (%d)\n", val
); break;
15302 case OFBA_MSPABI_Tag_Data_Model
:
15303 val
= read_uleb128 (p
, &len
, end
);
15305 printf (" Tag_Data_Model: ");
15308 case 0: printf (_("None\n")); break;
15309 case 1: printf (_("Small\n")); break;
15310 case 2: printf (_("Large\n")); break;
15311 case 3: printf (_("Restricted Large\n")); break;
15312 default: printf ("??? (%d)\n", val
); break;
15317 printf (_(" <unknown tag %d>: "), tag
);
15324 size_t maxlen
= (end
- p
) - 1;
15326 print_symbol ((int) maxlen
, (const char *) p
);
15327 p
+= strnlen ((char *) p
, maxlen
) + 1;
15331 printf (_("<corrupt>"));
15332 p
= (unsigned char *) end
;
15338 val
= read_uleb128 (p
, &len
, end
);
15340 printf ("%d (0x%x)\n", val
, val
);
15350 process_attributes (Filedata
* filedata
,
15351 const char * public_name
,
15352 unsigned int proc_type
,
15353 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15354 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15356 Elf_Internal_Shdr
* sect
;
15358 bfd_boolean res
= TRUE
;
15360 /* Find the section header so that we get the size. */
15361 for (i
= 0, sect
= filedata
->section_headers
;
15362 i
< filedata
->file_header
.e_shnum
;
15365 unsigned char * contents
;
15368 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15371 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15372 sect
->sh_size
, _("attributes"));
15373 if (contents
== NULL
)
15380 /* The first character is the version of the attributes.
15381 Currently only version 1, (aka 'A') is recognised here. */
15384 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15389 bfd_vma section_len
;
15391 section_len
= sect
->sh_size
- 1;
15394 while (section_len
> 0)
15397 unsigned int namelen
;
15398 bfd_boolean public_section
;
15399 bfd_boolean gnu_section
;
15401 if (section_len
<= 4)
15403 error (_("Tag section ends prematurely\n"));
15407 attr_len
= byte_get (p
, 4);
15410 if (attr_len
> section_len
)
15412 error (_("Bad attribute length (%u > %u)\n"),
15413 (unsigned) attr_len
, (unsigned) section_len
);
15414 attr_len
= section_len
;
15417 /* PR 17531: file: 001-101425-0.004 */
15418 else if (attr_len
< 5)
15420 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15425 section_len
-= attr_len
;
15428 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15429 if (namelen
== 0 || namelen
>= attr_len
)
15431 error (_("Corrupt attribute section name\n"));
15436 printf (_("Attribute Section: "));
15437 print_symbol (INT_MAX
, (const char *) p
);
15440 if (public_name
&& streq ((char *) p
, public_name
))
15441 public_section
= TRUE
;
15443 public_section
= FALSE
;
15445 if (streq ((char *) p
, "gnu"))
15446 gnu_section
= TRUE
;
15448 gnu_section
= FALSE
;
15451 attr_len
-= namelen
;
15453 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15458 unsigned char * end
;
15460 /* PR binutils/17531: Safe handling of corrupt files. */
15463 error (_("Unused bytes at end of section\n"));
15470 size
= byte_get (p
, 4);
15471 if (size
> attr_len
)
15473 error (_("Bad subsection length (%u > %u)\n"),
15474 (unsigned) size
, (unsigned) attr_len
);
15478 /* PR binutils/17531: Safe handling of corrupt files. */
15481 error (_("Bad subsection length (%u < 6)\n"),
15489 end
= p
+ size
- 1;
15490 assert (end
<= contents
+ sect
->sh_size
);
15496 printf (_("File Attributes\n"));
15499 printf (_("Section Attributes:"));
15502 printf (_("Symbol Attributes:"));
15503 /* Fall through. */
15509 val
= read_uleb128 (p
, &j
, end
);
15513 printf (" %d", val
);
15518 printf (_("Unknown tag: %d\n"), tag
);
15519 public_section
= FALSE
;
15523 if (public_section
&& display_pub_attribute
!= NULL
)
15526 p
= display_pub_attribute (p
, end
);
15529 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15532 p
= display_gnu_attribute (p
,
15533 display_proc_gnu_attribute
,
15539 printf (_(" Unknown attribute:\n"));
15540 display_raw_attribute (p
, end
);
15555 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15556 Print the Address, Access and Initial fields of an entry at VMA ADDR
15557 and return the VMA of the next entry, or -1 if there was a problem.
15558 Does not read from DATA_END or beyond. */
15561 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15562 unsigned char * data_end
)
15565 print_vma (addr
, LONG_HEX
);
15567 if (addr
< pltgot
+ 0xfff0)
15568 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15570 printf ("%10s", "");
15573 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15577 unsigned char * from
= data
+ addr
- pltgot
;
15579 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15581 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15582 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15583 return (bfd_vma
) -1;
15587 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15588 print_vma (entry
, LONG_HEX
);
15591 return addr
+ (is_32bit_elf
? 4 : 8);
15594 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15595 PLTGOT. Print the Address and Initial fields of an entry at VMA
15596 ADDR and return the VMA of the next entry. */
15599 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15602 print_vma (addr
, LONG_HEX
);
15605 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15610 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15611 print_vma (entry
, LONG_HEX
);
15613 return addr
+ (is_32bit_elf
? 4 : 8);
15617 print_mips_ases (unsigned int mask
)
15619 if (mask
& AFL_ASE_DSP
)
15620 fputs ("\n\tDSP ASE", stdout
);
15621 if (mask
& AFL_ASE_DSPR2
)
15622 fputs ("\n\tDSP R2 ASE", stdout
);
15623 if (mask
& AFL_ASE_DSPR3
)
15624 fputs ("\n\tDSP R3 ASE", stdout
);
15625 if (mask
& AFL_ASE_EVA
)
15626 fputs ("\n\tEnhanced VA Scheme", stdout
);
15627 if (mask
& AFL_ASE_MCU
)
15628 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15629 if (mask
& AFL_ASE_MDMX
)
15630 fputs ("\n\tMDMX ASE", stdout
);
15631 if (mask
& AFL_ASE_MIPS3D
)
15632 fputs ("\n\tMIPS-3D ASE", stdout
);
15633 if (mask
& AFL_ASE_MT
)
15634 fputs ("\n\tMT ASE", stdout
);
15635 if (mask
& AFL_ASE_SMARTMIPS
)
15636 fputs ("\n\tSmartMIPS ASE", stdout
);
15637 if (mask
& AFL_ASE_VIRT
)
15638 fputs ("\n\tVZ ASE", stdout
);
15639 if (mask
& AFL_ASE_MSA
)
15640 fputs ("\n\tMSA ASE", stdout
);
15641 if (mask
& AFL_ASE_MIPS16
)
15642 fputs ("\n\tMIPS16 ASE", stdout
);
15643 if (mask
& AFL_ASE_MICROMIPS
)
15644 fputs ("\n\tMICROMIPS ASE", stdout
);
15645 if (mask
& AFL_ASE_XPA
)
15646 fputs ("\n\tXPA ASE", stdout
);
15647 if (mask
& AFL_ASE_MIPS16E2
)
15648 fputs ("\n\tMIPS16e2 ASE", stdout
);
15649 if (mask
& AFL_ASE_CRC
)
15650 fputs ("\n\tCRC ASE", stdout
);
15651 if (mask
& AFL_ASE_GINV
)
15652 fputs ("\n\tGINV ASE", stdout
);
15653 if (mask
& AFL_ASE_LOONGSON_MMI
)
15654 fputs ("\n\tLoongson MMI ASE", stdout
);
15655 if (mask
& AFL_ASE_LOONGSON_CAM
)
15656 fputs ("\n\tLoongson CAM ASE", stdout
);
15657 if (mask
& AFL_ASE_LOONGSON_EXT
)
15658 fputs ("\n\tLoongson EXT ASE", stdout
);
15659 if (mask
& AFL_ASE_LOONGSON_EXT2
)
15660 fputs ("\n\tLoongson EXT2 ASE", stdout
);
15662 fprintf (stdout
, "\n\t%s", _("None"));
15663 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15664 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15668 print_mips_isa_ext (unsigned int isa_ext
)
15673 fputs (_("None"), stdout
);
15676 fputs ("RMI XLR", stdout
);
15678 case AFL_EXT_OCTEON3
:
15679 fputs ("Cavium Networks Octeon3", stdout
);
15681 case AFL_EXT_OCTEON2
:
15682 fputs ("Cavium Networks Octeon2", stdout
);
15684 case AFL_EXT_OCTEONP
:
15685 fputs ("Cavium Networks OcteonP", stdout
);
15687 case AFL_EXT_OCTEON
:
15688 fputs ("Cavium Networks Octeon", stdout
);
15691 fputs ("Toshiba R5900", stdout
);
15694 fputs ("MIPS R4650", stdout
);
15697 fputs ("LSI R4010", stdout
);
15700 fputs ("NEC VR4100", stdout
);
15703 fputs ("Toshiba R3900", stdout
);
15705 case AFL_EXT_10000
:
15706 fputs ("MIPS R10000", stdout
);
15709 fputs ("Broadcom SB-1", stdout
);
15712 fputs ("NEC VR4111/VR4181", stdout
);
15715 fputs ("NEC VR4120", stdout
);
15718 fputs ("NEC VR5400", stdout
);
15721 fputs ("NEC VR5500", stdout
);
15723 case AFL_EXT_LOONGSON_2E
:
15724 fputs ("ST Microelectronics Loongson 2E", stdout
);
15726 case AFL_EXT_LOONGSON_2F
:
15727 fputs ("ST Microelectronics Loongson 2F", stdout
);
15729 case AFL_EXT_INTERAPTIV_MR2
:
15730 fputs ("Imagination interAptiv MR2", stdout
);
15733 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15738 get_mips_reg_size (int reg_size
)
15740 return (reg_size
== AFL_REG_NONE
) ? 0
15741 : (reg_size
== AFL_REG_32
) ? 32
15742 : (reg_size
== AFL_REG_64
) ? 64
15743 : (reg_size
== AFL_REG_128
) ? 128
15748 process_mips_specific (Filedata
* filedata
)
15750 Elf_Internal_Dyn
* entry
;
15751 Elf_Internal_Shdr
*sect
= NULL
;
15752 size_t liblist_offset
= 0;
15753 size_t liblistno
= 0;
15754 size_t conflictsno
= 0;
15755 size_t options_offset
= 0;
15756 size_t conflicts_offset
= 0;
15757 size_t pltrelsz
= 0;
15759 bfd_vma pltgot
= 0;
15760 bfd_vma mips_pltgot
= 0;
15761 bfd_vma jmprel
= 0;
15762 bfd_vma local_gotno
= 0;
15763 bfd_vma gotsym
= 0;
15764 bfd_vma symtabno
= 0;
15765 bfd_boolean res
= TRUE
;
15767 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15768 display_mips_gnu_attribute
))
15771 sect
= find_section (filedata
, ".MIPS.abiflags");
15775 Elf_External_ABIFlags_v0
*abiflags_ext
;
15776 Elf_Internal_ABIFlags_v0 abiflags_in
;
15778 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15780 error (_("Corrupt MIPS ABI Flags section.\n"));
15785 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15786 sect
->sh_size
, _("MIPS ABI Flags section"));
15789 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15790 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15791 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15792 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15793 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15794 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15795 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15796 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15797 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15798 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15799 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15801 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15802 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15803 if (abiflags_in
.isa_rev
> 1)
15804 printf ("r%d", abiflags_in
.isa_rev
);
15805 printf ("\nGPR size: %d",
15806 get_mips_reg_size (abiflags_in
.gpr_size
));
15807 printf ("\nCPR1 size: %d",
15808 get_mips_reg_size (abiflags_in
.cpr1_size
));
15809 printf ("\nCPR2 size: %d",
15810 get_mips_reg_size (abiflags_in
.cpr2_size
));
15811 fputs ("\nFP ABI: ", stdout
);
15812 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15813 fputs ("ISA Extension: ", stdout
);
15814 print_mips_isa_ext (abiflags_in
.isa_ext
);
15815 fputs ("\nASEs:", stdout
);
15816 print_mips_ases (abiflags_in
.ases
);
15817 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15818 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15819 fputc ('\n', stdout
);
15820 free (abiflags_ext
);
15825 /* We have a lot of special sections. Thanks SGI! */
15826 if (dynamic_section
== NULL
)
15828 /* No dynamic information available. See if there is static GOT. */
15829 sect
= find_section (filedata
, ".got");
15832 unsigned char *data_end
;
15833 unsigned char *data
;
15837 pltgot
= sect
->sh_addr
;
15840 addr_size
= (is_32bit_elf
? 4 : 8);
15841 end
= pltgot
+ sect
->sh_size
;
15843 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15845 _("Global Offset Table data"));
15846 /* PR 12855: Null data is handled gracefully throughout. */
15847 data_end
= data
+ (end
- pltgot
);
15849 printf (_("\nStatic GOT:\n"));
15850 printf (_(" Canonical gp value: "));
15851 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15854 /* In a dynamic binary GOT[0] is reserved for the dynamic
15855 loader to store the lazy resolver pointer, however in
15856 a static binary it may well have been omitted and GOT
15857 reduced to a table of addresses.
15858 PR 21344: Check for the entry being fully available
15859 before fetching it. */
15861 && data
+ ent
- pltgot
+ addr_size
<= data_end
15862 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15864 printf (_(" Reserved entries:\n"));
15865 printf (_(" %*s %10s %*s\n"),
15866 addr_size
* 2, _("Address"), _("Access"),
15867 addr_size
* 2, _("Value"));
15868 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15870 if (ent
== (bfd_vma
) -1)
15871 goto sgot_print_fail
;
15873 /* Check for the MSB of GOT[1] being set, identifying a
15874 GNU object. This entry will be used by some runtime
15875 loaders, to store the module pointer. Otherwise this
15876 is an ordinary local entry.
15877 PR 21344: Check for the entry being fully available
15878 before fetching it. */
15880 && data
+ ent
- pltgot
+ addr_size
<= data_end
15881 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15882 >> (addr_size
* 8 - 1)) != 0)
15884 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15886 if (ent
== (bfd_vma
) -1)
15887 goto sgot_print_fail
;
15892 if (data
!= NULL
&& ent
< end
)
15894 printf (_(" Local entries:\n"));
15895 printf (" %*s %10s %*s\n",
15896 addr_size
* 2, _("Address"), _("Access"),
15897 addr_size
* 2, _("Value"));
15900 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15902 if (ent
== (bfd_vma
) -1)
15903 goto sgot_print_fail
;
15915 for (entry
= dynamic_section
;
15916 /* PR 17531 file: 012-50589-0.004. */
15917 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15919 switch (entry
->d_tag
)
15921 case DT_MIPS_LIBLIST
:
15923 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15924 liblistno
* sizeof (Elf32_External_Lib
));
15926 case DT_MIPS_LIBLISTNO
:
15927 liblistno
= entry
->d_un
.d_val
;
15929 case DT_MIPS_OPTIONS
:
15930 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15932 case DT_MIPS_CONFLICT
:
15934 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15935 conflictsno
* sizeof (Elf32_External_Conflict
));
15937 case DT_MIPS_CONFLICTNO
:
15938 conflictsno
= entry
->d_un
.d_val
;
15941 pltgot
= entry
->d_un
.d_ptr
;
15943 case DT_MIPS_LOCAL_GOTNO
:
15944 local_gotno
= entry
->d_un
.d_val
;
15946 case DT_MIPS_GOTSYM
:
15947 gotsym
= entry
->d_un
.d_val
;
15949 case DT_MIPS_SYMTABNO
:
15950 symtabno
= entry
->d_un
.d_val
;
15952 case DT_MIPS_PLTGOT
:
15953 mips_pltgot
= entry
->d_un
.d_ptr
;
15956 pltrel
= entry
->d_un
.d_val
;
15959 pltrelsz
= entry
->d_un
.d_val
;
15962 jmprel
= entry
->d_un
.d_ptr
;
15968 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15970 Elf32_External_Lib
* elib
;
15973 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15975 sizeof (Elf32_External_Lib
),
15976 _("liblist section data"));
15979 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15980 "\nSection '.liblist' contains %lu entries:\n",
15981 (unsigned long) liblistno
),
15982 (unsigned long) liblistno
);
15983 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15986 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15993 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15994 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15995 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15996 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15997 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15999 tmp
= gmtime (&atime
);
16000 snprintf (timebuf
, sizeof (timebuf
),
16001 "%04u-%02u-%02uT%02u:%02u:%02u",
16002 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16003 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16005 printf ("%3lu: ", (unsigned long) cnt
);
16006 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16007 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16009 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16010 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16011 liblist
.l_version
);
16013 if (liblist
.l_flags
== 0)
16017 static const struct
16024 { " EXACT_MATCH", LL_EXACT_MATCH
},
16025 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16026 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16027 { " EXPORTS", LL_EXPORTS
},
16028 { " DELAY_LOAD", LL_DELAY_LOAD
},
16029 { " DELTA", LL_DELTA
}
16031 int flags
= liblist
.l_flags
;
16034 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16035 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16037 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16038 flags
^= l_flags_vals
[fcnt
].bit
;
16041 printf (" %#x", (unsigned int) flags
);
16053 if (options_offset
!= 0)
16055 Elf_External_Options
* eopt
;
16056 Elf_Internal_Options
* iopt
;
16057 Elf_Internal_Options
* option
;
16060 sect
= filedata
->section_headers
;
16062 /* Find the section header so that we get the size. */
16063 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16064 /* PR 17533 file: 012-277276-0.004. */
16067 error (_("No MIPS_OPTIONS header found\n"));
16071 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16072 sect
->sh_size
, _("options"));
16075 iopt
= (Elf_Internal_Options
*)
16076 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16079 error (_("Out of memory allocating space for MIPS options\n"));
16086 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16088 Elf_External_Options
* eoption
;
16090 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16092 option
->kind
= BYTE_GET (eoption
->kind
);
16093 option
->size
= BYTE_GET (eoption
->size
);
16094 option
->section
= BYTE_GET (eoption
->section
);
16095 option
->info
= BYTE_GET (eoption
->info
);
16097 /* PR 17531: file: ffa0fa3b. */
16098 if (option
->size
< sizeof (* eopt
)
16099 || offset
+ option
->size
> sect
->sh_size
)
16101 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16104 offset
+= option
->size
;
16110 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16111 "\nSection '%s' contains %d entries:\n",
16113 printable_section_name (filedata
, sect
), cnt
);
16122 switch (option
->kind
)
16125 /* This shouldn't happen. */
16126 printf (" NULL %d %lx", option
->section
, option
->info
);
16129 printf (" REGINFO ");
16130 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16133 Elf32_External_RegInfo
* ereg
;
16134 Elf32_RegInfo reginfo
;
16136 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16137 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16138 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16139 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16140 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16141 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16142 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16144 printf ("GPR %08lx GP 0x%lx\n",
16145 reginfo
.ri_gprmask
,
16146 (unsigned long) reginfo
.ri_gp_value
);
16147 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16148 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16149 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16154 Elf64_External_RegInfo
* ereg
;
16155 Elf64_Internal_RegInfo reginfo
;
16157 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16158 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16159 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16160 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16161 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16162 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16163 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16165 printf ("GPR %08lx GP 0x",
16166 reginfo
.ri_gprmask
);
16167 printf_vma (reginfo
.ri_gp_value
);
16170 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16171 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16172 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16176 case ODK_EXCEPTIONS
:
16177 fputs (" EXCEPTIONS fpe_min(", stdout
);
16178 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16179 fputs (") fpe_max(", stdout
);
16180 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16181 fputs (")", stdout
);
16183 if (option
->info
& OEX_PAGE0
)
16184 fputs (" PAGE0", stdout
);
16185 if (option
->info
& OEX_SMM
)
16186 fputs (" SMM", stdout
);
16187 if (option
->info
& OEX_FPDBUG
)
16188 fputs (" FPDBUG", stdout
);
16189 if (option
->info
& OEX_DISMISS
)
16190 fputs (" DISMISS", stdout
);
16193 fputs (" PAD ", stdout
);
16194 if (option
->info
& OPAD_PREFIX
)
16195 fputs (" PREFIX", stdout
);
16196 if (option
->info
& OPAD_POSTFIX
)
16197 fputs (" POSTFIX", stdout
);
16198 if (option
->info
& OPAD_SYMBOL
)
16199 fputs (" SYMBOL", stdout
);
16202 fputs (" HWPATCH ", stdout
);
16203 if (option
->info
& OHW_R4KEOP
)
16204 fputs (" R4KEOP", stdout
);
16205 if (option
->info
& OHW_R8KPFETCH
)
16206 fputs (" R8KPFETCH", stdout
);
16207 if (option
->info
& OHW_R5KEOP
)
16208 fputs (" R5KEOP", stdout
);
16209 if (option
->info
& OHW_R5KCVTL
)
16210 fputs (" R5KCVTL", stdout
);
16213 fputs (" FILL ", stdout
);
16214 /* XXX Print content of info word? */
16217 fputs (" TAGS ", stdout
);
16218 /* XXX Print content of info word? */
16221 fputs (" HWAND ", stdout
);
16222 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16223 fputs (" R4KEOP_CHECKED", stdout
);
16224 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16225 fputs (" R4KEOP_CLEAN", stdout
);
16228 fputs (" HWOR ", stdout
);
16229 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16230 fputs (" R4KEOP_CHECKED", stdout
);
16231 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16232 fputs (" R4KEOP_CLEAN", stdout
);
16235 printf (" GP_GROUP %#06lx self-contained %#06lx",
16236 option
->info
& OGP_GROUP
,
16237 (option
->info
& OGP_SELF
) >> 16);
16240 printf (" IDENT %#06lx self-contained %#06lx",
16241 option
->info
& OGP_GROUP
,
16242 (option
->info
& OGP_SELF
) >> 16);
16245 /* This shouldn't happen. */
16246 printf (" %3d ??? %d %lx",
16247 option
->kind
, option
->section
, option
->info
);
16251 len
= sizeof (* eopt
);
16252 while (len
< option
->size
)
16254 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16256 if (ISPRINT (datum
))
16257 printf ("%c", datum
);
16259 printf ("\\%03o", datum
);
16262 fputs ("\n", stdout
);
16264 offset
+= option
->size
;
16274 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16276 Elf32_Conflict
* iconf
;
16279 if (dynamic_symbols
== NULL
)
16281 error (_("conflict list found without a dynamic symbol table\n"));
16285 /* PR 21345 - print a slightly more helpful error message
16286 if we are sure that the cmalloc will fail. */
16287 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16289 error (_("Overlarge number of conflicts detected: %lx\n"),
16290 (long) conflictsno
);
16294 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16297 error (_("Out of memory allocating space for dynamic conflicts\n"));
16303 Elf32_External_Conflict
* econf32
;
16305 econf32
= (Elf32_External_Conflict
*)
16306 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16307 sizeof (* econf32
), _("conflict"));
16311 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16312 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16318 Elf64_External_Conflict
* econf64
;
16320 econf64
= (Elf64_External_Conflict
*)
16321 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16322 sizeof (* econf64
), _("conflict"));
16326 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16327 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16332 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16333 "\nSection '.conflict' contains %lu entries:\n",
16334 (unsigned long) conflictsno
),
16335 (unsigned long) conflictsno
);
16336 puts (_(" Num: Index Value Name"));
16338 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16340 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16342 if (iconf
[cnt
] >= num_dynamic_syms
)
16343 printf (_("<corrupt symbol index>"));
16346 Elf_Internal_Sym
* psym
;
16348 psym
= & dynamic_symbols
[iconf
[cnt
]];
16349 print_vma (psym
->st_value
, FULL_HEX
);
16351 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16352 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16354 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16362 if (pltgot
!= 0 && local_gotno
!= 0)
16364 bfd_vma ent
, local_end
, global_end
;
16366 unsigned char * data
;
16367 unsigned char * data_end
;
16371 addr_size
= (is_32bit_elf
? 4 : 8);
16372 local_end
= pltgot
+ local_gotno
* addr_size
;
16374 /* PR binutils/17533 file: 012-111227-0.004 */
16375 if (symtabno
< gotsym
)
16377 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16378 (unsigned long) gotsym
, (unsigned long) symtabno
);
16382 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16383 /* PR 17531: file: 54c91a34. */
16384 if (global_end
< local_end
)
16386 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16390 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16391 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16392 global_end
- pltgot
, 1,
16393 _("Global Offset Table data"));
16394 /* PR 12855: Null data is handled gracefully throughout. */
16395 data_end
= data
+ (global_end
- pltgot
);
16397 printf (_("\nPrimary GOT:\n"));
16398 printf (_(" Canonical gp value: "));
16399 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16402 printf (_(" Reserved entries:\n"));
16403 printf (_(" %*s %10s %*s Purpose\n"),
16404 addr_size
* 2, _("Address"), _("Access"),
16405 addr_size
* 2, _("Initial"));
16406 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16407 printf (_(" Lazy resolver\n"));
16408 if (ent
== (bfd_vma
) -1)
16409 goto got_print_fail
;
16411 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16412 This entry will be used by some runtime loaders, to store the
16413 module pointer. Otherwise this is an ordinary local entry.
16414 PR 21344: Check for the entry being fully available before
16417 && data
+ ent
- pltgot
+ addr_size
<= data_end
16418 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16419 >> (addr_size
* 8 - 1)) != 0)
16421 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16422 printf (_(" Module pointer (GNU extension)\n"));
16423 if (ent
== (bfd_vma
) -1)
16424 goto got_print_fail
;
16428 if (data
!= NULL
&& ent
< local_end
)
16430 printf (_(" Local entries:\n"));
16431 printf (" %*s %10s %*s\n",
16432 addr_size
* 2, _("Address"), _("Access"),
16433 addr_size
* 2, _("Initial"));
16434 while (ent
< local_end
)
16436 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16438 if (ent
== (bfd_vma
) -1)
16439 goto got_print_fail
;
16444 if (data
!= NULL
&& gotsym
< symtabno
)
16448 printf (_(" Global entries:\n"));
16449 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16450 addr_size
* 2, _("Address"),
16452 addr_size
* 2, _("Initial"),
16453 addr_size
* 2, _("Sym.Val."),
16455 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16456 _("Ndx"), _("Name"));
16458 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16460 for (i
= gotsym
; i
< symtabno
; i
++)
16462 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16465 if (dynamic_symbols
== NULL
)
16466 printf (_("<no dynamic symbols>"));
16467 else if (i
< num_dynamic_syms
)
16469 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16471 print_vma (psym
->st_value
, LONG_HEX
);
16472 printf (" %-7s %3s ",
16473 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16474 get_symbol_index_type (filedata
, psym
->st_shndx
));
16476 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16477 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16479 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16482 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16483 (unsigned long) i
);
16486 if (ent
== (bfd_vma
) -1)
16497 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16500 size_t offset
, rel_offset
;
16501 unsigned long count
, i
;
16502 unsigned char * data
;
16503 int addr_size
, sym_width
;
16504 Elf_Internal_Rela
* rels
;
16506 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16507 if (pltrel
== DT_RELA
)
16509 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16514 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16519 addr_size
= (is_32bit_elf
? 4 : 8);
16520 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16522 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16523 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16524 1, _("Procedure Linkage Table data"));
16528 printf ("\nPLT GOT:\n\n");
16529 printf (_(" Reserved entries:\n"));
16530 printf (_(" %*s %*s Purpose\n"),
16531 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16532 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16533 printf (_(" PLT lazy resolver\n"));
16534 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16535 printf (_(" Module pointer\n"));
16538 printf (_(" Entries:\n"));
16539 printf (" %*s %*s %*s %-7s %3s %s\n",
16540 addr_size
* 2, _("Address"),
16541 addr_size
* 2, _("Initial"),
16542 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16543 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16544 for (i
= 0; i
< count
; i
++)
16546 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16548 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16551 if (idx
>= num_dynamic_syms
)
16552 printf (_("<corrupt symbol index: %lu>"), idx
);
16555 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16557 print_vma (psym
->st_value
, LONG_HEX
);
16558 printf (" %-7s %3s ",
16559 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16560 get_symbol_index_type (filedata
, psym
->st_shndx
));
16561 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16562 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16564 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16579 process_nds32_specific (Filedata
* filedata
)
16581 Elf_Internal_Shdr
*sect
= NULL
;
16583 sect
= find_section (filedata
, ".nds32_e_flags");
16586 unsigned int *flag
;
16588 printf ("\nNDS32 elf flags section:\n");
16589 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16590 sect
->sh_size
, _("NDS32 elf flags section"));
16595 switch ((*flag
) & 0x3)
16598 printf ("(VEC_SIZE):\tNo entry.\n");
16601 printf ("(VEC_SIZE):\t4 bytes\n");
16604 printf ("(VEC_SIZE):\t16 bytes\n");
16607 printf ("(VEC_SIZE):\treserved\n");
16616 process_gnu_liblist (Filedata
* filedata
)
16618 Elf_Internal_Shdr
* section
;
16619 Elf_Internal_Shdr
* string_sec
;
16620 Elf32_External_Lib
* elib
;
16622 size_t strtab_size
;
16624 unsigned long num_liblist
;
16626 bfd_boolean res
= TRUE
;
16631 for (i
= 0, section
= filedata
->section_headers
;
16632 i
< filedata
->file_header
.e_shnum
;
16635 switch (section
->sh_type
)
16637 case SHT_GNU_LIBLIST
:
16638 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16641 elib
= (Elf32_External_Lib
*)
16642 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16643 _("liblist section data"));
16651 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16652 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16653 string_sec
->sh_size
,
16654 _("liblist string table"));
16656 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16663 strtab_size
= string_sec
->sh_size
;
16665 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16666 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16667 "\nLibrary list section '%s' contains %lu entries:\n",
16669 printable_section_name (filedata
, section
),
16672 puts (_(" Library Time Stamp Checksum Version Flags"));
16674 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16682 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16683 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16684 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16685 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16686 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16688 tmp
= gmtime (&atime
);
16689 snprintf (timebuf
, sizeof (timebuf
),
16690 "%04u-%02u-%02uT%02u:%02u:%02u",
16691 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16692 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16694 printf ("%3lu: ", (unsigned long) cnt
);
16696 printf ("%-20s", liblist
.l_name
< strtab_size
16697 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16699 printf ("%-20.20s", liblist
.l_name
< strtab_size
16700 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16701 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16702 liblist
.l_version
, liblist
.l_flags
);
16713 static const char *
16714 get_note_type (Filedata
* filedata
, unsigned e_type
)
16716 static char buff
[64];
16718 if (filedata
->file_header
.e_type
== ET_CORE
)
16722 return _("NT_AUXV (auxiliary vector)");
16724 return _("NT_PRSTATUS (prstatus structure)");
16726 return _("NT_FPREGSET (floating point registers)");
16728 return _("NT_PRPSINFO (prpsinfo structure)");
16729 case NT_TASKSTRUCT
:
16730 return _("NT_TASKSTRUCT (task structure)");
16732 return _("NT_PRXFPREG (user_xfpregs structure)");
16734 return _("NT_PPC_VMX (ppc Altivec registers)");
16736 return _("NT_PPC_VSX (ppc VSX registers)");
16738 return _("NT_PPC_TAR (ppc TAR register)");
16740 return _("NT_PPC_PPR (ppc PPR register)");
16742 return _("NT_PPC_DSCR (ppc DSCR register)");
16744 return _("NT_PPC_EBB (ppc EBB registers)");
16746 return _("NT_PPC_PMU (ppc PMU registers)");
16747 case NT_PPC_TM_CGPR
:
16748 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16749 case NT_PPC_TM_CFPR
:
16750 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16751 case NT_PPC_TM_CVMX
:
16752 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16753 case NT_PPC_TM_CVSX
:
16754 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16755 case NT_PPC_TM_SPR
:
16756 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16757 case NT_PPC_TM_CTAR
:
16758 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16759 case NT_PPC_TM_CPPR
:
16760 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16761 case NT_PPC_TM_CDSCR
:
16762 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16764 return _("NT_386_TLS (x86 TLS information)");
16765 case NT_386_IOPERM
:
16766 return _("NT_386_IOPERM (x86 I/O permissions)");
16767 case NT_X86_XSTATE
:
16768 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16769 case NT_S390_HIGH_GPRS
:
16770 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16771 case NT_S390_TIMER
:
16772 return _("NT_S390_TIMER (s390 timer register)");
16773 case NT_S390_TODCMP
:
16774 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16775 case NT_S390_TODPREG
:
16776 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16778 return _("NT_S390_CTRS (s390 control registers)");
16779 case NT_S390_PREFIX
:
16780 return _("NT_S390_PREFIX (s390 prefix register)");
16781 case NT_S390_LAST_BREAK
:
16782 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16783 case NT_S390_SYSTEM_CALL
:
16784 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16786 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16787 case NT_S390_VXRS_LOW
:
16788 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16789 case NT_S390_VXRS_HIGH
:
16790 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16791 case NT_S390_GS_CB
:
16792 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16793 case NT_S390_GS_BC
:
16794 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16796 return _("NT_ARM_VFP (arm VFP registers)");
16798 return _("NT_ARM_TLS (AArch TLS registers)");
16799 case NT_ARM_HW_BREAK
:
16800 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16801 case NT_ARM_HW_WATCH
:
16802 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16804 return _("NT_PSTATUS (pstatus structure)");
16806 return _("NT_FPREGS (floating point registers)");
16808 return _("NT_PSINFO (psinfo structure)");
16810 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16812 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16813 case NT_WIN32PSTATUS
:
16814 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16816 return _("NT_SIGINFO (siginfo_t data)");
16818 return _("NT_FILE (mapped files)");
16826 return _("NT_VERSION (version)");
16828 return _("NT_ARCH (architecture)");
16829 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16831 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16837 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16842 print_core_note (Elf_Internal_Note
*pnote
)
16844 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16845 bfd_vma count
, page_size
;
16846 unsigned char *descdata
, *filenames
, *descend
;
16848 if (pnote
->type
!= NT_FILE
)
16858 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16859 /* Still "successful". */
16864 if (pnote
->descsz
< 2 * addr_size
)
16866 error (_(" Malformed note - too short for header\n"));
16870 descdata
= (unsigned char *) pnote
->descdata
;
16871 descend
= descdata
+ pnote
->descsz
;
16873 if (descdata
[pnote
->descsz
- 1] != '\0')
16875 error (_(" Malformed note - does not end with \\0\n"));
16879 count
= byte_get (descdata
, addr_size
);
16880 descdata
+= addr_size
;
16882 page_size
= byte_get (descdata
, addr_size
);
16883 descdata
+= addr_size
;
16885 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16886 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16888 error (_(" Malformed note - too short for supplied file count\n"));
16892 printf (_(" Page size: "));
16893 print_vma (page_size
, DEC
);
16896 printf (_(" %*s%*s%*s\n"),
16897 (int) (2 + 2 * addr_size
), _("Start"),
16898 (int) (4 + 2 * addr_size
), _("End"),
16899 (int) (4 + 2 * addr_size
), _("Page Offset"));
16900 filenames
= descdata
+ count
* 3 * addr_size
;
16901 while (count
-- > 0)
16903 bfd_vma start
, end
, file_ofs
;
16905 if (filenames
== descend
)
16907 error (_(" Malformed note - filenames end too early\n"));
16911 start
= byte_get (descdata
, addr_size
);
16912 descdata
+= addr_size
;
16913 end
= byte_get (descdata
, addr_size
);
16914 descdata
+= addr_size
;
16915 file_ofs
= byte_get (descdata
, addr_size
);
16916 descdata
+= addr_size
;
16919 print_vma (start
, FULL_HEX
);
16921 print_vma (end
, FULL_HEX
);
16923 print_vma (file_ofs
, FULL_HEX
);
16924 printf ("\n %s\n", filenames
);
16926 filenames
+= 1 + strlen ((char *) filenames
);
16932 static const char *
16933 get_gnu_elf_note_type (unsigned e_type
)
16935 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16938 case NT_GNU_ABI_TAG
:
16939 return _("NT_GNU_ABI_TAG (ABI version tag)");
16941 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16942 case NT_GNU_BUILD_ID
:
16943 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16944 case NT_GNU_GOLD_VERSION
:
16945 return _("NT_GNU_GOLD_VERSION (gold version)");
16946 case NT_GNU_PROPERTY_TYPE_0
:
16947 return _("NT_GNU_PROPERTY_TYPE_0");
16948 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16949 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16950 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16951 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16954 static char buff
[64];
16956 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16963 decode_x86_compat_isa (unsigned int bitmask
)
16967 unsigned int bit
= bitmask
& (- bitmask
);
16972 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
16975 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
16978 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
16981 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
16984 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
16987 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
16990 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
16993 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
16996 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
16999 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17002 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17005 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17006 printf ("AVX512F");
17008 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17009 printf ("AVX512CD");
17011 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17012 printf ("AVX512ER");
17014 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17015 printf ("AVX512PF");
17017 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17018 printf ("AVX512VL");
17020 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17021 printf ("AVX512DQ");
17023 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17024 printf ("AVX512BW");
17027 printf (_("<unknown: %x>"), bit
);
17036 decode_x86_isa (unsigned int bitmask
)
17038 if (bitmask
== GNU_PROPERTY_X86_UINT32_VALID
)
17040 printf (_("<None>"));
17044 bitmask
&= ~GNU_PROPERTY_X86_UINT32_VALID
;
17048 unsigned int bit
= bitmask
& (- bitmask
);
17053 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17056 case GNU_PROPERTY_X86_ISA_1_SSE
:
17059 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17062 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17065 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17068 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17071 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17074 case GNU_PROPERTY_X86_ISA_1_AVX
:
17077 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17080 case GNU_PROPERTY_X86_ISA_1_FMA
:
17083 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17084 printf ("AVX512F");
17086 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17087 printf ("AVX512CD");
17089 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17090 printf ("AVX512ER");
17092 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17093 printf ("AVX512PF");
17095 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17096 printf ("AVX512VL");
17098 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17099 printf ("AVX512DQ");
17101 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17102 printf ("AVX512BW");
17104 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17105 printf ("AVX512_4FMAPS");
17107 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17108 printf ("AVX512_4VNNIW");
17110 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17111 printf ("AVX512_BITALG");
17113 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17114 printf ("AVX512_IFMA");
17116 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17117 printf ("AVX512_VBMI");
17119 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17120 printf ("AVX512_VBMI2");
17122 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17123 printf ("AVX512_VNNI");
17126 printf (_("<unknown: %x>"), bit
);
17135 decode_x86_feature_1 (unsigned int bitmask
)
17137 if (bitmask
== GNU_PROPERTY_X86_UINT32_VALID
)
17139 printf (_("<None>"));
17143 bitmask
&= ~GNU_PROPERTY_X86_UINT32_VALID
;
17147 unsigned int bit
= bitmask
& (- bitmask
);
17152 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17155 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17159 printf (_("<unknown: %x>"), bit
);
17168 decode_x86_feature_2 (unsigned int bitmask
)
17170 if (bitmask
== GNU_PROPERTY_X86_UINT32_VALID
)
17172 printf (_("<None>"));
17176 bitmask
&= ~GNU_PROPERTY_X86_UINT32_VALID
;
17180 unsigned int bit
= bitmask
& (- bitmask
);
17185 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17188 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17191 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17194 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17197 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17200 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17203 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17206 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17209 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17210 printf ("XSAVEOPT");
17212 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17216 printf (_("<unknown: %x>"), bit
);
17225 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17227 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17228 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17229 unsigned int size
= is_32bit_elf
? 4 : 8;
17231 printf (_(" Properties: "));
17233 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17235 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17239 while (ptr
< ptr_end
)
17243 unsigned int datasz
;
17245 if ((size_t) (ptr_end
- ptr
) < 8)
17247 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17251 type
= byte_get (ptr
, 4);
17252 datasz
= byte_get (ptr
+ 4, 4);
17256 if (datasz
> (size_t) (ptr_end
- ptr
))
17258 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17263 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17265 if (filedata
->file_header
.e_machine
== EM_X86_64
17266 || filedata
->file_header
.e_machine
== EM_IAMCU
17267 || filedata
->file_header
.e_machine
== EM_386
)
17269 unsigned int bitmask
;
17273 bitmask
= byte_get (ptr
, 4);
17274 if ((filedata
->file_header
.e_type
== ET_EXEC
17275 || filedata
->file_header
.e_type
== ET_DYN
)
17276 && !(bitmask
& GNU_PROPERTY_X86_UINT32_VALID
))
17277 printf ("Invalid ");
17284 case GNU_PROPERTY_X86_ISA_1_USED
:
17286 printf (_("x86 ISA used: <corrupt length: %#x> "),
17290 printf ("x86 ISA used: ");
17291 decode_x86_isa (bitmask
);
17295 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17297 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17301 printf ("x86 ISA needed: ");
17302 decode_x86_isa (bitmask
);
17306 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17308 printf (_("x86 feature: <corrupt length: %#x> "),
17312 printf ("x86 feature: ");
17313 decode_x86_feature_1 (bitmask
);
17317 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17319 printf (_("x86 feature used: <corrupt length: %#x> "),
17323 printf ("x86 feature used: ");
17324 decode_x86_feature_2 (bitmask
);
17328 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17330 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17333 printf ("x86 feature needed: ");
17334 decode_x86_feature_2 (bitmask
);
17338 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17340 printf (_("x86 ISA used: <corrupt length: %#x> "),
17344 printf ("x86 ISA used: ");
17345 decode_x86_compat_isa (bitmask
);
17349 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
17351 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17355 printf ("x86 ISA needed: ");
17356 decode_x86_compat_isa (bitmask
);
17369 case GNU_PROPERTY_STACK_SIZE
:
17370 printf (_("stack size: "));
17371 if (datasz
!= size
)
17372 printf (_("<corrupt length: %#x> "), datasz
);
17374 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17377 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17378 printf ("no copy on protected ");
17380 printf (_("<corrupt length: %#x> "), datasz
);
17388 if (type
< GNU_PROPERTY_LOPROC
)
17389 printf (_("<unknown type %#x data: "), type
);
17390 else if (type
< GNU_PROPERTY_LOUSER
)
17391 printf (_("<procesor-specific type %#x data: "), type
);
17393 printf (_("<application-specific type %#x data: "), type
);
17394 for (j
= 0; j
< datasz
; ++j
)
17395 printf ("%02x ", ptr
[j
] & 0xff);
17399 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17400 if (ptr
== ptr_end
)
17413 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17415 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17416 switch (pnote
->type
)
17418 case NT_GNU_BUILD_ID
:
17422 printf (_(" Build ID: "));
17423 for (i
= 0; i
< pnote
->descsz
; ++i
)
17424 printf ("%02x", pnote
->descdata
[i
] & 0xff);
17429 case NT_GNU_ABI_TAG
:
17431 unsigned long os
, major
, minor
, subminor
;
17432 const char *osname
;
17434 /* PR 17531: file: 030-599401-0.004. */
17435 if (pnote
->descsz
< 16)
17437 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17441 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17442 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17443 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
17444 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
17448 case GNU_ABI_TAG_LINUX
:
17451 case GNU_ABI_TAG_HURD
:
17454 case GNU_ABI_TAG_SOLARIS
:
17455 osname
= "Solaris";
17457 case GNU_ABI_TAG_FREEBSD
:
17458 osname
= "FreeBSD";
17460 case GNU_ABI_TAG_NETBSD
:
17463 case GNU_ABI_TAG_SYLLABLE
:
17464 osname
= "Syllable";
17466 case GNU_ABI_TAG_NACL
:
17470 osname
= "Unknown";
17474 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17475 major
, minor
, subminor
);
17479 case NT_GNU_GOLD_VERSION
:
17483 printf (_(" Version: "));
17484 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17485 printf ("%c", pnote
->descdata
[i
]);
17492 unsigned long num_entries
, mask
;
17494 /* Hardware capabilities information. Word 0 is the number of entries.
17495 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17496 is a series of entries, where each entry is a single byte followed
17497 by a nul terminated string. The byte gives the bit number to test
17498 if enabled in the bitmask. */
17499 printf (_(" Hardware Capabilities: "));
17500 if (pnote
->descsz
< 8)
17502 error (_("<corrupt GNU_HWCAP>\n"));
17505 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17506 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17507 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17508 /* FIXME: Add code to display the entries... */
17512 case NT_GNU_PROPERTY_TYPE_0
:
17513 print_gnu_property_note (filedata
, pnote
);
17517 /* Handle unrecognised types. An error message should have already been
17518 created by get_gnu_elf_note_type(), so all that we need to do is to
17519 display the data. */
17523 printf (_(" Description data: "));
17524 for (i
= 0; i
< pnote
->descsz
; ++i
)
17525 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17534 static const char *
17535 get_v850_elf_note_type (enum v850_notes n_type
)
17537 static char buff
[64];
17541 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17542 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17543 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17544 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17545 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17546 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17548 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17554 print_v850_note (Elf_Internal_Note
* pnote
)
17558 if (pnote
->descsz
!= 4)
17561 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17565 printf (_("not set\n"));
17569 switch (pnote
->type
)
17571 case V850_NOTE_ALIGNMENT
:
17574 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17575 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17579 case V850_NOTE_DATA_SIZE
:
17582 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17583 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17587 case V850_NOTE_FPU_INFO
:
17590 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17591 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17595 case V850_NOTE_MMU_INFO
:
17596 case V850_NOTE_CACHE_INFO
:
17597 case V850_NOTE_SIMD_INFO
:
17598 if (val
== EF_RH850_SIMD
)
17600 printf (_("yes\n"));
17606 /* An 'unknown note type' message will already have been displayed. */
17610 printf (_("unknown value: %x\n"), val
);
17615 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17617 unsigned int version
;
17619 switch (pnote
->type
)
17621 case NT_NETBSD_IDENT
:
17622 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17623 if ((version
/ 10000) % 100)
17624 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17625 version
, version
/ 100000000, (version
/ 1000000) % 100,
17626 (version
/ 10000) % 100 > 26 ? "Z" : "",
17627 'A' + (version
/ 10000) % 26);
17629 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17630 version
, version
/ 100000000, (version
/ 1000000) % 100,
17631 (version
/ 100) % 100);
17634 case NT_NETBSD_MARCH
:
17635 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17640 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17646 static const char *
17647 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17651 case NT_FREEBSD_THRMISC
:
17652 return _("NT_THRMISC (thrmisc structure)");
17653 case NT_FREEBSD_PROCSTAT_PROC
:
17654 return _("NT_PROCSTAT_PROC (proc data)");
17655 case NT_FREEBSD_PROCSTAT_FILES
:
17656 return _("NT_PROCSTAT_FILES (files data)");
17657 case NT_FREEBSD_PROCSTAT_VMMAP
:
17658 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17659 case NT_FREEBSD_PROCSTAT_GROUPS
:
17660 return _("NT_PROCSTAT_GROUPS (groups data)");
17661 case NT_FREEBSD_PROCSTAT_UMASK
:
17662 return _("NT_PROCSTAT_UMASK (umask data)");
17663 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17664 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17665 case NT_FREEBSD_PROCSTAT_OSREL
:
17666 return _("NT_PROCSTAT_OSREL (osreldate data)");
17667 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17668 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17669 case NT_FREEBSD_PROCSTAT_AUXV
:
17670 return _("NT_PROCSTAT_AUXV (auxv data)");
17671 case NT_FREEBSD_PTLWPINFO
:
17672 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17674 return get_note_type (filedata
, e_type
);
17677 static const char *
17678 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17680 static char buff
[64];
17682 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17683 return _("NetBSD procinfo structure");
17685 /* As of Jan 2002 there are no other machine-independent notes
17686 defined for NetBSD core files. If the note type is less
17687 than the start of the machine-dependent note types, we don't
17690 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17692 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17696 switch (filedata
->file_header
.e_machine
)
17698 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17699 and PT_GETFPREGS == mach+2. */
17704 case EM_SPARC32PLUS
:
17708 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17709 return _("PT_GETREGS (reg structure)");
17710 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17711 return _("PT_GETFPREGS (fpreg structure)");
17717 /* On all other arch's, PT_GETREGS == mach+1 and
17718 PT_GETFPREGS == mach+3. */
17722 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17723 return _("PT_GETREGS (reg structure)");
17724 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17725 return _("PT_GETFPREGS (fpreg structure)");
17731 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17732 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17736 static const char *
17737 get_stapsdt_note_type (unsigned e_type
)
17739 static char buff
[64];
17744 return _("NT_STAPSDT (SystemTap probe descriptors)");
17750 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17755 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17757 int addr_size
= is_32bit_elf
? 4 : 8;
17758 char *data
= pnote
->descdata
;
17759 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17760 bfd_vma pc
, base_addr
, semaphore
;
17761 char *provider
, *probe
, *arg_fmt
;
17763 pc
= byte_get ((unsigned char *) data
, addr_size
);
17765 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17767 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17771 data
+= strlen (data
) + 1;
17773 data
+= strlen (data
) + 1;
17775 data
+= strlen (data
) + 1;
17777 printf (_(" Provider: %s\n"), provider
);
17778 printf (_(" Name: %s\n"), probe
);
17779 printf (_(" Location: "));
17780 print_vma (pc
, FULL_HEX
);
17781 printf (_(", Base: "));
17782 print_vma (base_addr
, FULL_HEX
);
17783 printf (_(", Semaphore: "));
17784 print_vma (semaphore
, FULL_HEX
);
17786 printf (_(" Arguments: %s\n"), arg_fmt
);
17788 return data
== data_end
;
17791 static const char *
17792 get_ia64_vms_note_type (unsigned e_type
)
17794 static char buff
[64];
17799 return _("NT_VMS_MHD (module header)");
17801 return _("NT_VMS_LNM (language name)");
17803 return _("NT_VMS_SRC (source files)");
17805 return "NT_VMS_TITLE";
17807 return _("NT_VMS_EIDC (consistency check)");
17808 case NT_VMS_FPMODE
:
17809 return _("NT_VMS_FPMODE (FP mode)");
17810 case NT_VMS_LINKTIME
:
17811 return "NT_VMS_LINKTIME";
17812 case NT_VMS_IMGNAM
:
17813 return _("NT_VMS_IMGNAM (image name)");
17815 return _("NT_VMS_IMGID (image id)");
17816 case NT_VMS_LINKID
:
17817 return _("NT_VMS_LINKID (link id)");
17818 case NT_VMS_IMGBID
:
17819 return _("NT_VMS_IMGBID (build id)");
17820 case NT_VMS_GSTNAM
:
17821 return _("NT_VMS_GSTNAM (sym table name)");
17822 case NT_VMS_ORIG_DYN
:
17823 return "NT_VMS_ORIG_DYN";
17824 case NT_VMS_PATCHTIME
:
17825 return "NT_VMS_PATCHTIME";
17827 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17833 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17835 switch (pnote
->type
)
17838 if (pnote
->descsz
> 36)
17840 size_t l
= strlen (pnote
->descdata
+ 34);
17841 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17842 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17843 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17844 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17847 printf (_(" Invalid size\n"));
17850 printf (_(" Language: %s\n"), pnote
->descdata
);
17853 case NT_VMS_FPMODE
:
17854 printf (_(" Floating Point mode: "));
17855 printf ("0x%016" BFD_VMA_FMT
"x\n",
17856 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17858 case NT_VMS_LINKTIME
:
17859 printf (_(" Link time: "));
17861 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17864 case NT_VMS_PATCHTIME
:
17865 printf (_(" Patch time: "));
17867 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17870 case NT_VMS_ORIG_DYN
:
17871 printf (_(" Major id: %u, minor id: %u\n"),
17872 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17873 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17874 printf (_(" Last modified : "));
17876 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17877 printf (_("\n Link flags : "));
17878 printf ("0x%016" BFD_VMA_FMT
"x\n",
17879 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17880 printf (_(" Header flags: 0x%08x\n"),
17881 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17882 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17885 case NT_VMS_IMGNAM
:
17886 printf (_(" Image name: %s\n"), pnote
->descdata
);
17888 case NT_VMS_GSTNAM
:
17889 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17892 printf (_(" Image id: %s\n"), pnote
->descdata
);
17894 case NT_VMS_LINKID
:
17895 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17903 /* Find the symbol associated with a build attribute that is attached
17904 to address OFFSET. If PNAME is non-NULL then store the name of
17905 the symbol (if found) in the provided pointer, Returns NULL if a
17906 symbol could not be found. */
17908 static Elf_Internal_Sym
*
17909 get_symbol_for_build_attribute (Filedata
* filedata
,
17910 unsigned long offset
,
17911 bfd_boolean is_open_attr
,
17912 const char ** pname
)
17914 static Filedata
* saved_filedata
= NULL
;
17915 static char * strtab
;
17916 static unsigned long strtablen
;
17917 static Elf_Internal_Sym
* symtab
;
17918 static unsigned long nsyms
;
17919 Elf_Internal_Sym
* saved_sym
= NULL
;
17920 Elf_Internal_Sym
* sym
;
17922 if (filedata
->section_headers
!= NULL
17923 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17925 Elf_Internal_Shdr
* symsec
;
17927 /* Load the symbol and string sections. */
17928 for (symsec
= filedata
->section_headers
;
17929 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17932 if (symsec
->sh_type
== SHT_SYMTAB
)
17934 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17936 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17938 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17940 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17941 1, strtab_sec
->sh_size
,
17942 _("string table"));
17943 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17947 saved_filedata
= filedata
;
17950 if (symtab
== NULL
|| strtab
== NULL
)
17953 /* Find a symbol whose value matches offset. */
17954 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17955 if (sym
->st_value
== offset
)
17957 if (sym
->st_name
>= strtablen
)
17958 /* Huh ? This should not happen. */
17961 if (strtab
[sym
->st_name
] == 0)
17964 /* The AArch64 and ARM architectures define mapping symbols
17965 (eg $d, $x, $t) which we want to ignore. */
17966 if (strtab
[sym
->st_name
] == '$'
17967 && strtab
[sym
->st_name
+ 1] != 0
17968 && strtab
[sym
->st_name
+ 2] == 0)
17973 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17974 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17975 FUNC symbols entirely. */
17976 switch (ELF_ST_TYPE (sym
->st_info
))
17983 /* If the symbol has a size associated
17984 with it then we can stop searching. */
17985 sym
= symtab
+ nsyms
;
17990 /* Ignore function symbols. */
17997 switch (ELF_ST_BIND (sym
->st_info
))
18000 if (saved_sym
== NULL
18001 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18006 if (saved_sym
== NULL
)
18016 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18024 if (saved_sym
&& pname
)
18025 * pname
= strtab
+ saved_sym
->st_name
;
18030 /* Returns true iff addr1 and addr2 are in the same section. */
18033 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18035 Elf_Internal_Shdr
* a1
;
18036 Elf_Internal_Shdr
* a2
;
18038 a1
= find_section_by_address (filedata
, addr1
);
18039 a2
= find_section_by_address (filedata
, addr2
);
18041 return a1
== a2
&& a1
!= NULL
;
18045 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18046 Filedata
* filedata
)
18048 static unsigned long global_offset
= 0;
18049 static unsigned long global_end
= 0;
18050 static unsigned long func_offset
= 0;
18051 static unsigned long func_end
= 0;
18053 Elf_Internal_Sym
* sym
;
18055 unsigned long start
;
18057 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18059 switch (pnote
->descsz
)
18062 /* A zero-length description means that the range of
18063 the previous note of the same type should be used. */
18066 if (global_end
> global_offset
)
18067 printf (_(" Applies to region from %#lx to %#lx\n"),
18068 global_offset
, global_end
);
18070 printf (_(" Applies to region from %#lx\n"), global_offset
);
18074 if (func_end
> func_offset
)
18075 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18077 printf (_(" Applies to region from %#lx\n"), func_offset
);
18082 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18089 /* FIXME: We should check that version 3+ notes are being used here... */
18090 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18091 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18095 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18101 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18102 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18106 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18107 printf (_(" <invalid descsz>"));
18112 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18113 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18114 in order to avoid them being confused with the start address of the
18115 first function in the file... */
18116 if (sym
== NULL
&& is_open_attr
)
18117 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18120 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18121 end
= start
+ sym
->st_size
;
18125 /* FIXME: Need to properly allow for section alignment.
18126 16 is just the alignment used on x86_64. */
18128 && start
> BFD_ALIGN (global_end
, 16)
18129 /* Build notes are not guaranteed to be organised in order of
18130 increasing address, but we should find the all of the notes
18131 for one section in the same place. */
18132 && same_section (filedata
, start
, global_end
))
18133 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18134 global_end
+ 1, start
- 1);
18136 printf (_(" Applies to region from %#lx"), start
);
18137 global_offset
= start
;
18141 printf (_(" to %#lx"), end
);
18147 printf (_(" Applies to region from %#lx"), start
);
18148 func_offset
= start
;
18152 printf (_(" to %#lx"), end
);
18158 printf (_(" (%s)"), name
);
18165 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18167 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18168 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18169 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18171 char name_attribute
;
18172 const char * expected_types
;
18173 const char * name
= pnote
->namedata
;
18177 if (name
== NULL
|| pnote
->namesz
< 2)
18179 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18180 print_symbol (-20, _(" <corrupt name>"));
18189 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18190 if (name
[0] == 'G' && name
[1] == 'A')
18192 if (pnote
->namesz
< 4)
18194 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18195 print_symbol (-20, _(" <corrupt name>"));
18204 switch ((name_type
= * name
))
18206 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18207 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18208 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18209 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18210 printf ("%c", * name
);
18214 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
18215 print_symbol (-20, _("<unknown name type>"));
18222 switch ((name_attribute
= * name
))
18224 case GNU_BUILD_ATTRIBUTE_VERSION
:
18225 text
= _("<version>");
18226 expected_types
= string_expected
;
18229 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18230 text
= _("<stack prot>");
18231 expected_types
= "!+*";
18234 case GNU_BUILD_ATTRIBUTE_RELRO
:
18235 text
= _("<relro>");
18236 expected_types
= bool_expected
;
18239 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
18240 text
= _("<stack size>");
18241 expected_types
= number_expected
;
18244 case GNU_BUILD_ATTRIBUTE_TOOL
:
18245 text
= _("<tool>");
18246 expected_types
= string_expected
;
18249 case GNU_BUILD_ATTRIBUTE_ABI
:
18251 expected_types
= "$*";
18254 case GNU_BUILD_ATTRIBUTE_PIC
:
18256 expected_types
= number_expected
;
18259 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
18260 text
= _("<short enum>");
18261 expected_types
= bool_expected
;
18265 if (ISPRINT (* name
))
18267 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
18269 if (len
> left
&& ! do_wide
)
18271 printf ("%.*s:", len
, name
);
18277 static char tmpbuf
[128];
18279 error (_("unrecognised byte in name field: %d\n"), * name
);
18280 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
18284 expected_types
= "*$!+";
18289 left
-= printf ("%s", text
);
18291 if (strchr (expected_types
, name_type
) == NULL
)
18292 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
18294 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
18296 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18297 (unsigned long) pnote
->namesz
,
18298 (long) (name
- pnote
->namedata
));
18302 if (left
< 1 && ! do_wide
)
18307 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18309 unsigned int bytes
;
18310 unsigned long long val
= 0;
18311 unsigned int shift
= 0;
18312 char * decoded
= NULL
;
18314 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
18316 /* The -1 is because the name field is always 0 terminated, and we
18317 want to be able to ensure that the shift in the while loop below
18318 will not overflow. */
18321 if (bytes
> sizeof (val
))
18323 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18325 bytes
= sizeof (val
);
18327 /* We do not bother to warn if bytes == 0 as this can
18328 happen with some early versions of the gcc plugin. */
18332 unsigned long byte
= (* name
++) & 0xff;
18334 val
|= byte
<< shift
;
18338 switch (name_attribute
)
18340 case GNU_BUILD_ATTRIBUTE_PIC
:
18343 case 0: decoded
= "static"; break;
18344 case 1: decoded
= "pic"; break;
18345 case 2: decoded
= "PIC"; break;
18346 case 3: decoded
= "pie"; break;
18347 case 4: decoded
= "PIE"; break;
18351 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18354 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18355 case 0: decoded
= "off"; break;
18356 case 1: decoded
= "on"; break;
18357 case 2: decoded
= "all"; break;
18358 case 3: decoded
= "strong"; break;
18359 case 4: decoded
= "explicit"; break;
18367 if (decoded
!= NULL
)
18369 print_symbol (-left
, decoded
);
18380 left
-= printf ("0x%llx", val
);
18382 left
-= printf ("0x%-.*llx", left
, val
);
18386 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18387 left
-= print_symbol (- left
, name
);
18389 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18390 left
-= print_symbol (- left
, "true");
18392 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18393 left
-= print_symbol (- left
, "false");
18397 if (do_wide
&& left
> 0)
18398 printf ("%-*s", left
, " ");
18403 /* Note that by the ELF standard, the name field is already null byte
18404 terminated, and namesz includes the terminating null byte.
18405 I.E. the value of namesz for the name "FSF" is 4.
18407 If the value of namesz is zero, there is no name present. */
18410 process_note (Elf_Internal_Note
* pnote
,
18411 Filedata
* filedata
)
18413 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
18416 if (pnote
->namesz
== 0)
18417 /* If there is no note name, then use the default set of
18418 note type strings. */
18419 nt
= get_note_type (filedata
, pnote
->type
);
18421 else if (const_strneq (pnote
->namedata
, "GNU"))
18422 /* GNU-specific object file notes. */
18423 nt
= get_gnu_elf_note_type (pnote
->type
);
18425 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
18426 /* FreeBSD-specific core file notes. */
18427 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
18429 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
18430 /* NetBSD-specific core file notes. */
18431 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
18433 else if (const_strneq (pnote
->namedata
, "NetBSD"))
18434 /* NetBSD-specific core file notes. */
18435 return process_netbsd_elf_note (pnote
);
18437 else if (strneq (pnote
->namedata
, "SPU/", 4))
18439 /* SPU-specific core file notes. */
18440 nt
= pnote
->namedata
+ 4;
18444 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18445 /* VMS/ia64-specific file notes. */
18446 nt
= get_ia64_vms_note_type (pnote
->type
);
18448 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18449 nt
= get_stapsdt_note_type (pnote
->type
);
18452 /* Don't recognize this note name; just use the default set of
18453 note type strings. */
18454 nt
= get_note_type (filedata
, pnote
->type
);
18458 if (((const_strneq (pnote
->namedata
, "GA")
18459 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18460 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18461 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18462 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18463 print_gnu_build_attribute_name (pnote
);
18465 print_symbol (-20, name
);
18468 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
18470 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
18472 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18473 return print_ia64_vms_note (pnote
);
18474 else if (const_strneq (pnote
->namedata
, "GNU"))
18475 return print_gnu_note (filedata
, pnote
);
18476 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18477 return print_stapsdt_note (pnote
);
18478 else if (const_strneq (pnote
->namedata
, "CORE"))
18479 return print_core_note (pnote
);
18480 else if (((const_strneq (pnote
->namedata
, "GA")
18481 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18482 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18483 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18484 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18485 return print_gnu_build_attribute_description (pnote
, filedata
);
18491 printf (_(" description data: "));
18492 for (i
= 0; i
< pnote
->descsz
; i
++)
18493 printf ("%02x ", pnote
->descdata
[i
]);
18505 process_notes_at (Filedata
* filedata
,
18506 Elf_Internal_Shdr
* section
,
18511 Elf_External_Note
* pnotes
;
18512 Elf_External_Note
* external
;
18514 bfd_boolean res
= TRUE
;
18521 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18524 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18529 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18532 if (pnotes
== NULL
)
18538 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18540 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18541 (unsigned long) offset
, (unsigned long) length
);
18543 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18544 specifies that notes should be aligned to 4 bytes in 32-bit
18545 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18546 we also support 4 byte alignment in 64-bit objects. If section
18547 alignment is less than 4, we treate alignment as 4 bytes. */
18550 else if (align
!= 4 && align
!= 8)
18552 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18557 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18559 end
= (char *) pnotes
+ length
;
18560 while ((char *) external
< end
)
18562 Elf_Internal_Note inote
;
18565 char * temp
= NULL
;
18566 size_t data_remaining
= end
- (char *) external
;
18568 if (!is_ia64_vms (filedata
))
18570 /* PR binutils/15191
18571 Make sure that there is enough data to read. */
18572 min_notesz
= offsetof (Elf_External_Note
, name
);
18573 if (data_remaining
< min_notesz
)
18575 warn (ngettext ("Corrupt note: only %ld byte remains, "
18576 "not enough for a full note\n",
18577 "Corrupt note: only %ld bytes remain, "
18578 "not enough for a full note\n",
18580 (long) data_remaining
);
18583 data_remaining
-= min_notesz
;
18585 inote
.type
= BYTE_GET (external
->type
);
18586 inote
.namesz
= BYTE_GET (external
->namesz
);
18587 inote
.namedata
= external
->name
;
18588 inote
.descsz
= BYTE_GET (external
->descsz
);
18589 inote
.descdata
= ((char *) external
18590 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18591 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18592 next
= ((char *) external
18593 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18597 Elf64_External_VMS_Note
*vms_external
;
18599 /* PR binutils/15191
18600 Make sure that there is enough data to read. */
18601 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18602 if (data_remaining
< min_notesz
)
18604 warn (ngettext ("Corrupt note: only %ld byte remains, "
18605 "not enough for a full note\n",
18606 "Corrupt note: only %ld bytes remain, "
18607 "not enough for a full note\n",
18609 (long) data_remaining
);
18612 data_remaining
-= min_notesz
;
18614 vms_external
= (Elf64_External_VMS_Note
*) external
;
18615 inote
.type
= BYTE_GET (vms_external
->type
);
18616 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18617 inote
.namedata
= vms_external
->name
;
18618 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18619 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18620 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18621 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18624 /* PR 17531: file: 3443835e. */
18625 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18626 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18627 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18628 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18629 || ((size_t) (next
- inote
.descdata
)
18630 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18632 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18633 (unsigned long) ((char *) external
- (char *) pnotes
));
18634 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18635 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18639 external
= (Elf_External_Note
*) next
;
18641 /* Verify that name is null terminated. It appears that at least
18642 one version of Linux (RedHat 6.0) generates corefiles that don't
18643 comply with the ELF spec by failing to include the null byte in
18645 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18647 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18649 temp
= (char *) malloc (inote
.namesz
+ 1);
18652 error (_("Out of memory allocating space for inote name\n"));
18657 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18658 inote
.namedata
= temp
;
18660 inote
.namedata
[inote
.namesz
] = 0;
18663 if (! process_note (& inote
, filedata
))
18679 process_corefile_note_segments (Filedata
* filedata
)
18681 Elf_Internal_Phdr
* segment
;
18683 bfd_boolean res
= TRUE
;
18685 if (! get_program_headers (filedata
))
18688 for (i
= 0, segment
= filedata
->program_headers
;
18689 i
< filedata
->file_header
.e_phnum
;
18692 if (segment
->p_type
== PT_NOTE
)
18693 if (! process_notes_at (filedata
, NULL
,
18694 (bfd_vma
) segment
->p_offset
,
18695 (bfd_vma
) segment
->p_filesz
,
18696 (bfd_vma
) segment
->p_align
))
18704 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18706 Elf_External_Note
* pnotes
;
18707 Elf_External_Note
* external
;
18709 bfd_boolean res
= TRUE
;
18714 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18716 if (pnotes
== NULL
)
18720 end
= (char*) pnotes
+ length
;
18722 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18723 (unsigned long) offset
, (unsigned long) length
);
18725 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18727 Elf_External_Note
* next
;
18728 Elf_Internal_Note inote
;
18730 inote
.type
= BYTE_GET (external
->type
);
18731 inote
.namesz
= BYTE_GET (external
->namesz
);
18732 inote
.namedata
= external
->name
;
18733 inote
.descsz
= BYTE_GET (external
->descsz
);
18734 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18735 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18737 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18739 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18740 inote
.descdata
= inote
.namedata
;
18744 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18746 if ( ((char *) next
> end
)
18747 || ((char *) next
< (char *) pnotes
))
18749 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18750 (unsigned long) ((char *) external
- (char *) pnotes
));
18751 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18752 inote
.type
, inote
.namesz
, inote
.descsz
);
18758 /* Prevent out-of-bounds indexing. */
18759 if ( inote
.namedata
+ inote
.namesz
> end
18760 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18762 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18763 (unsigned long) ((char *) external
- (char *) pnotes
));
18764 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18765 inote
.type
, inote
.namesz
, inote
.descsz
);
18769 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18771 if (! print_v850_note (& inote
))
18774 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18775 inote
.namesz
, inote
.descsz
);
18785 process_note_sections (Filedata
* filedata
)
18787 Elf_Internal_Shdr
* section
;
18789 unsigned int n
= 0;
18790 bfd_boolean res
= TRUE
;
18792 for (i
= 0, section
= filedata
->section_headers
;
18793 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18796 if (section
->sh_type
== SHT_NOTE
)
18798 if (! process_notes_at (filedata
, section
,
18799 (bfd_vma
) section
->sh_offset
,
18800 (bfd_vma
) section
->sh_size
,
18801 (bfd_vma
) section
->sh_addralign
))
18806 if (( filedata
->file_header
.e_machine
== EM_V800
18807 || filedata
->file_header
.e_machine
== EM_V850
18808 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18809 && section
->sh_type
== SHT_RENESAS_INFO
)
18811 if (! process_v850_notes (filedata
,
18812 (bfd_vma
) section
->sh_offset
,
18813 (bfd_vma
) section
->sh_size
))
18820 /* Try processing NOTE segments instead. */
18821 return process_corefile_note_segments (filedata
);
18827 process_notes (Filedata
* filedata
)
18829 /* If we have not been asked to display the notes then do nothing. */
18833 if (filedata
->file_header
.e_type
!= ET_CORE
)
18834 return process_note_sections (filedata
);
18836 /* No program headers means no NOTE segment. */
18837 if (filedata
->file_header
.e_phnum
> 0)
18838 return process_corefile_note_segments (filedata
);
18840 printf (_("No note segments present in the core file.\n"));
18844 static unsigned char *
18845 display_public_gnu_attributes (unsigned char * start
,
18846 const unsigned char * const end
)
18848 printf (_(" Unknown GNU attribute: %s\n"), start
);
18850 start
+= strnlen ((char *) start
, end
- start
);
18851 display_raw_attribute (start
, end
);
18853 return (unsigned char *) end
;
18856 static unsigned char *
18857 display_generic_attribute (unsigned char * start
,
18859 const unsigned char * const end
)
18862 return (unsigned char *) end
;
18864 return display_tag_value (tag
, start
, end
);
18868 process_arch_specific (Filedata
* filedata
)
18873 switch (filedata
->file_header
.e_machine
)
18876 case EM_ARC_COMPACT
:
18877 case EM_ARC_COMPACT2
:
18878 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18879 display_arc_attribute
,
18880 display_generic_attribute
);
18882 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18883 display_arm_attribute
,
18884 display_generic_attribute
);
18887 case EM_MIPS_RS3_LE
:
18888 return process_mips_specific (filedata
);
18891 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18892 display_msp430x_attribute
,
18893 display_generic_attribute
);
18896 return process_nds32_specific (filedata
);
18900 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18901 display_power_gnu_attribute
);
18905 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18906 display_s390_gnu_attribute
);
18909 case EM_SPARC32PLUS
:
18911 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18912 display_sparc_gnu_attribute
);
18915 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18916 display_tic6x_attribute
,
18917 display_generic_attribute
);
18920 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18921 display_public_gnu_attributes
,
18922 display_generic_attribute
);
18927 get_file_header (Filedata
* filedata
)
18929 /* Read in the identity array. */
18930 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18933 /* Determine how to read the rest of the header. */
18934 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18939 byte_get
= byte_get_little_endian
;
18940 byte_put
= byte_put_little_endian
;
18943 byte_get
= byte_get_big_endian
;
18944 byte_put
= byte_put_big_endian
;
18948 /* For now we only support 32 bit and 64 bit ELF files. */
18949 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18951 /* Read in the rest of the header. */
18954 Elf32_External_Ehdr ehdr32
;
18956 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18959 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18960 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18961 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18962 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18963 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18964 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18965 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18966 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18967 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18968 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18969 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18970 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18971 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18975 Elf64_External_Ehdr ehdr64
;
18977 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18978 we will not be able to cope with the 64bit data found in
18979 64 ELF files. Detect this now and abort before we start
18980 overwriting things. */
18981 if (sizeof (bfd_vma
) < 8)
18983 error (_("This instance of readelf has been built without support for a\n\
18984 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18988 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18991 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18992 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18993 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18994 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18995 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18996 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18997 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18998 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18999 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19000 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19001 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19002 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19003 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19006 if (filedata
->file_header
.e_shoff
)
19008 /* There may be some extensions in the first section header. Don't
19009 bomb if we can't read it. */
19011 get_32bit_section_headers (filedata
, TRUE
);
19013 get_64bit_section_headers (filedata
, TRUE
);
19020 close_file (Filedata
* filedata
)
19024 if (filedata
->handle
)
19025 fclose (filedata
->handle
);
19031 close_debug_file (void * data
)
19033 close_file ((Filedata
*) data
);
19037 open_file (const char * pathname
)
19039 struct stat statbuf
;
19040 Filedata
* filedata
= NULL
;
19042 if (stat (pathname
, & statbuf
) < 0
19043 || ! S_ISREG (statbuf
.st_mode
))
19046 filedata
= calloc (1, sizeof * filedata
);
19047 if (filedata
== NULL
)
19050 filedata
->handle
= fopen (pathname
, "rb");
19051 if (filedata
->handle
== NULL
)
19054 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19055 filedata
->file_name
= pathname
;
19057 if (! get_file_header (filedata
))
19060 if (filedata
->file_header
.e_shoff
)
19064 /* Read the section headers again, this time for real. */
19066 res
= get_32bit_section_headers (filedata
, FALSE
);
19068 res
= get_64bit_section_headers (filedata
, FALSE
);
19079 if (filedata
->handle
)
19080 fclose (filedata
->handle
);
19087 open_debug_file (const char * pathname
)
19089 return open_file (pathname
);
19092 /* Process one ELF object file according to the command line options.
19093 This file may actually be stored in an archive. The file is
19094 positioned at the start of the ELF object. Returns TRUE if no
19095 problems were encountered, FALSE otherwise. */
19098 process_object (Filedata
* filedata
)
19100 Filedata
* separates
;
19102 bfd_boolean res
= TRUE
;
19104 if (! get_file_header (filedata
))
19106 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19110 /* Initialise per file variables. */
19111 for (i
= ARRAY_SIZE (version_info
); i
--;)
19112 version_info
[i
] = 0;
19114 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19115 dynamic_info
[i
] = 0;
19116 dynamic_info_DT_GNU_HASH
= 0;
19118 /* Process the file. */
19120 printf (_("\nFile: %s\n"), filedata
->file_name
);
19122 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19123 Note we do this even if cmdline_dump_sects is empty because we
19124 must make sure that the dump_sets array is zeroed out before each
19125 object file is processed. */
19126 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19127 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19129 if (cmdline
.num_dump_sects
> 0)
19131 if (filedata
->num_dump_sects
== 0)
19132 /* A sneaky way of allocating the dump_sects array. */
19133 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19135 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19136 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19137 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19140 if (! process_file_header (filedata
))
19143 if (! process_section_headers (filedata
))
19145 /* Without loaded section headers we cannot process lots of things. */
19146 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19148 if (! do_using_dynamic
)
19149 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19152 if (! process_section_groups (filedata
))
19153 /* Without loaded section groups we cannot process unwind. */
19156 if (process_program_headers (filedata
))
19157 process_dynamic_section (filedata
);
19161 if (! process_relocs (filedata
))
19164 if (! process_unwind (filedata
))
19167 if (! process_symbol_table (filedata
))
19170 if (! process_syminfo (filedata
))
19173 if (! process_version_sections (filedata
))
19176 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19177 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
19181 if (! process_section_contents (filedata
))
19186 if (! process_section_headers (separates
))
19188 else if (! process_section_contents (separates
))
19192 if (! process_notes (filedata
))
19195 if (! process_gnu_liblist (filedata
))
19198 if (! process_arch_specific (filedata
))
19201 free (filedata
->program_headers
);
19202 filedata
->program_headers
= NULL
;
19204 free (filedata
->section_headers
);
19205 filedata
->section_headers
= NULL
;
19207 free (filedata
->string_table
);
19208 filedata
->string_table
= NULL
;
19209 filedata
->string_table_length
= 0;
19211 if (dynamic_strings
)
19213 free (dynamic_strings
);
19214 dynamic_strings
= NULL
;
19215 dynamic_strings_length
= 0;
19218 if (dynamic_symbols
)
19220 free (dynamic_symbols
);
19221 dynamic_symbols
= NULL
;
19222 num_dynamic_syms
= 0;
19225 if (dynamic_syminfo
)
19227 free (dynamic_syminfo
);
19228 dynamic_syminfo
= NULL
;
19231 if (dynamic_section
)
19233 free (dynamic_section
);
19234 dynamic_section
= NULL
;
19237 if (section_headers_groups
)
19239 free (section_headers_groups
);
19240 section_headers_groups
= NULL
;
19243 if (section_groups
)
19245 struct group_list
* g
;
19246 struct group_list
* next
;
19248 for (i
= 0; i
< group_count
; i
++)
19250 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
19257 free (section_groups
);
19258 section_groups
= NULL
;
19261 free_debug_memory ();
19266 /* Process an ELF archive.
19267 On entry the file is positioned just after the ARMAG string.
19268 Returns TRUE upon success, FALSE otherwise. */
19271 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
19273 struct archive_info arch
;
19274 struct archive_info nested_arch
;
19276 bfd_boolean ret
= TRUE
;
19280 /* The ARCH structure is used to hold information about this archive. */
19281 arch
.file_name
= NULL
;
19283 arch
.index_array
= NULL
;
19284 arch
.sym_table
= NULL
;
19285 arch
.longnames
= NULL
;
19287 /* The NESTED_ARCH structure is used as a single-item cache of information
19288 about a nested archive (when members of a thin archive reside within
19289 another regular archive file). */
19290 nested_arch
.file_name
= NULL
;
19291 nested_arch
.file
= NULL
;
19292 nested_arch
.index_array
= NULL
;
19293 nested_arch
.sym_table
= NULL
;
19294 nested_arch
.longnames
= NULL
;
19296 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
19297 is_thin_archive
, do_archive_index
) != 0)
19303 if (do_archive_index
)
19305 if (arch
.sym_table
== NULL
)
19306 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
19309 unsigned long i
, l
;
19310 unsigned long current_pos
;
19312 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19313 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
19315 current_pos
= ftell (filedata
->handle
);
19317 for (i
= l
= 0; i
< arch
.index_num
; i
++)
19319 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
19321 char * member_name
;
19323 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
19325 if (member_name
!= NULL
)
19327 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
19329 if (qualified_name
!= NULL
)
19331 printf (_("Contents of binary %s at offset "), qualified_name
);
19332 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
19334 free (qualified_name
);
19339 if (l
>= arch
.sym_size
)
19341 error (_("%s: end of the symbol table reached before the end of the index\n"),
19342 filedata
->file_name
);
19346 /* PR 17531: file: 0b6630b2. */
19347 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
19348 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
19351 if (arch
.uses_64bit_indices
)
19356 if (l
< arch
.sym_size
)
19358 error (ngettext ("%s: %ld byte remains in the symbol table, "
19359 "but without corresponding entries in "
19360 "the index table\n",
19361 "%s: %ld bytes remain in the symbol table, "
19362 "but without corresponding entries in "
19363 "the index table\n",
19364 arch
.sym_size
- l
),
19365 filedata
->file_name
, arch
.sym_size
- l
);
19369 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
19371 error (_("%s: failed to seek back to start of object files in the archive\n"),
19372 filedata
->file_name
);
19378 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
19379 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
19380 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
19381 && !do_section_groups
&& !do_dyn_syms
)
19383 ret
= TRUE
; /* Archive index only. */
19392 char * qualified_name
;
19394 /* Read the next archive header. */
19395 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
19397 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
19400 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
19401 if (got
!= sizeof arch
.arhdr
)
19405 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
19409 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
19411 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
19416 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
19418 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
19419 if (archive_file_size
& 01)
19420 ++archive_file_size
;
19422 name
= get_archive_member_name (&arch
, &nested_arch
);
19425 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19429 namelen
= strlen (name
);
19431 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
19432 if (qualified_name
== NULL
)
19434 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19439 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
19441 /* This is a proxy for an external member of a thin archive. */
19442 Filedata
* member_filedata
;
19443 char * member_file_name
= adjust_relative_path
19444 (filedata
->file_name
, name
, namelen
);
19446 if (member_file_name
== NULL
)
19452 member_filedata
= open_file (member_file_name
);
19453 if (member_filedata
== NULL
)
19455 error (_("Input file '%s' is not readable.\n"), member_file_name
);
19456 free (member_file_name
);
19461 archive_file_offset
= arch
.nested_member_origin
;
19462 member_filedata
->file_name
= qualified_name
;
19464 if (! process_object (member_filedata
))
19467 close_file (member_filedata
);
19468 free (member_file_name
);
19470 else if (is_thin_archive
)
19472 Filedata thin_filedata
;
19474 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
19476 /* PR 15140: Allow for corrupt thin archives. */
19477 if (nested_arch
.file
== NULL
)
19479 error (_("%s: contains corrupt thin archive: %s\n"),
19480 filedata
->file_name
, name
);
19485 /* This is a proxy for a member of a nested archive. */
19486 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19488 /* The nested archive file will have been opened and setup by
19489 get_archive_member_name. */
19490 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19492 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19497 thin_filedata
.handle
= nested_arch
.file
;
19498 thin_filedata
.file_name
= qualified_name
;
19500 if (! process_object (& thin_filedata
))
19505 archive_file_offset
= arch
.next_arhdr_offset
;
19506 arch
.next_arhdr_offset
+= archive_file_size
;
19508 filedata
->file_name
= qualified_name
;
19509 if (! process_object (filedata
))
19513 if (filedata
->dump_sects
!= NULL
)
19515 free (filedata
->dump_sects
);
19516 filedata
->dump_sects
= NULL
;
19517 filedata
->num_dump_sects
= 0;
19520 free (qualified_name
);
19524 if (nested_arch
.file
!= NULL
)
19525 fclose (nested_arch
.file
);
19526 release_archive (&nested_arch
);
19527 release_archive (&arch
);
19533 process_file (char * file_name
)
19535 Filedata
* filedata
= NULL
;
19536 struct stat statbuf
;
19537 char armag
[SARMAG
];
19538 bfd_boolean ret
= TRUE
;
19540 if (stat (file_name
, &statbuf
) < 0)
19542 if (errno
== ENOENT
)
19543 error (_("'%s': No such file\n"), file_name
);
19545 error (_("Could not locate '%s'. System error message: %s\n"),
19546 file_name
, strerror (errno
));
19550 if (! S_ISREG (statbuf
.st_mode
))
19552 error (_("'%s' is not an ordinary file\n"), file_name
);
19556 filedata
= calloc (1, sizeof * filedata
);
19557 if (filedata
== NULL
)
19559 error (_("Out of memory allocating file data structure\n"));
19563 filedata
->file_name
= file_name
;
19564 filedata
->handle
= fopen (file_name
, "rb");
19565 if (filedata
->handle
== NULL
)
19567 error (_("Input file '%s' is not readable.\n"), file_name
);
19572 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19574 error (_("%s: Failed to read file's magic number\n"), file_name
);
19575 fclose (filedata
->handle
);
19580 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19582 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19584 if (! process_archive (filedata
, FALSE
))
19587 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19589 if ( ! process_archive (filedata
, TRUE
))
19594 if (do_archive_index
)
19595 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19598 rewind (filedata
->handle
);
19599 archive_file_size
= archive_file_offset
= 0;
19601 if (! process_object (filedata
))
19605 fclose (filedata
->handle
);
19611 #ifdef SUPPORT_DISASSEMBLY
19612 /* Needed by the i386 disassembler. For extra credit, someone could
19613 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19617 print_address (unsigned int addr
, FILE * outfile
)
19619 fprintf (outfile
,"0x%8.8x", addr
);
19622 /* Needed by the i386 disassembler. */
19625 db_task_printsym (unsigned int addr
)
19627 print_address (addr
, stderr
);
19632 main (int argc
, char ** argv
)
19636 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19637 setlocale (LC_MESSAGES
, "");
19639 #if defined (HAVE_SETLOCALE)
19640 setlocale (LC_CTYPE
, "");
19642 bindtextdomain (PACKAGE
, LOCALEDIR
);
19643 textdomain (PACKAGE
);
19645 expandargv (&argc
, &argv
);
19647 cmdline
.file_name
= "<cmdline>";
19648 parse_args (& cmdline
, argc
, argv
);
19650 if (optind
< (argc
- 1))
19652 else if (optind
>= argc
)
19654 warn (_("Nothing to do.\n"));
19659 while (optind
< argc
)
19660 if (! process_file (argv
[optind
++]))
19663 if (cmdline
.dump_sects
!= NULL
)
19664 free (cmdline
.dump_sects
);
19666 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;