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
4773 ? _("<unknown: %lx>")
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"),
4784 (unsigned long) header
->e_version
);
4786 printf (_(" Entry point address: "));
4787 print_vma ((bfd_vma
) header
->e_entry
, PREFIX_HEX
);
4788 printf (_("\n Start of program headers: "));
4789 print_vma ((bfd_vma
) header
->e_phoff
, DEC
);
4790 printf (_(" (bytes into file)\n Start of section headers: "));
4791 print_vma ((bfd_vma
) header
->e_shoff
, DEC
);
4792 printf (_(" (bytes into file)\n"));
4794 printf (_(" Flags: 0x%lx%s\n"),
4795 (unsigned long) header
->e_flags
,
4796 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4797 printf (_(" Size of this header: %ld (bytes)\n"),
4798 (long) header
->e_ehsize
);
4799 printf (_(" Size of program headers: %ld (bytes)\n"),
4800 (long) header
->e_phentsize
);
4801 printf (_(" Number of program headers: %ld"),
4802 (long) header
->e_phnum
);
4803 if (filedata
->section_headers
!= NULL
4804 && header
->e_phnum
== PN_XNUM
4805 && filedata
->section_headers
[0].sh_info
!= 0)
4806 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_info
);
4807 putc ('\n', stdout
);
4808 printf (_(" Size of section headers: %ld (bytes)\n"),
4809 (long) header
->e_shentsize
);
4810 printf (_(" Number of section headers: %ld"),
4811 (long) header
->e_shnum
);
4812 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4813 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_size
);
4814 putc ('\n', stdout
);
4815 printf (_(" Section header string table index: %ld"),
4816 (long) header
->e_shstrndx
);
4817 if (filedata
->section_headers
!= NULL
4818 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4819 printf (" (%u)", filedata
->section_headers
[0].sh_link
);
4820 else if (header
->e_shstrndx
!= SHN_UNDEF
4821 && header
->e_shstrndx
>= header
->e_shnum
)
4822 printf (_(" <corrupt: out of range>"));
4823 putc ('\n', stdout
);
4826 if (filedata
->section_headers
!= NULL
)
4828 if (header
->e_phnum
== PN_XNUM
4829 && filedata
->section_headers
[0].sh_info
!= 0)
4830 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4831 if (header
->e_shnum
== SHN_UNDEF
)
4832 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4833 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4834 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4835 if (header
->e_shstrndx
>= header
->e_shnum
)
4836 header
->e_shstrndx
= SHN_UNDEF
;
4837 free (filedata
->section_headers
);
4838 filedata
->section_headers
= NULL
;
4844 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4845 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4848 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4850 Elf32_External_Phdr
* phdrs
;
4851 Elf32_External_Phdr
* external
;
4852 Elf_Internal_Phdr
* internal
;
4854 unsigned int size
= filedata
->file_header
.e_phentsize
;
4855 unsigned int num
= filedata
->file_header
.e_phnum
;
4857 /* PR binutils/17531: Cope with unexpected section header sizes. */
4858 if (size
== 0 || num
== 0)
4860 if (size
< sizeof * phdrs
)
4862 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4865 if (size
> sizeof * phdrs
)
4866 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4868 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4869 size
, num
, _("program headers"));
4873 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4874 i
< filedata
->file_header
.e_phnum
;
4875 i
++, internal
++, external
++)
4877 internal
->p_type
= BYTE_GET (external
->p_type
);
4878 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4879 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4880 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4881 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4882 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4883 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4884 internal
->p_align
= BYTE_GET (external
->p_align
);
4891 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4892 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4895 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4897 Elf64_External_Phdr
* phdrs
;
4898 Elf64_External_Phdr
* external
;
4899 Elf_Internal_Phdr
* internal
;
4901 unsigned int size
= filedata
->file_header
.e_phentsize
;
4902 unsigned int num
= filedata
->file_header
.e_phnum
;
4904 /* PR binutils/17531: Cope with unexpected section header sizes. */
4905 if (size
== 0 || num
== 0)
4907 if (size
< sizeof * phdrs
)
4909 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4912 if (size
> sizeof * phdrs
)
4913 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4915 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4916 size
, num
, _("program headers"));
4920 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4921 i
< filedata
->file_header
.e_phnum
;
4922 i
++, internal
++, external
++)
4924 internal
->p_type
= BYTE_GET (external
->p_type
);
4925 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4926 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4927 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4928 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4929 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4930 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4931 internal
->p_align
= BYTE_GET (external
->p_align
);
4938 /* Returns TRUE if the program headers were read into `program_headers'. */
4941 get_program_headers (Filedata
* filedata
)
4943 Elf_Internal_Phdr
* phdrs
;
4945 /* Check cache of prior read. */
4946 if (filedata
->program_headers
!= NULL
)
4949 /* Be kind to memory checkers by looking for
4950 e_phnum values which we know must be invalid. */
4951 if (filedata
->file_header
.e_phnum
4952 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4953 >= filedata
->file_size
)
4955 error (_("Too many program headers - %#x - the file is not that big\n"),
4956 filedata
->file_header
.e_phnum
);
4960 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4961 sizeof (Elf_Internal_Phdr
));
4964 error (_("Out of memory reading %u program headers\n"),
4965 filedata
->file_header
.e_phnum
);
4970 ? get_32bit_program_headers (filedata
, phdrs
)
4971 : get_64bit_program_headers (filedata
, phdrs
))
4973 filedata
->program_headers
= phdrs
;
4981 /* Returns TRUE if the program headers were loaded. */
4984 process_program_headers (Filedata
* filedata
)
4986 Elf_Internal_Phdr
* segment
;
4988 Elf_Internal_Phdr
* previous_load
= NULL
;
4990 if (filedata
->file_header
.e_phnum
== 0)
4992 /* PR binutils/12467. */
4993 if (filedata
->file_header
.e_phoff
!= 0)
4995 warn (_("possibly corrupt ELF header - it has a non-zero program"
4996 " header offset, but no program headers\n"));
4999 else if (do_segments
)
5000 printf (_("\nThere are no program headers in this file.\n"));
5004 if (do_segments
&& !do_header
)
5006 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5007 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5008 printf (ngettext ("There is %d program header, starting at offset %s\n",
5009 "There are %d program headers, starting at offset %s\n",
5010 filedata
->file_header
.e_phnum
),
5011 filedata
->file_header
.e_phnum
,
5012 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5015 if (! get_program_headers (filedata
))
5020 if (filedata
->file_header
.e_phnum
> 1)
5021 printf (_("\nProgram Headers:\n"));
5023 printf (_("\nProgram Headers:\n"));
5027 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5030 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5034 (_(" Type Offset VirtAddr PhysAddr\n"));
5036 (_(" FileSiz MemSiz Flags Align\n"));
5043 for (i
= 0, segment
= filedata
->program_headers
;
5044 i
< filedata
->file_header
.e_phnum
;
5049 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5053 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5054 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5055 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5056 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5057 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5059 (segment
->p_flags
& PF_R
? 'R' : ' '),
5060 (segment
->p_flags
& PF_W
? 'W' : ' '),
5061 (segment
->p_flags
& PF_X
? 'E' : ' '));
5062 printf ("%#lx", (unsigned long) segment
->p_align
);
5066 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5067 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5070 print_vma (segment
->p_offset
, FULL_HEX
);
5074 print_vma (segment
->p_vaddr
, FULL_HEX
);
5076 print_vma (segment
->p_paddr
, FULL_HEX
);
5079 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5080 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5083 print_vma (segment
->p_filesz
, FULL_HEX
);
5087 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5088 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5091 print_vma (segment
->p_memsz
, FULL_HEX
);
5095 (segment
->p_flags
& PF_R
? 'R' : ' '),
5096 (segment
->p_flags
& PF_W
? 'W' : ' '),
5097 (segment
->p_flags
& PF_X
? 'E' : ' '));
5099 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5100 printf ("%#lx", (unsigned long) segment
->p_align
);
5103 print_vma (segment
->p_align
, PREFIX_HEX
);
5108 print_vma (segment
->p_offset
, FULL_HEX
);
5110 print_vma (segment
->p_vaddr
, FULL_HEX
);
5112 print_vma (segment
->p_paddr
, FULL_HEX
);
5114 print_vma (segment
->p_filesz
, FULL_HEX
);
5116 print_vma (segment
->p_memsz
, FULL_HEX
);
5118 (segment
->p_flags
& PF_R
? 'R' : ' '),
5119 (segment
->p_flags
& PF_W
? 'W' : ' '),
5120 (segment
->p_flags
& PF_X
? 'E' : ' '));
5121 print_vma (segment
->p_align
, PREFIX_HEX
);
5124 putc ('\n', stdout
);
5127 switch (segment
->p_type
)
5130 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5131 required by the ELF standard, several programs, including the Linux
5132 kernel, make use of non-ordered segments. */
5134 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5135 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5137 if (segment
->p_memsz
< segment
->p_filesz
)
5138 error (_("the segment's file size is larger than its memory size\n"));
5139 previous_load
= segment
;
5143 /* PR 20815 - Verify that the program header is loaded into memory. */
5144 if (i
> 0 && previous_load
!= NULL
)
5145 error (_("the PHDR segment must occur before any LOAD segment\n"));
5146 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5150 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5151 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5152 && (filedata
->program_headers
[j
].p_vaddr
5153 + filedata
->program_headers
[j
].p_memsz
)
5154 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5156 if (j
== filedata
->file_header
.e_phnum
)
5157 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5163 error (_("more than one dynamic segment\n"));
5165 /* By default, assume that the .dynamic section is the first
5166 section in the DYNAMIC segment. */
5167 dynamic_addr
= segment
->p_offset
;
5168 dynamic_size
= segment
->p_filesz
;
5170 /* Try to locate the .dynamic section. If there is
5171 a section header table, we can easily locate it. */
5172 if (filedata
->section_headers
!= NULL
)
5174 Elf_Internal_Shdr
* sec
;
5176 sec
= find_section (filedata
, ".dynamic");
5177 if (sec
== NULL
|| sec
->sh_size
== 0)
5179 /* A corresponding .dynamic section is expected, but on
5180 IA-64/OpenVMS it is OK for it to be missing. */
5181 if (!is_ia64_vms (filedata
))
5182 error (_("no .dynamic section in the dynamic segment\n"));
5186 if (sec
->sh_type
== SHT_NOBITS
)
5192 dynamic_addr
= sec
->sh_offset
;
5193 dynamic_size
= sec
->sh_size
;
5195 if (dynamic_addr
< segment
->p_offset
5196 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5197 warn (_("the .dynamic section is not contained"
5198 " within the dynamic segment\n"));
5199 else if (dynamic_addr
> segment
->p_offset
)
5200 warn (_("the .dynamic section is not the first section"
5201 " in the dynamic segment.\n"));
5204 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5205 segment. Check this after matching against the section headers
5206 so we don't warn on debuginfo file (which have NOBITS .dynamic
5208 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5210 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5211 dynamic_addr
= dynamic_size
= 0;
5216 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5218 error (_("Unable to find program interpreter name\n"));
5222 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5224 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5225 error (_("Internal error: failed to create format string to display program interpreter\n"));
5227 program_interpreter
[0] = 0;
5228 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5229 error (_("Unable to read program interpreter name\n"));
5232 printf (_(" [Requesting program interpreter: %s]\n"),
5233 program_interpreter
);
5240 && filedata
->section_headers
!= NULL
5241 && filedata
->string_table
!= NULL
)
5243 printf (_("\n Section to Segment mapping:\n"));
5244 printf (_(" Segment Sections...\n"));
5246 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5249 Elf_Internal_Shdr
* section
;
5251 segment
= filedata
->program_headers
+ i
;
5252 section
= filedata
->section_headers
+ 1;
5254 printf (" %2.2d ", i
);
5256 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5258 if (!ELF_TBSS_SPECIAL (section
, segment
)
5259 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5260 printf ("%s ", printable_section_name (filedata
, section
));
5271 /* Find the file offset corresponding to VMA by using the program headers. */
5274 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5276 Elf_Internal_Phdr
* seg
;
5278 if (! get_program_headers (filedata
))
5280 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5284 for (seg
= filedata
->program_headers
;
5285 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5288 if (seg
->p_type
!= PT_LOAD
)
5291 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5292 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5293 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5296 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5297 (unsigned long) vma
);
5302 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5303 If PROBE is true, this is just a probe and we do not generate any error
5304 messages if the load fails. */
5307 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5309 Elf32_External_Shdr
* shdrs
;
5310 Elf_Internal_Shdr
* internal
;
5312 unsigned int size
= filedata
->file_header
.e_shentsize
;
5313 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5315 /* PR binutils/17531: Cope with unexpected section header sizes. */
5316 if (size
== 0 || num
== 0)
5318 if (size
< sizeof * shdrs
)
5321 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5324 if (!probe
&& size
> sizeof * shdrs
)
5325 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5327 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5329 probe
? NULL
: _("section headers"));
5333 free (filedata
->section_headers
);
5334 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5335 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5336 if (filedata
->section_headers
== NULL
)
5339 error (_("Out of memory reading %u section headers\n"), num
);
5344 for (i
= 0, internal
= filedata
->section_headers
;
5348 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5349 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5350 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5351 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5352 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5353 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5354 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5355 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5356 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5357 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5358 if (!probe
&& internal
->sh_link
> num
)
5359 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5360 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5361 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5368 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5371 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5373 Elf64_External_Shdr
* shdrs
;
5374 Elf_Internal_Shdr
* internal
;
5376 unsigned int size
= filedata
->file_header
.e_shentsize
;
5377 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5379 /* PR binutils/17531: Cope with unexpected section header sizes. */
5380 if (size
== 0 || num
== 0)
5383 if (size
< sizeof * shdrs
)
5386 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5390 if (! probe
&& size
> sizeof * shdrs
)
5391 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5393 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5394 filedata
->file_header
.e_shoff
,
5396 probe
? NULL
: _("section headers"));
5400 free (filedata
->section_headers
);
5401 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5402 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5403 if (filedata
->section_headers
== NULL
)
5406 error (_("Out of memory reading %u section headers\n"), num
);
5411 for (i
= 0, internal
= filedata
->section_headers
;
5415 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5416 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5417 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5418 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5419 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5420 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5421 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5422 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5423 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5424 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5425 if (!probe
&& internal
->sh_link
> num
)
5426 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5427 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5428 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5435 static Elf_Internal_Sym
*
5436 get_32bit_elf_symbols (Filedata
* filedata
,
5437 Elf_Internal_Shdr
* section
,
5438 unsigned long * num_syms_return
)
5440 unsigned long number
= 0;
5441 Elf32_External_Sym
* esyms
= NULL
;
5442 Elf_External_Sym_Shndx
* shndx
= NULL
;
5443 Elf_Internal_Sym
* isyms
= NULL
;
5444 Elf_Internal_Sym
* psym
;
5446 elf_section_list
* entry
;
5448 if (section
->sh_size
== 0)
5450 if (num_syms_return
!= NULL
)
5451 * num_syms_return
= 0;
5455 /* Run some sanity checks first. */
5456 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5458 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5459 printable_section_name (filedata
, section
),
5460 (unsigned long) section
->sh_entsize
);
5464 if (section
->sh_size
> filedata
->file_size
)
5466 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5467 printable_section_name (filedata
, section
),
5468 (unsigned long) section
->sh_size
);
5472 number
= section
->sh_size
/ section
->sh_entsize
;
5474 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5476 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5477 (unsigned long) section
->sh_size
,
5478 printable_section_name (filedata
, section
),
5479 (unsigned long) section
->sh_entsize
);
5483 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5484 section
->sh_size
, _("symbols"));
5489 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5491 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5496 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5500 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5501 entry
->hdr
->sh_offset
,
5502 1, entry
->hdr
->sh_size
,
5503 _("symbol table section indices"));
5507 /* PR17531: file: heap-buffer-overflow */
5508 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5510 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5511 printable_section_name (filedata
, entry
->hdr
),
5512 (unsigned long) entry
->hdr
->sh_size
,
5513 (unsigned long) section
->sh_size
);
5518 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5522 error (_("Out of memory reading %lu symbols\n"),
5523 (unsigned long) number
);
5527 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5529 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5530 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5531 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5532 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5533 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5535 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5536 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5537 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5538 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5539 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5546 if (num_syms_return
!= NULL
)
5547 * num_syms_return
= isyms
== NULL
? 0 : number
;
5552 static Elf_Internal_Sym
*
5553 get_64bit_elf_symbols (Filedata
* filedata
,
5554 Elf_Internal_Shdr
* section
,
5555 unsigned long * num_syms_return
)
5557 unsigned long number
= 0;
5558 Elf64_External_Sym
* esyms
= NULL
;
5559 Elf_External_Sym_Shndx
* shndx
= NULL
;
5560 Elf_Internal_Sym
* isyms
= NULL
;
5561 Elf_Internal_Sym
* psym
;
5563 elf_section_list
* entry
;
5565 if (section
->sh_size
== 0)
5567 if (num_syms_return
!= NULL
)
5568 * num_syms_return
= 0;
5572 /* Run some sanity checks first. */
5573 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5575 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5576 printable_section_name (filedata
, section
),
5577 (unsigned long) section
->sh_entsize
);
5581 if (section
->sh_size
> filedata
->file_size
)
5583 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5584 printable_section_name (filedata
, section
),
5585 (unsigned long) section
->sh_size
);
5589 number
= section
->sh_size
/ section
->sh_entsize
;
5591 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5593 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5594 (unsigned long) section
->sh_size
,
5595 printable_section_name (filedata
, section
),
5596 (unsigned long) section
->sh_entsize
);
5600 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5601 section
->sh_size
, _("symbols"));
5606 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5608 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5613 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5617 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5618 entry
->hdr
->sh_offset
,
5619 1, entry
->hdr
->sh_size
,
5620 _("symbol table section indices"));
5624 /* PR17531: file: heap-buffer-overflow */
5625 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5627 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5628 printable_section_name (filedata
, entry
->hdr
),
5629 (unsigned long) entry
->hdr
->sh_size
,
5630 (unsigned long) section
->sh_size
);
5635 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5639 error (_("Out of memory reading %lu symbols\n"),
5640 (unsigned long) number
);
5644 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5646 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5647 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5648 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5649 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5651 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5653 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5654 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5655 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5657 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5658 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5665 if (num_syms_return
!= NULL
)
5666 * num_syms_return
= isyms
== NULL
? 0 : number
;
5672 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5674 static char buff
[1024];
5676 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5678 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5679 bfd_vma os_flags
= 0;
5680 bfd_vma proc_flags
= 0;
5681 bfd_vma unknown_flags
= 0;
5689 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5690 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5691 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5692 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5693 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5694 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5695 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5696 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5697 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5698 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5699 /* IA-64 specific. */
5700 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5701 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5702 /* IA-64 OpenVMS specific. */
5703 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5704 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5705 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5706 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5707 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5708 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5710 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5711 /* SPARC specific. */
5712 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5713 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5715 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5716 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5717 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5719 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5721 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5724 if (do_section_details
)
5726 sprintf (buff
, "[%*.*lx]: ",
5727 field_size
, field_size
, (unsigned long) sh_flags
);
5728 p
+= field_size
+ 4;
5735 flag
= sh_flags
& - sh_flags
;
5738 if (do_section_details
)
5742 case SHF_WRITE
: sindex
= 0; break;
5743 case SHF_ALLOC
: sindex
= 1; break;
5744 case SHF_EXECINSTR
: sindex
= 2; break;
5745 case SHF_MERGE
: sindex
= 3; break;
5746 case SHF_STRINGS
: sindex
= 4; break;
5747 case SHF_INFO_LINK
: sindex
= 5; break;
5748 case SHF_LINK_ORDER
: sindex
= 6; break;
5749 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5750 case SHF_GROUP
: sindex
= 8; break;
5751 case SHF_TLS
: sindex
= 9; break;
5752 case SHF_EXCLUDE
: sindex
= 18; break;
5753 case SHF_COMPRESSED
: sindex
= 20; break;
5754 case SHF_GNU_MBIND
: sindex
= 24; break;
5758 switch (filedata
->file_header
.e_machine
)
5761 if (flag
== SHF_IA_64_SHORT
)
5763 else if (flag
== SHF_IA_64_NORECOV
)
5766 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5769 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5770 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5771 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5772 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5773 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5774 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5785 case EM_OLD_SPARCV9
:
5786 case EM_SPARC32PLUS
:
5789 if (flag
== SHF_ORDERED
)
5796 case SHF_ENTRYSECT
: sindex
= 21; break;
5797 case SHF_ARM_PURECODE
: sindex
= 22; break;
5798 case SHF_COMDEF
: sindex
= 23; break;
5803 if (flag
== SHF_PPC_VLE
)
5814 if (p
!= buff
+ field_size
+ 4)
5816 if (size
< (10 + 2))
5818 warn (_("Internal error: not enough buffer room for section flag info"));
5819 return _("<unknown>");
5826 size
-= flags
[sindex
].len
;
5827 p
= stpcpy (p
, flags
[sindex
].str
);
5829 else if (flag
& SHF_MASKOS
)
5831 else if (flag
& SHF_MASKPROC
)
5834 unknown_flags
|= flag
;
5840 case SHF_WRITE
: *p
= 'W'; break;
5841 case SHF_ALLOC
: *p
= 'A'; break;
5842 case SHF_EXECINSTR
: *p
= 'X'; break;
5843 case SHF_MERGE
: *p
= 'M'; break;
5844 case SHF_STRINGS
: *p
= 'S'; break;
5845 case SHF_INFO_LINK
: *p
= 'I'; break;
5846 case SHF_LINK_ORDER
: *p
= 'L'; break;
5847 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5848 case SHF_GROUP
: *p
= 'G'; break;
5849 case SHF_TLS
: *p
= 'T'; break;
5850 case SHF_EXCLUDE
: *p
= 'E'; break;
5851 case SHF_COMPRESSED
: *p
= 'C'; break;
5852 case SHF_GNU_MBIND
: *p
= 'D'; break;
5855 if ((filedata
->file_header
.e_machine
== EM_X86_64
5856 || filedata
->file_header
.e_machine
== EM_L1OM
5857 || filedata
->file_header
.e_machine
== EM_K1OM
)
5858 && flag
== SHF_X86_64_LARGE
)
5860 else if (filedata
->file_header
.e_machine
== EM_ARM
5861 && flag
== SHF_ARM_PURECODE
)
5863 else if (filedata
->file_header
.e_machine
== EM_PPC
5864 && flag
== SHF_PPC_VLE
)
5866 else if (flag
& SHF_MASKOS
)
5869 sh_flags
&= ~ SHF_MASKOS
;
5871 else if (flag
& SHF_MASKPROC
)
5874 sh_flags
&= ~ SHF_MASKPROC
;
5884 if (do_section_details
)
5888 size
-= 5 + field_size
;
5889 if (p
!= buff
+ field_size
+ 4)
5893 warn (_("Internal error: not enough buffer room for section flag info"));
5894 return _("<unknown>");
5900 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5901 (unsigned long) os_flags
);
5902 p
+= 5 + field_size
;
5906 size
-= 7 + field_size
;
5907 if (p
!= buff
+ field_size
+ 4)
5911 warn (_("Internal error: not enough buffer room for section flag info"));
5912 return _("<unknown>");
5918 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5919 (unsigned long) proc_flags
);
5920 p
+= 7 + field_size
;
5924 size
-= 10 + field_size
;
5925 if (p
!= buff
+ field_size
+ 4)
5929 warn (_("Internal error: not enough buffer room for section flag info"));
5930 return _("<unknown>");
5936 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5937 (unsigned long) unknown_flags
);
5938 p
+= 10 + field_size
;
5947 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5951 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5953 if (size
< sizeof (* echdr
))
5955 error (_("Compressed section is too small even for a compression header\n"));
5959 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5960 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5961 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5962 return sizeof (*echdr
);
5966 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5968 if (size
< sizeof (* echdr
))
5970 error (_("Compressed section is too small even for a compression header\n"));
5974 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5975 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5976 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5977 return sizeof (*echdr
);
5982 process_section_headers (Filedata
* filedata
)
5984 Elf_Internal_Shdr
* section
;
5987 filedata
->section_headers
= NULL
;
5989 if (filedata
->file_header
.e_shnum
== 0)
5991 /* PR binutils/12467. */
5992 if (filedata
->file_header
.e_shoff
!= 0)
5994 warn (_("possibly corrupt ELF file header - it has a non-zero"
5995 " section header offset, but no section headers\n"));
5998 else if (do_sections
)
5999 printf (_("\nThere are no sections in this file.\n"));
6004 if (do_sections
&& !do_header
)
6005 printf (ngettext ("There is %d section header, "
6006 "starting at offset 0x%lx:\n",
6007 "There are %d section headers, "
6008 "starting at offset 0x%lx:\n",
6009 filedata
->file_header
.e_shnum
),
6010 filedata
->file_header
.e_shnum
,
6011 (unsigned long) filedata
->file_header
.e_shoff
);
6015 if (! get_32bit_section_headers (filedata
, FALSE
))
6020 if (! get_64bit_section_headers (filedata
, FALSE
))
6024 /* Read in the string table, so that we have names to display. */
6025 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6026 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6028 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6030 if (section
->sh_size
!= 0)
6032 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6033 1, section
->sh_size
,
6036 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6040 /* Scan the sections for the dynamic symbol table
6041 and dynamic string table and debug sections. */
6042 dynamic_symbols
= NULL
;
6043 dynamic_strings
= NULL
;
6044 dynamic_syminfo
= NULL
;
6045 symtab_shndx_list
= NULL
;
6047 eh_addr_size
= is_32bit_elf
? 4 : 8;
6048 switch (filedata
->file_header
.e_machine
)
6051 case EM_MIPS_RS3_LE
:
6052 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6053 FDE addresses. However, the ABI also has a semi-official ILP32
6054 variant for which the normal FDE address size rules apply.
6056 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6057 section, where XX is the size of longs in bits. Unfortunately,
6058 earlier compilers provided no way of distinguishing ILP32 objects
6059 from LP64 objects, so if there's any doubt, we should assume that
6060 the official LP64 form is being used. */
6061 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6062 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6068 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6070 case E_H8_MACH_H8300
:
6071 case E_H8_MACH_H8300HN
:
6072 case E_H8_MACH_H8300SN
:
6073 case E_H8_MACH_H8300SXN
:
6076 case E_H8_MACH_H8300H
:
6077 case E_H8_MACH_H8300S
:
6078 case E_H8_MACH_H8300SX
:
6086 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6088 case EF_M32C_CPU_M16C
:
6095 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6098 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6099 if (section->sh_entsize != expected_entsize) \
6102 sprintf_vma (buf, section->sh_entsize); \
6103 /* Note: coded this way so that there is a single string for \
6105 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6106 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6107 (unsigned) expected_entsize); \
6108 section->sh_entsize = expected_entsize; \
6113 #define CHECK_ENTSIZE(section, i, type) \
6114 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6115 sizeof (Elf64_External_##type))
6117 for (i
= 0, section
= filedata
->section_headers
;
6118 i
< filedata
->file_header
.e_shnum
;
6121 char * name
= SECTION_NAME (section
);
6123 if (section
->sh_type
== SHT_DYNSYM
)
6125 if (dynamic_symbols
!= NULL
)
6127 error (_("File contains multiple dynamic symbol tables\n"));
6131 CHECK_ENTSIZE (section
, i
, Sym
);
6132 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6134 else if (section
->sh_type
== SHT_STRTAB
6135 && streq (name
, ".dynstr"))
6137 if (dynamic_strings
!= NULL
)
6139 error (_("File contains multiple dynamic string tables\n"));
6143 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6144 1, section
->sh_size
,
6145 _("dynamic strings"));
6146 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6148 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6150 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6152 entry
->hdr
= section
;
6153 entry
->next
= symtab_shndx_list
;
6154 symtab_shndx_list
= entry
;
6156 else if (section
->sh_type
== SHT_SYMTAB
)
6157 CHECK_ENTSIZE (section
, i
, Sym
);
6158 else if (section
->sh_type
== SHT_GROUP
)
6159 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6160 else if (section
->sh_type
== SHT_REL
)
6161 CHECK_ENTSIZE (section
, i
, Rel
);
6162 else if (section
->sh_type
== SHT_RELA
)
6163 CHECK_ENTSIZE (section
, i
, Rela
);
6164 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6165 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6166 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6167 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6168 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6169 && (const_strneq (name
, ".debug_")
6170 || const_strneq (name
, ".zdebug_")))
6173 name
+= sizeof (".zdebug_") - 1;
6175 name
+= sizeof (".debug_") - 1;
6178 || (do_debug_info
&& const_strneq (name
, "info"))
6179 || (do_debug_info
&& const_strneq (name
, "types"))
6180 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6181 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6182 || (do_debug_lines
&& const_strneq (name
, "line."))
6183 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6184 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6185 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6186 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6187 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6188 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6189 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6190 || (do_debug_frames
&& const_strneq (name
, "frame"))
6191 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6192 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6193 || (do_debug_str
&& const_strneq (name
, "str"))
6194 || (do_debug_loc
&& const_strneq (name
, "loc"))
6195 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6196 || (do_debug_addr
&& const_strneq (name
, "addr"))
6197 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6198 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6200 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6202 /* Linkonce section to be combined with .debug_info at link time. */
6203 else if ((do_debugging
|| do_debug_info
)
6204 && const_strneq (name
, ".gnu.linkonce.wi."))
6205 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6206 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6207 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6208 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6209 || streq (name
, ".debug_names")))
6210 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6211 /* Trace sections for Itanium VMS. */
6212 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6213 || do_trace_aranges
)
6214 && const_strneq (name
, ".trace_"))
6216 name
+= sizeof (".trace_") - 1;
6219 || (do_trace_info
&& streq (name
, "info"))
6220 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6221 || (do_trace_aranges
&& streq (name
, "aranges"))
6223 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6225 else if ((do_debugging
|| do_debug_links
)
6226 && (const_strneq (name
, ".gnu_debuglink")
6227 || const_strneq (name
, ".gnu_debugaltlink")))
6228 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6234 if (filedata
->file_header
.e_shnum
> 1)
6235 printf (_("\nSection Headers:\n"));
6237 printf (_("\nSection Header:\n"));
6241 if (do_section_details
)
6243 printf (_(" [Nr] Name\n"));
6244 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6248 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6252 if (do_section_details
)
6254 printf (_(" [Nr] Name\n"));
6255 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6259 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6263 if (do_section_details
)
6265 printf (_(" [Nr] Name\n"));
6266 printf (_(" Type Address Offset Link\n"));
6267 printf (_(" Size EntSize Info Align\n"));
6271 printf (_(" [Nr] Name Type Address Offset\n"));
6272 printf (_(" Size EntSize Flags Link Info Align\n"));
6276 if (do_section_details
)
6277 printf (_(" Flags\n"));
6279 for (i
= 0, section
= filedata
->section_headers
;
6280 i
< filedata
->file_header
.e_shnum
;
6283 /* Run some sanity checks on the section header. */
6285 /* Check the sh_link field. */
6286 switch (section
->sh_type
)
6288 case SHT_SYMTAB_SHNDX
:
6292 case SHT_GNU_versym
:
6295 if (section
->sh_link
< 1
6296 || section
->sh_link
>= filedata
->file_header
.e_shnum
6297 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6298 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6299 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6300 i
, section
->sh_link
);
6306 case SHT_GNU_verneed
:
6307 case SHT_GNU_verdef
:
6308 case SHT_GNU_LIBLIST
:
6309 if (section
->sh_link
< 1
6310 || section
->sh_link
>= filedata
->file_header
.e_shnum
6311 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6312 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6313 i
, section
->sh_link
);
6316 case SHT_INIT_ARRAY
:
6317 case SHT_FINI_ARRAY
:
6318 case SHT_PREINIT_ARRAY
:
6319 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6320 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6321 i
, section
->sh_link
);
6325 /* FIXME: Add support for target specific section types. */
6326 #if 0 /* Currently we do not check other section types as there are too
6327 many special cases. Stab sections for example have a type
6328 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6330 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6331 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6332 i
, section
->sh_link
);
6337 /* Check the sh_info field. */
6338 switch (section
->sh_type
)
6342 if (section
->sh_info
< 1
6343 || section
->sh_info
>= filedata
->file_header
.e_shnum
6344 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6345 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6346 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6347 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6348 /* FIXME: Are other section types valid ? */
6349 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6351 if (section
->sh_info
== 0
6352 && (filedata
->file_header
.e_type
== ET_EXEC
6353 || filedata
->file_header
.e_type
== ET_DYN
6354 /* These next two tests may be redundant, but
6355 they have been left in for paranoia's sake. */
6356 || streq (SECTION_NAME (section
), ".rel.dyn")
6357 || streq (SECTION_NAME (section
), ".rela.dyn")))
6358 /* Dynamic relocations apply to segments, not sections, so
6359 they do not need an sh_info value. */
6362 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6363 i
, section
->sh_info
);
6369 case SHT_SYMTAB_SHNDX
:
6370 case SHT_INIT_ARRAY
:
6371 case SHT_FINI_ARRAY
:
6372 case SHT_PREINIT_ARRAY
:
6373 if (section
->sh_info
!= 0)
6374 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6375 i
, section
->sh_info
);
6381 /* A symbol index - we assume that it is valid. */
6385 /* FIXME: Add support for target specific section types. */
6386 if (section
->sh_type
== SHT_NOBITS
)
6387 /* NOBITS section headers with non-zero sh_info fields can be
6388 created when a binary is stripped of everything but its debug
6389 information. The stripped sections have their headers
6390 preserved but their types set to SHT_NOBITS. So do not check
6391 this type of section. */
6393 else if (section
->sh_flags
& SHF_INFO_LINK
)
6395 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6396 warn (_("[%2u]: Expected link to another section in info field"), i
);
6398 else if (section
->sh_type
< SHT_LOOS
6399 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6400 && section
->sh_info
!= 0)
6401 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6402 i
, section
->sh_info
);
6406 /* Check the sh_size field. */
6407 if (section
->sh_size
> filedata
->file_size
6408 && section
->sh_type
!= SHT_NOBITS
6409 && section
->sh_type
!= SHT_NULL
6410 && section
->sh_type
< SHT_LOOS
)
6411 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6413 printf (" [%2u] ", i
);
6414 if (do_section_details
)
6415 printf ("%s\n ", printable_section_name (filedata
, section
));
6417 print_symbol (-17, SECTION_NAME (section
));
6419 printf (do_wide
? " %-15s " : " %-15.15s ",
6420 get_section_type_name (filedata
, section
->sh_type
));
6424 const char * link_too_big
= NULL
;
6426 print_vma (section
->sh_addr
, LONG_HEX
);
6428 printf ( " %6.6lx %6.6lx %2.2lx",
6429 (unsigned long) section
->sh_offset
,
6430 (unsigned long) section
->sh_size
,
6431 (unsigned long) section
->sh_entsize
);
6433 if (do_section_details
)
6434 fputs (" ", stdout
);
6436 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6438 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6441 /* The sh_link value is out of range. Normally this indicates
6442 an error but it can have special values in Solaris binaries. */
6443 switch (filedata
->file_header
.e_machine
)
6450 case EM_OLD_SPARCV9
:
6451 case EM_SPARC32PLUS
:
6454 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6455 link_too_big
= "BEFORE";
6456 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6457 link_too_big
= "AFTER";
6464 if (do_section_details
)
6466 if (link_too_big
!= NULL
&& * link_too_big
)
6467 printf ("<%s> ", link_too_big
);
6469 printf ("%2u ", section
->sh_link
);
6470 printf ("%3u %2lu\n", section
->sh_info
,
6471 (unsigned long) section
->sh_addralign
);
6474 printf ("%2u %3u %2lu\n",
6477 (unsigned long) section
->sh_addralign
);
6479 if (link_too_big
&& ! * link_too_big
)
6480 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6481 i
, section
->sh_link
);
6485 print_vma (section
->sh_addr
, LONG_HEX
);
6487 if ((long) section
->sh_offset
== section
->sh_offset
)
6488 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6492 print_vma (section
->sh_offset
, LONG_HEX
);
6495 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6496 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6500 print_vma (section
->sh_size
, LONG_HEX
);
6503 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6504 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6508 print_vma (section
->sh_entsize
, LONG_HEX
);
6511 if (do_section_details
)
6512 fputs (" ", stdout
);
6514 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6516 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6518 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6519 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6522 print_vma (section
->sh_addralign
, DEC
);
6526 else if (do_section_details
)
6529 print_vma (section
->sh_addr
, LONG_HEX
);
6530 if ((long) section
->sh_offset
== section
->sh_offset
)
6531 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6535 print_vma (section
->sh_offset
, LONG_HEX
);
6537 printf (" %u\n ", section
->sh_link
);
6538 print_vma (section
->sh_size
, LONG_HEX
);
6540 print_vma (section
->sh_entsize
, LONG_HEX
);
6542 printf (" %-16u %lu\n",
6544 (unsigned long) section
->sh_addralign
);
6549 print_vma (section
->sh_addr
, LONG_HEX
);
6550 if ((long) section
->sh_offset
== section
->sh_offset
)
6551 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6555 print_vma (section
->sh_offset
, LONG_HEX
);
6558 print_vma (section
->sh_size
, LONG_HEX
);
6560 print_vma (section
->sh_entsize
, LONG_HEX
);
6562 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6564 printf (" %2u %3u %lu\n",
6567 (unsigned long) section
->sh_addralign
);
6570 if (do_section_details
)
6572 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6573 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6575 /* Minimum section size is 12 bytes for 32-bit compression
6576 header + 12 bytes for compressed data header. */
6577 unsigned char buf
[24];
6579 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6580 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6581 sizeof (buf
), _("compression header")))
6583 Elf_Internal_Chdr chdr
;
6585 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6587 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6590 printf (_(" [<unknown>: 0x%x], "),
6592 print_vma (chdr
.ch_size
, LONG_HEX
);
6593 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6599 if (!do_section_details
)
6601 /* The ordering of the letters shown here matches the ordering of the
6602 corresponding SHF_xxx values, and hence the order in which these
6603 letters will be displayed to the user. */
6604 printf (_("Key to Flags:\n\
6605 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6606 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6607 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6608 if (filedata
->file_header
.e_machine
== EM_X86_64
6609 || filedata
->file_header
.e_machine
== EM_L1OM
6610 || filedata
->file_header
.e_machine
== EM_K1OM
)
6611 printf (_("l (large), "));
6612 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6613 printf (_("y (purecode), "));
6614 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6615 printf (_("v (VLE), "));
6616 printf ("p (processor specific)\n");
6623 get_group_flags (unsigned int flags
)
6625 static char buff
[128];
6629 else if (flags
== GRP_COMDAT
)
6632 snprintf (buff
, 14, _("[0x%x: "), flags
);
6634 flags
&= ~ GRP_COMDAT
;
6635 if (flags
& GRP_MASKOS
)
6637 strcat (buff
, "<OS specific>");
6638 flags
&= ~ GRP_MASKOS
;
6641 if (flags
& GRP_MASKPROC
)
6643 strcat (buff
, "<PROC specific>");
6644 flags
&= ~ GRP_MASKPROC
;
6648 strcat (buff
, "<unknown>");
6655 process_section_groups (Filedata
* filedata
)
6657 Elf_Internal_Shdr
* section
;
6659 struct group
* group
;
6660 Elf_Internal_Shdr
* symtab_sec
;
6661 Elf_Internal_Shdr
* strtab_sec
;
6662 Elf_Internal_Sym
* symtab
;
6663 unsigned long num_syms
;
6667 /* Don't process section groups unless needed. */
6668 if (!do_unwind
&& !do_section_groups
)
6671 if (filedata
->file_header
.e_shnum
== 0)
6673 if (do_section_groups
)
6674 printf (_("\nThere are no sections to group in this file.\n"));
6679 if (filedata
->section_headers
== NULL
)
6681 error (_("Section headers are not available!\n"));
6682 /* PR 13622: This can happen with a corrupt ELF header. */
6686 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6687 sizeof (struct group
*));
6689 if (section_headers_groups
== NULL
)
6691 error (_("Out of memory reading %u section group headers\n"),
6692 filedata
->file_header
.e_shnum
);
6696 /* Scan the sections for the group section. */
6698 for (i
= 0, section
= filedata
->section_headers
;
6699 i
< filedata
->file_header
.e_shnum
;
6701 if (section
->sh_type
== SHT_GROUP
)
6704 if (group_count
== 0)
6706 if (do_section_groups
)
6707 printf (_("\nThere are no section groups in this file.\n"));
6712 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6714 if (section_groups
== NULL
)
6716 error (_("Out of memory reading %lu groups\n"),
6717 (unsigned long) group_count
);
6727 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6728 i
< filedata
->file_header
.e_shnum
;
6731 if (section
->sh_type
== SHT_GROUP
)
6733 const char * name
= printable_section_name (filedata
, section
);
6734 const char * group_name
;
6735 unsigned char * start
;
6736 unsigned char * indices
;
6737 unsigned int entry
, j
, size
;
6738 Elf_Internal_Shdr
* sec
;
6739 Elf_Internal_Sym
* sym
;
6741 /* Get the symbol table. */
6742 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6743 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6746 error (_("Bad sh_link in group section `%s'\n"), name
);
6750 if (symtab_sec
!= sec
)
6755 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6760 error (_("Corrupt header in group section `%s'\n"), name
);
6764 if (section
->sh_info
>= num_syms
)
6766 error (_("Bad sh_info in group section `%s'\n"), name
);
6770 sym
= symtab
+ section
->sh_info
;
6772 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6774 if (sym
->st_shndx
== 0
6775 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6777 error (_("Bad sh_info in group section `%s'\n"), name
);
6781 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6790 /* Get the string table. */
6791 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6800 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6806 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6807 1, strtab_sec
->sh_size
,
6809 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6811 group_name
= sym
->st_name
< strtab_size
6812 ? strtab
+ sym
->st_name
: _("<corrupt>");
6815 /* PR 17531: file: loop. */
6816 if (section
->sh_entsize
> section
->sh_size
)
6818 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6819 printable_section_name (filedata
, section
),
6820 (unsigned long) section
->sh_entsize
,
6821 (unsigned long) section
->sh_size
);
6825 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6826 1, section
->sh_size
,
6832 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6833 entry
= byte_get (indices
, 4);
6836 if (do_section_groups
)
6838 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6839 get_group_flags (entry
), i
, name
, group_name
, size
);
6841 printf (_(" [Index] Name\n"));
6844 group
->group_index
= i
;
6846 for (j
= 0; j
< size
; j
++)
6848 struct group_list
* g
;
6850 entry
= byte_get (indices
, 4);
6853 if (entry
>= filedata
->file_header
.e_shnum
)
6855 static unsigned num_group_errors
= 0;
6857 if (num_group_errors
++ < 10)
6859 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6860 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6861 if (num_group_errors
== 10)
6862 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6867 if (section_headers_groups
[entry
] != NULL
)
6871 static unsigned num_errs
= 0;
6873 if (num_errs
++ < 10)
6875 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6877 section_headers_groups
[entry
]->group_index
);
6879 warn (_("Further error messages about already contained group sections suppressed\n"));
6885 /* Intel C/C++ compiler may put section 0 in a
6886 section group. We just warn it the first time
6887 and ignore it afterwards. */
6888 static bfd_boolean warned
= FALSE
;
6891 error (_("section 0 in group section [%5u]\n"),
6892 section_headers_groups
[entry
]->group_index
);
6898 section_headers_groups
[entry
] = group
;
6900 if (do_section_groups
)
6902 sec
= filedata
->section_headers
+ entry
;
6903 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6906 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6907 g
->section_index
= entry
;
6908 g
->next
= group
->root
;
6926 /* Data used to display dynamic fixups. */
6928 struct ia64_vms_dynfixup
6930 bfd_vma needed_ident
; /* Library ident number. */
6931 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6932 bfd_vma fixup_needed
; /* Index of the library. */
6933 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6934 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6937 /* Data used to display dynamic relocations. */
6939 struct ia64_vms_dynimgrela
6941 bfd_vma img_rela_cnt
; /* Number of relocations. */
6942 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6945 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6949 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6950 struct ia64_vms_dynfixup
* fixup
,
6951 const char * strtab
,
6952 unsigned int strtab_sz
)
6954 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6956 const char * lib_name
;
6958 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6959 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6960 _("dynamic section image fixups"));
6964 if (fixup
->needed
< strtab_sz
)
6965 lib_name
= strtab
+ fixup
->needed
;
6968 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6969 (unsigned long) fixup
->needed
);
6972 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6973 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6975 (_("Seg Offset Type SymVec DataType\n"));
6977 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6982 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6983 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6984 type
= BYTE_GET (imfs
[i
].type
);
6985 rtype
= elf_ia64_reloc_type (type
);
6987 printf (" 0x%08x ", type
);
6989 printf (" %-32s ", rtype
);
6990 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6991 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6998 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7001 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7003 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7006 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7007 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7008 _("dynamic section image relocations"));
7012 printf (_("\nImage relocs\n"));
7014 (_("Seg Offset Type Addend Seg Sym Off\n"));
7016 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7021 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7022 printf ("%08" BFD_VMA_FMT
"x ",
7023 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7024 type
= BYTE_GET (imrs
[i
].type
);
7025 rtype
= elf_ia64_reloc_type (type
);
7027 printf ("0x%08x ", type
);
7029 printf ("%-31s ", rtype
);
7030 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7031 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7032 printf ("%08" BFD_VMA_FMT
"x\n",
7033 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7040 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7043 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7045 struct ia64_vms_dynfixup fixup
;
7046 struct ia64_vms_dynimgrela imgrela
;
7047 Elf_Internal_Dyn
*entry
;
7048 bfd_vma strtab_off
= 0;
7049 bfd_vma strtab_sz
= 0;
7050 char *strtab
= NULL
;
7051 bfd_boolean res
= TRUE
;
7053 memset (&fixup
, 0, sizeof (fixup
));
7054 memset (&imgrela
, 0, sizeof (imgrela
));
7056 /* Note: the order of the entries is specified by the OpenVMS specs. */
7057 for (entry
= dynamic_section
;
7058 entry
< dynamic_section
+ dynamic_nent
;
7061 switch (entry
->d_tag
)
7063 case DT_IA_64_VMS_STRTAB_OFFSET
:
7064 strtab_off
= entry
->d_un
.d_val
;
7067 strtab_sz
= entry
->d_un
.d_val
;
7069 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7070 1, strtab_sz
, _("dynamic string section"));
7073 case DT_IA_64_VMS_NEEDED_IDENT
:
7074 fixup
.needed_ident
= entry
->d_un
.d_val
;
7077 fixup
.needed
= entry
->d_un
.d_val
;
7079 case DT_IA_64_VMS_FIXUP_NEEDED
:
7080 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7082 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7083 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7085 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7086 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7087 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7090 case DT_IA_64_VMS_IMG_RELA_CNT
:
7091 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7093 case DT_IA_64_VMS_IMG_RELA_OFF
:
7094 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7095 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7117 dynamic_relocations
[] =
7119 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7120 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7121 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7124 /* Process the reloc section. */
7127 process_relocs (Filedata
* filedata
)
7129 unsigned long rel_size
;
7130 unsigned long rel_offset
;
7135 if (do_using_dynamic
)
7139 bfd_boolean has_dynamic_reloc
;
7142 has_dynamic_reloc
= FALSE
;
7144 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7146 is_rela
= dynamic_relocations
[i
].rela
;
7147 name
= dynamic_relocations
[i
].name
;
7148 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7149 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7152 has_dynamic_reloc
= TRUE
;
7154 if (is_rela
== UNKNOWN
)
7156 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7157 switch (dynamic_info
[DT_PLTREL
])
7171 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7172 name
, rel_offset
, rel_size
);
7174 dump_relocations (filedata
,
7175 offset_from_vma (filedata
, rel_offset
, rel_size
),
7177 dynamic_symbols
, num_dynamic_syms
,
7178 dynamic_strings
, dynamic_strings_length
,
7179 is_rela
, TRUE
/* is_dynamic */);
7183 if (is_ia64_vms (filedata
))
7184 if (process_ia64_vms_dynamic_relocs (filedata
))
7185 has_dynamic_reloc
= TRUE
;
7187 if (! has_dynamic_reloc
)
7188 printf (_("\nThere are no dynamic relocations in this file.\n"));
7192 Elf_Internal_Shdr
* section
;
7194 bfd_boolean found
= FALSE
;
7196 for (i
= 0, section
= filedata
->section_headers
;
7197 i
< filedata
->file_header
.e_shnum
;
7200 if ( section
->sh_type
!= SHT_RELA
7201 && section
->sh_type
!= SHT_REL
)
7204 rel_offset
= section
->sh_offset
;
7205 rel_size
= section
->sh_size
;
7209 Elf_Internal_Shdr
* strsec
;
7211 unsigned long num_rela
;
7213 printf (_("\nRelocation section "));
7215 if (filedata
->string_table
== NULL
)
7216 printf ("%d", section
->sh_name
);
7218 printf ("'%s'", printable_section_name (filedata
, section
));
7220 num_rela
= rel_size
/ section
->sh_entsize
;
7221 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7222 " at offset 0x%lx contains %lu entries:\n",
7224 rel_offset
, num_rela
);
7226 is_rela
= section
->sh_type
== SHT_RELA
;
7228 if (section
->sh_link
!= 0
7229 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7231 Elf_Internal_Shdr
* symsec
;
7232 Elf_Internal_Sym
* symtab
;
7233 unsigned long nsyms
;
7234 unsigned long strtablen
= 0;
7235 char * strtab
= NULL
;
7237 symsec
= filedata
->section_headers
+ section
->sh_link
;
7238 if (symsec
->sh_type
!= SHT_SYMTAB
7239 && symsec
->sh_type
!= SHT_DYNSYM
)
7242 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7247 if (symsec
->sh_link
!= 0
7248 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7250 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7252 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7255 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7258 dump_relocations (filedata
, rel_offset
, rel_size
,
7259 symtab
, nsyms
, strtab
, strtablen
,
7261 symsec
->sh_type
== SHT_DYNSYM
);
7267 dump_relocations (filedata
, rel_offset
, rel_size
,
7268 NULL
, 0, NULL
, 0, is_rela
,
7269 FALSE
/* is_dynamic */);
7277 /* Users sometimes forget the -D option, so try to be helpful. */
7278 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7280 if (dynamic_info
[dynamic_relocations
[i
].size
])
7282 printf (_("\nThere are no static relocations in this file."));
7283 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7288 if (i
== ARRAY_SIZE (dynamic_relocations
))
7289 printf (_("\nThere are no relocations in this file.\n"));
7296 /* An absolute address consists of a section and an offset. If the
7297 section is NULL, the offset itself is the address, otherwise, the
7298 address equals to LOAD_ADDRESS(section) + offset. */
7302 unsigned short section
;
7306 #define ABSADDR(a) \
7308 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7311 /* Find the nearest symbol at or below ADDR. Returns the symbol
7312 name, if found, and the offset from the symbol to ADDR. */
7315 find_symbol_for_address (Filedata
* filedata
,
7316 Elf_Internal_Sym
* symtab
,
7317 unsigned long nsyms
,
7318 const char * strtab
,
7319 unsigned long strtab_size
,
7320 struct absaddr addr
,
7321 const char ** symname
,
7324 bfd_vma dist
= 0x100000;
7325 Elf_Internal_Sym
* sym
;
7326 Elf_Internal_Sym
* beg
;
7327 Elf_Internal_Sym
* end
;
7328 Elf_Internal_Sym
* best
= NULL
;
7330 REMOVE_ARCH_BITS (addr
.offset
);
7332 end
= symtab
+ nsyms
;
7338 sym
= beg
+ (end
- beg
) / 2;
7340 value
= sym
->st_value
;
7341 REMOVE_ARCH_BITS (value
);
7343 if (sym
->st_name
!= 0
7344 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7345 && addr
.offset
>= value
7346 && addr
.offset
- value
< dist
)
7349 dist
= addr
.offset
- value
;
7354 if (addr
.offset
< value
)
7362 *symname
= (best
->st_name
>= strtab_size
7363 ? _("<corrupt>") : strtab
+ best
->st_name
);
7369 *offset
= addr
.offset
;
7372 static /* signed */ int
7373 symcmp (const void *p
, const void *q
)
7375 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7376 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7378 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7381 /* Process the unwind section. */
7383 #include "unwind-ia64.h"
7385 struct ia64_unw_table_entry
7387 struct absaddr start
;
7389 struct absaddr info
;
7392 struct ia64_unw_aux_info
7394 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7395 unsigned long table_len
; /* Length of unwind table. */
7396 unsigned char * info
; /* Unwind info. */
7397 unsigned long info_size
; /* Size of unwind info. */
7398 bfd_vma info_addr
; /* Starting address of unwind info. */
7399 bfd_vma seg_base
; /* Starting address of segment. */
7400 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7401 unsigned long nsyms
; /* Number of symbols. */
7402 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7403 unsigned long nfuns
; /* Number of entries in funtab. */
7404 char * strtab
; /* The string table. */
7405 unsigned long strtab_size
; /* Size of string table. */
7409 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7411 struct ia64_unw_table_entry
* tp
;
7412 unsigned long j
, nfuns
;
7414 bfd_boolean res
= TRUE
;
7416 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7417 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7418 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7419 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7421 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7423 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7427 const unsigned char * dp
;
7428 const unsigned char * head
;
7429 const unsigned char * end
;
7430 const char * procname
;
7432 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7433 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7435 fputs ("\n<", stdout
);
7439 fputs (procname
, stdout
);
7442 printf ("+%lx", (unsigned long) offset
);
7445 fputs (">: [", stdout
);
7446 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7447 fputc ('-', stdout
);
7448 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7449 printf ("], info at +0x%lx\n",
7450 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7452 /* PR 17531: file: 86232b32. */
7453 if (aux
->info
== NULL
)
7456 /* PR 17531: file: 0997b4d1. */
7457 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7459 warn (_("Invalid offset %lx in table entry %ld\n"),
7460 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7465 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7466 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7468 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7469 (unsigned) UNW_VER (stamp
),
7470 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7471 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7472 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7473 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7475 if (UNW_VER (stamp
) != 1)
7477 printf (_("\tUnknown version.\n"));
7482 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7483 /* PR 17531: file: 16ceda89. */
7484 if (end
> aux
->info
+ aux
->info_size
)
7485 end
= aux
->info
+ aux
->info_size
;
7486 for (dp
= head
+ 8; dp
< end
;)
7487 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7496 slurp_ia64_unwind_table (Filedata
* filedata
,
7497 struct ia64_unw_aux_info
* aux
,
7498 Elf_Internal_Shdr
* sec
)
7500 unsigned long size
, nrelas
, i
;
7501 Elf_Internal_Phdr
* seg
;
7502 struct ia64_unw_table_entry
* tep
;
7503 Elf_Internal_Shdr
* relsec
;
7504 Elf_Internal_Rela
* rela
;
7505 Elf_Internal_Rela
* rp
;
7506 unsigned char * table
;
7508 Elf_Internal_Sym
* sym
;
7509 const char * relname
;
7513 /* First, find the starting address of the segment that includes
7516 if (filedata
->file_header
.e_phnum
)
7518 if (! get_program_headers (filedata
))
7521 for (seg
= filedata
->program_headers
;
7522 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7525 if (seg
->p_type
!= PT_LOAD
)
7528 if (sec
->sh_addr
>= seg
->p_vaddr
7529 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7531 aux
->seg_base
= seg
->p_vaddr
;
7537 /* Second, build the unwind table from the contents of the unwind section: */
7538 size
= sec
->sh_size
;
7539 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7544 aux
->table_len
= size
/ (3 * eh_addr_size
);
7545 aux
->table
= (struct ia64_unw_table_entry
*)
7546 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7549 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7551 tep
->start
.section
= SHN_UNDEF
;
7552 tep
->end
.section
= SHN_UNDEF
;
7553 tep
->info
.section
= SHN_UNDEF
;
7554 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7555 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7556 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7557 tep
->start
.offset
+= aux
->seg_base
;
7558 tep
->end
.offset
+= aux
->seg_base
;
7559 tep
->info
.offset
+= aux
->seg_base
;
7563 /* Third, apply any relocations to the unwind table: */
7564 for (relsec
= filedata
->section_headers
;
7565 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7568 if (relsec
->sh_type
!= SHT_RELA
7569 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7570 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7573 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7582 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7584 relname
= elf_ia64_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7585 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7587 /* PR 17531: file: 9fa67536. */
7588 if (relname
== NULL
)
7590 warn (_("Skipping unknown relocation type: %u\n"),
7591 get_reloc_type (filedata
, rp
->r_info
));
7595 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7597 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7601 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7603 /* PR 17531: file: 5bc8d9bf. */
7604 if (i
>= aux
->table_len
)
7606 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7610 switch (rp
->r_offset
/ eh_addr_size
% 3)
7613 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7614 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7617 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7618 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7621 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7622 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7636 ia64_process_unwind (Filedata
* filedata
)
7638 Elf_Internal_Shdr
* sec
;
7639 Elf_Internal_Shdr
* unwsec
= NULL
;
7640 Elf_Internal_Shdr
* strsec
;
7641 unsigned long i
, unwcount
= 0, unwstart
= 0;
7642 struct ia64_unw_aux_info aux
;
7643 bfd_boolean res
= TRUE
;
7645 memset (& aux
, 0, sizeof (aux
));
7647 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7649 if (sec
->sh_type
== SHT_SYMTAB
7650 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7652 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7654 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7655 if (aux
.strtab
!= NULL
)
7657 error (_("Multiple auxillary string tables encountered\n"));
7661 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7664 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7666 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7671 printf (_("\nThere are no unwind sections in this file.\n"));
7673 while (unwcount
-- > 0)
7678 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7679 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7680 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7685 /* We have already counted the number of SHT_IA64_UNWIND
7686 sections so the loop above should never fail. */
7687 assert (unwsec
!= NULL
);
7690 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7692 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7694 /* We need to find which section group it is in. */
7695 struct group_list
* g
;
7697 if (section_headers_groups
== NULL
7698 || section_headers_groups
[i
] == NULL
)
7699 i
= filedata
->file_header
.e_shnum
;
7702 g
= section_headers_groups
[i
]->root
;
7704 for (; g
!= NULL
; g
= g
->next
)
7706 sec
= filedata
->section_headers
+ g
->section_index
;
7708 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7713 i
= filedata
->file_header
.e_shnum
;
7716 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7718 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7719 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7720 suffix
= SECTION_NAME (unwsec
) + len
;
7721 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7723 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7724 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7729 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7730 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7731 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7732 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7734 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7735 suffix
= SECTION_NAME (unwsec
) + len
;
7736 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7738 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7739 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7743 if (i
== filedata
->file_header
.e_shnum
)
7745 printf (_("\nCould not find unwind info section for "));
7747 if (filedata
->string_table
== NULL
)
7748 printf ("%d", unwsec
->sh_name
);
7750 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7754 aux
.info_addr
= sec
->sh_addr
;
7755 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7758 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7760 printf (_("\nUnwind section "));
7762 if (filedata
->string_table
== NULL
)
7763 printf ("%d", unwsec
->sh_name
);
7765 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7767 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7768 (unsigned long) unwsec
->sh_offset
,
7769 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7771 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7772 && aux
.table_len
> 0)
7773 dump_ia64_unwind (filedata
, & aux
);
7776 free ((char *) aux
.table
);
7778 free ((char *) aux
.info
);
7787 free ((char *) aux
.strtab
);
7792 struct hppa_unw_table_entry
7794 struct absaddr start
;
7796 unsigned int Cannot_unwind
:1; /* 0 */
7797 unsigned int Millicode
:1; /* 1 */
7798 unsigned int Millicode_save_sr0
:1; /* 2 */
7799 unsigned int Region_description
:2; /* 3..4 */
7800 unsigned int reserved1
:1; /* 5 */
7801 unsigned int Entry_SR
:1; /* 6 */
7802 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7803 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7804 unsigned int Args_stored
:1; /* 16 */
7805 unsigned int Variable_Frame
:1; /* 17 */
7806 unsigned int Separate_Package_Body
:1; /* 18 */
7807 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7808 unsigned int Stack_Overflow_Check
:1; /* 20 */
7809 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7810 unsigned int Ada_Region
:1; /* 22 */
7811 unsigned int cxx_info
:1; /* 23 */
7812 unsigned int cxx_try_catch
:1; /* 24 */
7813 unsigned int sched_entry_seq
:1; /* 25 */
7814 unsigned int reserved2
:1; /* 26 */
7815 unsigned int Save_SP
:1; /* 27 */
7816 unsigned int Save_RP
:1; /* 28 */
7817 unsigned int Save_MRP_in_frame
:1; /* 29 */
7818 unsigned int extn_ptr_defined
:1; /* 30 */
7819 unsigned int Cleanup_defined
:1; /* 31 */
7821 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7822 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7823 unsigned int Large_frame
:1; /* 2 */
7824 unsigned int Pseudo_SP_Set
:1; /* 3 */
7825 unsigned int reserved4
:1; /* 4 */
7826 unsigned int Total_frame_size
:27; /* 5..31 */
7829 struct hppa_unw_aux_info
7831 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7832 unsigned long table_len
; /* Length of unwind table. */
7833 bfd_vma seg_base
; /* Starting address of segment. */
7834 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7835 unsigned long nsyms
; /* Number of symbols. */
7836 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7837 unsigned long nfuns
; /* Number of entries in funtab. */
7838 char * strtab
; /* The string table. */
7839 unsigned long strtab_size
; /* Size of string table. */
7843 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7845 struct hppa_unw_table_entry
* tp
;
7846 unsigned long j
, nfuns
;
7847 bfd_boolean res
= TRUE
;
7849 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7850 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7851 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7852 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7854 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7856 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7859 const char * procname
;
7861 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7862 aux
->strtab_size
, tp
->start
, &procname
,
7865 fputs ("\n<", stdout
);
7869 fputs (procname
, stdout
);
7872 printf ("+%lx", (unsigned long) offset
);
7875 fputs (">: [", stdout
);
7876 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7877 fputc ('-', stdout
);
7878 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7881 #define PF(_m) if (tp->_m) printf (#_m " ");
7882 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7885 PF(Millicode_save_sr0
);
7886 /* PV(Region_description); */
7892 PF(Separate_Package_Body
);
7893 PF(Frame_Extension_Millicode
);
7894 PF(Stack_Overflow_Check
);
7895 PF(Two_Instruction_SP_Increment
);
7899 PF(sched_entry_seq
);
7902 PF(Save_MRP_in_frame
);
7903 PF(extn_ptr_defined
);
7904 PF(Cleanup_defined
);
7905 PF(MPE_XL_interrupt_marker
);
7906 PF(HP_UX_interrupt_marker
);
7909 PV(Total_frame_size
);
7922 slurp_hppa_unwind_table (Filedata
* filedata
,
7923 struct hppa_unw_aux_info
* aux
,
7924 Elf_Internal_Shdr
* sec
)
7926 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7927 Elf_Internal_Phdr
* seg
;
7928 struct hppa_unw_table_entry
* tep
;
7929 Elf_Internal_Shdr
* relsec
;
7930 Elf_Internal_Rela
* rela
;
7931 Elf_Internal_Rela
* rp
;
7932 unsigned char * table
;
7934 Elf_Internal_Sym
* sym
;
7935 const char * relname
;
7937 /* First, find the starting address of the segment that includes
7939 if (filedata
->file_header
.e_phnum
)
7941 if (! get_program_headers (filedata
))
7944 for (seg
= filedata
->program_headers
;
7945 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7948 if (seg
->p_type
!= PT_LOAD
)
7951 if (sec
->sh_addr
>= seg
->p_vaddr
7952 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7954 aux
->seg_base
= seg
->p_vaddr
;
7960 /* Second, build the unwind table from the contents of the unwind
7962 size
= sec
->sh_size
;
7963 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7969 nentries
= size
/ unw_ent_size
;
7970 size
= unw_ent_size
* nentries
;
7972 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7973 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7975 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7977 unsigned int tmp1
, tmp2
;
7979 tep
->start
.section
= SHN_UNDEF
;
7980 tep
->end
.section
= SHN_UNDEF
;
7982 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7983 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7984 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7985 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7987 tep
->start
.offset
+= aux
->seg_base
;
7988 tep
->end
.offset
+= aux
->seg_base
;
7990 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7991 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7992 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7993 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7994 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7995 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7996 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7997 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7998 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7999 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8000 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8001 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8002 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8003 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8004 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8005 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8006 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8007 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8008 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8009 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8010 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8011 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8012 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8013 tep
->Cleanup_defined
= tmp1
& 0x1;
8015 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8016 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8017 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8018 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8019 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8020 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8024 /* Third, apply any relocations to the unwind table. */
8025 for (relsec
= filedata
->section_headers
;
8026 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8029 if (relsec
->sh_type
!= SHT_RELA
8030 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8031 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8034 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8038 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8040 relname
= elf_hppa_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
8041 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
8043 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8044 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8046 warn (_("Skipping unexpected relocation type %s\n"), relname
);
8050 i
= rp
->r_offset
/ unw_ent_size
;
8052 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
8055 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8056 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8059 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8060 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8070 aux
->table_len
= nentries
;
8076 hppa_process_unwind (Filedata
* filedata
)
8078 struct hppa_unw_aux_info aux
;
8079 Elf_Internal_Shdr
* unwsec
= NULL
;
8080 Elf_Internal_Shdr
* strsec
;
8081 Elf_Internal_Shdr
* sec
;
8083 bfd_boolean res
= TRUE
;
8085 if (filedata
->string_table
== NULL
)
8088 memset (& aux
, 0, sizeof (aux
));
8090 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8092 if (sec
->sh_type
== SHT_SYMTAB
8093 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8095 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8097 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8098 if (aux
.strtab
!= NULL
)
8100 error (_("Multiple auxillary string tables encountered\n"));
8104 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8107 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8109 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8114 printf (_("\nThere are no unwind sections in this file.\n"));
8116 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8118 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8120 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8122 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8123 "contains %lu entry:\n",
8124 "\nUnwind section '%s' at offset 0x%lx "
8125 "contains %lu entries:\n",
8127 printable_section_name (filedata
, sec
),
8128 (unsigned long) sec
->sh_offset
,
8131 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8134 if (aux
.table_len
> 0)
8136 if (! dump_hppa_unwind (filedata
, &aux
))
8141 free ((char *) aux
.table
);
8149 free ((char *) aux
.strtab
);
8156 unsigned char * data
; /* The unwind data. */
8157 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8158 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8159 unsigned long nrelas
; /* The number of relocations. */
8160 unsigned int rel_type
; /* REL or RELA ? */
8161 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8164 struct arm_unw_aux_info
8166 Filedata
* filedata
; /* The file containing the unwind sections. */
8167 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8168 unsigned long nsyms
; /* Number of symbols. */
8169 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8170 unsigned long nfuns
; /* Number of these symbols. */
8171 char * strtab
; /* The file's string table. */
8172 unsigned long strtab_size
; /* Size of string table. */
8176 arm_print_vma_and_name (Filedata
* filedata
,
8177 struct arm_unw_aux_info
* aux
,
8179 struct absaddr addr
)
8181 const char *procname
;
8184 if (addr
.section
== SHN_UNDEF
)
8187 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8188 aux
->strtab_size
, addr
, &procname
,
8191 print_vma (fn
, PREFIX_HEX
);
8195 fputs (" <", stdout
);
8196 fputs (procname
, stdout
);
8199 printf ("+0x%lx", (unsigned long) sym_offset
);
8200 fputc ('>', stdout
);
8207 arm_free_section (struct arm_section
*arm_sec
)
8209 if (arm_sec
->data
!= NULL
)
8210 free (arm_sec
->data
);
8212 if (arm_sec
->rela
!= NULL
)
8213 free (arm_sec
->rela
);
8216 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8217 cached section and install SEC instead.
8218 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8219 and return its valued in * WORDP, relocating if necessary.
8220 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8221 relocation's offset in ADDR.
8222 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8223 into the string table of the symbol associated with the reloc. If no
8224 reloc was applied store -1 there.
8225 5) Return TRUE upon success, FALSE otherwise. */
8228 get_unwind_section_word (Filedata
* filedata
,
8229 struct arm_unw_aux_info
* aux
,
8230 struct arm_section
* arm_sec
,
8231 Elf_Internal_Shdr
* sec
,
8232 bfd_vma word_offset
,
8233 unsigned int * wordp
,
8234 struct absaddr
* addr
,
8237 Elf_Internal_Rela
*rp
;
8238 Elf_Internal_Sym
*sym
;
8239 const char * relname
;
8241 bfd_boolean wrapped
;
8243 if (sec
== NULL
|| arm_sec
== NULL
)
8246 addr
->section
= SHN_UNDEF
;
8249 if (sym_name
!= NULL
)
8250 *sym_name
= (bfd_vma
) -1;
8252 /* If necessary, update the section cache. */
8253 if (sec
!= arm_sec
->sec
)
8255 Elf_Internal_Shdr
*relsec
;
8257 arm_free_section (arm_sec
);
8260 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8261 sec
->sh_size
, _("unwind data"));
8262 arm_sec
->rela
= NULL
;
8263 arm_sec
->nrelas
= 0;
8265 for (relsec
= filedata
->section_headers
;
8266 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8269 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8270 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8271 /* PR 15745: Check the section type as well. */
8272 || (relsec
->sh_type
!= SHT_REL
8273 && relsec
->sh_type
!= SHT_RELA
))
8276 arm_sec
->rel_type
= relsec
->sh_type
;
8277 if (relsec
->sh_type
== SHT_REL
)
8279 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8281 & arm_sec
->rela
, & arm_sec
->nrelas
))
8284 else /* relsec->sh_type == SHT_RELA */
8286 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8288 & arm_sec
->rela
, & arm_sec
->nrelas
))
8294 arm_sec
->next_rela
= arm_sec
->rela
;
8297 /* If there is no unwind data we can do nothing. */
8298 if (arm_sec
->data
== NULL
)
8301 /* If the offset is invalid then fail. */
8302 if (/* PR 21343 *//* PR 18879 */
8304 || word_offset
> (sec
->sh_size
- 4)
8305 || ((bfd_signed_vma
) word_offset
) < 0)
8308 /* Get the word at the required offset. */
8309 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8311 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8312 if (arm_sec
->rela
== NULL
)
8318 /* Look through the relocs to find the one that applies to the provided offset. */
8320 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8322 bfd_vma prelval
, offset
;
8324 if (rp
->r_offset
> word_offset
&& !wrapped
)
8329 if (rp
->r_offset
> word_offset
)
8332 if (rp
->r_offset
& 3)
8334 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8335 (unsigned long) rp
->r_offset
);
8339 if (rp
->r_offset
< word_offset
)
8342 /* PR 17531: file: 027-161405-0.004 */
8343 if (aux
->symtab
== NULL
)
8346 if (arm_sec
->rel_type
== SHT_REL
)
8348 offset
= word
& 0x7fffffff;
8349 if (offset
& 0x40000000)
8350 offset
|= ~ (bfd_vma
) 0x7fffffff;
8352 else if (arm_sec
->rel_type
== SHT_RELA
)
8353 offset
= rp
->r_addend
;
8356 error (_("Unknown section relocation type %d encountered\n"),
8361 /* PR 17531 file: 027-1241568-0.004. */
8362 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8364 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8365 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8369 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8370 offset
+= sym
->st_value
;
8371 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8373 /* Check that we are processing the expected reloc type. */
8374 if (filedata
->file_header
.e_machine
== EM_ARM
)
8376 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8377 if (relname
== NULL
)
8379 warn (_("Skipping unknown ARM relocation type: %d\n"),
8380 (int) ELF32_R_TYPE (rp
->r_info
));
8384 if (streq (relname
, "R_ARM_NONE"))
8387 if (! streq (relname
, "R_ARM_PREL31"))
8389 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8393 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8395 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8396 if (relname
== NULL
)
8398 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8399 (int) ELF32_R_TYPE (rp
->r_info
));
8403 if (streq (relname
, "R_C6000_NONE"))
8406 if (! streq (relname
, "R_C6000_PREL31"))
8408 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8416 /* This function currently only supports ARM and TI unwinders. */
8417 warn (_("Only TI and ARM unwinders are currently supported\n"));
8421 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8422 addr
->section
= sym
->st_shndx
;
8423 addr
->offset
= offset
;
8426 * sym_name
= sym
->st_name
;
8431 arm_sec
->next_rela
= rp
;
8436 static const char *tic6x_unwind_regnames
[16] =
8438 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8439 "A14", "A13", "A12", "A11", "A10",
8440 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8444 decode_tic6x_unwind_regmask (unsigned int mask
)
8448 for (i
= 12; mask
; mask
>>= 1, i
--)
8452 fputs (tic6x_unwind_regnames
[i
], stdout
);
8454 fputs (", ", stdout
);
8460 if (remaining == 0 && more_words) \
8463 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8464 data_offset, & word, & addr, NULL)) \
8470 #define GET_OP(OP) \
8475 (OP) = word >> 24; \
8480 printf (_("[Truncated opcode]\n")); \
8483 printf ("0x%02x ", OP)
8486 decode_arm_unwind_bytecode (Filedata
* filedata
,
8487 struct arm_unw_aux_info
* aux
,
8489 unsigned int remaining
,
8490 unsigned int more_words
,
8491 bfd_vma data_offset
,
8492 Elf_Internal_Shdr
* data_sec
,
8493 struct arm_section
* data_arm_sec
)
8495 struct absaddr addr
;
8496 bfd_boolean res
= TRUE
;
8498 /* Decode the unwinding instructions. */
8501 unsigned int op
, op2
;
8510 printf (" 0x%02x ", op
);
8512 if ((op
& 0xc0) == 0x00)
8514 int offset
= ((op
& 0x3f) << 2) + 4;
8516 printf (" vsp = vsp + %d", offset
);
8518 else if ((op
& 0xc0) == 0x40)
8520 int offset
= ((op
& 0x3f) << 2) + 4;
8522 printf (" vsp = vsp - %d", offset
);
8524 else if ((op
& 0xf0) == 0x80)
8527 if (op
== 0x80 && op2
== 0)
8528 printf (_("Refuse to unwind"));
8531 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8532 bfd_boolean first
= TRUE
;
8536 for (i
= 0; i
< 12; i
++)
8537 if (mask
& (1 << i
))
8543 printf ("r%d", 4 + i
);
8548 else if ((op
& 0xf0) == 0x90)
8550 if (op
== 0x9d || op
== 0x9f)
8551 printf (_(" [Reserved]"));
8553 printf (" vsp = r%d", op
& 0x0f);
8555 else if ((op
& 0xf0) == 0xa0)
8557 int end
= 4 + (op
& 0x07);
8558 bfd_boolean first
= TRUE
;
8562 for (i
= 4; i
<= end
; i
++)
8578 else if (op
== 0xb0)
8579 printf (_(" finish"));
8580 else if (op
== 0xb1)
8583 if (op2
== 0 || (op2
& 0xf0) != 0)
8584 printf (_("[Spare]"));
8587 unsigned int mask
= op2
& 0x0f;
8588 bfd_boolean first
= TRUE
;
8592 for (i
= 0; i
< 12; i
++)
8593 if (mask
& (1 << i
))
8604 else if (op
== 0xb2)
8606 unsigned char buf
[9];
8607 unsigned int i
, len
;
8608 unsigned long offset
;
8610 for (i
= 0; i
< sizeof (buf
); i
++)
8613 if ((buf
[i
] & 0x80) == 0)
8616 if (i
== sizeof (buf
))
8618 error (_("corrupt change to vsp"));
8623 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8624 assert (len
== i
+ 1);
8625 offset
= offset
* 4 + 0x204;
8626 printf ("vsp = vsp + %ld", offset
);
8629 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8631 unsigned int first
, last
;
8638 printf ("pop {D%d", first
);
8640 printf ("-D%d", first
+ last
);
8643 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8645 unsigned int count
= op
& 0x07;
8649 printf ("-D%d", 8 + count
);
8652 else if (op
>= 0xc0 && op
<= 0xc5)
8654 unsigned int count
= op
& 0x07;
8656 printf (" pop {wR10");
8658 printf ("-wR%d", 10 + count
);
8661 else if (op
== 0xc6)
8663 unsigned int first
, last
;
8668 printf ("pop {wR%d", first
);
8670 printf ("-wR%d", first
+ last
);
8673 else if (op
== 0xc7)
8676 if (op2
== 0 || (op2
& 0xf0) != 0)
8677 printf (_("[Spare]"));
8680 unsigned int mask
= op2
& 0x0f;
8681 bfd_boolean first
= TRUE
;
8685 for (i
= 0; i
< 4; i
++)
8686 if (mask
& (1 << i
))
8692 printf ("wCGR%d", i
);
8699 printf (_(" [unsupported opcode]"));
8710 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8711 struct arm_unw_aux_info
* aux
,
8713 unsigned int remaining
,
8714 unsigned int more_words
,
8715 bfd_vma data_offset
,
8716 Elf_Internal_Shdr
* data_sec
,
8717 struct arm_section
* data_arm_sec
)
8719 struct absaddr addr
;
8721 /* Decode the unwinding instructions. */
8724 unsigned int op
, op2
;
8733 printf (" 0x%02x ", op
);
8735 if ((op
& 0xc0) == 0x00)
8737 int offset
= ((op
& 0x3f) << 3) + 8;
8738 printf (" sp = sp + %d", offset
);
8740 else if ((op
& 0xc0) == 0x80)
8743 if (op
== 0x80 && op2
== 0)
8744 printf (_("Refuse to unwind"));
8747 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8749 printf ("pop compact {");
8753 decode_tic6x_unwind_regmask (mask
);
8757 else if ((op
& 0xf0) == 0xc0)
8765 unsigned int offset
;
8769 /* Scan entire instruction first so that GET_OP output is not
8770 interleaved with disassembly. */
8772 for (i
= 0; nregs
< (op
& 0xf); i
++)
8778 regpos
[nregs
].offset
= i
* 2;
8779 regpos
[nregs
].reg
= reg
;
8786 regpos
[nregs
].offset
= i
* 2 + 1;
8787 regpos
[nregs
].reg
= reg
;
8792 printf (_("pop frame {"));
8794 for (i
= i
* 2; i
> 0; i
--)
8796 if (regpos
[reg
].offset
== i
- 1)
8798 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8805 fputs (name
, stdout
);
8812 else if (op
== 0xd0)
8813 printf (" MOV FP, SP");
8814 else if (op
== 0xd1)
8815 printf (" __c6xabi_pop_rts");
8816 else if (op
== 0xd2)
8818 unsigned char buf
[9];
8819 unsigned int i
, len
;
8820 unsigned long offset
;
8822 for (i
= 0; i
< sizeof (buf
); i
++)
8825 if ((buf
[i
] & 0x80) == 0)
8828 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8829 if (i
== sizeof (buf
))
8831 warn (_("Corrupt stack pointer adjustment detected\n"));
8835 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8836 assert (len
== i
+ 1);
8837 offset
= offset
* 8 + 0x408;
8838 printf (_("sp = sp + %ld"), offset
);
8840 else if ((op
& 0xf0) == 0xe0)
8842 if ((op
& 0x0f) == 7)
8845 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8849 printf (_(" [unsupported opcode]"));
8858 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8862 offset
= word
& 0x7fffffff;
8863 if (offset
& 0x40000000)
8864 offset
|= ~ (bfd_vma
) 0x7fffffff;
8866 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8869 return offset
+ where
;
8873 decode_arm_unwind (Filedata
* filedata
,
8874 struct arm_unw_aux_info
* aux
,
8876 unsigned int remaining
,
8877 bfd_vma data_offset
,
8878 Elf_Internal_Shdr
* data_sec
,
8879 struct arm_section
* data_arm_sec
)
8882 unsigned int more_words
= 0;
8883 struct absaddr addr
;
8884 bfd_vma sym_name
= (bfd_vma
) -1;
8885 bfd_boolean res
= TRUE
;
8889 /* Fetch the first word.
8890 Note - when decoding an object file the address extracted
8891 here will always be 0. So we also pass in the sym_name
8892 parameter so that we can find the symbol associated with
8893 the personality routine. */
8894 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8895 & word
, & addr
, & sym_name
))
8901 if ((word
& 0x80000000) == 0)
8903 /* Expand prel31 for personality routine. */
8905 const char *procname
;
8907 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8908 printf (_(" Personality routine: "));
8910 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8911 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8913 procname
= aux
->strtab
+ sym_name
;
8914 print_vma (fn
, PREFIX_HEX
);
8917 fputs (" <", stdout
);
8918 fputs (procname
, stdout
);
8919 fputc ('>', stdout
);
8923 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8924 fputc ('\n', stdout
);
8926 /* The GCC personality routines use the standard compact
8927 encoding, starting with one byte giving the number of
8929 if (procname
!= NULL
8930 && (const_strneq (procname
, "__gcc_personality_v0")
8931 || const_strneq (procname
, "__gxx_personality_v0")
8932 || const_strneq (procname
, "__gcj_personality_v0")
8933 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8940 printf (_(" [Truncated data]\n"));
8943 more_words
= word
>> 24;
8953 /* ARM EHABI Section 6.3:
8955 An exception-handling table entry for the compact model looks like:
8959 1 0 index Data for personalityRoutine[index] */
8961 if (filedata
->file_header
.e_machine
== EM_ARM
8962 && (word
& 0x70000000))
8964 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8968 per_index
= (word
>> 24) & 0x7f;
8969 printf (_(" Compact model index: %d\n"), per_index
);
8976 else if (per_index
< 3)
8978 more_words
= (word
>> 16) & 0xff;
8984 switch (filedata
->file_header
.e_machine
)
8989 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8990 data_offset
, data_sec
, data_arm_sec
))
8995 warn (_("Unknown ARM compact model index encountered\n"));
8996 printf (_(" [reserved]\n"));
9004 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9005 data_offset
, data_sec
, data_arm_sec
))
9008 else if (per_index
< 5)
9010 if (((word
>> 17) & 0x7f) == 0x7f)
9011 printf (_(" Restore stack from frame pointer\n"));
9013 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9014 printf (_(" Registers restored: "));
9016 printf (" (compact) ");
9017 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9019 printf (_(" Return register: %s\n"),
9020 tic6x_unwind_regnames
[word
& 0xf]);
9023 printf (_(" [reserved (%d)]\n"), per_index
);
9027 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9028 filedata
->file_header
.e_machine
);
9032 /* Decode the descriptors. Not implemented. */
9038 dump_arm_unwind (Filedata
* filedata
,
9039 struct arm_unw_aux_info
* aux
,
9040 Elf_Internal_Shdr
* exidx_sec
)
9042 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9043 unsigned int i
, exidx_len
;
9044 unsigned long j
, nfuns
;
9045 bfd_boolean res
= TRUE
;
9047 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9048 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9049 exidx_len
= exidx_sec
->sh_size
/ 8;
9051 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9052 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9053 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9054 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9056 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9058 for (i
= 0; i
< exidx_len
; i
++)
9060 unsigned int exidx_fn
, exidx_entry
;
9061 struct absaddr fn_addr
, entry_addr
;
9064 fputc ('\n', stdout
);
9066 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9067 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9068 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9069 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9072 arm_free_section (& exidx_arm_sec
);
9073 arm_free_section (& extab_arm_sec
);
9077 /* ARM EHABI, Section 5:
9078 An index table entry consists of 2 words.
9079 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9080 if (exidx_fn
& 0x80000000)
9082 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9086 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9088 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9089 fputs (": ", stdout
);
9091 if (exidx_entry
== 1)
9093 print_vma (exidx_entry
, PREFIX_HEX
);
9094 fputs (" [cantunwind]\n", stdout
);
9096 else if (exidx_entry
& 0x80000000)
9098 print_vma (exidx_entry
, PREFIX_HEX
);
9099 fputc ('\n', stdout
);
9100 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9104 bfd_vma table
, table_offset
= 0;
9105 Elf_Internal_Shdr
*table_sec
;
9107 fputs ("@", stdout
);
9108 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9109 print_vma (table
, PREFIX_HEX
);
9112 /* Locate the matching .ARM.extab. */
9113 if (entry_addr
.section
!= SHN_UNDEF
9114 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9116 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9117 table_offset
= entry_addr
.offset
;
9119 if (table_offset
> table_sec
->sh_size
9120 || ((bfd_signed_vma
) table_offset
) < 0)
9122 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9123 (unsigned long) table_offset
,
9124 printable_section_name (filedata
, table_sec
));
9131 table_sec
= find_section_by_address (filedata
, table
);
9132 if (table_sec
!= NULL
)
9133 table_offset
= table
- table_sec
->sh_addr
;
9136 if (table_sec
== NULL
)
9138 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9139 (unsigned long) table
);
9144 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9153 arm_free_section (&exidx_arm_sec
);
9154 arm_free_section (&extab_arm_sec
);
9159 /* Used for both ARM and C6X unwinding tables. */
9162 arm_process_unwind (Filedata
* filedata
)
9164 struct arm_unw_aux_info aux
;
9165 Elf_Internal_Shdr
*unwsec
= NULL
;
9166 Elf_Internal_Shdr
*strsec
;
9167 Elf_Internal_Shdr
*sec
;
9169 unsigned int sec_type
;
9170 bfd_boolean res
= TRUE
;
9172 switch (filedata
->file_header
.e_machine
)
9175 sec_type
= SHT_ARM_EXIDX
;
9179 sec_type
= SHT_C6000_UNWIND
;
9183 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9184 filedata
->file_header
.e_machine
);
9188 if (filedata
->string_table
== NULL
)
9191 memset (& aux
, 0, sizeof (aux
));
9192 aux
.filedata
= filedata
;
9194 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9196 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9198 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9200 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9202 /* PR binutils/17531 file: 011-12666-0.004. */
9203 if (aux
.strtab
!= NULL
)
9205 error (_("Multiple string tables found in file.\n"));
9209 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9210 1, strsec
->sh_size
, _("string table"));
9211 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9213 else if (sec
->sh_type
== sec_type
)
9218 printf (_("\nThere are no unwind sections in this file.\n"));
9220 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9222 if (sec
->sh_type
== sec_type
)
9224 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9225 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9226 "contains %lu entry:\n",
9227 "\nUnwind section '%s' at offset 0x%lx "
9228 "contains %lu entries:\n",
9230 printable_section_name (filedata
, sec
),
9231 (unsigned long) sec
->sh_offset
,
9234 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9242 free ((char *) aux
.strtab
);
9248 process_unwind (Filedata
* filedata
)
9250 struct unwind_handler
9252 unsigned int machtype
;
9253 bfd_boolean (* handler
)(Filedata
*);
9256 { EM_ARM
, arm_process_unwind
},
9257 { EM_IA_64
, ia64_process_unwind
},
9258 { EM_PARISC
, hppa_process_unwind
},
9259 { EM_TI_C6000
, arm_process_unwind
},
9267 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9268 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9269 return handlers
[i
].handler (filedata
);
9271 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9272 get_machine_name (filedata
->file_header
.e_machine
));
9277 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9279 switch (entry
->d_tag
)
9282 if (entry
->d_un
.d_val
== 0)
9286 static const char * opts
[] =
9288 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9289 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9290 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9291 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9295 bfd_boolean first
= TRUE
;
9297 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9298 if (entry
->d_un
.d_val
& (1 << cnt
))
9300 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9306 case DT_MIPS_IVERSION
:
9307 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9308 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9312 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9313 /* Note: coded this way so that there is a single string for translation. */
9314 printf (_("<corrupt: %s>"), buf
);
9318 case DT_MIPS_TIME_STAMP
:
9322 time_t atime
= entry
->d_un
.d_val
;
9324 tmp
= gmtime (&atime
);
9325 /* PR 17531: file: 6accc532. */
9327 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9329 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9330 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9331 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9332 printf (_("Time Stamp: %s"), timebuf
);
9336 case DT_MIPS_RLD_VERSION
:
9337 case DT_MIPS_LOCAL_GOTNO
:
9338 case DT_MIPS_CONFLICTNO
:
9339 case DT_MIPS_LIBLISTNO
:
9340 case DT_MIPS_SYMTABNO
:
9341 case DT_MIPS_UNREFEXTNO
:
9342 case DT_MIPS_HIPAGENO
:
9343 case DT_MIPS_DELTA_CLASS_NO
:
9344 case DT_MIPS_DELTA_INSTANCE_NO
:
9345 case DT_MIPS_DELTA_RELOC_NO
:
9346 case DT_MIPS_DELTA_SYM_NO
:
9347 case DT_MIPS_DELTA_CLASSSYM_NO
:
9348 case DT_MIPS_COMPACT_SIZE
:
9349 print_vma (entry
->d_un
.d_val
, DEC
);
9353 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9359 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9361 switch (entry
->d_tag
)
9363 case DT_HP_DLD_FLAGS
:
9372 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9373 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9374 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9375 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9376 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9377 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9378 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9379 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9380 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9381 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9382 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9383 { DT_HP_GST
, "HP_GST" },
9384 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9385 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9386 { DT_HP_NODELETE
, "HP_NODELETE" },
9387 { DT_HP_GROUP
, "HP_GROUP" },
9388 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9390 bfd_boolean first
= TRUE
;
9392 bfd_vma val
= entry
->d_un
.d_val
;
9394 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9395 if (val
& flags
[cnt
].bit
)
9399 fputs (flags
[cnt
].str
, stdout
);
9401 val
^= flags
[cnt
].bit
;
9404 if (val
!= 0 || first
)
9408 print_vma (val
, HEX
);
9414 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9422 /* VMS vs Unix time offset and factor. */
9424 #define VMS_EPOCH_OFFSET 35067168000000000LL
9425 #define VMS_GRANULARITY_FACTOR 10000000
9427 /* Display a VMS time in a human readable format. */
9430 print_vms_time (bfd_int64_t vmstime
)
9435 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9436 tm
= gmtime (&unxtime
);
9437 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9438 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9439 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9444 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9446 switch (entry
->d_tag
)
9448 case DT_IA_64_PLT_RESERVE
:
9449 /* First 3 slots reserved. */
9450 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9452 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9455 case DT_IA_64_VMS_LINKTIME
:
9457 print_vms_time (entry
->d_un
.d_val
);
9461 case DT_IA_64_VMS_LNKFLAGS
:
9462 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9463 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9464 printf (" CALL_DEBUG");
9465 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9466 printf (" NOP0BUFS");
9467 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9468 printf (" P0IMAGE");
9469 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9470 printf (" MKTHREADS");
9471 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9472 printf (" UPCALLS");
9473 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9475 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9476 printf (" INITIALIZE");
9477 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9479 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9480 printf (" EXE_INIT");
9481 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9482 printf (" TBK_IN_IMG");
9483 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9484 printf (" DBG_IN_IMG");
9485 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9486 printf (" TBK_IN_DSF");
9487 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9488 printf (" DBG_IN_DSF");
9489 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9490 printf (" SIGNATURES");
9491 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9492 printf (" REL_SEG_OFF");
9496 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9503 get_32bit_dynamic_section (Filedata
* filedata
)
9505 Elf32_External_Dyn
* edyn
;
9506 Elf32_External_Dyn
* ext
;
9507 Elf_Internal_Dyn
* entry
;
9509 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9510 dynamic_size
, _("dynamic section"));
9514 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9515 might not have the luxury of section headers. Look for the DT_NULL
9516 terminator to determine the number of entries. */
9517 for (ext
= edyn
, dynamic_nent
= 0;
9518 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9522 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9526 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9528 if (dynamic_section
== NULL
)
9530 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9531 (unsigned long) dynamic_nent
);
9536 for (ext
= edyn
, entry
= dynamic_section
;
9537 entry
< dynamic_section
+ dynamic_nent
;
9540 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9541 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9550 get_64bit_dynamic_section (Filedata
* filedata
)
9552 Elf64_External_Dyn
* edyn
;
9553 Elf64_External_Dyn
* ext
;
9554 Elf_Internal_Dyn
* entry
;
9556 /* Read in the data. */
9557 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9558 dynamic_size
, _("dynamic section"));
9562 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9563 might not have the luxury of section headers. Look for the DT_NULL
9564 terminator to determine the number of entries. */
9565 for (ext
= edyn
, dynamic_nent
= 0;
9566 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9567 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9571 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9575 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9577 if (dynamic_section
== NULL
)
9579 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9580 (unsigned long) dynamic_nent
);
9585 /* Convert from external to internal formats. */
9586 for (ext
= edyn
, entry
= dynamic_section
;
9587 entry
< dynamic_section
+ dynamic_nent
;
9590 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9591 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9600 print_dynamic_flags (bfd_vma flags
)
9602 bfd_boolean first
= TRUE
;
9608 flag
= flags
& - flags
;
9618 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9619 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9620 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9621 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9622 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9623 default: fputs (_("unknown"), stdout
); break;
9629 /* Parse and display the contents of the dynamic section. */
9632 process_dynamic_section (Filedata
* filedata
)
9634 Elf_Internal_Dyn
* entry
;
9636 if (dynamic_size
== 0)
9639 printf (_("\nThere is no dynamic section in this file.\n"));
9646 if (! get_32bit_dynamic_section (filedata
))
9651 if (! get_64bit_dynamic_section (filedata
))
9655 /* Find the appropriate symbol table. */
9656 if (dynamic_symbols
== NULL
)
9658 for (entry
= dynamic_section
;
9659 entry
< dynamic_section
+ dynamic_nent
;
9662 Elf_Internal_Shdr section
;
9664 if (entry
->d_tag
!= DT_SYMTAB
)
9667 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9669 /* Since we do not know how big the symbol table is,
9670 we default to reading in the entire file (!) and
9671 processing that. This is overkill, I know, but it
9673 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9674 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9676 /* See PR 21379 for a reproducer. */
9677 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9681 if (archive_file_offset
!= 0)
9682 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9684 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9687 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9689 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9690 section
.sh_name
= filedata
->string_table_length
;
9692 if (dynamic_symbols
!= NULL
)
9694 error (_("Multiple dynamic symbol table sections found\n"));
9695 free (dynamic_symbols
);
9697 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9698 if (num_dynamic_syms
< 1)
9700 error (_("Unable to determine the number of symbols to load\n"));
9706 /* Similarly find a string table. */
9707 if (dynamic_strings
== NULL
)
9709 for (entry
= dynamic_section
;
9710 entry
< dynamic_section
+ dynamic_nent
;
9713 unsigned long offset
;
9716 if (entry
->d_tag
!= DT_STRTAB
)
9719 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9721 /* Since we do not know how big the string table is,
9722 we default to reading in the entire file (!) and
9723 processing that. This is overkill, I know, but it
9726 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9728 if (archive_file_offset
!= 0)
9729 str_tab_len
= archive_file_size
- offset
;
9731 str_tab_len
= filedata
->file_size
- offset
;
9733 if (str_tab_len
< 1)
9736 (_("Unable to determine the length of the dynamic string table\n"));
9740 if (dynamic_strings
!= NULL
)
9742 error (_("Multiple dynamic string tables found\n"));
9743 free (dynamic_strings
);
9746 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9748 _("dynamic string table"));
9749 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9753 /* And find the syminfo section if available. */
9754 if (dynamic_syminfo
== NULL
)
9756 unsigned long syminsz
= 0;
9758 for (entry
= dynamic_section
;
9759 entry
< dynamic_section
+ dynamic_nent
;
9762 if (entry
->d_tag
== DT_SYMINENT
)
9764 /* Note: these braces are necessary to avoid a syntax
9765 error from the SunOS4 C compiler. */
9766 /* PR binutils/17531: A corrupt file can trigger this test.
9767 So do not use an assert, instead generate an error message. */
9768 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9769 error (_("Bad value (%d) for SYMINENT entry\n"),
9770 (int) entry
->d_un
.d_val
);
9772 else if (entry
->d_tag
== DT_SYMINSZ
)
9773 syminsz
= entry
->d_un
.d_val
;
9774 else if (entry
->d_tag
== DT_SYMINFO
)
9775 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9779 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9781 Elf_External_Syminfo
* extsyminfo
;
9782 Elf_External_Syminfo
* extsym
;
9783 Elf_Internal_Syminfo
* syminfo
;
9785 /* There is a syminfo section. Read the data. */
9786 extsyminfo
= (Elf_External_Syminfo
*)
9787 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9788 _("symbol information"));
9792 if (dynamic_syminfo
!= NULL
)
9794 error (_("Multiple dynamic symbol information sections found\n"));
9795 free (dynamic_syminfo
);
9797 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9798 if (dynamic_syminfo
== NULL
)
9800 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9801 (unsigned long) syminsz
);
9805 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9806 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9807 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9808 ++syminfo
, ++extsym
)
9810 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9811 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9818 if (do_dynamic
&& dynamic_addr
)
9819 printf (ngettext ("\nDynamic section at offset 0x%lx "
9820 "contains %lu entry:\n",
9821 "\nDynamic section at offset 0x%lx "
9822 "contains %lu entries:\n",
9824 dynamic_addr
, (unsigned long) dynamic_nent
);
9826 printf (_(" Tag Type Name/Value\n"));
9828 for (entry
= dynamic_section
;
9829 entry
< dynamic_section
+ dynamic_nent
;
9837 print_vma (entry
->d_tag
, FULL_HEX
);
9838 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9839 printf (" (%s)%*s", dtype
,
9840 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9843 switch (entry
->d_tag
)
9847 print_dynamic_flags (entry
->d_un
.d_val
);
9857 switch (entry
->d_tag
)
9860 printf (_("Auxiliary library"));
9864 printf (_("Filter library"));
9868 printf (_("Configuration file"));
9872 printf (_("Dependency audit library"));
9876 printf (_("Audit library"));
9880 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9881 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9885 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9894 printf (_("Flags:"));
9896 if (entry
->d_un
.d_val
== 0)
9897 printf (_(" None\n"));
9900 unsigned long int val
= entry
->d_un
.d_val
;
9902 if (val
& DTF_1_PARINIT
)
9904 printf (" PARINIT");
9905 val
^= DTF_1_PARINIT
;
9907 if (val
& DTF_1_CONFEXP
)
9909 printf (" CONFEXP");
9910 val
^= DTF_1_CONFEXP
;
9913 printf (" %lx", val
);
9922 printf (_("Flags:"));
9924 if (entry
->d_un
.d_val
== 0)
9925 printf (_(" None\n"));
9928 unsigned long int val
= entry
->d_un
.d_val
;
9930 if (val
& DF_P1_LAZYLOAD
)
9932 printf (" LAZYLOAD");
9933 val
^= DF_P1_LAZYLOAD
;
9935 if (val
& DF_P1_GROUPPERM
)
9937 printf (" GROUPPERM");
9938 val
^= DF_P1_GROUPPERM
;
9941 printf (" %lx", val
);
9950 printf (_("Flags:"));
9951 if (entry
->d_un
.d_val
== 0)
9952 printf (_(" None\n"));
9955 unsigned long int val
= entry
->d_un
.d_val
;
9962 if (val
& DF_1_GLOBAL
)
9967 if (val
& DF_1_GROUP
)
9972 if (val
& DF_1_NODELETE
)
9974 printf (" NODELETE");
9975 val
^= DF_1_NODELETE
;
9977 if (val
& DF_1_LOADFLTR
)
9979 printf (" LOADFLTR");
9980 val
^= DF_1_LOADFLTR
;
9982 if (val
& DF_1_INITFIRST
)
9984 printf (" INITFIRST");
9985 val
^= DF_1_INITFIRST
;
9987 if (val
& DF_1_NOOPEN
)
9992 if (val
& DF_1_ORIGIN
)
9997 if (val
& DF_1_DIRECT
)
10000 val
^= DF_1_DIRECT
;
10002 if (val
& DF_1_TRANS
)
10007 if (val
& DF_1_INTERPOSE
)
10009 printf (" INTERPOSE");
10010 val
^= DF_1_INTERPOSE
;
10012 if (val
& DF_1_NODEFLIB
)
10014 printf (" NODEFLIB");
10015 val
^= DF_1_NODEFLIB
;
10017 if (val
& DF_1_NODUMP
)
10019 printf (" NODUMP");
10020 val
^= DF_1_NODUMP
;
10022 if (val
& DF_1_CONFALT
)
10024 printf (" CONFALT");
10025 val
^= DF_1_CONFALT
;
10027 if (val
& DF_1_ENDFILTEE
)
10029 printf (" ENDFILTEE");
10030 val
^= DF_1_ENDFILTEE
;
10032 if (val
& DF_1_DISPRELDNE
)
10034 printf (" DISPRELDNE");
10035 val
^= DF_1_DISPRELDNE
;
10037 if (val
& DF_1_DISPRELPND
)
10039 printf (" DISPRELPND");
10040 val
^= DF_1_DISPRELPND
;
10042 if (val
& DF_1_NODIRECT
)
10044 printf (" NODIRECT");
10045 val
^= DF_1_NODIRECT
;
10047 if (val
& DF_1_IGNMULDEF
)
10049 printf (" IGNMULDEF");
10050 val
^= DF_1_IGNMULDEF
;
10052 if (val
& DF_1_NOKSYMS
)
10054 printf (" NOKSYMS");
10055 val
^= DF_1_NOKSYMS
;
10057 if (val
& DF_1_NOHDR
)
10062 if (val
& DF_1_EDITED
)
10064 printf (" EDITED");
10065 val
^= DF_1_EDITED
;
10067 if (val
& DF_1_NORELOC
)
10069 printf (" NORELOC");
10070 val
^= DF_1_NORELOC
;
10072 if (val
& DF_1_SYMINTPOSE
)
10074 printf (" SYMINTPOSE");
10075 val
^= DF_1_SYMINTPOSE
;
10077 if (val
& DF_1_GLOBAUDIT
)
10079 printf (" GLOBAUDIT");
10080 val
^= DF_1_GLOBAUDIT
;
10082 if (val
& DF_1_SINGLETON
)
10084 printf (" SINGLETON");
10085 val
^= DF_1_SINGLETON
;
10087 if (val
& DF_1_STUB
)
10092 if (val
& DF_1_PIE
)
10097 if (val
& DF_1_KMOD
)
10102 if (val
& DF_1_WEAKFILTER
)
10104 printf (" WEAKFILTER");
10105 val
^= DF_1_WEAKFILTER
;
10107 if (val
& DF_1_NOCOMMON
)
10109 printf (" NOCOMMON");
10110 val
^= DF_1_NOCOMMON
;
10113 printf (" %lx", val
);
10120 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10122 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10142 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10148 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10149 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10155 switch (entry
->d_tag
)
10158 printf (_("Shared library: [%s]"), name
);
10160 if (streq (name
, program_interpreter
))
10161 printf (_(" program interpreter"));
10165 printf (_("Library soname: [%s]"), name
);
10169 printf (_("Library rpath: [%s]"), name
);
10173 printf (_("Library runpath: [%s]"), name
);
10177 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10182 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10195 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10196 /* Fall through. */
10200 case DT_INIT_ARRAYSZ
:
10201 case DT_FINI_ARRAYSZ
:
10202 case DT_GNU_CONFLICTSZ
:
10203 case DT_GNU_LIBLISTSZ
:
10206 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10207 printf (_(" (bytes)\n"));
10212 case DT_VERNEEDNUM
:
10217 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10226 case DT_INIT_ARRAY
:
10227 case DT_FINI_ARRAY
:
10230 if (entry
->d_tag
== DT_USED
10231 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10233 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10237 printf (_("Not needed object: [%s]\n"), name
);
10242 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10248 /* The value of this entry is ignored. */
10253 case DT_GNU_PRELINKED
:
10257 time_t atime
= entry
->d_un
.d_val
;
10259 tmp
= gmtime (&atime
);
10260 /* PR 17533 file: 041-1244816-0.004. */
10262 printf (_("<corrupt time val: %lx"),
10263 (unsigned long) atime
);
10265 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10266 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10267 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10273 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10276 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10282 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10283 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10288 switch (filedata
->file_header
.e_machine
)
10291 case EM_MIPS_RS3_LE
:
10292 dynamic_section_mips_val (entry
);
10295 dynamic_section_parisc_val (entry
);
10298 dynamic_section_ia64_val (entry
);
10301 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10313 get_ver_flags (unsigned int flags
)
10315 static char buff
[128];
10322 if (flags
& VER_FLG_BASE
)
10323 strcat (buff
, "BASE");
10325 if (flags
& VER_FLG_WEAK
)
10327 if (flags
& VER_FLG_BASE
)
10328 strcat (buff
, " | ");
10330 strcat (buff
, "WEAK");
10333 if (flags
& VER_FLG_INFO
)
10335 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10336 strcat (buff
, " | ");
10338 strcat (buff
, "INFO");
10341 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10343 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10344 strcat (buff
, " | ");
10346 strcat (buff
, _("<unknown>"));
10352 /* Display the contents of the version sections. */
10355 process_version_sections (Filedata
* filedata
)
10357 Elf_Internal_Shdr
* section
;
10359 bfd_boolean found
= FALSE
;
10364 for (i
= 0, section
= filedata
->section_headers
;
10365 i
< filedata
->file_header
.e_shnum
;
10368 switch (section
->sh_type
)
10370 case SHT_GNU_verdef
:
10372 Elf_External_Verdef
* edefs
;
10379 printf (ngettext ("\nVersion definition section '%s' "
10380 "contains %u entry:\n",
10381 "\nVersion definition section '%s' "
10382 "contains %u entries:\n",
10384 printable_section_name (filedata
, section
),
10387 printf (_(" Addr: 0x"));
10388 printf_vma (section
->sh_addr
);
10389 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10390 (unsigned long) section
->sh_offset
, section
->sh_link
,
10391 printable_section_name_from_index (filedata
, section
->sh_link
));
10393 edefs
= (Elf_External_Verdef
*)
10394 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10395 _("version definition section"));
10398 endbuf
= (char *) edefs
+ section
->sh_size
;
10400 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10403 Elf_External_Verdef
* edef
;
10404 Elf_Internal_Verdef ent
;
10405 Elf_External_Verdaux
* eaux
;
10406 Elf_Internal_Verdaux aux
;
10407 unsigned long isum
;
10410 vstart
= ((char *) edefs
) + idx
;
10411 if (vstart
+ sizeof (*edef
) > endbuf
)
10414 edef
= (Elf_External_Verdef
*) vstart
;
10416 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10417 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10418 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10419 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10420 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10421 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10422 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10424 printf (_(" %#06lx: Rev: %d Flags: %s"),
10425 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10427 printf (_(" Index: %d Cnt: %d "),
10428 ent
.vd_ndx
, ent
.vd_cnt
);
10430 /* Check for overflow. */
10431 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10434 vstart
+= ent
.vd_aux
;
10436 if (vstart
+ sizeof (*eaux
) > endbuf
)
10438 eaux
= (Elf_External_Verdaux
*) vstart
;
10440 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10441 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10443 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10444 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10446 printf (_("Name index: %ld\n"), aux
.vda_name
);
10448 isum
= idx
+ ent
.vd_aux
;
10450 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10452 if (aux
.vda_next
< sizeof (*eaux
)
10453 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10455 warn (_("Invalid vda_next field of %lx\n"),
10460 /* Check for overflow. */
10461 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10464 isum
+= aux
.vda_next
;
10465 vstart
+= aux
.vda_next
;
10467 if (vstart
+ sizeof (*eaux
) > endbuf
)
10469 eaux
= (Elf_External_Verdaux
*) vstart
;
10471 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10472 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10474 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10475 printf (_(" %#06lx: Parent %d: %s\n"),
10476 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10478 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10479 isum
, j
, aux
.vda_name
);
10482 if (j
< ent
.vd_cnt
)
10483 printf (_(" Version def aux past end of section\n"));
10486 file: id:000001,src:000172+005151,op:splice,rep:2. */
10487 if (ent
.vd_next
< sizeof (*edef
)
10488 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10490 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10491 cnt
= section
->sh_info
;
10494 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10497 idx
+= ent
.vd_next
;
10500 if (cnt
< section
->sh_info
)
10501 printf (_(" Version definition past end of section\n"));
10507 case SHT_GNU_verneed
:
10509 Elf_External_Verneed
* eneed
;
10516 printf (ngettext ("\nVersion needs section '%s' "
10517 "contains %u entry:\n",
10518 "\nVersion needs section '%s' "
10519 "contains %u entries:\n",
10521 printable_section_name (filedata
, section
), section
->sh_info
);
10523 printf (_(" Addr: 0x"));
10524 printf_vma (section
->sh_addr
);
10525 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10526 (unsigned long) section
->sh_offset
, section
->sh_link
,
10527 printable_section_name_from_index (filedata
, section
->sh_link
));
10529 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10530 section
->sh_offset
, 1,
10532 _("Version Needs section"));
10535 endbuf
= (char *) eneed
+ section
->sh_size
;
10537 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10539 Elf_External_Verneed
* entry
;
10540 Elf_Internal_Verneed ent
;
10541 unsigned long isum
;
10545 vstart
= ((char *) eneed
) + idx
;
10546 if (vstart
+ sizeof (*entry
) > endbuf
)
10549 entry
= (Elf_External_Verneed
*) vstart
;
10551 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10552 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10553 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10554 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10555 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10557 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10559 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10560 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10562 printf (_(" File: %lx"), ent
.vn_file
);
10564 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10566 /* Check for overflow. */
10567 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10569 vstart
+= ent
.vn_aux
;
10571 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10573 Elf_External_Vernaux
* eaux
;
10574 Elf_Internal_Vernaux aux
;
10576 if (vstart
+ sizeof (*eaux
) > endbuf
)
10578 eaux
= (Elf_External_Vernaux
*) vstart
;
10580 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10581 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10582 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10583 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10584 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10586 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10587 printf (_(" %#06lx: Name: %s"),
10588 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10590 printf (_(" %#06lx: Name index: %lx"),
10591 isum
, aux
.vna_name
);
10593 printf (_(" Flags: %s Version: %d\n"),
10594 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10596 if (aux
.vna_next
< sizeof (*eaux
)
10597 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10599 warn (_("Invalid vna_next field of %lx\n"),
10604 /* Check for overflow. */
10605 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10607 isum
+= aux
.vna_next
;
10608 vstart
+= aux
.vna_next
;
10611 if (j
< ent
.vn_cnt
)
10612 warn (_("Missing Version Needs auxillary information\n"));
10614 if (ent
.vn_next
< sizeof (*entry
)
10615 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10617 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10618 cnt
= section
->sh_info
;
10621 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10623 idx
+= ent
.vn_next
;
10626 if (cnt
< section
->sh_info
)
10627 warn (_("Missing Version Needs information\n"));
10633 case SHT_GNU_versym
:
10635 Elf_Internal_Shdr
* link_section
;
10638 unsigned char * edata
;
10639 unsigned short * data
;
10641 Elf_Internal_Sym
* symbols
;
10642 Elf_Internal_Shdr
* string_sec
;
10643 unsigned long num_syms
;
10646 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10649 link_section
= filedata
->section_headers
+ section
->sh_link
;
10650 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10652 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10657 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10658 if (symbols
== NULL
)
10661 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10663 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10664 string_sec
->sh_size
,
10665 _("version string table"));
10672 printf (ngettext ("\nVersion symbols section '%s' "
10673 "contains %lu entry:\n",
10674 "\nVersion symbols section '%s' "
10675 "contains %lu entries:\n",
10677 printable_section_name (filedata
, section
), (unsigned long) total
);
10679 printf (_(" Addr: "));
10680 printf_vma (section
->sh_addr
);
10681 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10682 (unsigned long) section
->sh_offset
, section
->sh_link
,
10683 printable_section_name (filedata
, link_section
));
10685 off
= offset_from_vma (filedata
,
10686 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10687 total
* sizeof (short));
10688 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10690 _("version symbol data"));
10698 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10700 for (cnt
= total
; cnt
--;)
10701 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10706 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10710 char *invalid
= _("*invalid*");
10712 printf (" %03x:", cnt
);
10714 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10715 switch (data
[cnt
+ j
])
10718 fputs (_(" 0 (*local*) "), stdout
);
10722 fputs (_(" 1 (*global*) "), stdout
);
10726 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10727 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10729 /* If this index value is greater than the size of the symbols
10730 array, break to avoid an out-of-bounds read. */
10731 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10733 warn (_("invalid index into symbol array\n"));
10738 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10740 Elf_Internal_Verneed ivn
;
10741 unsigned long offset
;
10743 offset
= offset_from_vma
10744 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10745 sizeof (Elf_External_Verneed
));
10749 Elf_Internal_Vernaux ivna
;
10750 Elf_External_Verneed evn
;
10751 Elf_External_Vernaux evna
;
10752 unsigned long a_off
;
10754 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10755 _("version need")) == NULL
)
10758 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10759 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10761 a_off
= offset
+ ivn
.vn_aux
;
10765 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10766 1, _("version need aux (2)")) == NULL
)
10769 ivna
.vna_other
= 0;
10773 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10774 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10777 a_off
+= ivna
.vna_next
;
10779 while (ivna
.vna_other
!= data
[cnt
+ j
]
10780 && ivna
.vna_next
!= 0);
10782 if (ivna
.vna_other
== data
[cnt
+ j
])
10784 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10786 if (ivna
.vna_name
>= string_sec
->sh_size
)
10789 name
= strtab
+ ivna
.vna_name
;
10793 offset
+= ivn
.vn_next
;
10795 while (ivn
.vn_next
);
10798 if (data
[cnt
+ j
] != 0x8001
10799 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10801 Elf_Internal_Verdef ivd
;
10802 Elf_External_Verdef evd
;
10803 unsigned long offset
;
10805 offset
= offset_from_vma
10806 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10811 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10812 _("version def")) == NULL
)
10815 /* PR 17531: file: 046-1082287-0.004. */
10816 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10821 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10822 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10825 offset
+= ivd
.vd_next
;
10827 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10828 && ivd
.vd_next
!= 0);
10830 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10832 Elf_External_Verdaux evda
;
10833 Elf_Internal_Verdaux ivda
;
10835 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10837 if (get_data (&evda
, filedata
,
10838 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10840 _("version def aux")) == NULL
)
10843 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10845 if (ivda
.vda_name
>= string_sec
->sh_size
)
10847 else if (name
!= NULL
&& name
!= invalid
)
10848 name
= _("*both*");
10850 name
= strtab
+ ivda
.vda_name
;
10854 nn
+= printf ("(%s%-*s",
10856 12 - (int) strlen (name
),
10860 printf ("%*c", 18 - nn
, ' ');
10878 printf (_("\nNo version information found in this file.\n"));
10883 static const char *
10884 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10886 static char buff
[32];
10890 case STB_LOCAL
: return "LOCAL";
10891 case STB_GLOBAL
: return "GLOBAL";
10892 case STB_WEAK
: return "WEAK";
10894 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10895 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10897 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10899 if (binding
== STB_GNU_UNIQUE
10900 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10901 /* GNU is still using the default value 0. */
10902 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10904 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10907 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10912 static const char *
10913 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10915 static char buff
[32];
10919 case STT_NOTYPE
: return "NOTYPE";
10920 case STT_OBJECT
: return "OBJECT";
10921 case STT_FUNC
: return "FUNC";
10922 case STT_SECTION
: return "SECTION";
10923 case STT_FILE
: return "FILE";
10924 case STT_COMMON
: return "COMMON";
10925 case STT_TLS
: return "TLS";
10926 case STT_RELC
: return "RELC";
10927 case STT_SRELC
: return "SRELC";
10929 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10931 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10932 return "THUMB_FUNC";
10934 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10937 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10938 return "PARISC_MILLI";
10940 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10942 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10944 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10946 if (type
== STT_HP_OPAQUE
)
10947 return "HP_OPAQUE";
10948 if (type
== STT_HP_STUB
)
10952 if (type
== STT_GNU_IFUNC
10953 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10954 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10955 /* GNU is still using the default value 0. */
10956 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10959 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10962 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10967 static const char *
10968 get_symbol_visibility (unsigned int visibility
)
10970 switch (visibility
)
10972 case STV_DEFAULT
: return "DEFAULT";
10973 case STV_INTERNAL
: return "INTERNAL";
10974 case STV_HIDDEN
: return "HIDDEN";
10975 case STV_PROTECTED
: return "PROTECTED";
10977 error (_("Unrecognized visibility value: %u"), visibility
);
10978 return _("<unknown>");
10982 static const char *
10983 get_solaris_symbol_visibility (unsigned int visibility
)
10985 switch (visibility
)
10987 case 4: return "EXPORTED";
10988 case 5: return "SINGLETON";
10989 case 6: return "ELIMINATE";
10990 default: return get_symbol_visibility (visibility
);
10994 static const char *
10995 get_mips_symbol_other (unsigned int other
)
10999 case STO_OPTIONAL
: return "OPTIONAL";
11000 case STO_MIPS_PLT
: return "MIPS PLT";
11001 case STO_MIPS_PIC
: return "MIPS PIC";
11002 case STO_MICROMIPS
: return "MICROMIPS";
11003 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11004 case STO_MIPS16
: return "MIPS16";
11005 default: return NULL
;
11009 static const char *
11010 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11012 if (is_ia64_vms (filedata
))
11014 static char res
[32];
11018 /* Function types is for images and .STB files only. */
11019 switch (filedata
->file_header
.e_type
)
11023 switch (VMS_ST_FUNC_TYPE (other
))
11025 case VMS_SFT_CODE_ADDR
:
11026 strcat (res
, " CA");
11028 case VMS_SFT_SYMV_IDX
:
11029 strcat (res
, " VEC");
11032 strcat (res
, " FD");
11034 case VMS_SFT_RESERVE
:
11035 strcat (res
, " RSV");
11038 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11039 VMS_ST_FUNC_TYPE (other
));
11040 strcat (res
, " <unknown>");
11047 switch (VMS_ST_LINKAGE (other
))
11049 case VMS_STL_IGNORE
:
11050 strcat (res
, " IGN");
11052 case VMS_STL_RESERVE
:
11053 strcat (res
, " RSV");
11056 strcat (res
, " STD");
11059 strcat (res
, " LNK");
11062 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11063 VMS_ST_LINKAGE (other
));
11064 strcat (res
, " <unknown>");
11076 static const char *
11077 get_ppc64_symbol_other (unsigned int other
)
11079 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
11081 static char buf
[32];
11082 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
11083 PPC64_LOCAL_ENTRY_OFFSET (other
));
11089 static const char *
11090 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11092 const char * result
= NULL
;
11093 static char buff
[32];
11098 switch (filedata
->file_header
.e_machine
)
11101 result
= get_mips_symbol_other (other
);
11104 result
= get_ia64_symbol_other (filedata
, other
);
11107 result
= get_ppc64_symbol_other (other
);
11117 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11121 static const char *
11122 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11124 static char buff
[32];
11128 case SHN_UNDEF
: return "UND";
11129 case SHN_ABS
: return "ABS";
11130 case SHN_COMMON
: return "COM";
11132 if (type
== SHN_IA_64_ANSI_COMMON
11133 && filedata
->file_header
.e_machine
== EM_IA_64
11134 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11136 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11137 || filedata
->file_header
.e_machine
== EM_L1OM
11138 || filedata
->file_header
.e_machine
== EM_K1OM
)
11139 && type
== SHN_X86_64_LCOMMON
)
11140 return "LARGE_COM";
11141 else if ((type
== SHN_MIPS_SCOMMON
11142 && filedata
->file_header
.e_machine
== EM_MIPS
)
11143 || (type
== SHN_TIC6X_SCOMMON
11144 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11146 else if (type
== SHN_MIPS_SUNDEFINED
11147 && filedata
->file_header
.e_machine
== EM_MIPS
)
11149 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11150 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11151 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11152 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11153 else if (type
>= SHN_LORESERVE
)
11154 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11155 else if (type
>= filedata
->file_header
.e_shnum
)
11156 sprintf (buff
, _("bad section index[%3d]"), type
);
11158 sprintf (buff
, "%3d", type
);
11166 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11168 unsigned char * e_data
;
11171 /* If the size_t type is smaller than the bfd_size_type, eg because
11172 you are building a 32-bit tool on a 64-bit host, then make sure
11173 that when (number) is cast to (size_t) no information is lost. */
11174 if (sizeof (size_t) < sizeof (bfd_size_type
)
11175 && (bfd_size_type
) ((size_t) number
) != number
)
11177 error (_("Size truncation prevents reading %s elements of size %u\n"),
11178 bfd_vmatoa ("u", number
), ent_size
);
11182 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11183 attempting to allocate memory when the read is bound to fail. */
11184 if (ent_size
* number
> filedata
->file_size
)
11186 error (_("Invalid number of dynamic entries: %s\n"),
11187 bfd_vmatoa ("u", number
));
11191 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11192 if (e_data
== NULL
)
11194 error (_("Out of memory reading %s dynamic entries\n"),
11195 bfd_vmatoa ("u", number
));
11199 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11201 error (_("Unable to read in %s bytes of dynamic data\n"),
11202 bfd_vmatoa ("u", number
* ent_size
));
11207 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11208 if (i_data
== NULL
)
11210 error (_("Out of memory allocating space for %s dynamic entries\n"),
11211 bfd_vmatoa ("u", number
));
11217 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11225 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11227 Elf_Internal_Sym
* psym
;
11230 n
= print_vma (si
, DEC_5
);
11232 fputs (&" "[n
], stdout
);
11233 printf (" %3lu: ", hn
);
11235 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11237 printf (_("<No info available for dynamic symbol number %lu>\n"),
11238 (unsigned long) si
);
11242 psym
= dynamic_symbols
+ si
;
11243 print_vma (psym
->st_value
, LONG_HEX
);
11245 print_vma (psym
->st_size
, DEC_5
);
11247 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11248 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11250 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11251 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11254 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11256 printf (" %-7s", get_symbol_visibility (vis
));
11257 /* Check to see if any other bits in the st_other field are set.
11258 Note - displaying this information disrupts the layout of the
11259 table being generated, but for the moment this case is very
11261 if (psym
->st_other
^ vis
)
11262 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11265 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11266 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11267 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11269 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11273 static const char *
11274 get_symbol_version_string (Filedata
* filedata
,
11275 bfd_boolean is_dynsym
,
11276 const char * strtab
,
11277 unsigned long int strtab_size
,
11279 Elf_Internal_Sym
* psym
,
11280 enum versioned_symbol_info
* sym_info
,
11281 unsigned short * vna_other
)
11283 unsigned char data
[2];
11284 unsigned short vers_data
;
11285 unsigned long offset
;
11288 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11291 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11292 sizeof data
+ si
* sizeof (vers_data
));
11294 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11295 sizeof (data
), 1, _("version data")) == NULL
)
11298 vers_data
= byte_get (data
, 2);
11300 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11303 /* Usually we'd only see verdef for defined symbols, and verneed for
11304 undefined symbols. However, symbols defined by the linker in
11305 .dynbss for variables copied from a shared library in order to
11306 avoid text relocations are defined yet have verneed. We could
11307 use a heuristic to detect the special case, for example, check
11308 for verneed first on symbols defined in SHT_NOBITS sections, but
11309 it is simpler and more reliable to just look for both verdef and
11310 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11312 if (psym
->st_shndx
!= SHN_UNDEF
11313 && vers_data
!= 0x8001
11314 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11316 Elf_Internal_Verdef ivd
;
11317 Elf_Internal_Verdaux ivda
;
11318 Elf_External_Verdaux evda
;
11321 off
= offset_from_vma (filedata
,
11322 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11323 sizeof (Elf_External_Verdef
));
11327 Elf_External_Verdef evd
;
11329 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11330 _("version def")) == NULL
)
11339 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11340 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11341 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11342 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11345 off
+= ivd
.vd_next
;
11347 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11349 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11351 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11354 off
-= ivd
.vd_next
;
11357 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11358 _("version def aux")) != NULL
)
11360 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11362 if (psym
->st_name
!= ivda
.vda_name
)
11364 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11365 ? symbol_hidden
: symbol_public
);
11366 return (ivda
.vda_name
< strtab_size
11367 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11373 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11375 Elf_External_Verneed evn
;
11376 Elf_Internal_Verneed ivn
;
11377 Elf_Internal_Vernaux ivna
;
11379 offset
= offset_from_vma (filedata
,
11380 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11384 unsigned long vna_off
;
11386 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11387 _("version need")) == NULL
)
11390 ivna
.vna_other
= 0;
11395 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11396 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11398 vna_off
= offset
+ ivn
.vn_aux
;
11402 Elf_External_Vernaux evna
;
11404 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11405 _("version need aux (3)")) == NULL
)
11408 ivna
.vna_other
= 0;
11413 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11414 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11415 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11418 vna_off
+= ivna
.vna_next
;
11420 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11422 if (ivna
.vna_other
== vers_data
)
11425 offset
+= ivn
.vn_next
;
11427 while (ivn
.vn_next
!= 0);
11429 if (ivna
.vna_other
== vers_data
)
11431 *sym_info
= symbol_undefined
;
11432 *vna_other
= ivna
.vna_other
;
11433 return (ivna
.vna_name
< strtab_size
11434 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11440 /* Dump the symbol table. */
11442 process_symbol_table (Filedata
* filedata
)
11444 Elf_Internal_Shdr
* section
;
11445 bfd_size_type nbuckets
= 0;
11446 bfd_size_type nchains
= 0;
11447 bfd_vma
* buckets
= NULL
;
11448 bfd_vma
* chains
= NULL
;
11449 bfd_vma ngnubuckets
= 0;
11450 bfd_vma
* gnubuckets
= NULL
;
11451 bfd_vma
* gnuchains
= NULL
;
11452 bfd_vma gnusymidx
= 0;
11453 bfd_size_type ngnuchains
= 0;
11455 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11458 if (dynamic_info
[DT_HASH
]
11460 || (do_using_dynamic
11462 && dynamic_strings
!= NULL
)))
11464 unsigned char nb
[8];
11465 unsigned char nc
[8];
11466 unsigned int hash_ent_size
= 4;
11468 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11469 || filedata
->file_header
.e_machine
== EM_S390
11470 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11471 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11474 if (fseek (filedata
->handle
,
11475 (archive_file_offset
11476 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11477 sizeof nb
+ sizeof nc
)),
11480 error (_("Unable to seek to start of dynamic information\n"));
11484 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11486 error (_("Failed to read in number of buckets\n"));
11490 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11492 error (_("Failed to read in number of chains\n"));
11496 nbuckets
= byte_get (nb
, hash_ent_size
);
11497 nchains
= byte_get (nc
, hash_ent_size
);
11499 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11500 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11503 if (buckets
== NULL
|| chains
== NULL
)
11505 if (do_using_dynamic
)
11516 if (dynamic_info_DT_GNU_HASH
11518 || (do_using_dynamic
11520 && dynamic_strings
!= NULL
)))
11522 unsigned char nb
[16];
11523 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11524 bfd_vma buckets_vma
;
11526 if (fseek (filedata
->handle
,
11527 (archive_file_offset
11528 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11532 error (_("Unable to seek to start of dynamic information\n"));
11536 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11538 error (_("Failed to read in number of buckets\n"));
11542 ngnubuckets
= byte_get (nb
, 4);
11543 gnusymidx
= byte_get (nb
+ 4, 4);
11544 bitmaskwords
= byte_get (nb
+ 8, 4);
11545 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11547 buckets_vma
+= bitmaskwords
* 4;
11549 buckets_vma
+= bitmaskwords
* 8;
11551 if (fseek (filedata
->handle
,
11552 (archive_file_offset
11553 + offset_from_vma (filedata
, buckets_vma
, 4)),
11556 error (_("Unable to seek to start of dynamic information\n"));
11560 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11562 if (gnubuckets
== NULL
)
11565 for (i
= 0; i
< ngnubuckets
; i
++)
11566 if (gnubuckets
[i
] != 0)
11568 if (gnubuckets
[i
] < gnusymidx
)
11571 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11572 maxchain
= gnubuckets
[i
];
11575 if (maxchain
== 0xffffffff)
11578 maxchain
-= gnusymidx
;
11580 if (fseek (filedata
->handle
,
11581 (archive_file_offset
11582 + offset_from_vma (filedata
, buckets_vma
11583 + 4 * (ngnubuckets
+ maxchain
), 4)),
11586 error (_("Unable to seek to start of dynamic information\n"));
11592 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11594 error (_("Failed to determine last chain length\n"));
11598 if (maxchain
+ 1 == 0)
11603 while ((byte_get (nb
, 4) & 1) == 0);
11605 if (fseek (filedata
->handle
,
11606 (archive_file_offset
11607 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11610 error (_("Unable to seek to start of dynamic information\n"));
11614 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11615 ngnuchains
= maxchain
;
11618 if (gnuchains
== NULL
)
11623 if (do_using_dynamic
)
11628 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11630 && do_using_dynamic
11631 && dynamic_strings
!= NULL
11632 && dynamic_symbols
!= NULL
)
11636 if (dynamic_info
[DT_HASH
])
11641 printf (_("\nSymbol table for image:\n"));
11643 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11645 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11647 visited
= xcmalloc (nchains
, 1);
11648 memset (visited
, 0, nchains
);
11649 for (hn
= 0; hn
< nbuckets
; hn
++)
11651 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11653 print_dynamic_symbol (filedata
, si
, hn
);
11654 if (si
>= nchains
|| visited
[si
])
11656 error (_("histogram chain is corrupt\n"));
11665 if (dynamic_info_DT_GNU_HASH
)
11667 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11669 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11671 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11673 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11674 if (gnubuckets
[hn
] != 0)
11676 bfd_vma si
= gnubuckets
[hn
];
11677 bfd_vma off
= si
- gnusymidx
;
11681 print_dynamic_symbol (filedata
, si
, hn
);
11684 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11688 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11689 && filedata
->section_headers
!= NULL
)
11693 for (i
= 0, section
= filedata
->section_headers
;
11694 i
< filedata
->file_header
.e_shnum
;
11698 char * strtab
= NULL
;
11699 unsigned long int strtab_size
= 0;
11700 Elf_Internal_Sym
* symtab
;
11701 Elf_Internal_Sym
* psym
;
11702 unsigned long num_syms
;
11704 if ((section
->sh_type
!= SHT_SYMTAB
11705 && section
->sh_type
!= SHT_DYNSYM
)
11707 && section
->sh_type
== SHT_SYMTAB
))
11710 if (section
->sh_entsize
== 0)
11712 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11713 printable_section_name (filedata
, section
));
11717 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11718 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11719 "\nSymbol table '%s' contains %lu entries:\n",
11721 printable_section_name (filedata
, section
),
11725 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11727 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11729 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11730 if (symtab
== NULL
)
11733 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11735 strtab
= filedata
->string_table
;
11736 strtab_size
= filedata
->string_table_length
;
11738 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11740 Elf_Internal_Shdr
* string_sec
;
11742 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11744 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11745 1, string_sec
->sh_size
,
11746 _("string table"));
11747 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11750 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11752 const char *version_string
;
11753 enum versioned_symbol_info sym_info
;
11754 unsigned short vna_other
;
11756 printf ("%6d: ", si
);
11757 print_vma (psym
->st_value
, LONG_HEX
);
11759 print_vma (psym
->st_size
, DEC_5
);
11760 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11761 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11762 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11763 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11766 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11768 printf (" %-7s", get_symbol_visibility (vis
));
11769 /* Check to see if any other bits in the st_other field are set.
11770 Note - displaying this information disrupts the layout of the
11771 table being generated, but for the moment this case is very rare. */
11772 if (psym
->st_other
^ vis
)
11773 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11775 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11776 print_symbol (25, psym
->st_name
< strtab_size
11777 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11780 = get_symbol_version_string (filedata
,
11781 section
->sh_type
== SHT_DYNSYM
,
11782 strtab
, strtab_size
, si
,
11783 psym
, &sym_info
, &vna_other
);
11784 if (version_string
)
11786 if (sym_info
== symbol_undefined
)
11787 printf ("@%s (%d)", version_string
, vna_other
);
11789 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11795 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11796 && si
>= section
->sh_info
11797 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11798 && filedata
->file_header
.e_machine
!= EM_MIPS
11799 /* Solaris binaries have been found to violate this requirement as
11800 well. Not sure if this is a bug or an ABI requirement. */
11801 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11802 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11803 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11807 if (strtab
!= filedata
->string_table
)
11813 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11815 if (do_histogram
&& buckets
!= NULL
)
11817 unsigned long * lengths
;
11818 unsigned long * counts
;
11821 unsigned long maxlength
= 0;
11822 unsigned long nzero_counts
= 0;
11823 unsigned long nsyms
= 0;
11826 printf (ngettext ("\nHistogram for bucket list length "
11827 "(total of %lu bucket):\n",
11828 "\nHistogram for bucket list length "
11829 "(total of %lu buckets):\n",
11830 (unsigned long) nbuckets
),
11831 (unsigned long) nbuckets
);
11833 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11834 if (lengths
== NULL
)
11836 error (_("Out of memory allocating space for histogram buckets\n"));
11839 visited
= xcmalloc (nchains
, 1);
11840 memset (visited
, 0, nchains
);
11842 printf (_(" Length Number %% of total Coverage\n"));
11843 for (hn
= 0; hn
< nbuckets
; ++hn
)
11845 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11848 if (maxlength
< ++lengths
[hn
])
11850 if (si
>= nchains
|| visited
[si
])
11852 error (_("histogram chain is corrupt\n"));
11860 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11861 if (counts
== NULL
)
11864 error (_("Out of memory allocating space for histogram counts\n"));
11868 for (hn
= 0; hn
< nbuckets
; ++hn
)
11869 ++counts
[lengths
[hn
]];
11874 printf (" 0 %-10lu (%5.1f%%)\n",
11875 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11876 for (i
= 1; i
<= maxlength
; ++i
)
11878 nzero_counts
+= counts
[i
] * i
;
11879 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11880 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11881 (nzero_counts
* 100.0) / nsyms
);
11889 if (buckets
!= NULL
)
11895 if (do_histogram
&& gnubuckets
!= NULL
)
11897 unsigned long * lengths
;
11898 unsigned long * counts
;
11900 unsigned long maxlength
= 0;
11901 unsigned long nzero_counts
= 0;
11902 unsigned long nsyms
= 0;
11904 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11905 "(total of %lu bucket):\n",
11906 "\nHistogram for `.gnu.hash' bucket list length "
11907 "(total of %lu buckets):\n",
11908 (unsigned long) ngnubuckets
),
11909 (unsigned long) ngnubuckets
);
11911 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11912 if (lengths
== NULL
)
11914 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11918 printf (_(" Length Number %% of total Coverage\n"));
11920 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11921 if (gnubuckets
[hn
] != 0)
11923 bfd_vma off
, length
= 1;
11925 for (off
= gnubuckets
[hn
] - gnusymidx
;
11926 /* PR 17531 file: 010-77222-0.004. */
11927 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11930 lengths
[hn
] = length
;
11931 if (length
> maxlength
)
11932 maxlength
= length
;
11936 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11937 if (counts
== NULL
)
11940 error (_("Out of memory allocating space for gnu histogram counts\n"));
11944 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11945 ++counts
[lengths
[hn
]];
11947 if (ngnubuckets
> 0)
11950 printf (" 0 %-10lu (%5.1f%%)\n",
11951 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11952 for (j
= 1; j
<= maxlength
; ++j
)
11954 nzero_counts
+= counts
[j
] * j
;
11955 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11956 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11957 (nzero_counts
* 100.0) / nsyms
);
11971 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
11975 if (dynamic_syminfo
== NULL
11977 /* No syminfo, this is ok. */
11980 /* There better should be a dynamic symbol section. */
11981 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11985 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11986 "contains %d entry:\n",
11987 "\nDynamic info segment at offset 0x%lx "
11988 "contains %d entries:\n",
11989 dynamic_syminfo_nent
),
11990 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11992 printf (_(" Num: Name BoundTo Flags\n"));
11993 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11995 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11997 printf ("%4d: ", i
);
11998 if (i
>= num_dynamic_syms
)
11999 printf (_("<corrupt index>"));
12000 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12001 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12003 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12006 switch (dynamic_syminfo
[i
].si_boundto
)
12008 case SYMINFO_BT_SELF
:
12009 fputs ("SELF ", stdout
);
12011 case SYMINFO_BT_PARENT
:
12012 fputs ("PARENT ", stdout
);
12015 if (dynamic_syminfo
[i
].si_boundto
> 0
12016 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12017 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12019 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12023 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12027 if (flags
& SYMINFO_FLG_DIRECT
)
12028 printf (" DIRECT");
12029 if (flags
& SYMINFO_FLG_PASSTHRU
)
12030 printf (" PASSTHRU");
12031 if (flags
& SYMINFO_FLG_COPY
)
12033 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12034 printf (" LAZYLOAD");
12042 #define IN_RANGE(START,END,ADDR,OFF) \
12043 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12045 /* Check to see if the given reloc needs to be handled in a target specific
12046 manner. If so then process the reloc and return TRUE otherwise return
12049 If called with reloc == NULL, then this is a signal that reloc processing
12050 for the current section has finished, and any saved state should be
12054 target_specific_reloc_handling (Filedata
* filedata
,
12055 Elf_Internal_Rela
* reloc
,
12056 unsigned char * start
,
12057 unsigned char * end
,
12058 Elf_Internal_Sym
* symtab
,
12059 unsigned long num_syms
)
12061 unsigned int reloc_type
= 0;
12062 unsigned long sym_index
= 0;
12066 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12067 sym_index
= get_reloc_symindex (reloc
->r_info
);
12070 switch (filedata
->file_header
.e_machine
)
12073 case EM_MSP430_OLD
:
12075 static Elf_Internal_Sym
* saved_sym
= NULL
;
12083 switch (reloc_type
)
12085 case 10: /* R_MSP430_SYM_DIFF */
12086 if (uses_msp430x_relocs (filedata
))
12088 /* Fall through. */
12089 case 21: /* R_MSP430X_SYM_DIFF */
12091 if (sym_index
>= num_syms
)
12092 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12095 saved_sym
= symtab
+ sym_index
;
12098 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12099 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12100 goto handle_sym_diff
;
12102 case 5: /* R_MSP430_16_BYTE */
12103 case 9: /* R_MSP430_8 */
12104 if (uses_msp430x_relocs (filedata
))
12106 goto handle_sym_diff
;
12108 case 2: /* R_MSP430_ABS16 */
12109 case 15: /* R_MSP430X_ABS16 */
12110 if (! uses_msp430x_relocs (filedata
))
12112 goto handle_sym_diff
;
12115 if (saved_sym
!= NULL
)
12117 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12120 if (sym_index
>= num_syms
)
12121 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12125 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12126 - saved_sym
->st_value
);
12128 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12129 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12132 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12133 (long) reloc
->r_offset
);
12142 if (saved_sym
!= NULL
)
12143 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12150 case EM_CYGNUS_MN10300
:
12152 static Elf_Internal_Sym
* saved_sym
= NULL
;
12160 switch (reloc_type
)
12162 case 34: /* R_MN10300_ALIGN */
12164 case 33: /* R_MN10300_SYM_DIFF */
12165 if (sym_index
>= num_syms
)
12166 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12169 saved_sym
= symtab
+ sym_index
;
12172 case 1: /* R_MN10300_32 */
12173 case 2: /* R_MN10300_16 */
12174 if (saved_sym
!= NULL
)
12176 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12179 if (sym_index
>= num_syms
)
12180 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12184 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12185 - saved_sym
->st_value
);
12187 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12188 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12190 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12191 (long) reloc
->r_offset
);
12199 if (saved_sym
!= NULL
)
12200 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12208 static bfd_vma saved_sym1
= 0;
12209 static bfd_vma saved_sym2
= 0;
12210 static bfd_vma value
;
12214 saved_sym1
= saved_sym2
= 0;
12218 switch (reloc_type
)
12220 case 0x80: /* R_RL78_SYM. */
12221 saved_sym1
= saved_sym2
;
12222 if (sym_index
>= num_syms
)
12223 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12227 saved_sym2
= symtab
[sym_index
].st_value
;
12228 saved_sym2
+= reloc
->r_addend
;
12232 case 0x83: /* R_RL78_OPsub. */
12233 value
= saved_sym1
- saved_sym2
;
12234 saved_sym2
= saved_sym1
= 0;
12238 case 0x41: /* R_RL78_ABS32. */
12239 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12240 byte_put (start
+ reloc
->r_offset
, value
, 4);
12242 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12243 (long) reloc
->r_offset
);
12247 case 0x43: /* R_RL78_ABS16. */
12248 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12249 byte_put (start
+ reloc
->r_offset
, value
, 2);
12251 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12252 (long) reloc
->r_offset
);
12266 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12267 DWARF debug sections. This is a target specific test. Note - we do not
12268 go through the whole including-target-headers-multiple-times route, (as
12269 we have already done with <elf/h8.h>) because this would become very
12270 messy and even then this function would have to contain target specific
12271 information (the names of the relocs instead of their numeric values).
12272 FIXME: This is not the correct way to solve this problem. The proper way
12273 is to have target specific reloc sizing and typing functions created by
12274 the reloc-macros.h header, in the same way that it already creates the
12275 reloc naming functions. */
12278 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12280 /* Please keep this table alpha-sorted for ease of visual lookup. */
12281 switch (filedata
->file_header
.e_machine
)
12285 return reloc_type
== 1; /* R_386_32. */
12287 return reloc_type
== 1; /* R_68K_32. */
12289 return reloc_type
== 1; /* R_860_32. */
12291 return reloc_type
== 2; /* R_960_32. */
12293 return (reloc_type
== 258
12294 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12295 case EM_ADAPTEVA_EPIPHANY
:
12296 return reloc_type
== 3;
12298 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12300 return reloc_type
== 1; /* R_ARC_32. */
12301 case EM_ARC_COMPACT
:
12302 case EM_ARC_COMPACT2
:
12303 return reloc_type
== 4; /* R_ARC_32. */
12305 return reloc_type
== 2; /* R_ARM_ABS32 */
12308 return reloc_type
== 1;
12310 return reloc_type
== 0x12; /* R_byte4_data. */
12312 return reloc_type
== 3; /* R_CRIS_32. */
12314 return reloc_type
== 3; /* R_CR16_NUM32. */
12316 return reloc_type
== 15; /* R_CRX_NUM32. */
12318 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12319 case EM_CYGNUS_FRV
:
12320 return reloc_type
== 1;
12321 case EM_CYGNUS_D10V
:
12323 return reloc_type
== 6; /* R_D10V_32. */
12324 case EM_CYGNUS_D30V
:
12326 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12328 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12329 case EM_CYGNUS_FR30
:
12331 return reloc_type
== 3; /* R_FR30_32. */
12333 return reloc_type
== 1; /* R_FT32_32. */
12337 return reloc_type
== 1; /* R_H8_DIR32. */
12339 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12340 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12341 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12342 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12345 return reloc_type
== 2; /* R_IP2K_32. */
12347 return reloc_type
== 2; /* R_IQ2000_32. */
12348 case EM_LATTICEMICO32
:
12349 return reloc_type
== 3; /* R_LM32_32. */
12352 return reloc_type
== 3; /* R_M32C_32. */
12354 return reloc_type
== 34; /* R_M32R_32_RELA. */
12357 return reloc_type
== 6; /* R_M68HC11_32. */
12359 return reloc_type
== 6; /* R_S12Z_EXT32. */
12361 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12362 case EM_CYGNUS_MEP
:
12363 return reloc_type
== 4; /* R_MEP_32. */
12365 return reloc_type
== 2; /* R_METAG_ADDR32. */
12366 case EM_MICROBLAZE
:
12367 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12369 return reloc_type
== 2; /* R_MIPS_32. */
12371 return reloc_type
== 4; /* R_MMIX_32. */
12372 case EM_CYGNUS_MN10200
:
12374 return reloc_type
== 1; /* R_MN10200_32. */
12375 case EM_CYGNUS_MN10300
:
12377 return reloc_type
== 1; /* R_MN10300_32. */
12379 return reloc_type
== 1; /* R_MOXIE_32. */
12380 case EM_MSP430_OLD
:
12382 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12384 return reloc_type
== 2; /* R_MT_32. */
12386 return reloc_type
== 20; /* R_NDS32_RELA. */
12387 case EM_ALTERA_NIOS2
:
12388 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12390 return reloc_type
== 1; /* R_NIOS_32. */
12392 return reloc_type
== 1; /* R_OR1K_32. */
12394 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12395 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12396 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12399 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12401 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12403 return reloc_type
== 1; /* R_PPC_ADDR32. */
12405 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12407 return reloc_type
== 1; /* R_RISCV_32. */
12409 return reloc_type
== 1; /* R_RL78_DIR32. */
12411 return reloc_type
== 1; /* R_RX_DIR32. */
12413 return reloc_type
== 1; /* R_I370_ADDR31. */
12416 return reloc_type
== 4; /* R_S390_32. */
12418 return reloc_type
== 8; /* R_SCORE_ABS32. */
12420 return reloc_type
== 1; /* R_SH_DIR32. */
12421 case EM_SPARC32PLUS
:
12424 return reloc_type
== 3 /* R_SPARC_32. */
12425 || reloc_type
== 23; /* R_SPARC_UA32. */
12427 return reloc_type
== 6; /* R_SPU_ADDR32 */
12429 return reloc_type
== 1; /* R_C6000_ABS32. */
12431 return reloc_type
== 2; /* R_TILEGX_32. */
12433 return reloc_type
== 1; /* R_TILEPRO_32. */
12434 case EM_CYGNUS_V850
:
12436 return reloc_type
== 6; /* R_V850_ABS32. */
12438 return reloc_type
== 0x33; /* R_V810_WORD. */
12440 return reloc_type
== 1; /* R_VAX_32. */
12442 return reloc_type
== 3; /* R_VISIUM_32. */
12443 case EM_WEBASSEMBLY
:
12444 return reloc_type
== 1; /* R_WASM32_32. */
12448 return reloc_type
== 10; /* R_X86_64_32. */
12451 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12453 return reloc_type
== 4; /* R_XGATE_32. */
12455 return reloc_type
== 1; /* R_XSTROMY16_32. */
12456 case EM_XTENSA_OLD
:
12458 return reloc_type
== 1; /* R_XTENSA_32. */
12461 static unsigned int prev_warn
= 0;
12463 /* Avoid repeating the same warning multiple times. */
12464 if (prev_warn
!= filedata
->file_header
.e_machine
)
12465 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12466 filedata
->file_header
.e_machine
);
12467 prev_warn
= filedata
->file_header
.e_machine
;
12473 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12474 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12477 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12479 switch (filedata
->file_header
.e_machine
)
12480 /* Please keep this table alpha-sorted for ease of visual lookup. */
12484 return reloc_type
== 2; /* R_386_PC32. */
12486 return reloc_type
== 4; /* R_68K_PC32. */
12488 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12489 case EM_ADAPTEVA_EPIPHANY
:
12490 return reloc_type
== 6;
12492 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12493 case EM_ARC_COMPACT
:
12494 case EM_ARC_COMPACT2
:
12495 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12497 return reloc_type
== 3; /* R_ARM_REL32 */
12500 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12501 case EM_MICROBLAZE
:
12502 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12504 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12506 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12508 return reloc_type
== 26; /* R_PPC_REL32. */
12510 return reloc_type
== 26; /* R_PPC64_REL32. */
12513 return reloc_type
== 5; /* R_390_PC32. */
12515 return reloc_type
== 2; /* R_SH_REL32. */
12516 case EM_SPARC32PLUS
:
12519 return reloc_type
== 6; /* R_SPARC_DISP32. */
12521 return reloc_type
== 13; /* R_SPU_REL32. */
12523 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12525 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12527 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12531 return reloc_type
== 2; /* R_X86_64_PC32. */
12532 case EM_XTENSA_OLD
:
12534 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12536 /* Do not abort or issue an error message here. Not all targets use
12537 pc-relative 32-bit relocs in their DWARF debug information and we
12538 have already tested for target coverage in is_32bit_abs_reloc. A
12539 more helpful warning message will be generated by apply_relocations
12540 anyway, so just return. */
12545 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12546 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12549 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12551 switch (filedata
->file_header
.e_machine
)
12554 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12556 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12558 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12559 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12561 return reloc_type
== 80; /* R_PARISC_DIR64. */
12563 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12565 return reloc_type
== 2; /* R_RISCV_64. */
12566 case EM_SPARC32PLUS
:
12569 return reloc_type
== 32 /* R_SPARC_64. */
12570 || reloc_type
== 54; /* R_SPARC_UA64. */
12574 return reloc_type
== 1; /* R_X86_64_64. */
12577 return reloc_type
== 22; /* R_S390_64. */
12579 return reloc_type
== 1; /* R_TILEGX_64. */
12581 return reloc_type
== 18; /* R_MIPS_64. */
12587 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12588 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12591 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12593 switch (filedata
->file_header
.e_machine
)
12596 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12598 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12600 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12601 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12603 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12605 return reloc_type
== 44; /* R_PPC64_REL64. */
12606 case EM_SPARC32PLUS
:
12609 return reloc_type
== 46; /* R_SPARC_DISP64. */
12613 return reloc_type
== 24; /* R_X86_64_PC64. */
12616 return reloc_type
== 23; /* R_S390_PC64. */
12618 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12624 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12625 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12628 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12630 switch (filedata
->file_header
.e_machine
)
12632 case EM_CYGNUS_MN10200
:
12634 return reloc_type
== 4; /* R_MN10200_24. */
12636 return reloc_type
== 5; /* R_FT32_20. */
12642 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12643 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12646 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12648 /* Please keep this table alpha-sorted for ease of visual lookup. */
12649 switch (filedata
->file_header
.e_machine
)
12652 case EM_ARC_COMPACT
:
12653 case EM_ARC_COMPACT2
:
12654 return reloc_type
== 2; /* R_ARC_16. */
12655 case EM_ADAPTEVA_EPIPHANY
:
12656 return reloc_type
== 5;
12659 return reloc_type
== 4; /* R_AVR_16. */
12660 case EM_CYGNUS_D10V
:
12662 return reloc_type
== 3; /* R_D10V_16. */
12664 return reloc_type
== 2; /* R_FT32_16. */
12668 return reloc_type
== R_H8_DIR16
;
12671 return reloc_type
== 1; /* R_IP2K_16. */
12674 return reloc_type
== 1; /* R_M32C_16 */
12675 case EM_CYGNUS_MN10200
:
12677 return reloc_type
== 2; /* R_MN10200_16. */
12678 case EM_CYGNUS_MN10300
:
12680 return reloc_type
== 2; /* R_MN10300_16. */
12682 if (uses_msp430x_relocs (filedata
))
12683 return reloc_type
== 2; /* R_MSP430_ABS16. */
12684 /* Fall through. */
12685 case EM_MSP430_OLD
:
12686 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12688 return reloc_type
== 19; /* R_NDS32_RELA. */
12689 case EM_ALTERA_NIOS2
:
12690 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12692 return reloc_type
== 9; /* R_NIOS_16. */
12694 return reloc_type
== 2; /* R_OR1K_16. */
12696 return reloc_type
== 55; /* R_RISCV_SET16. */
12698 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12700 return reloc_type
== 2; /* R_C6000_ABS16. */
12702 return reloc_type
== 2; /* R_VISIUM_16. */
12705 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12707 return reloc_type
== 3; /* R_XGATE_16. */
12713 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12714 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12717 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12719 switch (filedata
->file_header
.e_machine
)
12722 return reloc_type
== 54; /* R_RISCV_SET8. */
12728 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12729 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12732 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12734 switch (filedata
->file_header
.e_machine
)
12737 return reloc_type
== 53; /* R_RISCV_SET6. */
12743 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12744 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12747 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12749 /* Please keep this table alpha-sorted for ease of visual lookup. */
12750 switch (filedata
->file_header
.e_machine
)
12753 return reloc_type
== 35; /* R_RISCV_ADD32. */
12759 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12760 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12763 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12765 /* Please keep this table alpha-sorted for ease of visual lookup. */
12766 switch (filedata
->file_header
.e_machine
)
12769 return reloc_type
== 39; /* R_RISCV_SUB32. */
12775 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12776 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12779 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12781 /* Please keep this table alpha-sorted for ease of visual lookup. */
12782 switch (filedata
->file_header
.e_machine
)
12785 return reloc_type
== 36; /* R_RISCV_ADD64. */
12791 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12792 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12795 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12797 /* Please keep this table alpha-sorted for ease of visual lookup. */
12798 switch (filedata
->file_header
.e_machine
)
12801 return reloc_type
== 40; /* R_RISCV_SUB64. */
12807 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12808 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12811 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12813 /* Please keep this table alpha-sorted for ease of visual lookup. */
12814 switch (filedata
->file_header
.e_machine
)
12817 return reloc_type
== 34; /* R_RISCV_ADD16. */
12823 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12824 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12827 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12829 /* Please keep this table alpha-sorted for ease of visual lookup. */
12830 switch (filedata
->file_header
.e_machine
)
12833 return reloc_type
== 38; /* R_RISCV_SUB16. */
12839 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12840 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12843 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12845 /* Please keep this table alpha-sorted for ease of visual lookup. */
12846 switch (filedata
->file_header
.e_machine
)
12849 return reloc_type
== 33; /* R_RISCV_ADD8. */
12855 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12856 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12859 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12861 /* Please keep this table alpha-sorted for ease of visual lookup. */
12862 switch (filedata
->file_header
.e_machine
)
12865 return reloc_type
== 37; /* R_RISCV_SUB8. */
12871 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12872 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12875 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12877 switch (filedata
->file_header
.e_machine
)
12880 return reloc_type
== 52; /* R_RISCV_SUB6. */
12886 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12887 relocation entries (possibly formerly used for SHT_GROUP sections). */
12890 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12892 switch (filedata
->file_header
.e_machine
)
12894 case EM_386
: /* R_386_NONE. */
12895 case EM_68K
: /* R_68K_NONE. */
12896 case EM_ADAPTEVA_EPIPHANY
:
12897 case EM_ALPHA
: /* R_ALPHA_NONE. */
12898 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12899 case EM_ARC
: /* R_ARC_NONE. */
12900 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12901 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12902 case EM_ARM
: /* R_ARM_NONE. */
12903 case EM_C166
: /* R_XC16X_NONE. */
12904 case EM_CRIS
: /* R_CRIS_NONE. */
12905 case EM_FT32
: /* R_FT32_NONE. */
12906 case EM_IA_64
: /* R_IA64_NONE. */
12907 case EM_K1OM
: /* R_X86_64_NONE. */
12908 case EM_L1OM
: /* R_X86_64_NONE. */
12909 case EM_M32R
: /* R_M32R_NONE. */
12910 case EM_MIPS
: /* R_MIPS_NONE. */
12911 case EM_MN10300
: /* R_MN10300_NONE. */
12912 case EM_MOXIE
: /* R_MOXIE_NONE. */
12913 case EM_NIOS32
: /* R_NIOS_NONE. */
12914 case EM_OR1K
: /* R_OR1K_NONE. */
12915 case EM_PARISC
: /* R_PARISC_NONE. */
12916 case EM_PPC64
: /* R_PPC64_NONE. */
12917 case EM_PPC
: /* R_PPC_NONE. */
12918 case EM_RISCV
: /* R_RISCV_NONE. */
12919 case EM_S390
: /* R_390_NONE. */
12921 case EM_SH
: /* R_SH_NONE. */
12922 case EM_SPARC32PLUS
:
12923 case EM_SPARC
: /* R_SPARC_NONE. */
12925 case EM_TILEGX
: /* R_TILEGX_NONE. */
12926 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12927 case EM_TI_C6000
:/* R_C6000_NONE. */
12928 case EM_X86_64
: /* R_X86_64_NONE. */
12930 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12931 return reloc_type
== 0;
12934 return reloc_type
== 0 || reloc_type
== 256;
12937 return (reloc_type
== 0 /* R_AVR_NONE. */
12938 || reloc_type
== 30 /* R_AVR_DIFF8. */
12939 || reloc_type
== 31 /* R_AVR_DIFF16. */
12940 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12942 return reloc_type
== 3; /* R_METAG_NONE. */
12944 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12945 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12946 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12947 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12948 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12950 return (reloc_type
== 0 /* R_PRU_NONE. */
12951 || reloc_type
== 65 /* R_PRU_DIFF8. */
12952 || reloc_type
== 66 /* R_PRU_DIFF16. */
12953 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12954 case EM_XTENSA_OLD
:
12956 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12957 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12958 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12959 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12964 /* Returns TRUE if there is a relocation against
12965 section NAME at OFFSET bytes. */
12968 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12970 Elf_Internal_Rela
* relocs
;
12971 Elf_Internal_Rela
* rp
;
12973 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12976 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12978 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12979 if (rp
->r_offset
== offset
)
12985 /* Apply relocations to a section.
12986 Returns TRUE upon success, FALSE otherwise.
12987 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12988 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12989 will be set to the number of relocs loaded.
12991 Note: So far support has been added only for those relocations
12992 which can be found in debug sections. FIXME: Add support for
12993 more relocations ? */
12996 apply_relocations (Filedata
* filedata
,
12997 const Elf_Internal_Shdr
* section
,
12998 unsigned char * start
,
12999 bfd_size_type size
,
13000 void ** relocs_return
,
13001 unsigned long * num_relocs_return
)
13003 Elf_Internal_Shdr
* relsec
;
13004 unsigned char * end
= start
+ size
;
13005 bfd_boolean res
= TRUE
;
13007 if (relocs_return
!= NULL
)
13009 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13010 * num_relocs_return
= 0;
13013 if (filedata
->file_header
.e_type
!= ET_REL
)
13014 /* No relocs to apply. */
13017 /* Find the reloc section associated with the section. */
13018 for (relsec
= filedata
->section_headers
;
13019 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13022 bfd_boolean is_rela
;
13023 unsigned long num_relocs
;
13024 Elf_Internal_Rela
* relocs
;
13025 Elf_Internal_Rela
* rp
;
13026 Elf_Internal_Shdr
* symsec
;
13027 Elf_Internal_Sym
* symtab
;
13028 unsigned long num_syms
;
13029 Elf_Internal_Sym
* sym
;
13031 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13032 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13033 || filedata
->section_headers
+ relsec
->sh_info
!= section
13034 || relsec
->sh_size
== 0
13035 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13038 is_rela
= relsec
->sh_type
== SHT_RELA
;
13042 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13043 relsec
->sh_size
, & relocs
, & num_relocs
))
13048 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13049 relsec
->sh_size
, & relocs
, & num_relocs
))
13053 /* SH uses RELA but uses in place value instead of the addend field. */
13054 if (filedata
->file_header
.e_machine
== EM_SH
)
13057 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13058 if (symsec
->sh_type
!= SHT_SYMTAB
13059 && symsec
->sh_type
!= SHT_DYNSYM
)
13061 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13063 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13066 unsigned int reloc_type
;
13067 unsigned int reloc_size
;
13068 bfd_boolean reloc_inplace
= FALSE
;
13069 bfd_boolean reloc_subtract
= FALSE
;
13070 unsigned char * rloc
;
13071 unsigned long sym_index
;
13073 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13075 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13077 else if (is_none_reloc (filedata
, reloc_type
))
13079 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13080 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13082 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13083 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13085 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13087 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13089 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13090 || is_6bit_abs_reloc (filedata
, reloc_type
))
13092 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13094 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13097 reloc_inplace
= TRUE
;
13099 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13101 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13104 reloc_inplace
= TRUE
;
13106 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13108 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13111 reloc_inplace
= TRUE
;
13113 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13115 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13118 reloc_inplace
= TRUE
;
13120 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13124 reloc_inplace
= TRUE
;
13128 static unsigned int prev_reloc
= 0;
13130 if (reloc_type
!= prev_reloc
)
13131 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13132 reloc_type
, printable_section_name (filedata
, section
));
13133 prev_reloc
= reloc_type
;
13138 rloc
= start
+ rp
->r_offset
;
13139 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
13141 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13142 (unsigned long) rp
->r_offset
,
13143 printable_section_name (filedata
, section
));
13148 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13149 if (sym_index
>= num_syms
)
13151 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13152 sym_index
, printable_section_name (filedata
, section
));
13156 sym
= symtab
+ sym_index
;
13158 /* If the reloc has a symbol associated with it,
13159 make sure that it is of an appropriate type.
13161 Relocations against symbols without type can happen.
13162 Gcc -feliminate-dwarf2-dups may generate symbols
13163 without type for debug info.
13165 Icc generates relocations against function symbols
13166 instead of local labels.
13168 Relocations against object symbols can happen, eg when
13169 referencing a global array. For an example of this see
13170 the _clz.o binary in libgcc.a. */
13172 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13173 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13175 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13176 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13177 printable_section_name (filedata
, relsec
),
13178 (long int)(rp
- relocs
));
13185 addend
+= rp
->r_addend
;
13186 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13187 partial_inplace. */
13189 || (filedata
->file_header
.e_machine
== EM_XTENSA
13190 && reloc_type
== 1)
13191 || ((filedata
->file_header
.e_machine
== EM_PJ
13192 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13193 && reloc_type
== 1)
13194 || ((filedata
->file_header
.e_machine
== EM_D30V
13195 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13196 && reloc_type
== 12)
13199 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13200 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13202 addend
+= byte_get (rloc
, reloc_size
);
13205 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13206 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13208 /* On HPPA, all pc-relative relocations are biased by 8. */
13209 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13211 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13214 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13215 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13217 if (reloc_subtract
)
13218 addend
-= sym
->st_value
;
13220 addend
+= sym
->st_value
;
13221 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13222 byte_put (rloc
, addend
, reloc_size
);
13224 else if (reloc_subtract
)
13225 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13227 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13231 /* Let the target specific reloc processing code know that
13232 we have finished with these relocs. */
13233 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13237 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13238 * num_relocs_return
= num_relocs
;
13249 #ifdef SUPPORT_DISASSEMBLY
13251 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13253 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13255 /* FIXME: XXX -- to be done --- XXX */
13261 /* Reads in the contents of SECTION from FILE, returning a pointer
13262 to a malloc'ed buffer or NULL if something went wrong. */
13265 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13267 bfd_size_type num_bytes
= section
->sh_size
;
13269 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13271 printf (_("Section '%s' has no data to dump.\n"),
13272 printable_section_name (filedata
, section
));
13276 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13277 _("section contents"));
13280 /* Uncompresses a section that was compressed using zlib, in place. */
13283 uncompress_section_contents (unsigned char ** buffer
,
13284 dwarf_size_type uncompressed_size
,
13285 dwarf_size_type
* size
)
13287 dwarf_size_type compressed_size
= *size
;
13288 unsigned char * compressed_buffer
= *buffer
;
13289 unsigned char * uncompressed_buffer
;
13293 /* It is possible the section consists of several compressed
13294 buffers concatenated together, so we uncompress in a loop. */
13295 /* PR 18313: The state field in the z_stream structure is supposed
13296 to be invisible to the user (ie us), but some compilers will
13297 still complain about it being used without initialisation. So
13298 we first zero the entire z_stream structure and then set the fields
13300 memset (& strm
, 0, sizeof strm
);
13301 strm
.avail_in
= compressed_size
;
13302 strm
.next_in
= (Bytef
*) compressed_buffer
;
13303 strm
.avail_out
= uncompressed_size
;
13304 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13306 rc
= inflateInit (& strm
);
13307 while (strm
.avail_in
> 0)
13311 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13312 + (uncompressed_size
- strm
.avail_out
));
13313 rc
= inflate (&strm
, Z_FINISH
);
13314 if (rc
!= Z_STREAM_END
)
13316 rc
= inflateReset (& strm
);
13318 rc
= inflateEnd (& strm
);
13320 || strm
.avail_out
!= 0)
13323 *buffer
= uncompressed_buffer
;
13324 *size
= uncompressed_size
;
13328 free (uncompressed_buffer
);
13329 /* Indicate decompression failure. */
13335 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13337 Elf_Internal_Shdr
* relsec
;
13338 bfd_size_type num_bytes
;
13339 unsigned char * data
;
13340 unsigned char * end
;
13341 unsigned char * real_start
;
13342 unsigned char * start
;
13343 bfd_boolean some_strings_shown
;
13345 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13347 /* PR 21820: Do not fail if the section was empty. */
13348 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13350 num_bytes
= section
->sh_size
;
13352 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13354 if (decompress_dumps
)
13356 dwarf_size_type new_size
= num_bytes
;
13357 dwarf_size_type uncompressed_size
= 0;
13359 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13361 Elf_Internal_Chdr chdr
;
13362 unsigned int compression_header_size
13363 = get_compression_header (& chdr
, (unsigned char *) start
,
13366 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13368 warn (_("section '%s' has unsupported compress type: %d\n"),
13369 printable_section_name (filedata
, section
), chdr
.ch_type
);
13372 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13374 warn (_("compressed section '%s' is corrupted\n"),
13375 printable_section_name (filedata
, section
));
13378 uncompressed_size
= chdr
.ch_size
;
13379 start
+= compression_header_size
;
13380 new_size
-= compression_header_size
;
13382 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13384 /* Read the zlib header. In this case, it should be "ZLIB"
13385 followed by the uncompressed section size, 8 bytes in
13386 big-endian order. */
13387 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13388 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13389 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13390 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13391 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13392 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13393 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13394 uncompressed_size
+= start
[11];
13399 if (uncompressed_size
)
13401 if (uncompress_section_contents (& start
,
13402 uncompressed_size
, & new_size
))
13403 num_bytes
= new_size
;
13406 error (_("Unable to decompress section %s\n"),
13407 printable_section_name (filedata
, section
));
13412 start
= real_start
;
13415 /* If the section being dumped has relocations against it the user might
13416 be expecting these relocations to have been applied. Check for this
13417 case and issue a warning message in order to avoid confusion.
13418 FIXME: Maybe we ought to have an option that dumps a section with
13419 relocs applied ? */
13420 for (relsec
= filedata
->section_headers
;
13421 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13424 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13425 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13426 || filedata
->section_headers
+ relsec
->sh_info
!= section
13427 || relsec
->sh_size
== 0
13428 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13431 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13436 end
= start
+ num_bytes
;
13437 some_strings_shown
= FALSE
;
13441 while (!ISPRINT (* data
))
13442 if (++ data
>= end
)
13447 size_t maxlen
= end
- data
;
13450 /* PR 11128: Use two separate invocations in order to work
13451 around bugs in the Solaris 8 implementation of printf. */
13452 printf (" [%6tx] ", data
- start
);
13454 printf (" [%6Ix] ", (size_t) (data
- start
));
13458 print_symbol ((int) maxlen
, (const char *) data
);
13460 data
+= strnlen ((const char *) data
, maxlen
);
13464 printf (_("<corrupt>\n"));
13467 some_strings_shown
= TRUE
;
13471 if (! some_strings_shown
)
13472 printf (_(" No strings found in this section."));
13481 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13482 Filedata
* filedata
,
13483 bfd_boolean relocate
)
13485 Elf_Internal_Shdr
* relsec
;
13486 bfd_size_type bytes
;
13487 bfd_size_type section_size
;
13489 unsigned char * data
;
13490 unsigned char * real_start
;
13491 unsigned char * start
;
13493 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13495 /* PR 21820: Do not fail if the section was empty. */
13496 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13498 section_size
= section
->sh_size
;
13500 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13502 if (decompress_dumps
)
13504 dwarf_size_type new_size
= section_size
;
13505 dwarf_size_type uncompressed_size
= 0;
13507 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13509 Elf_Internal_Chdr chdr
;
13510 unsigned int compression_header_size
13511 = get_compression_header (& chdr
, start
, section_size
);
13513 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13515 warn (_("section '%s' has unsupported compress type: %d\n"),
13516 printable_section_name (filedata
, section
), chdr
.ch_type
);
13519 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13521 warn (_("compressed section '%s' is corrupted\n"),
13522 printable_section_name (filedata
, section
));
13525 uncompressed_size
= chdr
.ch_size
;
13526 start
+= compression_header_size
;
13527 new_size
-= compression_header_size
;
13529 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13531 /* Read the zlib header. In this case, it should be "ZLIB"
13532 followed by the uncompressed section size, 8 bytes in
13533 big-endian order. */
13534 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13535 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13536 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13537 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13538 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13539 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13540 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13541 uncompressed_size
+= start
[11];
13546 if (uncompressed_size
)
13548 if (uncompress_section_contents (& start
, uncompressed_size
,
13551 section_size
= new_size
;
13555 error (_("Unable to decompress section %s\n"),
13556 printable_section_name (filedata
, section
));
13557 /* FIXME: Print the section anyway ? */
13562 start
= real_start
;
13567 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13572 /* If the section being dumped has relocations against it the user might
13573 be expecting these relocations to have been applied. Check for this
13574 case and issue a warning message in order to avoid confusion.
13575 FIXME: Maybe we ought to have an option that dumps a section with
13576 relocs applied ? */
13577 for (relsec
= filedata
->section_headers
;
13578 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13581 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13582 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13583 || filedata
->section_headers
+ relsec
->sh_info
!= section
13584 || relsec
->sh_size
== 0
13585 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13588 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13593 addr
= section
->sh_addr
;
13594 bytes
= section_size
;
13603 lbytes
= (bytes
> 16 ? 16 : bytes
);
13605 printf (" 0x%8.8lx ", (unsigned long) addr
);
13607 for (j
= 0; j
< 16; j
++)
13610 printf ("%2.2x", data
[j
]);
13618 for (j
= 0; j
< lbytes
; j
++)
13621 if (k
>= ' ' && k
< 0x7f)
13641 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13642 const Elf_Internal_Shdr
* sec
,
13645 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13647 Filedata
* filedata
= (Filedata
*) data
;
13649 if (section
->start
!= NULL
)
13651 /* If it is already loaded, do nothing. */
13652 if (streq (section
->filename
, filedata
->file_name
))
13654 free (section
->start
);
13657 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13658 section
->address
= sec
->sh_addr
;
13659 section
->user_data
= NULL
;
13660 section
->filename
= filedata
->file_name
;
13661 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13663 sec
->sh_size
, buf
);
13664 if (section
->start
== NULL
)
13668 unsigned char *start
= section
->start
;
13669 dwarf_size_type size
= sec
->sh_size
;
13670 dwarf_size_type uncompressed_size
= 0;
13672 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13674 Elf_Internal_Chdr chdr
;
13675 unsigned int compression_header_size
;
13677 if (size
< (is_32bit_elf
13678 ? sizeof (Elf32_External_Chdr
)
13679 : sizeof (Elf64_External_Chdr
)))
13681 warn (_("compressed section %s is too small to contain a compression header"),
13686 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13688 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13690 warn (_("section '%s' has unsupported compress type: %d\n"),
13691 section
->name
, chdr
.ch_type
);
13694 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13696 warn (_("compressed section '%s' is corrupted\n"),
13700 uncompressed_size
= chdr
.ch_size
;
13701 start
+= compression_header_size
;
13702 size
-= compression_header_size
;
13704 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13706 /* Read the zlib header. In this case, it should be "ZLIB"
13707 followed by the uncompressed section size, 8 bytes in
13708 big-endian order. */
13709 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13710 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13711 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13712 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13713 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13714 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13715 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13716 uncompressed_size
+= start
[11];
13721 if (uncompressed_size
)
13723 if (uncompress_section_contents (&start
, uncompressed_size
,
13726 /* Free the compressed buffer, update the section buffer
13727 and the section size if uncompress is successful. */
13728 free (section
->start
);
13729 section
->start
= start
;
13733 error (_("Unable to decompress section %s\n"),
13734 printable_section_name (filedata
, sec
));
13739 section
->size
= size
;
13742 if (section
->start
== NULL
)
13745 if (debug_displays
[debug
].relocate
)
13747 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13748 & section
->reloc_info
, & section
->num_relocs
))
13753 section
->reloc_info
= NULL
;
13754 section
->num_relocs
= 0;
13760 /* If this is not NULL, load_debug_section will only look for sections
13761 within the list of sections given here. */
13762 static unsigned int * section_subset
= NULL
;
13765 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13767 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13768 Elf_Internal_Shdr
* sec
;
13769 Filedata
* filedata
= (Filedata
*) data
;
13771 /* Without section headers we cannot find any sections. */
13772 if (filedata
->section_headers
== NULL
)
13775 if (filedata
->string_table
== NULL
13776 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13777 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13779 Elf_Internal_Shdr
* strs
;
13781 /* Read in the string table, so that we have section names to scan. */
13782 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13784 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13786 filedata
->string_table
13787 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13788 1, strs
->sh_size
, _("string table"));
13790 filedata
->string_table_length
13791 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13795 /* Locate the debug section. */
13796 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13798 section
->name
= section
->uncompressed_name
;
13801 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13803 section
->name
= section
->compressed_name
;
13808 /* If we're loading from a subset of sections, and we've loaded
13809 a section matching this name before, it's likely that it's a
13811 if (section_subset
!= NULL
)
13812 free_debug_section (debug
);
13814 return load_specific_debug_section (debug
, sec
, data
);
13818 free_debug_section (enum dwarf_section_display_enum debug
)
13820 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13822 if (section
->start
== NULL
)
13825 free ((char *) section
->start
);
13826 section
->start
= NULL
;
13827 section
->address
= 0;
13832 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13834 char * name
= SECTION_NAME (section
);
13835 const char * print_name
= printable_section_name (filedata
, section
);
13836 bfd_size_type length
;
13837 bfd_boolean result
= TRUE
;
13840 length
= section
->sh_size
;
13843 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13846 if (section
->sh_type
== SHT_NOBITS
)
13848 /* There is no point in dumping the contents of a debugging section
13849 which has the NOBITS type - the bits in the file will be random.
13850 This can happen when a file containing a .eh_frame section is
13851 stripped with the --only-keep-debug command line option. */
13852 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13857 if (const_strneq (name
, ".gnu.linkonce.wi."))
13858 name
= ".debug_info";
13860 /* See if we know how to display the contents of this section. */
13861 for (i
= 0; i
< max
; i
++)
13863 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13864 struct dwarf_section_display
* display
= debug_displays
+ i
;
13865 struct dwarf_section
* sec
= & display
->section
;
13867 if (streq (sec
->uncompressed_name
, name
)
13868 || (id
== line
&& const_strneq (name
, ".debug_line."))
13869 || streq (sec
->compressed_name
, name
))
13871 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13874 free_debug_section (id
);
13876 if (i
== line
&& const_strneq (name
, ".debug_line."))
13878 else if (streq (sec
->uncompressed_name
, name
))
13879 sec
->name
= sec
->uncompressed_name
;
13881 sec
->name
= sec
->compressed_name
;
13883 if (load_specific_debug_section (id
, section
, filedata
))
13885 /* If this debug section is part of a CU/TU set in a .dwp file,
13886 restrict load_debug_section to the sections in that set. */
13887 section_subset
= find_cu_tu_set (filedata
, shndx
);
13889 result
&= display
->display (sec
, filedata
);
13891 section_subset
= NULL
;
13893 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13894 free_debug_section (id
);
13902 printf (_("Unrecognized debug section: %s\n"), print_name
);
13909 /* Set DUMP_SECTS for all sections where dumps were requested
13910 based on section name. */
13913 initialise_dumps_byname (Filedata
* filedata
)
13915 struct dump_list_entry
* cur
;
13917 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13920 bfd_boolean any
= FALSE
;
13922 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13923 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13925 request_dump_bynumber (filedata
, i
, cur
->type
);
13930 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13936 process_section_contents (Filedata
* filedata
)
13938 Elf_Internal_Shdr
* section
;
13940 bfd_boolean res
= TRUE
;
13945 initialise_dumps_byname (filedata
);
13947 for (i
= 0, section
= filedata
->section_headers
;
13948 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13951 dump_type dump
= filedata
->dump_sects
[i
];
13953 #ifdef SUPPORT_DISASSEMBLY
13954 if (dump
& DISASS_DUMP
)
13956 if (! disassemble_section (section
, filedata
))
13960 if (dump
& HEX_DUMP
)
13962 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13966 if (dump
& RELOC_DUMP
)
13968 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13972 if (dump
& STRING_DUMP
)
13974 if (! dump_section_as_strings (section
, filedata
))
13978 if (dump
& DEBUG_DUMP
)
13980 if (! display_debug_section (i
, section
, filedata
))
13985 /* Check to see if the user requested a
13986 dump of a section that does not exist. */
13987 while (i
< filedata
->num_dump_sects
)
13989 if (filedata
->dump_sects
[i
])
13991 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14001 process_mips_fpe_exception (int mask
)
14005 bfd_boolean first
= TRUE
;
14007 if (mask
& OEX_FPU_INEX
)
14008 fputs ("INEX", stdout
), first
= FALSE
;
14009 if (mask
& OEX_FPU_UFLO
)
14010 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14011 if (mask
& OEX_FPU_OFLO
)
14012 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14013 if (mask
& OEX_FPU_DIV0
)
14014 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14015 if (mask
& OEX_FPU_INVAL
)
14016 printf ("%sINVAL", first
? "" : "|");
14019 fputs ("0", stdout
);
14022 /* Display's the value of TAG at location P. If TAG is
14023 greater than 0 it is assumed to be an unknown tag, and
14024 a message is printed to this effect. Otherwise it is
14025 assumed that a message has already been printed.
14027 If the bottom bit of TAG is set it assumed to have a
14028 string value, otherwise it is assumed to have an integer
14031 Returns an updated P pointing to the first unread byte
14032 beyond the end of TAG's value.
14034 Reads at or beyond END will not be made. */
14036 static unsigned char *
14037 display_tag_value (signed int tag
,
14039 const unsigned char * const end
)
14044 printf (" Tag_unknown_%d: ", tag
);
14048 warn (_("<corrupt tag>\n"));
14052 /* PR 17531 file: 027-19978-0.004. */
14053 size_t maxlen
= (end
- p
) - 1;
14058 print_symbol ((int) maxlen
, (const char *) p
);
14059 p
+= strnlen ((char *) p
, maxlen
) + 1;
14063 printf (_("<corrupt string tag>"));
14064 p
= (unsigned char *) end
;
14072 val
= read_uleb128 (p
, &len
, end
);
14074 printf ("%ld (0x%lx)\n", val
, val
);
14081 /* ARC ABI attributes section. */
14083 static unsigned char *
14084 display_arc_attribute (unsigned char * p
,
14085 const unsigned char * const end
)
14091 tag
= read_uleb128 (p
, &len
, end
);
14096 case Tag_ARC_PCS_config
:
14097 val
= read_uleb128 (p
, &len
, end
);
14099 printf (" Tag_ARC_PCS_config: ");
14103 printf (_("Absent/Non standard\n"));
14106 printf (_("Bare metal/mwdt\n"));
14109 printf (_("Bare metal/newlib\n"));
14112 printf (_("Linux/uclibc\n"));
14115 printf (_("Linux/glibc\n"));
14118 printf (_("Unknown\n"));
14123 case Tag_ARC_CPU_base
:
14124 val
= read_uleb128 (p
, &len
, end
);
14126 printf (" Tag_ARC_CPU_base: ");
14131 printf (_("Absent\n"));
14133 case TAG_CPU_ARC6xx
:
14134 printf ("ARC6xx\n");
14136 case TAG_CPU_ARC7xx
:
14137 printf ("ARC7xx\n");
14139 case TAG_CPU_ARCEM
:
14140 printf ("ARCEM\n");
14142 case TAG_CPU_ARCHS
:
14143 printf ("ARCHS\n");
14148 case Tag_ARC_CPU_variation
:
14149 val
= read_uleb128 (p
, &len
, end
);
14151 printf (" Tag_ARC_CPU_variation: ");
14155 if (val
> 0 && val
< 16)
14156 printf ("Core%d\n", val
);
14158 printf ("Unknown\n");
14162 printf (_("Absent\n"));
14167 case Tag_ARC_CPU_name
:
14168 printf (" Tag_ARC_CPU_name: ");
14169 p
= display_tag_value (-1, p
, end
);
14172 case Tag_ARC_ABI_rf16
:
14173 val
= read_uleb128 (p
, &len
, end
);
14175 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14178 case Tag_ARC_ABI_osver
:
14179 val
= read_uleb128 (p
, &len
, end
);
14181 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14184 case Tag_ARC_ABI_pic
:
14185 case Tag_ARC_ABI_sda
:
14186 val
= read_uleb128 (p
, &len
, end
);
14188 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14189 : " Tag_ARC_ABI_pic: ");
14193 printf (_("Absent\n"));
14202 printf (_("Unknown\n"));
14207 case Tag_ARC_ABI_tls
:
14208 val
= read_uleb128 (p
, &len
, end
);
14210 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14213 case Tag_ARC_ABI_enumsize
:
14214 val
= read_uleb128 (p
, &len
, end
);
14216 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14220 case Tag_ARC_ABI_exceptions
:
14221 val
= read_uleb128 (p
, &len
, end
);
14223 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14227 case Tag_ARC_ABI_double_size
:
14228 val
= read_uleb128 (p
, &len
, end
);
14230 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14233 case Tag_ARC_ISA_config
:
14234 printf (" Tag_ARC_ISA_config: ");
14235 p
= display_tag_value (-1, p
, end
);
14238 case Tag_ARC_ISA_apex
:
14239 printf (" Tag_ARC_ISA_apex: ");
14240 p
= display_tag_value (-1, p
, end
);
14243 case Tag_ARC_ISA_mpy_option
:
14244 val
= read_uleb128 (p
, &len
, end
);
14246 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14250 return display_tag_value (tag
& 1, p
, end
);
14256 /* ARM EABI attributes section. */
14261 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14263 const char ** table
;
14264 } arm_attr_public_tag
;
14266 static const char * arm_attr_tag_CPU_arch
[] =
14267 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14268 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14270 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14271 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14272 {"No", "Thumb-1", "Thumb-2", "Yes"};
14273 static const char * arm_attr_tag_FP_arch
[] =
14274 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14275 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14276 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14277 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14278 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14279 "NEON for ARMv8.1"};
14280 static const char * arm_attr_tag_PCS_config
[] =
14281 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14282 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14283 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14284 {"V6", "SB", "TLS", "Unused"};
14285 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14286 {"Absolute", "PC-relative", "SB-relative", "None"};
14287 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14288 {"Absolute", "PC-relative", "None"};
14289 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14290 {"None", "direct", "GOT-indirect"};
14291 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14292 {"None", "??? 1", "2", "??? 3", "4"};
14293 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14294 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14295 {"Unused", "Needed", "Sign only"};
14296 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14297 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14298 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14299 {"Unused", "Finite", "RTABI", "IEEE 754"};
14300 static const char * arm_attr_tag_ABI_enum_size
[] =
14301 {"Unused", "small", "int", "forced to int"};
14302 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14303 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14304 static const char * arm_attr_tag_ABI_VFP_args
[] =
14305 {"AAPCS", "VFP registers", "custom", "compatible"};
14306 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14307 {"AAPCS", "WMMX registers", "custom"};
14308 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14309 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14310 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14311 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14312 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14313 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14314 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14315 static const char * arm_attr_tag_FP_HP_extension
[] =
14316 {"Not Allowed", "Allowed"};
14317 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14318 {"None", "IEEE 754", "Alternative Format"};
14319 static const char * arm_attr_tag_DSP_extension
[] =
14320 {"Follow architecture", "Allowed"};
14321 static const char * arm_attr_tag_MPextension_use
[] =
14322 {"Not Allowed", "Allowed"};
14323 static const char * arm_attr_tag_DIV_use
[] =
14324 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14325 "Allowed in v7-A with integer division extension"};
14326 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14327 static const char * arm_attr_tag_Virtualization_use
[] =
14328 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14329 "TrustZone and Virtualization Extensions"};
14330 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14331 {"Not Allowed", "Allowed"};
14333 #define LOOKUP(id, name) \
14334 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14335 static arm_attr_public_tag arm_attr_public_tags
[] =
14337 {4, "CPU_raw_name", 1, NULL
},
14338 {5, "CPU_name", 1, NULL
},
14339 LOOKUP(6, CPU_arch
),
14340 {7, "CPU_arch_profile", 0, NULL
},
14341 LOOKUP(8, ARM_ISA_use
),
14342 LOOKUP(9, THUMB_ISA_use
),
14343 LOOKUP(10, FP_arch
),
14344 LOOKUP(11, WMMX_arch
),
14345 LOOKUP(12, Advanced_SIMD_arch
),
14346 LOOKUP(13, PCS_config
),
14347 LOOKUP(14, ABI_PCS_R9_use
),
14348 LOOKUP(15, ABI_PCS_RW_data
),
14349 LOOKUP(16, ABI_PCS_RO_data
),
14350 LOOKUP(17, ABI_PCS_GOT_use
),
14351 LOOKUP(18, ABI_PCS_wchar_t
),
14352 LOOKUP(19, ABI_FP_rounding
),
14353 LOOKUP(20, ABI_FP_denormal
),
14354 LOOKUP(21, ABI_FP_exceptions
),
14355 LOOKUP(22, ABI_FP_user_exceptions
),
14356 LOOKUP(23, ABI_FP_number_model
),
14357 {24, "ABI_align_needed", 0, NULL
},
14358 {25, "ABI_align_preserved", 0, NULL
},
14359 LOOKUP(26, ABI_enum_size
),
14360 LOOKUP(27, ABI_HardFP_use
),
14361 LOOKUP(28, ABI_VFP_args
),
14362 LOOKUP(29, ABI_WMMX_args
),
14363 LOOKUP(30, ABI_optimization_goals
),
14364 LOOKUP(31, ABI_FP_optimization_goals
),
14365 {32, "compatibility", 0, NULL
},
14366 LOOKUP(34, CPU_unaligned_access
),
14367 LOOKUP(36, FP_HP_extension
),
14368 LOOKUP(38, ABI_FP_16bit_format
),
14369 LOOKUP(42, MPextension_use
),
14370 LOOKUP(44, DIV_use
),
14371 LOOKUP(46, DSP_extension
),
14372 {64, "nodefaults", 0, NULL
},
14373 {65, "also_compatible_with", 0, NULL
},
14374 LOOKUP(66, T2EE_use
),
14375 {67, "conformance", 1, NULL
},
14376 LOOKUP(68, Virtualization_use
),
14377 LOOKUP(70, MPextension_use_legacy
)
14381 static unsigned char *
14382 display_arm_attribute (unsigned char * p
,
14383 const unsigned char * const end
)
14388 arm_attr_public_tag
* attr
;
14392 tag
= read_uleb128 (p
, &len
, end
);
14395 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14397 if (arm_attr_public_tags
[i
].tag
== tag
)
14399 attr
= &arm_attr_public_tags
[i
];
14406 printf (" Tag_%s: ", attr
->name
);
14407 switch (attr
->type
)
14412 case 7: /* Tag_CPU_arch_profile. */
14413 val
= read_uleb128 (p
, &len
, end
);
14417 case 0: printf (_("None\n")); break;
14418 case 'A': printf (_("Application\n")); break;
14419 case 'R': printf (_("Realtime\n")); break;
14420 case 'M': printf (_("Microcontroller\n")); break;
14421 case 'S': printf (_("Application or Realtime\n")); break;
14422 default: printf ("??? (%d)\n", val
); break;
14426 case 24: /* Tag_align_needed. */
14427 val
= read_uleb128 (p
, &len
, end
);
14431 case 0: printf (_("None\n")); break;
14432 case 1: printf (_("8-byte\n")); break;
14433 case 2: printf (_("4-byte\n")); break;
14434 case 3: printf ("??? 3\n"); break;
14437 printf (_("8-byte and up to %d-byte extended\n"),
14440 printf ("??? (%d)\n", val
);
14445 case 25: /* Tag_align_preserved. */
14446 val
= read_uleb128 (p
, &len
, end
);
14450 case 0: printf (_("None\n")); break;
14451 case 1: printf (_("8-byte, except leaf SP\n")); break;
14452 case 2: printf (_("8-byte\n")); break;
14453 case 3: printf ("??? 3\n"); break;
14456 printf (_("8-byte and up to %d-byte extended\n"),
14459 printf ("??? (%d)\n", val
);
14464 case 32: /* Tag_compatibility. */
14466 val
= read_uleb128 (p
, &len
, end
);
14468 printf (_("flag = %d, vendor = "), val
);
14471 size_t maxlen
= (end
- p
) - 1;
14473 print_symbol ((int) maxlen
, (const char *) p
);
14474 p
+= strnlen ((char *) p
, maxlen
) + 1;
14478 printf (_("<corrupt>"));
14479 p
= (unsigned char *) end
;
14485 case 64: /* Tag_nodefaults. */
14486 /* PR 17531: file: 001-505008-0.01. */
14489 printf (_("True\n"));
14492 case 65: /* Tag_also_compatible_with. */
14493 val
= read_uleb128 (p
, &len
, end
);
14495 if (val
== 6 /* Tag_CPU_arch. */)
14497 val
= read_uleb128 (p
, &len
, end
);
14499 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14500 printf ("??? (%d)\n", val
);
14502 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14506 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14511 printf (_("<unknown: %d>\n"), tag
);
14517 return display_tag_value (-1, p
, end
);
14519 return display_tag_value (0, p
, end
);
14522 assert (attr
->type
& 0x80);
14523 val
= read_uleb128 (p
, &len
, end
);
14525 type
= attr
->type
& 0x7f;
14527 printf ("??? (%d)\n", val
);
14529 printf ("%s\n", attr
->table
[val
]);
14534 return display_tag_value (tag
, p
, end
);
14537 static unsigned char *
14538 display_gnu_attribute (unsigned char * p
,
14539 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14540 const unsigned char * const end
)
14546 tag
= read_uleb128 (p
, &len
, end
);
14549 /* Tag_compatibility is the only generic GNU attribute defined at
14553 val
= read_uleb128 (p
, &len
, end
);
14556 printf (_("flag = %d, vendor = "), val
);
14559 printf (_("<corrupt>\n"));
14560 warn (_("corrupt vendor attribute\n"));
14566 size_t maxlen
= (end
- p
) - 1;
14568 print_symbol ((int) maxlen
, (const char *) p
);
14569 p
+= strnlen ((char *) p
, maxlen
) + 1;
14573 printf (_("<corrupt>"));
14574 p
= (unsigned char *) end
;
14581 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14582 return display_proc_gnu_attribute (p
, tag
, end
);
14584 return display_tag_value (tag
, p
, end
);
14587 static unsigned char *
14588 display_power_gnu_attribute (unsigned char * p
,
14590 const unsigned char * const end
)
14595 if (tag
== Tag_GNU_Power_ABI_FP
)
14597 val
= read_uleb128 (p
, &len
, end
);
14599 printf (" Tag_GNU_Power_ABI_FP: ");
14602 printf (_("<corrupt>\n"));
14607 printf ("(%#x), ", val
);
14612 printf (_("unspecified hard/soft float, "));
14615 printf (_("hard float, "));
14618 printf (_("soft float, "));
14621 printf (_("single-precision hard float, "));
14628 printf (_("unspecified long double\n"));
14631 printf (_("128-bit IBM long double\n"));
14634 printf (_("64-bit long double\n"));
14637 printf (_("128-bit IEEE long double\n"));
14643 if (tag
== Tag_GNU_Power_ABI_Vector
)
14645 val
= read_uleb128 (p
, &len
, end
);
14647 printf (" Tag_GNU_Power_ABI_Vector: ");
14650 printf (_("<corrupt>\n"));
14655 printf ("(%#x), ", val
);
14660 printf (_("unspecified\n"));
14663 printf (_("generic\n"));
14666 printf ("AltiVec\n");
14675 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14677 val
= read_uleb128 (p
, &len
, end
);
14679 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14682 printf (_("<corrupt>\n"));
14687 printf ("(%#x), ", val
);
14692 printf (_("unspecified\n"));
14695 printf ("r3/r4\n");
14698 printf (_("memory\n"));
14707 return display_tag_value (tag
& 1, p
, end
);
14710 static unsigned char *
14711 display_s390_gnu_attribute (unsigned char * p
,
14713 const unsigned char * const end
)
14718 if (tag
== Tag_GNU_S390_ABI_Vector
)
14720 val
= read_uleb128 (p
, &len
, end
);
14722 printf (" Tag_GNU_S390_ABI_Vector: ");
14727 printf (_("any\n"));
14730 printf (_("software\n"));
14733 printf (_("hardware\n"));
14736 printf ("??? (%d)\n", val
);
14742 return display_tag_value (tag
& 1, p
, end
);
14746 display_sparc_hwcaps (unsigned int mask
)
14750 bfd_boolean first
= TRUE
;
14752 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14753 fputs ("mul32", stdout
), first
= FALSE
;
14754 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14755 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14756 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14757 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14758 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14759 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14760 if (mask
& ELF_SPARC_HWCAP_POPC
)
14761 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14762 if (mask
& ELF_SPARC_HWCAP_VIS
)
14763 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14764 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14765 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14766 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14767 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14768 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14769 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14770 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14771 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14772 if (mask
& ELF_SPARC_HWCAP_HPC
)
14773 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14774 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14775 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14776 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14777 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14778 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14779 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14780 if (mask
& ELF_SPARC_HWCAP_IMA
)
14781 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14782 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14783 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14786 fputc ('0', stdout
);
14787 fputc ('\n', stdout
);
14791 display_sparc_hwcaps2 (unsigned int mask
)
14795 bfd_boolean first
= TRUE
;
14797 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14798 fputs ("fjathplus", stdout
), first
= FALSE
;
14799 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14800 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14801 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14802 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14803 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14804 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14805 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14806 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14807 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14808 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14809 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14810 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14811 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14812 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14813 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14814 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14815 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14816 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14817 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14818 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14821 fputc ('0', stdout
);
14822 fputc ('\n', stdout
);
14825 static unsigned char *
14826 display_sparc_gnu_attribute (unsigned char * p
,
14828 const unsigned char * const end
)
14833 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14835 val
= read_uleb128 (p
, &len
, end
);
14837 printf (" Tag_GNU_Sparc_HWCAPS: ");
14838 display_sparc_hwcaps (val
);
14841 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14843 val
= read_uleb128 (p
, &len
, end
);
14845 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14846 display_sparc_hwcaps2 (val
);
14850 return display_tag_value (tag
, p
, end
);
14854 print_mips_fp_abi_value (unsigned int val
)
14858 case Val_GNU_MIPS_ABI_FP_ANY
:
14859 printf (_("Hard or soft float\n"));
14861 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14862 printf (_("Hard float (double precision)\n"));
14864 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14865 printf (_("Hard float (single precision)\n"));
14867 case Val_GNU_MIPS_ABI_FP_SOFT
:
14868 printf (_("Soft float\n"));
14870 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14871 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14873 case Val_GNU_MIPS_ABI_FP_XX
:
14874 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14876 case Val_GNU_MIPS_ABI_FP_64
:
14877 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14879 case Val_GNU_MIPS_ABI_FP_64A
:
14880 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14882 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14883 printf (_("NaN 2008 compatibility\n"));
14886 printf ("??? (%d)\n", val
);
14891 static unsigned char *
14892 display_mips_gnu_attribute (unsigned char * p
,
14894 const unsigned char * const end
)
14896 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14901 val
= read_uleb128 (p
, &len
, end
);
14903 printf (" Tag_GNU_MIPS_ABI_FP: ");
14905 print_mips_fp_abi_value (val
);
14910 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14915 val
= read_uleb128 (p
, &len
, end
);
14917 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14921 case Val_GNU_MIPS_ABI_MSA_ANY
:
14922 printf (_("Any MSA or not\n"));
14924 case Val_GNU_MIPS_ABI_MSA_128
:
14925 printf (_("128-bit MSA\n"));
14928 printf ("??? (%d)\n", val
);
14934 return display_tag_value (tag
& 1, p
, end
);
14937 static unsigned char *
14938 display_tic6x_attribute (unsigned char * p
,
14939 const unsigned char * const end
)
14945 tag
= read_uleb128 (p
, &len
, end
);
14951 val
= read_uleb128 (p
, &len
, end
);
14953 printf (" Tag_ISA: ");
14957 case C6XABI_Tag_ISA_none
:
14958 printf (_("None\n"));
14960 case C6XABI_Tag_ISA_C62X
:
14963 case C6XABI_Tag_ISA_C67X
:
14966 case C6XABI_Tag_ISA_C67XP
:
14967 printf ("C67x+\n");
14969 case C6XABI_Tag_ISA_C64X
:
14972 case C6XABI_Tag_ISA_C64XP
:
14973 printf ("C64x+\n");
14975 case C6XABI_Tag_ISA_C674X
:
14976 printf ("C674x\n");
14979 printf ("??? (%d)\n", val
);
14984 case Tag_ABI_wchar_t
:
14985 val
= read_uleb128 (p
, &len
, end
);
14987 printf (" Tag_ABI_wchar_t: ");
14991 printf (_("Not used\n"));
14994 printf (_("2 bytes\n"));
14997 printf (_("4 bytes\n"));
15000 printf ("??? (%d)\n", val
);
15005 case Tag_ABI_stack_align_needed
:
15006 val
= read_uleb128 (p
, &len
, end
);
15008 printf (" Tag_ABI_stack_align_needed: ");
15012 printf (_("8-byte\n"));
15015 printf (_("16-byte\n"));
15018 printf ("??? (%d)\n", val
);
15023 case Tag_ABI_stack_align_preserved
:
15024 val
= read_uleb128 (p
, &len
, end
);
15026 printf (" Tag_ABI_stack_align_preserved: ");
15030 printf (_("8-byte\n"));
15033 printf (_("16-byte\n"));
15036 printf ("??? (%d)\n", val
);
15042 val
= read_uleb128 (p
, &len
, end
);
15044 printf (" Tag_ABI_DSBT: ");
15048 printf (_("DSBT addressing not used\n"));
15051 printf (_("DSBT addressing used\n"));
15054 printf ("??? (%d)\n", val
);
15060 val
= read_uleb128 (p
, &len
, end
);
15062 printf (" Tag_ABI_PID: ");
15066 printf (_("Data addressing position-dependent\n"));
15069 printf (_("Data addressing position-independent, GOT near DP\n"));
15072 printf (_("Data addressing position-independent, GOT far from DP\n"));
15075 printf ("??? (%d)\n", val
);
15081 val
= read_uleb128 (p
, &len
, end
);
15083 printf (" Tag_ABI_PIC: ");
15087 printf (_("Code addressing position-dependent\n"));
15090 printf (_("Code addressing position-independent\n"));
15093 printf ("??? (%d)\n", val
);
15098 case Tag_ABI_array_object_alignment
:
15099 val
= read_uleb128 (p
, &len
, end
);
15101 printf (" Tag_ABI_array_object_alignment: ");
15105 printf (_("8-byte\n"));
15108 printf (_("4-byte\n"));
15111 printf (_("16-byte\n"));
15114 printf ("??? (%d)\n", val
);
15119 case Tag_ABI_array_object_align_expected
:
15120 val
= read_uleb128 (p
, &len
, end
);
15122 printf (" Tag_ABI_array_object_align_expected: ");
15126 printf (_("8-byte\n"));
15129 printf (_("4-byte\n"));
15132 printf (_("16-byte\n"));
15135 printf ("??? (%d)\n", val
);
15140 case Tag_ABI_compatibility
:
15142 val
= read_uleb128 (p
, &len
, end
);
15144 printf (" Tag_ABI_compatibility: ");
15145 printf (_("flag = %d, vendor = "), val
);
15148 size_t maxlen
= (end
- p
) - 1;
15150 print_symbol ((int) maxlen
, (const char *) p
);
15151 p
+= strnlen ((char *) p
, maxlen
) + 1;
15155 printf (_("<corrupt>"));
15156 p
= (unsigned char *) end
;
15162 case Tag_ABI_conformance
:
15164 printf (" Tag_ABI_conformance: \"");
15167 size_t maxlen
= (end
- p
) - 1;
15169 print_symbol ((int) maxlen
, (const char *) p
);
15170 p
+= strnlen ((char *) p
, maxlen
) + 1;
15174 printf (_("<corrupt>"));
15175 p
= (unsigned char *) end
;
15182 return display_tag_value (tag
, p
, end
);
15186 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15188 unsigned long addr
= 0;
15189 size_t bytes
= end
- p
;
15196 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15198 printf (" 0x%8.8lx ", addr
);
15200 for (j
= 0; j
< 16; j
++)
15203 printf ("%2.2x", p
[j
]);
15211 for (j
= 0; j
< lbytes
; j
++)
15214 if (k
>= ' ' && k
< 0x7f)
15230 static unsigned char *
15231 display_msp430x_attribute (unsigned char * p
,
15232 const unsigned char * const end
)
15238 tag
= read_uleb128 (p
, & len
, end
);
15243 case OFBA_MSPABI_Tag_ISA
:
15244 val
= read_uleb128 (p
, &len
, end
);
15246 printf (" Tag_ISA: ");
15249 case 0: printf (_("None\n")); break;
15250 case 1: printf (_("MSP430\n")); break;
15251 case 2: printf (_("MSP430X\n")); break;
15252 default: printf ("??? (%d)\n", val
); break;
15256 case OFBA_MSPABI_Tag_Code_Model
:
15257 val
= read_uleb128 (p
, &len
, end
);
15259 printf (" Tag_Code_Model: ");
15262 case 0: printf (_("None\n")); break;
15263 case 1: printf (_("Small\n")); break;
15264 case 2: printf (_("Large\n")); break;
15265 default: printf ("??? (%d)\n", val
); break;
15269 case OFBA_MSPABI_Tag_Data_Model
:
15270 val
= read_uleb128 (p
, &len
, end
);
15272 printf (" Tag_Data_Model: ");
15275 case 0: printf (_("None\n")); break;
15276 case 1: printf (_("Small\n")); break;
15277 case 2: printf (_("Large\n")); break;
15278 case 3: printf (_("Restricted Large\n")); break;
15279 default: printf ("??? (%d)\n", val
); break;
15284 printf (_(" <unknown tag %d>: "), tag
);
15291 size_t maxlen
= (end
- p
) - 1;
15293 print_symbol ((int) maxlen
, (const char *) p
);
15294 p
+= strnlen ((char *) p
, maxlen
) + 1;
15298 printf (_("<corrupt>"));
15299 p
= (unsigned char *) end
;
15305 val
= read_uleb128 (p
, &len
, end
);
15307 printf ("%d (0x%x)\n", val
, val
);
15317 process_attributes (Filedata
* filedata
,
15318 const char * public_name
,
15319 unsigned int proc_type
,
15320 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15321 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15323 Elf_Internal_Shdr
* sect
;
15325 bfd_boolean res
= TRUE
;
15327 /* Find the section header so that we get the size. */
15328 for (i
= 0, sect
= filedata
->section_headers
;
15329 i
< filedata
->file_header
.e_shnum
;
15332 unsigned char * contents
;
15335 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15338 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15339 sect
->sh_size
, _("attributes"));
15340 if (contents
== NULL
)
15347 /* The first character is the version of the attributes.
15348 Currently only version 1, (aka 'A') is recognised here. */
15351 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15356 bfd_vma section_len
;
15358 section_len
= sect
->sh_size
- 1;
15361 while (section_len
> 0)
15364 unsigned int namelen
;
15365 bfd_boolean public_section
;
15366 bfd_boolean gnu_section
;
15368 if (section_len
<= 4)
15370 error (_("Tag section ends prematurely\n"));
15374 attr_len
= byte_get (p
, 4);
15377 if (attr_len
> section_len
)
15379 error (_("Bad attribute length (%u > %u)\n"),
15380 (unsigned) attr_len
, (unsigned) section_len
);
15381 attr_len
= section_len
;
15384 /* PR 17531: file: 001-101425-0.004 */
15385 else if (attr_len
< 5)
15387 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15392 section_len
-= attr_len
;
15395 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15396 if (namelen
== 0 || namelen
>= attr_len
)
15398 error (_("Corrupt attribute section name\n"));
15403 printf (_("Attribute Section: "));
15404 print_symbol (INT_MAX
, (const char *) p
);
15407 if (public_name
&& streq ((char *) p
, public_name
))
15408 public_section
= TRUE
;
15410 public_section
= FALSE
;
15412 if (streq ((char *) p
, "gnu"))
15413 gnu_section
= TRUE
;
15415 gnu_section
= FALSE
;
15418 attr_len
-= namelen
;
15420 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15425 unsigned char * end
;
15427 /* PR binutils/17531: Safe handling of corrupt files. */
15430 error (_("Unused bytes at end of section\n"));
15437 size
= byte_get (p
, 4);
15438 if (size
> attr_len
)
15440 error (_("Bad subsection length (%u > %u)\n"),
15441 (unsigned) size
, (unsigned) attr_len
);
15445 /* PR binutils/17531: Safe handling of corrupt files. */
15448 error (_("Bad subsection length (%u < 6)\n"),
15456 end
= p
+ size
- 1;
15457 assert (end
<= contents
+ sect
->sh_size
);
15463 printf (_("File Attributes\n"));
15466 printf (_("Section Attributes:"));
15469 printf (_("Symbol Attributes:"));
15470 /* Fall through. */
15476 val
= read_uleb128 (p
, &j
, end
);
15480 printf (" %d", val
);
15485 printf (_("Unknown tag: %d\n"), tag
);
15486 public_section
= FALSE
;
15490 if (public_section
&& display_pub_attribute
!= NULL
)
15493 p
= display_pub_attribute (p
, end
);
15496 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15499 p
= display_gnu_attribute (p
,
15500 display_proc_gnu_attribute
,
15506 printf (_(" Unknown attribute:\n"));
15507 display_raw_attribute (p
, end
);
15522 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15523 Print the Address, Access and Initial fields of an entry at VMA ADDR
15524 and return the VMA of the next entry, or -1 if there was a problem.
15525 Does not read from DATA_END or beyond. */
15528 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15529 unsigned char * data_end
)
15532 print_vma (addr
, LONG_HEX
);
15534 if (addr
< pltgot
+ 0xfff0)
15535 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15537 printf ("%10s", "");
15540 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15544 unsigned char * from
= data
+ addr
- pltgot
;
15546 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15548 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15549 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15550 return (bfd_vma
) -1;
15554 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15555 print_vma (entry
, LONG_HEX
);
15558 return addr
+ (is_32bit_elf
? 4 : 8);
15561 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15562 PLTGOT. Print the Address and Initial fields of an entry at VMA
15563 ADDR and return the VMA of the next entry. */
15566 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15569 print_vma (addr
, LONG_HEX
);
15572 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15577 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15578 print_vma (entry
, LONG_HEX
);
15580 return addr
+ (is_32bit_elf
? 4 : 8);
15584 print_mips_ases (unsigned int mask
)
15586 if (mask
& AFL_ASE_DSP
)
15587 fputs ("\n\tDSP ASE", stdout
);
15588 if (mask
& AFL_ASE_DSPR2
)
15589 fputs ("\n\tDSP R2 ASE", stdout
);
15590 if (mask
& AFL_ASE_DSPR3
)
15591 fputs ("\n\tDSP R3 ASE", stdout
);
15592 if (mask
& AFL_ASE_EVA
)
15593 fputs ("\n\tEnhanced VA Scheme", stdout
);
15594 if (mask
& AFL_ASE_MCU
)
15595 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15596 if (mask
& AFL_ASE_MDMX
)
15597 fputs ("\n\tMDMX ASE", stdout
);
15598 if (mask
& AFL_ASE_MIPS3D
)
15599 fputs ("\n\tMIPS-3D ASE", stdout
);
15600 if (mask
& AFL_ASE_MT
)
15601 fputs ("\n\tMT ASE", stdout
);
15602 if (mask
& AFL_ASE_SMARTMIPS
)
15603 fputs ("\n\tSmartMIPS ASE", stdout
);
15604 if (mask
& AFL_ASE_VIRT
)
15605 fputs ("\n\tVZ ASE", stdout
);
15606 if (mask
& AFL_ASE_MSA
)
15607 fputs ("\n\tMSA ASE", stdout
);
15608 if (mask
& AFL_ASE_MIPS16
)
15609 fputs ("\n\tMIPS16 ASE", stdout
);
15610 if (mask
& AFL_ASE_MICROMIPS
)
15611 fputs ("\n\tMICROMIPS ASE", stdout
);
15612 if (mask
& AFL_ASE_XPA
)
15613 fputs ("\n\tXPA ASE", stdout
);
15614 if (mask
& AFL_ASE_MIPS16E2
)
15615 fputs ("\n\tMIPS16e2 ASE", stdout
);
15616 if (mask
& AFL_ASE_CRC
)
15617 fputs ("\n\tCRC ASE", stdout
);
15618 if (mask
& AFL_ASE_GINV
)
15619 fputs ("\n\tGINV ASE", stdout
);
15620 if (mask
& AFL_ASE_LOONGSON_MMI
)
15621 fputs ("\n\tLoongson MMI ASE", stdout
);
15623 fprintf (stdout
, "\n\t%s", _("None"));
15624 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15625 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15629 print_mips_isa_ext (unsigned int isa_ext
)
15634 fputs (_("None"), stdout
);
15637 fputs ("RMI XLR", stdout
);
15639 case AFL_EXT_OCTEON3
:
15640 fputs ("Cavium Networks Octeon3", stdout
);
15642 case AFL_EXT_OCTEON2
:
15643 fputs ("Cavium Networks Octeon2", stdout
);
15645 case AFL_EXT_OCTEONP
:
15646 fputs ("Cavium Networks OcteonP", stdout
);
15648 case AFL_EXT_LOONGSON_3A
:
15649 fputs ("Loongson 3A", stdout
);
15651 case AFL_EXT_OCTEON
:
15652 fputs ("Cavium Networks Octeon", stdout
);
15655 fputs ("Toshiba R5900", stdout
);
15658 fputs ("MIPS R4650", stdout
);
15661 fputs ("LSI R4010", stdout
);
15664 fputs ("NEC VR4100", stdout
);
15667 fputs ("Toshiba R3900", stdout
);
15669 case AFL_EXT_10000
:
15670 fputs ("MIPS R10000", stdout
);
15673 fputs ("Broadcom SB-1", stdout
);
15676 fputs ("NEC VR4111/VR4181", stdout
);
15679 fputs ("NEC VR4120", stdout
);
15682 fputs ("NEC VR5400", stdout
);
15685 fputs ("NEC VR5500", stdout
);
15687 case AFL_EXT_LOONGSON_2E
:
15688 fputs ("ST Microelectronics Loongson 2E", stdout
);
15690 case AFL_EXT_LOONGSON_2F
:
15691 fputs ("ST Microelectronics Loongson 2F", stdout
);
15693 case AFL_EXT_INTERAPTIV_MR2
:
15694 fputs ("Imagination interAptiv MR2", stdout
);
15697 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15702 get_mips_reg_size (int reg_size
)
15704 return (reg_size
== AFL_REG_NONE
) ? 0
15705 : (reg_size
== AFL_REG_32
) ? 32
15706 : (reg_size
== AFL_REG_64
) ? 64
15707 : (reg_size
== AFL_REG_128
) ? 128
15712 process_mips_specific (Filedata
* filedata
)
15714 Elf_Internal_Dyn
* entry
;
15715 Elf_Internal_Shdr
*sect
= NULL
;
15716 size_t liblist_offset
= 0;
15717 size_t liblistno
= 0;
15718 size_t conflictsno
= 0;
15719 size_t options_offset
= 0;
15720 size_t conflicts_offset
= 0;
15721 size_t pltrelsz
= 0;
15723 bfd_vma pltgot
= 0;
15724 bfd_vma mips_pltgot
= 0;
15725 bfd_vma jmprel
= 0;
15726 bfd_vma local_gotno
= 0;
15727 bfd_vma gotsym
= 0;
15728 bfd_vma symtabno
= 0;
15729 bfd_boolean res
= TRUE
;
15731 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15732 display_mips_gnu_attribute
))
15735 sect
= find_section (filedata
, ".MIPS.abiflags");
15739 Elf_External_ABIFlags_v0
*abiflags_ext
;
15740 Elf_Internal_ABIFlags_v0 abiflags_in
;
15742 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15744 error (_("Corrupt MIPS ABI Flags section.\n"));
15749 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15750 sect
->sh_size
, _("MIPS ABI Flags section"));
15753 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15754 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15755 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15756 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15757 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15758 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15759 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15760 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15761 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15762 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15763 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15765 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15766 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15767 if (abiflags_in
.isa_rev
> 1)
15768 printf ("r%d", abiflags_in
.isa_rev
);
15769 printf ("\nGPR size: %d",
15770 get_mips_reg_size (abiflags_in
.gpr_size
));
15771 printf ("\nCPR1 size: %d",
15772 get_mips_reg_size (abiflags_in
.cpr1_size
));
15773 printf ("\nCPR2 size: %d",
15774 get_mips_reg_size (abiflags_in
.cpr2_size
));
15775 fputs ("\nFP ABI: ", stdout
);
15776 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15777 fputs ("ISA Extension: ", stdout
);
15778 print_mips_isa_ext (abiflags_in
.isa_ext
);
15779 fputs ("\nASEs:", stdout
);
15780 print_mips_ases (abiflags_in
.ases
);
15781 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15782 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15783 fputc ('\n', stdout
);
15784 free (abiflags_ext
);
15789 /* We have a lot of special sections. Thanks SGI! */
15790 if (dynamic_section
== NULL
)
15792 /* No dynamic information available. See if there is static GOT. */
15793 sect
= find_section (filedata
, ".got");
15796 unsigned char *data_end
;
15797 unsigned char *data
;
15801 pltgot
= sect
->sh_addr
;
15804 addr_size
= (is_32bit_elf
? 4 : 8);
15805 end
= pltgot
+ sect
->sh_size
;
15807 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15809 _("Global Offset Table data"));
15810 /* PR 12855: Null data is handled gracefully throughout. */
15811 data_end
= data
+ (end
- pltgot
);
15813 printf (_("\nStatic GOT:\n"));
15814 printf (_(" Canonical gp value: "));
15815 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15818 /* In a dynamic binary GOT[0] is reserved for the dynamic
15819 loader to store the lazy resolver pointer, however in
15820 a static binary it may well have been omitted and GOT
15821 reduced to a table of addresses.
15822 PR 21344: Check for the entry being fully available
15823 before fetching it. */
15825 && data
+ ent
- pltgot
+ addr_size
<= data_end
15826 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15828 printf (_(" Reserved entries:\n"));
15829 printf (_(" %*s %10s %*s\n"),
15830 addr_size
* 2, _("Address"), _("Access"),
15831 addr_size
* 2, _("Value"));
15832 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15834 if (ent
== (bfd_vma
) -1)
15835 goto sgot_print_fail
;
15837 /* Check for the MSB of GOT[1] being set, identifying a
15838 GNU object. This entry will be used by some runtime
15839 loaders, to store the module pointer. Otherwise this
15840 is an ordinary local entry.
15841 PR 21344: Check for the entry being fully available
15842 before fetching it. */
15844 && data
+ ent
- pltgot
+ addr_size
<= data_end
15845 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15846 >> (addr_size
* 8 - 1)) != 0)
15848 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15850 if (ent
== (bfd_vma
) -1)
15851 goto sgot_print_fail
;
15856 if (data
!= NULL
&& ent
< end
)
15858 printf (_(" Local entries:\n"));
15859 printf (" %*s %10s %*s\n",
15860 addr_size
* 2, _("Address"), _("Access"),
15861 addr_size
* 2, _("Value"));
15864 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15866 if (ent
== (bfd_vma
) -1)
15867 goto sgot_print_fail
;
15879 for (entry
= dynamic_section
;
15880 /* PR 17531 file: 012-50589-0.004. */
15881 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15883 switch (entry
->d_tag
)
15885 case DT_MIPS_LIBLIST
:
15887 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15888 liblistno
* sizeof (Elf32_External_Lib
));
15890 case DT_MIPS_LIBLISTNO
:
15891 liblistno
= entry
->d_un
.d_val
;
15893 case DT_MIPS_OPTIONS
:
15894 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15896 case DT_MIPS_CONFLICT
:
15898 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15899 conflictsno
* sizeof (Elf32_External_Conflict
));
15901 case DT_MIPS_CONFLICTNO
:
15902 conflictsno
= entry
->d_un
.d_val
;
15905 pltgot
= entry
->d_un
.d_ptr
;
15907 case DT_MIPS_LOCAL_GOTNO
:
15908 local_gotno
= entry
->d_un
.d_val
;
15910 case DT_MIPS_GOTSYM
:
15911 gotsym
= entry
->d_un
.d_val
;
15913 case DT_MIPS_SYMTABNO
:
15914 symtabno
= entry
->d_un
.d_val
;
15916 case DT_MIPS_PLTGOT
:
15917 mips_pltgot
= entry
->d_un
.d_ptr
;
15920 pltrel
= entry
->d_un
.d_val
;
15923 pltrelsz
= entry
->d_un
.d_val
;
15926 jmprel
= entry
->d_un
.d_ptr
;
15932 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15934 Elf32_External_Lib
* elib
;
15937 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15939 sizeof (Elf32_External_Lib
),
15940 _("liblist section data"));
15943 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15944 "\nSection '.liblist' contains %lu entries:\n",
15945 (unsigned long) liblistno
),
15946 (unsigned long) liblistno
);
15947 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15950 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15957 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15958 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15959 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15960 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15961 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15963 tmp
= gmtime (&atime
);
15964 snprintf (timebuf
, sizeof (timebuf
),
15965 "%04u-%02u-%02uT%02u:%02u:%02u",
15966 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15967 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15969 printf ("%3lu: ", (unsigned long) cnt
);
15970 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15971 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15973 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15974 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15975 liblist
.l_version
);
15977 if (liblist
.l_flags
== 0)
15981 static const struct
15988 { " EXACT_MATCH", LL_EXACT_MATCH
},
15989 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15990 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15991 { " EXPORTS", LL_EXPORTS
},
15992 { " DELAY_LOAD", LL_DELAY_LOAD
},
15993 { " DELTA", LL_DELTA
}
15995 int flags
= liblist
.l_flags
;
15998 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15999 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16001 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16002 flags
^= l_flags_vals
[fcnt
].bit
;
16005 printf (" %#x", (unsigned int) flags
);
16017 if (options_offset
!= 0)
16019 Elf_External_Options
* eopt
;
16020 Elf_Internal_Options
* iopt
;
16021 Elf_Internal_Options
* option
;
16024 sect
= filedata
->section_headers
;
16026 /* Find the section header so that we get the size. */
16027 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16028 /* PR 17533 file: 012-277276-0.004. */
16031 error (_("No MIPS_OPTIONS header found\n"));
16035 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16036 sect
->sh_size
, _("options"));
16039 iopt
= (Elf_Internal_Options
*)
16040 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16043 error (_("Out of memory allocating space for MIPS options\n"));
16050 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16052 Elf_External_Options
* eoption
;
16054 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16056 option
->kind
= BYTE_GET (eoption
->kind
);
16057 option
->size
= BYTE_GET (eoption
->size
);
16058 option
->section
= BYTE_GET (eoption
->section
);
16059 option
->info
= BYTE_GET (eoption
->info
);
16061 /* PR 17531: file: ffa0fa3b. */
16062 if (option
->size
< sizeof (* eopt
)
16063 || offset
+ option
->size
> sect
->sh_size
)
16065 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16068 offset
+= option
->size
;
16074 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16075 "\nSection '%s' contains %d entries:\n",
16077 printable_section_name (filedata
, sect
), cnt
);
16086 switch (option
->kind
)
16089 /* This shouldn't happen. */
16090 printf (" NULL %d %lx", option
->section
, option
->info
);
16093 printf (" REGINFO ");
16094 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16097 Elf32_External_RegInfo
* ereg
;
16098 Elf32_RegInfo reginfo
;
16100 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16101 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16102 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16103 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16104 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16105 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16106 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16108 printf ("GPR %08lx GP 0x%lx\n",
16109 reginfo
.ri_gprmask
,
16110 (unsigned long) reginfo
.ri_gp_value
);
16111 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16112 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16113 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16118 Elf64_External_RegInfo
* ereg
;
16119 Elf64_Internal_RegInfo reginfo
;
16121 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16122 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16123 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16124 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16125 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16126 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16127 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16129 printf ("GPR %08lx GP 0x",
16130 reginfo
.ri_gprmask
);
16131 printf_vma (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]);
16140 case ODK_EXCEPTIONS
:
16141 fputs (" EXCEPTIONS fpe_min(", stdout
);
16142 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16143 fputs (") fpe_max(", stdout
);
16144 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16145 fputs (")", stdout
);
16147 if (option
->info
& OEX_PAGE0
)
16148 fputs (" PAGE0", stdout
);
16149 if (option
->info
& OEX_SMM
)
16150 fputs (" SMM", stdout
);
16151 if (option
->info
& OEX_FPDBUG
)
16152 fputs (" FPDBUG", stdout
);
16153 if (option
->info
& OEX_DISMISS
)
16154 fputs (" DISMISS", stdout
);
16157 fputs (" PAD ", stdout
);
16158 if (option
->info
& OPAD_PREFIX
)
16159 fputs (" PREFIX", stdout
);
16160 if (option
->info
& OPAD_POSTFIX
)
16161 fputs (" POSTFIX", stdout
);
16162 if (option
->info
& OPAD_SYMBOL
)
16163 fputs (" SYMBOL", stdout
);
16166 fputs (" HWPATCH ", stdout
);
16167 if (option
->info
& OHW_R4KEOP
)
16168 fputs (" R4KEOP", stdout
);
16169 if (option
->info
& OHW_R8KPFETCH
)
16170 fputs (" R8KPFETCH", stdout
);
16171 if (option
->info
& OHW_R5KEOP
)
16172 fputs (" R5KEOP", stdout
);
16173 if (option
->info
& OHW_R5KCVTL
)
16174 fputs (" R5KCVTL", stdout
);
16177 fputs (" FILL ", stdout
);
16178 /* XXX Print content of info word? */
16181 fputs (" TAGS ", stdout
);
16182 /* XXX Print content of info word? */
16185 fputs (" HWAND ", stdout
);
16186 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16187 fputs (" R4KEOP_CHECKED", stdout
);
16188 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16189 fputs (" R4KEOP_CLEAN", stdout
);
16192 fputs (" HWOR ", stdout
);
16193 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16194 fputs (" R4KEOP_CHECKED", stdout
);
16195 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16196 fputs (" R4KEOP_CLEAN", stdout
);
16199 printf (" GP_GROUP %#06lx self-contained %#06lx",
16200 option
->info
& OGP_GROUP
,
16201 (option
->info
& OGP_SELF
) >> 16);
16204 printf (" IDENT %#06lx self-contained %#06lx",
16205 option
->info
& OGP_GROUP
,
16206 (option
->info
& OGP_SELF
) >> 16);
16209 /* This shouldn't happen. */
16210 printf (" %3d ??? %d %lx",
16211 option
->kind
, option
->section
, option
->info
);
16215 len
= sizeof (* eopt
);
16216 while (len
< option
->size
)
16218 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16220 if (ISPRINT (datum
))
16221 printf ("%c", datum
);
16223 printf ("\\%03o", datum
);
16226 fputs ("\n", stdout
);
16228 offset
+= option
->size
;
16238 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16240 Elf32_Conflict
* iconf
;
16243 if (dynamic_symbols
== NULL
)
16245 error (_("conflict list found without a dynamic symbol table\n"));
16249 /* PR 21345 - print a slightly more helpful error message
16250 if we are sure that the cmalloc will fail. */
16251 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16253 error (_("Overlarge number of conflicts detected: %lx\n"),
16254 (long) conflictsno
);
16258 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16261 error (_("Out of memory allocating space for dynamic conflicts\n"));
16267 Elf32_External_Conflict
* econf32
;
16269 econf32
= (Elf32_External_Conflict
*)
16270 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16271 sizeof (* econf32
), _("conflict"));
16275 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16276 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16282 Elf64_External_Conflict
* econf64
;
16284 econf64
= (Elf64_External_Conflict
*)
16285 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16286 sizeof (* econf64
), _("conflict"));
16290 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16291 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16296 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16297 "\nSection '.conflict' contains %lu entries:\n",
16298 (unsigned long) conflictsno
),
16299 (unsigned long) conflictsno
);
16300 puts (_(" Num: Index Value Name"));
16302 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16304 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16306 if (iconf
[cnt
] >= num_dynamic_syms
)
16307 printf (_("<corrupt symbol index>"));
16310 Elf_Internal_Sym
* psym
;
16312 psym
= & dynamic_symbols
[iconf
[cnt
]];
16313 print_vma (psym
->st_value
, FULL_HEX
);
16315 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16316 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16318 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16326 if (pltgot
!= 0 && local_gotno
!= 0)
16328 bfd_vma ent
, local_end
, global_end
;
16330 unsigned char * data
;
16331 unsigned char * data_end
;
16335 addr_size
= (is_32bit_elf
? 4 : 8);
16336 local_end
= pltgot
+ local_gotno
* addr_size
;
16338 /* PR binutils/17533 file: 012-111227-0.004 */
16339 if (symtabno
< gotsym
)
16341 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16342 (unsigned long) gotsym
, (unsigned long) symtabno
);
16346 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16347 /* PR 17531: file: 54c91a34. */
16348 if (global_end
< local_end
)
16350 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16354 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16355 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16356 global_end
- pltgot
, 1,
16357 _("Global Offset Table data"));
16358 /* PR 12855: Null data is handled gracefully throughout. */
16359 data_end
= data
+ (global_end
- pltgot
);
16361 printf (_("\nPrimary GOT:\n"));
16362 printf (_(" Canonical gp value: "));
16363 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16366 printf (_(" Reserved entries:\n"));
16367 printf (_(" %*s %10s %*s Purpose\n"),
16368 addr_size
* 2, _("Address"), _("Access"),
16369 addr_size
* 2, _("Initial"));
16370 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16371 printf (_(" Lazy resolver\n"));
16372 if (ent
== (bfd_vma
) -1)
16373 goto got_print_fail
;
16375 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16376 This entry will be used by some runtime loaders, to store the
16377 module pointer. Otherwise this is an ordinary local entry.
16378 PR 21344: Check for the entry being fully available before
16381 && data
+ ent
- pltgot
+ addr_size
<= data_end
16382 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16383 >> (addr_size
* 8 - 1)) != 0)
16385 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16386 printf (_(" Module pointer (GNU extension)\n"));
16387 if (ent
== (bfd_vma
) -1)
16388 goto got_print_fail
;
16392 if (data
!= NULL
&& ent
< local_end
)
16394 printf (_(" Local entries:\n"));
16395 printf (" %*s %10s %*s\n",
16396 addr_size
* 2, _("Address"), _("Access"),
16397 addr_size
* 2, _("Initial"));
16398 while (ent
< local_end
)
16400 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16402 if (ent
== (bfd_vma
) -1)
16403 goto got_print_fail
;
16408 if (data
!= NULL
&& gotsym
< symtabno
)
16412 printf (_(" Global entries:\n"));
16413 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16414 addr_size
* 2, _("Address"),
16416 addr_size
* 2, _("Initial"),
16417 addr_size
* 2, _("Sym.Val."),
16419 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16420 _("Ndx"), _("Name"));
16422 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16424 for (i
= gotsym
; i
< symtabno
; i
++)
16426 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16429 if (dynamic_symbols
== NULL
)
16430 printf (_("<no dynamic symbols>"));
16431 else if (i
< num_dynamic_syms
)
16433 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16435 print_vma (psym
->st_value
, LONG_HEX
);
16436 printf (" %-7s %3s ",
16437 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16438 get_symbol_index_type (filedata
, psym
->st_shndx
));
16440 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16441 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16443 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16446 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16447 (unsigned long) i
);
16450 if (ent
== (bfd_vma
) -1)
16461 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16464 size_t offset
, rel_offset
;
16465 unsigned long count
, i
;
16466 unsigned char * data
;
16467 int addr_size
, sym_width
;
16468 Elf_Internal_Rela
* rels
;
16470 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16471 if (pltrel
== DT_RELA
)
16473 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16478 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16483 addr_size
= (is_32bit_elf
? 4 : 8);
16484 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16486 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16487 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16488 1, _("Procedure Linkage Table data"));
16492 printf ("\nPLT GOT:\n\n");
16493 printf (_(" Reserved entries:\n"));
16494 printf (_(" %*s %*s Purpose\n"),
16495 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16496 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16497 printf (_(" PLT lazy resolver\n"));
16498 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16499 printf (_(" Module pointer\n"));
16502 printf (_(" Entries:\n"));
16503 printf (" %*s %*s %*s %-7s %3s %s\n",
16504 addr_size
* 2, _("Address"),
16505 addr_size
* 2, _("Initial"),
16506 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16507 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16508 for (i
= 0; i
< count
; i
++)
16510 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16512 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16515 if (idx
>= num_dynamic_syms
)
16516 printf (_("<corrupt symbol index: %lu>"), idx
);
16519 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16521 print_vma (psym
->st_value
, LONG_HEX
);
16522 printf (" %-7s %3s ",
16523 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16524 get_symbol_index_type (filedata
, psym
->st_shndx
));
16525 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16526 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16528 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16543 process_nds32_specific (Filedata
* filedata
)
16545 Elf_Internal_Shdr
*sect
= NULL
;
16547 sect
= find_section (filedata
, ".nds32_e_flags");
16550 unsigned int *flag
;
16552 printf ("\nNDS32 elf flags section:\n");
16553 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16554 sect
->sh_size
, _("NDS32 elf flags section"));
16559 switch ((*flag
) & 0x3)
16562 printf ("(VEC_SIZE):\tNo entry.\n");
16565 printf ("(VEC_SIZE):\t4 bytes\n");
16568 printf ("(VEC_SIZE):\t16 bytes\n");
16571 printf ("(VEC_SIZE):\treserved\n");
16580 process_gnu_liblist (Filedata
* filedata
)
16582 Elf_Internal_Shdr
* section
;
16583 Elf_Internal_Shdr
* string_sec
;
16584 Elf32_External_Lib
* elib
;
16586 size_t strtab_size
;
16588 unsigned long num_liblist
;
16590 bfd_boolean res
= TRUE
;
16595 for (i
= 0, section
= filedata
->section_headers
;
16596 i
< filedata
->file_header
.e_shnum
;
16599 switch (section
->sh_type
)
16601 case SHT_GNU_LIBLIST
:
16602 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16605 elib
= (Elf32_External_Lib
*)
16606 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16607 _("liblist section data"));
16615 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16616 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16617 string_sec
->sh_size
,
16618 _("liblist string table"));
16620 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16627 strtab_size
= string_sec
->sh_size
;
16629 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16630 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16631 "\nLibrary list section '%s' contains %lu entries:\n",
16633 printable_section_name (filedata
, section
),
16636 puts (_(" Library Time Stamp Checksum Version Flags"));
16638 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16646 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16647 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16648 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16649 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16650 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16652 tmp
= gmtime (&atime
);
16653 snprintf (timebuf
, sizeof (timebuf
),
16654 "%04u-%02u-%02uT%02u:%02u:%02u",
16655 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16656 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16658 printf ("%3lu: ", (unsigned long) cnt
);
16660 printf ("%-20s", liblist
.l_name
< strtab_size
16661 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16663 printf ("%-20.20s", liblist
.l_name
< strtab_size
16664 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16665 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16666 liblist
.l_version
, liblist
.l_flags
);
16677 static const char *
16678 get_note_type (Filedata
* filedata
, unsigned e_type
)
16680 static char buff
[64];
16682 if (filedata
->file_header
.e_type
== ET_CORE
)
16686 return _("NT_AUXV (auxiliary vector)");
16688 return _("NT_PRSTATUS (prstatus structure)");
16690 return _("NT_FPREGSET (floating point registers)");
16692 return _("NT_PRPSINFO (prpsinfo structure)");
16693 case NT_TASKSTRUCT
:
16694 return _("NT_TASKSTRUCT (task structure)");
16696 return _("NT_PRXFPREG (user_xfpregs structure)");
16698 return _("NT_PPC_VMX (ppc Altivec registers)");
16700 return _("NT_PPC_VSX (ppc VSX registers)");
16702 return _("NT_PPC_TAR (ppc TAR register)");
16704 return _("NT_PPC_PPR (ppc PPR register)");
16706 return _("NT_PPC_DSCR (ppc DSCR register)");
16708 return _("NT_PPC_EBB (ppc EBB registers)");
16710 return _("NT_PPC_PMU (ppc PMU registers)");
16711 case NT_PPC_TM_CGPR
:
16712 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16713 case NT_PPC_TM_CFPR
:
16714 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16715 case NT_PPC_TM_CVMX
:
16716 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16717 case NT_PPC_TM_CVSX
:
16718 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16719 case NT_PPC_TM_SPR
:
16720 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16721 case NT_PPC_TM_CTAR
:
16722 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16723 case NT_PPC_TM_CPPR
:
16724 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16725 case NT_PPC_TM_CDSCR
:
16726 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16728 return _("NT_386_TLS (x86 TLS information)");
16729 case NT_386_IOPERM
:
16730 return _("NT_386_IOPERM (x86 I/O permissions)");
16731 case NT_X86_XSTATE
:
16732 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16733 case NT_S390_HIGH_GPRS
:
16734 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16735 case NT_S390_TIMER
:
16736 return _("NT_S390_TIMER (s390 timer register)");
16737 case NT_S390_TODCMP
:
16738 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16739 case NT_S390_TODPREG
:
16740 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16742 return _("NT_S390_CTRS (s390 control registers)");
16743 case NT_S390_PREFIX
:
16744 return _("NT_S390_PREFIX (s390 prefix register)");
16745 case NT_S390_LAST_BREAK
:
16746 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16747 case NT_S390_SYSTEM_CALL
:
16748 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16750 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16751 case NT_S390_VXRS_LOW
:
16752 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16753 case NT_S390_VXRS_HIGH
:
16754 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16755 case NT_S390_GS_CB
:
16756 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16757 case NT_S390_GS_BC
:
16758 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16760 return _("NT_ARM_VFP (arm VFP registers)");
16762 return _("NT_ARM_TLS (AArch TLS registers)");
16763 case NT_ARM_HW_BREAK
:
16764 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16765 case NT_ARM_HW_WATCH
:
16766 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16768 return _("NT_PSTATUS (pstatus structure)");
16770 return _("NT_FPREGS (floating point registers)");
16772 return _("NT_PSINFO (psinfo structure)");
16774 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16776 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16777 case NT_WIN32PSTATUS
:
16778 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16780 return _("NT_SIGINFO (siginfo_t data)");
16782 return _("NT_FILE (mapped files)");
16790 return _("NT_VERSION (version)");
16792 return _("NT_ARCH (architecture)");
16793 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16795 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16801 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16806 print_core_note (Elf_Internal_Note
*pnote
)
16808 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16809 bfd_vma count
, page_size
;
16810 unsigned char *descdata
, *filenames
, *descend
;
16812 if (pnote
->type
!= NT_FILE
)
16822 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16823 /* Still "successful". */
16828 if (pnote
->descsz
< 2 * addr_size
)
16830 error (_(" Malformed note - too short for header\n"));
16834 descdata
= (unsigned char *) pnote
->descdata
;
16835 descend
= descdata
+ pnote
->descsz
;
16837 if (descdata
[pnote
->descsz
- 1] != '\0')
16839 error (_(" Malformed note - does not end with \\0\n"));
16843 count
= byte_get (descdata
, addr_size
);
16844 descdata
+= addr_size
;
16846 page_size
= byte_get (descdata
, addr_size
);
16847 descdata
+= addr_size
;
16849 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16850 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16852 error (_(" Malformed note - too short for supplied file count\n"));
16856 printf (_(" Page size: "));
16857 print_vma (page_size
, DEC
);
16860 printf (_(" %*s%*s%*s\n"),
16861 (int) (2 + 2 * addr_size
), _("Start"),
16862 (int) (4 + 2 * addr_size
), _("End"),
16863 (int) (4 + 2 * addr_size
), _("Page Offset"));
16864 filenames
= descdata
+ count
* 3 * addr_size
;
16865 while (count
-- > 0)
16867 bfd_vma start
, end
, file_ofs
;
16869 if (filenames
== descend
)
16871 error (_(" Malformed note - filenames end too early\n"));
16875 start
= byte_get (descdata
, addr_size
);
16876 descdata
+= addr_size
;
16877 end
= byte_get (descdata
, addr_size
);
16878 descdata
+= addr_size
;
16879 file_ofs
= byte_get (descdata
, addr_size
);
16880 descdata
+= addr_size
;
16883 print_vma (start
, FULL_HEX
);
16885 print_vma (end
, FULL_HEX
);
16887 print_vma (file_ofs
, FULL_HEX
);
16888 printf ("\n %s\n", filenames
);
16890 filenames
+= 1 + strlen ((char *) filenames
);
16896 static const char *
16897 get_gnu_elf_note_type (unsigned e_type
)
16899 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16902 case NT_GNU_ABI_TAG
:
16903 return _("NT_GNU_ABI_TAG (ABI version tag)");
16905 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16906 case NT_GNU_BUILD_ID
:
16907 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16908 case NT_GNU_GOLD_VERSION
:
16909 return _("NT_GNU_GOLD_VERSION (gold version)");
16910 case NT_GNU_PROPERTY_TYPE_0
:
16911 return _("NT_GNU_PROPERTY_TYPE_0");
16912 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16913 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16914 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16915 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16918 static char buff
[64];
16920 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16927 decode_x86_isa (unsigned int bitmask
)
16931 unsigned int bit
= bitmask
& (- bitmask
);
16936 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16937 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16938 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16939 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16940 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16941 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16942 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16943 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16944 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16945 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16946 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16947 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16948 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16949 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16950 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16951 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16952 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16953 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16954 default: printf (_("<unknown: %x>"), bit
); break;
16962 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16966 unsigned int bit
= bitmask
& (- bitmask
);
16971 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16974 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16978 /* This should never happen. */
16982 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16985 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16989 /* This should never happen. */
16994 printf (_("<unknown: %x>"), bit
);
17003 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17005 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17006 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17007 unsigned int size
= is_32bit_elf
? 4 : 8;
17009 printf (_(" Properties: "));
17011 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17013 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17017 while (ptr
< ptr_end
)
17021 unsigned int datasz
;
17023 if ((size_t) (ptr_end
- ptr
) < 8)
17025 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17029 type
= byte_get (ptr
, 4);
17030 datasz
= byte_get (ptr
+ 4, 4);
17034 if (datasz
> (size_t) (ptr_end
- ptr
))
17036 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17041 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17043 if (filedata
->file_header
.e_machine
== EM_X86_64
17044 || filedata
->file_header
.e_machine
== EM_IAMCU
17045 || filedata
->file_header
.e_machine
== EM_386
)
17049 case GNU_PROPERTY_X86_ISA_1_USED
:
17050 printf ("x86 ISA used: ");
17052 printf (_("<corrupt length: %#x> "), datasz
);
17054 decode_x86_isa (byte_get (ptr
, 4));
17057 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17058 printf ("x86 ISA needed: ");
17060 printf (_("<corrupt length: %#x> "), datasz
);
17062 decode_x86_isa (byte_get (ptr
, 4));
17065 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17066 printf ("x86 feature: ");
17068 printf (_("<corrupt length: %#x> "), datasz
);
17070 decode_x86_feature (type
, byte_get (ptr
, 4));
17082 case GNU_PROPERTY_STACK_SIZE
:
17083 printf (_("stack size: "));
17084 if (datasz
!= size
)
17085 printf (_("<corrupt length: %#x> "), datasz
);
17087 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17090 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17091 printf ("no copy on protected ");
17093 printf (_("<corrupt length: %#x> "), datasz
);
17101 if (type
< GNU_PROPERTY_LOPROC
)
17102 printf (_("<unknown type %#x data: "), type
);
17103 else if (type
< GNU_PROPERTY_LOUSER
)
17104 printf (_("<procesor-specific type %#x data: "), type
);
17106 printf (_("<application-specific type %#x data: "), type
);
17107 for (j
= 0; j
< datasz
; ++j
)
17108 printf ("%02x ", ptr
[j
] & 0xff);
17112 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17113 if (ptr
== ptr_end
)
17126 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17128 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17129 switch (pnote
->type
)
17131 case NT_GNU_BUILD_ID
:
17135 printf (_(" Build ID: "));
17136 for (i
= 0; i
< pnote
->descsz
; ++i
)
17137 printf ("%02x", pnote
->descdata
[i
] & 0xff);
17142 case NT_GNU_ABI_TAG
:
17144 unsigned long os
, major
, minor
, subminor
;
17145 const char *osname
;
17147 /* PR 17531: file: 030-599401-0.004. */
17148 if (pnote
->descsz
< 16)
17150 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17154 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17155 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17156 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
17157 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
17161 case GNU_ABI_TAG_LINUX
:
17164 case GNU_ABI_TAG_HURD
:
17167 case GNU_ABI_TAG_SOLARIS
:
17168 osname
= "Solaris";
17170 case GNU_ABI_TAG_FREEBSD
:
17171 osname
= "FreeBSD";
17173 case GNU_ABI_TAG_NETBSD
:
17176 case GNU_ABI_TAG_SYLLABLE
:
17177 osname
= "Syllable";
17179 case GNU_ABI_TAG_NACL
:
17183 osname
= "Unknown";
17187 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17188 major
, minor
, subminor
);
17192 case NT_GNU_GOLD_VERSION
:
17196 printf (_(" Version: "));
17197 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17198 printf ("%c", pnote
->descdata
[i
]);
17205 unsigned long num_entries
, mask
;
17207 /* Hardware capabilities information. Word 0 is the number of entries.
17208 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17209 is a series of entries, where each entry is a single byte followed
17210 by a nul terminated string. The byte gives the bit number to test
17211 if enabled in the bitmask. */
17212 printf (_(" Hardware Capabilities: "));
17213 if (pnote
->descsz
< 8)
17215 error (_("<corrupt GNU_HWCAP>\n"));
17218 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17219 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17220 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17221 /* FIXME: Add code to display the entries... */
17225 case NT_GNU_PROPERTY_TYPE_0
:
17226 print_gnu_property_note (filedata
, pnote
);
17230 /* Handle unrecognised types. An error message should have already been
17231 created by get_gnu_elf_note_type(), so all that we need to do is to
17232 display the data. */
17236 printf (_(" Description data: "));
17237 for (i
= 0; i
< pnote
->descsz
; ++i
)
17238 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17247 static const char *
17248 get_v850_elf_note_type (enum v850_notes n_type
)
17250 static char buff
[64];
17254 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17255 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17256 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17257 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17258 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17259 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17261 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17267 print_v850_note (Elf_Internal_Note
* pnote
)
17271 if (pnote
->descsz
!= 4)
17274 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17278 printf (_("not set\n"));
17282 switch (pnote
->type
)
17284 case V850_NOTE_ALIGNMENT
:
17287 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17288 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17292 case V850_NOTE_DATA_SIZE
:
17295 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17296 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17300 case V850_NOTE_FPU_INFO
:
17303 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17304 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17308 case V850_NOTE_MMU_INFO
:
17309 case V850_NOTE_CACHE_INFO
:
17310 case V850_NOTE_SIMD_INFO
:
17311 if (val
== EF_RH850_SIMD
)
17313 printf (_("yes\n"));
17319 /* An 'unknown note type' message will already have been displayed. */
17323 printf (_("unknown value: %x\n"), val
);
17328 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17330 unsigned int version
;
17332 switch (pnote
->type
)
17334 case NT_NETBSD_IDENT
:
17335 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17336 if ((version
/ 10000) % 100)
17337 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17338 version
, version
/ 100000000, (version
/ 1000000) % 100,
17339 (version
/ 10000) % 100 > 26 ? "Z" : "",
17340 'A' + (version
/ 10000) % 26);
17342 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17343 version
, version
/ 100000000, (version
/ 1000000) % 100,
17344 (version
/ 100) % 100);
17347 case NT_NETBSD_MARCH
:
17348 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17353 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17359 static const char *
17360 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17364 case NT_FREEBSD_THRMISC
:
17365 return _("NT_THRMISC (thrmisc structure)");
17366 case NT_FREEBSD_PROCSTAT_PROC
:
17367 return _("NT_PROCSTAT_PROC (proc data)");
17368 case NT_FREEBSD_PROCSTAT_FILES
:
17369 return _("NT_PROCSTAT_FILES (files data)");
17370 case NT_FREEBSD_PROCSTAT_VMMAP
:
17371 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17372 case NT_FREEBSD_PROCSTAT_GROUPS
:
17373 return _("NT_PROCSTAT_GROUPS (groups data)");
17374 case NT_FREEBSD_PROCSTAT_UMASK
:
17375 return _("NT_PROCSTAT_UMASK (umask data)");
17376 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17377 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17378 case NT_FREEBSD_PROCSTAT_OSREL
:
17379 return _("NT_PROCSTAT_OSREL (osreldate data)");
17380 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17381 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17382 case NT_FREEBSD_PROCSTAT_AUXV
:
17383 return _("NT_PROCSTAT_AUXV (auxv data)");
17384 case NT_FREEBSD_PTLWPINFO
:
17385 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17387 return get_note_type (filedata
, e_type
);
17390 static const char *
17391 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17393 static char buff
[64];
17395 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17396 return _("NetBSD procinfo structure");
17398 /* As of Jan 2002 there are no other machine-independent notes
17399 defined for NetBSD core files. If the note type is less
17400 than the start of the machine-dependent note types, we don't
17403 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17405 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17409 switch (filedata
->file_header
.e_machine
)
17411 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17412 and PT_GETFPREGS == mach+2. */
17417 case EM_SPARC32PLUS
:
17421 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17422 return _("PT_GETREGS (reg structure)");
17423 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17424 return _("PT_GETFPREGS (fpreg structure)");
17430 /* On all other arch's, PT_GETREGS == mach+1 and
17431 PT_GETFPREGS == mach+3. */
17435 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17436 return _("PT_GETREGS (reg structure)");
17437 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17438 return _("PT_GETFPREGS (fpreg structure)");
17444 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17445 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17449 static const char *
17450 get_stapsdt_note_type (unsigned e_type
)
17452 static char buff
[64];
17457 return _("NT_STAPSDT (SystemTap probe descriptors)");
17463 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17468 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17470 int addr_size
= is_32bit_elf
? 4 : 8;
17471 char *data
= pnote
->descdata
;
17472 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17473 bfd_vma pc
, base_addr
, semaphore
;
17474 char *provider
, *probe
, *arg_fmt
;
17476 pc
= byte_get ((unsigned char *) data
, addr_size
);
17478 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17480 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17484 data
+= strlen (data
) + 1;
17486 data
+= strlen (data
) + 1;
17488 data
+= strlen (data
) + 1;
17490 printf (_(" Provider: %s\n"), provider
);
17491 printf (_(" Name: %s\n"), probe
);
17492 printf (_(" Location: "));
17493 print_vma (pc
, FULL_HEX
);
17494 printf (_(", Base: "));
17495 print_vma (base_addr
, FULL_HEX
);
17496 printf (_(", Semaphore: "));
17497 print_vma (semaphore
, FULL_HEX
);
17499 printf (_(" Arguments: %s\n"), arg_fmt
);
17501 return data
== data_end
;
17504 static const char *
17505 get_ia64_vms_note_type (unsigned e_type
)
17507 static char buff
[64];
17512 return _("NT_VMS_MHD (module header)");
17514 return _("NT_VMS_LNM (language name)");
17516 return _("NT_VMS_SRC (source files)");
17518 return "NT_VMS_TITLE";
17520 return _("NT_VMS_EIDC (consistency check)");
17521 case NT_VMS_FPMODE
:
17522 return _("NT_VMS_FPMODE (FP mode)");
17523 case NT_VMS_LINKTIME
:
17524 return "NT_VMS_LINKTIME";
17525 case NT_VMS_IMGNAM
:
17526 return _("NT_VMS_IMGNAM (image name)");
17528 return _("NT_VMS_IMGID (image id)");
17529 case NT_VMS_LINKID
:
17530 return _("NT_VMS_LINKID (link id)");
17531 case NT_VMS_IMGBID
:
17532 return _("NT_VMS_IMGBID (build id)");
17533 case NT_VMS_GSTNAM
:
17534 return _("NT_VMS_GSTNAM (sym table name)");
17535 case NT_VMS_ORIG_DYN
:
17536 return "NT_VMS_ORIG_DYN";
17537 case NT_VMS_PATCHTIME
:
17538 return "NT_VMS_PATCHTIME";
17540 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17546 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17548 switch (pnote
->type
)
17551 if (pnote
->descsz
> 36)
17553 size_t l
= strlen (pnote
->descdata
+ 34);
17554 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17555 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17556 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17557 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17560 printf (_(" Invalid size\n"));
17563 printf (_(" Language: %s\n"), pnote
->descdata
);
17566 case NT_VMS_FPMODE
:
17567 printf (_(" Floating Point mode: "));
17568 printf ("0x%016" BFD_VMA_FMT
"x\n",
17569 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17571 case NT_VMS_LINKTIME
:
17572 printf (_(" Link time: "));
17574 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17577 case NT_VMS_PATCHTIME
:
17578 printf (_(" Patch time: "));
17580 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17583 case NT_VMS_ORIG_DYN
:
17584 printf (_(" Major id: %u, minor id: %u\n"),
17585 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17586 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17587 printf (_(" Last modified : "));
17589 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17590 printf (_("\n Link flags : "));
17591 printf ("0x%016" BFD_VMA_FMT
"x\n",
17592 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17593 printf (_(" Header flags: 0x%08x\n"),
17594 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17595 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17598 case NT_VMS_IMGNAM
:
17599 printf (_(" Image name: %s\n"), pnote
->descdata
);
17601 case NT_VMS_GSTNAM
:
17602 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17605 printf (_(" Image id: %s\n"), pnote
->descdata
);
17607 case NT_VMS_LINKID
:
17608 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17616 /* Find the symbol associated with a build attribute that is attached
17617 to address OFFSET. If PNAME is non-NULL then store the name of
17618 the symbol (if found) in the provided pointer, Returns NULL if a
17619 symbol could not be found. */
17621 static Elf_Internal_Sym
*
17622 get_symbol_for_build_attribute (Filedata
* filedata
,
17623 unsigned long offset
,
17624 bfd_boolean is_open_attr
,
17625 const char ** pname
)
17627 static Filedata
* saved_filedata
= NULL
;
17628 static char * strtab
;
17629 static unsigned long strtablen
;
17630 static Elf_Internal_Sym
* symtab
;
17631 static unsigned long nsyms
;
17632 Elf_Internal_Sym
* saved_sym
= NULL
;
17633 Elf_Internal_Sym
* sym
;
17635 if (filedata
->section_headers
!= NULL
17636 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17638 Elf_Internal_Shdr
* symsec
;
17640 /* Load the symbol and string sections. */
17641 for (symsec
= filedata
->section_headers
;
17642 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17645 if (symsec
->sh_type
== SHT_SYMTAB
)
17647 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17649 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17651 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17653 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17654 1, strtab_sec
->sh_size
,
17655 _("string table"));
17656 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17660 saved_filedata
= filedata
;
17663 if (symtab
== NULL
|| strtab
== NULL
)
17666 /* Find a symbol whose value matches offset. */
17667 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17668 if (sym
->st_value
== offset
)
17670 if (sym
->st_name
>= strtablen
)
17671 /* Huh ? This should not happen. */
17674 if (strtab
[sym
->st_name
] == 0)
17677 /* The AArch64 and ARM architectures define mapping symbols
17678 (eg $d, $x, $t) which we want to ignore. */
17679 if (strtab
[sym
->st_name
] == '$'
17680 && strtab
[sym
->st_name
+ 1] != 0
17681 && strtab
[sym
->st_name
+ 2] == 0)
17686 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17687 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17688 FUNC symbols entirely. */
17689 switch (ELF_ST_TYPE (sym
->st_info
))
17696 /* If the symbol has a size associated
17697 with it then we can stop searching. */
17698 sym
= symtab
+ nsyms
;
17703 /* Ignore function symbols. */
17710 switch (ELF_ST_BIND (sym
->st_info
))
17713 if (saved_sym
== NULL
17714 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17719 if (saved_sym
== NULL
)
17729 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17737 if (saved_sym
&& pname
)
17738 * pname
= strtab
+ saved_sym
->st_name
;
17743 /* Returns true iff addr1 and addr2 are in the same section. */
17746 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
17748 Elf_Internal_Shdr
* a1
;
17749 Elf_Internal_Shdr
* a2
;
17751 a1
= find_section_by_address (filedata
, addr1
);
17752 a2
= find_section_by_address (filedata
, addr2
);
17754 return a1
== a2
&& a1
!= NULL
;
17758 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17759 Filedata
* filedata
)
17761 static unsigned long global_offset
= 0;
17762 static unsigned long global_end
= 0;
17763 static unsigned long func_offset
= 0;
17764 static unsigned long func_end
= 0;
17766 Elf_Internal_Sym
* sym
;
17768 unsigned long start
;
17770 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17772 switch (pnote
->descsz
)
17775 /* A zero-length description means that the range of
17776 the previous note of the same type should be used. */
17779 if (global_end
> global_offset
)
17780 printf (_(" Applies to region from %#lx to %#lx\n"),
17781 global_offset
, global_end
);
17783 printf (_(" Applies to region from %#lx\n"), global_offset
);
17787 if (func_end
> func_offset
)
17788 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
17790 printf (_(" Applies to region from %#lx\n"), func_offset
);
17795 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17802 /* FIXME: We should check that version 3+ notes are being used here... */
17803 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17804 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17808 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17814 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17815 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
17819 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17820 printf (_(" <invalid descsz>"));
17825 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
17826 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17827 in order to avoid them being confused with the start address of the
17828 first function in the file... */
17829 if (sym
== NULL
&& is_open_attr
)
17830 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
17833 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
17834 end
= start
+ sym
->st_size
;
17838 /* FIXME: Need to properly allow for section alignment.
17839 16 is just the alignment used on x86_64. */
17841 && start
> BFD_ALIGN (global_end
, 16)
17842 /* Build notes are not guaranteed to be organised in order of
17843 increasing address, but we should find the all of the notes
17844 for one section in the same place. */
17845 && same_section (filedata
, start
, global_end
))
17846 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17847 global_end
+ 1, start
- 1);
17849 printf (_(" Applies to region from %#lx"), start
);
17850 global_offset
= start
;
17854 printf (_(" to %#lx"), end
);
17860 printf (_(" Applies to region from %#lx"), start
);
17861 func_offset
= start
;
17865 printf (_(" to %#lx"), end
);
17871 printf (_(" (%s)"), name
);
17878 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17880 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17881 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17882 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17884 char name_attribute
;
17885 const char * expected_types
;
17886 const char * name
= pnote
->namedata
;
17890 if (name
== NULL
|| pnote
->namesz
< 2)
17892 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17893 print_symbol (-20, _(" <corrupt name>"));
17902 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17903 if (name
[0] == 'G' && name
[1] == 'A')
17905 if (pnote
->namesz
< 4)
17907 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17908 print_symbol (-20, _(" <corrupt name>"));
17917 switch ((name_type
= * name
))
17919 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17920 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17921 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17922 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17923 printf ("%c", * name
);
17927 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17928 print_symbol (-20, _("<unknown name type>"));
17935 switch ((name_attribute
= * name
))
17937 case GNU_BUILD_ATTRIBUTE_VERSION
:
17938 text
= _("<version>");
17939 expected_types
= string_expected
;
17942 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17943 text
= _("<stack prot>");
17944 expected_types
= "!+*";
17947 case GNU_BUILD_ATTRIBUTE_RELRO
:
17948 text
= _("<relro>");
17949 expected_types
= bool_expected
;
17952 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17953 text
= _("<stack size>");
17954 expected_types
= number_expected
;
17957 case GNU_BUILD_ATTRIBUTE_TOOL
:
17958 text
= _("<tool>");
17959 expected_types
= string_expected
;
17962 case GNU_BUILD_ATTRIBUTE_ABI
:
17964 expected_types
= "$*";
17967 case GNU_BUILD_ATTRIBUTE_PIC
:
17969 expected_types
= number_expected
;
17972 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17973 text
= _("<short enum>");
17974 expected_types
= bool_expected
;
17978 if (ISPRINT (* name
))
17980 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17982 if (len
> left
&& ! do_wide
)
17984 printf ("%.*s:", len
, name
);
17990 static char tmpbuf
[128];
17992 error (_("unrecognised byte in name field: %d\n"), * name
);
17993 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17997 expected_types
= "*$!+";
18002 left
-= printf ("%s", text
);
18004 if (strchr (expected_types
, name_type
) == NULL
)
18005 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
18007 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
18009 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18010 (unsigned long) pnote
->namesz
,
18011 (long) (name
- pnote
->namedata
));
18015 if (left
< 1 && ! do_wide
)
18020 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18022 unsigned int bytes
;
18023 unsigned long long val
= 0;
18024 unsigned int shift
= 0;
18025 char * decoded
= NULL
;
18027 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
18029 /* The -1 is because the name field is always 0 terminated, and we
18030 want to be able to ensure that the shift in the while loop below
18031 will not overflow. */
18034 if (bytes
> sizeof (val
))
18036 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18038 bytes
= sizeof (val
);
18040 /* We do not bother to warn if bytes == 0 as this can
18041 happen with some early versions of the gcc plugin. */
18045 unsigned long byte
= (* name
++) & 0xff;
18047 val
|= byte
<< shift
;
18051 switch (name_attribute
)
18053 case GNU_BUILD_ATTRIBUTE_PIC
:
18056 case 0: decoded
= "static"; break;
18057 case 1: decoded
= "pic"; break;
18058 case 2: decoded
= "PIC"; break;
18059 case 3: decoded
= "pie"; break;
18060 case 4: decoded
= "PIE"; break;
18064 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18067 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18068 case 0: decoded
= "off"; break;
18069 case 1: decoded
= "on"; break;
18070 case 2: decoded
= "all"; break;
18071 case 3: decoded
= "strong"; break;
18072 case 4: decoded
= "explicit"; break;
18080 if (decoded
!= NULL
)
18082 print_symbol (-left
, decoded
);
18093 left
-= printf ("0x%llx", val
);
18095 left
-= printf ("0x%-.*llx", left
, val
);
18099 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18100 left
-= print_symbol (- left
, name
);
18102 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18103 left
-= print_symbol (- left
, "true");
18105 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18106 left
-= print_symbol (- left
, "false");
18110 if (do_wide
&& left
> 0)
18111 printf ("%-*s", left
, " ");
18116 /* Note that by the ELF standard, the name field is already null byte
18117 terminated, and namesz includes the terminating null byte.
18118 I.E. the value of namesz for the name "FSF" is 4.
18120 If the value of namesz is zero, there is no name present. */
18123 process_note (Elf_Internal_Note
* pnote
,
18124 Filedata
* filedata
)
18126 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
18129 if (pnote
->namesz
== 0)
18130 /* If there is no note name, then use the default set of
18131 note type strings. */
18132 nt
= get_note_type (filedata
, pnote
->type
);
18134 else if (const_strneq (pnote
->namedata
, "GNU"))
18135 /* GNU-specific object file notes. */
18136 nt
= get_gnu_elf_note_type (pnote
->type
);
18138 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
18139 /* FreeBSD-specific core file notes. */
18140 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
18142 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
18143 /* NetBSD-specific core file notes. */
18144 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
18146 else if (const_strneq (pnote
->namedata
, "NetBSD"))
18147 /* NetBSD-specific core file notes. */
18148 return process_netbsd_elf_note (pnote
);
18150 else if (strneq (pnote
->namedata
, "SPU/", 4))
18152 /* SPU-specific core file notes. */
18153 nt
= pnote
->namedata
+ 4;
18157 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18158 /* VMS/ia64-specific file notes. */
18159 nt
= get_ia64_vms_note_type (pnote
->type
);
18161 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18162 nt
= get_stapsdt_note_type (pnote
->type
);
18165 /* Don't recognize this note name; just use the default set of
18166 note type strings. */
18167 nt
= get_note_type (filedata
, pnote
->type
);
18171 if (((const_strneq (pnote
->namedata
, "GA")
18172 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18173 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18174 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18175 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18176 print_gnu_build_attribute_name (pnote
);
18178 print_symbol (-20, name
);
18181 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
18183 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
18185 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18186 return print_ia64_vms_note (pnote
);
18187 else if (const_strneq (pnote
->namedata
, "GNU"))
18188 return print_gnu_note (filedata
, pnote
);
18189 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18190 return print_stapsdt_note (pnote
);
18191 else if (const_strneq (pnote
->namedata
, "CORE"))
18192 return print_core_note (pnote
);
18193 else if (((const_strneq (pnote
->namedata
, "GA")
18194 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18195 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18196 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18197 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18198 return print_gnu_build_attribute_description (pnote
, filedata
);
18204 printf (_(" description data: "));
18205 for (i
= 0; i
< pnote
->descsz
; i
++)
18206 printf ("%02x ", pnote
->descdata
[i
]);
18218 process_notes_at (Filedata
* filedata
,
18219 Elf_Internal_Shdr
* section
,
18224 Elf_External_Note
* pnotes
;
18225 Elf_External_Note
* external
;
18227 bfd_boolean res
= TRUE
;
18234 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18237 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18242 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18245 if (pnotes
== NULL
)
18251 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18253 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18254 (unsigned long) offset
, (unsigned long) length
);
18256 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18257 specifies that notes should be aligned to 4 bytes in 32-bit
18258 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18259 we also support 4 byte alignment in 64-bit objects. If section
18260 alignment is less than 4, we treate alignment as 4 bytes. */
18263 else if (align
!= 4 && align
!= 8)
18265 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18270 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18272 end
= (char *) pnotes
+ length
;
18273 while ((char *) external
< end
)
18275 Elf_Internal_Note inote
;
18278 char * temp
= NULL
;
18279 size_t data_remaining
= end
- (char *) external
;
18281 if (!is_ia64_vms (filedata
))
18283 /* PR binutils/15191
18284 Make sure that there is enough data to read. */
18285 min_notesz
= offsetof (Elf_External_Note
, name
);
18286 if (data_remaining
< min_notesz
)
18288 warn (ngettext ("Corrupt note: only %ld byte remains, "
18289 "not enough for a full note\n",
18290 "Corrupt note: only %ld bytes remain, "
18291 "not enough for a full note\n",
18293 (long) data_remaining
);
18296 data_remaining
-= min_notesz
;
18298 inote
.type
= BYTE_GET (external
->type
);
18299 inote
.namesz
= BYTE_GET (external
->namesz
);
18300 inote
.namedata
= external
->name
;
18301 inote
.descsz
= BYTE_GET (external
->descsz
);
18302 inote
.descdata
= ((char *) external
18303 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18304 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18305 next
= ((char *) external
18306 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18310 Elf64_External_VMS_Note
*vms_external
;
18312 /* PR binutils/15191
18313 Make sure that there is enough data to read. */
18314 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18315 if (data_remaining
< min_notesz
)
18317 warn (ngettext ("Corrupt note: only %ld byte remains, "
18318 "not enough for a full note\n",
18319 "Corrupt note: only %ld bytes remain, "
18320 "not enough for a full note\n",
18322 (long) data_remaining
);
18325 data_remaining
-= min_notesz
;
18327 vms_external
= (Elf64_External_VMS_Note
*) external
;
18328 inote
.type
= BYTE_GET (vms_external
->type
);
18329 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18330 inote
.namedata
= vms_external
->name
;
18331 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18332 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18333 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18334 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18337 /* PR 17531: file: 3443835e. */
18338 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18339 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18340 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18341 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18342 || ((size_t) (next
- inote
.descdata
)
18343 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18345 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18346 (unsigned long) ((char *) external
- (char *) pnotes
));
18347 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18348 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18352 external
= (Elf_External_Note
*) next
;
18354 /* Verify that name is null terminated. It appears that at least
18355 one version of Linux (RedHat 6.0) generates corefiles that don't
18356 comply with the ELF spec by failing to include the null byte in
18358 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18360 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18362 temp
= (char *) malloc (inote
.namesz
+ 1);
18365 error (_("Out of memory allocating space for inote name\n"));
18370 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18371 inote
.namedata
= temp
;
18373 inote
.namedata
[inote
.namesz
] = 0;
18376 if (! process_note (& inote
, filedata
))
18392 process_corefile_note_segments (Filedata
* filedata
)
18394 Elf_Internal_Phdr
* segment
;
18396 bfd_boolean res
= TRUE
;
18398 if (! get_program_headers (filedata
))
18401 for (i
= 0, segment
= filedata
->program_headers
;
18402 i
< filedata
->file_header
.e_phnum
;
18405 if (segment
->p_type
== PT_NOTE
)
18406 if (! process_notes_at (filedata
, NULL
,
18407 (bfd_vma
) segment
->p_offset
,
18408 (bfd_vma
) segment
->p_filesz
,
18409 (bfd_vma
) segment
->p_align
))
18417 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18419 Elf_External_Note
* pnotes
;
18420 Elf_External_Note
* external
;
18422 bfd_boolean res
= TRUE
;
18427 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18429 if (pnotes
== NULL
)
18433 end
= (char*) pnotes
+ length
;
18435 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18436 (unsigned long) offset
, (unsigned long) length
);
18438 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18440 Elf_External_Note
* next
;
18441 Elf_Internal_Note inote
;
18443 inote
.type
= BYTE_GET (external
->type
);
18444 inote
.namesz
= BYTE_GET (external
->namesz
);
18445 inote
.namedata
= external
->name
;
18446 inote
.descsz
= BYTE_GET (external
->descsz
);
18447 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18448 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18450 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18452 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18453 inote
.descdata
= inote
.namedata
;
18457 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18459 if ( ((char *) next
> end
)
18460 || ((char *) next
< (char *) pnotes
))
18462 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18463 (unsigned long) ((char *) external
- (char *) pnotes
));
18464 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18465 inote
.type
, inote
.namesz
, inote
.descsz
);
18471 /* Prevent out-of-bounds indexing. */
18472 if ( inote
.namedata
+ inote
.namesz
> end
18473 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18475 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18476 (unsigned long) ((char *) external
- (char *) pnotes
));
18477 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18478 inote
.type
, inote
.namesz
, inote
.descsz
);
18482 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18484 if (! print_v850_note (& inote
))
18487 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18488 inote
.namesz
, inote
.descsz
);
18498 process_note_sections (Filedata
* filedata
)
18500 Elf_Internal_Shdr
* section
;
18502 unsigned int n
= 0;
18503 bfd_boolean res
= TRUE
;
18505 for (i
= 0, section
= filedata
->section_headers
;
18506 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18509 if (section
->sh_type
== SHT_NOTE
)
18511 if (! process_notes_at (filedata
, section
,
18512 (bfd_vma
) section
->sh_offset
,
18513 (bfd_vma
) section
->sh_size
,
18514 (bfd_vma
) section
->sh_addralign
))
18519 if (( filedata
->file_header
.e_machine
== EM_V800
18520 || filedata
->file_header
.e_machine
== EM_V850
18521 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18522 && section
->sh_type
== SHT_RENESAS_INFO
)
18524 if (! process_v850_notes (filedata
,
18525 (bfd_vma
) section
->sh_offset
,
18526 (bfd_vma
) section
->sh_size
))
18533 /* Try processing NOTE segments instead. */
18534 return process_corefile_note_segments (filedata
);
18540 process_notes (Filedata
* filedata
)
18542 /* If we have not been asked to display the notes then do nothing. */
18546 if (filedata
->file_header
.e_type
!= ET_CORE
)
18547 return process_note_sections (filedata
);
18549 /* No program headers means no NOTE segment. */
18550 if (filedata
->file_header
.e_phnum
> 0)
18551 return process_corefile_note_segments (filedata
);
18553 printf (_("No note segments present in the core file.\n"));
18557 static unsigned char *
18558 display_public_gnu_attributes (unsigned char * start
,
18559 const unsigned char * const end
)
18561 printf (_(" Unknown GNU attribute: %s\n"), start
);
18563 start
+= strnlen ((char *) start
, end
- start
);
18564 display_raw_attribute (start
, end
);
18566 return (unsigned char *) end
;
18569 static unsigned char *
18570 display_generic_attribute (unsigned char * start
,
18572 const unsigned char * const end
)
18575 return (unsigned char *) end
;
18577 return display_tag_value (tag
, start
, end
);
18581 process_arch_specific (Filedata
* filedata
)
18586 switch (filedata
->file_header
.e_machine
)
18589 case EM_ARC_COMPACT
:
18590 case EM_ARC_COMPACT2
:
18591 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18592 display_arc_attribute
,
18593 display_generic_attribute
);
18595 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18596 display_arm_attribute
,
18597 display_generic_attribute
);
18600 case EM_MIPS_RS3_LE
:
18601 return process_mips_specific (filedata
);
18604 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18605 display_msp430x_attribute
,
18606 display_generic_attribute
);
18609 return process_nds32_specific (filedata
);
18613 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18614 display_power_gnu_attribute
);
18618 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18619 display_s390_gnu_attribute
);
18622 case EM_SPARC32PLUS
:
18624 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18625 display_sparc_gnu_attribute
);
18628 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18629 display_tic6x_attribute
,
18630 display_generic_attribute
);
18633 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18634 display_public_gnu_attributes
,
18635 display_generic_attribute
);
18640 get_file_header (Filedata
* filedata
)
18642 /* Read in the identity array. */
18643 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18646 /* Determine how to read the rest of the header. */
18647 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18652 byte_get
= byte_get_little_endian
;
18653 byte_put
= byte_put_little_endian
;
18656 byte_get
= byte_get_big_endian
;
18657 byte_put
= byte_put_big_endian
;
18661 /* For now we only support 32 bit and 64 bit ELF files. */
18662 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18664 /* Read in the rest of the header. */
18667 Elf32_External_Ehdr ehdr32
;
18669 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18672 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18673 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18674 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18675 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18676 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18677 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18678 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18679 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18680 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18681 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18682 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18683 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18684 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18688 Elf64_External_Ehdr ehdr64
;
18690 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18691 we will not be able to cope with the 64bit data found in
18692 64 ELF files. Detect this now and abort before we start
18693 overwriting things. */
18694 if (sizeof (bfd_vma
) < 8)
18696 error (_("This instance of readelf has been built without support for a\n\
18697 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18701 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18704 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18705 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18706 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18707 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18708 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18709 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18710 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18711 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18712 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18713 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18714 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18715 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18716 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18719 if (filedata
->file_header
.e_shoff
)
18721 /* There may be some extensions in the first section header. Don't
18722 bomb if we can't read it. */
18724 get_32bit_section_headers (filedata
, TRUE
);
18726 get_64bit_section_headers (filedata
, TRUE
);
18733 close_file (Filedata
* filedata
)
18737 if (filedata
->handle
)
18738 fclose (filedata
->handle
);
18744 close_debug_file (void * data
)
18746 close_file ((Filedata
*) data
);
18750 open_file (const char * pathname
)
18752 struct stat statbuf
;
18753 Filedata
* filedata
= NULL
;
18755 if (stat (pathname
, & statbuf
) < 0
18756 || ! S_ISREG (statbuf
.st_mode
))
18759 filedata
= calloc (1, sizeof * filedata
);
18760 if (filedata
== NULL
)
18763 filedata
->handle
= fopen (pathname
, "rb");
18764 if (filedata
->handle
== NULL
)
18767 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
18768 filedata
->file_name
= pathname
;
18770 if (! get_file_header (filedata
))
18773 if (filedata
->file_header
.e_shoff
)
18777 /* Read the section headers again, this time for real. */
18779 res
= get_32bit_section_headers (filedata
, FALSE
);
18781 res
= get_64bit_section_headers (filedata
, FALSE
);
18792 if (filedata
->handle
)
18793 fclose (filedata
->handle
);
18800 open_debug_file (const char * pathname
)
18802 return open_file (pathname
);
18805 /* Process one ELF object file according to the command line options.
18806 This file may actually be stored in an archive. The file is
18807 positioned at the start of the ELF object. Returns TRUE if no
18808 problems were encountered, FALSE otherwise. */
18811 process_object (Filedata
* filedata
)
18813 Filedata
* separates
;
18815 bfd_boolean res
= TRUE
;
18817 if (! get_file_header (filedata
))
18819 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
18823 /* Initialise per file variables. */
18824 for (i
= ARRAY_SIZE (version_info
); i
--;)
18825 version_info
[i
] = 0;
18827 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18828 dynamic_info
[i
] = 0;
18829 dynamic_info_DT_GNU_HASH
= 0;
18831 /* Process the file. */
18833 printf (_("\nFile: %s\n"), filedata
->file_name
);
18835 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18836 Note we do this even if cmdline_dump_sects is empty because we
18837 must make sure that the dump_sets array is zeroed out before each
18838 object file is processed. */
18839 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
18840 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
18842 if (cmdline
.num_dump_sects
> 0)
18844 if (filedata
->num_dump_sects
== 0)
18845 /* A sneaky way of allocating the dump_sects array. */
18846 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
18848 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
18849 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
18850 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
18853 if (! process_file_header (filedata
))
18856 if (! process_section_headers (filedata
))
18858 /* Without loaded section headers we cannot process lots of things. */
18859 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18861 if (! do_using_dynamic
)
18862 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18865 if (! process_section_groups (filedata
))
18866 /* Without loaded section groups we cannot process unwind. */
18869 if (process_program_headers (filedata
))
18870 process_dynamic_section (filedata
);
18874 if (! process_relocs (filedata
))
18877 if (! process_unwind (filedata
))
18880 if (! process_symbol_table (filedata
))
18883 if (! process_syminfo (filedata
))
18886 if (! process_version_sections (filedata
))
18889 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
18890 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
18894 if (! process_section_contents (filedata
))
18899 if (! process_section_headers (separates
))
18901 else if (! process_section_contents (separates
))
18905 if (! process_notes (filedata
))
18908 if (! process_gnu_liblist (filedata
))
18911 if (! process_arch_specific (filedata
))
18914 free (filedata
->program_headers
);
18915 filedata
->program_headers
= NULL
;
18917 free (filedata
->section_headers
);
18918 filedata
->section_headers
= NULL
;
18920 free (filedata
->string_table
);
18921 filedata
->string_table
= NULL
;
18922 filedata
->string_table_length
= 0;
18924 if (dynamic_strings
)
18926 free (dynamic_strings
);
18927 dynamic_strings
= NULL
;
18928 dynamic_strings_length
= 0;
18931 if (dynamic_symbols
)
18933 free (dynamic_symbols
);
18934 dynamic_symbols
= NULL
;
18935 num_dynamic_syms
= 0;
18938 if (dynamic_syminfo
)
18940 free (dynamic_syminfo
);
18941 dynamic_syminfo
= NULL
;
18944 if (dynamic_section
)
18946 free (dynamic_section
);
18947 dynamic_section
= NULL
;
18950 if (section_headers_groups
)
18952 free (section_headers_groups
);
18953 section_headers_groups
= NULL
;
18956 if (section_groups
)
18958 struct group_list
* g
;
18959 struct group_list
* next
;
18961 for (i
= 0; i
< group_count
; i
++)
18963 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18970 free (section_groups
);
18971 section_groups
= NULL
;
18974 free_debug_memory ();
18979 /* Process an ELF archive.
18980 On entry the file is positioned just after the ARMAG string.
18981 Returns TRUE upon success, FALSE otherwise. */
18984 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
18986 struct archive_info arch
;
18987 struct archive_info nested_arch
;
18989 bfd_boolean ret
= TRUE
;
18993 /* The ARCH structure is used to hold information about this archive. */
18994 arch
.file_name
= NULL
;
18996 arch
.index_array
= NULL
;
18997 arch
.sym_table
= NULL
;
18998 arch
.longnames
= NULL
;
19000 /* The NESTED_ARCH structure is used as a single-item cache of information
19001 about a nested archive (when members of a thin archive reside within
19002 another regular archive file). */
19003 nested_arch
.file_name
= NULL
;
19004 nested_arch
.file
= NULL
;
19005 nested_arch
.index_array
= NULL
;
19006 nested_arch
.sym_table
= NULL
;
19007 nested_arch
.longnames
= NULL
;
19009 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
19010 is_thin_archive
, do_archive_index
) != 0)
19016 if (do_archive_index
)
19018 if (arch
.sym_table
== NULL
)
19019 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
19022 unsigned long i
, l
;
19023 unsigned long current_pos
;
19025 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19026 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
19028 current_pos
= ftell (filedata
->handle
);
19030 for (i
= l
= 0; i
< arch
.index_num
; i
++)
19032 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
19034 char * member_name
;
19036 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
19038 if (member_name
!= NULL
)
19040 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
19042 if (qualified_name
!= NULL
)
19044 printf (_("Contents of binary %s at offset "), qualified_name
);
19045 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
19047 free (qualified_name
);
19052 if (l
>= arch
.sym_size
)
19054 error (_("%s: end of the symbol table reached before the end of the index\n"),
19055 filedata
->file_name
);
19059 /* PR 17531: file: 0b6630b2. */
19060 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
19061 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
19064 if (arch
.uses_64bit_indices
)
19069 if (l
< arch
.sym_size
)
19071 error (ngettext ("%s: %ld byte remains in the symbol table, "
19072 "but without corresponding entries in "
19073 "the index table\n",
19074 "%s: %ld bytes remain in the symbol table, "
19075 "but without corresponding entries in "
19076 "the index table\n",
19077 arch
.sym_size
- l
),
19078 filedata
->file_name
, arch
.sym_size
- l
);
19082 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
19084 error (_("%s: failed to seek back to start of object files in the archive\n"),
19085 filedata
->file_name
);
19091 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
19092 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
19093 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
19094 && !do_section_groups
&& !do_dyn_syms
)
19096 ret
= TRUE
; /* Archive index only. */
19105 char * qualified_name
;
19107 /* Read the next archive header. */
19108 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
19110 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
19113 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
19114 if (got
!= sizeof arch
.arhdr
)
19118 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
19122 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
19124 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
19129 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
19131 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
19132 if (archive_file_size
& 01)
19133 ++archive_file_size
;
19135 name
= get_archive_member_name (&arch
, &nested_arch
);
19138 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19142 namelen
= strlen (name
);
19144 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
19145 if (qualified_name
== NULL
)
19147 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19152 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
19154 /* This is a proxy for an external member of a thin archive. */
19155 Filedata
* member_filedata
;
19156 char * member_file_name
= adjust_relative_path
19157 (filedata
->file_name
, name
, namelen
);
19159 if (member_file_name
== NULL
)
19165 member_filedata
= open_file (member_file_name
);
19166 if (member_filedata
== NULL
)
19168 error (_("Input file '%s' is not readable.\n"), member_file_name
);
19169 free (member_file_name
);
19174 archive_file_offset
= arch
.nested_member_origin
;
19175 member_filedata
->file_name
= qualified_name
;
19177 if (! process_object (member_filedata
))
19180 close_file (member_filedata
);
19181 free (member_file_name
);
19183 else if (is_thin_archive
)
19185 Filedata thin_filedata
;
19187 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
19189 /* PR 15140: Allow for corrupt thin archives. */
19190 if (nested_arch
.file
== NULL
)
19192 error (_("%s: contains corrupt thin archive: %s\n"),
19193 filedata
->file_name
, name
);
19198 /* This is a proxy for a member of a nested archive. */
19199 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19201 /* The nested archive file will have been opened and setup by
19202 get_archive_member_name. */
19203 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19205 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19210 thin_filedata
.handle
= nested_arch
.file
;
19211 thin_filedata
.file_name
= qualified_name
;
19213 if (! process_object (& thin_filedata
))
19218 archive_file_offset
= arch
.next_arhdr_offset
;
19219 arch
.next_arhdr_offset
+= archive_file_size
;
19221 filedata
->file_name
= qualified_name
;
19222 if (! process_object (filedata
))
19226 if (filedata
->dump_sects
!= NULL
)
19228 free (filedata
->dump_sects
);
19229 filedata
->dump_sects
= NULL
;
19230 filedata
->num_dump_sects
= 0;
19233 free (qualified_name
);
19237 if (nested_arch
.file
!= NULL
)
19238 fclose (nested_arch
.file
);
19239 release_archive (&nested_arch
);
19240 release_archive (&arch
);
19246 process_file (char * file_name
)
19248 Filedata
* filedata
= NULL
;
19249 struct stat statbuf
;
19250 char armag
[SARMAG
];
19251 bfd_boolean ret
= TRUE
;
19253 if (stat (file_name
, &statbuf
) < 0)
19255 if (errno
== ENOENT
)
19256 error (_("'%s': No such file\n"), file_name
);
19258 error (_("Could not locate '%s'. System error message: %s\n"),
19259 file_name
, strerror (errno
));
19263 if (! S_ISREG (statbuf
.st_mode
))
19265 error (_("'%s' is not an ordinary file\n"), file_name
);
19269 filedata
= calloc (1, sizeof * filedata
);
19270 if (filedata
== NULL
)
19272 error (_("Out of memory allocating file data structure\n"));
19276 filedata
->file_name
= file_name
;
19277 filedata
->handle
= fopen (file_name
, "rb");
19278 if (filedata
->handle
== NULL
)
19280 error (_("Input file '%s' is not readable.\n"), file_name
);
19285 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19287 error (_("%s: Failed to read file's magic number\n"), file_name
);
19288 fclose (filedata
->handle
);
19293 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19295 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19297 if (! process_archive (filedata
, FALSE
))
19300 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19302 if ( ! process_archive (filedata
, TRUE
))
19307 if (do_archive_index
)
19308 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19311 rewind (filedata
->handle
);
19312 archive_file_size
= archive_file_offset
= 0;
19314 if (! process_object (filedata
))
19318 fclose (filedata
->handle
);
19324 #ifdef SUPPORT_DISASSEMBLY
19325 /* Needed by the i386 disassembler. For extra credit, someone could
19326 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19330 print_address (unsigned int addr
, FILE * outfile
)
19332 fprintf (outfile
,"0x%8.8x", addr
);
19335 /* Needed by the i386 disassembler. */
19338 db_task_printsym (unsigned int addr
)
19340 print_address (addr
, stderr
);
19345 main (int argc
, char ** argv
)
19349 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19350 setlocale (LC_MESSAGES
, "");
19352 #if defined (HAVE_SETLOCALE)
19353 setlocale (LC_CTYPE
, "");
19355 bindtextdomain (PACKAGE
, LOCALEDIR
);
19356 textdomain (PACKAGE
);
19358 expandargv (&argc
, &argv
);
19360 cmdline
.file_name
= "<cmdline>";
19361 parse_args (& cmdline
, argc
, argv
);
19363 if (optind
< (argc
- 1))
19365 else if (optind
>= argc
)
19367 warn (_("Nothing to do.\n"));
19372 while (optind
< argc
)
19373 if (! process_file (argv
[optind
++]))
19376 if (cmdline
.dump_sects
!= NULL
)
19377 free (cmdline
.dump_sects
);
19379 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;