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_LS3A
: strcat (buf
, ", loongson-3a"); break;
3408 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3409 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3410 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3411 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3412 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3414 /* We simply ignore the field in this case to avoid confusion:
3415 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3418 default: strcat (buf
, _(", unknown CPU")); break;
3421 switch ((e_flags
& EF_MIPS_ABI
))
3423 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3424 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3425 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3426 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3428 /* We simply ignore the field in this case to avoid confusion:
3429 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3430 This means it is likely to be an o32 file, but not for
3433 default: strcat (buf
, _(", unknown ABI")); break;
3436 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3437 strcat (buf
, ", mdmx");
3439 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3440 strcat (buf
, ", mips16");
3442 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3443 strcat (buf
, ", micromips");
3445 switch ((e_flags
& EF_MIPS_ARCH
))
3447 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3448 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3449 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3450 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3451 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3452 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3453 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3454 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3455 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3456 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3457 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3458 default: strcat (buf
, _(", unknown ISA")); break;
3463 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3467 switch (EF_NFP_MACH (e_flags
))
3469 case E_NFP_MACH_3200
:
3470 strcat (buf
, ", NFP-32xx");
3472 case E_NFP_MACH_6000
:
3473 strcat (buf
, ", NFP-6xxx");
3479 if (e_flags
& EF_RISCV_RVC
)
3480 strcat (buf
, ", RVC");
3482 if (e_flags
& EF_RISCV_RVE
)
3483 strcat (buf
, ", RVE");
3485 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3487 case EF_RISCV_FLOAT_ABI_SOFT
:
3488 strcat (buf
, ", soft-float ABI");
3491 case EF_RISCV_FLOAT_ABI_SINGLE
:
3492 strcat (buf
, ", single-float ABI");
3495 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3496 strcat (buf
, ", double-float ABI");
3499 case EF_RISCV_FLOAT_ABI_QUAD
:
3500 strcat (buf
, ", quad-float ABI");
3506 switch ((e_flags
& EF_SH_MACH_MASK
))
3508 case EF_SH1
: strcat (buf
, ", sh1"); break;
3509 case EF_SH2
: strcat (buf
, ", sh2"); break;
3510 case EF_SH3
: strcat (buf
, ", sh3"); break;
3511 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3512 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3513 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3514 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3515 case EF_SH4
: strcat (buf
, ", sh4"); break;
3516 case EF_SH5
: strcat (buf
, ", sh5"); break;
3517 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3518 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3519 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3520 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3521 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3522 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3523 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3524 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3525 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3526 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3527 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3528 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3529 default: strcat (buf
, _(", unknown ISA")); break;
3532 if (e_flags
& EF_SH_PIC
)
3533 strcat (buf
, ", pic");
3535 if (e_flags
& EF_SH_FDPIC
)
3536 strcat (buf
, ", fdpic");
3540 if (e_flags
& EF_OR1K_NODELAY
)
3541 strcat (buf
, ", no delay");
3545 if (e_flags
& EF_SPARC_32PLUS
)
3546 strcat (buf
, ", v8+");
3548 if (e_flags
& EF_SPARC_SUN_US1
)
3549 strcat (buf
, ", ultrasparcI");
3551 if (e_flags
& EF_SPARC_SUN_US3
)
3552 strcat (buf
, ", ultrasparcIII");
3554 if (e_flags
& EF_SPARC_HAL_R1
)
3555 strcat (buf
, ", halr1");
3557 if (e_flags
& EF_SPARC_LEDATA
)
3558 strcat (buf
, ", ledata");
3560 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3561 strcat (buf
, ", tso");
3563 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3564 strcat (buf
, ", pso");
3566 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3567 strcat (buf
, ", rmo");
3571 switch (e_flags
& EF_PARISC_ARCH
)
3573 case EFA_PARISC_1_0
:
3574 strcpy (buf
, ", PA-RISC 1.0");
3576 case EFA_PARISC_1_1
:
3577 strcpy (buf
, ", PA-RISC 1.1");
3579 case EFA_PARISC_2_0
:
3580 strcpy (buf
, ", PA-RISC 2.0");
3585 if (e_flags
& EF_PARISC_TRAPNIL
)
3586 strcat (buf
, ", trapnil");
3587 if (e_flags
& EF_PARISC_EXT
)
3588 strcat (buf
, ", ext");
3589 if (e_flags
& EF_PARISC_LSB
)
3590 strcat (buf
, ", lsb");
3591 if (e_flags
& EF_PARISC_WIDE
)
3592 strcat (buf
, ", wide");
3593 if (e_flags
& EF_PARISC_NO_KABP
)
3594 strcat (buf
, ", no kabp");
3595 if (e_flags
& EF_PARISC_LAZYSWAP
)
3596 strcat (buf
, ", lazyswap");
3601 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3602 strcat (buf
, ", new calling convention");
3604 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3605 strcat (buf
, ", gnu calling convention");
3609 if ((e_flags
& EF_IA_64_ABI64
))
3610 strcat (buf
, ", 64-bit");
3612 strcat (buf
, ", 32-bit");
3613 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3614 strcat (buf
, ", reduced fp model");
3615 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3616 strcat (buf
, ", no function descriptors, constant gp");
3617 else if ((e_flags
& EF_IA_64_CONS_GP
))
3618 strcat (buf
, ", constant gp");
3619 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3620 strcat (buf
, ", absolute");
3621 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3623 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3624 strcat (buf
, ", vms_linkages");
3625 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3627 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3629 case EF_IA_64_VMS_COMCOD_WARNING
:
3630 strcat (buf
, ", warning");
3632 case EF_IA_64_VMS_COMCOD_ERROR
:
3633 strcat (buf
, ", error");
3635 case EF_IA_64_VMS_COMCOD_ABORT
:
3636 strcat (buf
, ", abort");
3639 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3640 e_flags
& EF_IA_64_VMS_COMCOD
);
3641 strcat (buf
, ", <unknown>");
3647 if ((e_flags
& EF_VAX_NONPIC
))
3648 strcat (buf
, ", non-PIC");
3649 if ((e_flags
& EF_VAX_DFLOAT
))
3650 strcat (buf
, ", D-Float");
3651 if ((e_flags
& EF_VAX_GFLOAT
))
3652 strcat (buf
, ", G-Float");
3656 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3657 strcat (buf
, ", mcm");
3658 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3659 strcat (buf
, ", mcm24");
3660 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3661 strcat (buf
, ", gr6");
3665 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3667 case E_FLAG_RL78_ANY_CPU
: break;
3668 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3669 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3670 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3672 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3673 strcat (buf
, ", 64-bit doubles");
3677 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3678 strcat (buf
, ", 64-bit doubles");
3679 if (e_flags
& E_FLAG_RX_DSP
)
3680 strcat (buf
, ", dsp");
3681 if (e_flags
& E_FLAG_RX_PID
)
3682 strcat (buf
, ", pid");
3683 if (e_flags
& E_FLAG_RX_ABI
)
3684 strcat (buf
, ", RX ABI");
3685 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3686 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3687 ? ", uses String instructions" : ", bans String instructions");
3688 if (e_flags
& E_FLAG_RX_V2
)
3689 strcat (buf
, ", V2");
3693 if (e_flags
& EF_S390_HIGH_GPRS
)
3694 strcat (buf
, ", highgprs");
3698 if ((e_flags
& EF_C6000_REL
))
3699 strcat (buf
, ", relocatable module");
3703 strcat (buf
, _(": architecture variant: "));
3704 switch (e_flags
& EF_MSP430_MACH
)
3706 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3707 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3708 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3709 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3710 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3711 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3712 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3713 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3714 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3715 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3716 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3717 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3718 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3719 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3720 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3722 strcat (buf
, _(": unknown")); break;
3725 if (e_flags
& ~ EF_MSP430_MACH
)
3726 strcat (buf
, _(": unknown extra flag bits also present"));
3734 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3736 static char buff
[32];
3740 case ELFOSABI_NONE
: return "UNIX - System V";
3741 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3742 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3743 case ELFOSABI_GNU
: return "UNIX - GNU";
3744 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3745 case ELFOSABI_AIX
: return "UNIX - AIX";
3746 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3747 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3748 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3749 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3750 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3751 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3752 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3753 case ELFOSABI_AROS
: return "AROS";
3754 case ELFOSABI_FENIXOS
: return "FenixOS";
3755 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3756 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3759 switch (filedata
->file_header
.e_machine
)
3764 case ELFOSABI_ARM
: return "ARM";
3765 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3776 case ELFOSABI_STANDALONE
: return _("Standalone App");
3785 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3786 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3795 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3801 get_aarch64_segment_type (unsigned long type
)
3805 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3806 default: return NULL
;
3811 get_arm_segment_type (unsigned long type
)
3815 case PT_ARM_EXIDX
: return "EXIDX";
3816 default: return NULL
;
3821 get_s390_segment_type (unsigned long type
)
3825 case PT_S390_PGSTE
: return "S390_PGSTE";
3826 default: return NULL
;
3831 get_mips_segment_type (unsigned long type
)
3835 case PT_MIPS_REGINFO
: return "REGINFO";
3836 case PT_MIPS_RTPROC
: return "RTPROC";
3837 case PT_MIPS_OPTIONS
: return "OPTIONS";
3838 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3839 default: return NULL
;
3844 get_parisc_segment_type (unsigned long type
)
3848 case PT_HP_TLS
: return "HP_TLS";
3849 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3850 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3851 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3852 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3853 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3854 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3855 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3856 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3857 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3858 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3859 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3860 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3861 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3862 case PT_HP_STACK
: return "HP_STACK";
3863 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3864 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3865 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3866 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3867 default: return NULL
;
3872 get_ia64_segment_type (unsigned long type
)
3876 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3877 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3878 case PT_HP_TLS
: return "HP_TLS";
3879 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3880 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3881 case PT_IA_64_HP_STACK
: return "HP_STACK";
3882 default: return NULL
;
3887 get_tic6x_segment_type (unsigned long type
)
3891 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3892 default: return NULL
;
3897 get_solaris_segment_type (unsigned long type
)
3901 case 0x6464e550: return "PT_SUNW_UNWIND";
3902 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3903 case 0x6ffffff7: return "PT_LOSUNW";
3904 case 0x6ffffffa: return "PT_SUNWBSS";
3905 case 0x6ffffffb: return "PT_SUNWSTACK";
3906 case 0x6ffffffc: return "PT_SUNWDTRACE";
3907 case 0x6ffffffd: return "PT_SUNWCAP";
3908 case 0x6fffffff: return "PT_HISUNW";
3909 default: return NULL
;
3914 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3916 static char buff
[32];
3920 case PT_NULL
: return "NULL";
3921 case PT_LOAD
: return "LOAD";
3922 case PT_DYNAMIC
: return "DYNAMIC";
3923 case PT_INTERP
: return "INTERP";
3924 case PT_NOTE
: return "NOTE";
3925 case PT_SHLIB
: return "SHLIB";
3926 case PT_PHDR
: return "PHDR";
3927 case PT_TLS
: return "TLS";
3928 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3929 case PT_GNU_STACK
: return "GNU_STACK";
3930 case PT_GNU_RELRO
: return "GNU_RELRO";
3933 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3935 sprintf (buff
, "GNU_MBIND+%#lx",
3936 p_type
- PT_GNU_MBIND_LO
);
3938 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3940 const char * result
;
3942 switch (filedata
->file_header
.e_machine
)
3945 result
= get_aarch64_segment_type (p_type
);
3948 result
= get_arm_segment_type (p_type
);
3951 case EM_MIPS_RS3_LE
:
3952 result
= get_mips_segment_type (p_type
);
3955 result
= get_parisc_segment_type (p_type
);
3958 result
= get_ia64_segment_type (p_type
);
3961 result
= get_tic6x_segment_type (p_type
);
3965 result
= get_s390_segment_type (p_type
);
3975 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3977 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3979 const char * result
;
3981 switch (filedata
->file_header
.e_machine
)
3984 result
= get_parisc_segment_type (p_type
);
3987 result
= get_ia64_segment_type (p_type
);
3990 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3991 result
= get_solaris_segment_type (p_type
);
4000 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4003 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4010 get_arc_section_type_name (unsigned int sh_type
)
4014 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4022 get_mips_section_type_name (unsigned int sh_type
)
4026 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4027 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4028 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4029 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4030 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4031 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4032 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4033 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4034 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4035 case SHT_MIPS_RELD
: return "MIPS_RELD";
4036 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4037 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4038 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4039 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4040 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4041 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4042 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4043 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4044 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4045 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4046 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4047 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4048 case SHT_MIPS_LINE
: return "MIPS_LINE";
4049 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4050 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4051 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4052 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4053 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4054 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4055 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4056 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4057 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4058 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4059 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4060 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4061 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4062 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4063 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4064 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4065 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4073 get_parisc_section_type_name (unsigned int sh_type
)
4077 case SHT_PARISC_EXT
: return "PARISC_EXT";
4078 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4079 case SHT_PARISC_DOC
: return "PARISC_DOC";
4080 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4081 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4082 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4083 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4084 default: return NULL
;
4089 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4091 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4092 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4093 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4097 case SHT_IA_64_EXT
: return "IA_64_EXT";
4098 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4099 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4100 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4101 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4102 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4103 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4104 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4105 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4106 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4114 get_x86_64_section_type_name (unsigned int sh_type
)
4118 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4119 default: return NULL
;
4124 get_aarch64_section_type_name (unsigned int sh_type
)
4128 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4129 default: return NULL
;
4134 get_arm_section_type_name (unsigned int sh_type
)
4138 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4139 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4140 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4141 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4142 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4143 default: return NULL
;
4148 get_tic6x_section_type_name (unsigned int sh_type
)
4152 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4153 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4154 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4155 case SHT_TI_ICODE
: return "TI_ICODE";
4156 case SHT_TI_XREF
: return "TI_XREF";
4157 case SHT_TI_HANDLER
: return "TI_HANDLER";
4158 case SHT_TI_INITINFO
: return "TI_INITINFO";
4159 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4160 default: return NULL
;
4165 get_msp430x_section_type_name (unsigned int sh_type
)
4169 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4170 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4171 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4172 default: return NULL
;
4177 get_nfp_section_type_name (unsigned int sh_type
)
4181 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4182 case SHT_NFP_INITREG
: return "NFP_INITREG";
4183 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4184 default: return NULL
;
4189 get_v850_section_type_name (unsigned int sh_type
)
4193 case SHT_V850_SCOMMON
: return "V850 Small Common";
4194 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4195 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4196 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4197 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4198 default: return NULL
;
4203 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4205 static char buff
[32];
4206 const char * result
;
4210 case SHT_NULL
: return "NULL";
4211 case SHT_PROGBITS
: return "PROGBITS";
4212 case SHT_SYMTAB
: return "SYMTAB";
4213 case SHT_STRTAB
: return "STRTAB";
4214 case SHT_RELA
: return "RELA";
4215 case SHT_HASH
: return "HASH";
4216 case SHT_DYNAMIC
: return "DYNAMIC";
4217 case SHT_NOTE
: return "NOTE";
4218 case SHT_NOBITS
: return "NOBITS";
4219 case SHT_REL
: return "REL";
4220 case SHT_SHLIB
: return "SHLIB";
4221 case SHT_DYNSYM
: return "DYNSYM";
4222 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4223 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4224 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4225 case SHT_GNU_HASH
: return "GNU_HASH";
4226 case SHT_GROUP
: return "GROUP";
4227 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4228 case SHT_GNU_verdef
: return "VERDEF";
4229 case SHT_GNU_verneed
: return "VERNEED";
4230 case SHT_GNU_versym
: return "VERSYM";
4231 case 0x6ffffff0: return "VERSYM";
4232 case 0x6ffffffc: return "VERDEF";
4233 case 0x7ffffffd: return "AUXILIARY";
4234 case 0x7fffffff: return "FILTER";
4235 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4238 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4240 switch (filedata
->file_header
.e_machine
)
4243 case EM_ARC_COMPACT
:
4244 case EM_ARC_COMPACT2
:
4245 result
= get_arc_section_type_name (sh_type
);
4248 case EM_MIPS_RS3_LE
:
4249 result
= get_mips_section_type_name (sh_type
);
4252 result
= get_parisc_section_type_name (sh_type
);
4255 result
= get_ia64_section_type_name (filedata
, sh_type
);
4260 result
= get_x86_64_section_type_name (sh_type
);
4263 result
= get_aarch64_section_type_name (sh_type
);
4266 result
= get_arm_section_type_name (sh_type
);
4269 result
= get_tic6x_section_type_name (sh_type
);
4272 result
= get_msp430x_section_type_name (sh_type
);
4275 result
= get_nfp_section_type_name (sh_type
);
4279 case EM_CYGNUS_V850
:
4280 result
= get_v850_section_type_name (sh_type
);
4290 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4292 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4294 switch (filedata
->file_header
.e_machine
)
4297 result
= get_ia64_section_type_name (filedata
, sh_type
);
4300 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4301 result
= get_solaris_section_type (sh_type
);
4306 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4307 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4308 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4309 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4321 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4323 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4325 switch (filedata
->file_header
.e_machine
)
4329 case EM_CYGNUS_V850
:
4330 result
= get_v850_section_type_name (sh_type
);
4340 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4343 /* This message is probably going to be displayed in a 15
4344 character wide field, so put the hex value first. */
4345 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4351 #define OPTION_DEBUG_DUMP 512
4352 #define OPTION_DYN_SYMS 513
4353 #define OPTION_DWARF_DEPTH 514
4354 #define OPTION_DWARF_START 515
4355 #define OPTION_DWARF_CHECK 516
4357 static struct option options
[] =
4359 {"all", no_argument
, 0, 'a'},
4360 {"file-header", no_argument
, 0, 'h'},
4361 {"program-headers", no_argument
, 0, 'l'},
4362 {"headers", no_argument
, 0, 'e'},
4363 {"histogram", no_argument
, 0, 'I'},
4364 {"segments", no_argument
, 0, 'l'},
4365 {"sections", no_argument
, 0, 'S'},
4366 {"section-headers", no_argument
, 0, 'S'},
4367 {"section-groups", no_argument
, 0, 'g'},
4368 {"section-details", no_argument
, 0, 't'},
4369 {"full-section-name",no_argument
, 0, 'N'},
4370 {"symbols", no_argument
, 0, 's'},
4371 {"syms", no_argument
, 0, 's'},
4372 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4373 {"relocs", no_argument
, 0, 'r'},
4374 {"notes", no_argument
, 0, 'n'},
4375 {"dynamic", no_argument
, 0, 'd'},
4376 {"arch-specific", no_argument
, 0, 'A'},
4377 {"version-info", no_argument
, 0, 'V'},
4378 {"use-dynamic", no_argument
, 0, 'D'},
4379 {"unwind", no_argument
, 0, 'u'},
4380 {"archive-index", no_argument
, 0, 'c'},
4381 {"hex-dump", required_argument
, 0, 'x'},
4382 {"relocated-dump", required_argument
, 0, 'R'},
4383 {"string-dump", required_argument
, 0, 'p'},
4384 {"decompress", no_argument
, 0, 'z'},
4385 #ifdef SUPPORT_DISASSEMBLY
4386 {"instruction-dump", required_argument
, 0, 'i'},
4388 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4390 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4391 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4392 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4394 {"version", no_argument
, 0, 'v'},
4395 {"wide", no_argument
, 0, 'W'},
4396 {"help", no_argument
, 0, 'H'},
4397 {0, no_argument
, 0, 0}
4401 usage (FILE * stream
)
4403 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4404 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4405 fprintf (stream
, _(" Options are:\n\
4406 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4407 -h --file-header Display the ELF file header\n\
4408 -l --program-headers Display the program headers\n\
4409 --segments An alias for --program-headers\n\
4410 -S --section-headers Display the sections' header\n\
4411 --sections An alias for --section-headers\n\
4412 -g --section-groups Display the section groups\n\
4413 -t --section-details Display the section details\n\
4414 -e --headers Equivalent to: -h -l -S\n\
4415 -s --syms Display the symbol table\n\
4416 --symbols An alias for --syms\n\
4417 --dyn-syms Display the dynamic symbol table\n\
4418 -n --notes Display the core notes (if present)\n\
4419 -r --relocs Display the relocations (if present)\n\
4420 -u --unwind Display the unwind info (if present)\n\
4421 -d --dynamic Display the dynamic section (if present)\n\
4422 -V --version-info Display the version sections (if present)\n\
4423 -A --arch-specific Display architecture specific information (if any)\n\
4424 -c --archive-index Display the symbol/file index in an archive\n\
4425 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4426 -x --hex-dump=<number|name>\n\
4427 Dump the contents of section <number|name> as bytes\n\
4428 -p --string-dump=<number|name>\n\
4429 Dump the contents of section <number|name> as strings\n\
4430 -R --relocated-dump=<number|name>\n\
4431 Dump the contents of section <number|name> as relocated bytes\n\
4432 -z --decompress Decompress section before dumping it\n\
4433 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4434 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4435 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4436 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4437 =addr,=cu_index,=links,=follow-links]\n\
4438 Display the contents of DWARF debug sections\n"));
4439 fprintf (stream
, _("\
4440 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4441 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4443 #ifdef SUPPORT_DISASSEMBLY
4444 fprintf (stream
, _("\
4445 -i --instruction-dump=<number|name>\n\
4446 Disassemble the contents of section <number|name>\n"));
4448 fprintf (stream
, _("\
4449 -I --histogram Display histogram of bucket list lengths\n\
4450 -W --wide Allow output width to exceed 80 characters\n\
4451 @<file> Read options from <file>\n\
4452 -H --help Display this information\n\
4453 -v --version Display the version number of readelf\n"));
4455 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4456 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4458 exit (stream
== stdout
? 0 : 1);
4461 /* Record the fact that the user wants the contents of section number
4462 SECTION to be displayed using the method(s) encoded as flags bits
4463 in TYPE. Note, TYPE can be zero if we are creating the array for
4467 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4469 if (section
>= filedata
->num_dump_sects
)
4471 dump_type
* new_dump_sects
;
4473 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4474 sizeof (* new_dump_sects
));
4476 if (new_dump_sects
== NULL
)
4477 error (_("Out of memory allocating dump request table.\n"));
4480 if (filedata
->dump_sects
)
4482 /* Copy current flag settings. */
4483 memcpy (new_dump_sects
, filedata
->dump_sects
,
4484 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4486 free (filedata
->dump_sects
);
4489 filedata
->dump_sects
= new_dump_sects
;
4490 filedata
->num_dump_sects
= section
+ 1;
4494 if (filedata
->dump_sects
)
4495 filedata
->dump_sects
[section
] |= type
;
4498 /* Request a dump by section name. */
4501 request_dump_byname (const char * section
, dump_type type
)
4503 struct dump_list_entry
* new_request
;
4505 new_request
= (struct dump_list_entry
*)
4506 malloc (sizeof (struct dump_list_entry
));
4508 error (_("Out of memory allocating dump request table.\n"));
4510 new_request
->name
= strdup (section
);
4511 if (!new_request
->name
)
4512 error (_("Out of memory allocating dump request table.\n"));
4514 new_request
->type
= type
;
4516 new_request
->next
= dump_sects_byname
;
4517 dump_sects_byname
= new_request
;
4521 request_dump (Filedata
* filedata
, dump_type type
)
4527 section
= strtoul (optarg
, & cp
, 0);
4529 if (! *cp
&& section
>= 0)
4530 request_dump_bynumber (filedata
, section
, type
);
4532 request_dump_byname (optarg
, type
);
4536 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4543 while ((c
= getopt_long
4544 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4562 do_section_groups
= TRUE
;
4565 do_histogram
= TRUE
;
4570 do_section_groups
= TRUE
;
4575 do_section_details
= TRUE
;
4586 do_using_dynamic
= TRUE
;
4610 do_histogram
= TRUE
;
4616 do_archive_index
= TRUE
;
4619 request_dump (filedata
, HEX_DUMP
);
4622 request_dump (filedata
, STRING_DUMP
);
4625 request_dump (filedata
, RELOC_DUMP
);
4628 decompress_dumps
= TRUE
;
4634 do_debugging
= TRUE
;
4635 dwarf_select_sections_all ();
4639 do_debugging
= FALSE
;
4640 dwarf_select_sections_by_letters (optarg
);
4643 case OPTION_DEBUG_DUMP
:
4646 do_debugging
= TRUE
;
4649 do_debugging
= FALSE
;
4650 dwarf_select_sections_by_names (optarg
);
4653 case OPTION_DWARF_DEPTH
:
4657 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4660 case OPTION_DWARF_START
:
4664 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4667 case OPTION_DWARF_CHECK
:
4670 case OPTION_DYN_SYMS
:
4673 #ifdef SUPPORT_DISASSEMBLY
4675 request_dump (filedata
, DISASS_DUMP
);
4679 print_version (program_name
);
4688 /* xgettext:c-format */
4689 error (_("Invalid option '-%c'\n"), c
);
4696 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4697 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4698 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4699 && !do_section_groups
&& !do_archive_index
4705 get_elf_class (unsigned int elf_class
)
4707 static char buff
[32];
4711 case ELFCLASSNONE
: return _("none");
4712 case ELFCLASS32
: return "ELF32";
4713 case ELFCLASS64
: return "ELF64";
4715 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4721 get_data_encoding (unsigned int encoding
)
4723 static char buff
[32];
4727 case ELFDATANONE
: return _("none");
4728 case ELFDATA2LSB
: return _("2's complement, little endian");
4729 case ELFDATA2MSB
: return _("2's complement, big endian");
4731 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4736 /* Decode the data held in 'filedata->file_header'. */
4739 process_file_header (Filedata
* filedata
)
4741 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4743 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4744 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4745 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4746 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4749 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4753 init_dwarf_regnames (header
->e_machine
);
4759 printf (_("ELF Header:\n"));
4760 printf (_(" Magic: "));
4761 for (i
= 0; i
< EI_NIDENT
; i
++)
4762 printf ("%2.2x ", header
->e_ident
[i
]);
4764 printf (_(" Class: %s\n"),
4765 get_elf_class (header
->e_ident
[EI_CLASS
]));
4766 printf (_(" Data: %s\n"),
4767 get_data_encoding (header
->e_ident
[EI_DATA
]));
4768 printf (_(" Version: %d%s\n"),
4769 header
->e_ident
[EI_VERSION
],
4770 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4772 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4775 printf (_(" OS/ABI: %s\n"),
4776 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4777 printf (_(" ABI Version: %d\n"),
4778 header
->e_ident
[EI_ABIVERSION
]);
4779 printf (_(" Type: %s\n"),
4780 get_file_type (header
->e_type
));
4781 printf (_(" Machine: %s\n"),
4782 get_machine_name (header
->e_machine
));
4783 printf (_(" Version: 0x%lx\n"),
4786 printf (_(" Entry point address: "));
4787 print_vma (header
->e_entry
, PREFIX_HEX
);
4788 printf (_("\n Start of program headers: "));
4789 print_vma (header
->e_phoff
, DEC
);
4790 printf (_(" (bytes into file)\n Start of section headers: "));
4791 print_vma (header
->e_shoff
, DEC
);
4792 printf (_(" (bytes into file)\n"));
4794 printf (_(" Flags: 0x%lx%s\n"),
4796 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4797 printf (_(" Size of this header: %u (bytes)\n"),
4799 printf (_(" Size of program headers: %u (bytes)\n"),
4800 header
->e_phentsize
);
4801 printf (_(" Number of program headers: %u"),
4803 if (filedata
->section_headers
!= NULL
4804 && header
->e_phnum
== PN_XNUM
4805 && filedata
->section_headers
[0].sh_info
!= 0)
4807 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4808 printf (" (%u)", header
->e_phnum
);
4810 putc ('\n', stdout
);
4811 printf (_(" Size of section headers: %u (bytes)\n"),
4812 header
->e_shentsize
);
4813 printf (_(" Number of section headers: %u"),
4815 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4817 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4818 printf (" (%u)", header
->e_shnum
);
4820 putc ('\n', stdout
);
4821 printf (_(" Section header string table index: %u"),
4822 header
->e_shstrndx
);
4823 if (filedata
->section_headers
!= NULL
4824 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4826 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4827 printf (" (%u)", header
->e_shstrndx
);
4829 if (header
->e_shstrndx
!= SHN_UNDEF
4830 && header
->e_shstrndx
>= header
->e_shnum
)
4832 header
->e_shstrndx
= SHN_UNDEF
;
4833 printf (_(" <corrupt: out of range>"));
4835 putc ('\n', stdout
);
4838 if (filedata
->section_headers
!= NULL
)
4840 if (header
->e_phnum
== PN_XNUM
4841 && filedata
->section_headers
[0].sh_info
!= 0)
4842 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4843 if (header
->e_shnum
== SHN_UNDEF
)
4844 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4845 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4846 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4847 if (header
->e_shstrndx
>= header
->e_shnum
)
4848 header
->e_shstrndx
= SHN_UNDEF
;
4849 free (filedata
->section_headers
);
4850 filedata
->section_headers
= NULL
;
4856 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4857 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4860 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4862 Elf32_External_Phdr
* phdrs
;
4863 Elf32_External_Phdr
* external
;
4864 Elf_Internal_Phdr
* internal
;
4866 unsigned int size
= filedata
->file_header
.e_phentsize
;
4867 unsigned int num
= filedata
->file_header
.e_phnum
;
4869 /* PR binutils/17531: Cope with unexpected section header sizes. */
4870 if (size
== 0 || num
== 0)
4872 if (size
< sizeof * phdrs
)
4874 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4877 if (size
> sizeof * phdrs
)
4878 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4880 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4881 size
, num
, _("program headers"));
4885 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4886 i
< filedata
->file_header
.e_phnum
;
4887 i
++, internal
++, external
++)
4889 internal
->p_type
= BYTE_GET (external
->p_type
);
4890 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4891 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4892 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4893 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4894 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4895 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4896 internal
->p_align
= BYTE_GET (external
->p_align
);
4903 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4904 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4907 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4909 Elf64_External_Phdr
* phdrs
;
4910 Elf64_External_Phdr
* external
;
4911 Elf_Internal_Phdr
* internal
;
4913 unsigned int size
= filedata
->file_header
.e_phentsize
;
4914 unsigned int num
= filedata
->file_header
.e_phnum
;
4916 /* PR binutils/17531: Cope with unexpected section header sizes. */
4917 if (size
== 0 || num
== 0)
4919 if (size
< sizeof * phdrs
)
4921 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4924 if (size
> sizeof * phdrs
)
4925 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4927 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4928 size
, num
, _("program headers"));
4932 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4933 i
< filedata
->file_header
.e_phnum
;
4934 i
++, internal
++, external
++)
4936 internal
->p_type
= BYTE_GET (external
->p_type
);
4937 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4938 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4939 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4940 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4941 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4942 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4943 internal
->p_align
= BYTE_GET (external
->p_align
);
4950 /* Returns TRUE if the program headers were read into `program_headers'. */
4953 get_program_headers (Filedata
* filedata
)
4955 Elf_Internal_Phdr
* phdrs
;
4957 /* Check cache of prior read. */
4958 if (filedata
->program_headers
!= NULL
)
4961 /* Be kind to memory checkers by looking for
4962 e_phnum values which we know must be invalid. */
4963 if (filedata
->file_header
.e_phnum
4964 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4965 >= filedata
->file_size
)
4967 error (_("Too many program headers - %#x - the file is not that big\n"),
4968 filedata
->file_header
.e_phnum
);
4972 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4973 sizeof (Elf_Internal_Phdr
));
4976 error (_("Out of memory reading %u program headers\n"),
4977 filedata
->file_header
.e_phnum
);
4982 ? get_32bit_program_headers (filedata
, phdrs
)
4983 : get_64bit_program_headers (filedata
, phdrs
))
4985 filedata
->program_headers
= phdrs
;
4993 /* Returns TRUE if the program headers were loaded. */
4996 process_program_headers (Filedata
* filedata
)
4998 Elf_Internal_Phdr
* segment
;
5000 Elf_Internal_Phdr
* previous_load
= NULL
;
5002 if (filedata
->file_header
.e_phnum
== 0)
5004 /* PR binutils/12467. */
5005 if (filedata
->file_header
.e_phoff
!= 0)
5007 warn (_("possibly corrupt ELF header - it has a non-zero program"
5008 " header offset, but no program headers\n"));
5011 else if (do_segments
)
5012 printf (_("\nThere are no program headers in this file.\n"));
5016 if (do_segments
&& !do_header
)
5018 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5019 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5020 printf (ngettext ("There is %d program header, starting at offset %s\n",
5021 "There are %d program headers, starting at offset %s\n",
5022 filedata
->file_header
.e_phnum
),
5023 filedata
->file_header
.e_phnum
,
5024 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5027 if (! get_program_headers (filedata
))
5032 if (filedata
->file_header
.e_phnum
> 1)
5033 printf (_("\nProgram Headers:\n"));
5035 printf (_("\nProgram Headers:\n"));
5039 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5042 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5046 (_(" Type Offset VirtAddr PhysAddr\n"));
5048 (_(" FileSiz MemSiz Flags Align\n"));
5055 for (i
= 0, segment
= filedata
->program_headers
;
5056 i
< filedata
->file_header
.e_phnum
;
5061 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5065 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5066 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5067 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5068 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5069 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5071 (segment
->p_flags
& PF_R
? 'R' : ' '),
5072 (segment
->p_flags
& PF_W
? 'W' : ' '),
5073 (segment
->p_flags
& PF_X
? 'E' : ' '));
5074 printf ("%#lx", (unsigned long) segment
->p_align
);
5078 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5079 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5082 print_vma (segment
->p_offset
, FULL_HEX
);
5086 print_vma (segment
->p_vaddr
, FULL_HEX
);
5088 print_vma (segment
->p_paddr
, FULL_HEX
);
5091 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5092 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5095 print_vma (segment
->p_filesz
, FULL_HEX
);
5099 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5100 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5103 print_vma (segment
->p_memsz
, FULL_HEX
);
5107 (segment
->p_flags
& PF_R
? 'R' : ' '),
5108 (segment
->p_flags
& PF_W
? 'W' : ' '),
5109 (segment
->p_flags
& PF_X
? 'E' : ' '));
5111 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5112 printf ("%#lx", (unsigned long) segment
->p_align
);
5115 print_vma (segment
->p_align
, PREFIX_HEX
);
5120 print_vma (segment
->p_offset
, FULL_HEX
);
5122 print_vma (segment
->p_vaddr
, FULL_HEX
);
5124 print_vma (segment
->p_paddr
, FULL_HEX
);
5126 print_vma (segment
->p_filesz
, FULL_HEX
);
5128 print_vma (segment
->p_memsz
, FULL_HEX
);
5130 (segment
->p_flags
& PF_R
? 'R' : ' '),
5131 (segment
->p_flags
& PF_W
? 'W' : ' '),
5132 (segment
->p_flags
& PF_X
? 'E' : ' '));
5133 print_vma (segment
->p_align
, PREFIX_HEX
);
5136 putc ('\n', stdout
);
5139 switch (segment
->p_type
)
5142 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5143 required by the ELF standard, several programs, including the Linux
5144 kernel, make use of non-ordered segments. */
5146 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5147 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5149 if (segment
->p_memsz
< segment
->p_filesz
)
5150 error (_("the segment's file size is larger than its memory size\n"));
5151 previous_load
= segment
;
5155 /* PR 20815 - Verify that the program header is loaded into memory. */
5156 if (i
> 0 && previous_load
!= NULL
)
5157 error (_("the PHDR segment must occur before any LOAD segment\n"));
5158 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5162 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5163 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5164 && (filedata
->program_headers
[j
].p_vaddr
5165 + filedata
->program_headers
[j
].p_memsz
)
5166 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5168 if (j
== filedata
->file_header
.e_phnum
)
5169 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5175 error (_("more than one dynamic segment\n"));
5177 /* By default, assume that the .dynamic section is the first
5178 section in the DYNAMIC segment. */
5179 dynamic_addr
= segment
->p_offset
;
5180 dynamic_size
= segment
->p_filesz
;
5182 /* Try to locate the .dynamic section. If there is
5183 a section header table, we can easily locate it. */
5184 if (filedata
->section_headers
!= NULL
)
5186 Elf_Internal_Shdr
* sec
;
5188 sec
= find_section (filedata
, ".dynamic");
5189 if (sec
== NULL
|| sec
->sh_size
== 0)
5191 /* A corresponding .dynamic section is expected, but on
5192 IA-64/OpenVMS it is OK for it to be missing. */
5193 if (!is_ia64_vms (filedata
))
5194 error (_("no .dynamic section in the dynamic segment\n"));
5198 if (sec
->sh_type
== SHT_NOBITS
)
5204 dynamic_addr
= sec
->sh_offset
;
5205 dynamic_size
= sec
->sh_size
;
5207 if (dynamic_addr
< segment
->p_offset
5208 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5209 warn (_("the .dynamic section is not contained"
5210 " within the dynamic segment\n"));
5211 else if (dynamic_addr
> segment
->p_offset
)
5212 warn (_("the .dynamic section is not the first section"
5213 " in the dynamic segment.\n"));
5216 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5217 segment. Check this after matching against the section headers
5218 so we don't warn on debuginfo file (which have NOBITS .dynamic
5220 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5222 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5223 dynamic_addr
= dynamic_size
= 0;
5228 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5230 error (_("Unable to find program interpreter name\n"));
5234 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5236 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5237 error (_("Internal error: failed to create format string to display program interpreter\n"));
5239 program_interpreter
[0] = 0;
5240 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5241 error (_("Unable to read program interpreter name\n"));
5244 printf (_(" [Requesting program interpreter: %s]\n"),
5245 program_interpreter
);
5252 && filedata
->section_headers
!= NULL
5253 && filedata
->string_table
!= NULL
)
5255 printf (_("\n Section to Segment mapping:\n"));
5256 printf (_(" Segment Sections...\n"));
5258 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5261 Elf_Internal_Shdr
* section
;
5263 segment
= filedata
->program_headers
+ i
;
5264 section
= filedata
->section_headers
+ 1;
5266 printf (" %2.2d ", i
);
5268 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5270 if (!ELF_TBSS_SPECIAL (section
, segment
)
5271 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5272 printf ("%s ", printable_section_name (filedata
, section
));
5283 /* Find the file offset corresponding to VMA by using the program headers. */
5286 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5288 Elf_Internal_Phdr
* seg
;
5290 if (! get_program_headers (filedata
))
5292 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5296 for (seg
= filedata
->program_headers
;
5297 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5300 if (seg
->p_type
!= PT_LOAD
)
5303 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5304 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5305 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5308 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5309 (unsigned long) vma
);
5314 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5315 If PROBE is true, this is just a probe and we do not generate any error
5316 messages if the load fails. */
5319 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5321 Elf32_External_Shdr
* shdrs
;
5322 Elf_Internal_Shdr
* internal
;
5324 unsigned int size
= filedata
->file_header
.e_shentsize
;
5325 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5327 /* PR binutils/17531: Cope with unexpected section header sizes. */
5328 if (size
== 0 || num
== 0)
5330 if (size
< sizeof * shdrs
)
5333 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5336 if (!probe
&& size
> sizeof * shdrs
)
5337 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5339 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5341 probe
? NULL
: _("section headers"));
5345 free (filedata
->section_headers
);
5346 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5347 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5348 if (filedata
->section_headers
== NULL
)
5351 error (_("Out of memory reading %u section headers\n"), num
);
5356 for (i
= 0, internal
= filedata
->section_headers
;
5360 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5361 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5362 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5363 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5364 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5365 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5366 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5367 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5368 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5369 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5370 if (!probe
&& internal
->sh_link
> num
)
5371 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5372 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5373 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5380 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5383 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5385 Elf64_External_Shdr
* shdrs
;
5386 Elf_Internal_Shdr
* internal
;
5388 unsigned int size
= filedata
->file_header
.e_shentsize
;
5389 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5391 /* PR binutils/17531: Cope with unexpected section header sizes. */
5392 if (size
== 0 || num
== 0)
5395 if (size
< sizeof * shdrs
)
5398 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5402 if (! probe
&& size
> sizeof * shdrs
)
5403 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5405 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5406 filedata
->file_header
.e_shoff
,
5408 probe
? NULL
: _("section headers"));
5412 free (filedata
->section_headers
);
5413 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5414 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5415 if (filedata
->section_headers
== NULL
)
5418 error (_("Out of memory reading %u section headers\n"), num
);
5423 for (i
= 0, internal
= filedata
->section_headers
;
5427 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5428 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5429 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5430 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5431 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5432 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5433 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5434 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5435 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5436 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5437 if (!probe
&& internal
->sh_link
> num
)
5438 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5439 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5440 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5447 static Elf_Internal_Sym
*
5448 get_32bit_elf_symbols (Filedata
* filedata
,
5449 Elf_Internal_Shdr
* section
,
5450 unsigned long * num_syms_return
)
5452 unsigned long number
= 0;
5453 Elf32_External_Sym
* esyms
= NULL
;
5454 Elf_External_Sym_Shndx
* shndx
= NULL
;
5455 Elf_Internal_Sym
* isyms
= NULL
;
5456 Elf_Internal_Sym
* psym
;
5458 elf_section_list
* entry
;
5460 if (section
->sh_size
== 0)
5462 if (num_syms_return
!= NULL
)
5463 * num_syms_return
= 0;
5467 /* Run some sanity checks first. */
5468 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5470 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5471 printable_section_name (filedata
, section
),
5472 (unsigned long) section
->sh_entsize
);
5476 if (section
->sh_size
> filedata
->file_size
)
5478 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5479 printable_section_name (filedata
, section
),
5480 (unsigned long) section
->sh_size
);
5484 number
= section
->sh_size
/ section
->sh_entsize
;
5486 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5488 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5489 (unsigned long) section
->sh_size
,
5490 printable_section_name (filedata
, section
),
5491 (unsigned long) section
->sh_entsize
);
5495 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5496 section
->sh_size
, _("symbols"));
5501 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5503 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5508 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5512 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5513 entry
->hdr
->sh_offset
,
5514 1, entry
->hdr
->sh_size
,
5515 _("symbol table section indices"));
5519 /* PR17531: file: heap-buffer-overflow */
5520 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5522 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5523 printable_section_name (filedata
, entry
->hdr
),
5524 (unsigned long) entry
->hdr
->sh_size
,
5525 (unsigned long) section
->sh_size
);
5530 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5534 error (_("Out of memory reading %lu symbols\n"),
5535 (unsigned long) number
);
5539 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5541 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5542 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5543 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5544 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5545 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5547 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5548 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5549 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5550 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5551 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5558 if (num_syms_return
!= NULL
)
5559 * num_syms_return
= isyms
== NULL
? 0 : number
;
5564 static Elf_Internal_Sym
*
5565 get_64bit_elf_symbols (Filedata
* filedata
,
5566 Elf_Internal_Shdr
* section
,
5567 unsigned long * num_syms_return
)
5569 unsigned long number
= 0;
5570 Elf64_External_Sym
* esyms
= NULL
;
5571 Elf_External_Sym_Shndx
* shndx
= NULL
;
5572 Elf_Internal_Sym
* isyms
= NULL
;
5573 Elf_Internal_Sym
* psym
;
5575 elf_section_list
* entry
;
5577 if (section
->sh_size
== 0)
5579 if (num_syms_return
!= NULL
)
5580 * num_syms_return
= 0;
5584 /* Run some sanity checks first. */
5585 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5587 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5588 printable_section_name (filedata
, section
),
5589 (unsigned long) section
->sh_entsize
);
5593 if (section
->sh_size
> filedata
->file_size
)
5595 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5596 printable_section_name (filedata
, section
),
5597 (unsigned long) section
->sh_size
);
5601 number
= section
->sh_size
/ section
->sh_entsize
;
5603 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5605 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5606 (unsigned long) section
->sh_size
,
5607 printable_section_name (filedata
, section
),
5608 (unsigned long) section
->sh_entsize
);
5612 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5613 section
->sh_size
, _("symbols"));
5618 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5620 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5625 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5629 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5630 entry
->hdr
->sh_offset
,
5631 1, entry
->hdr
->sh_size
,
5632 _("symbol table section indices"));
5636 /* PR17531: file: heap-buffer-overflow */
5637 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5639 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5640 printable_section_name (filedata
, entry
->hdr
),
5641 (unsigned long) entry
->hdr
->sh_size
,
5642 (unsigned long) section
->sh_size
);
5647 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5651 error (_("Out of memory reading %lu symbols\n"),
5652 (unsigned long) number
);
5656 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5658 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5659 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5660 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5661 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5663 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5665 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5666 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5667 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5669 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5670 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5677 if (num_syms_return
!= NULL
)
5678 * num_syms_return
= isyms
== NULL
? 0 : number
;
5684 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5686 static char buff
[1024];
5688 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5690 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5691 bfd_vma os_flags
= 0;
5692 bfd_vma proc_flags
= 0;
5693 bfd_vma unknown_flags
= 0;
5701 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5702 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5703 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5704 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5705 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5706 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5707 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5708 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5709 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5710 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5711 /* IA-64 specific. */
5712 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5713 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5714 /* IA-64 OpenVMS specific. */
5715 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5716 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5717 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5718 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5719 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5720 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5722 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5723 /* SPARC specific. */
5724 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5725 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5727 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5728 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5729 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5731 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5733 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5736 if (do_section_details
)
5738 sprintf (buff
, "[%*.*lx]: ",
5739 field_size
, field_size
, (unsigned long) sh_flags
);
5740 p
+= field_size
+ 4;
5747 flag
= sh_flags
& - sh_flags
;
5750 if (do_section_details
)
5754 case SHF_WRITE
: sindex
= 0; break;
5755 case SHF_ALLOC
: sindex
= 1; break;
5756 case SHF_EXECINSTR
: sindex
= 2; break;
5757 case SHF_MERGE
: sindex
= 3; break;
5758 case SHF_STRINGS
: sindex
= 4; break;
5759 case SHF_INFO_LINK
: sindex
= 5; break;
5760 case SHF_LINK_ORDER
: sindex
= 6; break;
5761 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5762 case SHF_GROUP
: sindex
= 8; break;
5763 case SHF_TLS
: sindex
= 9; break;
5764 case SHF_EXCLUDE
: sindex
= 18; break;
5765 case SHF_COMPRESSED
: sindex
= 20; break;
5766 case SHF_GNU_MBIND
: sindex
= 24; break;
5770 switch (filedata
->file_header
.e_machine
)
5773 if (flag
== SHF_IA_64_SHORT
)
5775 else if (flag
== SHF_IA_64_NORECOV
)
5778 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5781 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5782 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5783 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5784 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5785 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5786 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5797 case EM_OLD_SPARCV9
:
5798 case EM_SPARC32PLUS
:
5801 if (flag
== SHF_ORDERED
)
5808 case SHF_ENTRYSECT
: sindex
= 21; break;
5809 case SHF_ARM_PURECODE
: sindex
= 22; break;
5810 case SHF_COMDEF
: sindex
= 23; break;
5815 if (flag
== SHF_PPC_VLE
)
5826 if (p
!= buff
+ field_size
+ 4)
5828 if (size
< (10 + 2))
5830 warn (_("Internal error: not enough buffer room for section flag info"));
5831 return _("<unknown>");
5838 size
-= flags
[sindex
].len
;
5839 p
= stpcpy (p
, flags
[sindex
].str
);
5841 else if (flag
& SHF_MASKOS
)
5843 else if (flag
& SHF_MASKPROC
)
5846 unknown_flags
|= flag
;
5852 case SHF_WRITE
: *p
= 'W'; break;
5853 case SHF_ALLOC
: *p
= 'A'; break;
5854 case SHF_EXECINSTR
: *p
= 'X'; break;
5855 case SHF_MERGE
: *p
= 'M'; break;
5856 case SHF_STRINGS
: *p
= 'S'; break;
5857 case SHF_INFO_LINK
: *p
= 'I'; break;
5858 case SHF_LINK_ORDER
: *p
= 'L'; break;
5859 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5860 case SHF_GROUP
: *p
= 'G'; break;
5861 case SHF_TLS
: *p
= 'T'; break;
5862 case SHF_EXCLUDE
: *p
= 'E'; break;
5863 case SHF_COMPRESSED
: *p
= 'C'; break;
5864 case SHF_GNU_MBIND
: *p
= 'D'; break;
5867 if ((filedata
->file_header
.e_machine
== EM_X86_64
5868 || filedata
->file_header
.e_machine
== EM_L1OM
5869 || filedata
->file_header
.e_machine
== EM_K1OM
)
5870 && flag
== SHF_X86_64_LARGE
)
5872 else if (filedata
->file_header
.e_machine
== EM_ARM
5873 && flag
== SHF_ARM_PURECODE
)
5875 else if (filedata
->file_header
.e_machine
== EM_PPC
5876 && flag
== SHF_PPC_VLE
)
5878 else if (flag
& SHF_MASKOS
)
5881 sh_flags
&= ~ SHF_MASKOS
;
5883 else if (flag
& SHF_MASKPROC
)
5886 sh_flags
&= ~ SHF_MASKPROC
;
5896 if (do_section_details
)
5900 size
-= 5 + field_size
;
5901 if (p
!= buff
+ field_size
+ 4)
5905 warn (_("Internal error: not enough buffer room for section flag info"));
5906 return _("<unknown>");
5912 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5913 (unsigned long) os_flags
);
5914 p
+= 5 + field_size
;
5918 size
-= 7 + field_size
;
5919 if (p
!= buff
+ field_size
+ 4)
5923 warn (_("Internal error: not enough buffer room for section flag info"));
5924 return _("<unknown>");
5930 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5931 (unsigned long) proc_flags
);
5932 p
+= 7 + field_size
;
5936 size
-= 10 + field_size
;
5937 if (p
!= buff
+ field_size
+ 4)
5941 warn (_("Internal error: not enough buffer room for section flag info"));
5942 return _("<unknown>");
5948 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5949 (unsigned long) unknown_flags
);
5950 p
+= 10 + field_size
;
5959 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5963 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5965 if (size
< sizeof (* echdr
))
5967 error (_("Compressed section is too small even for a compression header\n"));
5971 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5972 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5973 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5974 return sizeof (*echdr
);
5978 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5980 if (size
< sizeof (* echdr
))
5982 error (_("Compressed section is too small even for a compression header\n"));
5986 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5987 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5988 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5989 return sizeof (*echdr
);
5994 process_section_headers (Filedata
* filedata
)
5996 Elf_Internal_Shdr
* section
;
5999 filedata
->section_headers
= NULL
;
6001 if (filedata
->file_header
.e_shnum
== 0)
6003 /* PR binutils/12467. */
6004 if (filedata
->file_header
.e_shoff
!= 0)
6006 warn (_("possibly corrupt ELF file header - it has a non-zero"
6007 " section header offset, but no section headers\n"));
6010 else if (do_sections
)
6011 printf (_("\nThere are no sections in this file.\n"));
6016 if (do_sections
&& !do_header
)
6017 printf (ngettext ("There is %d section header, "
6018 "starting at offset 0x%lx:\n",
6019 "There are %d section headers, "
6020 "starting at offset 0x%lx:\n",
6021 filedata
->file_header
.e_shnum
),
6022 filedata
->file_header
.e_shnum
,
6023 (unsigned long) filedata
->file_header
.e_shoff
);
6027 if (! get_32bit_section_headers (filedata
, FALSE
))
6032 if (! get_64bit_section_headers (filedata
, FALSE
))
6036 /* Read in the string table, so that we have names to display. */
6037 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6038 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6040 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6042 if (section
->sh_size
!= 0)
6044 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6045 1, section
->sh_size
,
6048 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6052 /* Scan the sections for the dynamic symbol table
6053 and dynamic string table and debug sections. */
6054 dynamic_symbols
= NULL
;
6055 dynamic_strings
= NULL
;
6056 dynamic_syminfo
= NULL
;
6057 symtab_shndx_list
= NULL
;
6059 eh_addr_size
= is_32bit_elf
? 4 : 8;
6060 switch (filedata
->file_header
.e_machine
)
6063 case EM_MIPS_RS3_LE
:
6064 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6065 FDE addresses. However, the ABI also has a semi-official ILP32
6066 variant for which the normal FDE address size rules apply.
6068 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6069 section, where XX is the size of longs in bits. Unfortunately,
6070 earlier compilers provided no way of distinguishing ILP32 objects
6071 from LP64 objects, so if there's any doubt, we should assume that
6072 the official LP64 form is being used. */
6073 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6074 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6080 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6082 case E_H8_MACH_H8300
:
6083 case E_H8_MACH_H8300HN
:
6084 case E_H8_MACH_H8300SN
:
6085 case E_H8_MACH_H8300SXN
:
6088 case E_H8_MACH_H8300H
:
6089 case E_H8_MACH_H8300S
:
6090 case E_H8_MACH_H8300SX
:
6098 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6100 case EF_M32C_CPU_M16C
:
6107 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6110 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6111 if (section->sh_entsize != expected_entsize) \
6114 sprintf_vma (buf, section->sh_entsize); \
6115 /* Note: coded this way so that there is a single string for \
6117 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6118 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6119 (unsigned) expected_entsize); \
6120 section->sh_entsize = expected_entsize; \
6125 #define CHECK_ENTSIZE(section, i, type) \
6126 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6127 sizeof (Elf64_External_##type))
6129 for (i
= 0, section
= filedata
->section_headers
;
6130 i
< filedata
->file_header
.e_shnum
;
6133 char * name
= SECTION_NAME (section
);
6135 if (section
->sh_type
== SHT_DYNSYM
)
6137 if (dynamic_symbols
!= NULL
)
6139 error (_("File contains multiple dynamic symbol tables\n"));
6143 CHECK_ENTSIZE (section
, i
, Sym
);
6144 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6146 else if (section
->sh_type
== SHT_STRTAB
6147 && streq (name
, ".dynstr"))
6149 if (dynamic_strings
!= NULL
)
6151 error (_("File contains multiple dynamic string tables\n"));
6155 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6156 1, section
->sh_size
,
6157 _("dynamic strings"));
6158 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6160 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6162 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6164 entry
->hdr
= section
;
6165 entry
->next
= symtab_shndx_list
;
6166 symtab_shndx_list
= entry
;
6168 else if (section
->sh_type
== SHT_SYMTAB
)
6169 CHECK_ENTSIZE (section
, i
, Sym
);
6170 else if (section
->sh_type
== SHT_GROUP
)
6171 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6172 else if (section
->sh_type
== SHT_REL
)
6173 CHECK_ENTSIZE (section
, i
, Rel
);
6174 else if (section
->sh_type
== SHT_RELA
)
6175 CHECK_ENTSIZE (section
, i
, Rela
);
6176 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6177 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6178 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6179 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6180 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6181 && (const_strneq (name
, ".debug_")
6182 || const_strneq (name
, ".zdebug_")))
6185 name
+= sizeof (".zdebug_") - 1;
6187 name
+= sizeof (".debug_") - 1;
6190 || (do_debug_info
&& const_strneq (name
, "info"))
6191 || (do_debug_info
&& const_strneq (name
, "types"))
6192 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6193 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6194 || (do_debug_lines
&& const_strneq (name
, "line."))
6195 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6196 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6197 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6198 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6199 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6200 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6201 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6202 || (do_debug_frames
&& const_strneq (name
, "frame"))
6203 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6204 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6205 || (do_debug_str
&& const_strneq (name
, "str"))
6206 || (do_debug_loc
&& const_strneq (name
, "loc"))
6207 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6208 || (do_debug_addr
&& const_strneq (name
, "addr"))
6209 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6210 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6212 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6214 /* Linkonce section to be combined with .debug_info at link time. */
6215 else if ((do_debugging
|| do_debug_info
)
6216 && const_strneq (name
, ".gnu.linkonce.wi."))
6217 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6218 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6219 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6220 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6221 || streq (name
, ".debug_names")))
6222 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6223 /* Trace sections for Itanium VMS. */
6224 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6225 || do_trace_aranges
)
6226 && const_strneq (name
, ".trace_"))
6228 name
+= sizeof (".trace_") - 1;
6231 || (do_trace_info
&& streq (name
, "info"))
6232 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6233 || (do_trace_aranges
&& streq (name
, "aranges"))
6235 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6237 else if ((do_debugging
|| do_debug_links
)
6238 && (const_strneq (name
, ".gnu_debuglink")
6239 || const_strneq (name
, ".gnu_debugaltlink")))
6240 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6246 if (filedata
->file_header
.e_shnum
> 1)
6247 printf (_("\nSection Headers:\n"));
6249 printf (_("\nSection Header:\n"));
6253 if (do_section_details
)
6255 printf (_(" [Nr] Name\n"));
6256 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6260 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6264 if (do_section_details
)
6266 printf (_(" [Nr] Name\n"));
6267 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6271 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6275 if (do_section_details
)
6277 printf (_(" [Nr] Name\n"));
6278 printf (_(" Type Address Offset Link\n"));
6279 printf (_(" Size EntSize Info Align\n"));
6283 printf (_(" [Nr] Name Type Address Offset\n"));
6284 printf (_(" Size EntSize Flags Link Info Align\n"));
6288 if (do_section_details
)
6289 printf (_(" Flags\n"));
6291 for (i
= 0, section
= filedata
->section_headers
;
6292 i
< filedata
->file_header
.e_shnum
;
6295 /* Run some sanity checks on the section header. */
6297 /* Check the sh_link field. */
6298 switch (section
->sh_type
)
6300 case SHT_SYMTAB_SHNDX
:
6304 case SHT_GNU_versym
:
6307 if (section
->sh_link
< 1
6308 || section
->sh_link
>= filedata
->file_header
.e_shnum
6309 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6310 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6311 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6312 i
, section
->sh_link
);
6318 case SHT_GNU_verneed
:
6319 case SHT_GNU_verdef
:
6320 case SHT_GNU_LIBLIST
:
6321 if (section
->sh_link
< 1
6322 || section
->sh_link
>= filedata
->file_header
.e_shnum
6323 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6324 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6325 i
, section
->sh_link
);
6328 case SHT_INIT_ARRAY
:
6329 case SHT_FINI_ARRAY
:
6330 case SHT_PREINIT_ARRAY
:
6331 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6332 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6333 i
, section
->sh_link
);
6337 /* FIXME: Add support for target specific section types. */
6338 #if 0 /* Currently we do not check other section types as there are too
6339 many special cases. Stab sections for example have a type
6340 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6342 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6343 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6344 i
, section
->sh_link
);
6349 /* Check the sh_info field. */
6350 switch (section
->sh_type
)
6354 if (section
->sh_info
< 1
6355 || section
->sh_info
>= filedata
->file_header
.e_shnum
6356 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6357 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6358 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6359 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6360 /* FIXME: Are other section types valid ? */
6361 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6363 if (section
->sh_info
== 0
6364 && (filedata
->file_header
.e_type
== ET_EXEC
6365 || filedata
->file_header
.e_type
== ET_DYN
6366 /* These next two tests may be redundant, but
6367 they have been left in for paranoia's sake. */
6368 || streq (SECTION_NAME (section
), ".rel.dyn")
6369 || streq (SECTION_NAME (section
), ".rela.dyn")))
6370 /* Dynamic relocations apply to segments, not sections, so
6371 they do not need an sh_info value. */
6374 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6375 i
, section
->sh_info
);
6381 case SHT_SYMTAB_SHNDX
:
6382 case SHT_INIT_ARRAY
:
6383 case SHT_FINI_ARRAY
:
6384 case SHT_PREINIT_ARRAY
:
6385 if (section
->sh_info
!= 0)
6386 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6387 i
, section
->sh_info
);
6393 /* A symbol index - we assume that it is valid. */
6397 /* FIXME: Add support for target specific section types. */
6398 if (section
->sh_type
== SHT_NOBITS
)
6399 /* NOBITS section headers with non-zero sh_info fields can be
6400 created when a binary is stripped of everything but its debug
6401 information. The stripped sections have their headers
6402 preserved but their types set to SHT_NOBITS. So do not check
6403 this type of section. */
6405 else if (section
->sh_flags
& SHF_INFO_LINK
)
6407 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6408 warn (_("[%2u]: Expected link to another section in info field"), i
);
6410 else if (section
->sh_type
< SHT_LOOS
6411 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6412 && section
->sh_info
!= 0)
6413 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6414 i
, section
->sh_info
);
6418 /* Check the sh_size field. */
6419 if (section
->sh_size
> filedata
->file_size
6420 && section
->sh_type
!= SHT_NOBITS
6421 && section
->sh_type
!= SHT_NULL
6422 && section
->sh_type
< SHT_LOOS
)
6423 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6425 printf (" [%2u] ", i
);
6426 if (do_section_details
)
6427 printf ("%s\n ", printable_section_name (filedata
, section
));
6429 print_symbol (-17, SECTION_NAME (section
));
6431 printf (do_wide
? " %-15s " : " %-15.15s ",
6432 get_section_type_name (filedata
, section
->sh_type
));
6436 const char * link_too_big
= NULL
;
6438 print_vma (section
->sh_addr
, LONG_HEX
);
6440 printf ( " %6.6lx %6.6lx %2.2lx",
6441 (unsigned long) section
->sh_offset
,
6442 (unsigned long) section
->sh_size
,
6443 (unsigned long) section
->sh_entsize
);
6445 if (do_section_details
)
6446 fputs (" ", stdout
);
6448 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6450 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6453 /* The sh_link value is out of range. Normally this indicates
6454 an error but it can have special values in Solaris binaries. */
6455 switch (filedata
->file_header
.e_machine
)
6462 case EM_OLD_SPARCV9
:
6463 case EM_SPARC32PLUS
:
6466 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6467 link_too_big
= "BEFORE";
6468 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6469 link_too_big
= "AFTER";
6476 if (do_section_details
)
6478 if (link_too_big
!= NULL
&& * link_too_big
)
6479 printf ("<%s> ", link_too_big
);
6481 printf ("%2u ", section
->sh_link
);
6482 printf ("%3u %2lu\n", section
->sh_info
,
6483 (unsigned long) section
->sh_addralign
);
6486 printf ("%2u %3u %2lu\n",
6489 (unsigned long) section
->sh_addralign
);
6491 if (link_too_big
&& ! * link_too_big
)
6492 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6493 i
, section
->sh_link
);
6497 print_vma (section
->sh_addr
, LONG_HEX
);
6499 if ((long) section
->sh_offset
== section
->sh_offset
)
6500 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6504 print_vma (section
->sh_offset
, LONG_HEX
);
6507 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6508 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6512 print_vma (section
->sh_size
, LONG_HEX
);
6515 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6516 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6520 print_vma (section
->sh_entsize
, LONG_HEX
);
6523 if (do_section_details
)
6524 fputs (" ", stdout
);
6526 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6528 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6530 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6531 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6534 print_vma (section
->sh_addralign
, DEC
);
6538 else if (do_section_details
)
6541 print_vma (section
->sh_addr
, LONG_HEX
);
6542 if ((long) section
->sh_offset
== section
->sh_offset
)
6543 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6547 print_vma (section
->sh_offset
, LONG_HEX
);
6549 printf (" %u\n ", section
->sh_link
);
6550 print_vma (section
->sh_size
, LONG_HEX
);
6552 print_vma (section
->sh_entsize
, LONG_HEX
);
6554 printf (" %-16u %lu\n",
6556 (unsigned long) section
->sh_addralign
);
6561 print_vma (section
->sh_addr
, LONG_HEX
);
6562 if ((long) section
->sh_offset
== section
->sh_offset
)
6563 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6567 print_vma (section
->sh_offset
, LONG_HEX
);
6570 print_vma (section
->sh_size
, LONG_HEX
);
6572 print_vma (section
->sh_entsize
, LONG_HEX
);
6574 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6576 printf (" %2u %3u %lu\n",
6579 (unsigned long) section
->sh_addralign
);
6582 if (do_section_details
)
6584 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6585 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6587 /* Minimum section size is 12 bytes for 32-bit compression
6588 header + 12 bytes for compressed data header. */
6589 unsigned char buf
[24];
6591 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6592 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6593 sizeof (buf
), _("compression header")))
6595 Elf_Internal_Chdr chdr
;
6597 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6599 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6602 printf (_(" [<unknown>: 0x%x], "),
6604 print_vma (chdr
.ch_size
, LONG_HEX
);
6605 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6611 if (!do_section_details
)
6613 /* The ordering of the letters shown here matches the ordering of the
6614 corresponding SHF_xxx values, and hence the order in which these
6615 letters will be displayed to the user. */
6616 printf (_("Key to Flags:\n\
6617 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6618 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6619 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6620 if (filedata
->file_header
.e_machine
== EM_X86_64
6621 || filedata
->file_header
.e_machine
== EM_L1OM
6622 || filedata
->file_header
.e_machine
== EM_K1OM
)
6623 printf (_("l (large), "));
6624 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6625 printf (_("y (purecode), "));
6626 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6627 printf (_("v (VLE), "));
6628 printf ("p (processor specific)\n");
6635 get_group_flags (unsigned int flags
)
6637 static char buff
[128];
6641 else if (flags
== GRP_COMDAT
)
6644 snprintf (buff
, 14, _("[0x%x: "), flags
);
6646 flags
&= ~ GRP_COMDAT
;
6647 if (flags
& GRP_MASKOS
)
6649 strcat (buff
, "<OS specific>");
6650 flags
&= ~ GRP_MASKOS
;
6653 if (flags
& GRP_MASKPROC
)
6655 strcat (buff
, "<PROC specific>");
6656 flags
&= ~ GRP_MASKPROC
;
6660 strcat (buff
, "<unknown>");
6667 process_section_groups (Filedata
* filedata
)
6669 Elf_Internal_Shdr
* section
;
6671 struct group
* group
;
6672 Elf_Internal_Shdr
* symtab_sec
;
6673 Elf_Internal_Shdr
* strtab_sec
;
6674 Elf_Internal_Sym
* symtab
;
6675 unsigned long num_syms
;
6679 /* Don't process section groups unless needed. */
6680 if (!do_unwind
&& !do_section_groups
)
6683 if (filedata
->file_header
.e_shnum
== 0)
6685 if (do_section_groups
)
6686 printf (_("\nThere are no sections to group in this file.\n"));
6691 if (filedata
->section_headers
== NULL
)
6693 error (_("Section headers are not available!\n"));
6694 /* PR 13622: This can happen with a corrupt ELF header. */
6698 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6699 sizeof (struct group
*));
6701 if (section_headers_groups
== NULL
)
6703 error (_("Out of memory reading %u section group headers\n"),
6704 filedata
->file_header
.e_shnum
);
6708 /* Scan the sections for the group section. */
6710 for (i
= 0, section
= filedata
->section_headers
;
6711 i
< filedata
->file_header
.e_shnum
;
6713 if (section
->sh_type
== SHT_GROUP
)
6716 if (group_count
== 0)
6718 if (do_section_groups
)
6719 printf (_("\nThere are no section groups in this file.\n"));
6724 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6726 if (section_groups
== NULL
)
6728 error (_("Out of memory reading %lu groups\n"),
6729 (unsigned long) group_count
);
6739 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6740 i
< filedata
->file_header
.e_shnum
;
6743 if (section
->sh_type
== SHT_GROUP
)
6745 const char * name
= printable_section_name (filedata
, section
);
6746 const char * group_name
;
6747 unsigned char * start
;
6748 unsigned char * indices
;
6749 unsigned int entry
, j
, size
;
6750 Elf_Internal_Shdr
* sec
;
6751 Elf_Internal_Sym
* sym
;
6753 /* Get the symbol table. */
6754 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6755 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6758 error (_("Bad sh_link in group section `%s'\n"), name
);
6762 if (symtab_sec
!= sec
)
6767 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6772 error (_("Corrupt header in group section `%s'\n"), name
);
6776 if (section
->sh_info
>= num_syms
)
6778 error (_("Bad sh_info in group section `%s'\n"), name
);
6782 sym
= symtab
+ section
->sh_info
;
6784 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6786 if (sym
->st_shndx
== 0
6787 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6789 error (_("Bad sh_info in group section `%s'\n"), name
);
6793 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6802 /* Get the string table. */
6803 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6812 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6818 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6819 1, strtab_sec
->sh_size
,
6821 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6823 group_name
= sym
->st_name
< strtab_size
6824 ? strtab
+ sym
->st_name
: _("<corrupt>");
6827 /* PR 17531: file: loop. */
6828 if (section
->sh_entsize
> section
->sh_size
)
6830 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6831 printable_section_name (filedata
, section
),
6832 (unsigned long) section
->sh_entsize
,
6833 (unsigned long) section
->sh_size
);
6837 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6838 1, section
->sh_size
,
6844 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6845 entry
= byte_get (indices
, 4);
6848 if (do_section_groups
)
6850 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6851 get_group_flags (entry
), i
, name
, group_name
, size
);
6853 printf (_(" [Index] Name\n"));
6856 group
->group_index
= i
;
6858 for (j
= 0; j
< size
; j
++)
6860 struct group_list
* g
;
6862 entry
= byte_get (indices
, 4);
6865 if (entry
>= filedata
->file_header
.e_shnum
)
6867 static unsigned num_group_errors
= 0;
6869 if (num_group_errors
++ < 10)
6871 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6872 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6873 if (num_group_errors
== 10)
6874 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6879 if (section_headers_groups
[entry
] != NULL
)
6883 static unsigned num_errs
= 0;
6885 if (num_errs
++ < 10)
6887 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6889 section_headers_groups
[entry
]->group_index
);
6891 warn (_("Further error messages about already contained group sections suppressed\n"));
6897 /* Intel C/C++ compiler may put section 0 in a
6898 section group. We just warn it the first time
6899 and ignore it afterwards. */
6900 static bfd_boolean warned
= FALSE
;
6903 error (_("section 0 in group section [%5u]\n"),
6904 section_headers_groups
[entry
]->group_index
);
6910 section_headers_groups
[entry
] = group
;
6912 if (do_section_groups
)
6914 sec
= filedata
->section_headers
+ entry
;
6915 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6918 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6919 g
->section_index
= entry
;
6920 g
->next
= group
->root
;
6938 /* Data used to display dynamic fixups. */
6940 struct ia64_vms_dynfixup
6942 bfd_vma needed_ident
; /* Library ident number. */
6943 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6944 bfd_vma fixup_needed
; /* Index of the library. */
6945 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6946 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6949 /* Data used to display dynamic relocations. */
6951 struct ia64_vms_dynimgrela
6953 bfd_vma img_rela_cnt
; /* Number of relocations. */
6954 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6957 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6961 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6962 struct ia64_vms_dynfixup
* fixup
,
6963 const char * strtab
,
6964 unsigned int strtab_sz
)
6966 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6968 const char * lib_name
;
6970 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6971 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6972 _("dynamic section image fixups"));
6976 if (fixup
->needed
< strtab_sz
)
6977 lib_name
= strtab
+ fixup
->needed
;
6980 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6981 (unsigned long) fixup
->needed
);
6984 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6985 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6987 (_("Seg Offset Type SymVec DataType\n"));
6989 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6994 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6995 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6996 type
= BYTE_GET (imfs
[i
].type
);
6997 rtype
= elf_ia64_reloc_type (type
);
6999 printf (" 0x%08x ", type
);
7001 printf (" %-32s ", rtype
);
7002 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7003 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7010 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7013 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7015 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7018 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7019 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7020 _("dynamic section image relocations"));
7024 printf (_("\nImage relocs\n"));
7026 (_("Seg Offset Type Addend Seg Sym Off\n"));
7028 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7033 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7034 printf ("%08" BFD_VMA_FMT
"x ",
7035 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7036 type
= BYTE_GET (imrs
[i
].type
);
7037 rtype
= elf_ia64_reloc_type (type
);
7039 printf ("0x%08x ", type
);
7041 printf ("%-31s ", rtype
);
7042 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7043 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7044 printf ("%08" BFD_VMA_FMT
"x\n",
7045 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7052 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7055 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7057 struct ia64_vms_dynfixup fixup
;
7058 struct ia64_vms_dynimgrela imgrela
;
7059 Elf_Internal_Dyn
*entry
;
7060 bfd_vma strtab_off
= 0;
7061 bfd_vma strtab_sz
= 0;
7062 char *strtab
= NULL
;
7063 bfd_boolean res
= TRUE
;
7065 memset (&fixup
, 0, sizeof (fixup
));
7066 memset (&imgrela
, 0, sizeof (imgrela
));
7068 /* Note: the order of the entries is specified by the OpenVMS specs. */
7069 for (entry
= dynamic_section
;
7070 entry
< dynamic_section
+ dynamic_nent
;
7073 switch (entry
->d_tag
)
7075 case DT_IA_64_VMS_STRTAB_OFFSET
:
7076 strtab_off
= entry
->d_un
.d_val
;
7079 strtab_sz
= entry
->d_un
.d_val
;
7081 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7082 1, strtab_sz
, _("dynamic string section"));
7085 case DT_IA_64_VMS_NEEDED_IDENT
:
7086 fixup
.needed_ident
= entry
->d_un
.d_val
;
7089 fixup
.needed
= entry
->d_un
.d_val
;
7091 case DT_IA_64_VMS_FIXUP_NEEDED
:
7092 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7094 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7095 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7097 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7098 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7099 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7102 case DT_IA_64_VMS_IMG_RELA_CNT
:
7103 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7105 case DT_IA_64_VMS_IMG_RELA_OFF
:
7106 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7107 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7129 dynamic_relocations
[] =
7131 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7132 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7133 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7136 /* Process the reloc section. */
7139 process_relocs (Filedata
* filedata
)
7141 unsigned long rel_size
;
7142 unsigned long rel_offset
;
7147 if (do_using_dynamic
)
7151 bfd_boolean has_dynamic_reloc
;
7154 has_dynamic_reloc
= FALSE
;
7156 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7158 is_rela
= dynamic_relocations
[i
].rela
;
7159 name
= dynamic_relocations
[i
].name
;
7160 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7161 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7164 has_dynamic_reloc
= TRUE
;
7166 if (is_rela
== UNKNOWN
)
7168 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7169 switch (dynamic_info
[DT_PLTREL
])
7183 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7184 name
, rel_offset
, rel_size
);
7186 dump_relocations (filedata
,
7187 offset_from_vma (filedata
, rel_offset
, rel_size
),
7189 dynamic_symbols
, num_dynamic_syms
,
7190 dynamic_strings
, dynamic_strings_length
,
7191 is_rela
, TRUE
/* is_dynamic */);
7195 if (is_ia64_vms (filedata
))
7196 if (process_ia64_vms_dynamic_relocs (filedata
))
7197 has_dynamic_reloc
= TRUE
;
7199 if (! has_dynamic_reloc
)
7200 printf (_("\nThere are no dynamic relocations in this file.\n"));
7204 Elf_Internal_Shdr
* section
;
7206 bfd_boolean found
= FALSE
;
7208 for (i
= 0, section
= filedata
->section_headers
;
7209 i
< filedata
->file_header
.e_shnum
;
7212 if ( section
->sh_type
!= SHT_RELA
7213 && section
->sh_type
!= SHT_REL
)
7216 rel_offset
= section
->sh_offset
;
7217 rel_size
= section
->sh_size
;
7221 Elf_Internal_Shdr
* strsec
;
7223 unsigned long num_rela
;
7225 printf (_("\nRelocation section "));
7227 if (filedata
->string_table
== NULL
)
7228 printf ("%d", section
->sh_name
);
7230 printf ("'%s'", printable_section_name (filedata
, section
));
7232 num_rela
= rel_size
/ section
->sh_entsize
;
7233 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7234 " at offset 0x%lx contains %lu entries:\n",
7236 rel_offset
, num_rela
);
7238 is_rela
= section
->sh_type
== SHT_RELA
;
7240 if (section
->sh_link
!= 0
7241 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7243 Elf_Internal_Shdr
* symsec
;
7244 Elf_Internal_Sym
* symtab
;
7245 unsigned long nsyms
;
7246 unsigned long strtablen
= 0;
7247 char * strtab
= NULL
;
7249 symsec
= filedata
->section_headers
+ section
->sh_link
;
7250 if (symsec
->sh_type
!= SHT_SYMTAB
7251 && symsec
->sh_type
!= SHT_DYNSYM
)
7254 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7259 if (symsec
->sh_link
!= 0
7260 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7262 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7264 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7267 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7270 dump_relocations (filedata
, rel_offset
, rel_size
,
7271 symtab
, nsyms
, strtab
, strtablen
,
7273 symsec
->sh_type
== SHT_DYNSYM
);
7279 dump_relocations (filedata
, rel_offset
, rel_size
,
7280 NULL
, 0, NULL
, 0, is_rela
,
7281 FALSE
/* is_dynamic */);
7289 /* Users sometimes forget the -D option, so try to be helpful. */
7290 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7292 if (dynamic_info
[dynamic_relocations
[i
].size
])
7294 printf (_("\nThere are no static relocations in this file."));
7295 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7300 if (i
== ARRAY_SIZE (dynamic_relocations
))
7301 printf (_("\nThere are no relocations in this file.\n"));
7308 /* An absolute address consists of a section and an offset. If the
7309 section is NULL, the offset itself is the address, otherwise, the
7310 address equals to LOAD_ADDRESS(section) + offset. */
7314 unsigned short section
;
7318 #define ABSADDR(a) \
7320 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7323 /* Find the nearest symbol at or below ADDR. Returns the symbol
7324 name, if found, and the offset from the symbol to ADDR. */
7327 find_symbol_for_address (Filedata
* filedata
,
7328 Elf_Internal_Sym
* symtab
,
7329 unsigned long nsyms
,
7330 const char * strtab
,
7331 unsigned long strtab_size
,
7332 struct absaddr addr
,
7333 const char ** symname
,
7336 bfd_vma dist
= 0x100000;
7337 Elf_Internal_Sym
* sym
;
7338 Elf_Internal_Sym
* beg
;
7339 Elf_Internal_Sym
* end
;
7340 Elf_Internal_Sym
* best
= NULL
;
7342 REMOVE_ARCH_BITS (addr
.offset
);
7344 end
= symtab
+ nsyms
;
7350 sym
= beg
+ (end
- beg
) / 2;
7352 value
= sym
->st_value
;
7353 REMOVE_ARCH_BITS (value
);
7355 if (sym
->st_name
!= 0
7356 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7357 && addr
.offset
>= value
7358 && addr
.offset
- value
< dist
)
7361 dist
= addr
.offset
- value
;
7366 if (addr
.offset
< value
)
7374 *symname
= (best
->st_name
>= strtab_size
7375 ? _("<corrupt>") : strtab
+ best
->st_name
);
7381 *offset
= addr
.offset
;
7384 static /* signed */ int
7385 symcmp (const void *p
, const void *q
)
7387 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7388 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7390 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7393 /* Process the unwind section. */
7395 #include "unwind-ia64.h"
7397 struct ia64_unw_table_entry
7399 struct absaddr start
;
7401 struct absaddr info
;
7404 struct ia64_unw_aux_info
7406 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7407 unsigned long table_len
; /* Length of unwind table. */
7408 unsigned char * info
; /* Unwind info. */
7409 unsigned long info_size
; /* Size of unwind info. */
7410 bfd_vma info_addr
; /* Starting address of unwind info. */
7411 bfd_vma seg_base
; /* Starting address of segment. */
7412 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7413 unsigned long nsyms
; /* Number of symbols. */
7414 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7415 unsigned long nfuns
; /* Number of entries in funtab. */
7416 char * strtab
; /* The string table. */
7417 unsigned long strtab_size
; /* Size of string table. */
7421 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7423 struct ia64_unw_table_entry
* tp
;
7424 unsigned long j
, nfuns
;
7426 bfd_boolean res
= TRUE
;
7428 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7429 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7430 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7431 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7433 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7435 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7439 const unsigned char * dp
;
7440 const unsigned char * head
;
7441 const unsigned char * end
;
7442 const char * procname
;
7444 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7445 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7447 fputs ("\n<", stdout
);
7451 fputs (procname
, stdout
);
7454 printf ("+%lx", (unsigned long) offset
);
7457 fputs (">: [", stdout
);
7458 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7459 fputc ('-', stdout
);
7460 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7461 printf ("], info at +0x%lx\n",
7462 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7464 /* PR 17531: file: 86232b32. */
7465 if (aux
->info
== NULL
)
7468 /* PR 17531: file: 0997b4d1. */
7469 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7471 warn (_("Invalid offset %lx in table entry %ld\n"),
7472 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7477 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7478 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7480 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7481 (unsigned) UNW_VER (stamp
),
7482 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7483 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7484 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7485 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7487 if (UNW_VER (stamp
) != 1)
7489 printf (_("\tUnknown version.\n"));
7494 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7495 /* PR 17531: file: 16ceda89. */
7496 if (end
> aux
->info
+ aux
->info_size
)
7497 end
= aux
->info
+ aux
->info_size
;
7498 for (dp
= head
+ 8; dp
< end
;)
7499 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7508 slurp_ia64_unwind_table (Filedata
* filedata
,
7509 struct ia64_unw_aux_info
* aux
,
7510 Elf_Internal_Shdr
* sec
)
7512 unsigned long size
, nrelas
, i
;
7513 Elf_Internal_Phdr
* seg
;
7514 struct ia64_unw_table_entry
* tep
;
7515 Elf_Internal_Shdr
* relsec
;
7516 Elf_Internal_Rela
* rela
;
7517 Elf_Internal_Rela
* rp
;
7518 unsigned char * table
;
7520 Elf_Internal_Sym
* sym
;
7521 const char * relname
;
7525 /* First, find the starting address of the segment that includes
7528 if (filedata
->file_header
.e_phnum
)
7530 if (! get_program_headers (filedata
))
7533 for (seg
= filedata
->program_headers
;
7534 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7537 if (seg
->p_type
!= PT_LOAD
)
7540 if (sec
->sh_addr
>= seg
->p_vaddr
7541 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7543 aux
->seg_base
= seg
->p_vaddr
;
7549 /* Second, build the unwind table from the contents of the unwind section: */
7550 size
= sec
->sh_size
;
7551 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7556 aux
->table_len
= size
/ (3 * eh_addr_size
);
7557 aux
->table
= (struct ia64_unw_table_entry
*)
7558 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7561 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7563 tep
->start
.section
= SHN_UNDEF
;
7564 tep
->end
.section
= SHN_UNDEF
;
7565 tep
->info
.section
= SHN_UNDEF
;
7566 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7567 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7568 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7569 tep
->start
.offset
+= aux
->seg_base
;
7570 tep
->end
.offset
+= aux
->seg_base
;
7571 tep
->info
.offset
+= aux
->seg_base
;
7575 /* Third, apply any relocations to the unwind table: */
7576 for (relsec
= filedata
->section_headers
;
7577 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7580 if (relsec
->sh_type
!= SHT_RELA
7581 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7582 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7585 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7594 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7596 relname
= elf_ia64_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7597 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7599 /* PR 17531: file: 9fa67536. */
7600 if (relname
== NULL
)
7602 warn (_("Skipping unknown relocation type: %u\n"),
7603 get_reloc_type (filedata
, rp
->r_info
));
7607 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7609 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7613 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7615 /* PR 17531: file: 5bc8d9bf. */
7616 if (i
>= aux
->table_len
)
7618 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7622 switch (rp
->r_offset
/ eh_addr_size
% 3)
7625 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7626 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7629 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7630 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7633 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7634 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7648 ia64_process_unwind (Filedata
* filedata
)
7650 Elf_Internal_Shdr
* sec
;
7651 Elf_Internal_Shdr
* unwsec
= NULL
;
7652 Elf_Internal_Shdr
* strsec
;
7653 unsigned long i
, unwcount
= 0, unwstart
= 0;
7654 struct ia64_unw_aux_info aux
;
7655 bfd_boolean res
= TRUE
;
7657 memset (& aux
, 0, sizeof (aux
));
7659 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7661 if (sec
->sh_type
== SHT_SYMTAB
7662 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7664 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7666 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7667 if (aux
.strtab
!= NULL
)
7669 error (_("Multiple auxillary string tables encountered\n"));
7673 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7676 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7678 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7683 printf (_("\nThere are no unwind sections in this file.\n"));
7685 while (unwcount
-- > 0)
7690 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7691 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7692 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7697 /* We have already counted the number of SHT_IA64_UNWIND
7698 sections so the loop above should never fail. */
7699 assert (unwsec
!= NULL
);
7702 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7704 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7706 /* We need to find which section group it is in. */
7707 struct group_list
* g
;
7709 if (section_headers_groups
== NULL
7710 || section_headers_groups
[i
] == NULL
)
7711 i
= filedata
->file_header
.e_shnum
;
7714 g
= section_headers_groups
[i
]->root
;
7716 for (; g
!= NULL
; g
= g
->next
)
7718 sec
= filedata
->section_headers
+ g
->section_index
;
7720 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7725 i
= filedata
->file_header
.e_shnum
;
7728 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7730 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7731 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7732 suffix
= SECTION_NAME (unwsec
) + len
;
7733 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7735 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7736 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7741 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7742 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7743 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7744 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7746 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7747 suffix
= SECTION_NAME (unwsec
) + len
;
7748 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7750 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7751 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7755 if (i
== filedata
->file_header
.e_shnum
)
7757 printf (_("\nCould not find unwind info section for "));
7759 if (filedata
->string_table
== NULL
)
7760 printf ("%d", unwsec
->sh_name
);
7762 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7766 aux
.info_addr
= sec
->sh_addr
;
7767 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7770 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7772 printf (_("\nUnwind section "));
7774 if (filedata
->string_table
== NULL
)
7775 printf ("%d", unwsec
->sh_name
);
7777 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7779 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7780 (unsigned long) unwsec
->sh_offset
,
7781 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7783 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7784 && aux
.table_len
> 0)
7785 dump_ia64_unwind (filedata
, & aux
);
7788 free ((char *) aux
.table
);
7790 free ((char *) aux
.info
);
7799 free ((char *) aux
.strtab
);
7804 struct hppa_unw_table_entry
7806 struct absaddr start
;
7808 unsigned int Cannot_unwind
:1; /* 0 */
7809 unsigned int Millicode
:1; /* 1 */
7810 unsigned int Millicode_save_sr0
:1; /* 2 */
7811 unsigned int Region_description
:2; /* 3..4 */
7812 unsigned int reserved1
:1; /* 5 */
7813 unsigned int Entry_SR
:1; /* 6 */
7814 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7815 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7816 unsigned int Args_stored
:1; /* 16 */
7817 unsigned int Variable_Frame
:1; /* 17 */
7818 unsigned int Separate_Package_Body
:1; /* 18 */
7819 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7820 unsigned int Stack_Overflow_Check
:1; /* 20 */
7821 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7822 unsigned int Ada_Region
:1; /* 22 */
7823 unsigned int cxx_info
:1; /* 23 */
7824 unsigned int cxx_try_catch
:1; /* 24 */
7825 unsigned int sched_entry_seq
:1; /* 25 */
7826 unsigned int reserved2
:1; /* 26 */
7827 unsigned int Save_SP
:1; /* 27 */
7828 unsigned int Save_RP
:1; /* 28 */
7829 unsigned int Save_MRP_in_frame
:1; /* 29 */
7830 unsigned int extn_ptr_defined
:1; /* 30 */
7831 unsigned int Cleanup_defined
:1; /* 31 */
7833 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7834 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7835 unsigned int Large_frame
:1; /* 2 */
7836 unsigned int Pseudo_SP_Set
:1; /* 3 */
7837 unsigned int reserved4
:1; /* 4 */
7838 unsigned int Total_frame_size
:27; /* 5..31 */
7841 struct hppa_unw_aux_info
7843 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7844 unsigned long table_len
; /* Length of unwind table. */
7845 bfd_vma seg_base
; /* Starting address of segment. */
7846 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7847 unsigned long nsyms
; /* Number of symbols. */
7848 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7849 unsigned long nfuns
; /* Number of entries in funtab. */
7850 char * strtab
; /* The string table. */
7851 unsigned long strtab_size
; /* Size of string table. */
7855 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7857 struct hppa_unw_table_entry
* tp
;
7858 unsigned long j
, nfuns
;
7859 bfd_boolean res
= TRUE
;
7861 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7862 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7863 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7864 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7866 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7868 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7871 const char * procname
;
7873 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7874 aux
->strtab_size
, tp
->start
, &procname
,
7877 fputs ("\n<", stdout
);
7881 fputs (procname
, stdout
);
7884 printf ("+%lx", (unsigned long) offset
);
7887 fputs (">: [", stdout
);
7888 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7889 fputc ('-', stdout
);
7890 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7893 #define PF(_m) if (tp->_m) printf (#_m " ");
7894 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7897 PF(Millicode_save_sr0
);
7898 /* PV(Region_description); */
7904 PF(Separate_Package_Body
);
7905 PF(Frame_Extension_Millicode
);
7906 PF(Stack_Overflow_Check
);
7907 PF(Two_Instruction_SP_Increment
);
7911 PF(sched_entry_seq
);
7914 PF(Save_MRP_in_frame
);
7915 PF(extn_ptr_defined
);
7916 PF(Cleanup_defined
);
7917 PF(MPE_XL_interrupt_marker
);
7918 PF(HP_UX_interrupt_marker
);
7921 PV(Total_frame_size
);
7934 slurp_hppa_unwind_table (Filedata
* filedata
,
7935 struct hppa_unw_aux_info
* aux
,
7936 Elf_Internal_Shdr
* sec
)
7938 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7939 Elf_Internal_Phdr
* seg
;
7940 struct hppa_unw_table_entry
* tep
;
7941 Elf_Internal_Shdr
* relsec
;
7942 Elf_Internal_Rela
* rela
;
7943 Elf_Internal_Rela
* rp
;
7944 unsigned char * table
;
7946 Elf_Internal_Sym
* sym
;
7947 const char * relname
;
7949 /* First, find the starting address of the segment that includes
7951 if (filedata
->file_header
.e_phnum
)
7953 if (! get_program_headers (filedata
))
7956 for (seg
= filedata
->program_headers
;
7957 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7960 if (seg
->p_type
!= PT_LOAD
)
7963 if (sec
->sh_addr
>= seg
->p_vaddr
7964 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7966 aux
->seg_base
= seg
->p_vaddr
;
7972 /* Second, build the unwind table from the contents of the unwind
7974 size
= sec
->sh_size
;
7975 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7981 nentries
= size
/ unw_ent_size
;
7982 size
= unw_ent_size
* nentries
;
7984 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7985 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7987 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7989 unsigned int tmp1
, tmp2
;
7991 tep
->start
.section
= SHN_UNDEF
;
7992 tep
->end
.section
= SHN_UNDEF
;
7994 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7995 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7996 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7997 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7999 tep
->start
.offset
+= aux
->seg_base
;
8000 tep
->end
.offset
+= aux
->seg_base
;
8002 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8003 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8004 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8005 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8006 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8007 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8008 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8009 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8010 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8011 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8012 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8013 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8014 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8015 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8016 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8017 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8018 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8019 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8020 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8021 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8022 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8023 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8024 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8025 tep
->Cleanup_defined
= tmp1
& 0x1;
8027 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8028 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8029 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8030 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8031 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8032 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8036 /* Third, apply any relocations to the unwind table. */
8037 for (relsec
= filedata
->section_headers
;
8038 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8041 if (relsec
->sh_type
!= SHT_RELA
8042 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8043 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8046 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8050 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8052 relname
= elf_hppa_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
8053 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
8055 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8056 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8058 warn (_("Skipping unexpected relocation type %s\n"), relname
);
8062 i
= rp
->r_offset
/ unw_ent_size
;
8064 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
8067 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8068 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8071 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8072 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8082 aux
->table_len
= nentries
;
8088 hppa_process_unwind (Filedata
* filedata
)
8090 struct hppa_unw_aux_info aux
;
8091 Elf_Internal_Shdr
* unwsec
= NULL
;
8092 Elf_Internal_Shdr
* strsec
;
8093 Elf_Internal_Shdr
* sec
;
8095 bfd_boolean res
= TRUE
;
8097 if (filedata
->string_table
== NULL
)
8100 memset (& aux
, 0, sizeof (aux
));
8102 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8104 if (sec
->sh_type
== SHT_SYMTAB
8105 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8107 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8109 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8110 if (aux
.strtab
!= NULL
)
8112 error (_("Multiple auxillary string tables encountered\n"));
8116 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8119 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8121 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8126 printf (_("\nThere are no unwind sections in this file.\n"));
8128 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8130 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8132 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8134 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8135 "contains %lu entry:\n",
8136 "\nUnwind section '%s' at offset 0x%lx "
8137 "contains %lu entries:\n",
8139 printable_section_name (filedata
, sec
),
8140 (unsigned long) sec
->sh_offset
,
8143 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8146 if (res
&& aux
.table_len
> 0)
8148 if (! dump_hppa_unwind (filedata
, &aux
))
8153 free ((char *) aux
.table
);
8161 free ((char *) aux
.strtab
);
8168 unsigned char * data
; /* The unwind data. */
8169 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8170 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8171 unsigned long nrelas
; /* The number of relocations. */
8172 unsigned int rel_type
; /* REL or RELA ? */
8173 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8176 struct arm_unw_aux_info
8178 Filedata
* filedata
; /* The file containing the unwind sections. */
8179 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8180 unsigned long nsyms
; /* Number of symbols. */
8181 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8182 unsigned long nfuns
; /* Number of these symbols. */
8183 char * strtab
; /* The file's string table. */
8184 unsigned long strtab_size
; /* Size of string table. */
8188 arm_print_vma_and_name (Filedata
* filedata
,
8189 struct arm_unw_aux_info
* aux
,
8191 struct absaddr addr
)
8193 const char *procname
;
8196 if (addr
.section
== SHN_UNDEF
)
8199 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8200 aux
->strtab_size
, addr
, &procname
,
8203 print_vma (fn
, PREFIX_HEX
);
8207 fputs (" <", stdout
);
8208 fputs (procname
, stdout
);
8211 printf ("+0x%lx", (unsigned long) sym_offset
);
8212 fputc ('>', stdout
);
8219 arm_free_section (struct arm_section
*arm_sec
)
8221 if (arm_sec
->data
!= NULL
)
8222 free (arm_sec
->data
);
8224 if (arm_sec
->rela
!= NULL
)
8225 free (arm_sec
->rela
);
8228 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8229 cached section and install SEC instead.
8230 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8231 and return its valued in * WORDP, relocating if necessary.
8232 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8233 relocation's offset in ADDR.
8234 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8235 into the string table of the symbol associated with the reloc. If no
8236 reloc was applied store -1 there.
8237 5) Return TRUE upon success, FALSE otherwise. */
8240 get_unwind_section_word (Filedata
* filedata
,
8241 struct arm_unw_aux_info
* aux
,
8242 struct arm_section
* arm_sec
,
8243 Elf_Internal_Shdr
* sec
,
8244 bfd_vma word_offset
,
8245 unsigned int * wordp
,
8246 struct absaddr
* addr
,
8249 Elf_Internal_Rela
*rp
;
8250 Elf_Internal_Sym
*sym
;
8251 const char * relname
;
8253 bfd_boolean wrapped
;
8255 if (sec
== NULL
|| arm_sec
== NULL
)
8258 addr
->section
= SHN_UNDEF
;
8261 if (sym_name
!= NULL
)
8262 *sym_name
= (bfd_vma
) -1;
8264 /* If necessary, update the section cache. */
8265 if (sec
!= arm_sec
->sec
)
8267 Elf_Internal_Shdr
*relsec
;
8269 arm_free_section (arm_sec
);
8272 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8273 sec
->sh_size
, _("unwind data"));
8274 arm_sec
->rela
= NULL
;
8275 arm_sec
->nrelas
= 0;
8277 for (relsec
= filedata
->section_headers
;
8278 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8281 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8282 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8283 /* PR 15745: Check the section type as well. */
8284 || (relsec
->sh_type
!= SHT_REL
8285 && relsec
->sh_type
!= SHT_RELA
))
8288 arm_sec
->rel_type
= relsec
->sh_type
;
8289 if (relsec
->sh_type
== SHT_REL
)
8291 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8293 & arm_sec
->rela
, & arm_sec
->nrelas
))
8296 else /* relsec->sh_type == SHT_RELA */
8298 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8300 & arm_sec
->rela
, & arm_sec
->nrelas
))
8306 arm_sec
->next_rela
= arm_sec
->rela
;
8309 /* If there is no unwind data we can do nothing. */
8310 if (arm_sec
->data
== NULL
)
8313 /* If the offset is invalid then fail. */
8314 if (/* PR 21343 *//* PR 18879 */
8316 || word_offset
> (sec
->sh_size
- 4)
8317 || ((bfd_signed_vma
) word_offset
) < 0)
8320 /* Get the word at the required offset. */
8321 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8323 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8324 if (arm_sec
->rela
== NULL
)
8330 /* Look through the relocs to find the one that applies to the provided offset. */
8332 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8334 bfd_vma prelval
, offset
;
8336 if (rp
->r_offset
> word_offset
&& !wrapped
)
8341 if (rp
->r_offset
> word_offset
)
8344 if (rp
->r_offset
& 3)
8346 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8347 (unsigned long) rp
->r_offset
);
8351 if (rp
->r_offset
< word_offset
)
8354 /* PR 17531: file: 027-161405-0.004 */
8355 if (aux
->symtab
== NULL
)
8358 if (arm_sec
->rel_type
== SHT_REL
)
8360 offset
= word
& 0x7fffffff;
8361 if (offset
& 0x40000000)
8362 offset
|= ~ (bfd_vma
) 0x7fffffff;
8364 else if (arm_sec
->rel_type
== SHT_RELA
)
8365 offset
= rp
->r_addend
;
8368 error (_("Unknown section relocation type %d encountered\n"),
8373 /* PR 17531 file: 027-1241568-0.004. */
8374 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8376 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8377 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8381 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8382 offset
+= sym
->st_value
;
8383 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8385 /* Check that we are processing the expected reloc type. */
8386 if (filedata
->file_header
.e_machine
== EM_ARM
)
8388 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8389 if (relname
== NULL
)
8391 warn (_("Skipping unknown ARM relocation type: %d\n"),
8392 (int) ELF32_R_TYPE (rp
->r_info
));
8396 if (streq (relname
, "R_ARM_NONE"))
8399 if (! streq (relname
, "R_ARM_PREL31"))
8401 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8405 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8407 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8408 if (relname
== NULL
)
8410 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8411 (int) ELF32_R_TYPE (rp
->r_info
));
8415 if (streq (relname
, "R_C6000_NONE"))
8418 if (! streq (relname
, "R_C6000_PREL31"))
8420 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8428 /* This function currently only supports ARM and TI unwinders. */
8429 warn (_("Only TI and ARM unwinders are currently supported\n"));
8433 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8434 addr
->section
= sym
->st_shndx
;
8435 addr
->offset
= offset
;
8438 * sym_name
= sym
->st_name
;
8443 arm_sec
->next_rela
= rp
;
8448 static const char *tic6x_unwind_regnames
[16] =
8450 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8451 "A14", "A13", "A12", "A11", "A10",
8452 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8456 decode_tic6x_unwind_regmask (unsigned int mask
)
8460 for (i
= 12; mask
; mask
>>= 1, i
--)
8464 fputs (tic6x_unwind_regnames
[i
], stdout
);
8466 fputs (", ", stdout
);
8472 if (remaining == 0 && more_words) \
8475 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8476 data_offset, & word, & addr, NULL)) \
8482 #define GET_OP(OP) \
8487 (OP) = word >> 24; \
8492 printf (_("[Truncated opcode]\n")); \
8495 printf ("0x%02x ", OP)
8498 decode_arm_unwind_bytecode (Filedata
* filedata
,
8499 struct arm_unw_aux_info
* aux
,
8501 unsigned int remaining
,
8502 unsigned int more_words
,
8503 bfd_vma data_offset
,
8504 Elf_Internal_Shdr
* data_sec
,
8505 struct arm_section
* data_arm_sec
)
8507 struct absaddr addr
;
8508 bfd_boolean res
= TRUE
;
8510 /* Decode the unwinding instructions. */
8513 unsigned int op
, op2
;
8522 printf (" 0x%02x ", op
);
8524 if ((op
& 0xc0) == 0x00)
8526 int offset
= ((op
& 0x3f) << 2) + 4;
8528 printf (" vsp = vsp + %d", offset
);
8530 else if ((op
& 0xc0) == 0x40)
8532 int offset
= ((op
& 0x3f) << 2) + 4;
8534 printf (" vsp = vsp - %d", offset
);
8536 else if ((op
& 0xf0) == 0x80)
8539 if (op
== 0x80 && op2
== 0)
8540 printf (_("Refuse to unwind"));
8543 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8544 bfd_boolean first
= TRUE
;
8548 for (i
= 0; i
< 12; i
++)
8549 if (mask
& (1 << i
))
8555 printf ("r%d", 4 + i
);
8560 else if ((op
& 0xf0) == 0x90)
8562 if (op
== 0x9d || op
== 0x9f)
8563 printf (_(" [Reserved]"));
8565 printf (" vsp = r%d", op
& 0x0f);
8567 else if ((op
& 0xf0) == 0xa0)
8569 int end
= 4 + (op
& 0x07);
8570 bfd_boolean first
= TRUE
;
8574 for (i
= 4; i
<= end
; i
++)
8590 else if (op
== 0xb0)
8591 printf (_(" finish"));
8592 else if (op
== 0xb1)
8595 if (op2
== 0 || (op2
& 0xf0) != 0)
8596 printf (_("[Spare]"));
8599 unsigned int mask
= op2
& 0x0f;
8600 bfd_boolean first
= TRUE
;
8604 for (i
= 0; i
< 12; i
++)
8605 if (mask
& (1 << i
))
8616 else if (op
== 0xb2)
8618 unsigned char buf
[9];
8619 unsigned int i
, len
;
8620 unsigned long offset
;
8622 for (i
= 0; i
< sizeof (buf
); i
++)
8625 if ((buf
[i
] & 0x80) == 0)
8628 if (i
== sizeof (buf
))
8630 error (_("corrupt change to vsp"));
8635 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8636 assert (len
== i
+ 1);
8637 offset
= offset
* 4 + 0x204;
8638 printf ("vsp = vsp + %ld", offset
);
8641 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8643 unsigned int first
, last
;
8650 printf ("pop {D%d", first
);
8652 printf ("-D%d", first
+ last
);
8655 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8657 unsigned int count
= op
& 0x07;
8661 printf ("-D%d", 8 + count
);
8664 else if (op
>= 0xc0 && op
<= 0xc5)
8666 unsigned int count
= op
& 0x07;
8668 printf (" pop {wR10");
8670 printf ("-wR%d", 10 + count
);
8673 else if (op
== 0xc6)
8675 unsigned int first
, last
;
8680 printf ("pop {wR%d", first
);
8682 printf ("-wR%d", first
+ last
);
8685 else if (op
== 0xc7)
8688 if (op2
== 0 || (op2
& 0xf0) != 0)
8689 printf (_("[Spare]"));
8692 unsigned int mask
= op2
& 0x0f;
8693 bfd_boolean first
= TRUE
;
8697 for (i
= 0; i
< 4; i
++)
8698 if (mask
& (1 << i
))
8704 printf ("wCGR%d", i
);
8711 printf (_(" [unsupported opcode]"));
8722 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8723 struct arm_unw_aux_info
* aux
,
8725 unsigned int remaining
,
8726 unsigned int more_words
,
8727 bfd_vma data_offset
,
8728 Elf_Internal_Shdr
* data_sec
,
8729 struct arm_section
* data_arm_sec
)
8731 struct absaddr addr
;
8733 /* Decode the unwinding instructions. */
8736 unsigned int op
, op2
;
8745 printf (" 0x%02x ", op
);
8747 if ((op
& 0xc0) == 0x00)
8749 int offset
= ((op
& 0x3f) << 3) + 8;
8750 printf (" sp = sp + %d", offset
);
8752 else if ((op
& 0xc0) == 0x80)
8755 if (op
== 0x80 && op2
== 0)
8756 printf (_("Refuse to unwind"));
8759 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8761 printf ("pop compact {");
8765 decode_tic6x_unwind_regmask (mask
);
8769 else if ((op
& 0xf0) == 0xc0)
8777 unsigned int offset
;
8781 /* Scan entire instruction first so that GET_OP output is not
8782 interleaved with disassembly. */
8784 for (i
= 0; nregs
< (op
& 0xf); i
++)
8790 regpos
[nregs
].offset
= i
* 2;
8791 regpos
[nregs
].reg
= reg
;
8798 regpos
[nregs
].offset
= i
* 2 + 1;
8799 regpos
[nregs
].reg
= reg
;
8804 printf (_("pop frame {"));
8806 for (i
= i
* 2; i
> 0; i
--)
8808 if (regpos
[reg
].offset
== i
- 1)
8810 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8817 fputs (name
, stdout
);
8824 else if (op
== 0xd0)
8825 printf (" MOV FP, SP");
8826 else if (op
== 0xd1)
8827 printf (" __c6xabi_pop_rts");
8828 else if (op
== 0xd2)
8830 unsigned char buf
[9];
8831 unsigned int i
, len
;
8832 unsigned long offset
;
8834 for (i
= 0; i
< sizeof (buf
); i
++)
8837 if ((buf
[i
] & 0x80) == 0)
8840 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8841 if (i
== sizeof (buf
))
8843 warn (_("Corrupt stack pointer adjustment detected\n"));
8847 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8848 assert (len
== i
+ 1);
8849 offset
= offset
* 8 + 0x408;
8850 printf (_("sp = sp + %ld"), offset
);
8852 else if ((op
& 0xf0) == 0xe0)
8854 if ((op
& 0x0f) == 7)
8857 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8861 printf (_(" [unsupported opcode]"));
8870 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8874 offset
= word
& 0x7fffffff;
8875 if (offset
& 0x40000000)
8876 offset
|= ~ (bfd_vma
) 0x7fffffff;
8878 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8881 return offset
+ where
;
8885 decode_arm_unwind (Filedata
* filedata
,
8886 struct arm_unw_aux_info
* aux
,
8888 unsigned int remaining
,
8889 bfd_vma data_offset
,
8890 Elf_Internal_Shdr
* data_sec
,
8891 struct arm_section
* data_arm_sec
)
8894 unsigned int more_words
= 0;
8895 struct absaddr addr
;
8896 bfd_vma sym_name
= (bfd_vma
) -1;
8897 bfd_boolean res
= TRUE
;
8901 /* Fetch the first word.
8902 Note - when decoding an object file the address extracted
8903 here will always be 0. So we also pass in the sym_name
8904 parameter so that we can find the symbol associated with
8905 the personality routine. */
8906 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8907 & word
, & addr
, & sym_name
))
8913 if ((word
& 0x80000000) == 0)
8915 /* Expand prel31 for personality routine. */
8917 const char *procname
;
8919 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8920 printf (_(" Personality routine: "));
8922 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8923 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8925 procname
= aux
->strtab
+ sym_name
;
8926 print_vma (fn
, PREFIX_HEX
);
8929 fputs (" <", stdout
);
8930 fputs (procname
, stdout
);
8931 fputc ('>', stdout
);
8935 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8936 fputc ('\n', stdout
);
8938 /* The GCC personality routines use the standard compact
8939 encoding, starting with one byte giving the number of
8941 if (procname
!= NULL
8942 && (const_strneq (procname
, "__gcc_personality_v0")
8943 || const_strneq (procname
, "__gxx_personality_v0")
8944 || const_strneq (procname
, "__gcj_personality_v0")
8945 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8952 printf (_(" [Truncated data]\n"));
8955 more_words
= word
>> 24;
8965 /* ARM EHABI Section 6.3:
8967 An exception-handling table entry for the compact model looks like:
8971 1 0 index Data for personalityRoutine[index] */
8973 if (filedata
->file_header
.e_machine
== EM_ARM
8974 && (word
& 0x70000000))
8976 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8980 per_index
= (word
>> 24) & 0x7f;
8981 printf (_(" Compact model index: %d\n"), per_index
);
8988 else if (per_index
< 3)
8990 more_words
= (word
>> 16) & 0xff;
8996 switch (filedata
->file_header
.e_machine
)
9001 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9002 data_offset
, data_sec
, data_arm_sec
))
9007 warn (_("Unknown ARM compact model index encountered\n"));
9008 printf (_(" [reserved]\n"));
9016 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9017 data_offset
, data_sec
, data_arm_sec
))
9020 else if (per_index
< 5)
9022 if (((word
>> 17) & 0x7f) == 0x7f)
9023 printf (_(" Restore stack from frame pointer\n"));
9025 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9026 printf (_(" Registers restored: "));
9028 printf (" (compact) ");
9029 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9031 printf (_(" Return register: %s\n"),
9032 tic6x_unwind_regnames
[word
& 0xf]);
9035 printf (_(" [reserved (%d)]\n"), per_index
);
9039 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9040 filedata
->file_header
.e_machine
);
9044 /* Decode the descriptors. Not implemented. */
9050 dump_arm_unwind (Filedata
* filedata
,
9051 struct arm_unw_aux_info
* aux
,
9052 Elf_Internal_Shdr
* exidx_sec
)
9054 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9055 unsigned int i
, exidx_len
;
9056 unsigned long j
, nfuns
;
9057 bfd_boolean res
= TRUE
;
9059 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9060 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9061 exidx_len
= exidx_sec
->sh_size
/ 8;
9063 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9064 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9065 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9066 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9068 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9070 for (i
= 0; i
< exidx_len
; i
++)
9072 unsigned int exidx_fn
, exidx_entry
;
9073 struct absaddr fn_addr
, entry_addr
;
9076 fputc ('\n', stdout
);
9078 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9079 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9080 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9081 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9084 arm_free_section (& exidx_arm_sec
);
9085 arm_free_section (& extab_arm_sec
);
9089 /* ARM EHABI, Section 5:
9090 An index table entry consists of 2 words.
9091 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9092 if (exidx_fn
& 0x80000000)
9094 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9098 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9100 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9101 fputs (": ", stdout
);
9103 if (exidx_entry
== 1)
9105 print_vma (exidx_entry
, PREFIX_HEX
);
9106 fputs (" [cantunwind]\n", stdout
);
9108 else if (exidx_entry
& 0x80000000)
9110 print_vma (exidx_entry
, PREFIX_HEX
);
9111 fputc ('\n', stdout
);
9112 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9116 bfd_vma table
, table_offset
= 0;
9117 Elf_Internal_Shdr
*table_sec
;
9119 fputs ("@", stdout
);
9120 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9121 print_vma (table
, PREFIX_HEX
);
9124 /* Locate the matching .ARM.extab. */
9125 if (entry_addr
.section
!= SHN_UNDEF
9126 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9128 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9129 table_offset
= entry_addr
.offset
;
9131 if (table_offset
> table_sec
->sh_size
9132 || ((bfd_signed_vma
) table_offset
) < 0)
9134 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9135 (unsigned long) table_offset
,
9136 printable_section_name (filedata
, table_sec
));
9143 table_sec
= find_section_by_address (filedata
, table
);
9144 if (table_sec
!= NULL
)
9145 table_offset
= table
- table_sec
->sh_addr
;
9148 if (table_sec
== NULL
)
9150 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9151 (unsigned long) table
);
9156 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9165 arm_free_section (&exidx_arm_sec
);
9166 arm_free_section (&extab_arm_sec
);
9171 /* Used for both ARM and C6X unwinding tables. */
9174 arm_process_unwind (Filedata
* filedata
)
9176 struct arm_unw_aux_info aux
;
9177 Elf_Internal_Shdr
*unwsec
= NULL
;
9178 Elf_Internal_Shdr
*strsec
;
9179 Elf_Internal_Shdr
*sec
;
9181 unsigned int sec_type
;
9182 bfd_boolean res
= TRUE
;
9184 switch (filedata
->file_header
.e_machine
)
9187 sec_type
= SHT_ARM_EXIDX
;
9191 sec_type
= SHT_C6000_UNWIND
;
9195 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9196 filedata
->file_header
.e_machine
);
9200 if (filedata
->string_table
== NULL
)
9203 memset (& aux
, 0, sizeof (aux
));
9204 aux
.filedata
= filedata
;
9206 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9208 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9210 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9212 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9214 /* PR binutils/17531 file: 011-12666-0.004. */
9215 if (aux
.strtab
!= NULL
)
9217 error (_("Multiple string tables found in file.\n"));
9221 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9222 1, strsec
->sh_size
, _("string table"));
9223 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9225 else if (sec
->sh_type
== sec_type
)
9230 printf (_("\nThere are no unwind sections in this file.\n"));
9232 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9234 if (sec
->sh_type
== sec_type
)
9236 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9237 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9238 "contains %lu entry:\n",
9239 "\nUnwind section '%s' at offset 0x%lx "
9240 "contains %lu entries:\n",
9242 printable_section_name (filedata
, sec
),
9243 (unsigned long) sec
->sh_offset
,
9246 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9254 free ((char *) aux
.strtab
);
9260 process_unwind (Filedata
* filedata
)
9262 struct unwind_handler
9264 unsigned int machtype
;
9265 bfd_boolean (* handler
)(Filedata
*);
9268 { EM_ARM
, arm_process_unwind
},
9269 { EM_IA_64
, ia64_process_unwind
},
9270 { EM_PARISC
, hppa_process_unwind
},
9271 { EM_TI_C6000
, arm_process_unwind
},
9279 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9280 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9281 return handlers
[i
].handler (filedata
);
9283 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9284 get_machine_name (filedata
->file_header
.e_machine
));
9289 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9291 switch (entry
->d_tag
)
9294 if (entry
->d_un
.d_val
== 0)
9298 static const char * opts
[] =
9300 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9301 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9302 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9303 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9307 bfd_boolean first
= TRUE
;
9309 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9310 if (entry
->d_un
.d_val
& (1 << cnt
))
9312 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9318 case DT_MIPS_IVERSION
:
9319 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9320 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9324 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9325 /* Note: coded this way so that there is a single string for translation. */
9326 printf (_("<corrupt: %s>"), buf
);
9330 case DT_MIPS_TIME_STAMP
:
9334 time_t atime
= entry
->d_un
.d_val
;
9336 tmp
= gmtime (&atime
);
9337 /* PR 17531: file: 6accc532. */
9339 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9341 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9342 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9343 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9344 printf (_("Time Stamp: %s"), timebuf
);
9348 case DT_MIPS_RLD_VERSION
:
9349 case DT_MIPS_LOCAL_GOTNO
:
9350 case DT_MIPS_CONFLICTNO
:
9351 case DT_MIPS_LIBLISTNO
:
9352 case DT_MIPS_SYMTABNO
:
9353 case DT_MIPS_UNREFEXTNO
:
9354 case DT_MIPS_HIPAGENO
:
9355 case DT_MIPS_DELTA_CLASS_NO
:
9356 case DT_MIPS_DELTA_INSTANCE_NO
:
9357 case DT_MIPS_DELTA_RELOC_NO
:
9358 case DT_MIPS_DELTA_SYM_NO
:
9359 case DT_MIPS_DELTA_CLASSSYM_NO
:
9360 case DT_MIPS_COMPACT_SIZE
:
9361 print_vma (entry
->d_un
.d_val
, DEC
);
9365 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9371 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9373 switch (entry
->d_tag
)
9375 case DT_HP_DLD_FLAGS
:
9384 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9385 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9386 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9387 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9388 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9389 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9390 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9391 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9392 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9393 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9394 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9395 { DT_HP_GST
, "HP_GST" },
9396 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9397 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9398 { DT_HP_NODELETE
, "HP_NODELETE" },
9399 { DT_HP_GROUP
, "HP_GROUP" },
9400 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9402 bfd_boolean first
= TRUE
;
9404 bfd_vma val
= entry
->d_un
.d_val
;
9406 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9407 if (val
& flags
[cnt
].bit
)
9411 fputs (flags
[cnt
].str
, stdout
);
9413 val
^= flags
[cnt
].bit
;
9416 if (val
!= 0 || first
)
9420 print_vma (val
, HEX
);
9426 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9434 /* VMS vs Unix time offset and factor. */
9436 #define VMS_EPOCH_OFFSET 35067168000000000LL
9437 #define VMS_GRANULARITY_FACTOR 10000000
9439 /* Display a VMS time in a human readable format. */
9442 print_vms_time (bfd_int64_t vmstime
)
9447 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9448 tm
= gmtime (&unxtime
);
9449 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9450 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9451 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9456 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9458 switch (entry
->d_tag
)
9460 case DT_IA_64_PLT_RESERVE
:
9461 /* First 3 slots reserved. */
9462 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9464 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9467 case DT_IA_64_VMS_LINKTIME
:
9469 print_vms_time (entry
->d_un
.d_val
);
9473 case DT_IA_64_VMS_LNKFLAGS
:
9474 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9475 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9476 printf (" CALL_DEBUG");
9477 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9478 printf (" NOP0BUFS");
9479 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9480 printf (" P0IMAGE");
9481 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9482 printf (" MKTHREADS");
9483 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9484 printf (" UPCALLS");
9485 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9487 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9488 printf (" INITIALIZE");
9489 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9491 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9492 printf (" EXE_INIT");
9493 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9494 printf (" TBK_IN_IMG");
9495 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9496 printf (" DBG_IN_IMG");
9497 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9498 printf (" TBK_IN_DSF");
9499 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9500 printf (" DBG_IN_DSF");
9501 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9502 printf (" SIGNATURES");
9503 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9504 printf (" REL_SEG_OFF");
9508 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9515 get_32bit_dynamic_section (Filedata
* filedata
)
9517 Elf32_External_Dyn
* edyn
;
9518 Elf32_External_Dyn
* ext
;
9519 Elf_Internal_Dyn
* entry
;
9521 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9522 dynamic_size
, _("dynamic section"));
9526 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9527 might not have the luxury of section headers. Look for the DT_NULL
9528 terminator to determine the number of entries. */
9529 for (ext
= edyn
, dynamic_nent
= 0;
9530 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9534 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9538 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9540 if (dynamic_section
== NULL
)
9542 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9543 (unsigned long) dynamic_nent
);
9548 for (ext
= edyn
, entry
= dynamic_section
;
9549 entry
< dynamic_section
+ dynamic_nent
;
9552 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9553 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9562 get_64bit_dynamic_section (Filedata
* filedata
)
9564 Elf64_External_Dyn
* edyn
;
9565 Elf64_External_Dyn
* ext
;
9566 Elf_Internal_Dyn
* entry
;
9568 /* Read in the data. */
9569 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9570 dynamic_size
, _("dynamic section"));
9574 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9575 might not have the luxury of section headers. Look for the DT_NULL
9576 terminator to determine the number of entries. */
9577 for (ext
= edyn
, dynamic_nent
= 0;
9578 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9579 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9583 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9587 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9589 if (dynamic_section
== NULL
)
9591 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9592 (unsigned long) dynamic_nent
);
9597 /* Convert from external to internal formats. */
9598 for (ext
= edyn
, entry
= dynamic_section
;
9599 entry
< dynamic_section
+ dynamic_nent
;
9602 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9603 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9612 print_dynamic_flags (bfd_vma flags
)
9614 bfd_boolean first
= TRUE
;
9620 flag
= flags
& - flags
;
9630 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9631 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9632 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9633 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9634 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9635 default: fputs (_("unknown"), stdout
); break;
9641 /* Parse and display the contents of the dynamic section. */
9644 process_dynamic_section (Filedata
* filedata
)
9646 Elf_Internal_Dyn
* entry
;
9648 if (dynamic_size
== 0)
9651 printf (_("\nThere is no dynamic section in this file.\n"));
9658 if (! get_32bit_dynamic_section (filedata
))
9663 if (! get_64bit_dynamic_section (filedata
))
9667 /* Find the appropriate symbol table. */
9668 if (dynamic_symbols
== NULL
)
9670 for (entry
= dynamic_section
;
9671 entry
< dynamic_section
+ dynamic_nent
;
9674 Elf_Internal_Shdr section
;
9676 if (entry
->d_tag
!= DT_SYMTAB
)
9679 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9681 /* Since we do not know how big the symbol table is,
9682 we default to reading in the entire file (!) and
9683 processing that. This is overkill, I know, but it
9685 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9686 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9688 /* See PR 21379 for a reproducer. */
9689 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9693 if (archive_file_offset
!= 0)
9694 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9696 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9699 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9701 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9702 section
.sh_name
= filedata
->string_table_length
;
9704 if (dynamic_symbols
!= NULL
)
9706 error (_("Multiple dynamic symbol table sections found\n"));
9707 free (dynamic_symbols
);
9709 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9710 if (num_dynamic_syms
< 1)
9712 error (_("Unable to determine the number of symbols to load\n"));
9718 /* Similarly find a string table. */
9719 if (dynamic_strings
== NULL
)
9721 for (entry
= dynamic_section
;
9722 entry
< dynamic_section
+ dynamic_nent
;
9725 unsigned long offset
;
9728 if (entry
->d_tag
!= DT_STRTAB
)
9731 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9733 /* Since we do not know how big the string table is,
9734 we default to reading in the entire file (!) and
9735 processing that. This is overkill, I know, but it
9738 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9740 if (archive_file_offset
!= 0)
9741 str_tab_len
= archive_file_size
- offset
;
9743 str_tab_len
= filedata
->file_size
- offset
;
9745 if (str_tab_len
< 1)
9748 (_("Unable to determine the length of the dynamic string table\n"));
9752 if (dynamic_strings
!= NULL
)
9754 error (_("Multiple dynamic string tables found\n"));
9755 free (dynamic_strings
);
9758 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9760 _("dynamic string table"));
9761 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9765 /* And find the syminfo section if available. */
9766 if (dynamic_syminfo
== NULL
)
9768 unsigned long syminsz
= 0;
9770 for (entry
= dynamic_section
;
9771 entry
< dynamic_section
+ dynamic_nent
;
9774 if (entry
->d_tag
== DT_SYMINENT
)
9776 /* Note: these braces are necessary to avoid a syntax
9777 error from the SunOS4 C compiler. */
9778 /* PR binutils/17531: A corrupt file can trigger this test.
9779 So do not use an assert, instead generate an error message. */
9780 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9781 error (_("Bad value (%d) for SYMINENT entry\n"),
9782 (int) entry
->d_un
.d_val
);
9784 else if (entry
->d_tag
== DT_SYMINSZ
)
9785 syminsz
= entry
->d_un
.d_val
;
9786 else if (entry
->d_tag
== DT_SYMINFO
)
9787 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9791 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9793 Elf_External_Syminfo
* extsyminfo
;
9794 Elf_External_Syminfo
* extsym
;
9795 Elf_Internal_Syminfo
* syminfo
;
9797 /* There is a syminfo section. Read the data. */
9798 extsyminfo
= (Elf_External_Syminfo
*)
9799 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9800 _("symbol information"));
9804 if (dynamic_syminfo
!= NULL
)
9806 error (_("Multiple dynamic symbol information sections found\n"));
9807 free (dynamic_syminfo
);
9809 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9810 if (dynamic_syminfo
== NULL
)
9812 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9813 (unsigned long) syminsz
);
9817 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9818 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9819 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9820 ++syminfo
, ++extsym
)
9822 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9823 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9830 if (do_dynamic
&& dynamic_addr
)
9831 printf (ngettext ("\nDynamic section at offset 0x%lx "
9832 "contains %lu entry:\n",
9833 "\nDynamic section at offset 0x%lx "
9834 "contains %lu entries:\n",
9836 dynamic_addr
, (unsigned long) dynamic_nent
);
9838 printf (_(" Tag Type Name/Value\n"));
9840 for (entry
= dynamic_section
;
9841 entry
< dynamic_section
+ dynamic_nent
;
9849 print_vma (entry
->d_tag
, FULL_HEX
);
9850 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9851 printf (" (%s)%*s", dtype
,
9852 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9855 switch (entry
->d_tag
)
9859 print_dynamic_flags (entry
->d_un
.d_val
);
9869 switch (entry
->d_tag
)
9872 printf (_("Auxiliary library"));
9876 printf (_("Filter library"));
9880 printf (_("Configuration file"));
9884 printf (_("Dependency audit library"));
9888 printf (_("Audit library"));
9892 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9893 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9897 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9906 printf (_("Flags:"));
9908 if (entry
->d_un
.d_val
== 0)
9909 printf (_(" None\n"));
9912 unsigned long int val
= entry
->d_un
.d_val
;
9914 if (val
& DTF_1_PARINIT
)
9916 printf (" PARINIT");
9917 val
^= DTF_1_PARINIT
;
9919 if (val
& DTF_1_CONFEXP
)
9921 printf (" CONFEXP");
9922 val
^= DTF_1_CONFEXP
;
9925 printf (" %lx", val
);
9934 printf (_("Flags:"));
9936 if (entry
->d_un
.d_val
== 0)
9937 printf (_(" None\n"));
9940 unsigned long int val
= entry
->d_un
.d_val
;
9942 if (val
& DF_P1_LAZYLOAD
)
9944 printf (" LAZYLOAD");
9945 val
^= DF_P1_LAZYLOAD
;
9947 if (val
& DF_P1_GROUPPERM
)
9949 printf (" GROUPPERM");
9950 val
^= DF_P1_GROUPPERM
;
9953 printf (" %lx", val
);
9962 printf (_("Flags:"));
9963 if (entry
->d_un
.d_val
== 0)
9964 printf (_(" None\n"));
9967 unsigned long int val
= entry
->d_un
.d_val
;
9974 if (val
& DF_1_GLOBAL
)
9979 if (val
& DF_1_GROUP
)
9984 if (val
& DF_1_NODELETE
)
9986 printf (" NODELETE");
9987 val
^= DF_1_NODELETE
;
9989 if (val
& DF_1_LOADFLTR
)
9991 printf (" LOADFLTR");
9992 val
^= DF_1_LOADFLTR
;
9994 if (val
& DF_1_INITFIRST
)
9996 printf (" INITFIRST");
9997 val
^= DF_1_INITFIRST
;
9999 if (val
& DF_1_NOOPEN
)
10001 printf (" NOOPEN");
10002 val
^= DF_1_NOOPEN
;
10004 if (val
& DF_1_ORIGIN
)
10006 printf (" ORIGIN");
10007 val
^= DF_1_ORIGIN
;
10009 if (val
& DF_1_DIRECT
)
10011 printf (" DIRECT");
10012 val
^= DF_1_DIRECT
;
10014 if (val
& DF_1_TRANS
)
10019 if (val
& DF_1_INTERPOSE
)
10021 printf (" INTERPOSE");
10022 val
^= DF_1_INTERPOSE
;
10024 if (val
& DF_1_NODEFLIB
)
10026 printf (" NODEFLIB");
10027 val
^= DF_1_NODEFLIB
;
10029 if (val
& DF_1_NODUMP
)
10031 printf (" NODUMP");
10032 val
^= DF_1_NODUMP
;
10034 if (val
& DF_1_CONFALT
)
10036 printf (" CONFALT");
10037 val
^= DF_1_CONFALT
;
10039 if (val
& DF_1_ENDFILTEE
)
10041 printf (" ENDFILTEE");
10042 val
^= DF_1_ENDFILTEE
;
10044 if (val
& DF_1_DISPRELDNE
)
10046 printf (" DISPRELDNE");
10047 val
^= DF_1_DISPRELDNE
;
10049 if (val
& DF_1_DISPRELPND
)
10051 printf (" DISPRELPND");
10052 val
^= DF_1_DISPRELPND
;
10054 if (val
& DF_1_NODIRECT
)
10056 printf (" NODIRECT");
10057 val
^= DF_1_NODIRECT
;
10059 if (val
& DF_1_IGNMULDEF
)
10061 printf (" IGNMULDEF");
10062 val
^= DF_1_IGNMULDEF
;
10064 if (val
& DF_1_NOKSYMS
)
10066 printf (" NOKSYMS");
10067 val
^= DF_1_NOKSYMS
;
10069 if (val
& DF_1_NOHDR
)
10074 if (val
& DF_1_EDITED
)
10076 printf (" EDITED");
10077 val
^= DF_1_EDITED
;
10079 if (val
& DF_1_NORELOC
)
10081 printf (" NORELOC");
10082 val
^= DF_1_NORELOC
;
10084 if (val
& DF_1_SYMINTPOSE
)
10086 printf (" SYMINTPOSE");
10087 val
^= DF_1_SYMINTPOSE
;
10089 if (val
& DF_1_GLOBAUDIT
)
10091 printf (" GLOBAUDIT");
10092 val
^= DF_1_GLOBAUDIT
;
10094 if (val
& DF_1_SINGLETON
)
10096 printf (" SINGLETON");
10097 val
^= DF_1_SINGLETON
;
10099 if (val
& DF_1_STUB
)
10104 if (val
& DF_1_PIE
)
10109 if (val
& DF_1_KMOD
)
10114 if (val
& DF_1_WEAKFILTER
)
10116 printf (" WEAKFILTER");
10117 val
^= DF_1_WEAKFILTER
;
10119 if (val
& DF_1_NOCOMMON
)
10121 printf (" NOCOMMON");
10122 val
^= DF_1_NOCOMMON
;
10125 printf (" %lx", val
);
10132 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10134 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10154 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10160 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10161 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10167 switch (entry
->d_tag
)
10170 printf (_("Shared library: [%s]"), name
);
10172 if (streq (name
, program_interpreter
))
10173 printf (_(" program interpreter"));
10177 printf (_("Library soname: [%s]"), name
);
10181 printf (_("Library rpath: [%s]"), name
);
10185 printf (_("Library runpath: [%s]"), name
);
10189 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10194 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10207 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10208 /* Fall through. */
10212 case DT_INIT_ARRAYSZ
:
10213 case DT_FINI_ARRAYSZ
:
10214 case DT_GNU_CONFLICTSZ
:
10215 case DT_GNU_LIBLISTSZ
:
10218 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10219 printf (_(" (bytes)\n"));
10224 case DT_VERNEEDNUM
:
10229 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10238 case DT_INIT_ARRAY
:
10239 case DT_FINI_ARRAY
:
10242 if (entry
->d_tag
== DT_USED
10243 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10245 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10249 printf (_("Not needed object: [%s]\n"), name
);
10254 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10260 /* The value of this entry is ignored. */
10265 case DT_GNU_PRELINKED
:
10269 time_t atime
= entry
->d_un
.d_val
;
10271 tmp
= gmtime (&atime
);
10272 /* PR 17533 file: 041-1244816-0.004. */
10274 printf (_("<corrupt time val: %lx"),
10275 (unsigned long) atime
);
10277 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10278 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10279 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10285 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10288 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10294 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10295 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10300 switch (filedata
->file_header
.e_machine
)
10303 case EM_MIPS_RS3_LE
:
10304 dynamic_section_mips_val (entry
);
10307 dynamic_section_parisc_val (entry
);
10310 dynamic_section_ia64_val (entry
);
10313 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10325 get_ver_flags (unsigned int flags
)
10327 static char buff
[128];
10334 if (flags
& VER_FLG_BASE
)
10335 strcat (buff
, "BASE");
10337 if (flags
& VER_FLG_WEAK
)
10339 if (flags
& VER_FLG_BASE
)
10340 strcat (buff
, " | ");
10342 strcat (buff
, "WEAK");
10345 if (flags
& VER_FLG_INFO
)
10347 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10348 strcat (buff
, " | ");
10350 strcat (buff
, "INFO");
10353 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10355 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10356 strcat (buff
, " | ");
10358 strcat (buff
, _("<unknown>"));
10364 /* Display the contents of the version sections. */
10367 process_version_sections (Filedata
* filedata
)
10369 Elf_Internal_Shdr
* section
;
10371 bfd_boolean found
= FALSE
;
10376 for (i
= 0, section
= filedata
->section_headers
;
10377 i
< filedata
->file_header
.e_shnum
;
10380 switch (section
->sh_type
)
10382 case SHT_GNU_verdef
:
10384 Elf_External_Verdef
* edefs
;
10391 printf (ngettext ("\nVersion definition section '%s' "
10392 "contains %u entry:\n",
10393 "\nVersion definition section '%s' "
10394 "contains %u entries:\n",
10396 printable_section_name (filedata
, section
),
10399 printf (_(" Addr: 0x"));
10400 printf_vma (section
->sh_addr
);
10401 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10402 (unsigned long) section
->sh_offset
, section
->sh_link
,
10403 printable_section_name_from_index (filedata
, section
->sh_link
));
10405 edefs
= (Elf_External_Verdef
*)
10406 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10407 _("version definition section"));
10410 endbuf
= (char *) edefs
+ section
->sh_size
;
10412 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10415 Elf_External_Verdef
* edef
;
10416 Elf_Internal_Verdef ent
;
10417 Elf_External_Verdaux
* eaux
;
10418 Elf_Internal_Verdaux aux
;
10419 unsigned long isum
;
10422 vstart
= ((char *) edefs
) + idx
;
10423 if (vstart
+ sizeof (*edef
) > endbuf
)
10426 edef
= (Elf_External_Verdef
*) vstart
;
10428 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10429 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10430 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10431 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10432 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10433 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10434 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10436 printf (_(" %#06lx: Rev: %d Flags: %s"),
10437 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10439 printf (_(" Index: %d Cnt: %d "),
10440 ent
.vd_ndx
, ent
.vd_cnt
);
10442 /* Check for overflow. */
10443 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10446 vstart
+= ent
.vd_aux
;
10448 if (vstart
+ sizeof (*eaux
) > endbuf
)
10450 eaux
= (Elf_External_Verdaux
*) vstart
;
10452 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10453 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10455 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10456 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10458 printf (_("Name index: %ld\n"), aux
.vda_name
);
10460 isum
= idx
+ ent
.vd_aux
;
10462 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10464 if (aux
.vda_next
< sizeof (*eaux
)
10465 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10467 warn (_("Invalid vda_next field of %lx\n"),
10472 /* Check for overflow. */
10473 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10476 isum
+= aux
.vda_next
;
10477 vstart
+= aux
.vda_next
;
10479 if (vstart
+ sizeof (*eaux
) > endbuf
)
10481 eaux
= (Elf_External_Verdaux
*) vstart
;
10483 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10484 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10486 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10487 printf (_(" %#06lx: Parent %d: %s\n"),
10488 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10490 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10491 isum
, j
, aux
.vda_name
);
10494 if (j
< ent
.vd_cnt
)
10495 printf (_(" Version def aux past end of section\n"));
10498 file: id:000001,src:000172+005151,op:splice,rep:2. */
10499 if (ent
.vd_next
< sizeof (*edef
)
10500 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10502 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10503 cnt
= section
->sh_info
;
10506 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10509 idx
+= ent
.vd_next
;
10512 if (cnt
< section
->sh_info
)
10513 printf (_(" Version definition past end of section\n"));
10519 case SHT_GNU_verneed
:
10521 Elf_External_Verneed
* eneed
;
10528 printf (ngettext ("\nVersion needs section '%s' "
10529 "contains %u entry:\n",
10530 "\nVersion needs section '%s' "
10531 "contains %u entries:\n",
10533 printable_section_name (filedata
, section
), section
->sh_info
);
10535 printf (_(" Addr: 0x"));
10536 printf_vma (section
->sh_addr
);
10537 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10538 (unsigned long) section
->sh_offset
, section
->sh_link
,
10539 printable_section_name_from_index (filedata
, section
->sh_link
));
10541 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10542 section
->sh_offset
, 1,
10544 _("Version Needs section"));
10547 endbuf
= (char *) eneed
+ section
->sh_size
;
10549 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10551 Elf_External_Verneed
* entry
;
10552 Elf_Internal_Verneed ent
;
10553 unsigned long isum
;
10557 vstart
= ((char *) eneed
) + idx
;
10558 if (vstart
+ sizeof (*entry
) > endbuf
)
10561 entry
= (Elf_External_Verneed
*) vstart
;
10563 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10564 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10565 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10566 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10567 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10569 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10571 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10572 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10574 printf (_(" File: %lx"), ent
.vn_file
);
10576 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10578 /* Check for overflow. */
10579 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10581 vstart
+= ent
.vn_aux
;
10583 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10585 Elf_External_Vernaux
* eaux
;
10586 Elf_Internal_Vernaux aux
;
10588 if (vstart
+ sizeof (*eaux
) > endbuf
)
10590 eaux
= (Elf_External_Vernaux
*) vstart
;
10592 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10593 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10594 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10595 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10596 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10598 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10599 printf (_(" %#06lx: Name: %s"),
10600 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10602 printf (_(" %#06lx: Name index: %lx"),
10603 isum
, aux
.vna_name
);
10605 printf (_(" Flags: %s Version: %d\n"),
10606 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10608 if (aux
.vna_next
< sizeof (*eaux
)
10609 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10611 warn (_("Invalid vna_next field of %lx\n"),
10616 /* Check for overflow. */
10617 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10619 isum
+= aux
.vna_next
;
10620 vstart
+= aux
.vna_next
;
10623 if (j
< ent
.vn_cnt
)
10624 warn (_("Missing Version Needs auxillary information\n"));
10626 if (ent
.vn_next
< sizeof (*entry
)
10627 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10629 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10630 cnt
= section
->sh_info
;
10633 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10635 idx
+= ent
.vn_next
;
10638 if (cnt
< section
->sh_info
)
10639 warn (_("Missing Version Needs information\n"));
10645 case SHT_GNU_versym
:
10647 Elf_Internal_Shdr
* link_section
;
10650 unsigned char * edata
;
10651 unsigned short * data
;
10653 Elf_Internal_Sym
* symbols
;
10654 Elf_Internal_Shdr
* string_sec
;
10655 unsigned long num_syms
;
10658 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10661 link_section
= filedata
->section_headers
+ section
->sh_link
;
10662 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10664 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10669 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10670 if (symbols
== NULL
)
10673 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10675 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10676 string_sec
->sh_size
,
10677 _("version string table"));
10684 printf (ngettext ("\nVersion symbols section '%s' "
10685 "contains %lu entry:\n",
10686 "\nVersion symbols section '%s' "
10687 "contains %lu entries:\n",
10689 printable_section_name (filedata
, section
), (unsigned long) total
);
10691 printf (_(" Addr: "));
10692 printf_vma (section
->sh_addr
);
10693 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10694 (unsigned long) section
->sh_offset
, section
->sh_link
,
10695 printable_section_name (filedata
, link_section
));
10697 off
= offset_from_vma (filedata
,
10698 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10699 total
* sizeof (short));
10700 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10702 _("version symbol data"));
10710 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10712 for (cnt
= total
; cnt
--;)
10713 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10718 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10722 char *invalid
= _("*invalid*");
10724 printf (" %03x:", cnt
);
10726 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10727 switch (data
[cnt
+ j
])
10730 fputs (_(" 0 (*local*) "), stdout
);
10734 fputs (_(" 1 (*global*) "), stdout
);
10738 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10739 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10741 /* If this index value is greater than the size of the symbols
10742 array, break to avoid an out-of-bounds read. */
10743 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10745 warn (_("invalid index into symbol array\n"));
10750 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10752 Elf_Internal_Verneed ivn
;
10753 unsigned long offset
;
10755 offset
= offset_from_vma
10756 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10757 sizeof (Elf_External_Verneed
));
10761 Elf_Internal_Vernaux ivna
;
10762 Elf_External_Verneed evn
;
10763 Elf_External_Vernaux evna
;
10764 unsigned long a_off
;
10766 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10767 _("version need")) == NULL
)
10770 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10771 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10773 a_off
= offset
+ ivn
.vn_aux
;
10777 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10778 1, _("version need aux (2)")) == NULL
)
10781 ivna
.vna_other
= 0;
10785 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10786 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10789 a_off
+= ivna
.vna_next
;
10791 while (ivna
.vna_other
!= data
[cnt
+ j
]
10792 && ivna
.vna_next
!= 0);
10794 if (ivna
.vna_other
== data
[cnt
+ j
])
10796 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10798 if (ivna
.vna_name
>= string_sec
->sh_size
)
10801 name
= strtab
+ ivna
.vna_name
;
10805 offset
+= ivn
.vn_next
;
10807 while (ivn
.vn_next
);
10810 if (data
[cnt
+ j
] != 0x8001
10811 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10813 Elf_Internal_Verdef ivd
;
10814 Elf_External_Verdef evd
;
10815 unsigned long offset
;
10817 offset
= offset_from_vma
10818 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10823 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10824 _("version def")) == NULL
)
10827 /* PR 17531: file: 046-1082287-0.004. */
10828 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10833 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10834 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10837 offset
+= ivd
.vd_next
;
10839 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10840 && ivd
.vd_next
!= 0);
10842 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10844 Elf_External_Verdaux evda
;
10845 Elf_Internal_Verdaux ivda
;
10847 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10849 if (get_data (&evda
, filedata
,
10850 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10852 _("version def aux")) == NULL
)
10855 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10857 if (ivda
.vda_name
>= string_sec
->sh_size
)
10859 else if (name
!= NULL
&& name
!= invalid
)
10860 name
= _("*both*");
10862 name
= strtab
+ ivda
.vda_name
;
10866 nn
+= printf ("(%s%-*s",
10868 12 - (int) strlen (name
),
10872 printf ("%*c", 18 - nn
, ' ');
10890 printf (_("\nNo version information found in this file.\n"));
10895 static const char *
10896 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10898 static char buff
[32];
10902 case STB_LOCAL
: return "LOCAL";
10903 case STB_GLOBAL
: return "GLOBAL";
10904 case STB_WEAK
: return "WEAK";
10906 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10907 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10909 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10911 if (binding
== STB_GNU_UNIQUE
10912 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10913 /* GNU is still using the default value 0. */
10914 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10916 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10919 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10924 static const char *
10925 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10927 static char buff
[32];
10931 case STT_NOTYPE
: return "NOTYPE";
10932 case STT_OBJECT
: return "OBJECT";
10933 case STT_FUNC
: return "FUNC";
10934 case STT_SECTION
: return "SECTION";
10935 case STT_FILE
: return "FILE";
10936 case STT_COMMON
: return "COMMON";
10937 case STT_TLS
: return "TLS";
10938 case STT_RELC
: return "RELC";
10939 case STT_SRELC
: return "SRELC";
10941 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10943 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10944 return "THUMB_FUNC";
10946 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10949 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10950 return "PARISC_MILLI";
10952 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10954 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10956 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10958 if (type
== STT_HP_OPAQUE
)
10959 return "HP_OPAQUE";
10960 if (type
== STT_HP_STUB
)
10964 if (type
== STT_GNU_IFUNC
10965 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10966 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10967 /* GNU is still using the default value 0. */
10968 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10971 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10974 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10979 static const char *
10980 get_symbol_visibility (unsigned int visibility
)
10982 switch (visibility
)
10984 case STV_DEFAULT
: return "DEFAULT";
10985 case STV_INTERNAL
: return "INTERNAL";
10986 case STV_HIDDEN
: return "HIDDEN";
10987 case STV_PROTECTED
: return "PROTECTED";
10989 error (_("Unrecognized visibility value: %u"), visibility
);
10990 return _("<unknown>");
10994 static const char *
10995 get_solaris_symbol_visibility (unsigned int visibility
)
10997 switch (visibility
)
10999 case 4: return "EXPORTED";
11000 case 5: return "SINGLETON";
11001 case 6: return "ELIMINATE";
11002 default: return get_symbol_visibility (visibility
);
11006 static const char *
11007 get_mips_symbol_other (unsigned int other
)
11011 case STO_OPTIONAL
: return "OPTIONAL";
11012 case STO_MIPS_PLT
: return "MIPS PLT";
11013 case STO_MIPS_PIC
: return "MIPS PIC";
11014 case STO_MICROMIPS
: return "MICROMIPS";
11015 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11016 case STO_MIPS16
: return "MIPS16";
11017 default: return NULL
;
11021 static const char *
11022 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11024 if (is_ia64_vms (filedata
))
11026 static char res
[32];
11030 /* Function types is for images and .STB files only. */
11031 switch (filedata
->file_header
.e_type
)
11035 switch (VMS_ST_FUNC_TYPE (other
))
11037 case VMS_SFT_CODE_ADDR
:
11038 strcat (res
, " CA");
11040 case VMS_SFT_SYMV_IDX
:
11041 strcat (res
, " VEC");
11044 strcat (res
, " FD");
11046 case VMS_SFT_RESERVE
:
11047 strcat (res
, " RSV");
11050 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11051 VMS_ST_FUNC_TYPE (other
));
11052 strcat (res
, " <unknown>");
11059 switch (VMS_ST_LINKAGE (other
))
11061 case VMS_STL_IGNORE
:
11062 strcat (res
, " IGN");
11064 case VMS_STL_RESERVE
:
11065 strcat (res
, " RSV");
11068 strcat (res
, " STD");
11071 strcat (res
, " LNK");
11074 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11075 VMS_ST_LINKAGE (other
));
11076 strcat (res
, " <unknown>");
11088 static const char *
11089 get_ppc64_symbol_other (unsigned int other
)
11091 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11094 other
>>= STO_PPC64_LOCAL_BIT
;
11097 static char buf
[32];
11099 other
= ppc64_decode_local_entry (other
);
11100 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11106 static const char *
11107 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11109 const char * result
= NULL
;
11110 static char buff
[32];
11115 switch (filedata
->file_header
.e_machine
)
11118 result
= get_mips_symbol_other (other
);
11121 result
= get_ia64_symbol_other (filedata
, other
);
11124 result
= get_ppc64_symbol_other (other
);
11134 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11138 static const char *
11139 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11141 static char buff
[32];
11145 case SHN_UNDEF
: return "UND";
11146 case SHN_ABS
: return "ABS";
11147 case SHN_COMMON
: return "COM";
11149 if (type
== SHN_IA_64_ANSI_COMMON
11150 && filedata
->file_header
.e_machine
== EM_IA_64
11151 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11153 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11154 || filedata
->file_header
.e_machine
== EM_L1OM
11155 || filedata
->file_header
.e_machine
== EM_K1OM
)
11156 && type
== SHN_X86_64_LCOMMON
)
11157 return "LARGE_COM";
11158 else if ((type
== SHN_MIPS_SCOMMON
11159 && filedata
->file_header
.e_machine
== EM_MIPS
)
11160 || (type
== SHN_TIC6X_SCOMMON
11161 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11163 else if (type
== SHN_MIPS_SUNDEFINED
11164 && filedata
->file_header
.e_machine
== EM_MIPS
)
11166 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11167 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11168 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11169 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11170 else if (type
>= SHN_LORESERVE
)
11171 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11172 else if (type
>= filedata
->file_header
.e_shnum
)
11173 sprintf (buff
, _("bad section index[%3d]"), type
);
11175 sprintf (buff
, "%3d", type
);
11183 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11185 unsigned char * e_data
;
11188 /* If the size_t type is smaller than the bfd_size_type, eg because
11189 you are building a 32-bit tool on a 64-bit host, then make sure
11190 that when (number) is cast to (size_t) no information is lost. */
11191 if (sizeof (size_t) < sizeof (bfd_size_type
)
11192 && (bfd_size_type
) ((size_t) number
) != number
)
11194 error (_("Size truncation prevents reading %s elements of size %u\n"),
11195 bfd_vmatoa ("u", number
), ent_size
);
11199 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11200 attempting to allocate memory when the read is bound to fail. */
11201 if (ent_size
* number
> filedata
->file_size
)
11203 error (_("Invalid number of dynamic entries: %s\n"),
11204 bfd_vmatoa ("u", number
));
11208 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11209 if (e_data
== NULL
)
11211 error (_("Out of memory reading %s dynamic entries\n"),
11212 bfd_vmatoa ("u", number
));
11216 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11218 error (_("Unable to read in %s bytes of dynamic data\n"),
11219 bfd_vmatoa ("u", number
* ent_size
));
11224 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11225 if (i_data
== NULL
)
11227 error (_("Out of memory allocating space for %s dynamic entries\n"),
11228 bfd_vmatoa ("u", number
));
11234 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11242 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11244 Elf_Internal_Sym
* psym
;
11247 n
= print_vma (si
, DEC_5
);
11249 fputs (&" "[n
], stdout
);
11250 printf (" %3lu: ", hn
);
11252 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11254 printf (_("<No info available for dynamic symbol number %lu>\n"),
11255 (unsigned long) si
);
11259 psym
= dynamic_symbols
+ si
;
11260 print_vma (psym
->st_value
, LONG_HEX
);
11262 print_vma (psym
->st_size
, DEC_5
);
11264 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11265 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11267 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11268 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11271 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11273 printf (" %-7s", get_symbol_visibility (vis
));
11274 /* Check to see if any other bits in the st_other field are set.
11275 Note - displaying this information disrupts the layout of the
11276 table being generated, but for the moment this case is very
11278 if (psym
->st_other
^ vis
)
11279 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11282 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11283 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11284 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11286 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11290 static const char *
11291 get_symbol_version_string (Filedata
* filedata
,
11292 bfd_boolean is_dynsym
,
11293 const char * strtab
,
11294 unsigned long int strtab_size
,
11296 Elf_Internal_Sym
* psym
,
11297 enum versioned_symbol_info
* sym_info
,
11298 unsigned short * vna_other
)
11300 unsigned char data
[2];
11301 unsigned short vers_data
;
11302 unsigned long offset
;
11305 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11308 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11309 sizeof data
+ si
* sizeof (vers_data
));
11311 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11312 sizeof (data
), 1, _("version data")) == NULL
)
11315 vers_data
= byte_get (data
, 2);
11317 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11320 /* Usually we'd only see verdef for defined symbols, and verneed for
11321 undefined symbols. However, symbols defined by the linker in
11322 .dynbss for variables copied from a shared library in order to
11323 avoid text relocations are defined yet have verneed. We could
11324 use a heuristic to detect the special case, for example, check
11325 for verneed first on symbols defined in SHT_NOBITS sections, but
11326 it is simpler and more reliable to just look for both verdef and
11327 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11329 if (psym
->st_shndx
!= SHN_UNDEF
11330 && vers_data
!= 0x8001
11331 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11333 Elf_Internal_Verdef ivd
;
11334 Elf_Internal_Verdaux ivda
;
11335 Elf_External_Verdaux evda
;
11338 off
= offset_from_vma (filedata
,
11339 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11340 sizeof (Elf_External_Verdef
));
11344 Elf_External_Verdef evd
;
11346 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11347 _("version def")) == NULL
)
11356 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11357 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11358 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11359 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11362 off
+= ivd
.vd_next
;
11364 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11366 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11368 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11371 off
-= ivd
.vd_next
;
11374 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11375 _("version def aux")) != NULL
)
11377 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11379 if (psym
->st_name
!= ivda
.vda_name
)
11381 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11382 ? symbol_hidden
: symbol_public
);
11383 return (ivda
.vda_name
< strtab_size
11384 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11390 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11392 Elf_External_Verneed evn
;
11393 Elf_Internal_Verneed ivn
;
11394 Elf_Internal_Vernaux ivna
;
11396 offset
= offset_from_vma (filedata
,
11397 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11401 unsigned long vna_off
;
11403 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11404 _("version need")) == NULL
)
11407 ivna
.vna_other
= 0;
11412 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11413 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11415 vna_off
= offset
+ ivn
.vn_aux
;
11419 Elf_External_Vernaux evna
;
11421 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11422 _("version need aux (3)")) == NULL
)
11425 ivna
.vna_other
= 0;
11430 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11431 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11432 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11435 vna_off
+= ivna
.vna_next
;
11437 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11439 if (ivna
.vna_other
== vers_data
)
11442 offset
+= ivn
.vn_next
;
11444 while (ivn
.vn_next
!= 0);
11446 if (ivna
.vna_other
== vers_data
)
11448 *sym_info
= symbol_undefined
;
11449 *vna_other
= ivna
.vna_other
;
11450 return (ivna
.vna_name
< strtab_size
11451 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11457 /* Dump the symbol table. */
11459 process_symbol_table (Filedata
* filedata
)
11461 Elf_Internal_Shdr
* section
;
11462 bfd_size_type nbuckets
= 0;
11463 bfd_size_type nchains
= 0;
11464 bfd_vma
* buckets
= NULL
;
11465 bfd_vma
* chains
= NULL
;
11466 bfd_vma ngnubuckets
= 0;
11467 bfd_vma
* gnubuckets
= NULL
;
11468 bfd_vma
* gnuchains
= NULL
;
11469 bfd_vma gnusymidx
= 0;
11470 bfd_size_type ngnuchains
= 0;
11472 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11475 if (dynamic_info
[DT_HASH
]
11477 || (do_using_dynamic
11479 && dynamic_strings
!= NULL
)))
11481 unsigned char nb
[8];
11482 unsigned char nc
[8];
11483 unsigned int hash_ent_size
= 4;
11485 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11486 || filedata
->file_header
.e_machine
== EM_S390
11487 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11488 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11491 if (fseek (filedata
->handle
,
11492 (archive_file_offset
11493 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11494 sizeof nb
+ sizeof nc
)),
11497 error (_("Unable to seek to start of dynamic information\n"));
11501 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11503 error (_("Failed to read in number of buckets\n"));
11507 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11509 error (_("Failed to read in number of chains\n"));
11513 nbuckets
= byte_get (nb
, hash_ent_size
);
11514 nchains
= byte_get (nc
, hash_ent_size
);
11516 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11517 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11520 if (buckets
== NULL
|| chains
== NULL
)
11522 if (do_using_dynamic
)
11533 if (dynamic_info_DT_GNU_HASH
11535 || (do_using_dynamic
11537 && dynamic_strings
!= NULL
)))
11539 unsigned char nb
[16];
11540 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11541 bfd_vma buckets_vma
;
11543 if (fseek (filedata
->handle
,
11544 (archive_file_offset
11545 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11549 error (_("Unable to seek to start of dynamic information\n"));
11553 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11555 error (_("Failed to read in number of buckets\n"));
11559 ngnubuckets
= byte_get (nb
, 4);
11560 gnusymidx
= byte_get (nb
+ 4, 4);
11561 bitmaskwords
= byte_get (nb
+ 8, 4);
11562 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11564 buckets_vma
+= bitmaskwords
* 4;
11566 buckets_vma
+= bitmaskwords
* 8;
11568 if (fseek (filedata
->handle
,
11569 (archive_file_offset
11570 + offset_from_vma (filedata
, buckets_vma
, 4)),
11573 error (_("Unable to seek to start of dynamic information\n"));
11577 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11579 if (gnubuckets
== NULL
)
11582 for (i
= 0; i
< ngnubuckets
; i
++)
11583 if (gnubuckets
[i
] != 0)
11585 if (gnubuckets
[i
] < gnusymidx
)
11588 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11589 maxchain
= gnubuckets
[i
];
11592 if (maxchain
== 0xffffffff)
11595 maxchain
-= gnusymidx
;
11597 if (fseek (filedata
->handle
,
11598 (archive_file_offset
11599 + offset_from_vma (filedata
, buckets_vma
11600 + 4 * (ngnubuckets
+ maxchain
), 4)),
11603 error (_("Unable to seek to start of dynamic information\n"));
11609 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11611 error (_("Failed to determine last chain length\n"));
11615 if (maxchain
+ 1 == 0)
11620 while ((byte_get (nb
, 4) & 1) == 0);
11622 if (fseek (filedata
->handle
,
11623 (archive_file_offset
11624 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11627 error (_("Unable to seek to start of dynamic information\n"));
11631 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11632 ngnuchains
= maxchain
;
11635 if (gnuchains
== NULL
)
11640 if (do_using_dynamic
)
11645 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11647 && do_using_dynamic
11648 && dynamic_strings
!= NULL
11649 && dynamic_symbols
!= NULL
)
11653 if (dynamic_info
[DT_HASH
])
11658 printf (_("\nSymbol table for image:\n"));
11660 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11662 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11664 visited
= xcmalloc (nchains
, 1);
11665 memset (visited
, 0, nchains
);
11666 for (hn
= 0; hn
< nbuckets
; hn
++)
11668 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11670 print_dynamic_symbol (filedata
, si
, hn
);
11671 if (si
>= nchains
|| visited
[si
])
11673 error (_("histogram chain is corrupt\n"));
11682 if (dynamic_info_DT_GNU_HASH
)
11684 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11686 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11688 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11690 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11691 if (gnubuckets
[hn
] != 0)
11693 bfd_vma si
= gnubuckets
[hn
];
11694 bfd_vma off
= si
- gnusymidx
;
11698 print_dynamic_symbol (filedata
, si
, hn
);
11701 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11705 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11706 && filedata
->section_headers
!= NULL
)
11710 for (i
= 0, section
= filedata
->section_headers
;
11711 i
< filedata
->file_header
.e_shnum
;
11715 char * strtab
= NULL
;
11716 unsigned long int strtab_size
= 0;
11717 Elf_Internal_Sym
* symtab
;
11718 Elf_Internal_Sym
* psym
;
11719 unsigned long num_syms
;
11721 if ((section
->sh_type
!= SHT_SYMTAB
11722 && section
->sh_type
!= SHT_DYNSYM
)
11724 && section
->sh_type
== SHT_SYMTAB
))
11727 if (section
->sh_entsize
== 0)
11729 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11730 printable_section_name (filedata
, section
));
11734 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11735 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11736 "\nSymbol table '%s' contains %lu entries:\n",
11738 printable_section_name (filedata
, section
),
11742 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11744 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11746 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11747 if (symtab
== NULL
)
11750 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11752 strtab
= filedata
->string_table
;
11753 strtab_size
= filedata
->string_table_length
;
11755 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11757 Elf_Internal_Shdr
* string_sec
;
11759 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11761 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11762 1, string_sec
->sh_size
,
11763 _("string table"));
11764 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11767 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11769 const char *version_string
;
11770 enum versioned_symbol_info sym_info
;
11771 unsigned short vna_other
;
11773 printf ("%6d: ", si
);
11774 print_vma (psym
->st_value
, LONG_HEX
);
11776 print_vma (psym
->st_size
, DEC_5
);
11777 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11778 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11779 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11780 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11783 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11785 printf (" %-7s", get_symbol_visibility (vis
));
11786 /* Check to see if any other bits in the st_other field are set.
11787 Note - displaying this information disrupts the layout of the
11788 table being generated, but for the moment this case is very rare. */
11789 if (psym
->st_other
^ vis
)
11790 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11792 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11793 print_symbol (25, psym
->st_name
< strtab_size
11794 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11797 = get_symbol_version_string (filedata
,
11798 section
->sh_type
== SHT_DYNSYM
,
11799 strtab
, strtab_size
, si
,
11800 psym
, &sym_info
, &vna_other
);
11801 if (version_string
)
11803 if (sym_info
== symbol_undefined
)
11804 printf ("@%s (%d)", version_string
, vna_other
);
11806 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11812 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11813 && si
>= section
->sh_info
11814 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11815 && filedata
->file_header
.e_machine
!= EM_MIPS
11816 /* Solaris binaries have been found to violate this requirement as
11817 well. Not sure if this is a bug or an ABI requirement. */
11818 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11819 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11820 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11824 if (strtab
!= filedata
->string_table
)
11830 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11832 if (do_histogram
&& buckets
!= NULL
)
11834 unsigned long * lengths
;
11835 unsigned long * counts
;
11838 unsigned long maxlength
= 0;
11839 unsigned long nzero_counts
= 0;
11840 unsigned long nsyms
= 0;
11843 printf (ngettext ("\nHistogram for bucket list length "
11844 "(total of %lu bucket):\n",
11845 "\nHistogram for bucket list length "
11846 "(total of %lu buckets):\n",
11847 (unsigned long) nbuckets
),
11848 (unsigned long) nbuckets
);
11850 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11851 if (lengths
== NULL
)
11853 error (_("Out of memory allocating space for histogram buckets\n"));
11856 visited
= xcmalloc (nchains
, 1);
11857 memset (visited
, 0, nchains
);
11859 printf (_(" Length Number %% of total Coverage\n"));
11860 for (hn
= 0; hn
< nbuckets
; ++hn
)
11862 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11865 if (maxlength
< ++lengths
[hn
])
11867 if (si
>= nchains
|| visited
[si
])
11869 error (_("histogram chain is corrupt\n"));
11877 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11878 if (counts
== NULL
)
11881 error (_("Out of memory allocating space for histogram counts\n"));
11885 for (hn
= 0; hn
< nbuckets
; ++hn
)
11886 ++counts
[lengths
[hn
]];
11891 printf (" 0 %-10lu (%5.1f%%)\n",
11892 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11893 for (i
= 1; i
<= maxlength
; ++i
)
11895 nzero_counts
+= counts
[i
] * i
;
11896 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11897 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11898 (nzero_counts
* 100.0) / nsyms
);
11906 if (buckets
!= NULL
)
11912 if (do_histogram
&& gnubuckets
!= NULL
)
11914 unsigned long * lengths
;
11915 unsigned long * counts
;
11917 unsigned long maxlength
= 0;
11918 unsigned long nzero_counts
= 0;
11919 unsigned long nsyms
= 0;
11921 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11922 "(total of %lu bucket):\n",
11923 "\nHistogram for `.gnu.hash' bucket list length "
11924 "(total of %lu buckets):\n",
11925 (unsigned long) ngnubuckets
),
11926 (unsigned long) ngnubuckets
);
11928 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11929 if (lengths
== NULL
)
11931 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11935 printf (_(" Length Number %% of total Coverage\n"));
11937 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11938 if (gnubuckets
[hn
] != 0)
11940 bfd_vma off
, length
= 1;
11942 for (off
= gnubuckets
[hn
] - gnusymidx
;
11943 /* PR 17531 file: 010-77222-0.004. */
11944 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11947 lengths
[hn
] = length
;
11948 if (length
> maxlength
)
11949 maxlength
= length
;
11953 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11954 if (counts
== NULL
)
11957 error (_("Out of memory allocating space for gnu histogram counts\n"));
11961 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11962 ++counts
[lengths
[hn
]];
11964 if (ngnubuckets
> 0)
11967 printf (" 0 %-10lu (%5.1f%%)\n",
11968 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11969 for (j
= 1; j
<= maxlength
; ++j
)
11971 nzero_counts
+= counts
[j
] * j
;
11972 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11973 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11974 (nzero_counts
* 100.0) / nsyms
);
11988 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
11992 if (dynamic_syminfo
== NULL
11994 /* No syminfo, this is ok. */
11997 /* There better should be a dynamic symbol section. */
11998 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12002 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12003 "contains %d entry:\n",
12004 "\nDynamic info segment at offset 0x%lx "
12005 "contains %d entries:\n",
12006 dynamic_syminfo_nent
),
12007 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12009 printf (_(" Num: Name BoundTo Flags\n"));
12010 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12012 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12014 printf ("%4d: ", i
);
12015 if (i
>= num_dynamic_syms
)
12016 printf (_("<corrupt index>"));
12017 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12018 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12020 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12023 switch (dynamic_syminfo
[i
].si_boundto
)
12025 case SYMINFO_BT_SELF
:
12026 fputs ("SELF ", stdout
);
12028 case SYMINFO_BT_PARENT
:
12029 fputs ("PARENT ", stdout
);
12032 if (dynamic_syminfo
[i
].si_boundto
> 0
12033 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12034 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12036 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12040 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12044 if (flags
& SYMINFO_FLG_DIRECT
)
12045 printf (" DIRECT");
12046 if (flags
& SYMINFO_FLG_PASSTHRU
)
12047 printf (" PASSTHRU");
12048 if (flags
& SYMINFO_FLG_COPY
)
12050 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12051 printf (" LAZYLOAD");
12059 #define IN_RANGE(START,END,ADDR,OFF) \
12060 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12062 /* Check to see if the given reloc needs to be handled in a target specific
12063 manner. If so then process the reloc and return TRUE otherwise return
12066 If called with reloc == NULL, then this is a signal that reloc processing
12067 for the current section has finished, and any saved state should be
12071 target_specific_reloc_handling (Filedata
* filedata
,
12072 Elf_Internal_Rela
* reloc
,
12073 unsigned char * start
,
12074 unsigned char * end
,
12075 Elf_Internal_Sym
* symtab
,
12076 unsigned long num_syms
)
12078 unsigned int reloc_type
= 0;
12079 unsigned long sym_index
= 0;
12083 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12084 sym_index
= get_reloc_symindex (reloc
->r_info
);
12087 switch (filedata
->file_header
.e_machine
)
12090 case EM_MSP430_OLD
:
12092 static Elf_Internal_Sym
* saved_sym
= NULL
;
12100 switch (reloc_type
)
12102 case 10: /* R_MSP430_SYM_DIFF */
12103 if (uses_msp430x_relocs (filedata
))
12105 /* Fall through. */
12106 case 21: /* R_MSP430X_SYM_DIFF */
12108 if (sym_index
>= num_syms
)
12109 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12112 saved_sym
= symtab
+ sym_index
;
12115 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12116 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12117 goto handle_sym_diff
;
12119 case 5: /* R_MSP430_16_BYTE */
12120 case 9: /* R_MSP430_8 */
12121 if (uses_msp430x_relocs (filedata
))
12123 goto handle_sym_diff
;
12125 case 2: /* R_MSP430_ABS16 */
12126 case 15: /* R_MSP430X_ABS16 */
12127 if (! uses_msp430x_relocs (filedata
))
12129 goto handle_sym_diff
;
12132 if (saved_sym
!= NULL
)
12134 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12137 if (sym_index
>= num_syms
)
12138 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12142 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12143 - saved_sym
->st_value
);
12145 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12146 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12149 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12150 (long) reloc
->r_offset
);
12159 if (saved_sym
!= NULL
)
12160 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12167 case EM_CYGNUS_MN10300
:
12169 static Elf_Internal_Sym
* saved_sym
= NULL
;
12177 switch (reloc_type
)
12179 case 34: /* R_MN10300_ALIGN */
12181 case 33: /* R_MN10300_SYM_DIFF */
12182 if (sym_index
>= num_syms
)
12183 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12186 saved_sym
= symtab
+ sym_index
;
12189 case 1: /* R_MN10300_32 */
12190 case 2: /* R_MN10300_16 */
12191 if (saved_sym
!= NULL
)
12193 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12196 if (sym_index
>= num_syms
)
12197 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12201 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12202 - saved_sym
->st_value
);
12204 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12205 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12207 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12208 (long) reloc
->r_offset
);
12216 if (saved_sym
!= NULL
)
12217 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12225 static bfd_vma saved_sym1
= 0;
12226 static bfd_vma saved_sym2
= 0;
12227 static bfd_vma value
;
12231 saved_sym1
= saved_sym2
= 0;
12235 switch (reloc_type
)
12237 case 0x80: /* R_RL78_SYM. */
12238 saved_sym1
= saved_sym2
;
12239 if (sym_index
>= num_syms
)
12240 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12244 saved_sym2
= symtab
[sym_index
].st_value
;
12245 saved_sym2
+= reloc
->r_addend
;
12249 case 0x83: /* R_RL78_OPsub. */
12250 value
= saved_sym1
- saved_sym2
;
12251 saved_sym2
= saved_sym1
= 0;
12255 case 0x41: /* R_RL78_ABS32. */
12256 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12257 byte_put (start
+ reloc
->r_offset
, value
, 4);
12259 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12260 (long) reloc
->r_offset
);
12264 case 0x43: /* R_RL78_ABS16. */
12265 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12266 byte_put (start
+ reloc
->r_offset
, value
, 2);
12268 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12269 (long) reloc
->r_offset
);
12283 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12284 DWARF debug sections. This is a target specific test. Note - we do not
12285 go through the whole including-target-headers-multiple-times route, (as
12286 we have already done with <elf/h8.h>) because this would become very
12287 messy and even then this function would have to contain target specific
12288 information (the names of the relocs instead of their numeric values).
12289 FIXME: This is not the correct way to solve this problem. The proper way
12290 is to have target specific reloc sizing and typing functions created by
12291 the reloc-macros.h header, in the same way that it already creates the
12292 reloc naming functions. */
12295 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12297 /* Please keep this table alpha-sorted for ease of visual lookup. */
12298 switch (filedata
->file_header
.e_machine
)
12302 return reloc_type
== 1; /* R_386_32. */
12304 return reloc_type
== 1; /* R_68K_32. */
12306 return reloc_type
== 1; /* R_860_32. */
12308 return reloc_type
== 2; /* R_960_32. */
12310 return (reloc_type
== 258
12311 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12312 case EM_ADAPTEVA_EPIPHANY
:
12313 return reloc_type
== 3;
12315 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12317 return reloc_type
== 1; /* R_ARC_32. */
12318 case EM_ARC_COMPACT
:
12319 case EM_ARC_COMPACT2
:
12320 return reloc_type
== 4; /* R_ARC_32. */
12322 return reloc_type
== 2; /* R_ARM_ABS32 */
12325 return reloc_type
== 1;
12327 return reloc_type
== 0x12; /* R_byte4_data. */
12329 return reloc_type
== 3; /* R_CRIS_32. */
12331 return reloc_type
== 3; /* R_CR16_NUM32. */
12333 return reloc_type
== 15; /* R_CRX_NUM32. */
12335 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12336 case EM_CYGNUS_FRV
:
12337 return reloc_type
== 1;
12338 case EM_CYGNUS_D10V
:
12340 return reloc_type
== 6; /* R_D10V_32. */
12341 case EM_CYGNUS_D30V
:
12343 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12345 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12346 case EM_CYGNUS_FR30
:
12348 return reloc_type
== 3; /* R_FR30_32. */
12350 return reloc_type
== 1; /* R_FT32_32. */
12354 return reloc_type
== 1; /* R_H8_DIR32. */
12356 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12357 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12358 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12359 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12362 return reloc_type
== 2; /* R_IP2K_32. */
12364 return reloc_type
== 2; /* R_IQ2000_32. */
12365 case EM_LATTICEMICO32
:
12366 return reloc_type
== 3; /* R_LM32_32. */
12369 return reloc_type
== 3; /* R_M32C_32. */
12371 return reloc_type
== 34; /* R_M32R_32_RELA. */
12374 return reloc_type
== 6; /* R_M68HC11_32. */
12376 return reloc_type
== 6; /* R_S12Z_EXT32. */
12378 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12379 case EM_CYGNUS_MEP
:
12380 return reloc_type
== 4; /* R_MEP_32. */
12382 return reloc_type
== 2; /* R_METAG_ADDR32. */
12383 case EM_MICROBLAZE
:
12384 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12386 return reloc_type
== 2; /* R_MIPS_32. */
12388 return reloc_type
== 4; /* R_MMIX_32. */
12389 case EM_CYGNUS_MN10200
:
12391 return reloc_type
== 1; /* R_MN10200_32. */
12392 case EM_CYGNUS_MN10300
:
12394 return reloc_type
== 1; /* R_MN10300_32. */
12396 return reloc_type
== 1; /* R_MOXIE_32. */
12397 case EM_MSP430_OLD
:
12399 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12401 return reloc_type
== 2; /* R_MT_32. */
12403 return reloc_type
== 20; /* R_NDS32_RELA. */
12404 case EM_ALTERA_NIOS2
:
12405 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12407 return reloc_type
== 1; /* R_NIOS_32. */
12409 return reloc_type
== 1; /* R_OR1K_32. */
12411 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12412 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12413 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12416 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12418 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12420 return reloc_type
== 1; /* R_PPC_ADDR32. */
12422 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12424 return reloc_type
== 1; /* R_RISCV_32. */
12426 return reloc_type
== 1; /* R_RL78_DIR32. */
12428 return reloc_type
== 1; /* R_RX_DIR32. */
12430 return reloc_type
== 1; /* R_I370_ADDR31. */
12433 return reloc_type
== 4; /* R_S390_32. */
12435 return reloc_type
== 8; /* R_SCORE_ABS32. */
12437 return reloc_type
== 1; /* R_SH_DIR32. */
12438 case EM_SPARC32PLUS
:
12441 return reloc_type
== 3 /* R_SPARC_32. */
12442 || reloc_type
== 23; /* R_SPARC_UA32. */
12444 return reloc_type
== 6; /* R_SPU_ADDR32 */
12446 return reloc_type
== 1; /* R_C6000_ABS32. */
12448 return reloc_type
== 2; /* R_TILEGX_32. */
12450 return reloc_type
== 1; /* R_TILEPRO_32. */
12451 case EM_CYGNUS_V850
:
12453 return reloc_type
== 6; /* R_V850_ABS32. */
12455 return reloc_type
== 0x33; /* R_V810_WORD. */
12457 return reloc_type
== 1; /* R_VAX_32. */
12459 return reloc_type
== 3; /* R_VISIUM_32. */
12460 case EM_WEBASSEMBLY
:
12461 return reloc_type
== 1; /* R_WASM32_32. */
12465 return reloc_type
== 10; /* R_X86_64_32. */
12468 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12470 return reloc_type
== 4; /* R_XGATE_32. */
12472 return reloc_type
== 1; /* R_XSTROMY16_32. */
12473 case EM_XTENSA_OLD
:
12475 return reloc_type
== 1; /* R_XTENSA_32. */
12478 static unsigned int prev_warn
= 0;
12480 /* Avoid repeating the same warning multiple times. */
12481 if (prev_warn
!= filedata
->file_header
.e_machine
)
12482 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12483 filedata
->file_header
.e_machine
);
12484 prev_warn
= filedata
->file_header
.e_machine
;
12490 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12491 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12494 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12496 switch (filedata
->file_header
.e_machine
)
12497 /* Please keep this table alpha-sorted for ease of visual lookup. */
12501 return reloc_type
== 2; /* R_386_PC32. */
12503 return reloc_type
== 4; /* R_68K_PC32. */
12505 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12506 case EM_ADAPTEVA_EPIPHANY
:
12507 return reloc_type
== 6;
12509 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12510 case EM_ARC_COMPACT
:
12511 case EM_ARC_COMPACT2
:
12512 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12514 return reloc_type
== 3; /* R_ARM_REL32 */
12517 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12518 case EM_MICROBLAZE
:
12519 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12521 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12523 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12525 return reloc_type
== 26; /* R_PPC_REL32. */
12527 return reloc_type
== 26; /* R_PPC64_REL32. */
12530 return reloc_type
== 5; /* R_390_PC32. */
12532 return reloc_type
== 2; /* R_SH_REL32. */
12533 case EM_SPARC32PLUS
:
12536 return reloc_type
== 6; /* R_SPARC_DISP32. */
12538 return reloc_type
== 13; /* R_SPU_REL32. */
12540 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12542 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12544 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12548 return reloc_type
== 2; /* R_X86_64_PC32. */
12549 case EM_XTENSA_OLD
:
12551 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12553 /* Do not abort or issue an error message here. Not all targets use
12554 pc-relative 32-bit relocs in their DWARF debug information and we
12555 have already tested for target coverage in is_32bit_abs_reloc. A
12556 more helpful warning message will be generated by apply_relocations
12557 anyway, so just return. */
12562 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12563 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12566 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12568 switch (filedata
->file_header
.e_machine
)
12571 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12573 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12575 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12576 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12578 return reloc_type
== 80; /* R_PARISC_DIR64. */
12580 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12582 return reloc_type
== 2; /* R_RISCV_64. */
12583 case EM_SPARC32PLUS
:
12586 return reloc_type
== 32 /* R_SPARC_64. */
12587 || reloc_type
== 54; /* R_SPARC_UA64. */
12591 return reloc_type
== 1; /* R_X86_64_64. */
12594 return reloc_type
== 22; /* R_S390_64. */
12596 return reloc_type
== 1; /* R_TILEGX_64. */
12598 return reloc_type
== 18; /* R_MIPS_64. */
12604 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12605 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12608 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12610 switch (filedata
->file_header
.e_machine
)
12613 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12615 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12617 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12618 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12620 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12622 return reloc_type
== 44; /* R_PPC64_REL64. */
12623 case EM_SPARC32PLUS
:
12626 return reloc_type
== 46; /* R_SPARC_DISP64. */
12630 return reloc_type
== 24; /* R_X86_64_PC64. */
12633 return reloc_type
== 23; /* R_S390_PC64. */
12635 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12641 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12642 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12645 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12647 switch (filedata
->file_header
.e_machine
)
12649 case EM_CYGNUS_MN10200
:
12651 return reloc_type
== 4; /* R_MN10200_24. */
12653 return reloc_type
== 5; /* R_FT32_20. */
12659 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12660 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12663 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12665 /* Please keep this table alpha-sorted for ease of visual lookup. */
12666 switch (filedata
->file_header
.e_machine
)
12669 case EM_ARC_COMPACT
:
12670 case EM_ARC_COMPACT2
:
12671 return reloc_type
== 2; /* R_ARC_16. */
12672 case EM_ADAPTEVA_EPIPHANY
:
12673 return reloc_type
== 5;
12676 return reloc_type
== 4; /* R_AVR_16. */
12677 case EM_CYGNUS_D10V
:
12679 return reloc_type
== 3; /* R_D10V_16. */
12681 return reloc_type
== 2; /* R_FT32_16. */
12685 return reloc_type
== R_H8_DIR16
;
12688 return reloc_type
== 1; /* R_IP2K_16. */
12691 return reloc_type
== 1; /* R_M32C_16 */
12692 case EM_CYGNUS_MN10200
:
12694 return reloc_type
== 2; /* R_MN10200_16. */
12695 case EM_CYGNUS_MN10300
:
12697 return reloc_type
== 2; /* R_MN10300_16. */
12699 if (uses_msp430x_relocs (filedata
))
12700 return reloc_type
== 2; /* R_MSP430_ABS16. */
12701 /* Fall through. */
12702 case EM_MSP430_OLD
:
12703 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12705 return reloc_type
== 19; /* R_NDS32_RELA. */
12706 case EM_ALTERA_NIOS2
:
12707 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12709 return reloc_type
== 9; /* R_NIOS_16. */
12711 return reloc_type
== 2; /* R_OR1K_16. */
12713 return reloc_type
== 55; /* R_RISCV_SET16. */
12715 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12717 return reloc_type
== 2; /* R_C6000_ABS16. */
12719 return reloc_type
== 2; /* R_VISIUM_16. */
12722 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12724 return reloc_type
== 3; /* R_XGATE_16. */
12730 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12731 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12734 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12736 switch (filedata
->file_header
.e_machine
)
12739 return reloc_type
== 54; /* R_RISCV_SET8. */
12745 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12746 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12749 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12751 switch (filedata
->file_header
.e_machine
)
12754 return reloc_type
== 53; /* R_RISCV_SET6. */
12760 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12761 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12764 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12766 /* Please keep this table alpha-sorted for ease of visual lookup. */
12767 switch (filedata
->file_header
.e_machine
)
12770 return reloc_type
== 35; /* R_RISCV_ADD32. */
12776 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12777 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12780 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12782 /* Please keep this table alpha-sorted for ease of visual lookup. */
12783 switch (filedata
->file_header
.e_machine
)
12786 return reloc_type
== 39; /* R_RISCV_SUB32. */
12792 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12793 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12796 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12798 /* Please keep this table alpha-sorted for ease of visual lookup. */
12799 switch (filedata
->file_header
.e_machine
)
12802 return reloc_type
== 36; /* R_RISCV_ADD64. */
12808 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12809 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12812 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12814 /* Please keep this table alpha-sorted for ease of visual lookup. */
12815 switch (filedata
->file_header
.e_machine
)
12818 return reloc_type
== 40; /* R_RISCV_SUB64. */
12824 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12825 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12828 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12830 /* Please keep this table alpha-sorted for ease of visual lookup. */
12831 switch (filedata
->file_header
.e_machine
)
12834 return reloc_type
== 34; /* R_RISCV_ADD16. */
12840 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12841 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12844 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12846 /* Please keep this table alpha-sorted for ease of visual lookup. */
12847 switch (filedata
->file_header
.e_machine
)
12850 return reloc_type
== 38; /* R_RISCV_SUB16. */
12856 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12857 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12860 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12862 /* Please keep this table alpha-sorted for ease of visual lookup. */
12863 switch (filedata
->file_header
.e_machine
)
12866 return reloc_type
== 33; /* R_RISCV_ADD8. */
12872 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12873 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12876 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12878 /* Please keep this table alpha-sorted for ease of visual lookup. */
12879 switch (filedata
->file_header
.e_machine
)
12882 return reloc_type
== 37; /* R_RISCV_SUB8. */
12888 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12889 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12892 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12894 switch (filedata
->file_header
.e_machine
)
12897 return reloc_type
== 52; /* R_RISCV_SUB6. */
12903 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12904 relocation entries (possibly formerly used for SHT_GROUP sections). */
12907 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12909 switch (filedata
->file_header
.e_machine
)
12911 case EM_386
: /* R_386_NONE. */
12912 case EM_68K
: /* R_68K_NONE. */
12913 case EM_ADAPTEVA_EPIPHANY
:
12914 case EM_ALPHA
: /* R_ALPHA_NONE. */
12915 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12916 case EM_ARC
: /* R_ARC_NONE. */
12917 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12918 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12919 case EM_ARM
: /* R_ARM_NONE. */
12920 case EM_C166
: /* R_XC16X_NONE. */
12921 case EM_CRIS
: /* R_CRIS_NONE. */
12922 case EM_FT32
: /* R_FT32_NONE. */
12923 case EM_IA_64
: /* R_IA64_NONE. */
12924 case EM_K1OM
: /* R_X86_64_NONE. */
12925 case EM_L1OM
: /* R_X86_64_NONE. */
12926 case EM_M32R
: /* R_M32R_NONE. */
12927 case EM_MIPS
: /* R_MIPS_NONE. */
12928 case EM_MN10300
: /* R_MN10300_NONE. */
12929 case EM_MOXIE
: /* R_MOXIE_NONE. */
12930 case EM_NIOS32
: /* R_NIOS_NONE. */
12931 case EM_OR1K
: /* R_OR1K_NONE. */
12932 case EM_PARISC
: /* R_PARISC_NONE. */
12933 case EM_PPC64
: /* R_PPC64_NONE. */
12934 case EM_PPC
: /* R_PPC_NONE. */
12935 case EM_RISCV
: /* R_RISCV_NONE. */
12936 case EM_S390
: /* R_390_NONE. */
12938 case EM_SH
: /* R_SH_NONE. */
12939 case EM_SPARC32PLUS
:
12940 case EM_SPARC
: /* R_SPARC_NONE. */
12942 case EM_TILEGX
: /* R_TILEGX_NONE. */
12943 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12944 case EM_TI_C6000
:/* R_C6000_NONE. */
12945 case EM_X86_64
: /* R_X86_64_NONE. */
12947 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12948 return reloc_type
== 0;
12951 return reloc_type
== 0 || reloc_type
== 256;
12954 return (reloc_type
== 0 /* R_AVR_NONE. */
12955 || reloc_type
== 30 /* R_AVR_DIFF8. */
12956 || reloc_type
== 31 /* R_AVR_DIFF16. */
12957 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12959 return reloc_type
== 3; /* R_METAG_NONE. */
12961 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12962 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12963 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12964 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12965 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12967 return (reloc_type
== 0 /* R_PRU_NONE. */
12968 || reloc_type
== 65 /* R_PRU_DIFF8. */
12969 || reloc_type
== 66 /* R_PRU_DIFF16. */
12970 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12971 case EM_XTENSA_OLD
:
12973 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12974 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12975 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12976 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12981 /* Returns TRUE if there is a relocation against
12982 section NAME at OFFSET bytes. */
12985 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12987 Elf_Internal_Rela
* relocs
;
12988 Elf_Internal_Rela
* rp
;
12990 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12993 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12995 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12996 if (rp
->r_offset
== offset
)
13002 /* Apply relocations to a section.
13003 Returns TRUE upon success, FALSE otherwise.
13004 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13005 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13006 will be set to the number of relocs loaded.
13008 Note: So far support has been added only for those relocations
13009 which can be found in debug sections. FIXME: Add support for
13010 more relocations ? */
13013 apply_relocations (Filedata
* filedata
,
13014 const Elf_Internal_Shdr
* section
,
13015 unsigned char * start
,
13016 bfd_size_type size
,
13017 void ** relocs_return
,
13018 unsigned long * num_relocs_return
)
13020 Elf_Internal_Shdr
* relsec
;
13021 unsigned char * end
= start
+ size
;
13022 bfd_boolean res
= TRUE
;
13024 if (relocs_return
!= NULL
)
13026 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13027 * num_relocs_return
= 0;
13030 if (filedata
->file_header
.e_type
!= ET_REL
)
13031 /* No relocs to apply. */
13034 /* Find the reloc section associated with the section. */
13035 for (relsec
= filedata
->section_headers
;
13036 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13039 bfd_boolean is_rela
;
13040 unsigned long num_relocs
;
13041 Elf_Internal_Rela
* relocs
;
13042 Elf_Internal_Rela
* rp
;
13043 Elf_Internal_Shdr
* symsec
;
13044 Elf_Internal_Sym
* symtab
;
13045 unsigned long num_syms
;
13046 Elf_Internal_Sym
* sym
;
13048 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13049 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13050 || filedata
->section_headers
+ relsec
->sh_info
!= section
13051 || relsec
->sh_size
== 0
13052 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13055 is_rela
= relsec
->sh_type
== SHT_RELA
;
13059 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13060 relsec
->sh_size
, & relocs
, & num_relocs
))
13065 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13066 relsec
->sh_size
, & relocs
, & num_relocs
))
13070 /* SH uses RELA but uses in place value instead of the addend field. */
13071 if (filedata
->file_header
.e_machine
== EM_SH
)
13074 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13075 if (symsec
->sh_type
!= SHT_SYMTAB
13076 && symsec
->sh_type
!= SHT_DYNSYM
)
13078 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13080 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13083 unsigned int reloc_type
;
13084 unsigned int reloc_size
;
13085 bfd_boolean reloc_inplace
= FALSE
;
13086 bfd_boolean reloc_subtract
= FALSE
;
13087 unsigned char * rloc
;
13088 unsigned long sym_index
;
13090 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13092 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13094 else if (is_none_reloc (filedata
, reloc_type
))
13096 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13097 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13099 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13100 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13102 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13104 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13106 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13107 || is_6bit_abs_reloc (filedata
, reloc_type
))
13109 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13111 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13114 reloc_inplace
= TRUE
;
13116 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13118 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13121 reloc_inplace
= TRUE
;
13123 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13125 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13128 reloc_inplace
= TRUE
;
13130 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13132 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13135 reloc_inplace
= TRUE
;
13137 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13141 reloc_inplace
= TRUE
;
13145 static unsigned int prev_reloc
= 0;
13147 if (reloc_type
!= prev_reloc
)
13148 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13149 reloc_type
, printable_section_name (filedata
, section
));
13150 prev_reloc
= reloc_type
;
13155 rloc
= start
+ rp
->r_offset
;
13156 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
13158 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13159 (unsigned long) rp
->r_offset
,
13160 printable_section_name (filedata
, section
));
13165 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13166 if (sym_index
>= num_syms
)
13168 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13169 sym_index
, printable_section_name (filedata
, section
));
13173 sym
= symtab
+ sym_index
;
13175 /* If the reloc has a symbol associated with it,
13176 make sure that it is of an appropriate type.
13178 Relocations against symbols without type can happen.
13179 Gcc -feliminate-dwarf2-dups may generate symbols
13180 without type for debug info.
13182 Icc generates relocations against function symbols
13183 instead of local labels.
13185 Relocations against object symbols can happen, eg when
13186 referencing a global array. For an example of this see
13187 the _clz.o binary in libgcc.a. */
13189 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13190 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13192 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13193 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13194 printable_section_name (filedata
, relsec
),
13195 (long int)(rp
- relocs
));
13202 addend
+= rp
->r_addend
;
13203 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13204 partial_inplace. */
13206 || (filedata
->file_header
.e_machine
== EM_XTENSA
13207 && reloc_type
== 1)
13208 || ((filedata
->file_header
.e_machine
== EM_PJ
13209 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13210 && reloc_type
== 1)
13211 || ((filedata
->file_header
.e_machine
== EM_D30V
13212 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13213 && reloc_type
== 12)
13216 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13217 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13219 addend
+= byte_get (rloc
, reloc_size
);
13222 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13223 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13225 /* On HPPA, all pc-relative relocations are biased by 8. */
13226 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13228 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13231 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13232 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13234 if (reloc_subtract
)
13235 addend
-= sym
->st_value
;
13237 addend
+= sym
->st_value
;
13238 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13239 byte_put (rloc
, addend
, reloc_size
);
13241 else if (reloc_subtract
)
13242 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13244 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13248 /* Let the target specific reloc processing code know that
13249 we have finished with these relocs. */
13250 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13254 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13255 * num_relocs_return
= num_relocs
;
13266 #ifdef SUPPORT_DISASSEMBLY
13268 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13270 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13272 /* FIXME: XXX -- to be done --- XXX */
13278 /* Reads in the contents of SECTION from FILE, returning a pointer
13279 to a malloc'ed buffer or NULL if something went wrong. */
13282 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13284 bfd_size_type num_bytes
= section
->sh_size
;
13286 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13288 printf (_("Section '%s' has no data to dump.\n"),
13289 printable_section_name (filedata
, section
));
13293 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13294 _("section contents"));
13297 /* Uncompresses a section that was compressed using zlib, in place. */
13300 uncompress_section_contents (unsigned char ** buffer
,
13301 dwarf_size_type uncompressed_size
,
13302 dwarf_size_type
* size
)
13304 dwarf_size_type compressed_size
= *size
;
13305 unsigned char * compressed_buffer
= *buffer
;
13306 unsigned char * uncompressed_buffer
;
13310 /* It is possible the section consists of several compressed
13311 buffers concatenated together, so we uncompress in a loop. */
13312 /* PR 18313: The state field in the z_stream structure is supposed
13313 to be invisible to the user (ie us), but some compilers will
13314 still complain about it being used without initialisation. So
13315 we first zero the entire z_stream structure and then set the fields
13317 memset (& strm
, 0, sizeof strm
);
13318 strm
.avail_in
= compressed_size
;
13319 strm
.next_in
= (Bytef
*) compressed_buffer
;
13320 strm
.avail_out
= uncompressed_size
;
13321 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13323 rc
= inflateInit (& strm
);
13324 while (strm
.avail_in
> 0)
13328 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13329 + (uncompressed_size
- strm
.avail_out
));
13330 rc
= inflate (&strm
, Z_FINISH
);
13331 if (rc
!= Z_STREAM_END
)
13333 rc
= inflateReset (& strm
);
13335 rc
= inflateEnd (& strm
);
13337 || strm
.avail_out
!= 0)
13340 *buffer
= uncompressed_buffer
;
13341 *size
= uncompressed_size
;
13345 free (uncompressed_buffer
);
13346 /* Indicate decompression failure. */
13352 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13354 Elf_Internal_Shdr
* relsec
;
13355 bfd_size_type num_bytes
;
13356 unsigned char * data
;
13357 unsigned char * end
;
13358 unsigned char * real_start
;
13359 unsigned char * start
;
13360 bfd_boolean some_strings_shown
;
13362 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13364 /* PR 21820: Do not fail if the section was empty. */
13365 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13367 num_bytes
= section
->sh_size
;
13369 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13371 if (decompress_dumps
)
13373 dwarf_size_type new_size
= num_bytes
;
13374 dwarf_size_type uncompressed_size
= 0;
13376 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13378 Elf_Internal_Chdr chdr
;
13379 unsigned int compression_header_size
13380 = get_compression_header (& chdr
, (unsigned char *) start
,
13383 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13385 warn (_("section '%s' has unsupported compress type: %d\n"),
13386 printable_section_name (filedata
, section
), chdr
.ch_type
);
13389 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13391 warn (_("compressed section '%s' is corrupted\n"),
13392 printable_section_name (filedata
, section
));
13395 uncompressed_size
= chdr
.ch_size
;
13396 start
+= compression_header_size
;
13397 new_size
-= compression_header_size
;
13399 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13401 /* Read the zlib header. In this case, it should be "ZLIB"
13402 followed by the uncompressed section size, 8 bytes in
13403 big-endian order. */
13404 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13405 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13406 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13407 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13408 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13409 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13410 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13411 uncompressed_size
+= start
[11];
13416 if (uncompressed_size
)
13418 if (uncompress_section_contents (& start
,
13419 uncompressed_size
, & new_size
))
13420 num_bytes
= new_size
;
13423 error (_("Unable to decompress section %s\n"),
13424 printable_section_name (filedata
, section
));
13429 start
= real_start
;
13432 /* If the section being dumped has relocations against it the user might
13433 be expecting these relocations to have been applied. Check for this
13434 case and issue a warning message in order to avoid confusion.
13435 FIXME: Maybe we ought to have an option that dumps a section with
13436 relocs applied ? */
13437 for (relsec
= filedata
->section_headers
;
13438 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13441 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13442 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13443 || filedata
->section_headers
+ relsec
->sh_info
!= section
13444 || relsec
->sh_size
== 0
13445 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13448 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13453 end
= start
+ num_bytes
;
13454 some_strings_shown
= FALSE
;
13458 while (!ISPRINT (* data
))
13459 if (++ data
>= end
)
13464 size_t maxlen
= end
- data
;
13467 /* PR 11128: Use two separate invocations in order to work
13468 around bugs in the Solaris 8 implementation of printf. */
13469 printf (" [%6tx] ", data
- start
);
13471 printf (" [%6Ix] ", (size_t) (data
- start
));
13475 print_symbol ((int) maxlen
, (const char *) data
);
13477 data
+= strnlen ((const char *) data
, maxlen
);
13481 printf (_("<corrupt>\n"));
13484 some_strings_shown
= TRUE
;
13488 if (! some_strings_shown
)
13489 printf (_(" No strings found in this section."));
13498 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13499 Filedata
* filedata
,
13500 bfd_boolean relocate
)
13502 Elf_Internal_Shdr
* relsec
;
13503 bfd_size_type bytes
;
13504 bfd_size_type section_size
;
13506 unsigned char * data
;
13507 unsigned char * real_start
;
13508 unsigned char * start
;
13510 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13512 /* PR 21820: Do not fail if the section was empty. */
13513 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13515 section_size
= section
->sh_size
;
13517 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13519 if (decompress_dumps
)
13521 dwarf_size_type new_size
= section_size
;
13522 dwarf_size_type uncompressed_size
= 0;
13524 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13526 Elf_Internal_Chdr chdr
;
13527 unsigned int compression_header_size
13528 = get_compression_header (& chdr
, start
, section_size
);
13530 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13532 warn (_("section '%s' has unsupported compress type: %d\n"),
13533 printable_section_name (filedata
, section
), chdr
.ch_type
);
13536 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13538 warn (_("compressed section '%s' is corrupted\n"),
13539 printable_section_name (filedata
, section
));
13542 uncompressed_size
= chdr
.ch_size
;
13543 start
+= compression_header_size
;
13544 new_size
-= compression_header_size
;
13546 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13548 /* Read the zlib header. In this case, it should be "ZLIB"
13549 followed by the uncompressed section size, 8 bytes in
13550 big-endian order. */
13551 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13552 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13553 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13554 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13555 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13556 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13557 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13558 uncompressed_size
+= start
[11];
13563 if (uncompressed_size
)
13565 if (uncompress_section_contents (& start
, uncompressed_size
,
13568 section_size
= new_size
;
13572 error (_("Unable to decompress section %s\n"),
13573 printable_section_name (filedata
, section
));
13574 /* FIXME: Print the section anyway ? */
13579 start
= real_start
;
13584 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13589 /* If the section being dumped has relocations against it the user might
13590 be expecting these relocations to have been applied. Check for this
13591 case and issue a warning message in order to avoid confusion.
13592 FIXME: Maybe we ought to have an option that dumps a section with
13593 relocs applied ? */
13594 for (relsec
= filedata
->section_headers
;
13595 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13598 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13599 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13600 || filedata
->section_headers
+ relsec
->sh_info
!= section
13601 || relsec
->sh_size
== 0
13602 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13605 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13610 addr
= section
->sh_addr
;
13611 bytes
= section_size
;
13620 lbytes
= (bytes
> 16 ? 16 : bytes
);
13622 printf (" 0x%8.8lx ", (unsigned long) addr
);
13624 for (j
= 0; j
< 16; j
++)
13627 printf ("%2.2x", data
[j
]);
13635 for (j
= 0; j
< lbytes
; j
++)
13638 if (k
>= ' ' && k
< 0x7f)
13658 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13659 const Elf_Internal_Shdr
* sec
,
13662 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13664 Filedata
* filedata
= (Filedata
*) data
;
13666 if (section
->start
!= NULL
)
13668 /* If it is already loaded, do nothing. */
13669 if (streq (section
->filename
, filedata
->file_name
))
13671 free (section
->start
);
13674 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13675 section
->address
= sec
->sh_addr
;
13676 section
->user_data
= NULL
;
13677 section
->filename
= filedata
->file_name
;
13678 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13680 sec
->sh_size
, buf
);
13681 if (section
->start
== NULL
)
13685 unsigned char *start
= section
->start
;
13686 dwarf_size_type size
= sec
->sh_size
;
13687 dwarf_size_type uncompressed_size
= 0;
13689 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13691 Elf_Internal_Chdr chdr
;
13692 unsigned int compression_header_size
;
13694 if (size
< (is_32bit_elf
13695 ? sizeof (Elf32_External_Chdr
)
13696 : sizeof (Elf64_External_Chdr
)))
13698 warn (_("compressed section %s is too small to contain a compression header"),
13703 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13705 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13707 warn (_("section '%s' has unsupported compress type: %d\n"),
13708 section
->name
, chdr
.ch_type
);
13711 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13713 warn (_("compressed section '%s' is corrupted\n"),
13717 uncompressed_size
= chdr
.ch_size
;
13718 start
+= compression_header_size
;
13719 size
-= compression_header_size
;
13721 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13723 /* Read the zlib header. In this case, it should be "ZLIB"
13724 followed by the uncompressed section size, 8 bytes in
13725 big-endian order. */
13726 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13727 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13728 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13729 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13730 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13731 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13732 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13733 uncompressed_size
+= start
[11];
13738 if (uncompressed_size
)
13740 if (uncompress_section_contents (&start
, uncompressed_size
,
13743 /* Free the compressed buffer, update the section buffer
13744 and the section size if uncompress is successful. */
13745 free (section
->start
);
13746 section
->start
= start
;
13750 error (_("Unable to decompress section %s\n"),
13751 printable_section_name (filedata
, sec
));
13756 section
->size
= size
;
13759 if (section
->start
== NULL
)
13762 if (debug_displays
[debug
].relocate
)
13764 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13765 & section
->reloc_info
, & section
->num_relocs
))
13770 section
->reloc_info
= NULL
;
13771 section
->num_relocs
= 0;
13777 /* If this is not NULL, load_debug_section will only look for sections
13778 within the list of sections given here. */
13779 static unsigned int * section_subset
= NULL
;
13782 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13784 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13785 Elf_Internal_Shdr
* sec
;
13786 Filedata
* filedata
= (Filedata
*) data
;
13788 /* Without section headers we cannot find any sections. */
13789 if (filedata
->section_headers
== NULL
)
13792 if (filedata
->string_table
== NULL
13793 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13794 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13796 Elf_Internal_Shdr
* strs
;
13798 /* Read in the string table, so that we have section names to scan. */
13799 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13801 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13803 filedata
->string_table
13804 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13805 1, strs
->sh_size
, _("string table"));
13807 filedata
->string_table_length
13808 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13812 /* Locate the debug section. */
13813 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13815 section
->name
= section
->uncompressed_name
;
13818 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13820 section
->name
= section
->compressed_name
;
13825 /* If we're loading from a subset of sections, and we've loaded
13826 a section matching this name before, it's likely that it's a
13828 if (section_subset
!= NULL
)
13829 free_debug_section (debug
);
13831 return load_specific_debug_section (debug
, sec
, data
);
13835 free_debug_section (enum dwarf_section_display_enum debug
)
13837 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13839 if (section
->start
== NULL
)
13842 free ((char *) section
->start
);
13843 section
->start
= NULL
;
13844 section
->address
= 0;
13849 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13851 char * name
= SECTION_NAME (section
);
13852 const char * print_name
= printable_section_name (filedata
, section
);
13853 bfd_size_type length
;
13854 bfd_boolean result
= TRUE
;
13857 length
= section
->sh_size
;
13860 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13863 if (section
->sh_type
== SHT_NOBITS
)
13865 /* There is no point in dumping the contents of a debugging section
13866 which has the NOBITS type - the bits in the file will be random.
13867 This can happen when a file containing a .eh_frame section is
13868 stripped with the --only-keep-debug command line option. */
13869 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13874 if (const_strneq (name
, ".gnu.linkonce.wi."))
13875 name
= ".debug_info";
13877 /* See if we know how to display the contents of this section. */
13878 for (i
= 0; i
< max
; i
++)
13880 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13881 struct dwarf_section_display
* display
= debug_displays
+ i
;
13882 struct dwarf_section
* sec
= & display
->section
;
13884 if (streq (sec
->uncompressed_name
, name
)
13885 || (id
== line
&& const_strneq (name
, ".debug_line."))
13886 || streq (sec
->compressed_name
, name
))
13888 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13891 free_debug_section (id
);
13893 if (i
== line
&& const_strneq (name
, ".debug_line."))
13895 else if (streq (sec
->uncompressed_name
, name
))
13896 sec
->name
= sec
->uncompressed_name
;
13898 sec
->name
= sec
->compressed_name
;
13900 if (load_specific_debug_section (id
, section
, filedata
))
13902 /* If this debug section is part of a CU/TU set in a .dwp file,
13903 restrict load_debug_section to the sections in that set. */
13904 section_subset
= find_cu_tu_set (filedata
, shndx
);
13906 result
&= display
->display (sec
, filedata
);
13908 section_subset
= NULL
;
13910 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13911 free_debug_section (id
);
13919 printf (_("Unrecognized debug section: %s\n"), print_name
);
13926 /* Set DUMP_SECTS for all sections where dumps were requested
13927 based on section name. */
13930 initialise_dumps_byname (Filedata
* filedata
)
13932 struct dump_list_entry
* cur
;
13934 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13937 bfd_boolean any
= FALSE
;
13939 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13940 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13942 request_dump_bynumber (filedata
, i
, cur
->type
);
13947 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13953 process_section_contents (Filedata
* filedata
)
13955 Elf_Internal_Shdr
* section
;
13957 bfd_boolean res
= TRUE
;
13962 initialise_dumps_byname (filedata
);
13964 for (i
= 0, section
= filedata
->section_headers
;
13965 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13968 dump_type dump
= filedata
->dump_sects
[i
];
13970 #ifdef SUPPORT_DISASSEMBLY
13971 if (dump
& DISASS_DUMP
)
13973 if (! disassemble_section (section
, filedata
))
13977 if (dump
& HEX_DUMP
)
13979 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13983 if (dump
& RELOC_DUMP
)
13985 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13989 if (dump
& STRING_DUMP
)
13991 if (! dump_section_as_strings (section
, filedata
))
13995 if (dump
& DEBUG_DUMP
)
13997 if (! display_debug_section (i
, section
, filedata
))
14002 /* Check to see if the user requested a
14003 dump of a section that does not exist. */
14004 while (i
< filedata
->num_dump_sects
)
14006 if (filedata
->dump_sects
[i
])
14008 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14018 process_mips_fpe_exception (int mask
)
14022 bfd_boolean first
= TRUE
;
14024 if (mask
& OEX_FPU_INEX
)
14025 fputs ("INEX", stdout
), first
= FALSE
;
14026 if (mask
& OEX_FPU_UFLO
)
14027 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14028 if (mask
& OEX_FPU_OFLO
)
14029 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14030 if (mask
& OEX_FPU_DIV0
)
14031 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14032 if (mask
& OEX_FPU_INVAL
)
14033 printf ("%sINVAL", first
? "" : "|");
14036 fputs ("0", stdout
);
14039 /* Display's the value of TAG at location P. If TAG is
14040 greater than 0 it is assumed to be an unknown tag, and
14041 a message is printed to this effect. Otherwise it is
14042 assumed that a message has already been printed.
14044 If the bottom bit of TAG is set it assumed to have a
14045 string value, otherwise it is assumed to have an integer
14048 Returns an updated P pointing to the first unread byte
14049 beyond the end of TAG's value.
14051 Reads at or beyond END will not be made. */
14053 static unsigned char *
14054 display_tag_value (signed int tag
,
14056 const unsigned char * const end
)
14061 printf (" Tag_unknown_%d: ", tag
);
14065 warn (_("<corrupt tag>\n"));
14069 /* PR 17531 file: 027-19978-0.004. */
14070 size_t maxlen
= (end
- p
) - 1;
14075 print_symbol ((int) maxlen
, (const char *) p
);
14076 p
+= strnlen ((char *) p
, maxlen
) + 1;
14080 printf (_("<corrupt string tag>"));
14081 p
= (unsigned char *) end
;
14089 val
= read_uleb128 (p
, &len
, end
);
14091 printf ("%ld (0x%lx)\n", val
, val
);
14098 /* ARC ABI attributes section. */
14100 static unsigned char *
14101 display_arc_attribute (unsigned char * p
,
14102 const unsigned char * const end
)
14108 tag
= read_uleb128 (p
, &len
, end
);
14113 case Tag_ARC_PCS_config
:
14114 val
= read_uleb128 (p
, &len
, end
);
14116 printf (" Tag_ARC_PCS_config: ");
14120 printf (_("Absent/Non standard\n"));
14123 printf (_("Bare metal/mwdt\n"));
14126 printf (_("Bare metal/newlib\n"));
14129 printf (_("Linux/uclibc\n"));
14132 printf (_("Linux/glibc\n"));
14135 printf (_("Unknown\n"));
14140 case Tag_ARC_CPU_base
:
14141 val
= read_uleb128 (p
, &len
, end
);
14143 printf (" Tag_ARC_CPU_base: ");
14148 printf (_("Absent\n"));
14150 case TAG_CPU_ARC6xx
:
14151 printf ("ARC6xx\n");
14153 case TAG_CPU_ARC7xx
:
14154 printf ("ARC7xx\n");
14156 case TAG_CPU_ARCEM
:
14157 printf ("ARCEM\n");
14159 case TAG_CPU_ARCHS
:
14160 printf ("ARCHS\n");
14165 case Tag_ARC_CPU_variation
:
14166 val
= read_uleb128 (p
, &len
, end
);
14168 printf (" Tag_ARC_CPU_variation: ");
14172 if (val
> 0 && val
< 16)
14173 printf ("Core%d\n", val
);
14175 printf ("Unknown\n");
14179 printf (_("Absent\n"));
14184 case Tag_ARC_CPU_name
:
14185 printf (" Tag_ARC_CPU_name: ");
14186 p
= display_tag_value (-1, p
, end
);
14189 case Tag_ARC_ABI_rf16
:
14190 val
= read_uleb128 (p
, &len
, end
);
14192 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14195 case Tag_ARC_ABI_osver
:
14196 val
= read_uleb128 (p
, &len
, end
);
14198 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14201 case Tag_ARC_ABI_pic
:
14202 case Tag_ARC_ABI_sda
:
14203 val
= read_uleb128 (p
, &len
, end
);
14205 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14206 : " Tag_ARC_ABI_pic: ");
14210 printf (_("Absent\n"));
14219 printf (_("Unknown\n"));
14224 case Tag_ARC_ABI_tls
:
14225 val
= read_uleb128 (p
, &len
, end
);
14227 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14230 case Tag_ARC_ABI_enumsize
:
14231 val
= read_uleb128 (p
, &len
, end
);
14233 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14237 case Tag_ARC_ABI_exceptions
:
14238 val
= read_uleb128 (p
, &len
, end
);
14240 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14244 case Tag_ARC_ABI_double_size
:
14245 val
= read_uleb128 (p
, &len
, end
);
14247 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14250 case Tag_ARC_ISA_config
:
14251 printf (" Tag_ARC_ISA_config: ");
14252 p
= display_tag_value (-1, p
, end
);
14255 case Tag_ARC_ISA_apex
:
14256 printf (" Tag_ARC_ISA_apex: ");
14257 p
= display_tag_value (-1, p
, end
);
14260 case Tag_ARC_ISA_mpy_option
:
14261 val
= read_uleb128 (p
, &len
, end
);
14263 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14266 case Tag_ARC_ATR_version
:
14267 val
= read_uleb128 (p
, &len
, end
);
14269 printf (" Tag_ARC_ATR_version: %d\n", val
);
14273 return display_tag_value (tag
& 1, p
, end
);
14279 /* ARM EABI attributes section. */
14284 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14286 const char ** table
;
14287 } arm_attr_public_tag
;
14289 static const char * arm_attr_tag_CPU_arch
[] =
14290 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14291 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14293 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14294 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14295 {"No", "Thumb-1", "Thumb-2", "Yes"};
14296 static const char * arm_attr_tag_FP_arch
[] =
14297 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14298 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14299 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14300 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14301 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14302 "NEON for ARMv8.1"};
14303 static const char * arm_attr_tag_PCS_config
[] =
14304 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14305 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14306 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14307 {"V6", "SB", "TLS", "Unused"};
14308 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14309 {"Absolute", "PC-relative", "SB-relative", "None"};
14310 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14311 {"Absolute", "PC-relative", "None"};
14312 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14313 {"None", "direct", "GOT-indirect"};
14314 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14315 {"None", "??? 1", "2", "??? 3", "4"};
14316 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14317 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14318 {"Unused", "Needed", "Sign only"};
14319 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14320 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14321 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14322 {"Unused", "Finite", "RTABI", "IEEE 754"};
14323 static const char * arm_attr_tag_ABI_enum_size
[] =
14324 {"Unused", "small", "int", "forced to int"};
14325 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14326 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14327 static const char * arm_attr_tag_ABI_VFP_args
[] =
14328 {"AAPCS", "VFP registers", "custom", "compatible"};
14329 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14330 {"AAPCS", "WMMX registers", "custom"};
14331 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14332 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14333 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14334 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14335 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14336 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14337 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14338 static const char * arm_attr_tag_FP_HP_extension
[] =
14339 {"Not Allowed", "Allowed"};
14340 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14341 {"None", "IEEE 754", "Alternative Format"};
14342 static const char * arm_attr_tag_DSP_extension
[] =
14343 {"Follow architecture", "Allowed"};
14344 static const char * arm_attr_tag_MPextension_use
[] =
14345 {"Not Allowed", "Allowed"};
14346 static const char * arm_attr_tag_DIV_use
[] =
14347 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14348 "Allowed in v7-A with integer division extension"};
14349 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14350 static const char * arm_attr_tag_Virtualization_use
[] =
14351 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14352 "TrustZone and Virtualization Extensions"};
14353 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14354 {"Not Allowed", "Allowed"};
14356 #define LOOKUP(id, name) \
14357 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14358 static arm_attr_public_tag arm_attr_public_tags
[] =
14360 {4, "CPU_raw_name", 1, NULL
},
14361 {5, "CPU_name", 1, NULL
},
14362 LOOKUP(6, CPU_arch
),
14363 {7, "CPU_arch_profile", 0, NULL
},
14364 LOOKUP(8, ARM_ISA_use
),
14365 LOOKUP(9, THUMB_ISA_use
),
14366 LOOKUP(10, FP_arch
),
14367 LOOKUP(11, WMMX_arch
),
14368 LOOKUP(12, Advanced_SIMD_arch
),
14369 LOOKUP(13, PCS_config
),
14370 LOOKUP(14, ABI_PCS_R9_use
),
14371 LOOKUP(15, ABI_PCS_RW_data
),
14372 LOOKUP(16, ABI_PCS_RO_data
),
14373 LOOKUP(17, ABI_PCS_GOT_use
),
14374 LOOKUP(18, ABI_PCS_wchar_t
),
14375 LOOKUP(19, ABI_FP_rounding
),
14376 LOOKUP(20, ABI_FP_denormal
),
14377 LOOKUP(21, ABI_FP_exceptions
),
14378 LOOKUP(22, ABI_FP_user_exceptions
),
14379 LOOKUP(23, ABI_FP_number_model
),
14380 {24, "ABI_align_needed", 0, NULL
},
14381 {25, "ABI_align_preserved", 0, NULL
},
14382 LOOKUP(26, ABI_enum_size
),
14383 LOOKUP(27, ABI_HardFP_use
),
14384 LOOKUP(28, ABI_VFP_args
),
14385 LOOKUP(29, ABI_WMMX_args
),
14386 LOOKUP(30, ABI_optimization_goals
),
14387 LOOKUP(31, ABI_FP_optimization_goals
),
14388 {32, "compatibility", 0, NULL
},
14389 LOOKUP(34, CPU_unaligned_access
),
14390 LOOKUP(36, FP_HP_extension
),
14391 LOOKUP(38, ABI_FP_16bit_format
),
14392 LOOKUP(42, MPextension_use
),
14393 LOOKUP(44, DIV_use
),
14394 LOOKUP(46, DSP_extension
),
14395 {64, "nodefaults", 0, NULL
},
14396 {65, "also_compatible_with", 0, NULL
},
14397 LOOKUP(66, T2EE_use
),
14398 {67, "conformance", 1, NULL
},
14399 LOOKUP(68, Virtualization_use
),
14400 LOOKUP(70, MPextension_use_legacy
)
14404 static unsigned char *
14405 display_arm_attribute (unsigned char * p
,
14406 const unsigned char * const end
)
14411 arm_attr_public_tag
* attr
;
14415 tag
= read_uleb128 (p
, &len
, end
);
14418 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14420 if (arm_attr_public_tags
[i
].tag
== tag
)
14422 attr
= &arm_attr_public_tags
[i
];
14429 printf (" Tag_%s: ", attr
->name
);
14430 switch (attr
->type
)
14435 case 7: /* Tag_CPU_arch_profile. */
14436 val
= read_uleb128 (p
, &len
, end
);
14440 case 0: printf (_("None\n")); break;
14441 case 'A': printf (_("Application\n")); break;
14442 case 'R': printf (_("Realtime\n")); break;
14443 case 'M': printf (_("Microcontroller\n")); break;
14444 case 'S': printf (_("Application or Realtime\n")); break;
14445 default: printf ("??? (%d)\n", val
); break;
14449 case 24: /* Tag_align_needed. */
14450 val
= read_uleb128 (p
, &len
, end
);
14454 case 0: printf (_("None\n")); break;
14455 case 1: printf (_("8-byte\n")); break;
14456 case 2: printf (_("4-byte\n")); break;
14457 case 3: printf ("??? 3\n"); break;
14460 printf (_("8-byte and up to %d-byte extended\n"),
14463 printf ("??? (%d)\n", val
);
14468 case 25: /* Tag_align_preserved. */
14469 val
= read_uleb128 (p
, &len
, end
);
14473 case 0: printf (_("None\n")); break;
14474 case 1: printf (_("8-byte, except leaf SP\n")); break;
14475 case 2: printf (_("8-byte\n")); break;
14476 case 3: printf ("??? 3\n"); break;
14479 printf (_("8-byte and up to %d-byte extended\n"),
14482 printf ("??? (%d)\n", val
);
14487 case 32: /* Tag_compatibility. */
14489 val
= read_uleb128 (p
, &len
, end
);
14491 printf (_("flag = %d, vendor = "), val
);
14494 size_t maxlen
= (end
- p
) - 1;
14496 print_symbol ((int) maxlen
, (const char *) p
);
14497 p
+= strnlen ((char *) p
, maxlen
) + 1;
14501 printf (_("<corrupt>"));
14502 p
= (unsigned char *) end
;
14508 case 64: /* Tag_nodefaults. */
14509 /* PR 17531: file: 001-505008-0.01. */
14512 printf (_("True\n"));
14515 case 65: /* Tag_also_compatible_with. */
14516 val
= read_uleb128 (p
, &len
, end
);
14518 if (val
== 6 /* Tag_CPU_arch. */)
14520 val
= read_uleb128 (p
, &len
, end
);
14522 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14523 printf ("??? (%d)\n", val
);
14525 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14529 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14534 printf (_("<unknown: %d>\n"), tag
);
14540 return display_tag_value (-1, p
, end
);
14542 return display_tag_value (0, p
, end
);
14545 assert (attr
->type
& 0x80);
14546 val
= read_uleb128 (p
, &len
, end
);
14548 type
= attr
->type
& 0x7f;
14550 printf ("??? (%d)\n", val
);
14552 printf ("%s\n", attr
->table
[val
]);
14557 return display_tag_value (tag
, p
, end
);
14560 static unsigned char *
14561 display_gnu_attribute (unsigned char * p
,
14562 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14563 const unsigned char * const end
)
14569 tag
= read_uleb128 (p
, &len
, end
);
14572 /* Tag_compatibility is the only generic GNU attribute defined at
14576 val
= read_uleb128 (p
, &len
, end
);
14579 printf (_("flag = %d, vendor = "), val
);
14582 printf (_("<corrupt>\n"));
14583 warn (_("corrupt vendor attribute\n"));
14589 size_t maxlen
= (end
- p
) - 1;
14591 print_symbol ((int) maxlen
, (const char *) p
);
14592 p
+= strnlen ((char *) p
, maxlen
) + 1;
14596 printf (_("<corrupt>"));
14597 p
= (unsigned char *) end
;
14604 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14605 return display_proc_gnu_attribute (p
, tag
, end
);
14607 return display_tag_value (tag
, p
, end
);
14610 static unsigned char *
14611 display_power_gnu_attribute (unsigned char * p
,
14613 const unsigned char * const end
)
14618 if (tag
== Tag_GNU_Power_ABI_FP
)
14620 val
= read_uleb128 (p
, &len
, end
);
14622 printf (" Tag_GNU_Power_ABI_FP: ");
14625 printf (_("<corrupt>\n"));
14630 printf ("(%#x), ", val
);
14635 printf (_("unspecified hard/soft float, "));
14638 printf (_("hard float, "));
14641 printf (_("soft float, "));
14644 printf (_("single-precision hard float, "));
14651 printf (_("unspecified long double\n"));
14654 printf (_("128-bit IBM long double\n"));
14657 printf (_("64-bit long double\n"));
14660 printf (_("128-bit IEEE long double\n"));
14666 if (tag
== Tag_GNU_Power_ABI_Vector
)
14668 val
= read_uleb128 (p
, &len
, end
);
14670 printf (" Tag_GNU_Power_ABI_Vector: ");
14673 printf (_("<corrupt>\n"));
14678 printf ("(%#x), ", val
);
14683 printf (_("unspecified\n"));
14686 printf (_("generic\n"));
14689 printf ("AltiVec\n");
14698 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14700 val
= read_uleb128 (p
, &len
, end
);
14702 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14705 printf (_("<corrupt>\n"));
14710 printf ("(%#x), ", val
);
14715 printf (_("unspecified\n"));
14718 printf ("r3/r4\n");
14721 printf (_("memory\n"));
14730 return display_tag_value (tag
& 1, p
, end
);
14733 static unsigned char *
14734 display_s390_gnu_attribute (unsigned char * p
,
14736 const unsigned char * const end
)
14741 if (tag
== Tag_GNU_S390_ABI_Vector
)
14743 val
= read_uleb128 (p
, &len
, end
);
14745 printf (" Tag_GNU_S390_ABI_Vector: ");
14750 printf (_("any\n"));
14753 printf (_("software\n"));
14756 printf (_("hardware\n"));
14759 printf ("??? (%d)\n", val
);
14765 return display_tag_value (tag
& 1, p
, end
);
14769 display_sparc_hwcaps (unsigned int mask
)
14773 bfd_boolean first
= TRUE
;
14775 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14776 fputs ("mul32", stdout
), first
= FALSE
;
14777 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14778 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14779 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14780 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14781 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14782 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14783 if (mask
& ELF_SPARC_HWCAP_POPC
)
14784 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14785 if (mask
& ELF_SPARC_HWCAP_VIS
)
14786 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14787 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14788 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14789 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14790 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14791 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14792 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14793 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14794 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14795 if (mask
& ELF_SPARC_HWCAP_HPC
)
14796 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14797 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14798 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14799 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14800 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14801 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14802 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14803 if (mask
& ELF_SPARC_HWCAP_IMA
)
14804 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14805 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14806 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14809 fputc ('0', stdout
);
14810 fputc ('\n', stdout
);
14814 display_sparc_hwcaps2 (unsigned int mask
)
14818 bfd_boolean first
= TRUE
;
14820 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14821 fputs ("fjathplus", stdout
), first
= FALSE
;
14822 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14823 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14824 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14825 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14826 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14827 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14828 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14829 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14830 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14831 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14832 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14833 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14834 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14835 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14836 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14837 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14838 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14839 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14840 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14841 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14844 fputc ('0', stdout
);
14845 fputc ('\n', stdout
);
14848 static unsigned char *
14849 display_sparc_gnu_attribute (unsigned char * p
,
14851 const unsigned char * const end
)
14856 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14858 val
= read_uleb128 (p
, &len
, end
);
14860 printf (" Tag_GNU_Sparc_HWCAPS: ");
14861 display_sparc_hwcaps (val
);
14864 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14866 val
= read_uleb128 (p
, &len
, end
);
14868 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14869 display_sparc_hwcaps2 (val
);
14873 return display_tag_value (tag
, p
, end
);
14877 print_mips_fp_abi_value (unsigned int val
)
14881 case Val_GNU_MIPS_ABI_FP_ANY
:
14882 printf (_("Hard or soft float\n"));
14884 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14885 printf (_("Hard float (double precision)\n"));
14887 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14888 printf (_("Hard float (single precision)\n"));
14890 case Val_GNU_MIPS_ABI_FP_SOFT
:
14891 printf (_("Soft float\n"));
14893 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14894 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14896 case Val_GNU_MIPS_ABI_FP_XX
:
14897 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14899 case Val_GNU_MIPS_ABI_FP_64
:
14900 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14902 case Val_GNU_MIPS_ABI_FP_64A
:
14903 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14905 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14906 printf (_("NaN 2008 compatibility\n"));
14909 printf ("??? (%d)\n", val
);
14914 static unsigned char *
14915 display_mips_gnu_attribute (unsigned char * p
,
14917 const unsigned char * const end
)
14919 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14924 val
= read_uleb128 (p
, &len
, end
);
14926 printf (" Tag_GNU_MIPS_ABI_FP: ");
14928 print_mips_fp_abi_value (val
);
14933 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14938 val
= read_uleb128 (p
, &len
, end
);
14940 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14944 case Val_GNU_MIPS_ABI_MSA_ANY
:
14945 printf (_("Any MSA or not\n"));
14947 case Val_GNU_MIPS_ABI_MSA_128
:
14948 printf (_("128-bit MSA\n"));
14951 printf ("??? (%d)\n", val
);
14957 return display_tag_value (tag
& 1, p
, end
);
14960 static unsigned char *
14961 display_tic6x_attribute (unsigned char * p
,
14962 const unsigned char * const end
)
14968 tag
= read_uleb128 (p
, &len
, end
);
14974 val
= read_uleb128 (p
, &len
, end
);
14976 printf (" Tag_ISA: ");
14980 case C6XABI_Tag_ISA_none
:
14981 printf (_("None\n"));
14983 case C6XABI_Tag_ISA_C62X
:
14986 case C6XABI_Tag_ISA_C67X
:
14989 case C6XABI_Tag_ISA_C67XP
:
14990 printf ("C67x+\n");
14992 case C6XABI_Tag_ISA_C64X
:
14995 case C6XABI_Tag_ISA_C64XP
:
14996 printf ("C64x+\n");
14998 case C6XABI_Tag_ISA_C674X
:
14999 printf ("C674x\n");
15002 printf ("??? (%d)\n", val
);
15007 case Tag_ABI_wchar_t
:
15008 val
= read_uleb128 (p
, &len
, end
);
15010 printf (" Tag_ABI_wchar_t: ");
15014 printf (_("Not used\n"));
15017 printf (_("2 bytes\n"));
15020 printf (_("4 bytes\n"));
15023 printf ("??? (%d)\n", val
);
15028 case Tag_ABI_stack_align_needed
:
15029 val
= read_uleb128 (p
, &len
, end
);
15031 printf (" Tag_ABI_stack_align_needed: ");
15035 printf (_("8-byte\n"));
15038 printf (_("16-byte\n"));
15041 printf ("??? (%d)\n", val
);
15046 case Tag_ABI_stack_align_preserved
:
15047 val
= read_uleb128 (p
, &len
, end
);
15049 printf (" Tag_ABI_stack_align_preserved: ");
15053 printf (_("8-byte\n"));
15056 printf (_("16-byte\n"));
15059 printf ("??? (%d)\n", val
);
15065 val
= read_uleb128 (p
, &len
, end
);
15067 printf (" Tag_ABI_DSBT: ");
15071 printf (_("DSBT addressing not used\n"));
15074 printf (_("DSBT addressing used\n"));
15077 printf ("??? (%d)\n", val
);
15083 val
= read_uleb128 (p
, &len
, end
);
15085 printf (" Tag_ABI_PID: ");
15089 printf (_("Data addressing position-dependent\n"));
15092 printf (_("Data addressing position-independent, GOT near DP\n"));
15095 printf (_("Data addressing position-independent, GOT far from DP\n"));
15098 printf ("??? (%d)\n", val
);
15104 val
= read_uleb128 (p
, &len
, end
);
15106 printf (" Tag_ABI_PIC: ");
15110 printf (_("Code addressing position-dependent\n"));
15113 printf (_("Code addressing position-independent\n"));
15116 printf ("??? (%d)\n", val
);
15121 case Tag_ABI_array_object_alignment
:
15122 val
= read_uleb128 (p
, &len
, end
);
15124 printf (" Tag_ABI_array_object_alignment: ");
15128 printf (_("8-byte\n"));
15131 printf (_("4-byte\n"));
15134 printf (_("16-byte\n"));
15137 printf ("??? (%d)\n", val
);
15142 case Tag_ABI_array_object_align_expected
:
15143 val
= read_uleb128 (p
, &len
, end
);
15145 printf (" Tag_ABI_array_object_align_expected: ");
15149 printf (_("8-byte\n"));
15152 printf (_("4-byte\n"));
15155 printf (_("16-byte\n"));
15158 printf ("??? (%d)\n", val
);
15163 case Tag_ABI_compatibility
:
15165 val
= read_uleb128 (p
, &len
, end
);
15167 printf (" Tag_ABI_compatibility: ");
15168 printf (_("flag = %d, vendor = "), val
);
15171 size_t maxlen
= (end
- p
) - 1;
15173 print_symbol ((int) maxlen
, (const char *) p
);
15174 p
+= strnlen ((char *) p
, maxlen
) + 1;
15178 printf (_("<corrupt>"));
15179 p
= (unsigned char *) end
;
15185 case Tag_ABI_conformance
:
15187 printf (" Tag_ABI_conformance: \"");
15190 size_t maxlen
= (end
- p
) - 1;
15192 print_symbol ((int) maxlen
, (const char *) p
);
15193 p
+= strnlen ((char *) p
, maxlen
) + 1;
15197 printf (_("<corrupt>"));
15198 p
= (unsigned char *) end
;
15205 return display_tag_value (tag
, p
, end
);
15209 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15211 unsigned long addr
= 0;
15212 size_t bytes
= end
- p
;
15219 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15221 printf (" 0x%8.8lx ", addr
);
15223 for (j
= 0; j
< 16; j
++)
15226 printf ("%2.2x", p
[j
]);
15234 for (j
= 0; j
< lbytes
; j
++)
15237 if (k
>= ' ' && k
< 0x7f)
15253 static unsigned char *
15254 display_msp430x_attribute (unsigned char * p
,
15255 const unsigned char * const end
)
15261 tag
= read_uleb128 (p
, & len
, end
);
15266 case OFBA_MSPABI_Tag_ISA
:
15267 val
= read_uleb128 (p
, &len
, end
);
15269 printf (" Tag_ISA: ");
15272 case 0: printf (_("None\n")); break;
15273 case 1: printf (_("MSP430\n")); break;
15274 case 2: printf (_("MSP430X\n")); break;
15275 default: printf ("??? (%d)\n", val
); break;
15279 case OFBA_MSPABI_Tag_Code_Model
:
15280 val
= read_uleb128 (p
, &len
, end
);
15282 printf (" Tag_Code_Model: ");
15285 case 0: printf (_("None\n")); break;
15286 case 1: printf (_("Small\n")); break;
15287 case 2: printf (_("Large\n")); break;
15288 default: printf ("??? (%d)\n", val
); break;
15292 case OFBA_MSPABI_Tag_Data_Model
:
15293 val
= read_uleb128 (p
, &len
, end
);
15295 printf (" Tag_Data_Model: ");
15298 case 0: printf (_("None\n")); break;
15299 case 1: printf (_("Small\n")); break;
15300 case 2: printf (_("Large\n")); break;
15301 case 3: printf (_("Restricted Large\n")); break;
15302 default: printf ("??? (%d)\n", val
); break;
15307 printf (_(" <unknown tag %d>: "), tag
);
15314 size_t maxlen
= (end
- p
) - 1;
15316 print_symbol ((int) maxlen
, (const char *) p
);
15317 p
+= strnlen ((char *) p
, maxlen
) + 1;
15321 printf (_("<corrupt>"));
15322 p
= (unsigned char *) end
;
15328 val
= read_uleb128 (p
, &len
, end
);
15330 printf ("%d (0x%x)\n", val
, val
);
15340 process_attributes (Filedata
* filedata
,
15341 const char * public_name
,
15342 unsigned int proc_type
,
15343 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15344 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15346 Elf_Internal_Shdr
* sect
;
15348 bfd_boolean res
= TRUE
;
15350 /* Find the section header so that we get the size. */
15351 for (i
= 0, sect
= filedata
->section_headers
;
15352 i
< filedata
->file_header
.e_shnum
;
15355 unsigned char * contents
;
15358 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15361 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15362 sect
->sh_size
, _("attributes"));
15363 if (contents
== NULL
)
15370 /* The first character is the version of the attributes.
15371 Currently only version 1, (aka 'A') is recognised here. */
15374 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15379 bfd_vma section_len
;
15381 section_len
= sect
->sh_size
- 1;
15384 while (section_len
> 0)
15387 unsigned int namelen
;
15388 bfd_boolean public_section
;
15389 bfd_boolean gnu_section
;
15391 if (section_len
<= 4)
15393 error (_("Tag section ends prematurely\n"));
15397 attr_len
= byte_get (p
, 4);
15400 if (attr_len
> section_len
)
15402 error (_("Bad attribute length (%u > %u)\n"),
15403 (unsigned) attr_len
, (unsigned) section_len
);
15404 attr_len
= section_len
;
15407 /* PR 17531: file: 001-101425-0.004 */
15408 else if (attr_len
< 5)
15410 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15415 section_len
-= attr_len
;
15418 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15419 if (namelen
== 0 || namelen
>= attr_len
)
15421 error (_("Corrupt attribute section name\n"));
15426 printf (_("Attribute Section: "));
15427 print_symbol (INT_MAX
, (const char *) p
);
15430 if (public_name
&& streq ((char *) p
, public_name
))
15431 public_section
= TRUE
;
15433 public_section
= FALSE
;
15435 if (streq ((char *) p
, "gnu"))
15436 gnu_section
= TRUE
;
15438 gnu_section
= FALSE
;
15441 attr_len
-= namelen
;
15443 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15448 unsigned char * end
;
15450 /* PR binutils/17531: Safe handling of corrupt files. */
15453 error (_("Unused bytes at end of section\n"));
15460 size
= byte_get (p
, 4);
15461 if (size
> attr_len
)
15463 error (_("Bad subsection length (%u > %u)\n"),
15464 (unsigned) size
, (unsigned) attr_len
);
15468 /* PR binutils/17531: Safe handling of corrupt files. */
15471 error (_("Bad subsection length (%u < 6)\n"),
15479 end
= p
+ size
- 1;
15480 assert (end
<= contents
+ sect
->sh_size
);
15486 printf (_("File Attributes\n"));
15489 printf (_("Section Attributes:"));
15492 printf (_("Symbol Attributes:"));
15493 /* Fall through. */
15499 val
= read_uleb128 (p
, &j
, end
);
15503 printf (" %d", val
);
15508 printf (_("Unknown tag: %d\n"), tag
);
15509 public_section
= FALSE
;
15513 if (public_section
&& display_pub_attribute
!= NULL
)
15516 p
= display_pub_attribute (p
, end
);
15519 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15522 p
= display_gnu_attribute (p
,
15523 display_proc_gnu_attribute
,
15529 printf (_(" Unknown attribute:\n"));
15530 display_raw_attribute (p
, end
);
15545 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15546 Print the Address, Access and Initial fields of an entry at VMA ADDR
15547 and return the VMA of the next entry, or -1 if there was a problem.
15548 Does not read from DATA_END or beyond. */
15551 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15552 unsigned char * data_end
)
15555 print_vma (addr
, LONG_HEX
);
15557 if (addr
< pltgot
+ 0xfff0)
15558 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15560 printf ("%10s", "");
15563 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15567 unsigned char * from
= data
+ addr
- pltgot
;
15569 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15571 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15572 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15573 return (bfd_vma
) -1;
15577 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15578 print_vma (entry
, LONG_HEX
);
15581 return addr
+ (is_32bit_elf
? 4 : 8);
15584 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15585 PLTGOT. Print the Address and Initial fields of an entry at VMA
15586 ADDR and return the VMA of the next entry. */
15589 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15592 print_vma (addr
, LONG_HEX
);
15595 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15600 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15601 print_vma (entry
, LONG_HEX
);
15603 return addr
+ (is_32bit_elf
? 4 : 8);
15607 print_mips_ases (unsigned int mask
)
15609 if (mask
& AFL_ASE_DSP
)
15610 fputs ("\n\tDSP ASE", stdout
);
15611 if (mask
& AFL_ASE_DSPR2
)
15612 fputs ("\n\tDSP R2 ASE", stdout
);
15613 if (mask
& AFL_ASE_DSPR3
)
15614 fputs ("\n\tDSP R3 ASE", stdout
);
15615 if (mask
& AFL_ASE_EVA
)
15616 fputs ("\n\tEnhanced VA Scheme", stdout
);
15617 if (mask
& AFL_ASE_MCU
)
15618 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15619 if (mask
& AFL_ASE_MDMX
)
15620 fputs ("\n\tMDMX ASE", stdout
);
15621 if (mask
& AFL_ASE_MIPS3D
)
15622 fputs ("\n\tMIPS-3D ASE", stdout
);
15623 if (mask
& AFL_ASE_MT
)
15624 fputs ("\n\tMT ASE", stdout
);
15625 if (mask
& AFL_ASE_SMARTMIPS
)
15626 fputs ("\n\tSmartMIPS ASE", stdout
);
15627 if (mask
& AFL_ASE_VIRT
)
15628 fputs ("\n\tVZ ASE", stdout
);
15629 if (mask
& AFL_ASE_MSA
)
15630 fputs ("\n\tMSA ASE", stdout
);
15631 if (mask
& AFL_ASE_MIPS16
)
15632 fputs ("\n\tMIPS16 ASE", stdout
);
15633 if (mask
& AFL_ASE_MICROMIPS
)
15634 fputs ("\n\tMICROMIPS ASE", stdout
);
15635 if (mask
& AFL_ASE_XPA
)
15636 fputs ("\n\tXPA ASE", stdout
);
15637 if (mask
& AFL_ASE_MIPS16E2
)
15638 fputs ("\n\tMIPS16e2 ASE", stdout
);
15639 if (mask
& AFL_ASE_CRC
)
15640 fputs ("\n\tCRC ASE", stdout
);
15641 if (mask
& AFL_ASE_GINV
)
15642 fputs ("\n\tGINV ASE", stdout
);
15643 if (mask
& AFL_ASE_LOONGSON_MMI
)
15644 fputs ("\n\tLoongson MMI ASE", stdout
);
15646 fprintf (stdout
, "\n\t%s", _("None"));
15647 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15648 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15652 print_mips_isa_ext (unsigned int isa_ext
)
15657 fputs (_("None"), stdout
);
15660 fputs ("RMI XLR", stdout
);
15662 case AFL_EXT_OCTEON3
:
15663 fputs ("Cavium Networks Octeon3", stdout
);
15665 case AFL_EXT_OCTEON2
:
15666 fputs ("Cavium Networks Octeon2", stdout
);
15668 case AFL_EXT_OCTEONP
:
15669 fputs ("Cavium Networks OcteonP", stdout
);
15671 case AFL_EXT_LOONGSON_3A
:
15672 fputs ("Loongson 3A", stdout
);
15674 case AFL_EXT_OCTEON
:
15675 fputs ("Cavium Networks Octeon", stdout
);
15678 fputs ("Toshiba R5900", stdout
);
15681 fputs ("MIPS R4650", stdout
);
15684 fputs ("LSI R4010", stdout
);
15687 fputs ("NEC VR4100", stdout
);
15690 fputs ("Toshiba R3900", stdout
);
15692 case AFL_EXT_10000
:
15693 fputs ("MIPS R10000", stdout
);
15696 fputs ("Broadcom SB-1", stdout
);
15699 fputs ("NEC VR4111/VR4181", stdout
);
15702 fputs ("NEC VR4120", stdout
);
15705 fputs ("NEC VR5400", stdout
);
15708 fputs ("NEC VR5500", stdout
);
15710 case AFL_EXT_LOONGSON_2E
:
15711 fputs ("ST Microelectronics Loongson 2E", stdout
);
15713 case AFL_EXT_LOONGSON_2F
:
15714 fputs ("ST Microelectronics Loongson 2F", stdout
);
15716 case AFL_EXT_INTERAPTIV_MR2
:
15717 fputs ("Imagination interAptiv MR2", stdout
);
15720 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15725 get_mips_reg_size (int reg_size
)
15727 return (reg_size
== AFL_REG_NONE
) ? 0
15728 : (reg_size
== AFL_REG_32
) ? 32
15729 : (reg_size
== AFL_REG_64
) ? 64
15730 : (reg_size
== AFL_REG_128
) ? 128
15735 process_mips_specific (Filedata
* filedata
)
15737 Elf_Internal_Dyn
* entry
;
15738 Elf_Internal_Shdr
*sect
= NULL
;
15739 size_t liblist_offset
= 0;
15740 size_t liblistno
= 0;
15741 size_t conflictsno
= 0;
15742 size_t options_offset
= 0;
15743 size_t conflicts_offset
= 0;
15744 size_t pltrelsz
= 0;
15746 bfd_vma pltgot
= 0;
15747 bfd_vma mips_pltgot
= 0;
15748 bfd_vma jmprel
= 0;
15749 bfd_vma local_gotno
= 0;
15750 bfd_vma gotsym
= 0;
15751 bfd_vma symtabno
= 0;
15752 bfd_boolean res
= TRUE
;
15754 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15755 display_mips_gnu_attribute
))
15758 sect
= find_section (filedata
, ".MIPS.abiflags");
15762 Elf_External_ABIFlags_v0
*abiflags_ext
;
15763 Elf_Internal_ABIFlags_v0 abiflags_in
;
15765 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15767 error (_("Corrupt MIPS ABI Flags section.\n"));
15772 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15773 sect
->sh_size
, _("MIPS ABI Flags section"));
15776 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15777 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15778 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15779 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15780 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15781 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15782 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15783 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15784 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15785 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15786 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15788 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15789 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15790 if (abiflags_in
.isa_rev
> 1)
15791 printf ("r%d", abiflags_in
.isa_rev
);
15792 printf ("\nGPR size: %d",
15793 get_mips_reg_size (abiflags_in
.gpr_size
));
15794 printf ("\nCPR1 size: %d",
15795 get_mips_reg_size (abiflags_in
.cpr1_size
));
15796 printf ("\nCPR2 size: %d",
15797 get_mips_reg_size (abiflags_in
.cpr2_size
));
15798 fputs ("\nFP ABI: ", stdout
);
15799 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15800 fputs ("ISA Extension: ", stdout
);
15801 print_mips_isa_ext (abiflags_in
.isa_ext
);
15802 fputs ("\nASEs:", stdout
);
15803 print_mips_ases (abiflags_in
.ases
);
15804 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15805 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15806 fputc ('\n', stdout
);
15807 free (abiflags_ext
);
15812 /* We have a lot of special sections. Thanks SGI! */
15813 if (dynamic_section
== NULL
)
15815 /* No dynamic information available. See if there is static GOT. */
15816 sect
= find_section (filedata
, ".got");
15819 unsigned char *data_end
;
15820 unsigned char *data
;
15824 pltgot
= sect
->sh_addr
;
15827 addr_size
= (is_32bit_elf
? 4 : 8);
15828 end
= pltgot
+ sect
->sh_size
;
15830 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15832 _("Global Offset Table data"));
15833 /* PR 12855: Null data is handled gracefully throughout. */
15834 data_end
= data
+ (end
- pltgot
);
15836 printf (_("\nStatic GOT:\n"));
15837 printf (_(" Canonical gp value: "));
15838 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15841 /* In a dynamic binary GOT[0] is reserved for the dynamic
15842 loader to store the lazy resolver pointer, however in
15843 a static binary it may well have been omitted and GOT
15844 reduced to a table of addresses.
15845 PR 21344: Check for the entry being fully available
15846 before fetching it. */
15848 && data
+ ent
- pltgot
+ addr_size
<= data_end
15849 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15851 printf (_(" Reserved entries:\n"));
15852 printf (_(" %*s %10s %*s\n"),
15853 addr_size
* 2, _("Address"), _("Access"),
15854 addr_size
* 2, _("Value"));
15855 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15857 if (ent
== (bfd_vma
) -1)
15858 goto sgot_print_fail
;
15860 /* Check for the MSB of GOT[1] being set, identifying a
15861 GNU object. This entry will be used by some runtime
15862 loaders, to store the module pointer. Otherwise this
15863 is an ordinary local entry.
15864 PR 21344: Check for the entry being fully available
15865 before fetching it. */
15867 && data
+ ent
- pltgot
+ addr_size
<= data_end
15868 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15869 >> (addr_size
* 8 - 1)) != 0)
15871 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15873 if (ent
== (bfd_vma
) -1)
15874 goto sgot_print_fail
;
15879 if (data
!= NULL
&& ent
< end
)
15881 printf (_(" Local entries:\n"));
15882 printf (" %*s %10s %*s\n",
15883 addr_size
* 2, _("Address"), _("Access"),
15884 addr_size
* 2, _("Value"));
15887 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15889 if (ent
== (bfd_vma
) -1)
15890 goto sgot_print_fail
;
15902 for (entry
= dynamic_section
;
15903 /* PR 17531 file: 012-50589-0.004. */
15904 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15906 switch (entry
->d_tag
)
15908 case DT_MIPS_LIBLIST
:
15910 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15911 liblistno
* sizeof (Elf32_External_Lib
));
15913 case DT_MIPS_LIBLISTNO
:
15914 liblistno
= entry
->d_un
.d_val
;
15916 case DT_MIPS_OPTIONS
:
15917 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15919 case DT_MIPS_CONFLICT
:
15921 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15922 conflictsno
* sizeof (Elf32_External_Conflict
));
15924 case DT_MIPS_CONFLICTNO
:
15925 conflictsno
= entry
->d_un
.d_val
;
15928 pltgot
= entry
->d_un
.d_ptr
;
15930 case DT_MIPS_LOCAL_GOTNO
:
15931 local_gotno
= entry
->d_un
.d_val
;
15933 case DT_MIPS_GOTSYM
:
15934 gotsym
= entry
->d_un
.d_val
;
15936 case DT_MIPS_SYMTABNO
:
15937 symtabno
= entry
->d_un
.d_val
;
15939 case DT_MIPS_PLTGOT
:
15940 mips_pltgot
= entry
->d_un
.d_ptr
;
15943 pltrel
= entry
->d_un
.d_val
;
15946 pltrelsz
= entry
->d_un
.d_val
;
15949 jmprel
= entry
->d_un
.d_ptr
;
15955 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15957 Elf32_External_Lib
* elib
;
15960 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15962 sizeof (Elf32_External_Lib
),
15963 _("liblist section data"));
15966 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15967 "\nSection '.liblist' contains %lu entries:\n",
15968 (unsigned long) liblistno
),
15969 (unsigned long) liblistno
);
15970 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15973 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15980 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15981 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15982 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15983 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15984 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15986 tmp
= gmtime (&atime
);
15987 snprintf (timebuf
, sizeof (timebuf
),
15988 "%04u-%02u-%02uT%02u:%02u:%02u",
15989 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15990 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15992 printf ("%3lu: ", (unsigned long) cnt
);
15993 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15994 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15996 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15997 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15998 liblist
.l_version
);
16000 if (liblist
.l_flags
== 0)
16004 static const struct
16011 { " EXACT_MATCH", LL_EXACT_MATCH
},
16012 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16013 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16014 { " EXPORTS", LL_EXPORTS
},
16015 { " DELAY_LOAD", LL_DELAY_LOAD
},
16016 { " DELTA", LL_DELTA
}
16018 int flags
= liblist
.l_flags
;
16021 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16022 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16024 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16025 flags
^= l_flags_vals
[fcnt
].bit
;
16028 printf (" %#x", (unsigned int) flags
);
16040 if (options_offset
!= 0)
16042 Elf_External_Options
* eopt
;
16043 Elf_Internal_Options
* iopt
;
16044 Elf_Internal_Options
* option
;
16047 sect
= filedata
->section_headers
;
16049 /* Find the section header so that we get the size. */
16050 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16051 /* PR 17533 file: 012-277276-0.004. */
16054 error (_("No MIPS_OPTIONS header found\n"));
16058 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16059 sect
->sh_size
, _("options"));
16062 iopt
= (Elf_Internal_Options
*)
16063 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16066 error (_("Out of memory allocating space for MIPS options\n"));
16073 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16075 Elf_External_Options
* eoption
;
16077 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16079 option
->kind
= BYTE_GET (eoption
->kind
);
16080 option
->size
= BYTE_GET (eoption
->size
);
16081 option
->section
= BYTE_GET (eoption
->section
);
16082 option
->info
= BYTE_GET (eoption
->info
);
16084 /* PR 17531: file: ffa0fa3b. */
16085 if (option
->size
< sizeof (* eopt
)
16086 || offset
+ option
->size
> sect
->sh_size
)
16088 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16091 offset
+= option
->size
;
16097 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16098 "\nSection '%s' contains %d entries:\n",
16100 printable_section_name (filedata
, sect
), cnt
);
16109 switch (option
->kind
)
16112 /* This shouldn't happen. */
16113 printf (" NULL %d %lx", option
->section
, option
->info
);
16116 printf (" REGINFO ");
16117 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16120 Elf32_External_RegInfo
* ereg
;
16121 Elf32_RegInfo reginfo
;
16123 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16124 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16125 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16126 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16127 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16128 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16129 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16131 printf ("GPR %08lx GP 0x%lx\n",
16132 reginfo
.ri_gprmask
,
16133 (unsigned long) reginfo
.ri_gp_value
);
16134 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16135 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16136 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16141 Elf64_External_RegInfo
* ereg
;
16142 Elf64_Internal_RegInfo reginfo
;
16144 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16145 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16146 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16147 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16148 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16149 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16150 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16152 printf ("GPR %08lx GP 0x",
16153 reginfo
.ri_gprmask
);
16154 printf_vma (reginfo
.ri_gp_value
);
16157 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16158 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16159 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16163 case ODK_EXCEPTIONS
:
16164 fputs (" EXCEPTIONS fpe_min(", stdout
);
16165 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16166 fputs (") fpe_max(", stdout
);
16167 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16168 fputs (")", stdout
);
16170 if (option
->info
& OEX_PAGE0
)
16171 fputs (" PAGE0", stdout
);
16172 if (option
->info
& OEX_SMM
)
16173 fputs (" SMM", stdout
);
16174 if (option
->info
& OEX_FPDBUG
)
16175 fputs (" FPDBUG", stdout
);
16176 if (option
->info
& OEX_DISMISS
)
16177 fputs (" DISMISS", stdout
);
16180 fputs (" PAD ", stdout
);
16181 if (option
->info
& OPAD_PREFIX
)
16182 fputs (" PREFIX", stdout
);
16183 if (option
->info
& OPAD_POSTFIX
)
16184 fputs (" POSTFIX", stdout
);
16185 if (option
->info
& OPAD_SYMBOL
)
16186 fputs (" SYMBOL", stdout
);
16189 fputs (" HWPATCH ", stdout
);
16190 if (option
->info
& OHW_R4KEOP
)
16191 fputs (" R4KEOP", stdout
);
16192 if (option
->info
& OHW_R8KPFETCH
)
16193 fputs (" R8KPFETCH", stdout
);
16194 if (option
->info
& OHW_R5KEOP
)
16195 fputs (" R5KEOP", stdout
);
16196 if (option
->info
& OHW_R5KCVTL
)
16197 fputs (" R5KCVTL", stdout
);
16200 fputs (" FILL ", stdout
);
16201 /* XXX Print content of info word? */
16204 fputs (" TAGS ", stdout
);
16205 /* XXX Print content of info word? */
16208 fputs (" HWAND ", stdout
);
16209 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16210 fputs (" R4KEOP_CHECKED", stdout
);
16211 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16212 fputs (" R4KEOP_CLEAN", stdout
);
16215 fputs (" HWOR ", stdout
);
16216 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16217 fputs (" R4KEOP_CHECKED", stdout
);
16218 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16219 fputs (" R4KEOP_CLEAN", stdout
);
16222 printf (" GP_GROUP %#06lx self-contained %#06lx",
16223 option
->info
& OGP_GROUP
,
16224 (option
->info
& OGP_SELF
) >> 16);
16227 printf (" IDENT %#06lx self-contained %#06lx",
16228 option
->info
& OGP_GROUP
,
16229 (option
->info
& OGP_SELF
) >> 16);
16232 /* This shouldn't happen. */
16233 printf (" %3d ??? %d %lx",
16234 option
->kind
, option
->section
, option
->info
);
16238 len
= sizeof (* eopt
);
16239 while (len
< option
->size
)
16241 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16243 if (ISPRINT (datum
))
16244 printf ("%c", datum
);
16246 printf ("\\%03o", datum
);
16249 fputs ("\n", stdout
);
16251 offset
+= option
->size
;
16261 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16263 Elf32_Conflict
* iconf
;
16266 if (dynamic_symbols
== NULL
)
16268 error (_("conflict list found without a dynamic symbol table\n"));
16272 /* PR 21345 - print a slightly more helpful error message
16273 if we are sure that the cmalloc will fail. */
16274 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16276 error (_("Overlarge number of conflicts detected: %lx\n"),
16277 (long) conflictsno
);
16281 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16284 error (_("Out of memory allocating space for dynamic conflicts\n"));
16290 Elf32_External_Conflict
* econf32
;
16292 econf32
= (Elf32_External_Conflict
*)
16293 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16294 sizeof (* econf32
), _("conflict"));
16298 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16299 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16305 Elf64_External_Conflict
* econf64
;
16307 econf64
= (Elf64_External_Conflict
*)
16308 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16309 sizeof (* econf64
), _("conflict"));
16313 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16314 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16319 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16320 "\nSection '.conflict' contains %lu entries:\n",
16321 (unsigned long) conflictsno
),
16322 (unsigned long) conflictsno
);
16323 puts (_(" Num: Index Value Name"));
16325 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16327 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16329 if (iconf
[cnt
] >= num_dynamic_syms
)
16330 printf (_("<corrupt symbol index>"));
16333 Elf_Internal_Sym
* psym
;
16335 psym
= & dynamic_symbols
[iconf
[cnt
]];
16336 print_vma (psym
->st_value
, FULL_HEX
);
16338 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16339 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16341 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16349 if (pltgot
!= 0 && local_gotno
!= 0)
16351 bfd_vma ent
, local_end
, global_end
;
16353 unsigned char * data
;
16354 unsigned char * data_end
;
16358 addr_size
= (is_32bit_elf
? 4 : 8);
16359 local_end
= pltgot
+ local_gotno
* addr_size
;
16361 /* PR binutils/17533 file: 012-111227-0.004 */
16362 if (symtabno
< gotsym
)
16364 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16365 (unsigned long) gotsym
, (unsigned long) symtabno
);
16369 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16370 /* PR 17531: file: 54c91a34. */
16371 if (global_end
< local_end
)
16373 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16377 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16378 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16379 global_end
- pltgot
, 1,
16380 _("Global Offset Table data"));
16381 /* PR 12855: Null data is handled gracefully throughout. */
16382 data_end
= data
+ (global_end
- pltgot
);
16384 printf (_("\nPrimary GOT:\n"));
16385 printf (_(" Canonical gp value: "));
16386 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16389 printf (_(" Reserved entries:\n"));
16390 printf (_(" %*s %10s %*s Purpose\n"),
16391 addr_size
* 2, _("Address"), _("Access"),
16392 addr_size
* 2, _("Initial"));
16393 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16394 printf (_(" Lazy resolver\n"));
16395 if (ent
== (bfd_vma
) -1)
16396 goto got_print_fail
;
16398 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16399 This entry will be used by some runtime loaders, to store the
16400 module pointer. Otherwise this is an ordinary local entry.
16401 PR 21344: Check for the entry being fully available before
16404 && data
+ ent
- pltgot
+ addr_size
<= data_end
16405 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16406 >> (addr_size
* 8 - 1)) != 0)
16408 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16409 printf (_(" Module pointer (GNU extension)\n"));
16410 if (ent
== (bfd_vma
) -1)
16411 goto got_print_fail
;
16415 if (data
!= NULL
&& ent
< local_end
)
16417 printf (_(" Local entries:\n"));
16418 printf (" %*s %10s %*s\n",
16419 addr_size
* 2, _("Address"), _("Access"),
16420 addr_size
* 2, _("Initial"));
16421 while (ent
< local_end
)
16423 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16425 if (ent
== (bfd_vma
) -1)
16426 goto got_print_fail
;
16431 if (data
!= NULL
&& gotsym
< symtabno
)
16435 printf (_(" Global entries:\n"));
16436 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16437 addr_size
* 2, _("Address"),
16439 addr_size
* 2, _("Initial"),
16440 addr_size
* 2, _("Sym.Val."),
16442 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16443 _("Ndx"), _("Name"));
16445 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16447 for (i
= gotsym
; i
< symtabno
; i
++)
16449 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16452 if (dynamic_symbols
== NULL
)
16453 printf (_("<no dynamic symbols>"));
16454 else if (i
< num_dynamic_syms
)
16456 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16458 print_vma (psym
->st_value
, LONG_HEX
);
16459 printf (" %-7s %3s ",
16460 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16461 get_symbol_index_type (filedata
, psym
->st_shndx
));
16463 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16464 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16466 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16469 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16470 (unsigned long) i
);
16473 if (ent
== (bfd_vma
) -1)
16484 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16487 size_t offset
, rel_offset
;
16488 unsigned long count
, i
;
16489 unsigned char * data
;
16490 int addr_size
, sym_width
;
16491 Elf_Internal_Rela
* rels
;
16493 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16494 if (pltrel
== DT_RELA
)
16496 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16501 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16506 addr_size
= (is_32bit_elf
? 4 : 8);
16507 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16509 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16510 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16511 1, _("Procedure Linkage Table data"));
16515 printf ("\nPLT GOT:\n\n");
16516 printf (_(" Reserved entries:\n"));
16517 printf (_(" %*s %*s Purpose\n"),
16518 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16519 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16520 printf (_(" PLT lazy resolver\n"));
16521 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16522 printf (_(" Module pointer\n"));
16525 printf (_(" Entries:\n"));
16526 printf (" %*s %*s %*s %-7s %3s %s\n",
16527 addr_size
* 2, _("Address"),
16528 addr_size
* 2, _("Initial"),
16529 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16530 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16531 for (i
= 0; i
< count
; i
++)
16533 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16535 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16538 if (idx
>= num_dynamic_syms
)
16539 printf (_("<corrupt symbol index: %lu>"), idx
);
16542 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16544 print_vma (psym
->st_value
, LONG_HEX
);
16545 printf (" %-7s %3s ",
16546 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16547 get_symbol_index_type (filedata
, psym
->st_shndx
));
16548 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16549 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16551 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16566 process_nds32_specific (Filedata
* filedata
)
16568 Elf_Internal_Shdr
*sect
= NULL
;
16570 sect
= find_section (filedata
, ".nds32_e_flags");
16573 unsigned int *flag
;
16575 printf ("\nNDS32 elf flags section:\n");
16576 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16577 sect
->sh_size
, _("NDS32 elf flags section"));
16582 switch ((*flag
) & 0x3)
16585 printf ("(VEC_SIZE):\tNo entry.\n");
16588 printf ("(VEC_SIZE):\t4 bytes\n");
16591 printf ("(VEC_SIZE):\t16 bytes\n");
16594 printf ("(VEC_SIZE):\treserved\n");
16603 process_gnu_liblist (Filedata
* filedata
)
16605 Elf_Internal_Shdr
* section
;
16606 Elf_Internal_Shdr
* string_sec
;
16607 Elf32_External_Lib
* elib
;
16609 size_t strtab_size
;
16611 unsigned long num_liblist
;
16613 bfd_boolean res
= TRUE
;
16618 for (i
= 0, section
= filedata
->section_headers
;
16619 i
< filedata
->file_header
.e_shnum
;
16622 switch (section
->sh_type
)
16624 case SHT_GNU_LIBLIST
:
16625 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16628 elib
= (Elf32_External_Lib
*)
16629 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16630 _("liblist section data"));
16638 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16639 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16640 string_sec
->sh_size
,
16641 _("liblist string table"));
16643 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16650 strtab_size
= string_sec
->sh_size
;
16652 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16653 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16654 "\nLibrary list section '%s' contains %lu entries:\n",
16656 printable_section_name (filedata
, section
),
16659 puts (_(" Library Time Stamp Checksum Version Flags"));
16661 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16669 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16670 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16671 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16672 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16673 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16675 tmp
= gmtime (&atime
);
16676 snprintf (timebuf
, sizeof (timebuf
),
16677 "%04u-%02u-%02uT%02u:%02u:%02u",
16678 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16679 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16681 printf ("%3lu: ", (unsigned long) cnt
);
16683 printf ("%-20s", liblist
.l_name
< strtab_size
16684 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16686 printf ("%-20.20s", liblist
.l_name
< strtab_size
16687 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16688 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16689 liblist
.l_version
, liblist
.l_flags
);
16700 static const char *
16701 get_note_type (Filedata
* filedata
, unsigned e_type
)
16703 static char buff
[64];
16705 if (filedata
->file_header
.e_type
== ET_CORE
)
16709 return _("NT_AUXV (auxiliary vector)");
16711 return _("NT_PRSTATUS (prstatus structure)");
16713 return _("NT_FPREGSET (floating point registers)");
16715 return _("NT_PRPSINFO (prpsinfo structure)");
16716 case NT_TASKSTRUCT
:
16717 return _("NT_TASKSTRUCT (task structure)");
16719 return _("NT_PRXFPREG (user_xfpregs structure)");
16721 return _("NT_PPC_VMX (ppc Altivec registers)");
16723 return _("NT_PPC_VSX (ppc VSX registers)");
16725 return _("NT_PPC_TAR (ppc TAR register)");
16727 return _("NT_PPC_PPR (ppc PPR register)");
16729 return _("NT_PPC_DSCR (ppc DSCR register)");
16731 return _("NT_PPC_EBB (ppc EBB registers)");
16733 return _("NT_PPC_PMU (ppc PMU registers)");
16734 case NT_PPC_TM_CGPR
:
16735 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16736 case NT_PPC_TM_CFPR
:
16737 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16738 case NT_PPC_TM_CVMX
:
16739 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16740 case NT_PPC_TM_CVSX
:
16741 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16742 case NT_PPC_TM_SPR
:
16743 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16744 case NT_PPC_TM_CTAR
:
16745 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16746 case NT_PPC_TM_CPPR
:
16747 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16748 case NT_PPC_TM_CDSCR
:
16749 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16751 return _("NT_386_TLS (x86 TLS information)");
16752 case NT_386_IOPERM
:
16753 return _("NT_386_IOPERM (x86 I/O permissions)");
16754 case NT_X86_XSTATE
:
16755 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16756 case NT_S390_HIGH_GPRS
:
16757 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16758 case NT_S390_TIMER
:
16759 return _("NT_S390_TIMER (s390 timer register)");
16760 case NT_S390_TODCMP
:
16761 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16762 case NT_S390_TODPREG
:
16763 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16765 return _("NT_S390_CTRS (s390 control registers)");
16766 case NT_S390_PREFIX
:
16767 return _("NT_S390_PREFIX (s390 prefix register)");
16768 case NT_S390_LAST_BREAK
:
16769 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16770 case NT_S390_SYSTEM_CALL
:
16771 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16773 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16774 case NT_S390_VXRS_LOW
:
16775 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16776 case NT_S390_VXRS_HIGH
:
16777 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16778 case NT_S390_GS_CB
:
16779 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16780 case NT_S390_GS_BC
:
16781 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16783 return _("NT_ARM_VFP (arm VFP registers)");
16785 return _("NT_ARM_TLS (AArch TLS registers)");
16786 case NT_ARM_HW_BREAK
:
16787 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16788 case NT_ARM_HW_WATCH
:
16789 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16791 return _("NT_PSTATUS (pstatus structure)");
16793 return _("NT_FPREGS (floating point registers)");
16795 return _("NT_PSINFO (psinfo structure)");
16797 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16799 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16800 case NT_WIN32PSTATUS
:
16801 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16803 return _("NT_SIGINFO (siginfo_t data)");
16805 return _("NT_FILE (mapped files)");
16813 return _("NT_VERSION (version)");
16815 return _("NT_ARCH (architecture)");
16816 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16818 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16824 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16829 print_core_note (Elf_Internal_Note
*pnote
)
16831 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16832 bfd_vma count
, page_size
;
16833 unsigned char *descdata
, *filenames
, *descend
;
16835 if (pnote
->type
!= NT_FILE
)
16845 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16846 /* Still "successful". */
16851 if (pnote
->descsz
< 2 * addr_size
)
16853 error (_(" Malformed note - too short for header\n"));
16857 descdata
= (unsigned char *) pnote
->descdata
;
16858 descend
= descdata
+ pnote
->descsz
;
16860 if (descdata
[pnote
->descsz
- 1] != '\0')
16862 error (_(" Malformed note - does not end with \\0\n"));
16866 count
= byte_get (descdata
, addr_size
);
16867 descdata
+= addr_size
;
16869 page_size
= byte_get (descdata
, addr_size
);
16870 descdata
+= addr_size
;
16872 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16873 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16875 error (_(" Malformed note - too short for supplied file count\n"));
16879 printf (_(" Page size: "));
16880 print_vma (page_size
, DEC
);
16883 printf (_(" %*s%*s%*s\n"),
16884 (int) (2 + 2 * addr_size
), _("Start"),
16885 (int) (4 + 2 * addr_size
), _("End"),
16886 (int) (4 + 2 * addr_size
), _("Page Offset"));
16887 filenames
= descdata
+ count
* 3 * addr_size
;
16888 while (count
-- > 0)
16890 bfd_vma start
, end
, file_ofs
;
16892 if (filenames
== descend
)
16894 error (_(" Malformed note - filenames end too early\n"));
16898 start
= byte_get (descdata
, addr_size
);
16899 descdata
+= addr_size
;
16900 end
= byte_get (descdata
, addr_size
);
16901 descdata
+= addr_size
;
16902 file_ofs
= byte_get (descdata
, addr_size
);
16903 descdata
+= addr_size
;
16906 print_vma (start
, FULL_HEX
);
16908 print_vma (end
, FULL_HEX
);
16910 print_vma (file_ofs
, FULL_HEX
);
16911 printf ("\n %s\n", filenames
);
16913 filenames
+= 1 + strlen ((char *) filenames
);
16919 static const char *
16920 get_gnu_elf_note_type (unsigned e_type
)
16922 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16925 case NT_GNU_ABI_TAG
:
16926 return _("NT_GNU_ABI_TAG (ABI version tag)");
16928 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16929 case NT_GNU_BUILD_ID
:
16930 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16931 case NT_GNU_GOLD_VERSION
:
16932 return _("NT_GNU_GOLD_VERSION (gold version)");
16933 case NT_GNU_PROPERTY_TYPE_0
:
16934 return _("NT_GNU_PROPERTY_TYPE_0");
16935 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16936 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16937 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16938 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16941 static char buff
[64];
16943 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16950 decode_x86_compat_isa (unsigned int bitmask
)
16954 unsigned int bit
= bitmask
& (- bitmask
);
16959 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
16962 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
16965 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
16968 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
16971 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
16974 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
16977 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
16980 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
16983 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
16986 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
16989 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
16992 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
16993 printf ("AVX512F");
16995 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
16996 printf ("AVX512CD");
16998 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
16999 printf ("AVX512ER");
17001 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17002 printf ("AVX512PF");
17004 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17005 printf ("AVX512VL");
17007 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17008 printf ("AVX512DQ");
17010 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17011 printf ("AVX512BW");
17013 default: printf (_("<unknown: %x>"), bit
); break;
17021 decode_x86_isa (unsigned int bitmask
)
17025 unsigned int bit
= bitmask
& (- bitmask
);
17030 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17033 case GNU_PROPERTY_X86_ISA_1_SSE
:
17036 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17039 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17042 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17045 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17048 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17051 case GNU_PROPERTY_X86_ISA_1_AVX
:
17054 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17057 case GNU_PROPERTY_X86_ISA_1_FMA
:
17060 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17061 printf ("AVX512F");
17063 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17064 printf ("AVX512CD");
17066 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17067 printf ("AVX512ER");
17069 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17070 printf ("AVX512PF");
17072 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17073 printf ("AVX512VL");
17075 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17076 printf ("AVX512DQ");
17078 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17079 printf ("AVX512BW");
17081 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17082 printf ("AVX512_4FMAPS");
17084 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17085 printf ("AVX512_4VNNIW");
17087 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17088 printf ("AVX512_BITALG");
17090 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17091 printf ("AVX512_IFMA");
17093 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17094 printf ("AVX512_VBMI");
17096 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17097 printf ("AVX512_VBMI2");
17099 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17100 printf ("AVX512_VNNI");
17102 default: printf (_("<unknown: %x>"), bit
); break;
17110 decode_x86_feature_1 (unsigned int bitmask
)
17114 unsigned int bit
= bitmask
& (- bitmask
);
17119 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17122 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17126 printf (_("<unknown: %x>"), bit
);
17135 decode_x86_feature_2 (unsigned int bitmask
)
17139 unsigned int bit
= bitmask
& (- bitmask
);
17144 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17147 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17150 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17153 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17156 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17159 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17162 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17165 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17168 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17169 printf ("XSAVEOPT");
17171 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17174 default: printf (_("<unknown: %x>"), bit
); break;
17182 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17184 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17185 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17186 unsigned int size
= is_32bit_elf
? 4 : 8;
17188 printf (_(" Properties: "));
17190 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17192 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17196 while (ptr
< ptr_end
)
17200 unsigned int datasz
;
17202 if ((size_t) (ptr_end
- ptr
) < 8)
17204 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17208 type
= byte_get (ptr
, 4);
17209 datasz
= byte_get (ptr
+ 4, 4);
17213 if (datasz
> (size_t) (ptr_end
- ptr
))
17215 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17220 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17222 if (filedata
->file_header
.e_machine
== EM_X86_64
17223 || filedata
->file_header
.e_machine
== EM_IAMCU
17224 || filedata
->file_header
.e_machine
== EM_386
)
17226 unsigned int bitmask
;
17230 bitmask
= byte_get (ptr
, 4);
17231 if (filedata
->file_header
.e_type
== ET_EXEC
17232 || filedata
->file_header
.e_type
== ET_DYN
)
17234 if ((bitmask
& GNU_PROPERTY_X86_UINT32_VALID
))
17235 bitmask
&= ~GNU_PROPERTY_X86_UINT32_VALID
;
17237 printf ("Invalid ");
17245 case GNU_PROPERTY_X86_ISA_1_USED
:
17247 printf (_("x86 ISA used: <corrupt length: %#x> "),
17251 printf ("x86 ISA used: ");
17252 decode_x86_isa (bitmask
);
17256 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17258 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17262 printf ("x86 ISA needed: ");
17263 decode_x86_isa (bitmask
);
17267 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17269 printf (_("x86 feature: <corrupt length: %#x> "),
17273 printf ("x86 feature: ");
17274 decode_x86_feature_1 (bitmask
);
17278 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17280 printf (_("x86 feature used: <corrupt length: %#x> "),
17284 printf ("x86 feature used: ");
17285 decode_x86_feature_2 (bitmask
);
17289 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17291 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17294 printf ("x86 feature needed: ");
17295 decode_x86_feature_2 (bitmask
);
17299 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17301 printf (_("x86 ISA used: <corrupt length: %#x> "),
17305 printf ("x86 ISA used: ");
17306 decode_x86_compat_isa (bitmask
);
17310 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
17312 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17316 printf ("x86 ISA needed: ");
17317 decode_x86_compat_isa (bitmask
);
17330 case GNU_PROPERTY_STACK_SIZE
:
17331 printf (_("stack size: "));
17332 if (datasz
!= size
)
17333 printf (_("<corrupt length: %#x> "), datasz
);
17335 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17338 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17339 printf ("no copy on protected ");
17341 printf (_("<corrupt length: %#x> "), datasz
);
17349 if (type
< GNU_PROPERTY_LOPROC
)
17350 printf (_("<unknown type %#x data: "), type
);
17351 else if (type
< GNU_PROPERTY_LOUSER
)
17352 printf (_("<procesor-specific type %#x data: "), type
);
17354 printf (_("<application-specific type %#x data: "), type
);
17355 for (j
= 0; j
< datasz
; ++j
)
17356 printf ("%02x ", ptr
[j
] & 0xff);
17360 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17361 if (ptr
== ptr_end
)
17374 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17376 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17377 switch (pnote
->type
)
17379 case NT_GNU_BUILD_ID
:
17383 printf (_(" Build ID: "));
17384 for (i
= 0; i
< pnote
->descsz
; ++i
)
17385 printf ("%02x", pnote
->descdata
[i
] & 0xff);
17390 case NT_GNU_ABI_TAG
:
17392 unsigned long os
, major
, minor
, subminor
;
17393 const char *osname
;
17395 /* PR 17531: file: 030-599401-0.004. */
17396 if (pnote
->descsz
< 16)
17398 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17402 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17403 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17404 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
17405 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
17409 case GNU_ABI_TAG_LINUX
:
17412 case GNU_ABI_TAG_HURD
:
17415 case GNU_ABI_TAG_SOLARIS
:
17416 osname
= "Solaris";
17418 case GNU_ABI_TAG_FREEBSD
:
17419 osname
= "FreeBSD";
17421 case GNU_ABI_TAG_NETBSD
:
17424 case GNU_ABI_TAG_SYLLABLE
:
17425 osname
= "Syllable";
17427 case GNU_ABI_TAG_NACL
:
17431 osname
= "Unknown";
17435 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17436 major
, minor
, subminor
);
17440 case NT_GNU_GOLD_VERSION
:
17444 printf (_(" Version: "));
17445 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17446 printf ("%c", pnote
->descdata
[i
]);
17453 unsigned long num_entries
, mask
;
17455 /* Hardware capabilities information. Word 0 is the number of entries.
17456 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17457 is a series of entries, where each entry is a single byte followed
17458 by a nul terminated string. The byte gives the bit number to test
17459 if enabled in the bitmask. */
17460 printf (_(" Hardware Capabilities: "));
17461 if (pnote
->descsz
< 8)
17463 error (_("<corrupt GNU_HWCAP>\n"));
17466 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17467 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17468 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17469 /* FIXME: Add code to display the entries... */
17473 case NT_GNU_PROPERTY_TYPE_0
:
17474 print_gnu_property_note (filedata
, pnote
);
17478 /* Handle unrecognised types. An error message should have already been
17479 created by get_gnu_elf_note_type(), so all that we need to do is to
17480 display the data. */
17484 printf (_(" Description data: "));
17485 for (i
= 0; i
< pnote
->descsz
; ++i
)
17486 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17495 static const char *
17496 get_v850_elf_note_type (enum v850_notes n_type
)
17498 static char buff
[64];
17502 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17503 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17504 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17505 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17506 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17507 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17509 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17515 print_v850_note (Elf_Internal_Note
* pnote
)
17519 if (pnote
->descsz
!= 4)
17522 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17526 printf (_("not set\n"));
17530 switch (pnote
->type
)
17532 case V850_NOTE_ALIGNMENT
:
17535 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17536 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17540 case V850_NOTE_DATA_SIZE
:
17543 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17544 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17548 case V850_NOTE_FPU_INFO
:
17551 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17552 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17556 case V850_NOTE_MMU_INFO
:
17557 case V850_NOTE_CACHE_INFO
:
17558 case V850_NOTE_SIMD_INFO
:
17559 if (val
== EF_RH850_SIMD
)
17561 printf (_("yes\n"));
17567 /* An 'unknown note type' message will already have been displayed. */
17571 printf (_("unknown value: %x\n"), val
);
17576 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17578 unsigned int version
;
17580 switch (pnote
->type
)
17582 case NT_NETBSD_IDENT
:
17583 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17584 if ((version
/ 10000) % 100)
17585 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17586 version
, version
/ 100000000, (version
/ 1000000) % 100,
17587 (version
/ 10000) % 100 > 26 ? "Z" : "",
17588 'A' + (version
/ 10000) % 26);
17590 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17591 version
, version
/ 100000000, (version
/ 1000000) % 100,
17592 (version
/ 100) % 100);
17595 case NT_NETBSD_MARCH
:
17596 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17601 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17607 static const char *
17608 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17612 case NT_FREEBSD_THRMISC
:
17613 return _("NT_THRMISC (thrmisc structure)");
17614 case NT_FREEBSD_PROCSTAT_PROC
:
17615 return _("NT_PROCSTAT_PROC (proc data)");
17616 case NT_FREEBSD_PROCSTAT_FILES
:
17617 return _("NT_PROCSTAT_FILES (files data)");
17618 case NT_FREEBSD_PROCSTAT_VMMAP
:
17619 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17620 case NT_FREEBSD_PROCSTAT_GROUPS
:
17621 return _("NT_PROCSTAT_GROUPS (groups data)");
17622 case NT_FREEBSD_PROCSTAT_UMASK
:
17623 return _("NT_PROCSTAT_UMASK (umask data)");
17624 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17625 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17626 case NT_FREEBSD_PROCSTAT_OSREL
:
17627 return _("NT_PROCSTAT_OSREL (osreldate data)");
17628 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17629 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17630 case NT_FREEBSD_PROCSTAT_AUXV
:
17631 return _("NT_PROCSTAT_AUXV (auxv data)");
17632 case NT_FREEBSD_PTLWPINFO
:
17633 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17635 return get_note_type (filedata
, e_type
);
17638 static const char *
17639 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17641 static char buff
[64];
17643 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17644 return _("NetBSD procinfo structure");
17646 /* As of Jan 2002 there are no other machine-independent notes
17647 defined for NetBSD core files. If the note type is less
17648 than the start of the machine-dependent note types, we don't
17651 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17653 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17657 switch (filedata
->file_header
.e_machine
)
17659 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17660 and PT_GETFPREGS == mach+2. */
17665 case EM_SPARC32PLUS
:
17669 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17670 return _("PT_GETREGS (reg structure)");
17671 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17672 return _("PT_GETFPREGS (fpreg structure)");
17678 /* On all other arch's, PT_GETREGS == mach+1 and
17679 PT_GETFPREGS == mach+3. */
17683 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17684 return _("PT_GETREGS (reg structure)");
17685 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17686 return _("PT_GETFPREGS (fpreg structure)");
17692 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17693 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17697 static const char *
17698 get_stapsdt_note_type (unsigned e_type
)
17700 static char buff
[64];
17705 return _("NT_STAPSDT (SystemTap probe descriptors)");
17711 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17716 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17718 int addr_size
= is_32bit_elf
? 4 : 8;
17719 char *data
= pnote
->descdata
;
17720 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17721 bfd_vma pc
, base_addr
, semaphore
;
17722 char *provider
, *probe
, *arg_fmt
;
17724 pc
= byte_get ((unsigned char *) data
, addr_size
);
17726 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17728 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17732 data
+= strlen (data
) + 1;
17734 data
+= strlen (data
) + 1;
17736 data
+= strlen (data
) + 1;
17738 printf (_(" Provider: %s\n"), provider
);
17739 printf (_(" Name: %s\n"), probe
);
17740 printf (_(" Location: "));
17741 print_vma (pc
, FULL_HEX
);
17742 printf (_(", Base: "));
17743 print_vma (base_addr
, FULL_HEX
);
17744 printf (_(", Semaphore: "));
17745 print_vma (semaphore
, FULL_HEX
);
17747 printf (_(" Arguments: %s\n"), arg_fmt
);
17749 return data
== data_end
;
17752 static const char *
17753 get_ia64_vms_note_type (unsigned e_type
)
17755 static char buff
[64];
17760 return _("NT_VMS_MHD (module header)");
17762 return _("NT_VMS_LNM (language name)");
17764 return _("NT_VMS_SRC (source files)");
17766 return "NT_VMS_TITLE";
17768 return _("NT_VMS_EIDC (consistency check)");
17769 case NT_VMS_FPMODE
:
17770 return _("NT_VMS_FPMODE (FP mode)");
17771 case NT_VMS_LINKTIME
:
17772 return "NT_VMS_LINKTIME";
17773 case NT_VMS_IMGNAM
:
17774 return _("NT_VMS_IMGNAM (image name)");
17776 return _("NT_VMS_IMGID (image id)");
17777 case NT_VMS_LINKID
:
17778 return _("NT_VMS_LINKID (link id)");
17779 case NT_VMS_IMGBID
:
17780 return _("NT_VMS_IMGBID (build id)");
17781 case NT_VMS_GSTNAM
:
17782 return _("NT_VMS_GSTNAM (sym table name)");
17783 case NT_VMS_ORIG_DYN
:
17784 return "NT_VMS_ORIG_DYN";
17785 case NT_VMS_PATCHTIME
:
17786 return "NT_VMS_PATCHTIME";
17788 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17794 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17796 switch (pnote
->type
)
17799 if (pnote
->descsz
> 36)
17801 size_t l
= strlen (pnote
->descdata
+ 34);
17802 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17803 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17804 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17805 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17808 printf (_(" Invalid size\n"));
17811 printf (_(" Language: %s\n"), pnote
->descdata
);
17814 case NT_VMS_FPMODE
:
17815 printf (_(" Floating Point mode: "));
17816 printf ("0x%016" BFD_VMA_FMT
"x\n",
17817 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17819 case NT_VMS_LINKTIME
:
17820 printf (_(" Link time: "));
17822 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17825 case NT_VMS_PATCHTIME
:
17826 printf (_(" Patch time: "));
17828 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17831 case NT_VMS_ORIG_DYN
:
17832 printf (_(" Major id: %u, minor id: %u\n"),
17833 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17834 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17835 printf (_(" Last modified : "));
17837 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17838 printf (_("\n Link flags : "));
17839 printf ("0x%016" BFD_VMA_FMT
"x\n",
17840 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17841 printf (_(" Header flags: 0x%08x\n"),
17842 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17843 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17846 case NT_VMS_IMGNAM
:
17847 printf (_(" Image name: %s\n"), pnote
->descdata
);
17849 case NT_VMS_GSTNAM
:
17850 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17853 printf (_(" Image id: %s\n"), pnote
->descdata
);
17855 case NT_VMS_LINKID
:
17856 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17864 /* Find the symbol associated with a build attribute that is attached
17865 to address OFFSET. If PNAME is non-NULL then store the name of
17866 the symbol (if found) in the provided pointer, Returns NULL if a
17867 symbol could not be found. */
17869 static Elf_Internal_Sym
*
17870 get_symbol_for_build_attribute (Filedata
* filedata
,
17871 unsigned long offset
,
17872 bfd_boolean is_open_attr
,
17873 const char ** pname
)
17875 static Filedata
* saved_filedata
= NULL
;
17876 static char * strtab
;
17877 static unsigned long strtablen
;
17878 static Elf_Internal_Sym
* symtab
;
17879 static unsigned long nsyms
;
17880 Elf_Internal_Sym
* saved_sym
= NULL
;
17881 Elf_Internal_Sym
* sym
;
17883 if (filedata
->section_headers
!= NULL
17884 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17886 Elf_Internal_Shdr
* symsec
;
17888 /* Load the symbol and string sections. */
17889 for (symsec
= filedata
->section_headers
;
17890 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17893 if (symsec
->sh_type
== SHT_SYMTAB
)
17895 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17897 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17899 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17901 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17902 1, strtab_sec
->sh_size
,
17903 _("string table"));
17904 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17908 saved_filedata
= filedata
;
17911 if (symtab
== NULL
|| strtab
== NULL
)
17914 /* Find a symbol whose value matches offset. */
17915 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17916 if (sym
->st_value
== offset
)
17918 if (sym
->st_name
>= strtablen
)
17919 /* Huh ? This should not happen. */
17922 if (strtab
[sym
->st_name
] == 0)
17925 /* The AArch64 and ARM architectures define mapping symbols
17926 (eg $d, $x, $t) which we want to ignore. */
17927 if (strtab
[sym
->st_name
] == '$'
17928 && strtab
[sym
->st_name
+ 1] != 0
17929 && strtab
[sym
->st_name
+ 2] == 0)
17934 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17935 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17936 FUNC symbols entirely. */
17937 switch (ELF_ST_TYPE (sym
->st_info
))
17944 /* If the symbol has a size associated
17945 with it then we can stop searching. */
17946 sym
= symtab
+ nsyms
;
17951 /* Ignore function symbols. */
17958 switch (ELF_ST_BIND (sym
->st_info
))
17961 if (saved_sym
== NULL
17962 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17967 if (saved_sym
== NULL
)
17977 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17985 if (saved_sym
&& pname
)
17986 * pname
= strtab
+ saved_sym
->st_name
;
17991 /* Returns true iff addr1 and addr2 are in the same section. */
17994 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
17996 Elf_Internal_Shdr
* a1
;
17997 Elf_Internal_Shdr
* a2
;
17999 a1
= find_section_by_address (filedata
, addr1
);
18000 a2
= find_section_by_address (filedata
, addr2
);
18002 return a1
== a2
&& a1
!= NULL
;
18006 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18007 Filedata
* filedata
)
18009 static unsigned long global_offset
= 0;
18010 static unsigned long global_end
= 0;
18011 static unsigned long func_offset
= 0;
18012 static unsigned long func_end
= 0;
18014 Elf_Internal_Sym
* sym
;
18016 unsigned long start
;
18018 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18020 switch (pnote
->descsz
)
18023 /* A zero-length description means that the range of
18024 the previous note of the same type should be used. */
18027 if (global_end
> global_offset
)
18028 printf (_(" Applies to region from %#lx to %#lx\n"),
18029 global_offset
, global_end
);
18031 printf (_(" Applies to region from %#lx\n"), global_offset
);
18035 if (func_end
> func_offset
)
18036 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18038 printf (_(" Applies to region from %#lx\n"), func_offset
);
18043 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18050 /* FIXME: We should check that version 3+ notes are being used here... */
18051 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18052 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18056 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18062 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18063 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18067 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18068 printf (_(" <invalid descsz>"));
18073 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18074 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18075 in order to avoid them being confused with the start address of the
18076 first function in the file... */
18077 if (sym
== NULL
&& is_open_attr
)
18078 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18081 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18082 end
= start
+ sym
->st_size
;
18086 /* FIXME: Need to properly allow for section alignment.
18087 16 is just the alignment used on x86_64. */
18089 && start
> BFD_ALIGN (global_end
, 16)
18090 /* Build notes are not guaranteed to be organised in order of
18091 increasing address, but we should find the all of the notes
18092 for one section in the same place. */
18093 && same_section (filedata
, start
, global_end
))
18094 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18095 global_end
+ 1, start
- 1);
18097 printf (_(" Applies to region from %#lx"), start
);
18098 global_offset
= start
;
18102 printf (_(" to %#lx"), end
);
18108 printf (_(" Applies to region from %#lx"), start
);
18109 func_offset
= start
;
18113 printf (_(" to %#lx"), end
);
18119 printf (_(" (%s)"), name
);
18126 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18128 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18129 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18130 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18132 char name_attribute
;
18133 const char * expected_types
;
18134 const char * name
= pnote
->namedata
;
18138 if (name
== NULL
|| pnote
->namesz
< 2)
18140 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18141 print_symbol (-20, _(" <corrupt name>"));
18150 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18151 if (name
[0] == 'G' && name
[1] == 'A')
18153 if (pnote
->namesz
< 4)
18155 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18156 print_symbol (-20, _(" <corrupt name>"));
18165 switch ((name_type
= * name
))
18167 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18168 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18169 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18170 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18171 printf ("%c", * name
);
18175 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
18176 print_symbol (-20, _("<unknown name type>"));
18183 switch ((name_attribute
= * name
))
18185 case GNU_BUILD_ATTRIBUTE_VERSION
:
18186 text
= _("<version>");
18187 expected_types
= string_expected
;
18190 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18191 text
= _("<stack prot>");
18192 expected_types
= "!+*";
18195 case GNU_BUILD_ATTRIBUTE_RELRO
:
18196 text
= _("<relro>");
18197 expected_types
= bool_expected
;
18200 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
18201 text
= _("<stack size>");
18202 expected_types
= number_expected
;
18205 case GNU_BUILD_ATTRIBUTE_TOOL
:
18206 text
= _("<tool>");
18207 expected_types
= string_expected
;
18210 case GNU_BUILD_ATTRIBUTE_ABI
:
18212 expected_types
= "$*";
18215 case GNU_BUILD_ATTRIBUTE_PIC
:
18217 expected_types
= number_expected
;
18220 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
18221 text
= _("<short enum>");
18222 expected_types
= bool_expected
;
18226 if (ISPRINT (* name
))
18228 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
18230 if (len
> left
&& ! do_wide
)
18232 printf ("%.*s:", len
, name
);
18238 static char tmpbuf
[128];
18240 error (_("unrecognised byte in name field: %d\n"), * name
);
18241 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
18245 expected_types
= "*$!+";
18250 left
-= printf ("%s", text
);
18252 if (strchr (expected_types
, name_type
) == NULL
)
18253 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
18255 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
18257 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18258 (unsigned long) pnote
->namesz
,
18259 (long) (name
- pnote
->namedata
));
18263 if (left
< 1 && ! do_wide
)
18268 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18270 unsigned int bytes
;
18271 unsigned long long val
= 0;
18272 unsigned int shift
= 0;
18273 char * decoded
= NULL
;
18275 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
18277 /* The -1 is because the name field is always 0 terminated, and we
18278 want to be able to ensure that the shift in the while loop below
18279 will not overflow. */
18282 if (bytes
> sizeof (val
))
18284 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18286 bytes
= sizeof (val
);
18288 /* We do not bother to warn if bytes == 0 as this can
18289 happen with some early versions of the gcc plugin. */
18293 unsigned long byte
= (* name
++) & 0xff;
18295 val
|= byte
<< shift
;
18299 switch (name_attribute
)
18301 case GNU_BUILD_ATTRIBUTE_PIC
:
18304 case 0: decoded
= "static"; break;
18305 case 1: decoded
= "pic"; break;
18306 case 2: decoded
= "PIC"; break;
18307 case 3: decoded
= "pie"; break;
18308 case 4: decoded
= "PIE"; break;
18312 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18315 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18316 case 0: decoded
= "off"; break;
18317 case 1: decoded
= "on"; break;
18318 case 2: decoded
= "all"; break;
18319 case 3: decoded
= "strong"; break;
18320 case 4: decoded
= "explicit"; break;
18328 if (decoded
!= NULL
)
18330 print_symbol (-left
, decoded
);
18341 left
-= printf ("0x%llx", val
);
18343 left
-= printf ("0x%-.*llx", left
, val
);
18347 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18348 left
-= print_symbol (- left
, name
);
18350 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18351 left
-= print_symbol (- left
, "true");
18353 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18354 left
-= print_symbol (- left
, "false");
18358 if (do_wide
&& left
> 0)
18359 printf ("%-*s", left
, " ");
18364 /* Note that by the ELF standard, the name field is already null byte
18365 terminated, and namesz includes the terminating null byte.
18366 I.E. the value of namesz for the name "FSF" is 4.
18368 If the value of namesz is zero, there is no name present. */
18371 process_note (Elf_Internal_Note
* pnote
,
18372 Filedata
* filedata
)
18374 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
18377 if (pnote
->namesz
== 0)
18378 /* If there is no note name, then use the default set of
18379 note type strings. */
18380 nt
= get_note_type (filedata
, pnote
->type
);
18382 else if (const_strneq (pnote
->namedata
, "GNU"))
18383 /* GNU-specific object file notes. */
18384 nt
= get_gnu_elf_note_type (pnote
->type
);
18386 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
18387 /* FreeBSD-specific core file notes. */
18388 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
18390 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
18391 /* NetBSD-specific core file notes. */
18392 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
18394 else if (const_strneq (pnote
->namedata
, "NetBSD"))
18395 /* NetBSD-specific core file notes. */
18396 return process_netbsd_elf_note (pnote
);
18398 else if (strneq (pnote
->namedata
, "SPU/", 4))
18400 /* SPU-specific core file notes. */
18401 nt
= pnote
->namedata
+ 4;
18405 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18406 /* VMS/ia64-specific file notes. */
18407 nt
= get_ia64_vms_note_type (pnote
->type
);
18409 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18410 nt
= get_stapsdt_note_type (pnote
->type
);
18413 /* Don't recognize this note name; just use the default set of
18414 note type strings. */
18415 nt
= get_note_type (filedata
, pnote
->type
);
18419 if (((const_strneq (pnote
->namedata
, "GA")
18420 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18421 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18422 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18423 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18424 print_gnu_build_attribute_name (pnote
);
18426 print_symbol (-20, name
);
18429 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
18431 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
18433 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18434 return print_ia64_vms_note (pnote
);
18435 else if (const_strneq (pnote
->namedata
, "GNU"))
18436 return print_gnu_note (filedata
, pnote
);
18437 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18438 return print_stapsdt_note (pnote
);
18439 else if (const_strneq (pnote
->namedata
, "CORE"))
18440 return print_core_note (pnote
);
18441 else if (((const_strneq (pnote
->namedata
, "GA")
18442 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18443 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18444 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18445 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18446 return print_gnu_build_attribute_description (pnote
, filedata
);
18452 printf (_(" description data: "));
18453 for (i
= 0; i
< pnote
->descsz
; i
++)
18454 printf ("%02x ", pnote
->descdata
[i
]);
18466 process_notes_at (Filedata
* filedata
,
18467 Elf_Internal_Shdr
* section
,
18472 Elf_External_Note
* pnotes
;
18473 Elf_External_Note
* external
;
18475 bfd_boolean res
= TRUE
;
18482 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18485 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18490 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18493 if (pnotes
== NULL
)
18499 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18501 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18502 (unsigned long) offset
, (unsigned long) length
);
18504 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18505 specifies that notes should be aligned to 4 bytes in 32-bit
18506 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18507 we also support 4 byte alignment in 64-bit objects. If section
18508 alignment is less than 4, we treate alignment as 4 bytes. */
18511 else if (align
!= 4 && align
!= 8)
18513 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18518 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18520 end
= (char *) pnotes
+ length
;
18521 while ((char *) external
< end
)
18523 Elf_Internal_Note inote
;
18526 char * temp
= NULL
;
18527 size_t data_remaining
= end
- (char *) external
;
18529 if (!is_ia64_vms (filedata
))
18531 /* PR binutils/15191
18532 Make sure that there is enough data to read. */
18533 min_notesz
= offsetof (Elf_External_Note
, name
);
18534 if (data_remaining
< min_notesz
)
18536 warn (ngettext ("Corrupt note: only %ld byte remains, "
18537 "not enough for a full note\n",
18538 "Corrupt note: only %ld bytes remain, "
18539 "not enough for a full note\n",
18541 (long) data_remaining
);
18544 data_remaining
-= min_notesz
;
18546 inote
.type
= BYTE_GET (external
->type
);
18547 inote
.namesz
= BYTE_GET (external
->namesz
);
18548 inote
.namedata
= external
->name
;
18549 inote
.descsz
= BYTE_GET (external
->descsz
);
18550 inote
.descdata
= ((char *) external
18551 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18552 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18553 next
= ((char *) external
18554 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18558 Elf64_External_VMS_Note
*vms_external
;
18560 /* PR binutils/15191
18561 Make sure that there is enough data to read. */
18562 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18563 if (data_remaining
< min_notesz
)
18565 warn (ngettext ("Corrupt note: only %ld byte remains, "
18566 "not enough for a full note\n",
18567 "Corrupt note: only %ld bytes remain, "
18568 "not enough for a full note\n",
18570 (long) data_remaining
);
18573 data_remaining
-= min_notesz
;
18575 vms_external
= (Elf64_External_VMS_Note
*) external
;
18576 inote
.type
= BYTE_GET (vms_external
->type
);
18577 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18578 inote
.namedata
= vms_external
->name
;
18579 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18580 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18581 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18582 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18585 /* PR 17531: file: 3443835e. */
18586 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18587 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18588 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18589 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18590 || ((size_t) (next
- inote
.descdata
)
18591 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18593 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18594 (unsigned long) ((char *) external
- (char *) pnotes
));
18595 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18596 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18600 external
= (Elf_External_Note
*) next
;
18602 /* Verify that name is null terminated. It appears that at least
18603 one version of Linux (RedHat 6.0) generates corefiles that don't
18604 comply with the ELF spec by failing to include the null byte in
18606 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18608 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18610 temp
= (char *) malloc (inote
.namesz
+ 1);
18613 error (_("Out of memory allocating space for inote name\n"));
18618 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18619 inote
.namedata
= temp
;
18621 inote
.namedata
[inote
.namesz
] = 0;
18624 if (! process_note (& inote
, filedata
))
18640 process_corefile_note_segments (Filedata
* filedata
)
18642 Elf_Internal_Phdr
* segment
;
18644 bfd_boolean res
= TRUE
;
18646 if (! get_program_headers (filedata
))
18649 for (i
= 0, segment
= filedata
->program_headers
;
18650 i
< filedata
->file_header
.e_phnum
;
18653 if (segment
->p_type
== PT_NOTE
)
18654 if (! process_notes_at (filedata
, NULL
,
18655 (bfd_vma
) segment
->p_offset
,
18656 (bfd_vma
) segment
->p_filesz
,
18657 (bfd_vma
) segment
->p_align
))
18665 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18667 Elf_External_Note
* pnotes
;
18668 Elf_External_Note
* external
;
18670 bfd_boolean res
= TRUE
;
18675 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18677 if (pnotes
== NULL
)
18681 end
= (char*) pnotes
+ length
;
18683 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18684 (unsigned long) offset
, (unsigned long) length
);
18686 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18688 Elf_External_Note
* next
;
18689 Elf_Internal_Note inote
;
18691 inote
.type
= BYTE_GET (external
->type
);
18692 inote
.namesz
= BYTE_GET (external
->namesz
);
18693 inote
.namedata
= external
->name
;
18694 inote
.descsz
= BYTE_GET (external
->descsz
);
18695 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18696 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18698 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18700 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18701 inote
.descdata
= inote
.namedata
;
18705 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18707 if ( ((char *) next
> end
)
18708 || ((char *) next
< (char *) pnotes
))
18710 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18711 (unsigned long) ((char *) external
- (char *) pnotes
));
18712 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18713 inote
.type
, inote
.namesz
, inote
.descsz
);
18719 /* Prevent out-of-bounds indexing. */
18720 if ( inote
.namedata
+ inote
.namesz
> end
18721 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18723 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18724 (unsigned long) ((char *) external
- (char *) pnotes
));
18725 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18726 inote
.type
, inote
.namesz
, inote
.descsz
);
18730 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18732 if (! print_v850_note (& inote
))
18735 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18736 inote
.namesz
, inote
.descsz
);
18746 process_note_sections (Filedata
* filedata
)
18748 Elf_Internal_Shdr
* section
;
18750 unsigned int n
= 0;
18751 bfd_boolean res
= TRUE
;
18753 for (i
= 0, section
= filedata
->section_headers
;
18754 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18757 if (section
->sh_type
== SHT_NOTE
)
18759 if (! process_notes_at (filedata
, section
,
18760 (bfd_vma
) section
->sh_offset
,
18761 (bfd_vma
) section
->sh_size
,
18762 (bfd_vma
) section
->sh_addralign
))
18767 if (( filedata
->file_header
.e_machine
== EM_V800
18768 || filedata
->file_header
.e_machine
== EM_V850
18769 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18770 && section
->sh_type
== SHT_RENESAS_INFO
)
18772 if (! process_v850_notes (filedata
,
18773 (bfd_vma
) section
->sh_offset
,
18774 (bfd_vma
) section
->sh_size
))
18781 /* Try processing NOTE segments instead. */
18782 return process_corefile_note_segments (filedata
);
18788 process_notes (Filedata
* filedata
)
18790 /* If we have not been asked to display the notes then do nothing. */
18794 if (filedata
->file_header
.e_type
!= ET_CORE
)
18795 return process_note_sections (filedata
);
18797 /* No program headers means no NOTE segment. */
18798 if (filedata
->file_header
.e_phnum
> 0)
18799 return process_corefile_note_segments (filedata
);
18801 printf (_("No note segments present in the core file.\n"));
18805 static unsigned char *
18806 display_public_gnu_attributes (unsigned char * start
,
18807 const unsigned char * const end
)
18809 printf (_(" Unknown GNU attribute: %s\n"), start
);
18811 start
+= strnlen ((char *) start
, end
- start
);
18812 display_raw_attribute (start
, end
);
18814 return (unsigned char *) end
;
18817 static unsigned char *
18818 display_generic_attribute (unsigned char * start
,
18820 const unsigned char * const end
)
18823 return (unsigned char *) end
;
18825 return display_tag_value (tag
, start
, end
);
18829 process_arch_specific (Filedata
* filedata
)
18834 switch (filedata
->file_header
.e_machine
)
18837 case EM_ARC_COMPACT
:
18838 case EM_ARC_COMPACT2
:
18839 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18840 display_arc_attribute
,
18841 display_generic_attribute
);
18843 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18844 display_arm_attribute
,
18845 display_generic_attribute
);
18848 case EM_MIPS_RS3_LE
:
18849 return process_mips_specific (filedata
);
18852 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18853 display_msp430x_attribute
,
18854 display_generic_attribute
);
18857 return process_nds32_specific (filedata
);
18861 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18862 display_power_gnu_attribute
);
18866 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18867 display_s390_gnu_attribute
);
18870 case EM_SPARC32PLUS
:
18872 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18873 display_sparc_gnu_attribute
);
18876 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18877 display_tic6x_attribute
,
18878 display_generic_attribute
);
18881 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18882 display_public_gnu_attributes
,
18883 display_generic_attribute
);
18888 get_file_header (Filedata
* filedata
)
18890 /* Read in the identity array. */
18891 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18894 /* Determine how to read the rest of the header. */
18895 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18900 byte_get
= byte_get_little_endian
;
18901 byte_put
= byte_put_little_endian
;
18904 byte_get
= byte_get_big_endian
;
18905 byte_put
= byte_put_big_endian
;
18909 /* For now we only support 32 bit and 64 bit ELF files. */
18910 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18912 /* Read in the rest of the header. */
18915 Elf32_External_Ehdr ehdr32
;
18917 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18920 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18921 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18922 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18923 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18924 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18925 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18926 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18927 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18928 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18929 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18930 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18931 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18932 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18936 Elf64_External_Ehdr ehdr64
;
18938 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18939 we will not be able to cope with the 64bit data found in
18940 64 ELF files. Detect this now and abort before we start
18941 overwriting things. */
18942 if (sizeof (bfd_vma
) < 8)
18944 error (_("This instance of readelf has been built without support for a\n\
18945 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18949 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18952 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18953 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18954 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18955 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18956 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18957 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18958 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18959 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18960 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18961 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18962 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18963 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18964 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18967 if (filedata
->file_header
.e_shoff
)
18969 /* There may be some extensions in the first section header. Don't
18970 bomb if we can't read it. */
18972 get_32bit_section_headers (filedata
, TRUE
);
18974 get_64bit_section_headers (filedata
, TRUE
);
18981 close_file (Filedata
* filedata
)
18985 if (filedata
->handle
)
18986 fclose (filedata
->handle
);
18992 close_debug_file (void * data
)
18994 close_file ((Filedata
*) data
);
18998 open_file (const char * pathname
)
19000 struct stat statbuf
;
19001 Filedata
* filedata
= NULL
;
19003 if (stat (pathname
, & statbuf
) < 0
19004 || ! S_ISREG (statbuf
.st_mode
))
19007 filedata
= calloc (1, sizeof * filedata
);
19008 if (filedata
== NULL
)
19011 filedata
->handle
= fopen (pathname
, "rb");
19012 if (filedata
->handle
== NULL
)
19015 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19016 filedata
->file_name
= pathname
;
19018 if (! get_file_header (filedata
))
19021 if (filedata
->file_header
.e_shoff
)
19025 /* Read the section headers again, this time for real. */
19027 res
= get_32bit_section_headers (filedata
, FALSE
);
19029 res
= get_64bit_section_headers (filedata
, FALSE
);
19040 if (filedata
->handle
)
19041 fclose (filedata
->handle
);
19048 open_debug_file (const char * pathname
)
19050 return open_file (pathname
);
19053 /* Process one ELF object file according to the command line options.
19054 This file may actually be stored in an archive. The file is
19055 positioned at the start of the ELF object. Returns TRUE if no
19056 problems were encountered, FALSE otherwise. */
19059 process_object (Filedata
* filedata
)
19061 Filedata
* separates
;
19063 bfd_boolean res
= TRUE
;
19065 if (! get_file_header (filedata
))
19067 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19071 /* Initialise per file variables. */
19072 for (i
= ARRAY_SIZE (version_info
); i
--;)
19073 version_info
[i
] = 0;
19075 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19076 dynamic_info
[i
] = 0;
19077 dynamic_info_DT_GNU_HASH
= 0;
19079 /* Process the file. */
19081 printf (_("\nFile: %s\n"), filedata
->file_name
);
19083 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19084 Note we do this even if cmdline_dump_sects is empty because we
19085 must make sure that the dump_sets array is zeroed out before each
19086 object file is processed. */
19087 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19088 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19090 if (cmdline
.num_dump_sects
> 0)
19092 if (filedata
->num_dump_sects
== 0)
19093 /* A sneaky way of allocating the dump_sects array. */
19094 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19096 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19097 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19098 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19101 if (! process_file_header (filedata
))
19104 if (! process_section_headers (filedata
))
19106 /* Without loaded section headers we cannot process lots of things. */
19107 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19109 if (! do_using_dynamic
)
19110 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19113 if (! process_section_groups (filedata
))
19114 /* Without loaded section groups we cannot process unwind. */
19117 if (process_program_headers (filedata
))
19118 process_dynamic_section (filedata
);
19122 if (! process_relocs (filedata
))
19125 if (! process_unwind (filedata
))
19128 if (! process_symbol_table (filedata
))
19131 if (! process_syminfo (filedata
))
19134 if (! process_version_sections (filedata
))
19137 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19138 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
19142 if (! process_section_contents (filedata
))
19147 if (! process_section_headers (separates
))
19149 else if (! process_section_contents (separates
))
19153 if (! process_notes (filedata
))
19156 if (! process_gnu_liblist (filedata
))
19159 if (! process_arch_specific (filedata
))
19162 free (filedata
->program_headers
);
19163 filedata
->program_headers
= NULL
;
19165 free (filedata
->section_headers
);
19166 filedata
->section_headers
= NULL
;
19168 free (filedata
->string_table
);
19169 filedata
->string_table
= NULL
;
19170 filedata
->string_table_length
= 0;
19172 if (dynamic_strings
)
19174 free (dynamic_strings
);
19175 dynamic_strings
= NULL
;
19176 dynamic_strings_length
= 0;
19179 if (dynamic_symbols
)
19181 free (dynamic_symbols
);
19182 dynamic_symbols
= NULL
;
19183 num_dynamic_syms
= 0;
19186 if (dynamic_syminfo
)
19188 free (dynamic_syminfo
);
19189 dynamic_syminfo
= NULL
;
19192 if (dynamic_section
)
19194 free (dynamic_section
);
19195 dynamic_section
= NULL
;
19198 if (section_headers_groups
)
19200 free (section_headers_groups
);
19201 section_headers_groups
= NULL
;
19204 if (section_groups
)
19206 struct group_list
* g
;
19207 struct group_list
* next
;
19209 for (i
= 0; i
< group_count
; i
++)
19211 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
19218 free (section_groups
);
19219 section_groups
= NULL
;
19222 free_debug_memory ();
19227 /* Process an ELF archive.
19228 On entry the file is positioned just after the ARMAG string.
19229 Returns TRUE upon success, FALSE otherwise. */
19232 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
19234 struct archive_info arch
;
19235 struct archive_info nested_arch
;
19237 bfd_boolean ret
= TRUE
;
19241 /* The ARCH structure is used to hold information about this archive. */
19242 arch
.file_name
= NULL
;
19244 arch
.index_array
= NULL
;
19245 arch
.sym_table
= NULL
;
19246 arch
.longnames
= NULL
;
19248 /* The NESTED_ARCH structure is used as a single-item cache of information
19249 about a nested archive (when members of a thin archive reside within
19250 another regular archive file). */
19251 nested_arch
.file_name
= NULL
;
19252 nested_arch
.file
= NULL
;
19253 nested_arch
.index_array
= NULL
;
19254 nested_arch
.sym_table
= NULL
;
19255 nested_arch
.longnames
= NULL
;
19257 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
19258 is_thin_archive
, do_archive_index
) != 0)
19264 if (do_archive_index
)
19266 if (arch
.sym_table
== NULL
)
19267 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
19270 unsigned long i
, l
;
19271 unsigned long current_pos
;
19273 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19274 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
19276 current_pos
= ftell (filedata
->handle
);
19278 for (i
= l
= 0; i
< arch
.index_num
; i
++)
19280 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
19282 char * member_name
;
19284 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
19286 if (member_name
!= NULL
)
19288 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
19290 if (qualified_name
!= NULL
)
19292 printf (_("Contents of binary %s at offset "), qualified_name
);
19293 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
19295 free (qualified_name
);
19300 if (l
>= arch
.sym_size
)
19302 error (_("%s: end of the symbol table reached before the end of the index\n"),
19303 filedata
->file_name
);
19307 /* PR 17531: file: 0b6630b2. */
19308 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
19309 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
19312 if (arch
.uses_64bit_indices
)
19317 if (l
< arch
.sym_size
)
19319 error (ngettext ("%s: %ld byte remains in the symbol table, "
19320 "but without corresponding entries in "
19321 "the index table\n",
19322 "%s: %ld bytes remain in the symbol table, "
19323 "but without corresponding entries in "
19324 "the index table\n",
19325 arch
.sym_size
- l
),
19326 filedata
->file_name
, arch
.sym_size
- l
);
19330 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
19332 error (_("%s: failed to seek back to start of object files in the archive\n"),
19333 filedata
->file_name
);
19339 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
19340 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
19341 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
19342 && !do_section_groups
&& !do_dyn_syms
)
19344 ret
= TRUE
; /* Archive index only. */
19353 char * qualified_name
;
19355 /* Read the next archive header. */
19356 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
19358 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
19361 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
19362 if (got
!= sizeof arch
.arhdr
)
19366 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
19370 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
19372 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
19377 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
19379 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
19380 if (archive_file_size
& 01)
19381 ++archive_file_size
;
19383 name
= get_archive_member_name (&arch
, &nested_arch
);
19386 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19390 namelen
= strlen (name
);
19392 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
19393 if (qualified_name
== NULL
)
19395 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19400 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
19402 /* This is a proxy for an external member of a thin archive. */
19403 Filedata
* member_filedata
;
19404 char * member_file_name
= adjust_relative_path
19405 (filedata
->file_name
, name
, namelen
);
19407 if (member_file_name
== NULL
)
19413 member_filedata
= open_file (member_file_name
);
19414 if (member_filedata
== NULL
)
19416 error (_("Input file '%s' is not readable.\n"), member_file_name
);
19417 free (member_file_name
);
19422 archive_file_offset
= arch
.nested_member_origin
;
19423 member_filedata
->file_name
= qualified_name
;
19425 if (! process_object (member_filedata
))
19428 close_file (member_filedata
);
19429 free (member_file_name
);
19431 else if (is_thin_archive
)
19433 Filedata thin_filedata
;
19435 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
19437 /* PR 15140: Allow for corrupt thin archives. */
19438 if (nested_arch
.file
== NULL
)
19440 error (_("%s: contains corrupt thin archive: %s\n"),
19441 filedata
->file_name
, name
);
19446 /* This is a proxy for a member of a nested archive. */
19447 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19449 /* The nested archive file will have been opened and setup by
19450 get_archive_member_name. */
19451 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19453 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19458 thin_filedata
.handle
= nested_arch
.file
;
19459 thin_filedata
.file_name
= qualified_name
;
19461 if (! process_object (& thin_filedata
))
19466 archive_file_offset
= arch
.next_arhdr_offset
;
19467 arch
.next_arhdr_offset
+= archive_file_size
;
19469 filedata
->file_name
= qualified_name
;
19470 if (! process_object (filedata
))
19474 if (filedata
->dump_sects
!= NULL
)
19476 free (filedata
->dump_sects
);
19477 filedata
->dump_sects
= NULL
;
19478 filedata
->num_dump_sects
= 0;
19481 free (qualified_name
);
19485 if (nested_arch
.file
!= NULL
)
19486 fclose (nested_arch
.file
);
19487 release_archive (&nested_arch
);
19488 release_archive (&arch
);
19494 process_file (char * file_name
)
19496 Filedata
* filedata
= NULL
;
19497 struct stat statbuf
;
19498 char armag
[SARMAG
];
19499 bfd_boolean ret
= TRUE
;
19501 if (stat (file_name
, &statbuf
) < 0)
19503 if (errno
== ENOENT
)
19504 error (_("'%s': No such file\n"), file_name
);
19506 error (_("Could not locate '%s'. System error message: %s\n"),
19507 file_name
, strerror (errno
));
19511 if (! S_ISREG (statbuf
.st_mode
))
19513 error (_("'%s' is not an ordinary file\n"), file_name
);
19517 filedata
= calloc (1, sizeof * filedata
);
19518 if (filedata
== NULL
)
19520 error (_("Out of memory allocating file data structure\n"));
19524 filedata
->file_name
= file_name
;
19525 filedata
->handle
= fopen (file_name
, "rb");
19526 if (filedata
->handle
== NULL
)
19528 error (_("Input file '%s' is not readable.\n"), file_name
);
19533 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19535 error (_("%s: Failed to read file's magic number\n"), file_name
);
19536 fclose (filedata
->handle
);
19541 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19543 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19545 if (! process_archive (filedata
, FALSE
))
19548 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19550 if ( ! process_archive (filedata
, TRUE
))
19555 if (do_archive_index
)
19556 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19559 rewind (filedata
->handle
);
19560 archive_file_size
= archive_file_offset
= 0;
19562 if (! process_object (filedata
))
19566 fclose (filedata
->handle
);
19572 #ifdef SUPPORT_DISASSEMBLY
19573 /* Needed by the i386 disassembler. For extra credit, someone could
19574 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19578 print_address (unsigned int addr
, FILE * outfile
)
19580 fprintf (outfile
,"0x%8.8x", addr
);
19583 /* Needed by the i386 disassembler. */
19586 db_task_printsym (unsigned int addr
)
19588 print_address (addr
, stderr
);
19593 main (int argc
, char ** argv
)
19597 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19598 setlocale (LC_MESSAGES
, "");
19600 #if defined (HAVE_SETLOCALE)
19601 setlocale (LC_CTYPE
, "");
19603 bindtextdomain (PACKAGE
, LOCALEDIR
);
19604 textdomain (PACKAGE
);
19606 expandargv (&argc
, &argv
);
19608 cmdline
.file_name
= "<cmdline>";
19609 parse_args (& cmdline
, argc
, argv
);
19611 if (optind
< (argc
- 1))
19613 else if (optind
>= argc
)
19615 warn (_("Nothing to do.\n"));
19620 while (optind
< argc
)
19621 if (! process_file (argv
[optind
++]))
19624 if (cmdline
.dump_sects
!= NULL
)
19625 free (cmdline
.dump_sects
);
19627 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;