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/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/mmix.h"
128 #include "elf/mn10200.h"
129 #include "elf/mn10300.h"
130 #include "elf/moxie.h"
132 #include "elf/msp430.h"
133 #include "elf/nds32.h"
134 #include "elf/nios2.h"
135 #include "elf/or1k.h"
138 #include "elf/ppc64.h"
140 #include "elf/riscv.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/wasm32.h"
155 #include "elf/x86-64.h"
156 #include "elf/xc16x.h"
157 #include "elf/xgate.h"
158 #include "elf/xstormy16.h"
159 #include "elf/xtensa.h"
162 #include "libiberty.h"
163 #include "safe-ctype.h"
164 #include "filenames.h"
167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
170 typedef struct elf_section_list
172 Elf_Internal_Shdr
* hdr
;
173 struct elf_section_list
* next
;
176 /* Flag bits indicating particular types of dump. */
177 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
178 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
179 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
180 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
181 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
183 typedef unsigned char dump_type
;
185 /* A linked list of the section names for which dumps were requested. */
186 struct dump_list_entry
190 struct dump_list_entry
* next
;
193 typedef struct filedata
195 const char * file_name
;
197 bfd_size_type file_size
;
198 Elf_Internal_Ehdr file_header
;
199 Elf_Internal_Shdr
* section_headers
;
200 Elf_Internal_Phdr
* program_headers
;
202 unsigned long string_table_length
;
203 /* A dynamic array of flags indicating for which sections a dump of
204 some kind has been requested. It is reset on a per-object file
205 basis and then initialised from the cmdline_dump_sects array,
206 the results of interpreting the -w switch, and the
207 dump_sects_byname list. */
208 dump_type
* dump_sects
;
209 unsigned int num_dump_sects
;
212 char * program_name
= "readelf";
214 static unsigned long archive_file_offset
;
215 static unsigned long archive_file_size
;
216 static unsigned long dynamic_addr
;
217 static bfd_size_type dynamic_size
;
218 static size_t dynamic_nent
;
219 static char * dynamic_strings
;
220 static unsigned long dynamic_strings_length
;
221 static unsigned long num_dynamic_syms
;
222 static Elf_Internal_Sym
* dynamic_symbols
;
223 static Elf_Internal_Syminfo
* dynamic_syminfo
;
224 static unsigned long dynamic_syminfo_offset
;
225 static unsigned int dynamic_syminfo_nent
;
226 static char program_interpreter
[PATH_MAX
];
227 static bfd_vma dynamic_info
[DT_ENCODING
];
228 static bfd_vma dynamic_info_DT_GNU_HASH
;
229 static bfd_vma version_info
[16];
230 static Elf_Internal_Dyn
* dynamic_section
;
231 static elf_section_list
* symtab_shndx_list
;
232 static bfd_boolean show_name
= FALSE
;
233 static bfd_boolean do_dynamic
= FALSE
;
234 static bfd_boolean do_syms
= FALSE
;
235 static bfd_boolean do_dyn_syms
= FALSE
;
236 static bfd_boolean do_reloc
= FALSE
;
237 static bfd_boolean do_sections
= FALSE
;
238 static bfd_boolean do_section_groups
= FALSE
;
239 static bfd_boolean do_section_details
= FALSE
;
240 static bfd_boolean do_segments
= FALSE
;
241 static bfd_boolean do_unwind
= FALSE
;
242 static bfd_boolean do_using_dynamic
= FALSE
;
243 static bfd_boolean do_header
= FALSE
;
244 static bfd_boolean do_dump
= FALSE
;
245 static bfd_boolean do_version
= FALSE
;
246 static bfd_boolean do_histogram
= FALSE
;
247 static bfd_boolean do_debugging
= FALSE
;
248 static bfd_boolean do_arch
= FALSE
;
249 static bfd_boolean do_notes
= FALSE
;
250 static bfd_boolean do_archive_index
= FALSE
;
251 static bfd_boolean is_32bit_elf
= FALSE
;
252 static bfd_boolean decompress_dumps
= FALSE
;
256 struct group_list
* next
;
257 unsigned int section_index
;
262 struct group_list
* root
;
263 unsigned int group_index
;
266 static size_t group_count
;
267 static struct group
* section_groups
;
268 static struct group
** section_headers_groups
;
270 /* A dynamic array of flags indicating for which sections a dump
271 has been requested via command line switches. */
272 static Filedata cmdline
;
274 static struct dump_list_entry
* dump_sects_byname
;
276 /* How to print a vma value. */
277 typedef enum print_mode
289 /* Versioned symbol info. */
290 enum versioned_symbol_info
297 static const char * get_symbol_version_string
298 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
299 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
303 #define SECTION_NAME(X) \
304 ((X) == NULL ? _("<none>") \
305 : filedata->string_table == NULL ? _("<no-strings>") \
306 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
307 : filedata->string_table + (X)->sh_name))
309 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
311 #define GET_ELF_SYMBOLS(file, section, sym_count) \
312 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
313 : get_64bit_elf_symbols (file, section, sym_count))
315 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
316 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
317 already been called and verified that the string exists. */
318 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
320 #define REMOVE_ARCH_BITS(ADDR) \
323 if (filedata->file_header.e_machine == EM_ARM) \
328 /* Print a BFD_VMA to an internal buffer, for use in error messages.
329 BFD_FMA_FMT can't be used in translated strings. */
332 bfd_vmatoa (char *fmtch
, bfd_vma value
)
334 /* bfd_vmatoa is used more then once in a printf call for output.
335 Cycle through an array of buffers. */
336 static int buf_pos
= 0;
337 static struct bfd_vmatoa_buf
344 ret
= buf
[buf_pos
++].place
;
345 buf_pos
%= ARRAY_SIZE (buf
);
347 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
348 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
352 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
353 OFFSET + the offset of the current archive member, if we are examining an
354 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
355 allocate a buffer using malloc and fill that. In either case return the
356 pointer to the start of the retrieved data or NULL if something went wrong.
357 If something does go wrong and REASON is not NULL then emit an error
358 message using REASON as part of the context. */
361 get_data (void * var
,
363 unsigned long offset
,
369 bfd_size_type amt
= size
* nmemb
;
371 if (size
== 0 || nmemb
== 0)
374 /* If the size_t type is smaller than the bfd_size_type, eg because
375 you are building a 32-bit tool on a 64-bit host, then make sure
376 that when the sizes are cast to (size_t) no information is lost. */
377 if (sizeof (size_t) < sizeof (bfd_size_type
)
378 && ( (bfd_size_type
) ((size_t) size
) != size
379 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
382 error (_("Size truncation prevents reading %s"
383 " elements of size %s for %s\n"),
384 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
388 /* Check for size overflow. */
392 error (_("Size overflow prevents reading %s"
393 " elements of size %s for %s\n"),
394 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
398 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
399 attempting to allocate memory when the read is bound to fail. */
400 if (amt
> filedata
->file_size
401 || offset
+ archive_file_offset
+ amt
> filedata
->file_size
)
404 error (_("Reading %s bytes extends past end of file for %s\n"),
405 bfd_vmatoa ("u", amt
), reason
);
409 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
412 error (_("Unable to seek to 0x%lx for %s\n"),
413 archive_file_offset
+ offset
, reason
);
420 /* Check for overflow. */
421 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
422 /* + 1 so that we can '\0' terminate invalid string table sections. */
423 mvar
= malloc ((size_t) amt
+ 1);
428 error (_("Out of memory allocating %s bytes for %s\n"),
429 bfd_vmatoa ("u", amt
), reason
);
433 ((char *) mvar
)[amt
] = '\0';
436 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
439 error (_("Unable to read in %s bytes of %s\n"),
440 bfd_vmatoa ("u", amt
), reason
);
449 /* Print a VMA value in the MODE specified.
450 Returns the number of characters displayed. */
453 print_vma (bfd_vma vma
, print_mode mode
)
465 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
472 return printf ("%5" BFD_VMA_FMT
"d", vma
);
478 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
481 return printf ("%" BFD_VMA_FMT
"d", vma
);
484 return printf ("%" BFD_VMA_FMT
"u", vma
);
487 /* FIXME: Report unrecognised mode ? */
492 /* Display a symbol on stdout. Handles the display of control characters and
493 multibye characters (assuming the host environment supports them).
495 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
497 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
498 padding as necessary.
500 Returns the number of emitted characters. */
503 print_symbol (signed int width
, const char *symbol
)
505 bfd_boolean extra_padding
= FALSE
;
506 signed int num_printed
= 0;
507 #ifdef HAVE_MBSTATE_T
510 unsigned int width_remaining
;
514 /* Keep the width positive. This helps the code below. */
516 extra_padding
= TRUE
;
521 /* Set the remaining width to a very large value.
522 This simplifies the code below. */
523 width_remaining
= INT_MAX
;
525 width_remaining
= width
;
527 #ifdef HAVE_MBSTATE_T
528 /* Initialise the multibyte conversion state. */
529 memset (& state
, 0, sizeof (state
));
532 while (width_remaining
)
535 const char c
= *symbol
++;
540 /* Do not print control characters directly as they can affect terminal
541 settings. Such characters usually appear in the names generated
542 by the assembler for local labels. */
545 if (width_remaining
< 2)
548 printf ("^%c", c
+ 0x40);
549 width_remaining
-= 2;
552 else if (ISPRINT (c
))
560 #ifdef HAVE_MBSTATE_T
563 /* Let printf do the hard work of displaying multibyte characters. */
564 printf ("%.1s", symbol
- 1);
568 #ifdef HAVE_MBSTATE_T
569 /* Try to find out how many bytes made up the character that was
570 just printed. Advance the symbol pointer past the bytes that
572 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
576 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
581 if (extra_padding
&& num_printed
< width
)
583 /* Fill in the remaining spaces. */
584 printf ("%-*s", width
- num_printed
, " ");
591 /* Returns a pointer to a static buffer containing a printable version of
592 the given section's name. Like print_symbol, except that it does not try
593 to print multibyte characters, it just interprets them as hex values. */
596 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
598 #define MAX_PRINT_SEC_NAME_LEN 128
599 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
600 const char * name
= SECTION_NAME (sec
);
601 char * buf
= sec_name_buf
;
603 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
605 while ((c
= * name
++) != 0)
616 else if (ISPRINT (c
))
623 static char hex
[17] = "0123456789ABCDEF";
628 * buf
++ = hex
[(c
& 0xf0) >> 4];
629 * buf
++ = hex
[c
& 0x0f];
643 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
645 if (ndx
>= filedata
->file_header
.e_shnum
)
646 return _("<corrupt>");
648 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
651 /* Return a pointer to section NAME, or NULL if no such section exists. */
653 static Elf_Internal_Shdr
*
654 find_section (Filedata
* filedata
, const char * name
)
658 if (filedata
->section_headers
== NULL
)
661 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
662 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
663 return filedata
->section_headers
+ i
;
668 /* Return a pointer to a section containing ADDR, or NULL if no such
671 static Elf_Internal_Shdr
*
672 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
676 if (filedata
->section_headers
== NULL
)
679 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
681 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
683 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
690 static Elf_Internal_Shdr
*
691 find_section_by_type (Filedata
* filedata
, unsigned int type
)
695 if (filedata
->section_headers
== NULL
)
698 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
700 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
702 if (sec
->sh_type
== type
)
709 /* Return a pointer to section NAME, or NULL if no such section exists,
710 restricted to the list of sections given in SET. */
712 static Elf_Internal_Shdr
*
713 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
717 if (filedata
->section_headers
== NULL
)
722 while ((i
= *set
++) > 0)
724 /* See PR 21156 for a reproducer. */
725 if (i
>= filedata
->file_header
.e_shnum
)
726 continue; /* FIXME: Should we issue an error message ? */
728 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
729 return filedata
->section_headers
+ i
;
733 return find_section (filedata
, name
);
736 /* Read an unsigned LEB128 encoded value from DATA.
737 Set *LENGTH_RETURN to the number of bytes read. */
739 static inline unsigned long
740 read_uleb128 (unsigned char * data
,
741 unsigned int * length_return
,
742 const unsigned char * const end
)
744 return read_leb128 (data
, length_return
, FALSE
, end
);
747 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
748 This OS has so many departures from the ELF standard that we test it at
751 static inline bfd_boolean
752 is_ia64_vms (Filedata
* filedata
)
754 return filedata
->file_header
.e_machine
== EM_IA_64
755 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
758 /* Guess the relocation size commonly used by the specific machines. */
761 guess_is_rela (unsigned int e_machine
)
765 /* Targets that use REL relocations. */
780 /* Targets that use RELA relocations. */
784 case EM_ADAPTEVA_EPIPHANY
:
786 case EM_ALTERA_NIOS2
:
789 case EM_ARC_COMPACT2
:
809 case EM_LATTICEMICO32
:
818 case EM_CYGNUS_MN10200
:
820 case EM_CYGNUS_MN10300
:
856 case EM_MICROBLAZE_OLD
:
878 warn (_("Don't know about relocations on this machine architecture\n"));
883 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
884 Returns TRUE upon success, FALSE otherwise. If successful then a
885 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
886 and the number of relocs loaded is placed in *NRELASP. It is the caller's
887 responsibility to free the allocated buffer. */
890 slurp_rela_relocs (Filedata
* filedata
,
891 unsigned long rel_offset
,
892 unsigned long rel_size
,
893 Elf_Internal_Rela
** relasp
,
894 unsigned long * nrelasp
)
896 Elf_Internal_Rela
* relas
;
902 Elf32_External_Rela
* erelas
;
904 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
905 rel_size
, _("32-bit relocation data"));
909 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
911 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
912 sizeof (Elf_Internal_Rela
));
917 error (_("out of memory parsing relocs\n"));
921 for (i
= 0; i
< nrelas
; i
++)
923 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
924 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
925 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
932 Elf64_External_Rela
* erelas
;
934 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
935 rel_size
, _("64-bit relocation data"));
939 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
941 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
942 sizeof (Elf_Internal_Rela
));
947 error (_("out of memory parsing relocs\n"));
951 for (i
= 0; i
< nrelas
; i
++)
953 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
954 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
955 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
957 /* The #ifdef BFD64 below is to prevent a compile time
958 warning. We know that if we do not have a 64 bit data
959 type that we will never execute this code anyway. */
961 if (filedata
->file_header
.e_machine
== EM_MIPS
962 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
964 /* In little-endian objects, r_info isn't really a
965 64-bit little-endian value: it has a 32-bit
966 little-endian symbol index followed by four
967 individual byte fields. Reorder INFO
969 bfd_vma inf
= relas
[i
].r_info
;
970 inf
= (((inf
& 0xffffffff) << 32)
971 | ((inf
>> 56) & 0xff)
972 | ((inf
>> 40) & 0xff00)
973 | ((inf
>> 24) & 0xff0000)
974 | ((inf
>> 8) & 0xff000000));
975 relas
[i
].r_info
= inf
;
988 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
989 Returns TRUE upon success, FALSE otherwise. If successful then a
990 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
991 and the number of relocs loaded is placed in *NRELSP. It is the caller's
992 responsibility to free the allocated buffer. */
995 slurp_rel_relocs (Filedata
* filedata
,
996 unsigned long rel_offset
,
997 unsigned long rel_size
,
998 Elf_Internal_Rela
** relsp
,
999 unsigned long * nrelsp
)
1001 Elf_Internal_Rela
* rels
;
1007 Elf32_External_Rel
* erels
;
1009 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1010 rel_size
, _("32-bit relocation data"));
1014 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1016 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1021 error (_("out of memory parsing relocs\n"));
1025 for (i
= 0; i
< nrels
; i
++)
1027 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1028 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1029 rels
[i
].r_addend
= 0;
1036 Elf64_External_Rel
* erels
;
1038 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1039 rel_size
, _("64-bit relocation data"));
1043 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1045 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1050 error (_("out of memory parsing relocs\n"));
1054 for (i
= 0; i
< nrels
; i
++)
1056 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1057 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1058 rels
[i
].r_addend
= 0;
1060 /* The #ifdef BFD64 below is to prevent a compile time
1061 warning. We know that if we do not have a 64 bit data
1062 type that we will never execute this code anyway. */
1064 if (filedata
->file_header
.e_machine
== EM_MIPS
1065 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1067 /* In little-endian objects, r_info isn't really a
1068 64-bit little-endian value: it has a 32-bit
1069 little-endian symbol index followed by four
1070 individual byte fields. Reorder INFO
1072 bfd_vma inf
= rels
[i
].r_info
;
1073 inf
= (((inf
& 0xffffffff) << 32)
1074 | ((inf
>> 56) & 0xff)
1075 | ((inf
>> 40) & 0xff00)
1076 | ((inf
>> 24) & 0xff0000)
1077 | ((inf
>> 8) & 0xff000000));
1078 rels
[i
].r_info
= inf
;
1091 /* Returns the reloc type extracted from the reloc info field. */
1094 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1097 return ELF32_R_TYPE (reloc_info
);
1099 switch (filedata
->file_header
.e_machine
)
1102 /* Note: We assume that reloc_info has already been adjusted for us. */
1103 return ELF64_MIPS_R_TYPE (reloc_info
);
1106 return ELF64_R_TYPE_ID (reloc_info
);
1109 return ELF64_R_TYPE (reloc_info
);
1113 /* Return the symbol index extracted from the reloc info field. */
1116 get_reloc_symindex (bfd_vma reloc_info
)
1118 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1121 static inline bfd_boolean
1122 uses_msp430x_relocs (Filedata
* filedata
)
1125 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1126 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1127 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1128 /* TI compiler uses ELFOSABI_NONE. */
1129 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1132 /* Display the contents of the relocation data found at the specified
1136 dump_relocations (Filedata
* filedata
,
1137 unsigned long rel_offset
,
1138 unsigned long rel_size
,
1139 Elf_Internal_Sym
* symtab
,
1140 unsigned long nsyms
,
1142 unsigned long strtablen
,
1144 bfd_boolean is_dynsym
)
1147 Elf_Internal_Rela
* rels
;
1148 bfd_boolean res
= TRUE
;
1150 if (is_rela
== UNKNOWN
)
1151 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1155 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1160 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1169 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1171 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1176 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1178 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1186 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1188 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1193 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1195 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1199 for (i
= 0; i
< rel_size
; i
++)
1204 bfd_vma symtab_index
;
1207 offset
= rels
[i
].r_offset
;
1208 inf
= rels
[i
].r_info
;
1210 type
= get_reloc_type (filedata
, inf
);
1211 symtab_index
= get_reloc_symindex (inf
);
1215 printf ("%8.8lx %8.8lx ",
1216 (unsigned long) offset
& 0xffffffff,
1217 (unsigned long) inf
& 0xffffffff);
1221 #if BFD_HOST_64BIT_LONG
1223 ? "%16.16lx %16.16lx "
1224 : "%12.12lx %12.12lx ",
1226 #elif BFD_HOST_64BIT_LONG_LONG
1229 ? "%16.16llx %16.16llx "
1230 : "%12.12llx %12.12llx ",
1234 ? "%16.16I64x %16.16I64x "
1235 : "%12.12I64x %12.12I64x ",
1240 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1241 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1242 _bfd_int64_high (offset
),
1243 _bfd_int64_low (offset
),
1244 _bfd_int64_high (inf
),
1245 _bfd_int64_low (inf
));
1249 switch (filedata
->file_header
.e_machine
)
1256 rtype
= elf_aarch64_reloc_type (type
);
1260 case EM_CYGNUS_M32R
:
1261 rtype
= elf_m32r_reloc_type (type
);
1266 rtype
= elf_i386_reloc_type (type
);
1271 rtype
= elf_m68hc11_reloc_type (type
);
1275 rtype
= elf_m68k_reloc_type (type
);
1279 rtype
= elf_i960_reloc_type (type
);
1284 rtype
= elf_avr_reloc_type (type
);
1287 case EM_OLD_SPARCV9
:
1288 case EM_SPARC32PLUS
:
1291 rtype
= elf_sparc_reloc_type (type
);
1295 rtype
= elf_spu_reloc_type (type
);
1299 rtype
= v800_reloc_type (type
);
1302 case EM_CYGNUS_V850
:
1303 rtype
= v850_reloc_type (type
);
1307 case EM_CYGNUS_D10V
:
1308 rtype
= elf_d10v_reloc_type (type
);
1312 case EM_CYGNUS_D30V
:
1313 rtype
= elf_d30v_reloc_type (type
);
1317 rtype
= elf_dlx_reloc_type (type
);
1321 rtype
= elf_sh_reloc_type (type
);
1325 case EM_CYGNUS_MN10300
:
1326 rtype
= elf_mn10300_reloc_type (type
);
1330 case EM_CYGNUS_MN10200
:
1331 rtype
= elf_mn10200_reloc_type (type
);
1335 case EM_CYGNUS_FR30
:
1336 rtype
= elf_fr30_reloc_type (type
);
1340 rtype
= elf_frv_reloc_type (type
);
1344 rtype
= elf_ft32_reloc_type (type
);
1348 rtype
= elf_mcore_reloc_type (type
);
1352 rtype
= elf_mmix_reloc_type (type
);
1356 rtype
= elf_moxie_reloc_type (type
);
1360 if (uses_msp430x_relocs (filedata
))
1362 rtype
= elf_msp430x_reloc_type (type
);
1367 rtype
= elf_msp430_reloc_type (type
);
1371 rtype
= elf_nds32_reloc_type (type
);
1375 rtype
= elf_ppc_reloc_type (type
);
1379 rtype
= elf_ppc64_reloc_type (type
);
1383 case EM_MIPS_RS3_LE
:
1384 rtype
= elf_mips_reloc_type (type
);
1388 rtype
= elf_riscv_reloc_type (type
);
1392 rtype
= elf_alpha_reloc_type (type
);
1396 rtype
= elf_arm_reloc_type (type
);
1400 case EM_ARC_COMPACT
:
1401 case EM_ARC_COMPACT2
:
1402 rtype
= elf_arc_reloc_type (type
);
1406 rtype
= elf_hppa_reloc_type (type
);
1412 rtype
= elf_h8_reloc_type (type
);
1416 rtype
= elf_or1k_reloc_type (type
);
1421 rtype
= elf_pj_reloc_type (type
);
1424 rtype
= elf_ia64_reloc_type (type
);
1428 rtype
= elf_cris_reloc_type (type
);
1432 rtype
= elf_i860_reloc_type (type
);
1438 rtype
= elf_x86_64_reloc_type (type
);
1442 rtype
= i370_reloc_type (type
);
1447 rtype
= elf_s390_reloc_type (type
);
1451 rtype
= elf_score_reloc_type (type
);
1455 rtype
= elf_xstormy16_reloc_type (type
);
1459 rtype
= elf_crx_reloc_type (type
);
1463 rtype
= elf_vax_reloc_type (type
);
1467 rtype
= elf_visium_reloc_type (type
);
1470 case EM_ADAPTEVA_EPIPHANY
:
1471 rtype
= elf_epiphany_reloc_type (type
);
1476 rtype
= elf_ip2k_reloc_type (type
);
1480 rtype
= elf_iq2000_reloc_type (type
);
1485 rtype
= elf_xtensa_reloc_type (type
);
1488 case EM_LATTICEMICO32
:
1489 rtype
= elf_lm32_reloc_type (type
);
1494 rtype
= elf_m32c_reloc_type (type
);
1498 rtype
= elf_mt_reloc_type (type
);
1502 rtype
= elf_bfin_reloc_type (type
);
1506 rtype
= elf_mep_reloc_type (type
);
1510 rtype
= elf_cr16_reloc_type (type
);
1514 case EM_MICROBLAZE_OLD
:
1515 rtype
= elf_microblaze_reloc_type (type
);
1519 rtype
= elf_rl78_reloc_type (type
);
1523 rtype
= elf_rx_reloc_type (type
);
1527 rtype
= elf_metag_reloc_type (type
);
1532 rtype
= elf_xc16x_reloc_type (type
);
1536 rtype
= elf_tic6x_reloc_type (type
);
1540 rtype
= elf_tilegx_reloc_type (type
);
1544 rtype
= elf_tilepro_reloc_type (type
);
1547 case EM_WEBASSEMBLY
:
1548 rtype
= elf_wasm32_reloc_type (type
);
1552 rtype
= elf_xgate_reloc_type (type
);
1555 case EM_ALTERA_NIOS2
:
1556 rtype
= elf_nios2_reloc_type (type
);
1560 rtype
= elf_pru_reloc_type (type
);
1565 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1567 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1569 if (filedata
->file_header
.e_machine
== EM_ALPHA
1571 && streq (rtype
, "R_ALPHA_LITUSE")
1574 switch (rels
[i
].r_addend
)
1576 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1577 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1578 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1579 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1580 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1581 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1582 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1583 default: rtype
= NULL
;
1587 printf (" (%s)", rtype
);
1591 printf (_("<unknown addend: %lx>"),
1592 (unsigned long) rels
[i
].r_addend
);
1596 else if (symtab_index
)
1598 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1600 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1605 Elf_Internal_Sym
* psym
;
1606 const char * version_string
;
1607 enum versioned_symbol_info sym_info
;
1608 unsigned short vna_other
;
1610 psym
= symtab
+ symtab_index
;
1613 = get_symbol_version_string (filedata
, is_dynsym
,
1622 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1626 unsigned int width
= is_32bit_elf
? 8 : 14;
1628 /* Relocations against GNU_IFUNC symbols do not use the value
1629 of the symbol as the address to relocate against. Instead
1630 they invoke the function named by the symbol and use its
1631 result as the address for relocation.
1633 To indicate this to the user, do not display the value of
1634 the symbol in the "Symbols's Value" field. Instead show
1635 its name followed by () as a hint that the symbol is
1639 || psym
->st_name
== 0
1640 || psym
->st_name
>= strtablen
)
1643 name
= strtab
+ psym
->st_name
;
1645 len
= print_symbol (width
, name
);
1647 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1649 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1653 print_vma (psym
->st_value
, LONG_HEX
);
1655 printf (is_32bit_elf
? " " : " ");
1658 if (psym
->st_name
== 0)
1660 const char * sec_name
= "<null>";
1663 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1665 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1666 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1667 else if (psym
->st_shndx
== SHN_ABS
)
1669 else if (psym
->st_shndx
== SHN_COMMON
)
1670 sec_name
= "COMMON";
1671 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1672 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1673 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1674 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1675 sec_name
= "SCOMMON";
1676 else if (filedata
->file_header
.e_machine
== EM_MIPS
1677 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1678 sec_name
= "SUNDEF";
1679 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1680 || filedata
->file_header
.e_machine
== EM_L1OM
1681 || filedata
->file_header
.e_machine
== EM_K1OM
)
1682 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1683 sec_name
= "LARGE_COMMON";
1684 else if (filedata
->file_header
.e_machine
== EM_IA_64
1685 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1686 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1687 sec_name
= "ANSI_COM";
1688 else if (is_ia64_vms (filedata
)
1689 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1690 sec_name
= "VMS_SYMVEC";
1693 sprintf (name_buf
, "<section 0x%x>",
1694 (unsigned int) psym
->st_shndx
);
1695 sec_name
= name_buf
;
1698 print_symbol (22, sec_name
);
1700 else if (strtab
== NULL
)
1701 printf (_("<string table index: %3ld>"), psym
->st_name
);
1702 else if (psym
->st_name
>= strtablen
)
1704 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1709 print_symbol (22, strtab
+ psym
->st_name
);
1711 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1717 bfd_vma off
= rels
[i
].r_addend
;
1719 if ((bfd_signed_vma
) off
< 0)
1720 printf (" - %" BFD_VMA_FMT
"x", - off
);
1722 printf (" + %" BFD_VMA_FMT
"x", off
);
1728 bfd_vma off
= rels
[i
].r_addend
;
1730 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1731 if ((bfd_signed_vma
) off
< 0)
1732 printf ("-%" BFD_VMA_FMT
"x", - off
);
1734 printf ("%" BFD_VMA_FMT
"x", off
);
1737 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1739 && streq (rtype
, "R_SPARC_OLO10"))
1740 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1745 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1747 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1748 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1749 const char * rtype2
= elf_mips_reloc_type (type2
);
1750 const char * rtype3
= elf_mips_reloc_type (type3
);
1752 printf (" Type2: ");
1755 printf (_("unrecognized: %-7lx"),
1756 (unsigned long) type2
& 0xffffffff);
1758 printf ("%-17.17s", rtype2
);
1760 printf ("\n Type3: ");
1763 printf (_("unrecognized: %-7lx"),
1764 (unsigned long) type3
& 0xffffffff);
1766 printf ("%-17.17s", rtype3
);
1779 get_mips_dynamic_type (unsigned long type
)
1783 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1784 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1785 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1786 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1787 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1788 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1789 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1790 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1791 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1792 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1793 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1794 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1795 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1796 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1797 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1798 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1799 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1800 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1801 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1802 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1803 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1804 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1805 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1806 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1807 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1808 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1809 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1810 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1811 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1812 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1813 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1814 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1815 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1816 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1817 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1818 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1819 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1820 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1821 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1822 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1823 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1824 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1825 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1826 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1827 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1828 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1835 get_sparc64_dynamic_type (unsigned long type
)
1839 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1846 get_ppc_dynamic_type (unsigned long type
)
1850 case DT_PPC_GOT
: return "PPC_GOT";
1851 case DT_PPC_OPT
: return "PPC_OPT";
1858 get_ppc64_dynamic_type (unsigned long type
)
1862 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1863 case DT_PPC64_OPD
: return "PPC64_OPD";
1864 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1865 case DT_PPC64_OPT
: return "PPC64_OPT";
1872 get_parisc_dynamic_type (unsigned long type
)
1876 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1877 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1878 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1879 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1880 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1881 case DT_HP_PREINIT
: return "HP_PREINIT";
1882 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1883 case DT_HP_NEEDED
: return "HP_NEEDED";
1884 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1885 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1886 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1887 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1888 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1889 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1890 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1891 case DT_HP_FILTERED
: return "HP_FILTERED";
1892 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1893 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1894 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1895 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1896 case DT_PLT
: return "PLT";
1897 case DT_PLT_SIZE
: return "PLT_SIZE";
1898 case DT_DLT
: return "DLT";
1899 case DT_DLT_SIZE
: return "DLT_SIZE";
1906 get_ia64_dynamic_type (unsigned long type
)
1910 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1911 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1912 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1913 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1914 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1915 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1916 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1917 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1918 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1919 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1920 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1921 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1922 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1923 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1924 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1925 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1926 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1927 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1928 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1929 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1930 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1931 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1932 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1933 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1934 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1935 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1936 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1937 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1938 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1939 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1940 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1947 get_solaris_section_type (unsigned long type
)
1951 case 0x6fffffee: return "SUNW_ancillary";
1952 case 0x6fffffef: return "SUNW_capchain";
1953 case 0x6ffffff0: return "SUNW_capinfo";
1954 case 0x6ffffff1: return "SUNW_symsort";
1955 case 0x6ffffff2: return "SUNW_tlssort";
1956 case 0x6ffffff3: return "SUNW_LDYNSYM";
1957 case 0x6ffffff4: return "SUNW_dof";
1958 case 0x6ffffff5: return "SUNW_cap";
1959 case 0x6ffffff6: return "SUNW_SIGNATURE";
1960 case 0x6ffffff7: return "SUNW_ANNOTATE";
1961 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1962 case 0x6ffffff9: return "SUNW_DEBUG";
1963 case 0x6ffffffa: return "SUNW_move";
1964 case 0x6ffffffb: return "SUNW_COMDAT";
1965 case 0x6ffffffc: return "SUNW_syminfo";
1966 case 0x6ffffffd: return "SUNW_verdef";
1967 case 0x6ffffffe: return "SUNW_verneed";
1968 case 0x6fffffff: return "SUNW_versym";
1969 case 0x70000000: return "SPARC_GOTDATA";
1970 default: return NULL
;
1975 get_alpha_dynamic_type (unsigned long type
)
1979 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1980 default: return NULL
;
1985 get_score_dynamic_type (unsigned long type
)
1989 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1990 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1991 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1992 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1993 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1994 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1995 default: return NULL
;
2000 get_tic6x_dynamic_type (unsigned long type
)
2004 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2005 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2006 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2007 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2008 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2009 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2010 default: return NULL
;
2015 get_nios2_dynamic_type (unsigned long type
)
2019 case DT_NIOS2_GP
: return "NIOS2_GP";
2020 default: return NULL
;
2025 get_solaris_dynamic_type (unsigned long type
)
2029 case 0x6000000d: return "SUNW_AUXILIARY";
2030 case 0x6000000e: return "SUNW_RTLDINF";
2031 case 0x6000000f: return "SUNW_FILTER";
2032 case 0x60000010: return "SUNW_CAP";
2033 case 0x60000011: return "SUNW_SYMTAB";
2034 case 0x60000012: return "SUNW_SYMSZ";
2035 case 0x60000013: return "SUNW_SORTENT";
2036 case 0x60000014: return "SUNW_SYMSORT";
2037 case 0x60000015: return "SUNW_SYMSORTSZ";
2038 case 0x60000016: return "SUNW_TLSSORT";
2039 case 0x60000017: return "SUNW_TLSSORTSZ";
2040 case 0x60000018: return "SUNW_CAPINFO";
2041 case 0x60000019: return "SUNW_STRPAD";
2042 case 0x6000001a: return "SUNW_CAPCHAIN";
2043 case 0x6000001b: return "SUNW_LDMACH";
2044 case 0x6000001d: return "SUNW_CAPCHAINENT";
2045 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2046 case 0x60000021: return "SUNW_PARENT";
2047 case 0x60000023: return "SUNW_ASLR";
2048 case 0x60000025: return "SUNW_RELAX";
2049 case 0x60000029: return "SUNW_NXHEAP";
2050 case 0x6000002b: return "SUNW_NXSTACK";
2052 case 0x70000001: return "SPARC_REGISTER";
2053 case 0x7ffffffd: return "AUXILIARY";
2054 case 0x7ffffffe: return "USED";
2055 case 0x7fffffff: return "FILTER";
2057 default: return NULL
;
2062 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2064 static char buff
[64];
2068 case DT_NULL
: return "NULL";
2069 case DT_NEEDED
: return "NEEDED";
2070 case DT_PLTRELSZ
: return "PLTRELSZ";
2071 case DT_PLTGOT
: return "PLTGOT";
2072 case DT_HASH
: return "HASH";
2073 case DT_STRTAB
: return "STRTAB";
2074 case DT_SYMTAB
: return "SYMTAB";
2075 case DT_RELA
: return "RELA";
2076 case DT_RELASZ
: return "RELASZ";
2077 case DT_RELAENT
: return "RELAENT";
2078 case DT_STRSZ
: return "STRSZ";
2079 case DT_SYMENT
: return "SYMENT";
2080 case DT_INIT
: return "INIT";
2081 case DT_FINI
: return "FINI";
2082 case DT_SONAME
: return "SONAME";
2083 case DT_RPATH
: return "RPATH";
2084 case DT_SYMBOLIC
: return "SYMBOLIC";
2085 case DT_REL
: return "REL";
2086 case DT_RELSZ
: return "RELSZ";
2087 case DT_RELENT
: return "RELENT";
2088 case DT_PLTREL
: return "PLTREL";
2089 case DT_DEBUG
: return "DEBUG";
2090 case DT_TEXTREL
: return "TEXTREL";
2091 case DT_JMPREL
: return "JMPREL";
2092 case DT_BIND_NOW
: return "BIND_NOW";
2093 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2094 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2095 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2096 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2097 case DT_RUNPATH
: return "RUNPATH";
2098 case DT_FLAGS
: return "FLAGS";
2100 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2101 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2102 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2104 case DT_CHECKSUM
: return "CHECKSUM";
2105 case DT_PLTPADSZ
: return "PLTPADSZ";
2106 case DT_MOVEENT
: return "MOVEENT";
2107 case DT_MOVESZ
: return "MOVESZ";
2108 case DT_FEATURE
: return "FEATURE";
2109 case DT_POSFLAG_1
: return "POSFLAG_1";
2110 case DT_SYMINSZ
: return "SYMINSZ";
2111 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2113 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2114 case DT_CONFIG
: return "CONFIG";
2115 case DT_DEPAUDIT
: return "DEPAUDIT";
2116 case DT_AUDIT
: return "AUDIT";
2117 case DT_PLTPAD
: return "PLTPAD";
2118 case DT_MOVETAB
: return "MOVETAB";
2119 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2121 case DT_VERSYM
: return "VERSYM";
2123 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2124 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2125 case DT_RELACOUNT
: return "RELACOUNT";
2126 case DT_RELCOUNT
: return "RELCOUNT";
2127 case DT_FLAGS_1
: return "FLAGS_1";
2128 case DT_VERDEF
: return "VERDEF";
2129 case DT_VERDEFNUM
: return "VERDEFNUM";
2130 case DT_VERNEED
: return "VERNEED";
2131 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2133 case DT_AUXILIARY
: return "AUXILIARY";
2134 case DT_USED
: return "USED";
2135 case DT_FILTER
: return "FILTER";
2137 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2138 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2139 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2140 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2141 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2142 case DT_GNU_HASH
: return "GNU_HASH";
2145 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2147 const char * result
;
2149 switch (filedata
->file_header
.e_machine
)
2152 case EM_MIPS_RS3_LE
:
2153 result
= get_mips_dynamic_type (type
);
2156 result
= get_sparc64_dynamic_type (type
);
2159 result
= get_ppc_dynamic_type (type
);
2162 result
= get_ppc64_dynamic_type (type
);
2165 result
= get_ia64_dynamic_type (type
);
2168 result
= get_alpha_dynamic_type (type
);
2171 result
= get_score_dynamic_type (type
);
2174 result
= get_tic6x_dynamic_type (type
);
2176 case EM_ALTERA_NIOS2
:
2177 result
= get_nios2_dynamic_type (type
);
2180 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2181 result
= get_solaris_dynamic_type (type
);
2190 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2192 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2193 || (filedata
->file_header
.e_machine
== EM_PARISC
2194 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2196 const char * result
;
2198 switch (filedata
->file_header
.e_machine
)
2201 result
= get_parisc_dynamic_type (type
);
2204 result
= get_ia64_dynamic_type (type
);
2207 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2208 result
= get_solaris_dynamic_type (type
);
2217 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2221 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2228 get_file_type (unsigned e_type
)
2230 static char buff
[32];
2234 case ET_NONE
: return _("NONE (None)");
2235 case ET_REL
: return _("REL (Relocatable file)");
2236 case ET_EXEC
: return _("EXEC (Executable file)");
2237 case ET_DYN
: return _("DYN (Shared object file)");
2238 case ET_CORE
: return _("CORE (Core file)");
2241 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2242 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2243 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2244 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2246 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2252 get_machine_name (unsigned e_machine
)
2254 static char buff
[64]; /* XXX */
2258 /* Please keep this switch table sorted by increasing EM_ value. */
2260 case EM_NONE
: return _("None");
2261 case EM_M32
: return "WE32100";
2262 case EM_SPARC
: return "Sparc";
2263 case EM_386
: return "Intel 80386";
2264 case EM_68K
: return "MC68000";
2265 case EM_88K
: return "MC88000";
2266 case EM_IAMCU
: return "Intel MCU";
2267 case EM_860
: return "Intel 80860";
2268 case EM_MIPS
: return "MIPS R3000";
2269 case EM_S370
: return "IBM System/370";
2271 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2272 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2273 case EM_PARISC
: return "HPPA";
2274 case EM_VPP550
: return "Fujitsu VPP500";
2275 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2276 case EM_960
: return "Intel 90860";
2277 case EM_PPC
: return "PowerPC";
2279 case EM_PPC64
: return "PowerPC64";
2281 case EM_S390
: return "IBM S/390";
2282 case EM_SPU
: return "SPU";
2284 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2285 case EM_FR20
: return "Fujitsu FR20";
2286 case EM_RH32
: return "TRW RH32";
2287 case EM_MCORE
: return "MCORE";
2289 case EM_ARM
: return "ARM";
2290 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2291 case EM_SH
: return "Renesas / SuperH SH";
2292 case EM_SPARCV9
: return "Sparc v9";
2293 case EM_TRICORE
: return "Siemens Tricore";
2294 case EM_ARC
: return "ARC";
2295 case EM_H8_300
: return "Renesas H8/300";
2296 case EM_H8_300H
: return "Renesas H8/300H";
2297 case EM_H8S
: return "Renesas H8S";
2298 case EM_H8_500
: return "Renesas H8/500";
2300 case EM_IA_64
: return "Intel IA-64";
2301 case EM_MIPS_X
: return "Stanford MIPS-X";
2302 case EM_COLDFIRE
: return "Motorola Coldfire";
2303 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2304 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2305 case EM_PCP
: return "Siemens PCP";
2306 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2307 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2308 case EM_STARCORE
: return "Motorola Star*Core processor";
2309 case EM_ME16
: return "Toyota ME16 processor";
2311 case EM_ST100
: return "STMicroelectronics ST100 processor";
2312 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2313 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2314 case EM_PDSP
: return "Sony DSP processor";
2315 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2316 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2317 case EM_FX66
: return "Siemens FX66 microcontroller";
2318 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2319 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2320 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2322 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2323 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2324 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2325 case EM_SVX
: return "Silicon Graphics SVx";
2326 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2327 case EM_VAX
: return "Digital VAX";
2328 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2329 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2330 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2331 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2333 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2334 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2335 case EM_PRISM
: return "Vitesse Prism";
2337 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2338 case EM_CYGNUS_FR30
:
2339 case EM_FR30
: return "Fujitsu FR30";
2340 case EM_CYGNUS_D10V
:
2341 case EM_D10V
: return "d10v";
2342 case EM_CYGNUS_D30V
:
2343 case EM_D30V
: return "d30v";
2344 case EM_CYGNUS_V850
:
2345 case EM_V850
: return "Renesas V850";
2346 case EM_CYGNUS_M32R
:
2347 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2348 case EM_CYGNUS_MN10300
:
2349 case EM_MN10300
: return "mn10300";
2351 case EM_CYGNUS_MN10200
:
2352 case EM_MN10200
: return "mn10200";
2353 case EM_PJ
: return "picoJava";
2354 case EM_OR1K
: return "OpenRISC 1000";
2355 case EM_ARC_COMPACT
: return "ARCompact";
2357 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2358 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2359 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2360 case EM_NS32K
: return "National Semiconductor 32000 series";
2361 case EM_TPC
: return "Tenor Network TPC processor";
2362 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2364 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2366 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2367 case EM_MAX
: return "MAX Processor";
2368 case EM_CR
: return "National Semiconductor CompactRISC";
2369 case EM_F2MC16
: return "Fujitsu F2MC16";
2370 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2371 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2372 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2373 case EM_SEP
: return "Sharp embedded microprocessor";
2374 case EM_ARCA
: return "Arca RISC microprocessor";
2376 case EM_UNICORE
: return "Unicore";
2377 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2378 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2379 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2380 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2381 case EM_XGATE
: return "Motorola XGATE embedded processor";
2383 case EM_XC16X
: return "Infineon Technologies xc16x";
2384 case EM_M16C
: return "Renesas M16C series microprocessors";
2385 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2386 case EM_CE
: return "Freescale Communication Engine RISC core";
2388 case EM_M32C
: return "Renesas M32c";
2390 case EM_TSK3000
: return "Altium TSK3000 core";
2391 case EM_RS08
: return "Freescale RS08 embedded processor";
2392 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2393 case EM_SCORE
: return "SUNPLUS S+Core";
2394 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2395 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2396 case EM_LATTICEMICO32
: return "Lattice Mico32";
2397 case EM_SE_C17
: return "Seiko Epson C17 family";
2399 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2400 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2401 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2402 case EM_TI_PRU
: return "TI PRU I/O processor";
2404 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2405 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2406 case EM_R32C
: return "Renesas R32C series microprocessors";
2407 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2408 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2409 case EM_8051
: return "Intel 8051 and variants";
2410 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2411 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2412 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2413 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2415 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2416 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2417 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2418 case EM_RX
: return "Renesas RX";
2419 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2420 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2421 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2424 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2425 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2426 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2428 case EM_L1OM
: return "Intel L1OM";
2429 case EM_K1OM
: return "Intel K1OM";
2430 case EM_INTEL182
: return "Intel (reserved)";
2431 case EM_AARCH64
: return "AArch64";
2432 case EM_ARM184
: return "ARM (reserved)";
2433 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2434 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2435 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2436 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2438 case EM_CUDA
: return "NVIDIA CUDA architecture";
2439 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2440 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2441 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2442 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2443 case EM_ARC_COMPACT2
: return "ARCv2";
2444 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2445 case EM_RL78
: return "Renesas RL78";
2446 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2447 case EM_78K0R
: return "Renesas 78K0R";
2449 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2450 case EM_BA1
: return "Beyond BA1 CPU architecture";
2451 case EM_BA2
: return "Beyond BA2 CPU architecture";
2452 case EM_XCORE
: return "XMOS xCORE processor family";
2453 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2455 case EM_KM32
: return "KM211 KM32 32-bit processor";
2456 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2457 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2458 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2459 case EM_KVARC
: return "KM211 KVARC processor";
2460 case EM_CDP
: return "Paneve CDP architecture family";
2461 case EM_COGE
: return "Cognitive Smart Memory Processor";
2462 case EM_COOL
: return "Bluechip Systems CoolEngine";
2463 case EM_NORC
: return "Nanoradio Optimized RISC";
2464 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2466 case EM_Z80
: return "Zilog Z80";
2467 case EM_VISIUM
: return "CDS VISIUMcore processor";
2468 case EM_FT32
: return "FTDI Chip FT32";
2469 case EM_MOXIE
: return "Moxie";
2470 case EM_AMDGPU
: return "AMD GPU";
2471 case EM_RISCV
: return "RISC-V";
2472 case EM_LANAI
: return "Lanai 32-bit processor";
2473 case EM_BPF
: return "Linux BPF";
2475 /* Large numbers... */
2476 case EM_MT
: return "Morpho Techologies MT processor";
2477 case EM_ALPHA
: return "Alpha";
2478 case EM_WEBASSEMBLY
: return "Web Assembly";
2479 case EM_DLX
: return "OpenDLX";
2480 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2481 case EM_IQ2000
: return "Vitesse IQ2000";
2483 case EM_NIOS32
: return "Altera Nios";
2484 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2485 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2486 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2489 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2495 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2497 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2498 other compilers don't a specific architecture type in the e_flags, and
2499 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2500 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2503 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2504 but also sets a specific architecture type in the e_flags field.
2506 However, when decoding the flags we don't worry if we see an
2507 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2508 ARCEM architecture type. */
2510 switch (e_flags
& EF_ARC_MACH_MSK
)
2512 /* We only expect these to occur for EM_ARC_COMPACT2. */
2513 case EF_ARC_CPU_ARCV2EM
:
2514 strcat (buf
, ", ARC EM");
2516 case EF_ARC_CPU_ARCV2HS
:
2517 strcat (buf
, ", ARC HS");
2520 /* We only expect these to occur for EM_ARC_COMPACT. */
2521 case E_ARC_MACH_ARC600
:
2522 strcat (buf
, ", ARC600");
2524 case E_ARC_MACH_ARC601
:
2525 strcat (buf
, ", ARC601");
2527 case E_ARC_MACH_ARC700
:
2528 strcat (buf
, ", ARC700");
2531 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2532 new ELF with new architecture being read by an old version of
2533 readelf, or (c) An ELF built with non-GNU compiler that does not
2534 set the architecture in the e_flags. */
2536 if (e_machine
== EM_ARC_COMPACT
)
2537 strcat (buf
, ", Unknown ARCompact");
2539 strcat (buf
, ", Unknown ARC");
2543 switch (e_flags
& EF_ARC_OSABI_MSK
)
2545 case E_ARC_OSABI_ORIG
:
2546 strcat (buf
, ", (ABI:legacy)");
2548 case E_ARC_OSABI_V2
:
2549 strcat (buf
, ", (ABI:v2)");
2551 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2552 case E_ARC_OSABI_V3
:
2553 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2555 case E_ARC_OSABI_V4
:
2556 strcat (buf
, ", v4 ABI");
2559 strcat (buf
, ", unrecognised ARC OSABI flag");
2565 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2568 bfd_boolean unknown
= FALSE
;
2570 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2571 e_flags
&= ~ EF_ARM_EABIMASK
;
2573 /* Handle "generic" ARM flags. */
2574 if (e_flags
& EF_ARM_RELEXEC
)
2576 strcat (buf
, ", relocatable executable");
2577 e_flags
&= ~ EF_ARM_RELEXEC
;
2580 /* Now handle EABI specific flags. */
2584 strcat (buf
, ", <unrecognized EABI>");
2589 case EF_ARM_EABI_VER1
:
2590 strcat (buf
, ", Version1 EABI");
2595 /* Process flags one bit at a time. */
2596 flag
= e_flags
& - e_flags
;
2601 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2602 strcat (buf
, ", sorted symbol tables");
2612 case EF_ARM_EABI_VER2
:
2613 strcat (buf
, ", Version2 EABI");
2618 /* Process flags one bit at a time. */
2619 flag
= e_flags
& - e_flags
;
2624 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2625 strcat (buf
, ", sorted symbol tables");
2628 case EF_ARM_DYNSYMSUSESEGIDX
:
2629 strcat (buf
, ", dynamic symbols use segment index");
2632 case EF_ARM_MAPSYMSFIRST
:
2633 strcat (buf
, ", mapping symbols precede others");
2643 case EF_ARM_EABI_VER3
:
2644 strcat (buf
, ", Version3 EABI");
2647 case EF_ARM_EABI_VER4
:
2648 strcat (buf
, ", Version4 EABI");
2653 /* Process flags one bit at a time. */
2654 flag
= e_flags
& - e_flags
;
2660 strcat (buf
, ", BE8");
2664 strcat (buf
, ", LE8");
2674 case EF_ARM_EABI_VER5
:
2675 strcat (buf
, ", Version5 EABI");
2680 /* Process flags one bit at a time. */
2681 flag
= e_flags
& - e_flags
;
2687 strcat (buf
, ", BE8");
2691 strcat (buf
, ", LE8");
2694 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2695 strcat (buf
, ", soft-float ABI");
2698 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2699 strcat (buf
, ", hard-float ABI");
2709 case EF_ARM_EABI_UNKNOWN
:
2710 strcat (buf
, ", GNU EABI");
2715 /* Process flags one bit at a time. */
2716 flag
= e_flags
& - e_flags
;
2721 case EF_ARM_INTERWORK
:
2722 strcat (buf
, ", interworking enabled");
2725 case EF_ARM_APCS_26
:
2726 strcat (buf
, ", uses APCS/26");
2729 case EF_ARM_APCS_FLOAT
:
2730 strcat (buf
, ", uses APCS/float");
2734 strcat (buf
, ", position independent");
2738 strcat (buf
, ", 8 bit structure alignment");
2741 case EF_ARM_NEW_ABI
:
2742 strcat (buf
, ", uses new ABI");
2745 case EF_ARM_OLD_ABI
:
2746 strcat (buf
, ", uses old ABI");
2749 case EF_ARM_SOFT_FLOAT
:
2750 strcat (buf
, ", software FP");
2753 case EF_ARM_VFP_FLOAT
:
2754 strcat (buf
, ", VFP");
2757 case EF_ARM_MAVERICK_FLOAT
:
2758 strcat (buf
, ", Maverick FP");
2769 strcat (buf
,_(", <unknown>"));
2773 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2775 --size
; /* Leave space for null terminator. */
2777 switch (e_flags
& EF_AVR_MACH
)
2779 case E_AVR_MACH_AVR1
:
2780 strncat (buf
, ", avr:1", size
);
2782 case E_AVR_MACH_AVR2
:
2783 strncat (buf
, ", avr:2", size
);
2785 case E_AVR_MACH_AVR25
:
2786 strncat (buf
, ", avr:25", size
);
2788 case E_AVR_MACH_AVR3
:
2789 strncat (buf
, ", avr:3", size
);
2791 case E_AVR_MACH_AVR31
:
2792 strncat (buf
, ", avr:31", size
);
2794 case E_AVR_MACH_AVR35
:
2795 strncat (buf
, ", avr:35", size
);
2797 case E_AVR_MACH_AVR4
:
2798 strncat (buf
, ", avr:4", size
);
2800 case E_AVR_MACH_AVR5
:
2801 strncat (buf
, ", avr:5", size
);
2803 case E_AVR_MACH_AVR51
:
2804 strncat (buf
, ", avr:51", size
);
2806 case E_AVR_MACH_AVR6
:
2807 strncat (buf
, ", avr:6", size
);
2809 case E_AVR_MACH_AVRTINY
:
2810 strncat (buf
, ", avr:100", size
);
2812 case E_AVR_MACH_XMEGA1
:
2813 strncat (buf
, ", avr:101", size
);
2815 case E_AVR_MACH_XMEGA2
:
2816 strncat (buf
, ", avr:102", size
);
2818 case E_AVR_MACH_XMEGA3
:
2819 strncat (buf
, ", avr:103", size
);
2821 case E_AVR_MACH_XMEGA4
:
2822 strncat (buf
, ", avr:104", size
);
2824 case E_AVR_MACH_XMEGA5
:
2825 strncat (buf
, ", avr:105", size
);
2827 case E_AVR_MACH_XMEGA6
:
2828 strncat (buf
, ", avr:106", size
);
2830 case E_AVR_MACH_XMEGA7
:
2831 strncat (buf
, ", avr:107", size
);
2834 strncat (buf
, ", avr:<unknown>", size
);
2838 size
-= strlen (buf
);
2839 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2840 strncat (buf
, ", link-relax", size
);
2844 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2850 bfd_boolean has_fpu
= FALSE
;
2853 static const char *ABI_STRINGS
[] =
2855 "ABI v0", /* use r5 as return register; only used in N1213HC */
2856 "ABI v1", /* use r0 as return register */
2857 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2858 "ABI v2fp", /* for FPU */
2862 static const char *VER_STRINGS
[] =
2864 "Andes ELF V1.3 or older",
2868 static const char *ARCH_STRINGS
[] =
2877 abi
= EF_NDS_ABI
& e_flags
;
2878 arch
= EF_NDS_ARCH
& e_flags
;
2879 config
= EF_NDS_INST
& e_flags
;
2880 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2882 memset (buf
, 0, size
);
2889 case E_NDS_ABI_V2FP
:
2890 case E_NDS_ABI_AABI
:
2891 case E_NDS_ABI_V2FP_PLUS
:
2892 /* In case there are holes in the array. */
2893 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2897 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2903 case E_NDS32_ELF_VER_1_2
:
2904 case E_NDS32_ELF_VER_1_3
:
2905 case E_NDS32_ELF_VER_1_4
:
2906 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2910 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2914 if (E_NDS_ABI_V0
== abi
)
2916 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2917 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2918 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2919 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2925 case E_NDS_ARCH_STAR_V1_0
:
2926 case E_NDS_ARCH_STAR_V2_0
:
2927 case E_NDS_ARCH_STAR_V3_0
:
2928 case E_NDS_ARCH_STAR_V3_M
:
2929 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2933 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2934 /* ARCH version determines how the e_flags are interpreted.
2935 If it is unknown, we cannot proceed. */
2939 /* Newer ABI; Now handle architecture specific flags. */
2940 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2942 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2943 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2945 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2946 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2948 if (config
& E_NDS32_HAS_DIV_INST
)
2949 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2951 if (config
& E_NDS32_HAS_16BIT_INST
)
2952 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2956 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2958 if (version
<= E_NDS32_ELF_VER_1_3
)
2959 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2961 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2964 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2965 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2967 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2968 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2970 if (config
& E_NDS32_HAS_16BIT_INST
)
2972 if (version
<= E_NDS32_ELF_VER_1_3
)
2973 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2975 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2979 if (config
& E_NDS32_HAS_EXT_INST
)
2980 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2982 if (config
& E_NDS32_HAS_EXT2_INST
)
2983 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2985 if (config
& E_NDS32_HAS_FPU_INST
)
2988 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2991 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2994 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2997 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3000 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3005 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3007 case E_NDS32_FPU_REG_8SP_4DP
:
3008 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3010 case E_NDS32_FPU_REG_16SP_8DP
:
3011 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3013 case E_NDS32_FPU_REG_32SP_16DP
:
3014 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3016 case E_NDS32_FPU_REG_32SP_32DP
:
3017 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3022 if (config
& E_NDS32_HAS_AUDIO_INST
)
3023 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3025 if (config
& E_NDS32_HAS_STRING_INST
)
3026 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3028 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3029 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3031 if (config
& E_NDS32_HAS_VIDEO_INST
)
3033 if (version
<= E_NDS32_ELF_VER_1_3
)
3034 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3036 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3039 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3040 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3042 if (config
& E_NDS32_HAS_L2C_INST
)
3043 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3047 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3049 static char buf
[1024];
3060 case EM_ARC_COMPACT2
:
3061 case EM_ARC_COMPACT
:
3062 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3066 decode_ARM_machine_flags (e_flags
, buf
);
3070 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3074 if (e_flags
& EF_BFIN_PIC
)
3075 strcat (buf
, ", PIC");
3077 if (e_flags
& EF_BFIN_FDPIC
)
3078 strcat (buf
, ", FDPIC");
3080 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3081 strcat (buf
, ", code in L1");
3083 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3084 strcat (buf
, ", data in L1");
3089 switch (e_flags
& EF_FRV_CPU_MASK
)
3091 case EF_FRV_CPU_GENERIC
:
3095 strcat (buf
, ", fr???");
3098 case EF_FRV_CPU_FR300
:
3099 strcat (buf
, ", fr300");
3102 case EF_FRV_CPU_FR400
:
3103 strcat (buf
, ", fr400");
3105 case EF_FRV_CPU_FR405
:
3106 strcat (buf
, ", fr405");
3109 case EF_FRV_CPU_FR450
:
3110 strcat (buf
, ", fr450");
3113 case EF_FRV_CPU_FR500
:
3114 strcat (buf
, ", fr500");
3116 case EF_FRV_CPU_FR550
:
3117 strcat (buf
, ", fr550");
3120 case EF_FRV_CPU_SIMPLE
:
3121 strcat (buf
, ", simple");
3123 case EF_FRV_CPU_TOMCAT
:
3124 strcat (buf
, ", tomcat");
3130 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3131 strcat (buf
, ", m68000");
3132 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3133 strcat (buf
, ", cpu32");
3134 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3135 strcat (buf
, ", fido_a");
3138 char const * isa
= _("unknown");
3139 char const * mac
= _("unknown mac");
3140 char const * additional
= NULL
;
3142 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3144 case EF_M68K_CF_ISA_A_NODIV
:
3146 additional
= ", nodiv";
3148 case EF_M68K_CF_ISA_A
:
3151 case EF_M68K_CF_ISA_A_PLUS
:
3154 case EF_M68K_CF_ISA_B_NOUSP
:
3156 additional
= ", nousp";
3158 case EF_M68K_CF_ISA_B
:
3161 case EF_M68K_CF_ISA_C
:
3164 case EF_M68K_CF_ISA_C_NODIV
:
3166 additional
= ", nodiv";
3169 strcat (buf
, ", cf, isa ");
3172 strcat (buf
, additional
);
3173 if (e_flags
& EF_M68K_CF_FLOAT
)
3174 strcat (buf
, ", float");
3175 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3180 case EF_M68K_CF_MAC
:
3183 case EF_M68K_CF_EMAC
:
3186 case EF_M68K_CF_EMAC_B
:
3199 switch (e_flags
& EF_MEP_CPU_MASK
)
3201 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3202 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3203 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3204 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3205 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3206 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3207 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3210 switch (e_flags
& EF_MEP_COP_MASK
)
3212 case EF_MEP_COP_NONE
: break;
3213 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3214 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3215 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3216 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3217 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3220 if (e_flags
& EF_MEP_LIBRARY
)
3221 strcat (buf
, ", Built for Library");
3223 if (e_flags
& EF_MEP_INDEX_MASK
)
3224 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3225 e_flags
& EF_MEP_INDEX_MASK
);
3227 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3228 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3229 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3233 if (e_flags
& EF_PPC_EMB
)
3234 strcat (buf
, ", emb");
3236 if (e_flags
& EF_PPC_RELOCATABLE
)
3237 strcat (buf
, _(", relocatable"));
3239 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3240 strcat (buf
, _(", relocatable-lib"));
3244 if (e_flags
& EF_PPC64_ABI
)
3246 char abi
[] = ", abiv0";
3248 abi
[6] += e_flags
& EF_PPC64_ABI
;
3254 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3255 strcat (buf
, ", RH850 ABI");
3257 if (e_flags
& EF_V800_850E3
)
3258 strcat (buf
, ", V3 architecture");
3260 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3261 strcat (buf
, ", FPU not used");
3263 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3264 strcat (buf
, ", regmode: COMMON");
3266 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3267 strcat (buf
, ", r4 not used");
3269 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3270 strcat (buf
, ", r30 not used");
3272 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3273 strcat (buf
, ", r5 not used");
3275 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3276 strcat (buf
, ", r2 not used");
3278 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3280 switch (e_flags
& - e_flags
)
3282 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3283 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3284 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3285 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3286 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3287 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3288 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3289 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3290 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3291 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3292 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3293 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3300 case EM_CYGNUS_V850
:
3301 switch (e_flags
& EF_V850_ARCH
)
3303 case E_V850E3V5_ARCH
:
3304 strcat (buf
, ", v850e3v5");
3306 case E_V850E2V3_ARCH
:
3307 strcat (buf
, ", v850e2v3");
3310 strcat (buf
, ", v850e2");
3313 strcat (buf
, ", v850e1");
3316 strcat (buf
, ", v850e");
3319 strcat (buf
, ", v850");
3322 strcat (buf
, _(", unknown v850 architecture variant"));
3328 case EM_CYGNUS_M32R
:
3329 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3330 strcat (buf
, ", m32r");
3334 case EM_MIPS_RS3_LE
:
3335 if (e_flags
& EF_MIPS_NOREORDER
)
3336 strcat (buf
, ", noreorder");
3338 if (e_flags
& EF_MIPS_PIC
)
3339 strcat (buf
, ", pic");
3341 if (e_flags
& EF_MIPS_CPIC
)
3342 strcat (buf
, ", cpic");
3344 if (e_flags
& EF_MIPS_UCODE
)
3345 strcat (buf
, ", ugen_reserved");
3347 if (e_flags
& EF_MIPS_ABI2
)
3348 strcat (buf
, ", abi2");
3350 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3351 strcat (buf
, ", odk first");
3353 if (e_flags
& EF_MIPS_32BITMODE
)
3354 strcat (buf
, ", 32bitmode");
3356 if (e_flags
& EF_MIPS_NAN2008
)
3357 strcat (buf
, ", nan2008");
3359 if (e_flags
& EF_MIPS_FP64
)
3360 strcat (buf
, ", fp64");
3362 switch ((e_flags
& EF_MIPS_MACH
))
3364 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3365 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3366 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3367 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3368 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3369 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3370 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3371 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3372 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3373 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3374 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3375 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3376 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3377 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3378 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3379 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3380 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3381 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3382 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3384 /* We simply ignore the field in this case to avoid confusion:
3385 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3388 default: strcat (buf
, _(", unknown CPU")); break;
3391 switch ((e_flags
& EF_MIPS_ABI
))
3393 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3394 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3395 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3396 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3398 /* We simply ignore the field in this case to avoid confusion:
3399 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3400 This means it is likely to be an o32 file, but not for
3403 default: strcat (buf
, _(", unknown ABI")); break;
3406 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3407 strcat (buf
, ", mdmx");
3409 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3410 strcat (buf
, ", mips16");
3412 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3413 strcat (buf
, ", micromips");
3415 switch ((e_flags
& EF_MIPS_ARCH
))
3417 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3418 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3419 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3420 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3421 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3422 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3423 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3424 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3425 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3426 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3427 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3428 default: strcat (buf
, _(", unknown ISA")); break;
3433 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3437 if (e_flags
& EF_RISCV_RVC
)
3438 strcat (buf
, ", RVC");
3440 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3442 case EF_RISCV_FLOAT_ABI_SOFT
:
3443 strcat (buf
, ", soft-float ABI");
3446 case EF_RISCV_FLOAT_ABI_SINGLE
:
3447 strcat (buf
, ", single-float ABI");
3450 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3451 strcat (buf
, ", double-float ABI");
3454 case EF_RISCV_FLOAT_ABI_QUAD
:
3455 strcat (buf
, ", quad-float ABI");
3461 switch ((e_flags
& EF_SH_MACH_MASK
))
3463 case EF_SH1
: strcat (buf
, ", sh1"); break;
3464 case EF_SH2
: strcat (buf
, ", sh2"); break;
3465 case EF_SH3
: strcat (buf
, ", sh3"); break;
3466 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3467 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3468 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3469 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3470 case EF_SH4
: strcat (buf
, ", sh4"); break;
3471 case EF_SH5
: strcat (buf
, ", sh5"); break;
3472 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3473 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3474 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3475 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3476 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3477 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3478 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3479 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3480 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3481 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3482 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3483 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3484 default: strcat (buf
, _(", unknown ISA")); break;
3487 if (e_flags
& EF_SH_PIC
)
3488 strcat (buf
, ", pic");
3490 if (e_flags
& EF_SH_FDPIC
)
3491 strcat (buf
, ", fdpic");
3495 if (e_flags
& EF_OR1K_NODELAY
)
3496 strcat (buf
, ", no delay");
3500 if (e_flags
& EF_SPARC_32PLUS
)
3501 strcat (buf
, ", v8+");
3503 if (e_flags
& EF_SPARC_SUN_US1
)
3504 strcat (buf
, ", ultrasparcI");
3506 if (e_flags
& EF_SPARC_SUN_US3
)
3507 strcat (buf
, ", ultrasparcIII");
3509 if (e_flags
& EF_SPARC_HAL_R1
)
3510 strcat (buf
, ", halr1");
3512 if (e_flags
& EF_SPARC_LEDATA
)
3513 strcat (buf
, ", ledata");
3515 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3516 strcat (buf
, ", tso");
3518 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3519 strcat (buf
, ", pso");
3521 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3522 strcat (buf
, ", rmo");
3526 switch (e_flags
& EF_PARISC_ARCH
)
3528 case EFA_PARISC_1_0
:
3529 strcpy (buf
, ", PA-RISC 1.0");
3531 case EFA_PARISC_1_1
:
3532 strcpy (buf
, ", PA-RISC 1.1");
3534 case EFA_PARISC_2_0
:
3535 strcpy (buf
, ", PA-RISC 2.0");
3540 if (e_flags
& EF_PARISC_TRAPNIL
)
3541 strcat (buf
, ", trapnil");
3542 if (e_flags
& EF_PARISC_EXT
)
3543 strcat (buf
, ", ext");
3544 if (e_flags
& EF_PARISC_LSB
)
3545 strcat (buf
, ", lsb");
3546 if (e_flags
& EF_PARISC_WIDE
)
3547 strcat (buf
, ", wide");
3548 if (e_flags
& EF_PARISC_NO_KABP
)
3549 strcat (buf
, ", no kabp");
3550 if (e_flags
& EF_PARISC_LAZYSWAP
)
3551 strcat (buf
, ", lazyswap");
3556 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3557 strcat (buf
, ", new calling convention");
3559 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3560 strcat (buf
, ", gnu calling convention");
3564 if ((e_flags
& EF_IA_64_ABI64
))
3565 strcat (buf
, ", 64-bit");
3567 strcat (buf
, ", 32-bit");
3568 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3569 strcat (buf
, ", reduced fp model");
3570 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3571 strcat (buf
, ", no function descriptors, constant gp");
3572 else if ((e_flags
& EF_IA_64_CONS_GP
))
3573 strcat (buf
, ", constant gp");
3574 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3575 strcat (buf
, ", absolute");
3576 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3578 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3579 strcat (buf
, ", vms_linkages");
3580 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3582 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3584 case EF_IA_64_VMS_COMCOD_WARNING
:
3585 strcat (buf
, ", warning");
3587 case EF_IA_64_VMS_COMCOD_ERROR
:
3588 strcat (buf
, ", error");
3590 case EF_IA_64_VMS_COMCOD_ABORT
:
3591 strcat (buf
, ", abort");
3594 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3595 e_flags
& EF_IA_64_VMS_COMCOD
);
3596 strcat (buf
, ", <unknown>");
3602 if ((e_flags
& EF_VAX_NONPIC
))
3603 strcat (buf
, ", non-PIC");
3604 if ((e_flags
& EF_VAX_DFLOAT
))
3605 strcat (buf
, ", D-Float");
3606 if ((e_flags
& EF_VAX_GFLOAT
))
3607 strcat (buf
, ", G-Float");
3611 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3612 strcat (buf
, ", mcm");
3613 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3614 strcat (buf
, ", mcm24");
3615 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3616 strcat (buf
, ", gr6");
3620 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3622 case E_FLAG_RL78_ANY_CPU
: break;
3623 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3624 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3625 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3627 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3628 strcat (buf
, ", 64-bit doubles");
3632 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3633 strcat (buf
, ", 64-bit doubles");
3634 if (e_flags
& E_FLAG_RX_DSP
)
3635 strcat (buf
, ", dsp");
3636 if (e_flags
& E_FLAG_RX_PID
)
3637 strcat (buf
, ", pid");
3638 if (e_flags
& E_FLAG_RX_ABI
)
3639 strcat (buf
, ", RX ABI");
3640 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3641 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3642 ? ", uses String instructions" : ", bans String instructions");
3643 if (e_flags
& E_FLAG_RX_V2
)
3644 strcat (buf
, ", V2");
3648 if (e_flags
& EF_S390_HIGH_GPRS
)
3649 strcat (buf
, ", highgprs");
3653 if ((e_flags
& EF_C6000_REL
))
3654 strcat (buf
, ", relocatable module");
3658 strcat (buf
, _(": architecture variant: "));
3659 switch (e_flags
& EF_MSP430_MACH
)
3661 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3662 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3663 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3664 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3665 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3666 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3667 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3668 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3669 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3670 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3671 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3672 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3673 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3674 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3675 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3677 strcat (buf
, _(": unknown")); break;
3680 if (e_flags
& ~ EF_MSP430_MACH
)
3681 strcat (buf
, _(": unknown extra flag bits also present"));
3689 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3691 static char buff
[32];
3695 case ELFOSABI_NONE
: return "UNIX - System V";
3696 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3697 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3698 case ELFOSABI_GNU
: return "UNIX - GNU";
3699 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3700 case ELFOSABI_AIX
: return "UNIX - AIX";
3701 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3702 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3703 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3704 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3705 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3706 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3707 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3708 case ELFOSABI_AROS
: return "AROS";
3709 case ELFOSABI_FENIXOS
: return "FenixOS";
3710 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3711 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3714 switch (filedata
->file_header
.e_machine
)
3719 case ELFOSABI_ARM
: return "ARM";
3730 case ELFOSABI_STANDALONE
: return _("Standalone App");
3739 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3740 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3749 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3755 get_aarch64_segment_type (unsigned long type
)
3759 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3760 default: return NULL
;
3765 get_arm_segment_type (unsigned long type
)
3769 case PT_ARM_EXIDX
: return "EXIDX";
3770 default: return NULL
;
3775 get_s390_segment_type (unsigned long type
)
3779 case PT_S390_PGSTE
: return "S390_PGSTE";
3780 default: return NULL
;
3785 get_mips_segment_type (unsigned long type
)
3789 case PT_MIPS_REGINFO
: return "REGINFO";
3790 case PT_MIPS_RTPROC
: return "RTPROC";
3791 case PT_MIPS_OPTIONS
: return "OPTIONS";
3792 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3793 default: return NULL
;
3798 get_parisc_segment_type (unsigned long type
)
3802 case PT_HP_TLS
: return "HP_TLS";
3803 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3804 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3805 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3806 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3807 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3808 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3809 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3810 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3811 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3812 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3813 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3814 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3815 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3816 case PT_HP_STACK
: return "HP_STACK";
3817 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3818 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3819 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3820 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3821 default: return NULL
;
3826 get_ia64_segment_type (unsigned long type
)
3830 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3831 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3832 case PT_HP_TLS
: return "HP_TLS";
3833 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3834 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3835 case PT_IA_64_HP_STACK
: return "HP_STACK";
3836 default: return NULL
;
3841 get_tic6x_segment_type (unsigned long type
)
3845 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3846 default: return NULL
;
3851 get_solaris_segment_type (unsigned long type
)
3855 case 0x6464e550: return "PT_SUNW_UNWIND";
3856 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3857 case 0x6ffffff7: return "PT_LOSUNW";
3858 case 0x6ffffffa: return "PT_SUNWBSS";
3859 case 0x6ffffffb: return "PT_SUNWSTACK";
3860 case 0x6ffffffc: return "PT_SUNWDTRACE";
3861 case 0x6ffffffd: return "PT_SUNWCAP";
3862 case 0x6fffffff: return "PT_HISUNW";
3863 default: return NULL
;
3868 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3870 static char buff
[32];
3874 case PT_NULL
: return "NULL";
3875 case PT_LOAD
: return "LOAD";
3876 case PT_DYNAMIC
: return "DYNAMIC";
3877 case PT_INTERP
: return "INTERP";
3878 case PT_NOTE
: return "NOTE";
3879 case PT_SHLIB
: return "SHLIB";
3880 case PT_PHDR
: return "PHDR";
3881 case PT_TLS
: return "TLS";
3882 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3883 case PT_GNU_STACK
: return "GNU_STACK";
3884 case PT_GNU_RELRO
: return "GNU_RELRO";
3887 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3889 sprintf (buff
, "GNU_MBIND+%#lx",
3890 p_type
- PT_GNU_MBIND_LO
);
3892 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3894 const char * result
;
3896 switch (filedata
->file_header
.e_machine
)
3899 result
= get_aarch64_segment_type (p_type
);
3902 result
= get_arm_segment_type (p_type
);
3905 case EM_MIPS_RS3_LE
:
3906 result
= get_mips_segment_type (p_type
);
3909 result
= get_parisc_segment_type (p_type
);
3912 result
= get_ia64_segment_type (p_type
);
3915 result
= get_tic6x_segment_type (p_type
);
3919 result
= get_s390_segment_type (p_type
);
3929 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3931 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3933 const char * result
;
3935 switch (filedata
->file_header
.e_machine
)
3938 result
= get_parisc_segment_type (p_type
);
3941 result
= get_ia64_segment_type (p_type
);
3944 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3945 result
= get_solaris_segment_type (p_type
);
3954 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3957 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3964 get_arc_section_type_name (unsigned int sh_type
)
3968 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3976 get_mips_section_type_name (unsigned int sh_type
)
3980 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3981 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3982 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3983 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3984 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3985 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3986 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3987 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3988 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3989 case SHT_MIPS_RELD
: return "MIPS_RELD";
3990 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3991 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3992 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3993 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3994 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3995 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3996 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3997 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3998 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3999 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4000 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4001 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4002 case SHT_MIPS_LINE
: return "MIPS_LINE";
4003 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4004 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4005 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4006 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4007 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4008 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4009 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4010 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4011 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4012 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4013 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4014 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4015 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4016 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4017 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4018 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4019 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4027 get_parisc_section_type_name (unsigned int sh_type
)
4031 case SHT_PARISC_EXT
: return "PARISC_EXT";
4032 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4033 case SHT_PARISC_DOC
: return "PARISC_DOC";
4034 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4035 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4036 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4037 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4038 default: return NULL
;
4043 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4045 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4046 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4047 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4051 case SHT_IA_64_EXT
: return "IA_64_EXT";
4052 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4053 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4054 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4055 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4056 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4057 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4058 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4059 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4060 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4068 get_x86_64_section_type_name (unsigned int sh_type
)
4072 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4073 default: return NULL
;
4078 get_aarch64_section_type_name (unsigned int sh_type
)
4082 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4083 default: return NULL
;
4088 get_arm_section_type_name (unsigned int sh_type
)
4092 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4093 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4094 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4095 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4096 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4097 default: return NULL
;
4102 get_tic6x_section_type_name (unsigned int sh_type
)
4106 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4107 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4108 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4109 case SHT_TI_ICODE
: return "TI_ICODE";
4110 case SHT_TI_XREF
: return "TI_XREF";
4111 case SHT_TI_HANDLER
: return "TI_HANDLER";
4112 case SHT_TI_INITINFO
: return "TI_INITINFO";
4113 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4114 default: return NULL
;
4119 get_msp430x_section_type_name (unsigned int sh_type
)
4123 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4124 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4125 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4126 default: return NULL
;
4131 get_v850_section_type_name (unsigned int sh_type
)
4135 case SHT_V850_SCOMMON
: return "V850 Small Common";
4136 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4137 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4138 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4139 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4140 default: return NULL
;
4145 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4147 static char buff
[32];
4148 const char * result
;
4152 case SHT_NULL
: return "NULL";
4153 case SHT_PROGBITS
: return "PROGBITS";
4154 case SHT_SYMTAB
: return "SYMTAB";
4155 case SHT_STRTAB
: return "STRTAB";
4156 case SHT_RELA
: return "RELA";
4157 case SHT_HASH
: return "HASH";
4158 case SHT_DYNAMIC
: return "DYNAMIC";
4159 case SHT_NOTE
: return "NOTE";
4160 case SHT_NOBITS
: return "NOBITS";
4161 case SHT_REL
: return "REL";
4162 case SHT_SHLIB
: return "SHLIB";
4163 case SHT_DYNSYM
: return "DYNSYM";
4164 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4165 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4166 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4167 case SHT_GNU_HASH
: return "GNU_HASH";
4168 case SHT_GROUP
: return "GROUP";
4169 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4170 case SHT_GNU_verdef
: return "VERDEF";
4171 case SHT_GNU_verneed
: return "VERNEED";
4172 case SHT_GNU_versym
: return "VERSYM";
4173 case 0x6ffffff0: return "VERSYM";
4174 case 0x6ffffffc: return "VERDEF";
4175 case 0x7ffffffd: return "AUXILIARY";
4176 case 0x7fffffff: return "FILTER";
4177 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4180 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4182 switch (filedata
->file_header
.e_machine
)
4185 case EM_ARC_COMPACT
:
4186 case EM_ARC_COMPACT2
:
4187 result
= get_arc_section_type_name (sh_type
);
4190 case EM_MIPS_RS3_LE
:
4191 result
= get_mips_section_type_name (sh_type
);
4194 result
= get_parisc_section_type_name (sh_type
);
4197 result
= get_ia64_section_type_name (filedata
, sh_type
);
4202 result
= get_x86_64_section_type_name (sh_type
);
4205 result
= get_aarch64_section_type_name (sh_type
);
4208 result
= get_arm_section_type_name (sh_type
);
4211 result
= get_tic6x_section_type_name (sh_type
);
4214 result
= get_msp430x_section_type_name (sh_type
);
4218 case EM_CYGNUS_V850
:
4219 result
= get_v850_section_type_name (sh_type
);
4229 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4231 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4233 switch (filedata
->file_header
.e_machine
)
4236 result
= get_ia64_section_type_name (filedata
, sh_type
);
4239 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4240 result
= get_solaris_section_type (sh_type
);
4245 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4246 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4247 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4248 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4260 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4262 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4264 switch (filedata
->file_header
.e_machine
)
4268 case EM_CYGNUS_V850
:
4269 result
= get_v850_section_type_name (sh_type
);
4279 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4282 /* This message is probably going to be displayed in a 15
4283 character wide field, so put the hex value first. */
4284 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4290 #define OPTION_DEBUG_DUMP 512
4291 #define OPTION_DYN_SYMS 513
4292 #define OPTION_DWARF_DEPTH 514
4293 #define OPTION_DWARF_START 515
4294 #define OPTION_DWARF_CHECK 516
4296 static struct option options
[] =
4298 {"all", no_argument
, 0, 'a'},
4299 {"file-header", no_argument
, 0, 'h'},
4300 {"program-headers", no_argument
, 0, 'l'},
4301 {"headers", no_argument
, 0, 'e'},
4302 {"histogram", no_argument
, 0, 'I'},
4303 {"segments", no_argument
, 0, 'l'},
4304 {"sections", no_argument
, 0, 'S'},
4305 {"section-headers", no_argument
, 0, 'S'},
4306 {"section-groups", no_argument
, 0, 'g'},
4307 {"section-details", no_argument
, 0, 't'},
4308 {"full-section-name",no_argument
, 0, 'N'},
4309 {"symbols", no_argument
, 0, 's'},
4310 {"syms", no_argument
, 0, 's'},
4311 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4312 {"relocs", no_argument
, 0, 'r'},
4313 {"notes", no_argument
, 0, 'n'},
4314 {"dynamic", no_argument
, 0, 'd'},
4315 {"arch-specific", no_argument
, 0, 'A'},
4316 {"version-info", no_argument
, 0, 'V'},
4317 {"use-dynamic", no_argument
, 0, 'D'},
4318 {"unwind", no_argument
, 0, 'u'},
4319 {"archive-index", no_argument
, 0, 'c'},
4320 {"hex-dump", required_argument
, 0, 'x'},
4321 {"relocated-dump", required_argument
, 0, 'R'},
4322 {"string-dump", required_argument
, 0, 'p'},
4323 {"decompress", no_argument
, 0, 'z'},
4324 #ifdef SUPPORT_DISASSEMBLY
4325 {"instruction-dump", required_argument
, 0, 'i'},
4327 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4329 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4330 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4331 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4333 {"version", no_argument
, 0, 'v'},
4334 {"wide", no_argument
, 0, 'W'},
4335 {"help", no_argument
, 0, 'H'},
4336 {0, no_argument
, 0, 0}
4340 usage (FILE * stream
)
4342 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4343 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4344 fprintf (stream
, _(" Options are:\n\
4345 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4346 -h --file-header Display the ELF file header\n\
4347 -l --program-headers Display the program headers\n\
4348 --segments An alias for --program-headers\n\
4349 -S --section-headers Display the sections' header\n\
4350 --sections An alias for --section-headers\n\
4351 -g --section-groups Display the section groups\n\
4352 -t --section-details Display the section details\n\
4353 -e --headers Equivalent to: -h -l -S\n\
4354 -s --syms Display the symbol table\n\
4355 --symbols An alias for --syms\n\
4356 --dyn-syms Display the dynamic symbol table\n\
4357 -n --notes Display the core notes (if present)\n\
4358 -r --relocs Display the relocations (if present)\n\
4359 -u --unwind Display the unwind info (if present)\n\
4360 -d --dynamic Display the dynamic section (if present)\n\
4361 -V --version-info Display the version sections (if present)\n\
4362 -A --arch-specific Display architecture specific information (if any)\n\
4363 -c --archive-index Display the symbol/file index in an archive\n\
4364 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4365 -x --hex-dump=<number|name>\n\
4366 Dump the contents of section <number|name> as bytes\n\
4367 -p --string-dump=<number|name>\n\
4368 Dump the contents of section <number|name> as strings\n\
4369 -R --relocated-dump=<number|name>\n\
4370 Dump the contents of section <number|name> as relocated bytes\n\
4371 -z --decompress Decompress section before dumping it\n\
4372 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4373 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4374 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4375 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4376 =addr,=cu_index,=links,=follow-links]\n\
4377 Display the contents of DWARF debug sections\n"));
4378 fprintf (stream
, _("\
4379 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4380 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4382 #ifdef SUPPORT_DISASSEMBLY
4383 fprintf (stream
, _("\
4384 -i --instruction-dump=<number|name>\n\
4385 Disassemble the contents of section <number|name>\n"));
4387 fprintf (stream
, _("\
4388 -I --histogram Display histogram of bucket list lengths\n\
4389 -W --wide Allow output width to exceed 80 characters\n\
4390 @<file> Read options from <file>\n\
4391 -H --help Display this information\n\
4392 -v --version Display the version number of readelf\n"));
4394 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4395 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4397 exit (stream
== stdout
? 0 : 1);
4400 /* Record the fact that the user wants the contents of section number
4401 SECTION to be displayed using the method(s) encoded as flags bits
4402 in TYPE. Note, TYPE can be zero if we are creating the array for
4406 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4408 if (section
>= filedata
->num_dump_sects
)
4410 dump_type
* new_dump_sects
;
4412 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4413 sizeof (* new_dump_sects
));
4415 if (new_dump_sects
== NULL
)
4416 error (_("Out of memory allocating dump request table.\n"));
4419 if (filedata
->dump_sects
)
4421 /* Copy current flag settings. */
4422 memcpy (new_dump_sects
, filedata
->dump_sects
,
4423 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4425 free (filedata
->dump_sects
);
4428 filedata
->dump_sects
= new_dump_sects
;
4429 filedata
->num_dump_sects
= section
+ 1;
4433 if (filedata
->dump_sects
)
4434 filedata
->dump_sects
[section
] |= type
;
4437 /* Request a dump by section name. */
4440 request_dump_byname (const char * section
, dump_type type
)
4442 struct dump_list_entry
* new_request
;
4444 new_request
= (struct dump_list_entry
*)
4445 malloc (sizeof (struct dump_list_entry
));
4447 error (_("Out of memory allocating dump request table.\n"));
4449 new_request
->name
= strdup (section
);
4450 if (!new_request
->name
)
4451 error (_("Out of memory allocating dump request table.\n"));
4453 new_request
->type
= type
;
4455 new_request
->next
= dump_sects_byname
;
4456 dump_sects_byname
= new_request
;
4460 request_dump (Filedata
* filedata
, dump_type type
)
4466 section
= strtoul (optarg
, & cp
, 0);
4468 if (! *cp
&& section
>= 0)
4469 request_dump_bynumber (filedata
, section
, type
);
4471 request_dump_byname (optarg
, type
);
4475 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4482 while ((c
= getopt_long
4483 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4501 do_section_groups
= TRUE
;
4504 do_histogram
= TRUE
;
4509 do_section_groups
= TRUE
;
4514 do_section_details
= TRUE
;
4525 do_using_dynamic
= TRUE
;
4549 do_histogram
= TRUE
;
4555 do_archive_index
= TRUE
;
4558 request_dump (filedata
, HEX_DUMP
);
4561 request_dump (filedata
, STRING_DUMP
);
4564 request_dump (filedata
, RELOC_DUMP
);
4567 decompress_dumps
= TRUE
;
4573 do_debugging
= TRUE
;
4574 dwarf_select_sections_all ();
4578 do_debugging
= FALSE
;
4579 dwarf_select_sections_by_letters (optarg
);
4582 case OPTION_DEBUG_DUMP
:
4585 do_debugging
= TRUE
;
4588 do_debugging
= FALSE
;
4589 dwarf_select_sections_by_names (optarg
);
4592 case OPTION_DWARF_DEPTH
:
4596 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4599 case OPTION_DWARF_START
:
4603 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4606 case OPTION_DWARF_CHECK
:
4609 case OPTION_DYN_SYMS
:
4612 #ifdef SUPPORT_DISASSEMBLY
4614 request_dump (filedata
, DISASS_DUMP
);
4618 print_version (program_name
);
4627 /* xgettext:c-format */
4628 error (_("Invalid option '-%c'\n"), c
);
4635 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4636 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4637 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4638 && !do_section_groups
&& !do_archive_index
4644 get_elf_class (unsigned int elf_class
)
4646 static char buff
[32];
4650 case ELFCLASSNONE
: return _("none");
4651 case ELFCLASS32
: return "ELF32";
4652 case ELFCLASS64
: return "ELF64";
4654 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4660 get_data_encoding (unsigned int encoding
)
4662 static char buff
[32];
4666 case ELFDATANONE
: return _("none");
4667 case ELFDATA2LSB
: return _("2's complement, little endian");
4668 case ELFDATA2MSB
: return _("2's complement, big endian");
4670 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4675 /* Decode the data held in 'filedata->file_header'. */
4678 process_file_header (Filedata
* filedata
)
4680 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4682 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4683 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4684 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4685 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4688 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4692 init_dwarf_regnames (header
->e_machine
);
4698 printf (_("ELF Header:\n"));
4699 printf (_(" Magic: "));
4700 for (i
= 0; i
< EI_NIDENT
; i
++)
4701 printf ("%2.2x ", header
->e_ident
[i
]);
4703 printf (_(" Class: %s\n"),
4704 get_elf_class (header
->e_ident
[EI_CLASS
]));
4705 printf (_(" Data: %s\n"),
4706 get_data_encoding (header
->e_ident
[EI_DATA
]));
4707 printf (_(" Version: %d %s\n"),
4708 header
->e_ident
[EI_VERSION
],
4709 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4711 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4712 ? _("<unknown: %lx>")
4714 printf (_(" OS/ABI: %s\n"),
4715 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4716 printf (_(" ABI Version: %d\n"),
4717 header
->e_ident
[EI_ABIVERSION
]);
4718 printf (_(" Type: %s\n"),
4719 get_file_type (header
->e_type
));
4720 printf (_(" Machine: %s\n"),
4721 get_machine_name (header
->e_machine
));
4722 printf (_(" Version: 0x%lx\n"),
4723 (unsigned long) header
->e_version
);
4725 printf (_(" Entry point address: "));
4726 print_vma ((bfd_vma
) header
->e_entry
, PREFIX_HEX
);
4727 printf (_("\n Start of program headers: "));
4728 print_vma ((bfd_vma
) header
->e_phoff
, DEC
);
4729 printf (_(" (bytes into file)\n Start of section headers: "));
4730 print_vma ((bfd_vma
) header
->e_shoff
, DEC
);
4731 printf (_(" (bytes into file)\n"));
4733 printf (_(" Flags: 0x%lx%s\n"),
4734 (unsigned long) header
->e_flags
,
4735 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4736 printf (_(" Size of this header: %ld (bytes)\n"),
4737 (long) header
->e_ehsize
);
4738 printf (_(" Size of program headers: %ld (bytes)\n"),
4739 (long) header
->e_phentsize
);
4740 printf (_(" Number of program headers: %ld"),
4741 (long) header
->e_phnum
);
4742 if (filedata
->section_headers
!= NULL
4743 && header
->e_phnum
== PN_XNUM
4744 && filedata
->section_headers
[0].sh_info
!= 0)
4745 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_info
);
4746 putc ('\n', stdout
);
4747 printf (_(" Size of section headers: %ld (bytes)\n"),
4748 (long) header
->e_shentsize
);
4749 printf (_(" Number of section headers: %ld"),
4750 (long) header
->e_shnum
);
4751 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4752 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_size
);
4753 putc ('\n', stdout
);
4754 printf (_(" Section header string table index: %ld"),
4755 (long) header
->e_shstrndx
);
4756 if (filedata
->section_headers
!= NULL
4757 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4758 printf (" (%u)", filedata
->section_headers
[0].sh_link
);
4759 else if (header
->e_shstrndx
!= SHN_UNDEF
4760 && header
->e_shstrndx
>= header
->e_shnum
)
4761 printf (_(" <corrupt: out of range>"));
4762 putc ('\n', stdout
);
4765 if (filedata
->section_headers
!= NULL
)
4767 if (header
->e_phnum
== PN_XNUM
4768 && filedata
->section_headers
[0].sh_info
!= 0)
4769 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4770 if (header
->e_shnum
== SHN_UNDEF
)
4771 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4772 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4773 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4774 if (header
->e_shstrndx
>= header
->e_shnum
)
4775 header
->e_shstrndx
= SHN_UNDEF
;
4776 free (filedata
->section_headers
);
4777 filedata
->section_headers
= NULL
;
4783 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4784 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4787 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4789 Elf32_External_Phdr
* phdrs
;
4790 Elf32_External_Phdr
* external
;
4791 Elf_Internal_Phdr
* internal
;
4793 unsigned int size
= filedata
->file_header
.e_phentsize
;
4794 unsigned int num
= filedata
->file_header
.e_phnum
;
4796 /* PR binutils/17531: Cope with unexpected section header sizes. */
4797 if (size
== 0 || num
== 0)
4799 if (size
< sizeof * phdrs
)
4801 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4804 if (size
> sizeof * phdrs
)
4805 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4807 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4808 size
, num
, _("program headers"));
4812 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4813 i
< filedata
->file_header
.e_phnum
;
4814 i
++, internal
++, external
++)
4816 internal
->p_type
= BYTE_GET (external
->p_type
);
4817 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4818 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4819 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4820 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4821 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4822 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4823 internal
->p_align
= BYTE_GET (external
->p_align
);
4830 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4831 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4834 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4836 Elf64_External_Phdr
* phdrs
;
4837 Elf64_External_Phdr
* external
;
4838 Elf_Internal_Phdr
* internal
;
4840 unsigned int size
= filedata
->file_header
.e_phentsize
;
4841 unsigned int num
= filedata
->file_header
.e_phnum
;
4843 /* PR binutils/17531: Cope with unexpected section header sizes. */
4844 if (size
== 0 || num
== 0)
4846 if (size
< sizeof * phdrs
)
4848 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4851 if (size
> sizeof * phdrs
)
4852 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4854 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4855 size
, num
, _("program headers"));
4859 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4860 i
< filedata
->file_header
.e_phnum
;
4861 i
++, internal
++, external
++)
4863 internal
->p_type
= BYTE_GET (external
->p_type
);
4864 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4865 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4866 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4867 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4868 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4869 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4870 internal
->p_align
= BYTE_GET (external
->p_align
);
4877 /* Returns TRUE if the program headers were read into `program_headers'. */
4880 get_program_headers (Filedata
* filedata
)
4882 Elf_Internal_Phdr
* phdrs
;
4884 /* Check cache of prior read. */
4885 if (filedata
->program_headers
!= NULL
)
4888 /* Be kind to memory checkers by looking for
4889 e_phnum values which we know must be invalid. */
4890 if (filedata
->file_header
.e_phnum
4891 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4892 >= filedata
->file_size
)
4894 error (_("Too many program headers - %#x - the file is not that big\n"),
4895 filedata
->file_header
.e_phnum
);
4899 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4900 sizeof (Elf_Internal_Phdr
));
4903 error (_("Out of memory reading %u program headers\n"),
4904 filedata
->file_header
.e_phnum
);
4909 ? get_32bit_program_headers (filedata
, phdrs
)
4910 : get_64bit_program_headers (filedata
, phdrs
))
4912 filedata
->program_headers
= phdrs
;
4920 /* Returns TRUE if the program headers were loaded. */
4923 process_program_headers (Filedata
* filedata
)
4925 Elf_Internal_Phdr
* segment
;
4927 Elf_Internal_Phdr
* previous_load
= NULL
;
4929 if (filedata
->file_header
.e_phnum
== 0)
4931 /* PR binutils/12467. */
4932 if (filedata
->file_header
.e_phoff
!= 0)
4934 warn (_("possibly corrupt ELF header - it has a non-zero program"
4935 " header offset, but no program headers\n"));
4938 else if (do_segments
)
4939 printf (_("\nThere are no program headers in this file.\n"));
4943 if (do_segments
&& !do_header
)
4945 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
4946 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
4947 printf (ngettext ("There is %d program header, starting at offset %s\n",
4948 "There are %d program headers, starting at offset %s\n",
4949 filedata
->file_header
.e_phnum
),
4950 filedata
->file_header
.e_phnum
,
4951 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
4954 if (! get_program_headers (filedata
))
4959 if (filedata
->file_header
.e_phnum
> 1)
4960 printf (_("\nProgram Headers:\n"));
4962 printf (_("\nProgram Headers:\n"));
4966 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4969 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4973 (_(" Type Offset VirtAddr PhysAddr\n"));
4975 (_(" FileSiz MemSiz Flags Align\n"));
4982 for (i
= 0, segment
= filedata
->program_headers
;
4983 i
< filedata
->file_header
.e_phnum
;
4988 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
4992 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4993 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4994 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4995 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4996 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4998 (segment
->p_flags
& PF_R
? 'R' : ' '),
4999 (segment
->p_flags
& PF_W
? 'W' : ' '),
5000 (segment
->p_flags
& PF_X
? 'E' : ' '));
5001 printf ("%#lx", (unsigned long) segment
->p_align
);
5005 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5006 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5009 print_vma (segment
->p_offset
, FULL_HEX
);
5013 print_vma (segment
->p_vaddr
, FULL_HEX
);
5015 print_vma (segment
->p_paddr
, FULL_HEX
);
5018 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5019 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5022 print_vma (segment
->p_filesz
, FULL_HEX
);
5026 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5027 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5030 print_vma (segment
->p_memsz
, FULL_HEX
);
5034 (segment
->p_flags
& PF_R
? 'R' : ' '),
5035 (segment
->p_flags
& PF_W
? 'W' : ' '),
5036 (segment
->p_flags
& PF_X
? 'E' : ' '));
5038 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5039 printf ("%#lx", (unsigned long) segment
->p_align
);
5042 print_vma (segment
->p_align
, PREFIX_HEX
);
5047 print_vma (segment
->p_offset
, FULL_HEX
);
5049 print_vma (segment
->p_vaddr
, FULL_HEX
);
5051 print_vma (segment
->p_paddr
, FULL_HEX
);
5053 print_vma (segment
->p_filesz
, FULL_HEX
);
5055 print_vma (segment
->p_memsz
, FULL_HEX
);
5057 (segment
->p_flags
& PF_R
? 'R' : ' '),
5058 (segment
->p_flags
& PF_W
? 'W' : ' '),
5059 (segment
->p_flags
& PF_X
? 'E' : ' '));
5060 print_vma (segment
->p_align
, PREFIX_HEX
);
5063 putc ('\n', stdout
);
5066 switch (segment
->p_type
)
5069 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5070 required by the ELF standard, several programs, including the Linux
5071 kernel, make use of non-ordered segments. */
5073 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5074 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5076 if (segment
->p_memsz
< segment
->p_filesz
)
5077 error (_("the segment's file size is larger than its memory size\n"));
5078 previous_load
= segment
;
5082 /* PR 20815 - Verify that the program header is loaded into memory. */
5083 if (i
> 0 && previous_load
!= NULL
)
5084 error (_("the PHDR segment must occur before any LOAD segment\n"));
5085 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5089 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5090 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5091 && (filedata
->program_headers
[j
].p_vaddr
5092 + filedata
->program_headers
[j
].p_memsz
)
5093 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5095 if (j
== filedata
->file_header
.e_phnum
)
5096 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5102 error (_("more than one dynamic segment\n"));
5104 /* By default, assume that the .dynamic section is the first
5105 section in the DYNAMIC segment. */
5106 dynamic_addr
= segment
->p_offset
;
5107 dynamic_size
= segment
->p_filesz
;
5109 /* Try to locate the .dynamic section. If there is
5110 a section header table, we can easily locate it. */
5111 if (filedata
->section_headers
!= NULL
)
5113 Elf_Internal_Shdr
* sec
;
5115 sec
= find_section (filedata
, ".dynamic");
5116 if (sec
== NULL
|| sec
->sh_size
== 0)
5118 /* A corresponding .dynamic section is expected, but on
5119 IA-64/OpenVMS it is OK for it to be missing. */
5120 if (!is_ia64_vms (filedata
))
5121 error (_("no .dynamic section in the dynamic segment\n"));
5125 if (sec
->sh_type
== SHT_NOBITS
)
5131 dynamic_addr
= sec
->sh_offset
;
5132 dynamic_size
= sec
->sh_size
;
5134 if (dynamic_addr
< segment
->p_offset
5135 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5136 warn (_("the .dynamic section is not contained"
5137 " within the dynamic segment\n"));
5138 else if (dynamic_addr
> segment
->p_offset
)
5139 warn (_("the .dynamic section is not the first section"
5140 " in the dynamic segment.\n"));
5143 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5144 segment. Check this after matching against the section headers
5145 so we don't warn on debuginfo file (which have NOBITS .dynamic
5147 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5149 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5150 dynamic_addr
= dynamic_size
= 0;
5155 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5157 error (_("Unable to find program interpreter name\n"));
5161 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5163 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5164 error (_("Internal error: failed to create format string to display program interpreter\n"));
5166 program_interpreter
[0] = 0;
5167 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5168 error (_("Unable to read program interpreter name\n"));
5171 printf (_(" [Requesting program interpreter: %s]\n"),
5172 program_interpreter
);
5179 && filedata
->section_headers
!= NULL
5180 && filedata
->string_table
!= NULL
)
5182 printf (_("\n Section to Segment mapping:\n"));
5183 printf (_(" Segment Sections...\n"));
5185 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5188 Elf_Internal_Shdr
* section
;
5190 segment
= filedata
->program_headers
+ i
;
5191 section
= filedata
->section_headers
+ 1;
5193 printf (" %2.2d ", i
);
5195 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5197 if (!ELF_TBSS_SPECIAL (section
, segment
)
5198 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5199 printf ("%s ", printable_section_name (filedata
, section
));
5210 /* Find the file offset corresponding to VMA by using the program headers. */
5213 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5215 Elf_Internal_Phdr
* seg
;
5217 if (! get_program_headers (filedata
))
5219 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5223 for (seg
= filedata
->program_headers
;
5224 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5227 if (seg
->p_type
!= PT_LOAD
)
5230 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5231 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5232 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5235 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5236 (unsigned long) vma
);
5241 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5242 If PROBE is true, this is just a probe and we do not generate any error
5243 messages if the load fails. */
5246 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5248 Elf32_External_Shdr
* shdrs
;
5249 Elf_Internal_Shdr
* internal
;
5251 unsigned int size
= filedata
->file_header
.e_shentsize
;
5252 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5254 /* PR binutils/17531: Cope with unexpected section header sizes. */
5255 if (size
== 0 || num
== 0)
5257 if (size
< sizeof * shdrs
)
5260 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5263 if (!probe
&& size
> sizeof * shdrs
)
5264 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5266 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5268 probe
? NULL
: _("section headers"));
5272 free (filedata
->section_headers
);
5273 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5274 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5275 if (filedata
->section_headers
== NULL
)
5278 error (_("Out of memory reading %u section headers\n"), num
);
5282 for (i
= 0, internal
= filedata
->section_headers
;
5286 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5287 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5288 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5289 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5290 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5291 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5292 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5293 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5294 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5295 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5296 if (!probe
&& internal
->sh_link
> num
)
5297 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5298 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5299 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5306 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5309 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5311 Elf64_External_Shdr
* shdrs
;
5312 Elf_Internal_Shdr
* internal
;
5314 unsigned int size
= filedata
->file_header
.e_shentsize
;
5315 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5317 /* PR binutils/17531: Cope with unexpected section header sizes. */
5318 if (size
== 0 || num
== 0)
5321 if (size
< sizeof * shdrs
)
5324 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5328 if (! probe
&& size
> sizeof * shdrs
)
5329 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5331 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5332 filedata
->file_header
.e_shoff
,
5334 probe
? NULL
: _("section headers"));
5338 free (filedata
->section_headers
);
5339 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5340 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5341 if (filedata
->section_headers
== NULL
)
5344 error (_("Out of memory reading %u section headers\n"), num
);
5348 for (i
= 0, internal
= filedata
->section_headers
;
5352 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5353 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5354 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5355 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5356 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5357 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5358 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5359 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5360 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5361 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5362 if (!probe
&& internal
->sh_link
> num
)
5363 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5364 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5365 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5372 static Elf_Internal_Sym
*
5373 get_32bit_elf_symbols (Filedata
* filedata
,
5374 Elf_Internal_Shdr
* section
,
5375 unsigned long * num_syms_return
)
5377 unsigned long number
= 0;
5378 Elf32_External_Sym
* esyms
= NULL
;
5379 Elf_External_Sym_Shndx
* shndx
= NULL
;
5380 Elf_Internal_Sym
* isyms
= NULL
;
5381 Elf_Internal_Sym
* psym
;
5384 if (section
->sh_size
== 0)
5386 if (num_syms_return
!= NULL
)
5387 * num_syms_return
= 0;
5391 /* Run some sanity checks first. */
5392 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5394 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5395 printable_section_name (filedata
, section
),
5396 (unsigned long) section
->sh_entsize
);
5400 if (section
->sh_size
> filedata
->file_size
)
5402 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5403 printable_section_name (filedata
, section
),
5404 (unsigned long) section
->sh_size
);
5408 number
= section
->sh_size
/ section
->sh_entsize
;
5410 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5412 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5413 (unsigned long) section
->sh_size
,
5414 printable_section_name (filedata
, section
),
5415 (unsigned long) section
->sh_entsize
);
5419 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5420 section
->sh_size
, _("symbols"));
5425 elf_section_list
* entry
;
5428 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5429 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5431 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5432 entry
->hdr
->sh_offset
,
5433 1, entry
->hdr
->sh_size
,
5434 _("symbol table section indicies"));
5437 /* PR17531: file: heap-buffer-overflow */
5438 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5440 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5441 printable_section_name (filedata
, entry
->hdr
),
5442 (unsigned long) entry
->hdr
->sh_size
,
5443 (unsigned long) section
->sh_size
);
5449 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5453 error (_("Out of memory reading %lu symbols\n"),
5454 (unsigned long) number
);
5458 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5460 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5461 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5462 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5463 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5464 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5466 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5467 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5468 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5469 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5470 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5479 if (num_syms_return
!= NULL
)
5480 * num_syms_return
= isyms
== NULL
? 0 : number
;
5485 static Elf_Internal_Sym
*
5486 get_64bit_elf_symbols (Filedata
* filedata
,
5487 Elf_Internal_Shdr
* section
,
5488 unsigned long * num_syms_return
)
5490 unsigned long number
= 0;
5491 Elf64_External_Sym
* esyms
= NULL
;
5492 Elf_External_Sym_Shndx
* shndx
= NULL
;
5493 Elf_Internal_Sym
* isyms
= NULL
;
5494 Elf_Internal_Sym
* psym
;
5497 if (section
->sh_size
== 0)
5499 if (num_syms_return
!= NULL
)
5500 * num_syms_return
= 0;
5504 /* Run some sanity checks first. */
5505 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5507 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5508 printable_section_name (filedata
, section
),
5509 (unsigned long) section
->sh_entsize
);
5513 if (section
->sh_size
> filedata
->file_size
)
5515 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5516 printable_section_name (filedata
, section
),
5517 (unsigned long) section
->sh_size
);
5521 number
= section
->sh_size
/ section
->sh_entsize
;
5523 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5525 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5526 (unsigned long) section
->sh_size
,
5527 printable_section_name (filedata
, section
),
5528 (unsigned long) section
->sh_entsize
);
5532 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5533 section
->sh_size
, _("symbols"));
5538 elf_section_list
* entry
;
5541 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5542 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5544 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5545 entry
->hdr
->sh_offset
,
5546 1, entry
->hdr
->sh_size
,
5547 _("symbol table section indicies"));
5550 /* PR17531: file: heap-buffer-overflow */
5551 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5553 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5554 printable_section_name (filedata
, entry
->hdr
),
5555 (unsigned long) entry
->hdr
->sh_size
,
5556 (unsigned long) section
->sh_size
);
5562 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5566 error (_("Out of memory reading %lu symbols\n"),
5567 (unsigned long) number
);
5571 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5573 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5574 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5575 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5576 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5578 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5580 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5581 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5582 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5584 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5585 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5594 if (num_syms_return
!= NULL
)
5595 * num_syms_return
= isyms
== NULL
? 0 : number
;
5601 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5603 static char buff
[1024];
5605 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5607 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5608 bfd_vma os_flags
= 0;
5609 bfd_vma proc_flags
= 0;
5610 bfd_vma unknown_flags
= 0;
5618 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5619 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5620 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5621 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5622 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5623 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5624 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5625 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5626 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5627 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5628 /* IA-64 specific. */
5629 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5630 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5631 /* IA-64 OpenVMS specific. */
5632 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5633 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5634 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5635 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5636 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5637 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5639 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5640 /* SPARC specific. */
5641 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5642 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5644 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5645 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5646 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5648 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5650 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5653 if (do_section_details
)
5655 sprintf (buff
, "[%*.*lx]: ",
5656 field_size
, field_size
, (unsigned long) sh_flags
);
5657 p
+= field_size
+ 4;
5664 flag
= sh_flags
& - sh_flags
;
5667 if (do_section_details
)
5671 case SHF_WRITE
: sindex
= 0; break;
5672 case SHF_ALLOC
: sindex
= 1; break;
5673 case SHF_EXECINSTR
: sindex
= 2; break;
5674 case SHF_MERGE
: sindex
= 3; break;
5675 case SHF_STRINGS
: sindex
= 4; break;
5676 case SHF_INFO_LINK
: sindex
= 5; break;
5677 case SHF_LINK_ORDER
: sindex
= 6; break;
5678 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5679 case SHF_GROUP
: sindex
= 8; break;
5680 case SHF_TLS
: sindex
= 9; break;
5681 case SHF_EXCLUDE
: sindex
= 18; break;
5682 case SHF_COMPRESSED
: sindex
= 20; break;
5683 case SHF_GNU_MBIND
: sindex
= 24; break;
5687 switch (filedata
->file_header
.e_machine
)
5690 if (flag
== SHF_IA_64_SHORT
)
5692 else if (flag
== SHF_IA_64_NORECOV
)
5695 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5698 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5699 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5700 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5701 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5702 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5703 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5714 case EM_OLD_SPARCV9
:
5715 case EM_SPARC32PLUS
:
5718 if (flag
== SHF_ORDERED
)
5725 case SHF_ENTRYSECT
: sindex
= 21; break;
5726 case SHF_ARM_PURECODE
: sindex
= 22; break;
5727 case SHF_COMDEF
: sindex
= 23; break;
5732 if (flag
== SHF_PPC_VLE
)
5743 if (p
!= buff
+ field_size
+ 4)
5745 if (size
< (10 + 2))
5747 warn (_("Internal error: not enough buffer room for section flag info"));
5748 return _("<unknown>");
5755 size
-= flags
[sindex
].len
;
5756 p
= stpcpy (p
, flags
[sindex
].str
);
5758 else if (flag
& SHF_MASKOS
)
5760 else if (flag
& SHF_MASKPROC
)
5763 unknown_flags
|= flag
;
5769 case SHF_WRITE
: *p
= 'W'; break;
5770 case SHF_ALLOC
: *p
= 'A'; break;
5771 case SHF_EXECINSTR
: *p
= 'X'; break;
5772 case SHF_MERGE
: *p
= 'M'; break;
5773 case SHF_STRINGS
: *p
= 'S'; break;
5774 case SHF_INFO_LINK
: *p
= 'I'; break;
5775 case SHF_LINK_ORDER
: *p
= 'L'; break;
5776 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5777 case SHF_GROUP
: *p
= 'G'; break;
5778 case SHF_TLS
: *p
= 'T'; break;
5779 case SHF_EXCLUDE
: *p
= 'E'; break;
5780 case SHF_COMPRESSED
: *p
= 'C'; break;
5781 case SHF_GNU_MBIND
: *p
= 'D'; break;
5784 if ((filedata
->file_header
.e_machine
== EM_X86_64
5785 || filedata
->file_header
.e_machine
== EM_L1OM
5786 || filedata
->file_header
.e_machine
== EM_K1OM
)
5787 && flag
== SHF_X86_64_LARGE
)
5789 else if (filedata
->file_header
.e_machine
== EM_ARM
5790 && flag
== SHF_ARM_PURECODE
)
5792 else if (filedata
->file_header
.e_machine
== EM_PPC
5793 && flag
== SHF_PPC_VLE
)
5795 else if (flag
& SHF_MASKOS
)
5798 sh_flags
&= ~ SHF_MASKOS
;
5800 else if (flag
& SHF_MASKPROC
)
5803 sh_flags
&= ~ SHF_MASKPROC
;
5813 if (do_section_details
)
5817 size
-= 5 + field_size
;
5818 if (p
!= buff
+ field_size
+ 4)
5822 warn (_("Internal error: not enough buffer room for section flag info"));
5823 return _("<unknown>");
5829 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5830 (unsigned long) os_flags
);
5831 p
+= 5 + field_size
;
5835 size
-= 7 + field_size
;
5836 if (p
!= buff
+ field_size
+ 4)
5840 warn (_("Internal error: not enough buffer room for section flag info"));
5841 return _("<unknown>");
5847 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5848 (unsigned long) proc_flags
);
5849 p
+= 7 + field_size
;
5853 size
-= 10 + field_size
;
5854 if (p
!= buff
+ field_size
+ 4)
5858 warn (_("Internal error: not enough buffer room for section flag info"));
5859 return _("<unknown>");
5865 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5866 (unsigned long) unknown_flags
);
5867 p
+= 10 + field_size
;
5876 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5880 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5882 if (size
< sizeof (* echdr
))
5884 error (_("Compressed section is too small even for a compression header\n"));
5888 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5889 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5890 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5891 return sizeof (*echdr
);
5895 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5897 if (size
< sizeof (* echdr
))
5899 error (_("Compressed section is too small even for a compression header\n"));
5903 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5904 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5905 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5906 return sizeof (*echdr
);
5911 process_section_headers (Filedata
* filedata
)
5913 Elf_Internal_Shdr
* section
;
5916 filedata
->section_headers
= NULL
;
5918 if (filedata
->file_header
.e_shnum
== 0)
5920 /* PR binutils/12467. */
5921 if (filedata
->file_header
.e_shoff
!= 0)
5923 warn (_("possibly corrupt ELF file header - it has a non-zero"
5924 " section header offset, but no section headers\n"));
5927 else if (do_sections
)
5928 printf (_("\nThere are no sections in this file.\n"));
5933 if (do_sections
&& !do_header
)
5934 printf (ngettext ("There is %d section header, "
5935 "starting at offset 0x%lx:\n",
5936 "There are %d section headers, "
5937 "starting at offset 0x%lx:\n",
5938 filedata
->file_header
.e_shnum
),
5939 filedata
->file_header
.e_shnum
,
5940 (unsigned long) filedata
->file_header
.e_shoff
);
5944 if (! get_32bit_section_headers (filedata
, FALSE
))
5949 if (! get_64bit_section_headers (filedata
, FALSE
))
5953 /* Read in the string table, so that we have names to display. */
5954 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
5955 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
5957 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
5959 if (section
->sh_size
!= 0)
5961 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
5962 1, section
->sh_size
,
5965 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
5969 /* Scan the sections for the dynamic symbol table
5970 and dynamic string table and debug sections. */
5971 dynamic_symbols
= NULL
;
5972 dynamic_strings
= NULL
;
5973 dynamic_syminfo
= NULL
;
5974 symtab_shndx_list
= NULL
;
5976 eh_addr_size
= is_32bit_elf
? 4 : 8;
5977 switch (filedata
->file_header
.e_machine
)
5980 case EM_MIPS_RS3_LE
:
5981 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5982 FDE addresses. However, the ABI also has a semi-official ILP32
5983 variant for which the normal FDE address size rules apply.
5985 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5986 section, where XX is the size of longs in bits. Unfortunately,
5987 earlier compilers provided no way of distinguishing ILP32 objects
5988 from LP64 objects, so if there's any doubt, we should assume that
5989 the official LP64 form is being used. */
5990 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5991 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
5997 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
5999 case E_H8_MACH_H8300
:
6000 case E_H8_MACH_H8300HN
:
6001 case E_H8_MACH_H8300SN
:
6002 case E_H8_MACH_H8300SXN
:
6005 case E_H8_MACH_H8300H
:
6006 case E_H8_MACH_H8300S
:
6007 case E_H8_MACH_H8300SX
:
6015 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6017 case EF_M32C_CPU_M16C
:
6024 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6027 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6028 if (section->sh_entsize != expected_entsize) \
6031 sprintf_vma (buf, section->sh_entsize); \
6032 /* Note: coded this way so that there is a single string for \
6034 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6035 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6036 (unsigned) expected_entsize); \
6037 section->sh_entsize = expected_entsize; \
6042 #define CHECK_ENTSIZE(section, i, type) \
6043 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6044 sizeof (Elf64_External_##type))
6046 for (i
= 0, section
= filedata
->section_headers
;
6047 i
< filedata
->file_header
.e_shnum
;
6050 char * name
= SECTION_NAME (section
);
6052 if (section
->sh_type
== SHT_DYNSYM
)
6054 if (dynamic_symbols
!= NULL
)
6056 error (_("File contains multiple dynamic symbol tables\n"));
6060 CHECK_ENTSIZE (section
, i
, Sym
);
6061 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6063 else if (section
->sh_type
== SHT_STRTAB
6064 && streq (name
, ".dynstr"))
6066 if (dynamic_strings
!= NULL
)
6068 error (_("File contains multiple dynamic string tables\n"));
6072 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6073 1, section
->sh_size
,
6074 _("dynamic strings"));
6075 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6077 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6079 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6081 entry
->hdr
= section
;
6082 entry
->next
= symtab_shndx_list
;
6083 symtab_shndx_list
= entry
;
6085 else if (section
->sh_type
== SHT_SYMTAB
)
6086 CHECK_ENTSIZE (section
, i
, Sym
);
6087 else if (section
->sh_type
== SHT_GROUP
)
6088 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6089 else if (section
->sh_type
== SHT_REL
)
6090 CHECK_ENTSIZE (section
, i
, Rel
);
6091 else if (section
->sh_type
== SHT_RELA
)
6092 CHECK_ENTSIZE (section
, i
, Rela
);
6093 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6094 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6095 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6096 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6097 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6098 && (const_strneq (name
, ".debug_")
6099 || const_strneq (name
, ".zdebug_")))
6102 name
+= sizeof (".zdebug_") - 1;
6104 name
+= sizeof (".debug_") - 1;
6107 || (do_debug_info
&& const_strneq (name
, "info"))
6108 || (do_debug_info
&& const_strneq (name
, "types"))
6109 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6110 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6111 || (do_debug_lines
&& const_strneq (name
, "line."))
6112 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6113 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6114 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6115 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6116 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6117 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6118 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6119 || (do_debug_frames
&& const_strneq (name
, "frame"))
6120 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6121 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6122 || (do_debug_str
&& const_strneq (name
, "str"))
6123 || (do_debug_loc
&& const_strneq (name
, "loc"))
6124 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6125 || (do_debug_addr
&& const_strneq (name
, "addr"))
6126 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6127 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6129 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6131 /* Linkonce section to be combined with .debug_info at link time. */
6132 else if ((do_debugging
|| do_debug_info
)
6133 && const_strneq (name
, ".gnu.linkonce.wi."))
6134 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6135 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6136 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6137 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6138 || streq (name
, ".debug_names")))
6139 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6140 /* Trace sections for Itanium VMS. */
6141 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6142 || do_trace_aranges
)
6143 && const_strneq (name
, ".trace_"))
6145 name
+= sizeof (".trace_") - 1;
6148 || (do_trace_info
&& streq (name
, "info"))
6149 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6150 || (do_trace_aranges
&& streq (name
, "aranges"))
6152 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6154 else if ((do_debugging
|| do_debug_links
)
6155 && (const_strneq (name
, ".gnu_debuglink")
6156 || const_strneq (name
, ".gnu_debugaltlink")))
6157 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6163 if (filedata
->file_header
.e_shnum
> 1)
6164 printf (_("\nSection Headers:\n"));
6166 printf (_("\nSection Header:\n"));
6170 if (do_section_details
)
6172 printf (_(" [Nr] Name\n"));
6173 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6177 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6181 if (do_section_details
)
6183 printf (_(" [Nr] Name\n"));
6184 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6188 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6192 if (do_section_details
)
6194 printf (_(" [Nr] Name\n"));
6195 printf (_(" Type Address Offset Link\n"));
6196 printf (_(" Size EntSize Info Align\n"));
6200 printf (_(" [Nr] Name Type Address Offset\n"));
6201 printf (_(" Size EntSize Flags Link Info Align\n"));
6205 if (do_section_details
)
6206 printf (_(" Flags\n"));
6208 for (i
= 0, section
= filedata
->section_headers
;
6209 i
< filedata
->file_header
.e_shnum
;
6212 /* Run some sanity checks on the section header. */
6214 /* Check the sh_link field. */
6215 switch (section
->sh_type
)
6217 case SHT_SYMTAB_SHNDX
:
6221 case SHT_GNU_versym
:
6224 if (section
->sh_link
< 1
6225 || section
->sh_link
>= filedata
->file_header
.e_shnum
6226 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6227 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6228 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6229 i
, section
->sh_link
);
6235 case SHT_GNU_verneed
:
6236 case SHT_GNU_verdef
:
6237 case SHT_GNU_LIBLIST
:
6238 if (section
->sh_link
< 1
6239 || section
->sh_link
>= filedata
->file_header
.e_shnum
6240 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6241 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6242 i
, section
->sh_link
);
6245 case SHT_INIT_ARRAY
:
6246 case SHT_FINI_ARRAY
:
6247 case SHT_PREINIT_ARRAY
:
6248 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6249 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6250 i
, section
->sh_link
);
6254 /* FIXME: Add support for target specific section types. */
6255 #if 0 /* Currently we do not check other section types as there are too
6256 many special cases. Stab sections for example have a type
6257 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6259 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6260 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6261 i
, section
->sh_link
);
6266 /* Check the sh_info field. */
6267 switch (section
->sh_type
)
6271 if (section
->sh_info
< 1
6272 || section
->sh_info
>= filedata
->file_header
.e_shnum
6273 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6274 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6275 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6276 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6277 /* FIXME: Are other section types valid ? */
6278 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6280 if (section
->sh_info
== 0
6281 && (filedata
->file_header
.e_type
== ET_EXEC
6282 || filedata
->file_header
.e_type
== ET_DYN
6283 /* These next two tests may be redundant, but
6284 they have been left in for paranoia's sake. */
6285 || streq (SECTION_NAME (section
), ".rel.dyn")
6286 || streq (SECTION_NAME (section
), ".rela.dyn")))
6287 /* Dynamic relocations apply to segments, not sections, so
6288 they do not need an sh_info value. */
6291 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6292 i
, section
->sh_info
);
6298 case SHT_SYMTAB_SHNDX
:
6299 case SHT_INIT_ARRAY
:
6300 case SHT_FINI_ARRAY
:
6301 case SHT_PREINIT_ARRAY
:
6302 if (section
->sh_info
!= 0)
6303 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6304 i
, section
->sh_info
);
6310 /* A symbol index - we assume that it is valid. */
6314 /* FIXME: Add support for target specific section types. */
6315 if (section
->sh_type
== SHT_NOBITS
)
6316 /* NOBITS section headers with non-zero sh_info fields can be
6317 created when a binary is stripped of everything but its debug
6318 information. The stripped sections have their headers
6319 preserved but their types set to SHT_NOBITS. So do not check
6320 this type of section. */
6322 else if (section
->sh_flags
& SHF_INFO_LINK
)
6324 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6325 warn (_("[%2u]: Expected link to another section in info field"), i
);
6327 else if (section
->sh_type
< SHT_LOOS
6328 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6329 && section
->sh_info
!= 0)
6330 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6331 i
, section
->sh_info
);
6335 /* Check the sh_size field. */
6336 if (section
->sh_size
> filedata
->file_size
6337 && section
->sh_type
!= SHT_NOBITS
6338 && section
->sh_type
!= SHT_NULL
6339 && section
->sh_type
< SHT_LOOS
)
6340 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6342 printf (" [%2u] ", i
);
6343 if (do_section_details
)
6344 printf ("%s\n ", printable_section_name (filedata
, section
));
6346 print_symbol (-17, SECTION_NAME (section
));
6348 printf (do_wide
? " %-15s " : " %-15.15s ",
6349 get_section_type_name (filedata
, section
->sh_type
));
6353 const char * link_too_big
= NULL
;
6355 print_vma (section
->sh_addr
, LONG_HEX
);
6357 printf ( " %6.6lx %6.6lx %2.2lx",
6358 (unsigned long) section
->sh_offset
,
6359 (unsigned long) section
->sh_size
,
6360 (unsigned long) section
->sh_entsize
);
6362 if (do_section_details
)
6363 fputs (" ", stdout
);
6365 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6367 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6370 /* The sh_link value is out of range. Normally this indicates
6371 an error but it can have special values in Solaris binaries. */
6372 switch (filedata
->file_header
.e_machine
)
6379 case EM_OLD_SPARCV9
:
6380 case EM_SPARC32PLUS
:
6383 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6384 link_too_big
= "BEFORE";
6385 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6386 link_too_big
= "AFTER";
6393 if (do_section_details
)
6395 if (link_too_big
!= NULL
&& * link_too_big
)
6396 printf ("<%s> ", link_too_big
);
6398 printf ("%2u ", section
->sh_link
);
6399 printf ("%3u %2lu\n", section
->sh_info
,
6400 (unsigned long) section
->sh_addralign
);
6403 printf ("%2u %3u %2lu\n",
6406 (unsigned long) section
->sh_addralign
);
6408 if (link_too_big
&& ! * link_too_big
)
6409 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6410 i
, section
->sh_link
);
6414 print_vma (section
->sh_addr
, LONG_HEX
);
6416 if ((long) section
->sh_offset
== section
->sh_offset
)
6417 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6421 print_vma (section
->sh_offset
, LONG_HEX
);
6424 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6425 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6429 print_vma (section
->sh_size
, LONG_HEX
);
6432 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6433 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6437 print_vma (section
->sh_entsize
, LONG_HEX
);
6440 if (do_section_details
)
6441 fputs (" ", stdout
);
6443 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6445 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6447 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6448 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6451 print_vma (section
->sh_addralign
, DEC
);
6455 else if (do_section_details
)
6457 printf (" %-15.15s ",
6458 get_section_type_name (filedata
, section
->sh_type
));
6459 print_vma (section
->sh_addr
, LONG_HEX
);
6460 if ((long) section
->sh_offset
== section
->sh_offset
)
6461 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6465 print_vma (section
->sh_offset
, LONG_HEX
);
6467 printf (" %u\n ", section
->sh_link
);
6468 print_vma (section
->sh_size
, LONG_HEX
);
6470 print_vma (section
->sh_entsize
, LONG_HEX
);
6472 printf (" %-16u %lu\n",
6474 (unsigned long) section
->sh_addralign
);
6479 print_vma (section
->sh_addr
, LONG_HEX
);
6480 if ((long) section
->sh_offset
== section
->sh_offset
)
6481 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6485 print_vma (section
->sh_offset
, LONG_HEX
);
6488 print_vma (section
->sh_size
, LONG_HEX
);
6490 print_vma (section
->sh_entsize
, LONG_HEX
);
6492 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6494 printf (" %2u %3u %lu\n",
6497 (unsigned long) section
->sh_addralign
);
6500 if (do_section_details
)
6502 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6503 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6505 /* Minimum section size is 12 bytes for 32-bit compression
6506 header + 12 bytes for compressed data header. */
6507 unsigned char buf
[24];
6509 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6510 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6511 sizeof (buf
), _("compression header")))
6513 Elf_Internal_Chdr chdr
;
6515 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6517 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6520 printf (_(" [<unknown>: 0x%x], "),
6522 print_vma (chdr
.ch_size
, LONG_HEX
);
6523 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6529 if (!do_section_details
)
6531 /* The ordering of the letters shown here matches the ordering of the
6532 corresponding SHF_xxx values, and hence the order in which these
6533 letters will be displayed to the user. */
6534 printf (_("Key to Flags:\n\
6535 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6536 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6537 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6538 if (filedata
->file_header
.e_machine
== EM_X86_64
6539 || filedata
->file_header
.e_machine
== EM_L1OM
6540 || filedata
->file_header
.e_machine
== EM_K1OM
)
6541 printf (_("l (large), "));
6542 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6543 printf (_("y (purecode), "));
6544 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6545 printf (_("v (VLE), "));
6546 printf ("p (processor specific)\n");
6553 get_group_flags (unsigned int flags
)
6555 static char buff
[128];
6559 else if (flags
== GRP_COMDAT
)
6562 snprintf (buff
, 14, _("[0x%x: "), flags
);
6564 flags
&= ~ GRP_COMDAT
;
6565 if (flags
& GRP_MASKOS
)
6567 strcat (buff
, "<OS specific>");
6568 flags
&= ~ GRP_MASKOS
;
6571 if (flags
& GRP_MASKPROC
)
6573 strcat (buff
, "<PROC specific>");
6574 flags
&= ~ GRP_MASKPROC
;
6578 strcat (buff
, "<unknown>");
6585 process_section_groups (Filedata
* filedata
)
6587 Elf_Internal_Shdr
* section
;
6589 struct group
* group
;
6590 Elf_Internal_Shdr
* symtab_sec
;
6591 Elf_Internal_Shdr
* strtab_sec
;
6592 Elf_Internal_Sym
* symtab
;
6593 unsigned long num_syms
;
6597 /* Don't process section groups unless needed. */
6598 if (!do_unwind
&& !do_section_groups
)
6601 if (filedata
->file_header
.e_shnum
== 0)
6603 if (do_section_groups
)
6604 printf (_("\nThere are no sections to group in this file.\n"));
6609 if (filedata
->section_headers
== NULL
)
6611 error (_("Section headers are not available!\n"));
6612 /* PR 13622: This can happen with a corrupt ELF header. */
6616 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6617 sizeof (struct group
*));
6619 if (section_headers_groups
== NULL
)
6621 error (_("Out of memory reading %u section group headers\n"),
6622 filedata
->file_header
.e_shnum
);
6626 /* Scan the sections for the group section. */
6628 for (i
= 0, section
= filedata
->section_headers
;
6629 i
< filedata
->file_header
.e_shnum
;
6631 if (section
->sh_type
== SHT_GROUP
)
6634 if (group_count
== 0)
6636 if (do_section_groups
)
6637 printf (_("\nThere are no section groups in this file.\n"));
6642 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6644 if (section_groups
== NULL
)
6646 error (_("Out of memory reading %lu groups\n"),
6647 (unsigned long) group_count
);
6657 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6658 i
< filedata
->file_header
.e_shnum
;
6661 if (section
->sh_type
== SHT_GROUP
)
6663 const char * name
= printable_section_name (filedata
, section
);
6664 const char * group_name
;
6665 unsigned char * start
;
6666 unsigned char * indices
;
6667 unsigned int entry
, j
, size
;
6668 Elf_Internal_Shdr
* sec
;
6669 Elf_Internal_Sym
* sym
;
6671 /* Get the symbol table. */
6672 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6673 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6676 error (_("Bad sh_link in group section `%s'\n"), name
);
6680 if (symtab_sec
!= sec
)
6685 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6690 error (_("Corrupt header in group section `%s'\n"), name
);
6694 if (section
->sh_info
>= num_syms
)
6696 error (_("Bad sh_info in group section `%s'\n"), name
);
6700 sym
= symtab
+ section
->sh_info
;
6702 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6704 if (sym
->st_shndx
== 0
6705 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6707 error (_("Bad sh_info in group section `%s'\n"), name
);
6711 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6720 /* Get the string table. */
6721 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6730 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6736 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6737 1, strtab_sec
->sh_size
,
6739 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6741 group_name
= sym
->st_name
< strtab_size
6742 ? strtab
+ sym
->st_name
: _("<corrupt>");
6745 /* PR 17531: file: loop. */
6746 if (section
->sh_entsize
> section
->sh_size
)
6748 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6749 printable_section_name (filedata
, section
),
6750 (unsigned long) section
->sh_entsize
,
6751 (unsigned long) section
->sh_size
);
6755 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6756 1, section
->sh_size
,
6762 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6763 entry
= byte_get (indices
, 4);
6766 if (do_section_groups
)
6768 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6769 get_group_flags (entry
), i
, name
, group_name
, size
);
6771 printf (_(" [Index] Name\n"));
6774 group
->group_index
= i
;
6776 for (j
= 0; j
< size
; j
++)
6778 struct group_list
* g
;
6780 entry
= byte_get (indices
, 4);
6783 if (entry
>= filedata
->file_header
.e_shnum
)
6785 static unsigned num_group_errors
= 0;
6787 if (num_group_errors
++ < 10)
6789 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6790 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6791 if (num_group_errors
== 10)
6792 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6797 if (section_headers_groups
[entry
] != NULL
)
6801 static unsigned num_errs
= 0;
6803 if (num_errs
++ < 10)
6805 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6807 section_headers_groups
[entry
]->group_index
);
6809 warn (_("Further error messages about already contained group sections suppressed\n"));
6815 /* Intel C/C++ compiler may put section 0 in a
6816 section group. We just warn it the first time
6817 and ignore it afterwards. */
6818 static bfd_boolean warned
= FALSE
;
6821 error (_("section 0 in group section [%5u]\n"),
6822 section_headers_groups
[entry
]->group_index
);
6828 section_headers_groups
[entry
] = group
;
6830 if (do_section_groups
)
6832 sec
= filedata
->section_headers
+ entry
;
6833 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6836 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6837 g
->section_index
= entry
;
6838 g
->next
= group
->root
;
6856 /* Data used to display dynamic fixups. */
6858 struct ia64_vms_dynfixup
6860 bfd_vma needed_ident
; /* Library ident number. */
6861 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6862 bfd_vma fixup_needed
; /* Index of the library. */
6863 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6864 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6867 /* Data used to display dynamic relocations. */
6869 struct ia64_vms_dynimgrela
6871 bfd_vma img_rela_cnt
; /* Number of relocations. */
6872 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6875 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6879 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6880 struct ia64_vms_dynfixup
* fixup
,
6881 const char * strtab
,
6882 unsigned int strtab_sz
)
6884 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6886 const char * lib_name
;
6888 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6889 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6890 _("dynamic section image fixups"));
6894 if (fixup
->needed
< strtab_sz
)
6895 lib_name
= strtab
+ fixup
->needed
;
6898 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6899 (unsigned long) fixup
->needed
);
6902 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6903 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6905 (_("Seg Offset Type SymVec DataType\n"));
6907 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6912 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6913 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6914 type
= BYTE_GET (imfs
[i
].type
);
6915 rtype
= elf_ia64_reloc_type (type
);
6917 printf (" 0x%08x ", type
);
6919 printf (" %-32s ", rtype
);
6920 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6921 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6928 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6931 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
6933 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6936 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
6937 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6938 _("dynamic section image relocations"));
6942 printf (_("\nImage relocs\n"));
6944 (_("Seg Offset Type Addend Seg Sym Off\n"));
6946 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6951 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6952 printf ("%08" BFD_VMA_FMT
"x ",
6953 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6954 type
= BYTE_GET (imrs
[i
].type
);
6955 rtype
= elf_ia64_reloc_type (type
);
6957 printf ("0x%08x ", type
);
6959 printf ("%-31s ", rtype
);
6960 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6961 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6962 printf ("%08" BFD_VMA_FMT
"x\n",
6963 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6970 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6973 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
6975 struct ia64_vms_dynfixup fixup
;
6976 struct ia64_vms_dynimgrela imgrela
;
6977 Elf_Internal_Dyn
*entry
;
6978 bfd_vma strtab_off
= 0;
6979 bfd_vma strtab_sz
= 0;
6980 char *strtab
= NULL
;
6981 bfd_boolean res
= TRUE
;
6983 memset (&fixup
, 0, sizeof (fixup
));
6984 memset (&imgrela
, 0, sizeof (imgrela
));
6986 /* Note: the order of the entries is specified by the OpenVMS specs. */
6987 for (entry
= dynamic_section
;
6988 entry
< dynamic_section
+ dynamic_nent
;
6991 switch (entry
->d_tag
)
6993 case DT_IA_64_VMS_STRTAB_OFFSET
:
6994 strtab_off
= entry
->d_un
.d_val
;
6997 strtab_sz
= entry
->d_un
.d_val
;
6999 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7000 1, strtab_sz
, _("dynamic string section"));
7003 case DT_IA_64_VMS_NEEDED_IDENT
:
7004 fixup
.needed_ident
= entry
->d_un
.d_val
;
7007 fixup
.needed
= entry
->d_un
.d_val
;
7009 case DT_IA_64_VMS_FIXUP_NEEDED
:
7010 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7012 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7013 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7015 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7016 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7017 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7020 case DT_IA_64_VMS_IMG_RELA_CNT
:
7021 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7023 case DT_IA_64_VMS_IMG_RELA_OFF
:
7024 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7025 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7047 dynamic_relocations
[] =
7049 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7050 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7051 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7054 /* Process the reloc section. */
7057 process_relocs (Filedata
* filedata
)
7059 unsigned long rel_size
;
7060 unsigned long rel_offset
;
7065 if (do_using_dynamic
)
7069 bfd_boolean has_dynamic_reloc
;
7072 has_dynamic_reloc
= FALSE
;
7074 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7076 is_rela
= dynamic_relocations
[i
].rela
;
7077 name
= dynamic_relocations
[i
].name
;
7078 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7079 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7082 has_dynamic_reloc
= TRUE
;
7084 if (is_rela
== UNKNOWN
)
7086 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7087 switch (dynamic_info
[DT_PLTREL
])
7101 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7102 name
, rel_offset
, rel_size
);
7104 dump_relocations (filedata
,
7105 offset_from_vma (filedata
, rel_offset
, rel_size
),
7107 dynamic_symbols
, num_dynamic_syms
,
7108 dynamic_strings
, dynamic_strings_length
,
7109 is_rela
, TRUE
/* is_dynamic */);
7113 if (is_ia64_vms (filedata
))
7114 if (process_ia64_vms_dynamic_relocs (filedata
))
7115 has_dynamic_reloc
= TRUE
;
7117 if (! has_dynamic_reloc
)
7118 printf (_("\nThere are no dynamic relocations in this file.\n"));
7122 Elf_Internal_Shdr
* section
;
7124 bfd_boolean found
= FALSE
;
7126 for (i
= 0, section
= filedata
->section_headers
;
7127 i
< filedata
->file_header
.e_shnum
;
7130 if ( section
->sh_type
!= SHT_RELA
7131 && section
->sh_type
!= SHT_REL
)
7134 rel_offset
= section
->sh_offset
;
7135 rel_size
= section
->sh_size
;
7139 Elf_Internal_Shdr
* strsec
;
7141 unsigned long num_rela
;
7143 printf (_("\nRelocation section "));
7145 if (filedata
->string_table
== NULL
)
7146 printf ("%d", section
->sh_name
);
7148 printf ("'%s'", printable_section_name (filedata
, section
));
7150 num_rela
= rel_size
/ section
->sh_entsize
;
7151 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7152 " at offset 0x%lx contains %lu entries:\n",
7154 rel_offset
, num_rela
);
7156 is_rela
= section
->sh_type
== SHT_RELA
;
7158 if (section
->sh_link
!= 0
7159 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7161 Elf_Internal_Shdr
* symsec
;
7162 Elf_Internal_Sym
* symtab
;
7163 unsigned long nsyms
;
7164 unsigned long strtablen
= 0;
7165 char * strtab
= NULL
;
7167 symsec
= filedata
->section_headers
+ section
->sh_link
;
7168 if (symsec
->sh_type
!= SHT_SYMTAB
7169 && symsec
->sh_type
!= SHT_DYNSYM
)
7172 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7177 if (symsec
->sh_link
!= 0
7178 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7180 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7182 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7185 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7188 dump_relocations (filedata
, rel_offset
, rel_size
,
7189 symtab
, nsyms
, strtab
, strtablen
,
7191 symsec
->sh_type
== SHT_DYNSYM
);
7197 dump_relocations (filedata
, rel_offset
, rel_size
,
7198 NULL
, 0, NULL
, 0, is_rela
,
7199 FALSE
/* is_dynamic */);
7207 /* Users sometimes forget the -D option, so try to be helpful. */
7208 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7210 if (dynamic_info
[dynamic_relocations
[i
].size
])
7212 printf (_("\nThere are no static relocations in this file."));
7213 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7218 if (i
== ARRAY_SIZE (dynamic_relocations
))
7219 printf (_("\nThere are no relocations in this file.\n"));
7226 /* An absolute address consists of a section and an offset. If the
7227 section is NULL, the offset itself is the address, otherwise, the
7228 address equals to LOAD_ADDRESS(section) + offset. */
7232 unsigned short section
;
7236 #define ABSADDR(a) \
7238 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7241 /* Find the nearest symbol at or below ADDR. Returns the symbol
7242 name, if found, and the offset from the symbol to ADDR. */
7245 find_symbol_for_address (Filedata
* filedata
,
7246 Elf_Internal_Sym
* symtab
,
7247 unsigned long nsyms
,
7248 const char * strtab
,
7249 unsigned long strtab_size
,
7250 struct absaddr addr
,
7251 const char ** symname
,
7254 bfd_vma dist
= 0x100000;
7255 Elf_Internal_Sym
* sym
;
7256 Elf_Internal_Sym
* beg
;
7257 Elf_Internal_Sym
* end
;
7258 Elf_Internal_Sym
* best
= NULL
;
7260 REMOVE_ARCH_BITS (addr
.offset
);
7262 end
= symtab
+ nsyms
;
7268 sym
= beg
+ (end
- beg
) / 2;
7270 value
= sym
->st_value
;
7271 REMOVE_ARCH_BITS (value
);
7273 if (sym
->st_name
!= 0
7274 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7275 && addr
.offset
>= value
7276 && addr
.offset
- value
< dist
)
7279 dist
= addr
.offset
- value
;
7284 if (addr
.offset
< value
)
7292 *symname
= (best
->st_name
>= strtab_size
7293 ? _("<corrupt>") : strtab
+ best
->st_name
);
7299 *offset
= addr
.offset
;
7302 static /* signed */ int
7303 symcmp (const void *p
, const void *q
)
7305 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7306 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7308 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7311 /* Process the unwind section. */
7313 #include "unwind-ia64.h"
7315 struct ia64_unw_table_entry
7317 struct absaddr start
;
7319 struct absaddr info
;
7322 struct ia64_unw_aux_info
7324 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7325 unsigned long table_len
; /* Length of unwind table. */
7326 unsigned char * info
; /* Unwind info. */
7327 unsigned long info_size
; /* Size of unwind info. */
7328 bfd_vma info_addr
; /* Starting address of unwind info. */
7329 bfd_vma seg_base
; /* Starting address of segment. */
7330 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7331 unsigned long nsyms
; /* Number of symbols. */
7332 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7333 unsigned long nfuns
; /* Number of entries in funtab. */
7334 char * strtab
; /* The string table. */
7335 unsigned long strtab_size
; /* Size of string table. */
7339 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7341 struct ia64_unw_table_entry
* tp
;
7342 unsigned long j
, nfuns
;
7344 bfd_boolean res
= TRUE
;
7346 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7347 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7348 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7349 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7351 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7353 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7357 const unsigned char * dp
;
7358 const unsigned char * head
;
7359 const unsigned char * end
;
7360 const char * procname
;
7362 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7363 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7365 fputs ("\n<", stdout
);
7369 fputs (procname
, stdout
);
7372 printf ("+%lx", (unsigned long) offset
);
7375 fputs (">: [", stdout
);
7376 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7377 fputc ('-', stdout
);
7378 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7379 printf ("], info at +0x%lx\n",
7380 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7382 /* PR 17531: file: 86232b32. */
7383 if (aux
->info
== NULL
)
7386 /* PR 17531: file: 0997b4d1. */
7387 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7389 warn (_("Invalid offset %lx in table entry %ld\n"),
7390 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7395 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7396 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7398 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7399 (unsigned) UNW_VER (stamp
),
7400 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7401 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7402 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7403 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7405 if (UNW_VER (stamp
) != 1)
7407 printf (_("\tUnknown version.\n"));
7412 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7413 /* PR 17531: file: 16ceda89. */
7414 if (end
> aux
->info
+ aux
->info_size
)
7415 end
= aux
->info
+ aux
->info_size
;
7416 for (dp
= head
+ 8; dp
< end
;)
7417 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7426 slurp_ia64_unwind_table (Filedata
* filedata
,
7427 struct ia64_unw_aux_info
* aux
,
7428 Elf_Internal_Shdr
* sec
)
7430 unsigned long size
, nrelas
, i
;
7431 Elf_Internal_Phdr
* seg
;
7432 struct ia64_unw_table_entry
* tep
;
7433 Elf_Internal_Shdr
* relsec
;
7434 Elf_Internal_Rela
* rela
;
7435 Elf_Internal_Rela
* rp
;
7436 unsigned char * table
;
7438 Elf_Internal_Sym
* sym
;
7439 const char * relname
;
7443 /* First, find the starting address of the segment that includes
7446 if (filedata
->file_header
.e_phnum
)
7448 if (! get_program_headers (filedata
))
7451 for (seg
= filedata
->program_headers
;
7452 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7455 if (seg
->p_type
!= PT_LOAD
)
7458 if (sec
->sh_addr
>= seg
->p_vaddr
7459 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7461 aux
->seg_base
= seg
->p_vaddr
;
7467 /* Second, build the unwind table from the contents of the unwind section: */
7468 size
= sec
->sh_size
;
7469 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7474 aux
->table_len
= size
/ (3 * eh_addr_size
);
7475 aux
->table
= (struct ia64_unw_table_entry
*)
7476 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7479 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7481 tep
->start
.section
= SHN_UNDEF
;
7482 tep
->end
.section
= SHN_UNDEF
;
7483 tep
->info
.section
= SHN_UNDEF
;
7484 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7485 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7486 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7487 tep
->start
.offset
+= aux
->seg_base
;
7488 tep
->end
.offset
+= aux
->seg_base
;
7489 tep
->info
.offset
+= aux
->seg_base
;
7493 /* Third, apply any relocations to the unwind table: */
7494 for (relsec
= filedata
->section_headers
;
7495 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7498 if (relsec
->sh_type
!= SHT_RELA
7499 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7500 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7503 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7512 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7514 relname
= elf_ia64_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7515 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7517 /* PR 17531: file: 9fa67536. */
7518 if (relname
== NULL
)
7520 warn (_("Skipping unknown relocation type: %u\n"),
7521 get_reloc_type (filedata
, rp
->r_info
));
7525 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7527 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7531 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7533 /* PR 17531: file: 5bc8d9bf. */
7534 if (i
>= aux
->table_len
)
7536 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7540 switch (rp
->r_offset
/ eh_addr_size
% 3)
7543 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7544 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7547 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7548 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7551 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7552 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7566 ia64_process_unwind (Filedata
* filedata
)
7568 Elf_Internal_Shdr
* sec
;
7569 Elf_Internal_Shdr
* unwsec
= NULL
;
7570 Elf_Internal_Shdr
* strsec
;
7571 unsigned long i
, unwcount
= 0, unwstart
= 0;
7572 struct ia64_unw_aux_info aux
;
7573 bfd_boolean res
= TRUE
;
7575 memset (& aux
, 0, sizeof (aux
));
7577 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7579 if (sec
->sh_type
== SHT_SYMTAB
7580 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7582 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7584 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7585 if (aux
.strtab
!= NULL
)
7587 error (_("Multiple auxillary string tables encountered\n"));
7591 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7594 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7596 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7601 printf (_("\nThere are no unwind sections in this file.\n"));
7603 while (unwcount
-- > 0)
7608 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7609 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7610 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7615 /* We have already counted the number of SHT_IA64_UNWIND
7616 sections so the loop above should never fail. */
7617 assert (unwsec
!= NULL
);
7620 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7622 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7624 /* We need to find which section group it is in. */
7625 struct group_list
* g
;
7627 if (section_headers_groups
== NULL
7628 || section_headers_groups
[i
] == NULL
)
7629 i
= filedata
->file_header
.e_shnum
;
7632 g
= section_headers_groups
[i
]->root
;
7634 for (; g
!= NULL
; g
= g
->next
)
7636 sec
= filedata
->section_headers
+ g
->section_index
;
7638 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7643 i
= filedata
->file_header
.e_shnum
;
7646 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7648 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7649 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7650 suffix
= SECTION_NAME (unwsec
) + len
;
7651 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7653 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7654 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7659 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7660 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7661 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7662 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7664 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7665 suffix
= SECTION_NAME (unwsec
) + len
;
7666 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7668 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7669 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7673 if (i
== filedata
->file_header
.e_shnum
)
7675 printf (_("\nCould not find unwind info section for "));
7677 if (filedata
->string_table
== NULL
)
7678 printf ("%d", unwsec
->sh_name
);
7680 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7684 aux
.info_addr
= sec
->sh_addr
;
7685 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7688 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7690 printf (_("\nUnwind section "));
7692 if (filedata
->string_table
== NULL
)
7693 printf ("%d", unwsec
->sh_name
);
7695 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7697 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7698 (unsigned long) unwsec
->sh_offset
,
7699 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7701 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7702 && aux
.table_len
> 0)
7703 dump_ia64_unwind (filedata
, & aux
);
7706 free ((char *) aux
.table
);
7708 free ((char *) aux
.info
);
7717 free ((char *) aux
.strtab
);
7722 struct hppa_unw_table_entry
7724 struct absaddr start
;
7726 unsigned int Cannot_unwind
:1; /* 0 */
7727 unsigned int Millicode
:1; /* 1 */
7728 unsigned int Millicode_save_sr0
:1; /* 2 */
7729 unsigned int Region_description
:2; /* 3..4 */
7730 unsigned int reserved1
:1; /* 5 */
7731 unsigned int Entry_SR
:1; /* 6 */
7732 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7733 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7734 unsigned int Args_stored
:1; /* 16 */
7735 unsigned int Variable_Frame
:1; /* 17 */
7736 unsigned int Separate_Package_Body
:1; /* 18 */
7737 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7738 unsigned int Stack_Overflow_Check
:1; /* 20 */
7739 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7740 unsigned int Ada_Region
:1; /* 22 */
7741 unsigned int cxx_info
:1; /* 23 */
7742 unsigned int cxx_try_catch
:1; /* 24 */
7743 unsigned int sched_entry_seq
:1; /* 25 */
7744 unsigned int reserved2
:1; /* 26 */
7745 unsigned int Save_SP
:1; /* 27 */
7746 unsigned int Save_RP
:1; /* 28 */
7747 unsigned int Save_MRP_in_frame
:1; /* 29 */
7748 unsigned int extn_ptr_defined
:1; /* 30 */
7749 unsigned int Cleanup_defined
:1; /* 31 */
7751 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7752 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7753 unsigned int Large_frame
:1; /* 2 */
7754 unsigned int Pseudo_SP_Set
:1; /* 3 */
7755 unsigned int reserved4
:1; /* 4 */
7756 unsigned int Total_frame_size
:27; /* 5..31 */
7759 struct hppa_unw_aux_info
7761 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7762 unsigned long table_len
; /* Length of unwind table. */
7763 bfd_vma seg_base
; /* Starting address of segment. */
7764 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7765 unsigned long nsyms
; /* Number of symbols. */
7766 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7767 unsigned long nfuns
; /* Number of entries in funtab. */
7768 char * strtab
; /* The string table. */
7769 unsigned long strtab_size
; /* Size of string table. */
7773 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7775 struct hppa_unw_table_entry
* tp
;
7776 unsigned long j
, nfuns
;
7777 bfd_boolean res
= TRUE
;
7779 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7780 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7781 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7782 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7784 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7786 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7789 const char * procname
;
7791 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7792 aux
->strtab_size
, tp
->start
, &procname
,
7795 fputs ("\n<", stdout
);
7799 fputs (procname
, stdout
);
7802 printf ("+%lx", (unsigned long) offset
);
7805 fputs (">: [", stdout
);
7806 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7807 fputc ('-', stdout
);
7808 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7811 #define PF(_m) if (tp->_m) printf (#_m " ");
7812 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7815 PF(Millicode_save_sr0
);
7816 /* PV(Region_description); */
7822 PF(Separate_Package_Body
);
7823 PF(Frame_Extension_Millicode
);
7824 PF(Stack_Overflow_Check
);
7825 PF(Two_Instruction_SP_Increment
);
7829 PF(sched_entry_seq
);
7832 PF(Save_MRP_in_frame
);
7833 PF(extn_ptr_defined
);
7834 PF(Cleanup_defined
);
7835 PF(MPE_XL_interrupt_marker
);
7836 PF(HP_UX_interrupt_marker
);
7839 PV(Total_frame_size
);
7852 slurp_hppa_unwind_table (Filedata
* filedata
,
7853 struct hppa_unw_aux_info
* aux
,
7854 Elf_Internal_Shdr
* sec
)
7856 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7857 Elf_Internal_Phdr
* seg
;
7858 struct hppa_unw_table_entry
* tep
;
7859 Elf_Internal_Shdr
* relsec
;
7860 Elf_Internal_Rela
* rela
;
7861 Elf_Internal_Rela
* rp
;
7862 unsigned char * table
;
7864 Elf_Internal_Sym
* sym
;
7865 const char * relname
;
7867 /* First, find the starting address of the segment that includes
7869 if (filedata
->file_header
.e_phnum
)
7871 if (! get_program_headers (filedata
))
7874 for (seg
= filedata
->program_headers
;
7875 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7878 if (seg
->p_type
!= PT_LOAD
)
7881 if (sec
->sh_addr
>= seg
->p_vaddr
7882 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7884 aux
->seg_base
= seg
->p_vaddr
;
7890 /* Second, build the unwind table from the contents of the unwind
7892 size
= sec
->sh_size
;
7893 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7899 nentries
= size
/ unw_ent_size
;
7900 size
= unw_ent_size
* nentries
;
7902 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7903 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7905 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7907 unsigned int tmp1
, tmp2
;
7909 tep
->start
.section
= SHN_UNDEF
;
7910 tep
->end
.section
= SHN_UNDEF
;
7912 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7913 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7914 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7915 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7917 tep
->start
.offset
+= aux
->seg_base
;
7918 tep
->end
.offset
+= aux
->seg_base
;
7920 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7921 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7922 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7923 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7924 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7925 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7926 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7927 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7928 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7929 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7930 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7931 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7932 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7933 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7934 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7935 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7936 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7937 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7938 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7939 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7940 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7941 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7942 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7943 tep
->Cleanup_defined
= tmp1
& 0x1;
7945 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7946 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7947 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7948 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7949 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7950 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7954 /* Third, apply any relocations to the unwind table. */
7955 for (relsec
= filedata
->section_headers
;
7956 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7959 if (relsec
->sh_type
!= SHT_RELA
7960 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7961 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7964 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7968 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7970 relname
= elf_hppa_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7971 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7973 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7974 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7976 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7980 i
= rp
->r_offset
/ unw_ent_size
;
7982 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7985 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7986 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7989 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7990 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8000 aux
->table_len
= nentries
;
8006 hppa_process_unwind (Filedata
* filedata
)
8008 struct hppa_unw_aux_info aux
;
8009 Elf_Internal_Shdr
* unwsec
= NULL
;
8010 Elf_Internal_Shdr
* strsec
;
8011 Elf_Internal_Shdr
* sec
;
8013 bfd_boolean res
= TRUE
;
8015 if (filedata
->string_table
== NULL
)
8018 memset (& aux
, 0, sizeof (aux
));
8020 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8022 if (sec
->sh_type
== SHT_SYMTAB
8023 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8025 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8027 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8028 if (aux
.strtab
!= NULL
)
8030 error (_("Multiple auxillary string tables encountered\n"));
8034 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8037 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8039 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8044 printf (_("\nThere are no unwind sections in this file.\n"));
8046 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8048 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8050 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8052 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8053 "contains %lu entry:\n",
8054 "\nUnwind section '%s' at offset 0x%lx "
8055 "contains %lu entries:\n",
8057 printable_section_name (filedata
, sec
),
8058 (unsigned long) sec
->sh_offset
,
8061 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8064 if (aux
.table_len
> 0)
8066 if (! dump_hppa_unwind (filedata
, &aux
))
8071 free ((char *) aux
.table
);
8079 free ((char *) aux
.strtab
);
8086 unsigned char * data
; /* The unwind data. */
8087 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8088 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8089 unsigned long nrelas
; /* The number of relocations. */
8090 unsigned int rel_type
; /* REL or RELA ? */
8091 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8094 struct arm_unw_aux_info
8096 Filedata
* filedata
; /* The file containing the unwind sections. */
8097 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8098 unsigned long nsyms
; /* Number of symbols. */
8099 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8100 unsigned long nfuns
; /* Number of these symbols. */
8101 char * strtab
; /* The file's string table. */
8102 unsigned long strtab_size
; /* Size of string table. */
8106 arm_print_vma_and_name (Filedata
* filedata
,
8107 struct arm_unw_aux_info
* aux
,
8109 struct absaddr addr
)
8111 const char *procname
;
8114 if (addr
.section
== SHN_UNDEF
)
8117 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8118 aux
->strtab_size
, addr
, &procname
,
8121 print_vma (fn
, PREFIX_HEX
);
8125 fputs (" <", stdout
);
8126 fputs (procname
, stdout
);
8129 printf ("+0x%lx", (unsigned long) sym_offset
);
8130 fputc ('>', stdout
);
8137 arm_free_section (struct arm_section
*arm_sec
)
8139 if (arm_sec
->data
!= NULL
)
8140 free (arm_sec
->data
);
8142 if (arm_sec
->rela
!= NULL
)
8143 free (arm_sec
->rela
);
8146 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8147 cached section and install SEC instead.
8148 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8149 and return its valued in * WORDP, relocating if necessary.
8150 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8151 relocation's offset in ADDR.
8152 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8153 into the string table of the symbol associated with the reloc. If no
8154 reloc was applied store -1 there.
8155 5) Return TRUE upon success, FALSE otherwise. */
8158 get_unwind_section_word (Filedata
* filedata
,
8159 struct arm_unw_aux_info
* aux
,
8160 struct arm_section
* arm_sec
,
8161 Elf_Internal_Shdr
* sec
,
8162 bfd_vma word_offset
,
8163 unsigned int * wordp
,
8164 struct absaddr
* addr
,
8167 Elf_Internal_Rela
*rp
;
8168 Elf_Internal_Sym
*sym
;
8169 const char * relname
;
8171 bfd_boolean wrapped
;
8173 if (sec
== NULL
|| arm_sec
== NULL
)
8176 addr
->section
= SHN_UNDEF
;
8179 if (sym_name
!= NULL
)
8180 *sym_name
= (bfd_vma
) -1;
8182 /* If necessary, update the section cache. */
8183 if (sec
!= arm_sec
->sec
)
8185 Elf_Internal_Shdr
*relsec
;
8187 arm_free_section (arm_sec
);
8190 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8191 sec
->sh_size
, _("unwind data"));
8192 arm_sec
->rela
= NULL
;
8193 arm_sec
->nrelas
= 0;
8195 for (relsec
= filedata
->section_headers
;
8196 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8199 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8200 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8201 /* PR 15745: Check the section type as well. */
8202 || (relsec
->sh_type
!= SHT_REL
8203 && relsec
->sh_type
!= SHT_RELA
))
8206 arm_sec
->rel_type
= relsec
->sh_type
;
8207 if (relsec
->sh_type
== SHT_REL
)
8209 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8211 & arm_sec
->rela
, & arm_sec
->nrelas
))
8214 else /* relsec->sh_type == SHT_RELA */
8216 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8218 & arm_sec
->rela
, & arm_sec
->nrelas
))
8224 arm_sec
->next_rela
= arm_sec
->rela
;
8227 /* If there is no unwind data we can do nothing. */
8228 if (arm_sec
->data
== NULL
)
8231 /* If the offset is invalid then fail. */
8232 if (/* PR 21343 *//* PR 18879 */
8234 || word_offset
> (sec
->sh_size
- 4)
8235 || ((bfd_signed_vma
) word_offset
) < 0)
8238 /* Get the word at the required offset. */
8239 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8241 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8242 if (arm_sec
->rela
== NULL
)
8248 /* Look through the relocs to find the one that applies to the provided offset. */
8250 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8252 bfd_vma prelval
, offset
;
8254 if (rp
->r_offset
> word_offset
&& !wrapped
)
8259 if (rp
->r_offset
> word_offset
)
8262 if (rp
->r_offset
& 3)
8264 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8265 (unsigned long) rp
->r_offset
);
8269 if (rp
->r_offset
< word_offset
)
8272 /* PR 17531: file: 027-161405-0.004 */
8273 if (aux
->symtab
== NULL
)
8276 if (arm_sec
->rel_type
== SHT_REL
)
8278 offset
= word
& 0x7fffffff;
8279 if (offset
& 0x40000000)
8280 offset
|= ~ (bfd_vma
) 0x7fffffff;
8282 else if (arm_sec
->rel_type
== SHT_RELA
)
8283 offset
= rp
->r_addend
;
8286 error (_("Unknown section relocation type %d encountered\n"),
8291 /* PR 17531 file: 027-1241568-0.004. */
8292 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8294 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8295 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8299 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8300 offset
+= sym
->st_value
;
8301 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8303 /* Check that we are processing the expected reloc type. */
8304 if (filedata
->file_header
.e_machine
== EM_ARM
)
8306 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8307 if (relname
== NULL
)
8309 warn (_("Skipping unknown ARM relocation type: %d\n"),
8310 (int) ELF32_R_TYPE (rp
->r_info
));
8314 if (streq (relname
, "R_ARM_NONE"))
8317 if (! streq (relname
, "R_ARM_PREL31"))
8319 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8323 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8325 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8326 if (relname
== NULL
)
8328 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8329 (int) ELF32_R_TYPE (rp
->r_info
));
8333 if (streq (relname
, "R_C6000_NONE"))
8336 if (! streq (relname
, "R_C6000_PREL31"))
8338 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8346 /* This function currently only supports ARM and TI unwinders. */
8347 warn (_("Only TI and ARM unwinders are currently supported\n"));
8351 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8352 addr
->section
= sym
->st_shndx
;
8353 addr
->offset
= offset
;
8356 * sym_name
= sym
->st_name
;
8361 arm_sec
->next_rela
= rp
;
8366 static const char *tic6x_unwind_regnames
[16] =
8368 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8369 "A14", "A13", "A12", "A11", "A10",
8370 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8374 decode_tic6x_unwind_regmask (unsigned int mask
)
8378 for (i
= 12; mask
; mask
>>= 1, i
--)
8382 fputs (tic6x_unwind_regnames
[i
], stdout
);
8384 fputs (", ", stdout
);
8390 if (remaining == 0 && more_words) \
8393 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8394 data_offset, & word, & addr, NULL)) \
8400 #define GET_OP(OP) \
8405 (OP) = word >> 24; \
8410 printf (_("[Truncated opcode]\n")); \
8413 printf ("0x%02x ", OP)
8416 decode_arm_unwind_bytecode (Filedata
* filedata
,
8417 struct arm_unw_aux_info
* aux
,
8419 unsigned int remaining
,
8420 unsigned int more_words
,
8421 bfd_vma data_offset
,
8422 Elf_Internal_Shdr
* data_sec
,
8423 struct arm_section
* data_arm_sec
)
8425 struct absaddr addr
;
8426 bfd_boolean res
= TRUE
;
8428 /* Decode the unwinding instructions. */
8431 unsigned int op
, op2
;
8440 printf (" 0x%02x ", op
);
8442 if ((op
& 0xc0) == 0x00)
8444 int offset
= ((op
& 0x3f) << 2) + 4;
8446 printf (" vsp = vsp + %d", offset
);
8448 else if ((op
& 0xc0) == 0x40)
8450 int offset
= ((op
& 0x3f) << 2) + 4;
8452 printf (" vsp = vsp - %d", offset
);
8454 else if ((op
& 0xf0) == 0x80)
8457 if (op
== 0x80 && op2
== 0)
8458 printf (_("Refuse to unwind"));
8461 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8462 bfd_boolean first
= TRUE
;
8466 for (i
= 0; i
< 12; i
++)
8467 if (mask
& (1 << i
))
8473 printf ("r%d", 4 + i
);
8478 else if ((op
& 0xf0) == 0x90)
8480 if (op
== 0x9d || op
== 0x9f)
8481 printf (_(" [Reserved]"));
8483 printf (" vsp = r%d", op
& 0x0f);
8485 else if ((op
& 0xf0) == 0xa0)
8487 int end
= 4 + (op
& 0x07);
8488 bfd_boolean first
= TRUE
;
8492 for (i
= 4; i
<= end
; i
++)
8508 else if (op
== 0xb0)
8509 printf (_(" finish"));
8510 else if (op
== 0xb1)
8513 if (op2
== 0 || (op2
& 0xf0) != 0)
8514 printf (_("[Spare]"));
8517 unsigned int mask
= op2
& 0x0f;
8518 bfd_boolean first
= TRUE
;
8522 for (i
= 0; i
< 12; i
++)
8523 if (mask
& (1 << i
))
8534 else if (op
== 0xb2)
8536 unsigned char buf
[9];
8537 unsigned int i
, len
;
8538 unsigned long offset
;
8540 for (i
= 0; i
< sizeof (buf
); i
++)
8543 if ((buf
[i
] & 0x80) == 0)
8546 if (i
== sizeof (buf
))
8548 error (_("corrupt change to vsp"));
8553 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8554 assert (len
== i
+ 1);
8555 offset
= offset
* 4 + 0x204;
8556 printf ("vsp = vsp + %ld", offset
);
8559 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8561 unsigned int first
, last
;
8568 printf ("pop {D%d", first
);
8570 printf ("-D%d", first
+ last
);
8573 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8575 unsigned int count
= op
& 0x07;
8579 printf ("-D%d", 8 + count
);
8582 else if (op
>= 0xc0 && op
<= 0xc5)
8584 unsigned int count
= op
& 0x07;
8586 printf (" pop {wR10");
8588 printf ("-wR%d", 10 + count
);
8591 else if (op
== 0xc6)
8593 unsigned int first
, last
;
8598 printf ("pop {wR%d", first
);
8600 printf ("-wR%d", first
+ last
);
8603 else if (op
== 0xc7)
8606 if (op2
== 0 || (op2
& 0xf0) != 0)
8607 printf (_("[Spare]"));
8610 unsigned int mask
= op2
& 0x0f;
8611 bfd_boolean first
= TRUE
;
8615 for (i
= 0; i
< 4; i
++)
8616 if (mask
& (1 << i
))
8622 printf ("wCGR%d", i
);
8629 printf (_(" [unsupported opcode]"));
8640 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8641 struct arm_unw_aux_info
* aux
,
8643 unsigned int remaining
,
8644 unsigned int more_words
,
8645 bfd_vma data_offset
,
8646 Elf_Internal_Shdr
* data_sec
,
8647 struct arm_section
* data_arm_sec
)
8649 struct absaddr addr
;
8651 /* Decode the unwinding instructions. */
8654 unsigned int op
, op2
;
8663 printf (" 0x%02x ", op
);
8665 if ((op
& 0xc0) == 0x00)
8667 int offset
= ((op
& 0x3f) << 3) + 8;
8668 printf (" sp = sp + %d", offset
);
8670 else if ((op
& 0xc0) == 0x80)
8673 if (op
== 0x80 && op2
== 0)
8674 printf (_("Refuse to unwind"));
8677 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8679 printf ("pop compact {");
8683 decode_tic6x_unwind_regmask (mask
);
8687 else if ((op
& 0xf0) == 0xc0)
8695 unsigned int offset
;
8699 /* Scan entire instruction first so that GET_OP output is not
8700 interleaved with disassembly. */
8702 for (i
= 0; nregs
< (op
& 0xf); i
++)
8708 regpos
[nregs
].offset
= i
* 2;
8709 regpos
[nregs
].reg
= reg
;
8716 regpos
[nregs
].offset
= i
* 2 + 1;
8717 regpos
[nregs
].reg
= reg
;
8722 printf (_("pop frame {"));
8724 for (i
= i
* 2; i
> 0; i
--)
8726 if (regpos
[reg
].offset
== i
- 1)
8728 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8735 fputs (name
, stdout
);
8742 else if (op
== 0xd0)
8743 printf (" MOV FP, SP");
8744 else if (op
== 0xd1)
8745 printf (" __c6xabi_pop_rts");
8746 else if (op
== 0xd2)
8748 unsigned char buf
[9];
8749 unsigned int i
, len
;
8750 unsigned long offset
;
8752 for (i
= 0; i
< sizeof (buf
); i
++)
8755 if ((buf
[i
] & 0x80) == 0)
8758 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8759 if (i
== sizeof (buf
))
8761 warn (_("Corrupt stack pointer adjustment detected\n"));
8765 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8766 assert (len
== i
+ 1);
8767 offset
= offset
* 8 + 0x408;
8768 printf (_("sp = sp + %ld"), offset
);
8770 else if ((op
& 0xf0) == 0xe0)
8772 if ((op
& 0x0f) == 7)
8775 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8779 printf (_(" [unsupported opcode]"));
8788 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8792 offset
= word
& 0x7fffffff;
8793 if (offset
& 0x40000000)
8794 offset
|= ~ (bfd_vma
) 0x7fffffff;
8796 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8799 return offset
+ where
;
8803 decode_arm_unwind (Filedata
* filedata
,
8804 struct arm_unw_aux_info
* aux
,
8806 unsigned int remaining
,
8807 bfd_vma data_offset
,
8808 Elf_Internal_Shdr
* data_sec
,
8809 struct arm_section
* data_arm_sec
)
8812 unsigned int more_words
= 0;
8813 struct absaddr addr
;
8814 bfd_vma sym_name
= (bfd_vma
) -1;
8815 bfd_boolean res
= TRUE
;
8819 /* Fetch the first word.
8820 Note - when decoding an object file the address extracted
8821 here will always be 0. So we also pass in the sym_name
8822 parameter so that we can find the symbol associated with
8823 the personality routine. */
8824 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8825 & word
, & addr
, & sym_name
))
8831 if ((word
& 0x80000000) == 0)
8833 /* Expand prel31 for personality routine. */
8835 const char *procname
;
8837 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8838 printf (_(" Personality routine: "));
8840 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8841 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8843 procname
= aux
->strtab
+ sym_name
;
8844 print_vma (fn
, PREFIX_HEX
);
8847 fputs (" <", stdout
);
8848 fputs (procname
, stdout
);
8849 fputc ('>', stdout
);
8853 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8854 fputc ('\n', stdout
);
8856 /* The GCC personality routines use the standard compact
8857 encoding, starting with one byte giving the number of
8859 if (procname
!= NULL
8860 && (const_strneq (procname
, "__gcc_personality_v0")
8861 || const_strneq (procname
, "__gxx_personality_v0")
8862 || const_strneq (procname
, "__gcj_personality_v0")
8863 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8870 printf (_(" [Truncated data]\n"));
8873 more_words
= word
>> 24;
8883 /* ARM EHABI Section 6.3:
8885 An exception-handling table entry for the compact model looks like:
8889 1 0 index Data for personalityRoutine[index] */
8891 if (filedata
->file_header
.e_machine
== EM_ARM
8892 && (word
& 0x70000000))
8894 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8898 per_index
= (word
>> 24) & 0x7f;
8899 printf (_(" Compact model index: %d\n"), per_index
);
8906 else if (per_index
< 3)
8908 more_words
= (word
>> 16) & 0xff;
8914 switch (filedata
->file_header
.e_machine
)
8919 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8920 data_offset
, data_sec
, data_arm_sec
))
8925 warn (_("Unknown ARM compact model index encountered\n"));
8926 printf (_(" [reserved]\n"));
8934 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8935 data_offset
, data_sec
, data_arm_sec
))
8938 else if (per_index
< 5)
8940 if (((word
>> 17) & 0x7f) == 0x7f)
8941 printf (_(" Restore stack from frame pointer\n"));
8943 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8944 printf (_(" Registers restored: "));
8946 printf (" (compact) ");
8947 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8949 printf (_(" Return register: %s\n"),
8950 tic6x_unwind_regnames
[word
& 0xf]);
8953 printf (_(" [reserved (%d)]\n"), per_index
);
8957 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8958 filedata
->file_header
.e_machine
);
8962 /* Decode the descriptors. Not implemented. */
8968 dump_arm_unwind (Filedata
* filedata
,
8969 struct arm_unw_aux_info
* aux
,
8970 Elf_Internal_Shdr
* exidx_sec
)
8972 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8973 unsigned int i
, exidx_len
;
8974 unsigned long j
, nfuns
;
8975 bfd_boolean res
= TRUE
;
8977 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8978 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8979 exidx_len
= exidx_sec
->sh_size
/ 8;
8981 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8982 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8983 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8984 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8986 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8988 for (i
= 0; i
< exidx_len
; i
++)
8990 unsigned int exidx_fn
, exidx_entry
;
8991 struct absaddr fn_addr
, entry_addr
;
8994 fputc ('\n', stdout
);
8996 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
8997 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8998 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
8999 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9002 arm_free_section (& exidx_arm_sec
);
9003 arm_free_section (& extab_arm_sec
);
9007 /* ARM EHABI, Section 5:
9008 An index table entry consists of 2 words.
9009 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9010 if (exidx_fn
& 0x80000000)
9012 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9016 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9018 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9019 fputs (": ", stdout
);
9021 if (exidx_entry
== 1)
9023 print_vma (exidx_entry
, PREFIX_HEX
);
9024 fputs (" [cantunwind]\n", stdout
);
9026 else if (exidx_entry
& 0x80000000)
9028 print_vma (exidx_entry
, PREFIX_HEX
);
9029 fputc ('\n', stdout
);
9030 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9034 bfd_vma table
, table_offset
= 0;
9035 Elf_Internal_Shdr
*table_sec
;
9037 fputs ("@", stdout
);
9038 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9039 print_vma (table
, PREFIX_HEX
);
9042 /* Locate the matching .ARM.extab. */
9043 if (entry_addr
.section
!= SHN_UNDEF
9044 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9046 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9047 table_offset
= entry_addr
.offset
;
9049 if (table_offset
> table_sec
->sh_size
9050 || ((bfd_signed_vma
) table_offset
) < 0)
9052 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9053 (unsigned long) table_offset
,
9054 printable_section_name (filedata
, table_sec
));
9061 table_sec
= find_section_by_address (filedata
, table
);
9062 if (table_sec
!= NULL
)
9063 table_offset
= table
- table_sec
->sh_addr
;
9066 if (table_sec
== NULL
)
9068 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9069 (unsigned long) table
);
9074 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9083 arm_free_section (&exidx_arm_sec
);
9084 arm_free_section (&extab_arm_sec
);
9089 /* Used for both ARM and C6X unwinding tables. */
9092 arm_process_unwind (Filedata
* filedata
)
9094 struct arm_unw_aux_info aux
;
9095 Elf_Internal_Shdr
*unwsec
= NULL
;
9096 Elf_Internal_Shdr
*strsec
;
9097 Elf_Internal_Shdr
*sec
;
9099 unsigned int sec_type
;
9100 bfd_boolean res
= TRUE
;
9102 switch (filedata
->file_header
.e_machine
)
9105 sec_type
= SHT_ARM_EXIDX
;
9109 sec_type
= SHT_C6000_UNWIND
;
9113 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9114 filedata
->file_header
.e_machine
);
9118 if (filedata
->string_table
== NULL
)
9121 memset (& aux
, 0, sizeof (aux
));
9122 aux
.filedata
= filedata
;
9124 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9126 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9128 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9130 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9132 /* PR binutils/17531 file: 011-12666-0.004. */
9133 if (aux
.strtab
!= NULL
)
9135 error (_("Multiple string tables found in file.\n"));
9139 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9140 1, strsec
->sh_size
, _("string table"));
9141 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9143 else if (sec
->sh_type
== sec_type
)
9148 printf (_("\nThere are no unwind sections in this file.\n"));
9150 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9152 if (sec
->sh_type
== sec_type
)
9154 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9155 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9156 "contains %lu entry:\n",
9157 "\nUnwind section '%s' at offset 0x%lx "
9158 "contains %lu entries:\n",
9160 printable_section_name (filedata
, sec
),
9161 (unsigned long) sec
->sh_offset
,
9164 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9172 free ((char *) aux
.strtab
);
9178 process_unwind (Filedata
* filedata
)
9180 struct unwind_handler
9182 unsigned int machtype
;
9183 bfd_boolean (* handler
)(Filedata
*);
9186 { EM_ARM
, arm_process_unwind
},
9187 { EM_IA_64
, ia64_process_unwind
},
9188 { EM_PARISC
, hppa_process_unwind
},
9189 { EM_TI_C6000
, arm_process_unwind
},
9197 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9198 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9199 return handlers
[i
].handler (filedata
);
9201 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9202 get_machine_name (filedata
->file_header
.e_machine
));
9207 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9209 switch (entry
->d_tag
)
9212 if (entry
->d_un
.d_val
== 0)
9216 static const char * opts
[] =
9218 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9219 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9220 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9221 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9225 bfd_boolean first
= TRUE
;
9227 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9228 if (entry
->d_un
.d_val
& (1 << cnt
))
9230 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9236 case DT_MIPS_IVERSION
:
9237 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9238 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9242 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9243 /* Note: coded this way so that there is a single string for translation. */
9244 printf (_("<corrupt: %s>"), buf
);
9248 case DT_MIPS_TIME_STAMP
:
9252 time_t atime
= entry
->d_un
.d_val
;
9254 tmp
= gmtime (&atime
);
9255 /* PR 17531: file: 6accc532. */
9257 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9259 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9260 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9261 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9262 printf (_("Time Stamp: %s"), timebuf
);
9266 case DT_MIPS_RLD_VERSION
:
9267 case DT_MIPS_LOCAL_GOTNO
:
9268 case DT_MIPS_CONFLICTNO
:
9269 case DT_MIPS_LIBLISTNO
:
9270 case DT_MIPS_SYMTABNO
:
9271 case DT_MIPS_UNREFEXTNO
:
9272 case DT_MIPS_HIPAGENO
:
9273 case DT_MIPS_DELTA_CLASS_NO
:
9274 case DT_MIPS_DELTA_INSTANCE_NO
:
9275 case DT_MIPS_DELTA_RELOC_NO
:
9276 case DT_MIPS_DELTA_SYM_NO
:
9277 case DT_MIPS_DELTA_CLASSSYM_NO
:
9278 case DT_MIPS_COMPACT_SIZE
:
9279 print_vma (entry
->d_un
.d_val
, DEC
);
9283 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9289 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9291 switch (entry
->d_tag
)
9293 case DT_HP_DLD_FLAGS
:
9302 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9303 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9304 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9305 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9306 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9307 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9308 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9309 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9310 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9311 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9312 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9313 { DT_HP_GST
, "HP_GST" },
9314 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9315 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9316 { DT_HP_NODELETE
, "HP_NODELETE" },
9317 { DT_HP_GROUP
, "HP_GROUP" },
9318 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9320 bfd_boolean first
= TRUE
;
9322 bfd_vma val
= entry
->d_un
.d_val
;
9324 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9325 if (val
& flags
[cnt
].bit
)
9329 fputs (flags
[cnt
].str
, stdout
);
9331 val
^= flags
[cnt
].bit
;
9334 if (val
!= 0 || first
)
9338 print_vma (val
, HEX
);
9344 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9352 /* VMS vs Unix time offset and factor. */
9354 #define VMS_EPOCH_OFFSET 35067168000000000LL
9355 #define VMS_GRANULARITY_FACTOR 10000000
9357 /* Display a VMS time in a human readable format. */
9360 print_vms_time (bfd_int64_t vmstime
)
9365 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9366 tm
= gmtime (&unxtime
);
9367 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9368 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9369 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9374 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9376 switch (entry
->d_tag
)
9378 case DT_IA_64_PLT_RESERVE
:
9379 /* First 3 slots reserved. */
9380 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9382 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9385 case DT_IA_64_VMS_LINKTIME
:
9387 print_vms_time (entry
->d_un
.d_val
);
9391 case DT_IA_64_VMS_LNKFLAGS
:
9392 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9393 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9394 printf (" CALL_DEBUG");
9395 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9396 printf (" NOP0BUFS");
9397 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9398 printf (" P0IMAGE");
9399 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9400 printf (" MKTHREADS");
9401 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9402 printf (" UPCALLS");
9403 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9405 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9406 printf (" INITIALIZE");
9407 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9409 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9410 printf (" EXE_INIT");
9411 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9412 printf (" TBK_IN_IMG");
9413 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9414 printf (" DBG_IN_IMG");
9415 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9416 printf (" TBK_IN_DSF");
9417 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9418 printf (" DBG_IN_DSF");
9419 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9420 printf (" SIGNATURES");
9421 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9422 printf (" REL_SEG_OFF");
9426 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9433 get_32bit_dynamic_section (Filedata
* filedata
)
9435 Elf32_External_Dyn
* edyn
;
9436 Elf32_External_Dyn
* ext
;
9437 Elf_Internal_Dyn
* entry
;
9439 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9440 dynamic_size
, _("dynamic section"));
9444 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9445 might not have the luxury of section headers. Look for the DT_NULL
9446 terminator to determine the number of entries. */
9447 for (ext
= edyn
, dynamic_nent
= 0;
9448 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9452 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9456 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9458 if (dynamic_section
== NULL
)
9460 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9461 (unsigned long) dynamic_nent
);
9466 for (ext
= edyn
, entry
= dynamic_section
;
9467 entry
< dynamic_section
+ dynamic_nent
;
9470 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9471 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9480 get_64bit_dynamic_section (Filedata
* filedata
)
9482 Elf64_External_Dyn
* edyn
;
9483 Elf64_External_Dyn
* ext
;
9484 Elf_Internal_Dyn
* entry
;
9486 /* Read in the data. */
9487 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9488 dynamic_size
, _("dynamic section"));
9492 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9493 might not have the luxury of section headers. Look for the DT_NULL
9494 terminator to determine the number of entries. */
9495 for (ext
= edyn
, dynamic_nent
= 0;
9496 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9497 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9501 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9505 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9507 if (dynamic_section
== NULL
)
9509 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9510 (unsigned long) dynamic_nent
);
9515 /* Convert from external to internal formats. */
9516 for (ext
= edyn
, entry
= dynamic_section
;
9517 entry
< dynamic_section
+ dynamic_nent
;
9520 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9521 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9530 print_dynamic_flags (bfd_vma flags
)
9532 bfd_boolean first
= TRUE
;
9538 flag
= flags
& - flags
;
9548 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9549 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9550 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9551 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9552 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9553 default: fputs (_("unknown"), stdout
); break;
9559 /* Parse and display the contents of the dynamic section. */
9562 process_dynamic_section (Filedata
* filedata
)
9564 Elf_Internal_Dyn
* entry
;
9566 if (dynamic_size
== 0)
9569 printf (_("\nThere is no dynamic section in this file.\n"));
9576 if (! get_32bit_dynamic_section (filedata
))
9581 if (! get_64bit_dynamic_section (filedata
))
9585 /* Find the appropriate symbol table. */
9586 if (dynamic_symbols
== NULL
)
9588 for (entry
= dynamic_section
;
9589 entry
< dynamic_section
+ dynamic_nent
;
9592 Elf_Internal_Shdr section
;
9594 if (entry
->d_tag
!= DT_SYMTAB
)
9597 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9599 /* Since we do not know how big the symbol table is,
9600 we default to reading in the entire file (!) and
9601 processing that. This is overkill, I know, but it
9603 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9604 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9606 /* See PR 21379 for a reproducer. */
9607 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9611 if (archive_file_offset
!= 0)
9612 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9614 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9617 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9619 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9620 section
.sh_name
= filedata
->string_table_length
;
9622 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9623 if (num_dynamic_syms
< 1)
9625 error (_("Unable to determine the number of symbols to load\n"));
9631 /* Similarly find a string table. */
9632 if (dynamic_strings
== NULL
)
9634 for (entry
= dynamic_section
;
9635 entry
< dynamic_section
+ dynamic_nent
;
9638 unsigned long offset
;
9641 if (entry
->d_tag
!= DT_STRTAB
)
9644 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9646 /* Since we do not know how big the string table is,
9647 we default to reading in the entire file (!) and
9648 processing that. This is overkill, I know, but it
9651 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9653 if (archive_file_offset
!= 0)
9654 str_tab_len
= archive_file_size
- offset
;
9656 str_tab_len
= filedata
->file_size
;
9658 if (str_tab_len
< 1)
9661 (_("Unable to determine the length of the dynamic string table\n"));
9665 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9667 _("dynamic string table"));
9668 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9673 /* And find the syminfo section if available. */
9674 if (dynamic_syminfo
== NULL
)
9676 unsigned long syminsz
= 0;
9678 for (entry
= dynamic_section
;
9679 entry
< dynamic_section
+ dynamic_nent
;
9682 if (entry
->d_tag
== DT_SYMINENT
)
9684 /* Note: these braces are necessary to avoid a syntax
9685 error from the SunOS4 C compiler. */
9686 /* PR binutils/17531: A corrupt file can trigger this test.
9687 So do not use an assert, instead generate an error message. */
9688 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9689 error (_("Bad value (%d) for SYMINENT entry\n"),
9690 (int) entry
->d_un
.d_val
);
9692 else if (entry
->d_tag
== DT_SYMINSZ
)
9693 syminsz
= entry
->d_un
.d_val
;
9694 else if (entry
->d_tag
== DT_SYMINFO
)
9695 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9699 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9701 Elf_External_Syminfo
* extsyminfo
;
9702 Elf_External_Syminfo
* extsym
;
9703 Elf_Internal_Syminfo
* syminfo
;
9705 /* There is a syminfo section. Read the data. */
9706 extsyminfo
= (Elf_External_Syminfo
*)
9707 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9708 _("symbol information"));
9712 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9713 if (dynamic_syminfo
== NULL
)
9715 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9716 (unsigned long) syminsz
);
9720 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9721 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9722 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9723 ++syminfo
, ++extsym
)
9725 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9726 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9733 if (do_dynamic
&& dynamic_addr
)
9734 printf (ngettext ("\nDynamic section at offset 0x%lx "
9735 "contains %lu entry:\n",
9736 "\nDynamic section at offset 0x%lx "
9737 "contains %lu entries:\n",
9739 dynamic_addr
, (unsigned long) dynamic_nent
);
9741 printf (_(" Tag Type Name/Value\n"));
9743 for (entry
= dynamic_section
;
9744 entry
< dynamic_section
+ dynamic_nent
;
9752 print_vma (entry
->d_tag
, FULL_HEX
);
9753 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9754 printf (" (%s)%*s", dtype
,
9755 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9758 switch (entry
->d_tag
)
9762 print_dynamic_flags (entry
->d_un
.d_val
);
9772 switch (entry
->d_tag
)
9775 printf (_("Auxiliary library"));
9779 printf (_("Filter library"));
9783 printf (_("Configuration file"));
9787 printf (_("Dependency audit library"));
9791 printf (_("Audit library"));
9795 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9796 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9800 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9809 printf (_("Flags:"));
9811 if (entry
->d_un
.d_val
== 0)
9812 printf (_(" None\n"));
9815 unsigned long int val
= entry
->d_un
.d_val
;
9817 if (val
& DTF_1_PARINIT
)
9819 printf (" PARINIT");
9820 val
^= DTF_1_PARINIT
;
9822 if (val
& DTF_1_CONFEXP
)
9824 printf (" CONFEXP");
9825 val
^= DTF_1_CONFEXP
;
9828 printf (" %lx", val
);
9837 printf (_("Flags:"));
9839 if (entry
->d_un
.d_val
== 0)
9840 printf (_(" None\n"));
9843 unsigned long int val
= entry
->d_un
.d_val
;
9845 if (val
& DF_P1_LAZYLOAD
)
9847 printf (" LAZYLOAD");
9848 val
^= DF_P1_LAZYLOAD
;
9850 if (val
& DF_P1_GROUPPERM
)
9852 printf (" GROUPPERM");
9853 val
^= DF_P1_GROUPPERM
;
9856 printf (" %lx", val
);
9865 printf (_("Flags:"));
9866 if (entry
->d_un
.d_val
== 0)
9867 printf (_(" None\n"));
9870 unsigned long int val
= entry
->d_un
.d_val
;
9877 if (val
& DF_1_GLOBAL
)
9882 if (val
& DF_1_GROUP
)
9887 if (val
& DF_1_NODELETE
)
9889 printf (" NODELETE");
9890 val
^= DF_1_NODELETE
;
9892 if (val
& DF_1_LOADFLTR
)
9894 printf (" LOADFLTR");
9895 val
^= DF_1_LOADFLTR
;
9897 if (val
& DF_1_INITFIRST
)
9899 printf (" INITFIRST");
9900 val
^= DF_1_INITFIRST
;
9902 if (val
& DF_1_NOOPEN
)
9907 if (val
& DF_1_ORIGIN
)
9912 if (val
& DF_1_DIRECT
)
9917 if (val
& DF_1_TRANS
)
9922 if (val
& DF_1_INTERPOSE
)
9924 printf (" INTERPOSE");
9925 val
^= DF_1_INTERPOSE
;
9927 if (val
& DF_1_NODEFLIB
)
9929 printf (" NODEFLIB");
9930 val
^= DF_1_NODEFLIB
;
9932 if (val
& DF_1_NODUMP
)
9937 if (val
& DF_1_CONFALT
)
9939 printf (" CONFALT");
9940 val
^= DF_1_CONFALT
;
9942 if (val
& DF_1_ENDFILTEE
)
9944 printf (" ENDFILTEE");
9945 val
^= DF_1_ENDFILTEE
;
9947 if (val
& DF_1_DISPRELDNE
)
9949 printf (" DISPRELDNE");
9950 val
^= DF_1_DISPRELDNE
;
9952 if (val
& DF_1_DISPRELPND
)
9954 printf (" DISPRELPND");
9955 val
^= DF_1_DISPRELPND
;
9957 if (val
& DF_1_NODIRECT
)
9959 printf (" NODIRECT");
9960 val
^= DF_1_NODIRECT
;
9962 if (val
& DF_1_IGNMULDEF
)
9964 printf (" IGNMULDEF");
9965 val
^= DF_1_IGNMULDEF
;
9967 if (val
& DF_1_NOKSYMS
)
9969 printf (" NOKSYMS");
9970 val
^= DF_1_NOKSYMS
;
9972 if (val
& DF_1_NOHDR
)
9977 if (val
& DF_1_EDITED
)
9982 if (val
& DF_1_NORELOC
)
9984 printf (" NORELOC");
9985 val
^= DF_1_NORELOC
;
9987 if (val
& DF_1_SYMINTPOSE
)
9989 printf (" SYMINTPOSE");
9990 val
^= DF_1_SYMINTPOSE
;
9992 if (val
& DF_1_GLOBAUDIT
)
9994 printf (" GLOBAUDIT");
9995 val
^= DF_1_GLOBAUDIT
;
9997 if (val
& DF_1_SINGLETON
)
9999 printf (" SINGLETON");
10000 val
^= DF_1_SINGLETON
;
10002 if (val
& DF_1_STUB
)
10007 if (val
& DF_1_PIE
)
10013 printf (" %lx", val
);
10020 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10022 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10042 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10048 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10049 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10055 switch (entry
->d_tag
)
10058 printf (_("Shared library: [%s]"), name
);
10060 if (streq (name
, program_interpreter
))
10061 printf (_(" program interpreter"));
10065 printf (_("Library soname: [%s]"), name
);
10069 printf (_("Library rpath: [%s]"), name
);
10073 printf (_("Library runpath: [%s]"), name
);
10077 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10082 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10095 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10096 /* Fall through. */
10100 case DT_INIT_ARRAYSZ
:
10101 case DT_FINI_ARRAYSZ
:
10102 case DT_GNU_CONFLICTSZ
:
10103 case DT_GNU_LIBLISTSZ
:
10106 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10107 printf (_(" (bytes)\n"));
10112 case DT_VERNEEDNUM
:
10117 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10126 case DT_INIT_ARRAY
:
10127 case DT_FINI_ARRAY
:
10130 if (entry
->d_tag
== DT_USED
10131 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10133 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10137 printf (_("Not needed object: [%s]\n"), name
);
10142 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10148 /* The value of this entry is ignored. */
10153 case DT_GNU_PRELINKED
:
10157 time_t atime
= entry
->d_un
.d_val
;
10159 tmp
= gmtime (&atime
);
10160 /* PR 17533 file: 041-1244816-0.004. */
10162 printf (_("<corrupt time val: %lx"),
10163 (unsigned long) atime
);
10165 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10166 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10167 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10173 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10176 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10182 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10183 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10188 switch (filedata
->file_header
.e_machine
)
10191 case EM_MIPS_RS3_LE
:
10192 dynamic_section_mips_val (entry
);
10195 dynamic_section_parisc_val (entry
);
10198 dynamic_section_ia64_val (entry
);
10201 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10213 get_ver_flags (unsigned int flags
)
10215 static char buff
[128];
10222 if (flags
& VER_FLG_BASE
)
10223 strcat (buff
, "BASE");
10225 if (flags
& VER_FLG_WEAK
)
10227 if (flags
& VER_FLG_BASE
)
10228 strcat (buff
, " | ");
10230 strcat (buff
, "WEAK");
10233 if (flags
& VER_FLG_INFO
)
10235 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10236 strcat (buff
, " | ");
10238 strcat (buff
, "INFO");
10241 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10243 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10244 strcat (buff
, " | ");
10246 strcat (buff
, _("<unknown>"));
10252 /* Display the contents of the version sections. */
10255 process_version_sections (Filedata
* filedata
)
10257 Elf_Internal_Shdr
* section
;
10259 bfd_boolean found
= FALSE
;
10264 for (i
= 0, section
= filedata
->section_headers
;
10265 i
< filedata
->file_header
.e_shnum
;
10268 switch (section
->sh_type
)
10270 case SHT_GNU_verdef
:
10272 Elf_External_Verdef
* edefs
;
10279 printf (ngettext ("\nVersion definition section '%s' "
10280 "contains %u entry:\n",
10281 "\nVersion definition section '%s' "
10282 "contains %u entries:\n",
10284 printable_section_name (filedata
, section
),
10287 printf (_(" Addr: 0x"));
10288 printf_vma (section
->sh_addr
);
10289 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10290 (unsigned long) section
->sh_offset
, section
->sh_link
,
10291 printable_section_name_from_index (filedata
, section
->sh_link
));
10293 edefs
= (Elf_External_Verdef
*)
10294 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10295 _("version definition section"));
10298 endbuf
= (char *) edefs
+ section
->sh_size
;
10300 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10303 Elf_External_Verdef
* edef
;
10304 Elf_Internal_Verdef ent
;
10305 Elf_External_Verdaux
* eaux
;
10306 Elf_Internal_Verdaux aux
;
10307 unsigned long isum
;
10310 vstart
= ((char *) edefs
) + idx
;
10311 if (vstart
+ sizeof (*edef
) > endbuf
)
10314 edef
= (Elf_External_Verdef
*) vstart
;
10316 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10317 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10318 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10319 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10320 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10321 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10322 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10324 printf (_(" %#06lx: Rev: %d Flags: %s"),
10325 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10327 printf (_(" Index: %d Cnt: %d "),
10328 ent
.vd_ndx
, ent
.vd_cnt
);
10330 /* Check for overflow. */
10331 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10334 vstart
+= ent
.vd_aux
;
10336 if (vstart
+ sizeof (*eaux
) > endbuf
)
10338 eaux
= (Elf_External_Verdaux
*) vstart
;
10340 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10341 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10343 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10344 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10346 printf (_("Name index: %ld\n"), aux
.vda_name
);
10348 isum
= idx
+ ent
.vd_aux
;
10350 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10352 if (aux
.vda_next
< sizeof (*eaux
)
10353 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10355 warn (_("Invalid vda_next field of %lx\n"),
10360 /* Check for overflow. */
10361 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10364 isum
+= aux
.vda_next
;
10365 vstart
+= aux
.vda_next
;
10367 if (vstart
+ sizeof (*eaux
) > endbuf
)
10369 eaux
= (Elf_External_Verdaux
*) vstart
;
10371 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10372 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10374 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10375 printf (_(" %#06lx: Parent %d: %s\n"),
10376 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10378 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10379 isum
, j
, aux
.vda_name
);
10382 if (j
< ent
.vd_cnt
)
10383 printf (_(" Version def aux past end of section\n"));
10386 file: id:000001,src:000172+005151,op:splice,rep:2. */
10387 if (ent
.vd_next
< sizeof (*edef
)
10388 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10390 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10391 cnt
= section
->sh_info
;
10394 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10397 idx
+= ent
.vd_next
;
10400 if (cnt
< section
->sh_info
)
10401 printf (_(" Version definition past end of section\n"));
10407 case SHT_GNU_verneed
:
10409 Elf_External_Verneed
* eneed
;
10416 printf (ngettext ("\nVersion needs section '%s' "
10417 "contains %u entry:\n",
10418 "\nVersion needs section '%s' "
10419 "contains %u entries:\n",
10421 printable_section_name (filedata
, section
), section
->sh_info
);
10423 printf (_(" Addr: 0x"));
10424 printf_vma (section
->sh_addr
);
10425 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10426 (unsigned long) section
->sh_offset
, section
->sh_link
,
10427 printable_section_name_from_index (filedata
, section
->sh_link
));
10429 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10430 section
->sh_offset
, 1,
10432 _("Version Needs section"));
10435 endbuf
= (char *) eneed
+ section
->sh_size
;
10437 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10439 Elf_External_Verneed
* entry
;
10440 Elf_Internal_Verneed ent
;
10441 unsigned long isum
;
10445 vstart
= ((char *) eneed
) + idx
;
10446 if (vstart
+ sizeof (*entry
) > endbuf
)
10449 entry
= (Elf_External_Verneed
*) vstart
;
10451 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10452 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10453 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10454 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10455 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10457 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10459 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10460 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10462 printf (_(" File: %lx"), ent
.vn_file
);
10464 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10466 /* Check for overflow. */
10467 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10469 vstart
+= ent
.vn_aux
;
10471 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10473 Elf_External_Vernaux
* eaux
;
10474 Elf_Internal_Vernaux aux
;
10476 if (vstart
+ sizeof (*eaux
) > endbuf
)
10478 eaux
= (Elf_External_Vernaux
*) vstart
;
10480 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10481 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10482 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10483 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10484 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10486 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10487 printf (_(" %#06lx: Name: %s"),
10488 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10490 printf (_(" %#06lx: Name index: %lx"),
10491 isum
, aux
.vna_name
);
10493 printf (_(" Flags: %s Version: %d\n"),
10494 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10496 if (aux
.vna_next
< sizeof (*eaux
)
10497 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10499 warn (_("Invalid vna_next field of %lx\n"),
10504 /* Check for overflow. */
10505 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10507 isum
+= aux
.vna_next
;
10508 vstart
+= aux
.vna_next
;
10511 if (j
< ent
.vn_cnt
)
10512 warn (_("Missing Version Needs auxillary information\n"));
10514 if (ent
.vn_next
< sizeof (*entry
)
10515 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10517 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10518 cnt
= section
->sh_info
;
10521 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10523 idx
+= ent
.vn_next
;
10526 if (cnt
< section
->sh_info
)
10527 warn (_("Missing Version Needs information\n"));
10533 case SHT_GNU_versym
:
10535 Elf_Internal_Shdr
* link_section
;
10538 unsigned char * edata
;
10539 unsigned short * data
;
10541 Elf_Internal_Sym
* symbols
;
10542 Elf_Internal_Shdr
* string_sec
;
10543 unsigned long num_syms
;
10546 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10549 link_section
= filedata
->section_headers
+ section
->sh_link
;
10550 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10552 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10557 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10558 if (symbols
== NULL
)
10561 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10563 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10564 string_sec
->sh_size
,
10565 _("version string table"));
10572 printf (ngettext ("\nVersion symbols section '%s' "
10573 "contains %lu entry:\n",
10574 "\nVersion symbols section '%s' "
10575 "contains %lu entries:\n",
10577 printable_section_name (filedata
, section
), (unsigned long) total
);
10579 printf (_(" Addr: "));
10580 printf_vma (section
->sh_addr
);
10581 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10582 (unsigned long) section
->sh_offset
, section
->sh_link
,
10583 printable_section_name (filedata
, link_section
));
10585 off
= offset_from_vma (filedata
,
10586 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10587 total
* sizeof (short));
10588 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10590 _("version symbol data"));
10598 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10600 for (cnt
= total
; cnt
--;)
10601 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10606 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10610 char *invalid
= _("*invalid*");
10612 printf (" %03x:", cnt
);
10614 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10615 switch (data
[cnt
+ j
])
10618 fputs (_(" 0 (*local*) "), stdout
);
10622 fputs (_(" 1 (*global*) "), stdout
);
10626 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10627 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10629 /* If this index value is greater than the size of the symbols
10630 array, break to avoid an out-of-bounds read. */
10631 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10633 warn (_("invalid index into symbol array\n"));
10638 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10640 Elf_Internal_Verneed ivn
;
10641 unsigned long offset
;
10643 offset
= offset_from_vma
10644 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10645 sizeof (Elf_External_Verneed
));
10649 Elf_Internal_Vernaux ivna
;
10650 Elf_External_Verneed evn
;
10651 Elf_External_Vernaux evna
;
10652 unsigned long a_off
;
10654 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10655 _("version need")) == NULL
)
10658 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10659 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10661 a_off
= offset
+ ivn
.vn_aux
;
10665 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10666 1, _("version need aux (2)")) == NULL
)
10669 ivna
.vna_other
= 0;
10673 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10674 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10677 a_off
+= ivna
.vna_next
;
10679 while (ivna
.vna_other
!= data
[cnt
+ j
]
10680 && ivna
.vna_next
!= 0);
10682 if (ivna
.vna_other
== data
[cnt
+ j
])
10684 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10686 if (ivna
.vna_name
>= string_sec
->sh_size
)
10689 name
= strtab
+ ivna
.vna_name
;
10693 offset
+= ivn
.vn_next
;
10695 while (ivn
.vn_next
);
10698 if (data
[cnt
+ j
] != 0x8001
10699 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10701 Elf_Internal_Verdef ivd
;
10702 Elf_External_Verdef evd
;
10703 unsigned long offset
;
10705 offset
= offset_from_vma
10706 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10711 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10712 _("version def")) == NULL
)
10715 /* PR 17531: file: 046-1082287-0.004. */
10716 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10721 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10722 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10725 offset
+= ivd
.vd_next
;
10727 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10728 && ivd
.vd_next
!= 0);
10730 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10732 Elf_External_Verdaux evda
;
10733 Elf_Internal_Verdaux ivda
;
10735 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10737 if (get_data (&evda
, filedata
,
10738 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10740 _("version def aux")) == NULL
)
10743 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10745 if (ivda
.vda_name
>= string_sec
->sh_size
)
10747 else if (name
!= NULL
&& name
!= invalid
)
10748 name
= _("*both*");
10750 name
= strtab
+ ivda
.vda_name
;
10754 nn
+= printf ("(%s%-*s",
10756 12 - (int) strlen (name
),
10760 printf ("%*c", 18 - nn
, ' ');
10778 printf (_("\nNo version information found in this file.\n"));
10783 static const char *
10784 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10786 static char buff
[32];
10790 case STB_LOCAL
: return "LOCAL";
10791 case STB_GLOBAL
: return "GLOBAL";
10792 case STB_WEAK
: return "WEAK";
10794 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10795 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10797 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10799 if (binding
== STB_GNU_UNIQUE
10800 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10801 /* GNU is still using the default value 0. */
10802 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10804 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10807 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10812 static const char *
10813 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10815 static char buff
[32];
10819 case STT_NOTYPE
: return "NOTYPE";
10820 case STT_OBJECT
: return "OBJECT";
10821 case STT_FUNC
: return "FUNC";
10822 case STT_SECTION
: return "SECTION";
10823 case STT_FILE
: return "FILE";
10824 case STT_COMMON
: return "COMMON";
10825 case STT_TLS
: return "TLS";
10826 case STT_RELC
: return "RELC";
10827 case STT_SRELC
: return "SRELC";
10829 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10831 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10832 return "THUMB_FUNC";
10834 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10837 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10838 return "PARISC_MILLI";
10840 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10842 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10844 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10846 if (type
== STT_HP_OPAQUE
)
10847 return "HP_OPAQUE";
10848 if (type
== STT_HP_STUB
)
10852 if (type
== STT_GNU_IFUNC
10853 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10854 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10855 /* GNU is still using the default value 0. */
10856 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10859 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10862 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10867 static const char *
10868 get_symbol_visibility (unsigned int visibility
)
10870 switch (visibility
)
10872 case STV_DEFAULT
: return "DEFAULT";
10873 case STV_INTERNAL
: return "INTERNAL";
10874 case STV_HIDDEN
: return "HIDDEN";
10875 case STV_PROTECTED
: return "PROTECTED";
10877 error (_("Unrecognized visibility value: %u"), visibility
);
10878 return _("<unknown>");
10882 static const char *
10883 get_solaris_symbol_visibility (unsigned int visibility
)
10885 switch (visibility
)
10887 case 4: return "EXPORTED";
10888 case 5: return "SINGLETON";
10889 case 6: return "ELIMINATE";
10890 default: return get_symbol_visibility (visibility
);
10894 static const char *
10895 get_mips_symbol_other (unsigned int other
)
10899 case STO_OPTIONAL
: return "OPTIONAL";
10900 case STO_MIPS_PLT
: return "MIPS PLT";
10901 case STO_MIPS_PIC
: return "MIPS PIC";
10902 case STO_MICROMIPS
: return "MICROMIPS";
10903 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10904 case STO_MIPS16
: return "MIPS16";
10905 default: return NULL
;
10909 static const char *
10910 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
10912 if (is_ia64_vms (filedata
))
10914 static char res
[32];
10918 /* Function types is for images and .STB files only. */
10919 switch (filedata
->file_header
.e_type
)
10923 switch (VMS_ST_FUNC_TYPE (other
))
10925 case VMS_SFT_CODE_ADDR
:
10926 strcat (res
, " CA");
10928 case VMS_SFT_SYMV_IDX
:
10929 strcat (res
, " VEC");
10932 strcat (res
, " FD");
10934 case VMS_SFT_RESERVE
:
10935 strcat (res
, " RSV");
10938 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10939 VMS_ST_FUNC_TYPE (other
));
10940 strcat (res
, " <unknown>");
10947 switch (VMS_ST_LINKAGE (other
))
10949 case VMS_STL_IGNORE
:
10950 strcat (res
, " IGN");
10952 case VMS_STL_RESERVE
:
10953 strcat (res
, " RSV");
10956 strcat (res
, " STD");
10959 strcat (res
, " LNK");
10962 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10963 VMS_ST_LINKAGE (other
));
10964 strcat (res
, " <unknown>");
10976 static const char *
10977 get_ppc64_symbol_other (unsigned int other
)
10979 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10981 static char buf
[32];
10982 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10983 PPC64_LOCAL_ENTRY_OFFSET (other
));
10989 static const char *
10990 get_symbol_other (Filedata
* filedata
, unsigned int other
)
10992 const char * result
= NULL
;
10993 static char buff
[32];
10998 switch (filedata
->file_header
.e_machine
)
11001 result
= get_mips_symbol_other (other
);
11004 result
= get_ia64_symbol_other (filedata
, other
);
11007 result
= get_ppc64_symbol_other (other
);
11017 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11021 static const char *
11022 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11024 static char buff
[32];
11028 case SHN_UNDEF
: return "UND";
11029 case SHN_ABS
: return "ABS";
11030 case SHN_COMMON
: return "COM";
11032 if (type
== SHN_IA_64_ANSI_COMMON
11033 && filedata
->file_header
.e_machine
== EM_IA_64
11034 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11036 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11037 || filedata
->file_header
.e_machine
== EM_L1OM
11038 || filedata
->file_header
.e_machine
== EM_K1OM
)
11039 && type
== SHN_X86_64_LCOMMON
)
11040 return "LARGE_COM";
11041 else if ((type
== SHN_MIPS_SCOMMON
11042 && filedata
->file_header
.e_machine
== EM_MIPS
)
11043 || (type
== SHN_TIC6X_SCOMMON
11044 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11046 else if (type
== SHN_MIPS_SUNDEFINED
11047 && filedata
->file_header
.e_machine
== EM_MIPS
)
11049 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11050 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11051 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11052 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11053 else if (type
>= SHN_LORESERVE
)
11054 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11055 else if (type
>= filedata
->file_header
.e_shnum
)
11056 sprintf (buff
, _("bad section index[%3d]"), type
);
11058 sprintf (buff
, "%3d", type
);
11066 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11068 unsigned char * e_data
;
11071 /* If the size_t type is smaller than the bfd_size_type, eg because
11072 you are building a 32-bit tool on a 64-bit host, then make sure
11073 that when (number) is cast to (size_t) no information is lost. */
11074 if (sizeof (size_t) < sizeof (bfd_size_type
)
11075 && (bfd_size_type
) ((size_t) number
) != number
)
11077 error (_("Size truncation prevents reading %s elements of size %u\n"),
11078 bfd_vmatoa ("u", number
), ent_size
);
11082 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11083 attempting to allocate memory when the read is bound to fail. */
11084 if (ent_size
* number
> filedata
->file_size
)
11086 error (_("Invalid number of dynamic entries: %s\n"),
11087 bfd_vmatoa ("u", number
));
11091 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11092 if (e_data
== NULL
)
11094 error (_("Out of memory reading %s dynamic entries\n"),
11095 bfd_vmatoa ("u", number
));
11099 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11101 error (_("Unable to read in %s bytes of dynamic data\n"),
11102 bfd_vmatoa ("u", number
* ent_size
));
11107 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11108 if (i_data
== NULL
)
11110 error (_("Out of memory allocating space for %s dynamic entries\n"),
11111 bfd_vmatoa ("u", number
));
11117 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11125 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11127 Elf_Internal_Sym
* psym
;
11130 n
= print_vma (si
, DEC_5
);
11132 fputs (&" "[n
], stdout
);
11133 printf (" %3lu: ", hn
);
11135 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11137 printf (_("<No info available for dynamic symbol number %lu>\n"),
11138 (unsigned long) si
);
11142 psym
= dynamic_symbols
+ si
;
11143 print_vma (psym
->st_value
, LONG_HEX
);
11145 print_vma (psym
->st_size
, DEC_5
);
11147 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11148 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11150 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11151 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11154 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11156 printf (" %-7s", get_symbol_visibility (vis
));
11157 /* Check to see if any other bits in the st_other field are set.
11158 Note - displaying this information disrupts the layout of the
11159 table being generated, but for the moment this case is very
11161 if (psym
->st_other
^ vis
)
11162 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11165 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11166 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11167 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11169 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11173 static const char *
11174 get_symbol_version_string (Filedata
* filedata
,
11175 bfd_boolean is_dynsym
,
11176 const char * strtab
,
11177 unsigned long int strtab_size
,
11179 Elf_Internal_Sym
* psym
,
11180 enum versioned_symbol_info
* sym_info
,
11181 unsigned short * vna_other
)
11183 unsigned char data
[2];
11184 unsigned short vers_data
;
11185 unsigned long offset
;
11188 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11191 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11192 sizeof data
+ si
* sizeof (vers_data
));
11194 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11195 sizeof (data
), 1, _("version data")) == NULL
)
11198 vers_data
= byte_get (data
, 2);
11200 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11203 /* Usually we'd only see verdef for defined symbols, and verneed for
11204 undefined symbols. However, symbols defined by the linker in
11205 .dynbss for variables copied from a shared library in order to
11206 avoid text relocations are defined yet have verneed. We could
11207 use a heuristic to detect the special case, for example, check
11208 for verneed first on symbols defined in SHT_NOBITS sections, but
11209 it is simpler and more reliable to just look for both verdef and
11210 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11212 if (psym
->st_shndx
!= SHN_UNDEF
11213 && vers_data
!= 0x8001
11214 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11216 Elf_Internal_Verdef ivd
;
11217 Elf_Internal_Verdaux ivda
;
11218 Elf_External_Verdaux evda
;
11221 off
= offset_from_vma (filedata
,
11222 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11223 sizeof (Elf_External_Verdef
));
11227 Elf_External_Verdef evd
;
11229 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11230 _("version def")) == NULL
)
11238 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11239 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11240 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11243 off
+= ivd
.vd_next
;
11245 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11247 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11249 off
-= ivd
.vd_next
;
11252 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11253 _("version def aux")) != NULL
)
11255 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11257 if (psym
->st_name
!= ivda
.vda_name
)
11259 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11260 ? symbol_hidden
: symbol_public
);
11261 return (ivda
.vda_name
< strtab_size
11262 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11268 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11270 Elf_External_Verneed evn
;
11271 Elf_Internal_Verneed ivn
;
11272 Elf_Internal_Vernaux ivna
;
11274 offset
= offset_from_vma (filedata
,
11275 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11279 unsigned long vna_off
;
11281 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11282 _("version need")) == NULL
)
11285 ivna
.vna_other
= 0;
11290 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11291 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11293 vna_off
= offset
+ ivn
.vn_aux
;
11297 Elf_External_Vernaux evna
;
11299 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11300 _("version need aux (3)")) == NULL
)
11303 ivna
.vna_other
= 0;
11308 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11309 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11310 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11313 vna_off
+= ivna
.vna_next
;
11315 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11317 if (ivna
.vna_other
== vers_data
)
11320 offset
+= ivn
.vn_next
;
11322 while (ivn
.vn_next
!= 0);
11324 if (ivna
.vna_other
== vers_data
)
11326 *sym_info
= symbol_undefined
;
11327 *vna_other
= ivna
.vna_other
;
11328 return (ivna
.vna_name
< strtab_size
11329 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11335 /* Dump the symbol table. */
11337 process_symbol_table (Filedata
* filedata
)
11339 Elf_Internal_Shdr
* section
;
11340 bfd_size_type nbuckets
= 0;
11341 bfd_size_type nchains
= 0;
11342 bfd_vma
* buckets
= NULL
;
11343 bfd_vma
* chains
= NULL
;
11344 bfd_vma ngnubuckets
= 0;
11345 bfd_vma
* gnubuckets
= NULL
;
11346 bfd_vma
* gnuchains
= NULL
;
11347 bfd_vma gnusymidx
= 0;
11348 bfd_size_type ngnuchains
= 0;
11350 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11353 if (dynamic_info
[DT_HASH
]
11355 || (do_using_dynamic
11357 && dynamic_strings
!= NULL
)))
11359 unsigned char nb
[8];
11360 unsigned char nc
[8];
11361 unsigned int hash_ent_size
= 4;
11363 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11364 || filedata
->file_header
.e_machine
== EM_S390
11365 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11366 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11369 if (fseek (filedata
->handle
,
11370 (archive_file_offset
11371 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11372 sizeof nb
+ sizeof nc
)),
11375 error (_("Unable to seek to start of dynamic information\n"));
11379 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11381 error (_("Failed to read in number of buckets\n"));
11385 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11387 error (_("Failed to read in number of chains\n"));
11391 nbuckets
= byte_get (nb
, hash_ent_size
);
11392 nchains
= byte_get (nc
, hash_ent_size
);
11394 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11395 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11398 if (buckets
== NULL
|| chains
== NULL
)
11400 if (do_using_dynamic
)
11411 if (dynamic_info_DT_GNU_HASH
11413 || (do_using_dynamic
11415 && dynamic_strings
!= NULL
)))
11417 unsigned char nb
[16];
11418 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11419 bfd_vma buckets_vma
;
11421 if (fseek (filedata
->handle
,
11422 (archive_file_offset
11423 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11427 error (_("Unable to seek to start of dynamic information\n"));
11431 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11433 error (_("Failed to read in number of buckets\n"));
11437 ngnubuckets
= byte_get (nb
, 4);
11438 gnusymidx
= byte_get (nb
+ 4, 4);
11439 bitmaskwords
= byte_get (nb
+ 8, 4);
11440 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11442 buckets_vma
+= bitmaskwords
* 4;
11444 buckets_vma
+= bitmaskwords
* 8;
11446 if (fseek (filedata
->handle
,
11447 (archive_file_offset
11448 + offset_from_vma (filedata
, buckets_vma
, 4)),
11451 error (_("Unable to seek to start of dynamic information\n"));
11455 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11457 if (gnubuckets
== NULL
)
11460 for (i
= 0; i
< ngnubuckets
; i
++)
11461 if (gnubuckets
[i
] != 0)
11463 if (gnubuckets
[i
] < gnusymidx
)
11466 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11467 maxchain
= gnubuckets
[i
];
11470 if (maxchain
== 0xffffffff)
11473 maxchain
-= gnusymidx
;
11475 if (fseek (filedata
->handle
,
11476 (archive_file_offset
11477 + offset_from_vma (filedata
, buckets_vma
11478 + 4 * (ngnubuckets
+ maxchain
), 4)),
11481 error (_("Unable to seek to start of dynamic information\n"));
11487 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11489 error (_("Failed to determine last chain length\n"));
11493 if (maxchain
+ 1 == 0)
11498 while ((byte_get (nb
, 4) & 1) == 0);
11500 if (fseek (filedata
->handle
,
11501 (archive_file_offset
11502 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11505 error (_("Unable to seek to start of dynamic information\n"));
11509 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11510 ngnuchains
= maxchain
;
11513 if (gnuchains
== NULL
)
11518 if (do_using_dynamic
)
11523 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11525 && do_using_dynamic
11526 && dynamic_strings
!= NULL
11527 && dynamic_symbols
!= NULL
)
11531 if (dynamic_info
[DT_HASH
])
11536 printf (_("\nSymbol table for image:\n"));
11538 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11540 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11542 visited
= xcmalloc (nchains
, 1);
11543 memset (visited
, 0, nchains
);
11544 for (hn
= 0; hn
< nbuckets
; hn
++)
11546 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11548 print_dynamic_symbol (filedata
, si
, hn
);
11549 if (si
>= nchains
|| visited
[si
])
11551 error (_("histogram chain is corrupt\n"));
11560 if (dynamic_info_DT_GNU_HASH
)
11562 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11564 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11566 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11568 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11569 if (gnubuckets
[hn
] != 0)
11571 bfd_vma si
= gnubuckets
[hn
];
11572 bfd_vma off
= si
- gnusymidx
;
11576 print_dynamic_symbol (filedata
, si
, hn
);
11579 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11583 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11584 && filedata
->section_headers
!= NULL
)
11588 for (i
= 0, section
= filedata
->section_headers
;
11589 i
< filedata
->file_header
.e_shnum
;
11593 char * strtab
= NULL
;
11594 unsigned long int strtab_size
= 0;
11595 Elf_Internal_Sym
* symtab
;
11596 Elf_Internal_Sym
* psym
;
11597 unsigned long num_syms
;
11599 if ((section
->sh_type
!= SHT_SYMTAB
11600 && section
->sh_type
!= SHT_DYNSYM
)
11602 && section
->sh_type
== SHT_SYMTAB
))
11605 if (section
->sh_entsize
== 0)
11607 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11608 printable_section_name (filedata
, section
));
11612 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11613 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11614 "\nSymbol table '%s' contains %lu entries:\n",
11616 printable_section_name (filedata
, section
),
11620 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11622 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11624 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11625 if (symtab
== NULL
)
11628 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11630 strtab
= filedata
->string_table
;
11631 strtab_size
= filedata
->string_table_length
;
11633 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11635 Elf_Internal_Shdr
* string_sec
;
11637 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11639 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11640 1, string_sec
->sh_size
,
11641 _("string table"));
11642 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11645 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11647 const char *version_string
;
11648 enum versioned_symbol_info sym_info
;
11649 unsigned short vna_other
;
11651 printf ("%6d: ", si
);
11652 print_vma (psym
->st_value
, LONG_HEX
);
11654 print_vma (psym
->st_size
, DEC_5
);
11655 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11656 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11657 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11658 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11661 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11663 printf (" %-7s", get_symbol_visibility (vis
));
11664 /* Check to see if any other bits in the st_other field are set.
11665 Note - displaying this information disrupts the layout of the
11666 table being generated, but for the moment this case is very rare. */
11667 if (psym
->st_other
^ vis
)
11668 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11670 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11671 print_symbol (25, psym
->st_name
< strtab_size
11672 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11675 = get_symbol_version_string (filedata
,
11676 section
->sh_type
== SHT_DYNSYM
,
11677 strtab
, strtab_size
, si
,
11678 psym
, &sym_info
, &vna_other
);
11679 if (version_string
)
11681 if (sym_info
== symbol_undefined
)
11682 printf ("@%s (%d)", version_string
, vna_other
);
11684 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11690 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11691 && si
>= section
->sh_info
11692 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11693 && filedata
->file_header
.e_machine
!= EM_MIPS
11694 /* Solaris binaries have been found to violate this requirement as
11695 well. Not sure if this is a bug or an ABI requirement. */
11696 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11697 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11698 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11702 if (strtab
!= filedata
->string_table
)
11708 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11710 if (do_histogram
&& buckets
!= NULL
)
11712 unsigned long * lengths
;
11713 unsigned long * counts
;
11716 unsigned long maxlength
= 0;
11717 unsigned long nzero_counts
= 0;
11718 unsigned long nsyms
= 0;
11721 printf (ngettext ("\nHistogram for bucket list length "
11722 "(total of %lu bucket):\n",
11723 "\nHistogram for bucket list length "
11724 "(total of %lu buckets):\n",
11725 (unsigned long) nbuckets
),
11726 (unsigned long) nbuckets
);
11728 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11729 if (lengths
== NULL
)
11731 error (_("Out of memory allocating space for histogram buckets\n"));
11734 visited
= xcmalloc (nchains
, 1);
11735 memset (visited
, 0, nchains
);
11737 printf (_(" Length Number %% of total Coverage\n"));
11738 for (hn
= 0; hn
< nbuckets
; ++hn
)
11740 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11743 if (maxlength
< ++lengths
[hn
])
11745 if (si
>= nchains
|| visited
[si
])
11747 error (_("histogram chain is corrupt\n"));
11755 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11756 if (counts
== NULL
)
11759 error (_("Out of memory allocating space for histogram counts\n"));
11763 for (hn
= 0; hn
< nbuckets
; ++hn
)
11764 ++counts
[lengths
[hn
]];
11769 printf (" 0 %-10lu (%5.1f%%)\n",
11770 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11771 for (i
= 1; i
<= maxlength
; ++i
)
11773 nzero_counts
+= counts
[i
] * i
;
11774 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11775 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11776 (nzero_counts
* 100.0) / nsyms
);
11784 if (buckets
!= NULL
)
11790 if (do_histogram
&& gnubuckets
!= NULL
)
11792 unsigned long * lengths
;
11793 unsigned long * counts
;
11795 unsigned long maxlength
= 0;
11796 unsigned long nzero_counts
= 0;
11797 unsigned long nsyms
= 0;
11799 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11800 "(total of %lu bucket):\n",
11801 "\nHistogram for `.gnu.hash' bucket list length "
11802 "(total of %lu buckets):\n",
11803 (unsigned long) ngnubuckets
),
11804 (unsigned long) ngnubuckets
);
11806 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11807 if (lengths
== NULL
)
11809 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11813 printf (_(" Length Number %% of total Coverage\n"));
11815 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11816 if (gnubuckets
[hn
] != 0)
11818 bfd_vma off
, length
= 1;
11820 for (off
= gnubuckets
[hn
] - gnusymidx
;
11821 /* PR 17531 file: 010-77222-0.004. */
11822 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11825 lengths
[hn
] = length
;
11826 if (length
> maxlength
)
11827 maxlength
= length
;
11831 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11832 if (counts
== NULL
)
11835 error (_("Out of memory allocating space for gnu histogram counts\n"));
11839 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11840 ++counts
[lengths
[hn
]];
11842 if (ngnubuckets
> 0)
11845 printf (" 0 %-10lu (%5.1f%%)\n",
11846 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11847 for (j
= 1; j
<= maxlength
; ++j
)
11849 nzero_counts
+= counts
[j
] * j
;
11850 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11851 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11852 (nzero_counts
* 100.0) / nsyms
);
11866 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
11870 if (dynamic_syminfo
== NULL
11872 /* No syminfo, this is ok. */
11875 /* There better should be a dynamic symbol section. */
11876 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11880 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11881 "contains %d entry:\n",
11882 "\nDynamic info segment at offset 0x%lx "
11883 "contains %d entries:\n",
11884 dynamic_syminfo_nent
),
11885 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11887 printf (_(" Num: Name BoundTo Flags\n"));
11888 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11890 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11892 printf ("%4d: ", i
);
11893 if (i
>= num_dynamic_syms
)
11894 printf (_("<corrupt index>"));
11895 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11896 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11898 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11901 switch (dynamic_syminfo
[i
].si_boundto
)
11903 case SYMINFO_BT_SELF
:
11904 fputs ("SELF ", stdout
);
11906 case SYMINFO_BT_PARENT
:
11907 fputs ("PARENT ", stdout
);
11910 if (dynamic_syminfo
[i
].si_boundto
> 0
11911 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11912 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11914 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11918 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11922 if (flags
& SYMINFO_FLG_DIRECT
)
11923 printf (" DIRECT");
11924 if (flags
& SYMINFO_FLG_PASSTHRU
)
11925 printf (" PASSTHRU");
11926 if (flags
& SYMINFO_FLG_COPY
)
11928 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11929 printf (" LAZYLOAD");
11937 #define IN_RANGE(START,END,ADDR,OFF) \
11938 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11940 /* Check to see if the given reloc needs to be handled in a target specific
11941 manner. If so then process the reloc and return TRUE otherwise return
11944 If called with reloc == NULL, then this is a signal that reloc processing
11945 for the current section has finished, and any saved state should be
11949 target_specific_reloc_handling (Filedata
* filedata
,
11950 Elf_Internal_Rela
* reloc
,
11951 unsigned char * start
,
11952 unsigned char * end
,
11953 Elf_Internal_Sym
* symtab
,
11954 unsigned long num_syms
)
11956 unsigned int reloc_type
= 0;
11957 unsigned long sym_index
= 0;
11961 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
11962 sym_index
= get_reloc_symindex (reloc
->r_info
);
11965 switch (filedata
->file_header
.e_machine
)
11968 case EM_MSP430_OLD
:
11970 static Elf_Internal_Sym
* saved_sym
= NULL
;
11978 switch (reloc_type
)
11980 case 10: /* R_MSP430_SYM_DIFF */
11981 if (uses_msp430x_relocs (filedata
))
11983 /* Fall through. */
11984 case 21: /* R_MSP430X_SYM_DIFF */
11986 if (sym_index
>= num_syms
)
11987 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11990 saved_sym
= symtab
+ sym_index
;
11993 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11994 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11995 goto handle_sym_diff
;
11997 case 5: /* R_MSP430_16_BYTE */
11998 case 9: /* R_MSP430_8 */
11999 if (uses_msp430x_relocs (filedata
))
12001 goto handle_sym_diff
;
12003 case 2: /* R_MSP430_ABS16 */
12004 case 15: /* R_MSP430X_ABS16 */
12005 if (! uses_msp430x_relocs (filedata
))
12007 goto handle_sym_diff
;
12010 if (saved_sym
!= NULL
)
12012 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12015 if (sym_index
>= num_syms
)
12016 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12020 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12021 - saved_sym
->st_value
);
12023 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12024 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12027 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12028 (long) reloc
->r_offset
);
12037 if (saved_sym
!= NULL
)
12038 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12045 case EM_CYGNUS_MN10300
:
12047 static Elf_Internal_Sym
* saved_sym
= NULL
;
12055 switch (reloc_type
)
12057 case 34: /* R_MN10300_ALIGN */
12059 case 33: /* R_MN10300_SYM_DIFF */
12060 if (sym_index
>= num_syms
)
12061 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12064 saved_sym
= symtab
+ sym_index
;
12067 case 1: /* R_MN10300_32 */
12068 case 2: /* R_MN10300_16 */
12069 if (saved_sym
!= NULL
)
12071 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12074 if (sym_index
>= num_syms
)
12075 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12079 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12080 - saved_sym
->st_value
);
12082 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12083 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12085 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12086 (long) reloc
->r_offset
);
12094 if (saved_sym
!= NULL
)
12095 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12103 static bfd_vma saved_sym1
= 0;
12104 static bfd_vma saved_sym2
= 0;
12105 static bfd_vma value
;
12109 saved_sym1
= saved_sym2
= 0;
12113 switch (reloc_type
)
12115 case 0x80: /* R_RL78_SYM. */
12116 saved_sym1
= saved_sym2
;
12117 if (sym_index
>= num_syms
)
12118 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12122 saved_sym2
= symtab
[sym_index
].st_value
;
12123 saved_sym2
+= reloc
->r_addend
;
12127 case 0x83: /* R_RL78_OPsub. */
12128 value
= saved_sym1
- saved_sym2
;
12129 saved_sym2
= saved_sym1
= 0;
12133 case 0x41: /* R_RL78_ABS32. */
12134 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12135 byte_put (start
+ reloc
->r_offset
, value
, 4);
12137 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12138 (long) reloc
->r_offset
);
12142 case 0x43: /* R_RL78_ABS16. */
12143 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12144 byte_put (start
+ reloc
->r_offset
, value
, 2);
12146 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12147 (long) reloc
->r_offset
);
12161 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12162 DWARF debug sections. This is a target specific test. Note - we do not
12163 go through the whole including-target-headers-multiple-times route, (as
12164 we have already done with <elf/h8.h>) because this would become very
12165 messy and even then this function would have to contain target specific
12166 information (the names of the relocs instead of their numeric values).
12167 FIXME: This is not the correct way to solve this problem. The proper way
12168 is to have target specific reloc sizing and typing functions created by
12169 the reloc-macros.h header, in the same way that it already creates the
12170 reloc naming functions. */
12173 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12175 /* Please keep this table alpha-sorted for ease of visual lookup. */
12176 switch (filedata
->file_header
.e_machine
)
12180 return reloc_type
== 1; /* R_386_32. */
12182 return reloc_type
== 1; /* R_68K_32. */
12184 return reloc_type
== 1; /* R_860_32. */
12186 return reloc_type
== 2; /* R_960_32. */
12188 return (reloc_type
== 258
12189 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12190 case EM_ADAPTEVA_EPIPHANY
:
12191 return reloc_type
== 3;
12193 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12195 return reloc_type
== 1; /* R_ARC_32. */
12196 case EM_ARC_COMPACT
:
12197 case EM_ARC_COMPACT2
:
12198 return reloc_type
== 4; /* R_ARC_32. */
12200 return reloc_type
== 2; /* R_ARM_ABS32 */
12203 return reloc_type
== 1;
12205 return reloc_type
== 0x12; /* R_byte4_data. */
12207 return reloc_type
== 3; /* R_CRIS_32. */
12209 return reloc_type
== 3; /* R_CR16_NUM32. */
12211 return reloc_type
== 15; /* R_CRX_NUM32. */
12212 case EM_CYGNUS_FRV
:
12213 return reloc_type
== 1;
12214 case EM_CYGNUS_D10V
:
12216 return reloc_type
== 6; /* R_D10V_32. */
12217 case EM_CYGNUS_D30V
:
12219 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12221 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12222 case EM_CYGNUS_FR30
:
12224 return reloc_type
== 3; /* R_FR30_32. */
12226 return reloc_type
== 1; /* R_FT32_32. */
12230 return reloc_type
== 1; /* R_H8_DIR32. */
12232 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12233 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12234 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12235 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12238 return reloc_type
== 2; /* R_IP2K_32. */
12240 return reloc_type
== 2; /* R_IQ2000_32. */
12241 case EM_LATTICEMICO32
:
12242 return reloc_type
== 3; /* R_LM32_32. */
12245 return reloc_type
== 3; /* R_M32C_32. */
12247 return reloc_type
== 34; /* R_M32R_32_RELA. */
12250 return reloc_type
== 6; /* R_M68HC11_32. */
12252 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12253 case EM_CYGNUS_MEP
:
12254 return reloc_type
== 4; /* R_MEP_32. */
12256 return reloc_type
== 2; /* R_METAG_ADDR32. */
12257 case EM_MICROBLAZE
:
12258 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12260 return reloc_type
== 2; /* R_MIPS_32. */
12262 return reloc_type
== 4; /* R_MMIX_32. */
12263 case EM_CYGNUS_MN10200
:
12265 return reloc_type
== 1; /* R_MN10200_32. */
12266 case EM_CYGNUS_MN10300
:
12268 return reloc_type
== 1; /* R_MN10300_32. */
12270 return reloc_type
== 1; /* R_MOXIE_32. */
12271 case EM_MSP430_OLD
:
12273 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12275 return reloc_type
== 2; /* R_MT_32. */
12277 return reloc_type
== 20; /* R_NDS32_RELA. */
12278 case EM_ALTERA_NIOS2
:
12279 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12281 return reloc_type
== 1; /* R_NIOS_32. */
12283 return reloc_type
== 1; /* R_OR1K_32. */
12285 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12286 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12289 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12291 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12293 return reloc_type
== 1; /* R_PPC_ADDR32. */
12295 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12297 return reloc_type
== 1; /* R_RISCV_32. */
12299 return reloc_type
== 1; /* R_RL78_DIR32. */
12301 return reloc_type
== 1; /* R_RX_DIR32. */
12303 return reloc_type
== 1; /* R_I370_ADDR31. */
12306 return reloc_type
== 4; /* R_S390_32. */
12308 return reloc_type
== 8; /* R_SCORE_ABS32. */
12310 return reloc_type
== 1; /* R_SH_DIR32. */
12311 case EM_SPARC32PLUS
:
12314 return reloc_type
== 3 /* R_SPARC_32. */
12315 || reloc_type
== 23; /* R_SPARC_UA32. */
12317 return reloc_type
== 6; /* R_SPU_ADDR32 */
12319 return reloc_type
== 1; /* R_C6000_ABS32. */
12321 return reloc_type
== 2; /* R_TILEGX_32. */
12323 return reloc_type
== 1; /* R_TILEPRO_32. */
12324 case EM_CYGNUS_V850
:
12326 return reloc_type
== 6; /* R_V850_ABS32. */
12328 return reloc_type
== 0x33; /* R_V810_WORD. */
12330 return reloc_type
== 1; /* R_VAX_32. */
12332 return reloc_type
== 3; /* R_VISIUM_32. */
12333 case EM_WEBASSEMBLY
:
12334 return reloc_type
== 1; /* R_WASM32_32. */
12338 return reloc_type
== 10; /* R_X86_64_32. */
12341 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12343 return reloc_type
== 4; /* R_XGATE_32. */
12345 return reloc_type
== 1; /* R_XSTROMY16_32. */
12346 case EM_XTENSA_OLD
:
12348 return reloc_type
== 1; /* R_XTENSA_32. */
12351 static unsigned int prev_warn
= 0;
12353 /* Avoid repeating the same warning multiple times. */
12354 if (prev_warn
!= filedata
->file_header
.e_machine
)
12355 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12356 filedata
->file_header
.e_machine
);
12357 prev_warn
= filedata
->file_header
.e_machine
;
12363 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12364 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12367 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12369 switch (filedata
->file_header
.e_machine
)
12370 /* Please keep this table alpha-sorted for ease of visual lookup. */
12374 return reloc_type
== 2; /* R_386_PC32. */
12376 return reloc_type
== 4; /* R_68K_PC32. */
12378 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12379 case EM_ADAPTEVA_EPIPHANY
:
12380 return reloc_type
== 6;
12382 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12383 case EM_ARC_COMPACT
:
12384 case EM_ARC_COMPACT2
:
12385 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12387 return reloc_type
== 3; /* R_ARM_REL32 */
12390 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12391 case EM_MICROBLAZE
:
12392 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12394 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12396 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12398 return reloc_type
== 26; /* R_PPC_REL32. */
12400 return reloc_type
== 26; /* R_PPC64_REL32. */
12403 return reloc_type
== 5; /* R_390_PC32. */
12405 return reloc_type
== 2; /* R_SH_REL32. */
12406 case EM_SPARC32PLUS
:
12409 return reloc_type
== 6; /* R_SPARC_DISP32. */
12411 return reloc_type
== 13; /* R_SPU_REL32. */
12413 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12415 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12417 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12421 return reloc_type
== 2; /* R_X86_64_PC32. */
12422 case EM_XTENSA_OLD
:
12424 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12426 /* Do not abort or issue an error message here. Not all targets use
12427 pc-relative 32-bit relocs in their DWARF debug information and we
12428 have already tested for target coverage in is_32bit_abs_reloc. A
12429 more helpful warning message will be generated by apply_relocations
12430 anyway, so just return. */
12435 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12436 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12439 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12441 switch (filedata
->file_header
.e_machine
)
12444 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12446 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12448 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12449 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12451 return reloc_type
== 80; /* R_PARISC_DIR64. */
12453 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12455 return reloc_type
== 2; /* R_RISCV_64. */
12456 case EM_SPARC32PLUS
:
12459 return reloc_type
== 32 /* R_SPARC_64. */
12460 || reloc_type
== 54; /* R_SPARC_UA64. */
12464 return reloc_type
== 1; /* R_X86_64_64. */
12467 return reloc_type
== 22; /* R_S390_64. */
12469 return reloc_type
== 1; /* R_TILEGX_64. */
12471 return reloc_type
== 18; /* R_MIPS_64. */
12477 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12478 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12481 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12483 switch (filedata
->file_header
.e_machine
)
12486 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12488 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12490 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12491 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12493 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12495 return reloc_type
== 44; /* R_PPC64_REL64. */
12496 case EM_SPARC32PLUS
:
12499 return reloc_type
== 46; /* R_SPARC_DISP64. */
12503 return reloc_type
== 24; /* R_X86_64_PC64. */
12506 return reloc_type
== 23; /* R_S390_PC64. */
12508 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12514 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12515 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12518 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12520 switch (filedata
->file_header
.e_machine
)
12522 case EM_CYGNUS_MN10200
:
12524 return reloc_type
== 4; /* R_MN10200_24. */
12526 return reloc_type
== 5; /* R_FT32_20. */
12532 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12533 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12536 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12538 /* Please keep this table alpha-sorted for ease of visual lookup. */
12539 switch (filedata
->file_header
.e_machine
)
12542 case EM_ARC_COMPACT
:
12543 case EM_ARC_COMPACT2
:
12544 return reloc_type
== 2; /* R_ARC_16. */
12545 case EM_ADAPTEVA_EPIPHANY
:
12546 return reloc_type
== 5;
12549 return reloc_type
== 4; /* R_AVR_16. */
12550 case EM_CYGNUS_D10V
:
12552 return reloc_type
== 3; /* R_D10V_16. */
12554 return reloc_type
== 2; /* R_FT32_16. */
12558 return reloc_type
== R_H8_DIR16
;
12561 return reloc_type
== 1; /* R_IP2K_16. */
12564 return reloc_type
== 1; /* R_M32C_16 */
12565 case EM_CYGNUS_MN10200
:
12567 return reloc_type
== 2; /* R_MN10200_16. */
12568 case EM_CYGNUS_MN10300
:
12570 return reloc_type
== 2; /* R_MN10300_16. */
12572 if (uses_msp430x_relocs (filedata
))
12573 return reloc_type
== 2; /* R_MSP430_ABS16. */
12574 /* Fall through. */
12575 case EM_MSP430_OLD
:
12576 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12578 return reloc_type
== 19; /* R_NDS32_RELA. */
12579 case EM_ALTERA_NIOS2
:
12580 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12582 return reloc_type
== 9; /* R_NIOS_16. */
12584 return reloc_type
== 2; /* R_OR1K_16. */
12586 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12588 return reloc_type
== 2; /* R_C6000_ABS16. */
12590 return reloc_type
== 2; /* R_VISIUM_16. */
12593 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12595 return reloc_type
== 3; /* R_XGATE_16. */
12601 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12602 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12605 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12607 /* Please keep this table alpha-sorted for ease of visual lookup. */
12608 switch (filedata
->file_header
.e_machine
)
12611 return reloc_type
== 35; /* R_RISCV_ADD32. */
12617 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12618 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12621 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12623 /* Please keep this table alpha-sorted for ease of visual lookup. */
12624 switch (filedata
->file_header
.e_machine
)
12627 return reloc_type
== 39; /* R_RISCV_SUB32. */
12633 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12634 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12637 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12639 /* Please keep this table alpha-sorted for ease of visual lookup. */
12640 switch (filedata
->file_header
.e_machine
)
12643 return reloc_type
== 36; /* R_RISCV_ADD64. */
12649 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12650 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12653 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12655 /* Please keep this table alpha-sorted for ease of visual lookup. */
12656 switch (filedata
->file_header
.e_machine
)
12659 return reloc_type
== 40; /* R_RISCV_SUB64. */
12665 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12666 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12669 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12671 /* Please keep this table alpha-sorted for ease of visual lookup. */
12672 switch (filedata
->file_header
.e_machine
)
12675 return reloc_type
== 34; /* R_RISCV_ADD16. */
12681 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12682 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12685 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12687 /* Please keep this table alpha-sorted for ease of visual lookup. */
12688 switch (filedata
->file_header
.e_machine
)
12691 return reloc_type
== 38; /* R_RISCV_SUB16. */
12697 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12698 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12701 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12703 /* Please keep this table alpha-sorted for ease of visual lookup. */
12704 switch (filedata
->file_header
.e_machine
)
12707 return reloc_type
== 33; /* R_RISCV_ADD8. */
12713 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12714 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12717 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12719 /* Please keep this table alpha-sorted for ease of visual lookup. */
12720 switch (filedata
->file_header
.e_machine
)
12723 return reloc_type
== 37; /* R_RISCV_SUB8. */
12729 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12730 relocation entries (possibly formerly used for SHT_GROUP sections). */
12733 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12735 switch (filedata
->file_header
.e_machine
)
12737 case EM_386
: /* R_386_NONE. */
12738 case EM_68K
: /* R_68K_NONE. */
12739 case EM_ADAPTEVA_EPIPHANY
:
12740 case EM_ALPHA
: /* R_ALPHA_NONE. */
12741 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12742 case EM_ARC
: /* R_ARC_NONE. */
12743 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12744 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12745 case EM_ARM
: /* R_ARM_NONE. */
12746 case EM_C166
: /* R_XC16X_NONE. */
12747 case EM_CRIS
: /* R_CRIS_NONE. */
12748 case EM_FT32
: /* R_FT32_NONE. */
12749 case EM_IA_64
: /* R_IA64_NONE. */
12750 case EM_K1OM
: /* R_X86_64_NONE. */
12751 case EM_L1OM
: /* R_X86_64_NONE. */
12752 case EM_M32R
: /* R_M32R_NONE. */
12753 case EM_MIPS
: /* R_MIPS_NONE. */
12754 case EM_MN10300
: /* R_MN10300_NONE. */
12755 case EM_MOXIE
: /* R_MOXIE_NONE. */
12756 case EM_NIOS32
: /* R_NIOS_NONE. */
12757 case EM_OR1K
: /* R_OR1K_NONE. */
12758 case EM_PARISC
: /* R_PARISC_NONE. */
12759 case EM_PPC64
: /* R_PPC64_NONE. */
12760 case EM_PPC
: /* R_PPC_NONE. */
12761 case EM_RISCV
: /* R_RISCV_NONE. */
12762 case EM_S390
: /* R_390_NONE. */
12764 case EM_SH
: /* R_SH_NONE. */
12765 case EM_SPARC32PLUS
:
12766 case EM_SPARC
: /* R_SPARC_NONE. */
12768 case EM_TILEGX
: /* R_TILEGX_NONE. */
12769 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12770 case EM_TI_C6000
:/* R_C6000_NONE. */
12771 case EM_X86_64
: /* R_X86_64_NONE. */
12773 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12774 return reloc_type
== 0;
12777 return reloc_type
== 0 || reloc_type
== 256;
12780 return (reloc_type
== 0 /* R_AVR_NONE. */
12781 || reloc_type
== 30 /* R_AVR_DIFF8. */
12782 || reloc_type
== 31 /* R_AVR_DIFF16. */
12783 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12785 return reloc_type
== 3; /* R_METAG_NONE. */
12787 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12788 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12789 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12790 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12791 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12793 return (reloc_type
== 0 /* R_PRU_NONE. */
12794 || reloc_type
== 65 /* R_PRU_DIFF8. */
12795 || reloc_type
== 66 /* R_PRU_DIFF16. */
12796 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12797 case EM_XTENSA_OLD
:
12799 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12800 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12801 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12802 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12807 /* Returns TRUE if there is a relocation against
12808 section NAME at OFFSET bytes. */
12811 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12813 Elf_Internal_Rela
* relocs
;
12814 Elf_Internal_Rela
* rp
;
12816 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12819 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12821 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12822 if (rp
->r_offset
== offset
)
12828 /* Apply relocations to a section.
12829 Returns TRUE upon success, FALSE otherwise.
12830 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12831 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12832 will be set to the number of relocs loaded.
12834 Note: So far support has been added only for those relocations
12835 which can be found in debug sections. FIXME: Add support for
12836 more relocations ? */
12839 apply_relocations (Filedata
* filedata
,
12840 const Elf_Internal_Shdr
* section
,
12841 unsigned char * start
,
12842 bfd_size_type size
,
12843 void ** relocs_return
,
12844 unsigned long * num_relocs_return
)
12846 Elf_Internal_Shdr
* relsec
;
12847 unsigned char * end
= start
+ size
;
12848 bfd_boolean res
= TRUE
;
12850 if (relocs_return
!= NULL
)
12852 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12853 * num_relocs_return
= 0;
12856 if (filedata
->file_header
.e_type
!= ET_REL
)
12857 /* No relocs to apply. */
12860 /* Find the reloc section associated with the section. */
12861 for (relsec
= filedata
->section_headers
;
12862 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
12865 bfd_boolean is_rela
;
12866 unsigned long num_relocs
;
12867 Elf_Internal_Rela
* relocs
;
12868 Elf_Internal_Rela
* rp
;
12869 Elf_Internal_Shdr
* symsec
;
12870 Elf_Internal_Sym
* symtab
;
12871 unsigned long num_syms
;
12872 Elf_Internal_Sym
* sym
;
12874 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12875 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
12876 || filedata
->section_headers
+ relsec
->sh_info
!= section
12877 || relsec
->sh_size
== 0
12878 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
12881 is_rela
= relsec
->sh_type
== SHT_RELA
;
12885 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
12886 relsec
->sh_size
, & relocs
, & num_relocs
))
12891 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
12892 relsec
->sh_size
, & relocs
, & num_relocs
))
12896 /* SH uses RELA but uses in place value instead of the addend field. */
12897 if (filedata
->file_header
.e_machine
== EM_SH
)
12900 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
12901 if (symsec
->sh_type
!= SHT_SYMTAB
12902 && symsec
->sh_type
!= SHT_DYNSYM
)
12904 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
12906 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12909 unsigned int reloc_type
;
12910 unsigned int reloc_size
;
12911 bfd_boolean reloc_inplace
= FALSE
;
12912 bfd_boolean reloc_subtract
= FALSE
;
12913 unsigned char * rloc
;
12914 unsigned long sym_index
;
12916 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
12918 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
12920 else if (is_none_reloc (filedata
, reloc_type
))
12922 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
12923 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
12925 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
12926 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
12928 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
12930 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
12932 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
12934 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
12937 reloc_inplace
= TRUE
;
12939 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
12941 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
12944 reloc_inplace
= TRUE
;
12946 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
12948 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
12951 reloc_inplace
= TRUE
;
12953 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
12955 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
12958 reloc_inplace
= TRUE
;
12962 static unsigned int prev_reloc
= 0;
12964 if (reloc_type
!= prev_reloc
)
12965 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12966 reloc_type
, printable_section_name (filedata
, section
));
12967 prev_reloc
= reloc_type
;
12972 rloc
= start
+ rp
->r_offset
;
12973 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12975 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12976 (unsigned long) rp
->r_offset
,
12977 printable_section_name (filedata
, section
));
12982 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12983 if (sym_index
>= num_syms
)
12985 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12986 sym_index
, printable_section_name (filedata
, section
));
12990 sym
= symtab
+ sym_index
;
12992 /* If the reloc has a symbol associated with it,
12993 make sure that it is of an appropriate type.
12995 Relocations against symbols without type can happen.
12996 Gcc -feliminate-dwarf2-dups may generate symbols
12997 without type for debug info.
12999 Icc generates relocations against function symbols
13000 instead of local labels.
13002 Relocations against object symbols can happen, eg when
13003 referencing a global array. For an example of this see
13004 the _clz.o binary in libgcc.a. */
13006 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13007 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13009 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13010 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13011 printable_section_name (filedata
, relsec
),
13012 (long int)(rp
- relocs
));
13019 addend
+= rp
->r_addend
;
13020 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13021 partial_inplace. */
13023 || (filedata
->file_header
.e_machine
== EM_XTENSA
13024 && reloc_type
== 1)
13025 || ((filedata
->file_header
.e_machine
== EM_PJ
13026 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13027 && reloc_type
== 1)
13028 || ((filedata
->file_header
.e_machine
== EM_D30V
13029 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13030 && reloc_type
== 12)
13032 addend
+= byte_get (rloc
, reloc_size
);
13034 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13035 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13037 /* On HPPA, all pc-relative relocations are biased by 8. */
13038 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13040 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13043 else if (reloc_subtract
)
13044 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13046 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13050 /* Let the target specific reloc processing code know that
13051 we have finished with these relocs. */
13052 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13056 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13057 * num_relocs_return
= num_relocs
;
13068 #ifdef SUPPORT_DISASSEMBLY
13070 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13072 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13074 /* FIXME: XXX -- to be done --- XXX */
13080 /* Reads in the contents of SECTION from FILE, returning a pointer
13081 to a malloc'ed buffer or NULL if something went wrong. */
13084 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13086 bfd_size_type num_bytes
= section
->sh_size
;
13088 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13090 printf (_("Section '%s' has no data to dump.\n"),
13091 printable_section_name (filedata
, section
));
13095 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13096 _("section contents"));
13099 /* Uncompresses a section that was compressed using zlib, in place. */
13102 uncompress_section_contents (unsigned char ** buffer
,
13103 dwarf_size_type uncompressed_size
,
13104 dwarf_size_type
* size
)
13106 dwarf_size_type compressed_size
= *size
;
13107 unsigned char * compressed_buffer
= *buffer
;
13108 unsigned char * uncompressed_buffer
;
13112 /* It is possible the section consists of several compressed
13113 buffers concatenated together, so we uncompress in a loop. */
13114 /* PR 18313: The state field in the z_stream structure is supposed
13115 to be invisible to the user (ie us), but some compilers will
13116 still complain about it being used without initialisation. So
13117 we first zero the entire z_stream structure and then set the fields
13119 memset (& strm
, 0, sizeof strm
);
13120 strm
.avail_in
= compressed_size
;
13121 strm
.next_in
= (Bytef
*) compressed_buffer
;
13122 strm
.avail_out
= uncompressed_size
;
13123 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13125 rc
= inflateInit (& strm
);
13126 while (strm
.avail_in
> 0)
13130 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13131 + (uncompressed_size
- strm
.avail_out
));
13132 rc
= inflate (&strm
, Z_FINISH
);
13133 if (rc
!= Z_STREAM_END
)
13135 rc
= inflateReset (& strm
);
13137 rc
= inflateEnd (& strm
);
13139 || strm
.avail_out
!= 0)
13142 *buffer
= uncompressed_buffer
;
13143 *size
= uncompressed_size
;
13147 free (uncompressed_buffer
);
13148 /* Indicate decompression failure. */
13154 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13156 Elf_Internal_Shdr
* relsec
;
13157 bfd_size_type num_bytes
;
13158 unsigned char * data
;
13159 unsigned char * end
;
13160 unsigned char * real_start
;
13161 unsigned char * start
;
13162 bfd_boolean some_strings_shown
;
13164 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13166 /* PR 21820: Do not fail if the section was empty. */
13167 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13169 num_bytes
= section
->sh_size
;
13171 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13173 if (decompress_dumps
)
13175 dwarf_size_type new_size
= num_bytes
;
13176 dwarf_size_type uncompressed_size
= 0;
13178 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13180 Elf_Internal_Chdr chdr
;
13181 unsigned int compression_header_size
13182 = get_compression_header (& chdr
, (unsigned char *) start
,
13185 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13187 warn (_("section '%s' has unsupported compress type: %d\n"),
13188 printable_section_name (filedata
, section
), chdr
.ch_type
);
13191 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13193 warn (_("compressed section '%s' is corrupted\n"),
13194 printable_section_name (filedata
, section
));
13197 uncompressed_size
= chdr
.ch_size
;
13198 start
+= compression_header_size
;
13199 new_size
-= compression_header_size
;
13201 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13203 /* Read the zlib header. In this case, it should be "ZLIB"
13204 followed by the uncompressed section size, 8 bytes in
13205 big-endian order. */
13206 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13207 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13208 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13209 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13210 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13211 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13212 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13213 uncompressed_size
+= start
[11];
13218 if (uncompressed_size
)
13220 if (uncompress_section_contents (& start
,
13221 uncompressed_size
, & new_size
))
13222 num_bytes
= new_size
;
13225 error (_("Unable to decompress section %s\n"),
13226 printable_section_name (filedata
, section
));
13231 start
= real_start
;
13234 /* If the section being dumped has relocations against it the user might
13235 be expecting these relocations to have been applied. Check for this
13236 case and issue a warning message in order to avoid confusion.
13237 FIXME: Maybe we ought to have an option that dumps a section with
13238 relocs applied ? */
13239 for (relsec
= filedata
->section_headers
;
13240 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13243 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13244 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13245 || filedata
->section_headers
+ relsec
->sh_info
!= section
13246 || relsec
->sh_size
== 0
13247 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13250 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13255 end
= start
+ num_bytes
;
13256 some_strings_shown
= FALSE
;
13260 while (!ISPRINT (* data
))
13261 if (++ data
>= end
)
13266 size_t maxlen
= end
- data
;
13269 /* PR 11128: Use two separate invocations in order to work
13270 around bugs in the Solaris 8 implementation of printf. */
13271 printf (" [%6tx] ", data
- start
);
13273 printf (" [%6Ix] ", (size_t) (data
- start
));
13277 print_symbol ((int) maxlen
, (const char *) data
);
13279 data
+= strnlen ((const char *) data
, maxlen
);
13283 printf (_("<corrupt>\n"));
13286 some_strings_shown
= TRUE
;
13290 if (! some_strings_shown
)
13291 printf (_(" No strings found in this section."));
13300 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13301 Filedata
* filedata
,
13302 bfd_boolean relocate
)
13304 Elf_Internal_Shdr
* relsec
;
13305 bfd_size_type bytes
;
13306 bfd_size_type section_size
;
13308 unsigned char * data
;
13309 unsigned char * real_start
;
13310 unsigned char * start
;
13312 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13314 /* PR 21820: Do not fail if the section was empty. */
13315 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13317 section_size
= section
->sh_size
;
13319 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13321 if (decompress_dumps
)
13323 dwarf_size_type new_size
= section_size
;
13324 dwarf_size_type uncompressed_size
= 0;
13326 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13328 Elf_Internal_Chdr chdr
;
13329 unsigned int compression_header_size
13330 = get_compression_header (& chdr
, start
, section_size
);
13332 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13334 warn (_("section '%s' has unsupported compress type: %d\n"),
13335 printable_section_name (filedata
, section
), chdr
.ch_type
);
13338 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13340 warn (_("compressed section '%s' is corrupted\n"),
13341 printable_section_name (filedata
, section
));
13344 uncompressed_size
= chdr
.ch_size
;
13345 start
+= compression_header_size
;
13346 new_size
-= compression_header_size
;
13348 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13350 /* Read the zlib header. In this case, it should be "ZLIB"
13351 followed by the uncompressed section size, 8 bytes in
13352 big-endian order. */
13353 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13354 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13355 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13356 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13357 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13358 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13359 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13360 uncompressed_size
+= start
[11];
13365 if (uncompressed_size
)
13367 if (uncompress_section_contents (& start
, uncompressed_size
,
13370 section_size
= new_size
;
13374 error (_("Unable to decompress section %s\n"),
13375 printable_section_name (filedata
, section
));
13376 /* FIXME: Print the section anyway ? */
13381 start
= real_start
;
13386 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13391 /* If the section being dumped has relocations against it the user might
13392 be expecting these relocations to have been applied. Check for this
13393 case and issue a warning message in order to avoid confusion.
13394 FIXME: Maybe we ought to have an option that dumps a section with
13395 relocs applied ? */
13396 for (relsec
= filedata
->section_headers
;
13397 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13400 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13401 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13402 || filedata
->section_headers
+ relsec
->sh_info
!= section
13403 || relsec
->sh_size
== 0
13404 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13407 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13412 addr
= section
->sh_addr
;
13413 bytes
= section_size
;
13422 lbytes
= (bytes
> 16 ? 16 : bytes
);
13424 printf (" 0x%8.8lx ", (unsigned long) addr
);
13426 for (j
= 0; j
< 16; j
++)
13429 printf ("%2.2x", data
[j
]);
13437 for (j
= 0; j
< lbytes
; j
++)
13440 if (k
>= ' ' && k
< 0x7f)
13460 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13461 const Elf_Internal_Shdr
* sec
,
13464 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13466 Filedata
* filedata
= (Filedata
*) data
;
13468 if (section
->start
!= NULL
)
13470 /* If it is already loaded, do nothing. */
13471 if (streq (section
->filename
, filedata
->file_name
))
13473 free (section
->start
);
13476 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13477 section
->address
= sec
->sh_addr
;
13478 section
->user_data
= NULL
;
13479 section
->filename
= filedata
->file_name
;
13480 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13482 sec
->sh_size
, buf
);
13483 if (section
->start
== NULL
)
13487 unsigned char *start
= section
->start
;
13488 dwarf_size_type size
= sec
->sh_size
;
13489 dwarf_size_type uncompressed_size
= 0;
13491 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13493 Elf_Internal_Chdr chdr
;
13494 unsigned int compression_header_size
;
13496 if (size
< (is_32bit_elf
13497 ? sizeof (Elf32_External_Chdr
)
13498 : sizeof (Elf64_External_Chdr
)))
13500 warn (_("compressed section %s is too small to contain a compression header"),
13505 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13507 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13509 warn (_("section '%s' has unsupported compress type: %d\n"),
13510 section
->name
, chdr
.ch_type
);
13513 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13515 warn (_("compressed section '%s' is corrupted\n"),
13519 uncompressed_size
= chdr
.ch_size
;
13520 start
+= compression_header_size
;
13521 size
-= compression_header_size
;
13523 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13525 /* Read the zlib header. In this case, it should be "ZLIB"
13526 followed by the uncompressed section size, 8 bytes in
13527 big-endian order. */
13528 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13529 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13530 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13531 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13532 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13533 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13534 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13535 uncompressed_size
+= start
[11];
13540 if (uncompressed_size
)
13542 if (uncompress_section_contents (&start
, uncompressed_size
,
13545 /* Free the compressed buffer, update the section buffer
13546 and the section size if uncompress is successful. */
13547 free (section
->start
);
13548 section
->start
= start
;
13552 error (_("Unable to decompress section %s\n"),
13553 printable_section_name (filedata
, sec
));
13558 section
->size
= size
;
13561 if (section
->start
== NULL
)
13564 if (debug_displays
[debug
].relocate
)
13566 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13567 & section
->reloc_info
, & section
->num_relocs
))
13572 section
->reloc_info
= NULL
;
13573 section
->num_relocs
= 0;
13579 /* If this is not NULL, load_debug_section will only look for sections
13580 within the list of sections given here. */
13581 static unsigned int * section_subset
= NULL
;
13584 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13586 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13587 Elf_Internal_Shdr
* sec
;
13588 Filedata
* filedata
= (Filedata
*) data
;
13590 /* Without section headers we cannot find any sections. */
13591 if (filedata
->section_headers
== NULL
)
13594 if (filedata
->string_table
== NULL
13595 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13596 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13598 Elf_Internal_Shdr
* strs
;
13600 /* Read in the string table, so that we have section names to scan. */
13601 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13603 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13605 filedata
->string_table
13606 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13607 1, strs
->sh_size
, _("string table"));
13609 filedata
->string_table_length
13610 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13614 /* Locate the debug section. */
13615 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13617 section
->name
= section
->uncompressed_name
;
13620 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13622 section
->name
= section
->compressed_name
;
13627 /* If we're loading from a subset of sections, and we've loaded
13628 a section matching this name before, it's likely that it's a
13630 if (section_subset
!= NULL
)
13631 free_debug_section (debug
);
13633 return load_specific_debug_section (debug
, sec
, data
);
13637 free_debug_section (enum dwarf_section_display_enum debug
)
13639 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13641 if (section
->start
== NULL
)
13644 free ((char *) section
->start
);
13645 section
->start
= NULL
;
13646 section
->address
= 0;
13651 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13653 char * name
= SECTION_NAME (section
);
13654 const char * print_name
= printable_section_name (filedata
, section
);
13655 bfd_size_type length
;
13656 bfd_boolean result
= TRUE
;
13659 length
= section
->sh_size
;
13662 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13665 if (section
->sh_type
== SHT_NOBITS
)
13667 /* There is no point in dumping the contents of a debugging section
13668 which has the NOBITS type - the bits in the file will be random.
13669 This can happen when a file containing a .eh_frame section is
13670 stripped with the --only-keep-debug command line option. */
13671 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13676 if (const_strneq (name
, ".gnu.linkonce.wi."))
13677 name
= ".debug_info";
13679 /* See if we know how to display the contents of this section. */
13680 for (i
= 0; i
< max
; i
++)
13682 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13683 struct dwarf_section_display
* display
= debug_displays
+ i
;
13684 struct dwarf_section
* sec
= & display
->section
;
13686 if (streq (sec
->uncompressed_name
, name
)
13687 || (id
== line
&& const_strneq (name
, ".debug_line."))
13688 || streq (sec
->compressed_name
, name
))
13690 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13693 free_debug_section (id
);
13695 if (i
== line
&& const_strneq (name
, ".debug_line."))
13697 else if (streq (sec
->uncompressed_name
, name
))
13698 sec
->name
= sec
->uncompressed_name
;
13700 sec
->name
= sec
->compressed_name
;
13702 if (load_specific_debug_section (id
, section
, filedata
))
13704 /* If this debug section is part of a CU/TU set in a .dwp file,
13705 restrict load_debug_section to the sections in that set. */
13706 section_subset
= find_cu_tu_set (filedata
, shndx
);
13708 result
&= display
->display (sec
, filedata
);
13710 section_subset
= NULL
;
13712 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13713 free_debug_section (id
);
13721 printf (_("Unrecognized debug section: %s\n"), print_name
);
13728 /* Set DUMP_SECTS for all sections where dumps were requested
13729 based on section name. */
13732 initialise_dumps_byname (Filedata
* filedata
)
13734 struct dump_list_entry
* cur
;
13736 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13739 bfd_boolean any
= FALSE
;
13741 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13742 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13744 request_dump_bynumber (filedata
, i
, cur
->type
);
13749 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13755 process_section_contents (Filedata
* filedata
)
13757 Elf_Internal_Shdr
* section
;
13759 bfd_boolean res
= TRUE
;
13764 initialise_dumps_byname (filedata
);
13766 for (i
= 0, section
= filedata
->section_headers
;
13767 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13770 dump_type dump
= filedata
->dump_sects
[i
];
13772 #ifdef SUPPORT_DISASSEMBLY
13773 if (dump
& DISASS_DUMP
)
13775 if (! disassemble_section (section
, filedata
))
13779 if (dump
& HEX_DUMP
)
13781 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13785 if (dump
& RELOC_DUMP
)
13787 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13791 if (dump
& STRING_DUMP
)
13793 if (! dump_section_as_strings (section
, filedata
))
13797 if (dump
& DEBUG_DUMP
)
13799 if (! display_debug_section (i
, section
, filedata
))
13804 /* Check to see if the user requested a
13805 dump of a section that does not exist. */
13806 while (i
< filedata
->num_dump_sects
)
13808 if (filedata
->dump_sects
[i
])
13810 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13820 process_mips_fpe_exception (int mask
)
13824 bfd_boolean first
= TRUE
;
13826 if (mask
& OEX_FPU_INEX
)
13827 fputs ("INEX", stdout
), first
= FALSE
;
13828 if (mask
& OEX_FPU_UFLO
)
13829 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13830 if (mask
& OEX_FPU_OFLO
)
13831 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13832 if (mask
& OEX_FPU_DIV0
)
13833 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13834 if (mask
& OEX_FPU_INVAL
)
13835 printf ("%sINVAL", first
? "" : "|");
13838 fputs ("0", stdout
);
13841 /* Display's the value of TAG at location P. If TAG is
13842 greater than 0 it is assumed to be an unknown tag, and
13843 a message is printed to this effect. Otherwise it is
13844 assumed that a message has already been printed.
13846 If the bottom bit of TAG is set it assumed to have a
13847 string value, otherwise it is assumed to have an integer
13850 Returns an updated P pointing to the first unread byte
13851 beyond the end of TAG's value.
13853 Reads at or beyond END will not be made. */
13855 static unsigned char *
13856 display_tag_value (signed int tag
,
13858 const unsigned char * const end
)
13863 printf (" Tag_unknown_%d: ", tag
);
13867 warn (_("<corrupt tag>\n"));
13871 /* PR 17531 file: 027-19978-0.004. */
13872 size_t maxlen
= (end
- p
) - 1;
13877 print_symbol ((int) maxlen
, (const char *) p
);
13878 p
+= strnlen ((char *) p
, maxlen
) + 1;
13882 printf (_("<corrupt string tag>"));
13883 p
= (unsigned char *) end
;
13891 val
= read_uleb128 (p
, &len
, end
);
13893 printf ("%ld (0x%lx)\n", val
, val
);
13900 /* ARC ABI attributes section. */
13902 static unsigned char *
13903 display_arc_attribute (unsigned char * p
,
13904 const unsigned char * const end
)
13910 tag
= read_uleb128 (p
, &len
, end
);
13915 case Tag_ARC_PCS_config
:
13916 val
= read_uleb128 (p
, &len
, end
);
13918 printf (" Tag_ARC_PCS_config: ");
13922 printf (_("Absent/Non standard\n"));
13925 printf (_("Bare metal/mwdt\n"));
13928 printf (_("Bare metal/newlib\n"));
13931 printf (_("Linux/uclibc\n"));
13934 printf (_("Linux/glibc\n"));
13937 printf (_("Unknown\n"));
13942 case Tag_ARC_CPU_base
:
13943 val
= read_uleb128 (p
, &len
, end
);
13945 printf (" Tag_ARC_CPU_base: ");
13950 printf (_("Absent\n"));
13952 case TAG_CPU_ARC6xx
:
13953 printf ("ARC6xx\n");
13955 case TAG_CPU_ARC7xx
:
13956 printf ("ARC7xx\n");
13958 case TAG_CPU_ARCEM
:
13959 printf ("ARCEM\n");
13961 case TAG_CPU_ARCHS
:
13962 printf ("ARCHS\n");
13967 case Tag_ARC_CPU_variation
:
13968 val
= read_uleb128 (p
, &len
, end
);
13970 printf (" Tag_ARC_CPU_variation: ");
13974 if (val
> 0 && val
< 16)
13975 printf ("Core%d\n", val
);
13977 printf ("Unknown\n");
13981 printf (_("Absent\n"));
13986 case Tag_ARC_CPU_name
:
13987 printf (" Tag_ARC_CPU_name: ");
13988 p
= display_tag_value (-1, p
, end
);
13991 case Tag_ARC_ABI_rf16
:
13992 val
= read_uleb128 (p
, &len
, end
);
13994 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
13997 case Tag_ARC_ABI_osver
:
13998 val
= read_uleb128 (p
, &len
, end
);
14000 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14003 case Tag_ARC_ABI_pic
:
14004 case Tag_ARC_ABI_sda
:
14005 val
= read_uleb128 (p
, &len
, end
);
14007 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14008 : " Tag_ARC_ABI_pic: ");
14012 printf (_("Absent\n"));
14021 printf (_("Unknown\n"));
14026 case Tag_ARC_ABI_tls
:
14027 val
= read_uleb128 (p
, &len
, end
);
14029 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14032 case Tag_ARC_ABI_enumsize
:
14033 val
= read_uleb128 (p
, &len
, end
);
14035 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14039 case Tag_ARC_ABI_exceptions
:
14040 val
= read_uleb128 (p
, &len
, end
);
14042 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14046 case Tag_ARC_ABI_double_size
:
14047 val
= read_uleb128 (p
, &len
, end
);
14049 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14052 case Tag_ARC_ISA_config
:
14053 printf (" Tag_ARC_ISA_config: ");
14054 p
= display_tag_value (-1, p
, end
);
14057 case Tag_ARC_ISA_apex
:
14058 printf (" Tag_ARC_ISA_apex: ");
14059 p
= display_tag_value (-1, p
, end
);
14062 case Tag_ARC_ISA_mpy_option
:
14063 val
= read_uleb128 (p
, &len
, end
);
14065 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14069 return display_tag_value (tag
& 1, p
, end
);
14075 /* ARM EABI attributes section. */
14080 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14082 const char ** table
;
14083 } arm_attr_public_tag
;
14085 static const char * arm_attr_tag_CPU_arch
[] =
14086 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14087 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14089 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14090 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14091 {"No", "Thumb-1", "Thumb-2", "Yes"};
14092 static const char * arm_attr_tag_FP_arch
[] =
14093 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14094 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14095 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14096 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14097 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14098 "NEON for ARMv8.1"};
14099 static const char * arm_attr_tag_PCS_config
[] =
14100 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14101 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14102 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14103 {"V6", "SB", "TLS", "Unused"};
14104 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14105 {"Absolute", "PC-relative", "SB-relative", "None"};
14106 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14107 {"Absolute", "PC-relative", "None"};
14108 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14109 {"None", "direct", "GOT-indirect"};
14110 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14111 {"None", "??? 1", "2", "??? 3", "4"};
14112 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14113 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14114 {"Unused", "Needed", "Sign only"};
14115 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14116 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14117 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14118 {"Unused", "Finite", "RTABI", "IEEE 754"};
14119 static const char * arm_attr_tag_ABI_enum_size
[] =
14120 {"Unused", "small", "int", "forced to int"};
14121 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14122 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14123 static const char * arm_attr_tag_ABI_VFP_args
[] =
14124 {"AAPCS", "VFP registers", "custom", "compatible"};
14125 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14126 {"AAPCS", "WMMX registers", "custom"};
14127 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14128 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14129 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14130 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14131 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14132 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14133 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14134 static const char * arm_attr_tag_FP_HP_extension
[] =
14135 {"Not Allowed", "Allowed"};
14136 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14137 {"None", "IEEE 754", "Alternative Format"};
14138 static const char * arm_attr_tag_DSP_extension
[] =
14139 {"Follow architecture", "Allowed"};
14140 static const char * arm_attr_tag_MPextension_use
[] =
14141 {"Not Allowed", "Allowed"};
14142 static const char * arm_attr_tag_DIV_use
[] =
14143 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14144 "Allowed in v7-A with integer division extension"};
14145 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14146 static const char * arm_attr_tag_Virtualization_use
[] =
14147 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14148 "TrustZone and Virtualization Extensions"};
14149 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14150 {"Not Allowed", "Allowed"};
14152 #define LOOKUP(id, name) \
14153 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14154 static arm_attr_public_tag arm_attr_public_tags
[] =
14156 {4, "CPU_raw_name", 1, NULL
},
14157 {5, "CPU_name", 1, NULL
},
14158 LOOKUP(6, CPU_arch
),
14159 {7, "CPU_arch_profile", 0, NULL
},
14160 LOOKUP(8, ARM_ISA_use
),
14161 LOOKUP(9, THUMB_ISA_use
),
14162 LOOKUP(10, FP_arch
),
14163 LOOKUP(11, WMMX_arch
),
14164 LOOKUP(12, Advanced_SIMD_arch
),
14165 LOOKUP(13, PCS_config
),
14166 LOOKUP(14, ABI_PCS_R9_use
),
14167 LOOKUP(15, ABI_PCS_RW_data
),
14168 LOOKUP(16, ABI_PCS_RO_data
),
14169 LOOKUP(17, ABI_PCS_GOT_use
),
14170 LOOKUP(18, ABI_PCS_wchar_t
),
14171 LOOKUP(19, ABI_FP_rounding
),
14172 LOOKUP(20, ABI_FP_denormal
),
14173 LOOKUP(21, ABI_FP_exceptions
),
14174 LOOKUP(22, ABI_FP_user_exceptions
),
14175 LOOKUP(23, ABI_FP_number_model
),
14176 {24, "ABI_align_needed", 0, NULL
},
14177 {25, "ABI_align_preserved", 0, NULL
},
14178 LOOKUP(26, ABI_enum_size
),
14179 LOOKUP(27, ABI_HardFP_use
),
14180 LOOKUP(28, ABI_VFP_args
),
14181 LOOKUP(29, ABI_WMMX_args
),
14182 LOOKUP(30, ABI_optimization_goals
),
14183 LOOKUP(31, ABI_FP_optimization_goals
),
14184 {32, "compatibility", 0, NULL
},
14185 LOOKUP(34, CPU_unaligned_access
),
14186 LOOKUP(36, FP_HP_extension
),
14187 LOOKUP(38, ABI_FP_16bit_format
),
14188 LOOKUP(42, MPextension_use
),
14189 LOOKUP(44, DIV_use
),
14190 LOOKUP(46, DSP_extension
),
14191 {64, "nodefaults", 0, NULL
},
14192 {65, "also_compatible_with", 0, NULL
},
14193 LOOKUP(66, T2EE_use
),
14194 {67, "conformance", 1, NULL
},
14195 LOOKUP(68, Virtualization_use
),
14196 LOOKUP(70, MPextension_use_legacy
)
14200 static unsigned char *
14201 display_arm_attribute (unsigned char * p
,
14202 const unsigned char * const end
)
14207 arm_attr_public_tag
* attr
;
14211 tag
= read_uleb128 (p
, &len
, end
);
14214 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14216 if (arm_attr_public_tags
[i
].tag
== tag
)
14218 attr
= &arm_attr_public_tags
[i
];
14225 printf (" Tag_%s: ", attr
->name
);
14226 switch (attr
->type
)
14231 case 7: /* Tag_CPU_arch_profile. */
14232 val
= read_uleb128 (p
, &len
, end
);
14236 case 0: printf (_("None\n")); break;
14237 case 'A': printf (_("Application\n")); break;
14238 case 'R': printf (_("Realtime\n")); break;
14239 case 'M': printf (_("Microcontroller\n")); break;
14240 case 'S': printf (_("Application or Realtime\n")); break;
14241 default: printf ("??? (%d)\n", val
); break;
14245 case 24: /* Tag_align_needed. */
14246 val
= read_uleb128 (p
, &len
, end
);
14250 case 0: printf (_("None\n")); break;
14251 case 1: printf (_("8-byte\n")); break;
14252 case 2: printf (_("4-byte\n")); break;
14253 case 3: printf ("??? 3\n"); break;
14256 printf (_("8-byte and up to %d-byte extended\n"),
14259 printf ("??? (%d)\n", val
);
14264 case 25: /* Tag_align_preserved. */
14265 val
= read_uleb128 (p
, &len
, end
);
14269 case 0: printf (_("None\n")); break;
14270 case 1: printf (_("8-byte, except leaf SP\n")); break;
14271 case 2: printf (_("8-byte\n")); break;
14272 case 3: printf ("??? 3\n"); break;
14275 printf (_("8-byte and up to %d-byte extended\n"),
14278 printf ("??? (%d)\n", val
);
14283 case 32: /* Tag_compatibility. */
14285 val
= read_uleb128 (p
, &len
, end
);
14287 printf (_("flag = %d, vendor = "), val
);
14290 size_t maxlen
= (end
- p
) - 1;
14292 print_symbol ((int) maxlen
, (const char *) p
);
14293 p
+= strnlen ((char *) p
, maxlen
) + 1;
14297 printf (_("<corrupt>"));
14298 p
= (unsigned char *) end
;
14304 case 64: /* Tag_nodefaults. */
14305 /* PR 17531: file: 001-505008-0.01. */
14308 printf (_("True\n"));
14311 case 65: /* Tag_also_compatible_with. */
14312 val
= read_uleb128 (p
, &len
, end
);
14314 if (val
== 6 /* Tag_CPU_arch. */)
14316 val
= read_uleb128 (p
, &len
, end
);
14318 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14319 printf ("??? (%d)\n", val
);
14321 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14325 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14330 printf (_("<unknown: %d>\n"), tag
);
14336 return display_tag_value (-1, p
, end
);
14338 return display_tag_value (0, p
, end
);
14341 assert (attr
->type
& 0x80);
14342 val
= read_uleb128 (p
, &len
, end
);
14344 type
= attr
->type
& 0x7f;
14346 printf ("??? (%d)\n", val
);
14348 printf ("%s\n", attr
->table
[val
]);
14353 return display_tag_value (tag
, p
, end
);
14356 static unsigned char *
14357 display_gnu_attribute (unsigned char * p
,
14358 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14359 const unsigned char * const end
)
14365 tag
= read_uleb128 (p
, &len
, end
);
14368 /* Tag_compatibility is the only generic GNU attribute defined at
14372 val
= read_uleb128 (p
, &len
, end
);
14375 printf (_("flag = %d, vendor = "), val
);
14378 printf (_("<corrupt>\n"));
14379 warn (_("corrupt vendor attribute\n"));
14385 size_t maxlen
= (end
- p
) - 1;
14387 print_symbol ((int) maxlen
, (const char *) p
);
14388 p
+= strnlen ((char *) p
, maxlen
) + 1;
14392 printf (_("<corrupt>"));
14393 p
= (unsigned char *) end
;
14400 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14401 return display_proc_gnu_attribute (p
, tag
, end
);
14403 return display_tag_value (tag
, p
, end
);
14406 static unsigned char *
14407 display_power_gnu_attribute (unsigned char * p
,
14409 const unsigned char * const end
)
14414 if (tag
== Tag_GNU_Power_ABI_FP
)
14416 val
= read_uleb128 (p
, &len
, end
);
14418 printf (" Tag_GNU_Power_ABI_FP: ");
14421 printf (_("<corrupt>\n"));
14426 printf ("(%#x), ", val
);
14431 printf (_("unspecified hard/soft float, "));
14434 printf (_("hard float, "));
14437 printf (_("soft float, "));
14440 printf (_("single-precision hard float, "));
14447 printf (_("unspecified long double\n"));
14450 printf (_("128-bit IBM long double\n"));
14453 printf (_("64-bit long double\n"));
14456 printf (_("128-bit IEEE long double\n"));
14462 if (tag
== Tag_GNU_Power_ABI_Vector
)
14464 val
= read_uleb128 (p
, &len
, end
);
14466 printf (" Tag_GNU_Power_ABI_Vector: ");
14469 printf (_("<corrupt>\n"));
14474 printf ("(%#x), ", val
);
14479 printf (_("unspecified\n"));
14482 printf (_("generic\n"));
14485 printf ("AltiVec\n");
14494 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14496 val
= read_uleb128 (p
, &len
, end
);
14498 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14501 printf (_("<corrupt>\n"));
14506 printf ("(%#x), ", val
);
14511 printf (_("unspecified\n"));
14514 printf ("r3/r4\n");
14517 printf (_("memory\n"));
14526 return display_tag_value (tag
& 1, p
, end
);
14529 static unsigned char *
14530 display_s390_gnu_attribute (unsigned char * p
,
14532 const unsigned char * const end
)
14537 if (tag
== Tag_GNU_S390_ABI_Vector
)
14539 val
= read_uleb128 (p
, &len
, end
);
14541 printf (" Tag_GNU_S390_ABI_Vector: ");
14546 printf (_("any\n"));
14549 printf (_("software\n"));
14552 printf (_("hardware\n"));
14555 printf ("??? (%d)\n", val
);
14561 return display_tag_value (tag
& 1, p
, end
);
14565 display_sparc_hwcaps (unsigned int mask
)
14569 bfd_boolean first
= TRUE
;
14571 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14572 fputs ("mul32", stdout
), first
= FALSE
;
14573 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14574 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14575 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14576 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14577 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14578 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14579 if (mask
& ELF_SPARC_HWCAP_POPC
)
14580 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14581 if (mask
& ELF_SPARC_HWCAP_VIS
)
14582 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14583 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14584 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14585 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14586 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14587 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14588 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14589 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14590 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14591 if (mask
& ELF_SPARC_HWCAP_HPC
)
14592 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14593 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14594 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14595 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14596 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14597 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14598 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14599 if (mask
& ELF_SPARC_HWCAP_IMA
)
14600 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14601 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14602 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14605 fputc ('0', stdout
);
14606 fputc ('\n', stdout
);
14610 display_sparc_hwcaps2 (unsigned int mask
)
14614 bfd_boolean first
= TRUE
;
14616 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14617 fputs ("fjathplus", stdout
), first
= FALSE
;
14618 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14619 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14620 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14621 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14622 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14623 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14624 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14625 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14626 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14627 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14628 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14629 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14630 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14631 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14632 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14633 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14634 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14635 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14636 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14637 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14640 fputc ('0', stdout
);
14641 fputc ('\n', stdout
);
14644 static unsigned char *
14645 display_sparc_gnu_attribute (unsigned char * p
,
14647 const unsigned char * const end
)
14652 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14654 val
= read_uleb128 (p
, &len
, end
);
14656 printf (" Tag_GNU_Sparc_HWCAPS: ");
14657 display_sparc_hwcaps (val
);
14660 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14662 val
= read_uleb128 (p
, &len
, end
);
14664 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14665 display_sparc_hwcaps2 (val
);
14669 return display_tag_value (tag
, p
, end
);
14673 print_mips_fp_abi_value (unsigned int val
)
14677 case Val_GNU_MIPS_ABI_FP_ANY
:
14678 printf (_("Hard or soft float\n"));
14680 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14681 printf (_("Hard float (double precision)\n"));
14683 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14684 printf (_("Hard float (single precision)\n"));
14686 case Val_GNU_MIPS_ABI_FP_SOFT
:
14687 printf (_("Soft float\n"));
14689 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14690 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14692 case Val_GNU_MIPS_ABI_FP_XX
:
14693 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14695 case Val_GNU_MIPS_ABI_FP_64
:
14696 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14698 case Val_GNU_MIPS_ABI_FP_64A
:
14699 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14701 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14702 printf (_("NaN 2008 compatibility\n"));
14705 printf ("??? (%d)\n", val
);
14710 static unsigned char *
14711 display_mips_gnu_attribute (unsigned char * p
,
14713 const unsigned char * const end
)
14715 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14720 val
= read_uleb128 (p
, &len
, end
);
14722 printf (" Tag_GNU_MIPS_ABI_FP: ");
14724 print_mips_fp_abi_value (val
);
14729 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14734 val
= read_uleb128 (p
, &len
, end
);
14736 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14740 case Val_GNU_MIPS_ABI_MSA_ANY
:
14741 printf (_("Any MSA or not\n"));
14743 case Val_GNU_MIPS_ABI_MSA_128
:
14744 printf (_("128-bit MSA\n"));
14747 printf ("??? (%d)\n", val
);
14753 return display_tag_value (tag
& 1, p
, end
);
14756 static unsigned char *
14757 display_tic6x_attribute (unsigned char * p
,
14758 const unsigned char * const end
)
14764 tag
= read_uleb128 (p
, &len
, end
);
14770 val
= read_uleb128 (p
, &len
, end
);
14772 printf (" Tag_ISA: ");
14776 case C6XABI_Tag_ISA_none
:
14777 printf (_("None\n"));
14779 case C6XABI_Tag_ISA_C62X
:
14782 case C6XABI_Tag_ISA_C67X
:
14785 case C6XABI_Tag_ISA_C67XP
:
14786 printf ("C67x+\n");
14788 case C6XABI_Tag_ISA_C64X
:
14791 case C6XABI_Tag_ISA_C64XP
:
14792 printf ("C64x+\n");
14794 case C6XABI_Tag_ISA_C674X
:
14795 printf ("C674x\n");
14798 printf ("??? (%d)\n", val
);
14803 case Tag_ABI_wchar_t
:
14804 val
= read_uleb128 (p
, &len
, end
);
14806 printf (" Tag_ABI_wchar_t: ");
14810 printf (_("Not used\n"));
14813 printf (_("2 bytes\n"));
14816 printf (_("4 bytes\n"));
14819 printf ("??? (%d)\n", val
);
14824 case Tag_ABI_stack_align_needed
:
14825 val
= read_uleb128 (p
, &len
, end
);
14827 printf (" Tag_ABI_stack_align_needed: ");
14831 printf (_("8-byte\n"));
14834 printf (_("16-byte\n"));
14837 printf ("??? (%d)\n", val
);
14842 case Tag_ABI_stack_align_preserved
:
14843 val
= read_uleb128 (p
, &len
, end
);
14845 printf (" Tag_ABI_stack_align_preserved: ");
14849 printf (_("8-byte\n"));
14852 printf (_("16-byte\n"));
14855 printf ("??? (%d)\n", val
);
14861 val
= read_uleb128 (p
, &len
, end
);
14863 printf (" Tag_ABI_DSBT: ");
14867 printf (_("DSBT addressing not used\n"));
14870 printf (_("DSBT addressing used\n"));
14873 printf ("??? (%d)\n", val
);
14879 val
= read_uleb128 (p
, &len
, end
);
14881 printf (" Tag_ABI_PID: ");
14885 printf (_("Data addressing position-dependent\n"));
14888 printf (_("Data addressing position-independent, GOT near DP\n"));
14891 printf (_("Data addressing position-independent, GOT far from DP\n"));
14894 printf ("??? (%d)\n", val
);
14900 val
= read_uleb128 (p
, &len
, end
);
14902 printf (" Tag_ABI_PIC: ");
14906 printf (_("Code addressing position-dependent\n"));
14909 printf (_("Code addressing position-independent\n"));
14912 printf ("??? (%d)\n", val
);
14917 case Tag_ABI_array_object_alignment
:
14918 val
= read_uleb128 (p
, &len
, end
);
14920 printf (" Tag_ABI_array_object_alignment: ");
14924 printf (_("8-byte\n"));
14927 printf (_("4-byte\n"));
14930 printf (_("16-byte\n"));
14933 printf ("??? (%d)\n", val
);
14938 case Tag_ABI_array_object_align_expected
:
14939 val
= read_uleb128 (p
, &len
, end
);
14941 printf (" Tag_ABI_array_object_align_expected: ");
14945 printf (_("8-byte\n"));
14948 printf (_("4-byte\n"));
14951 printf (_("16-byte\n"));
14954 printf ("??? (%d)\n", val
);
14959 case Tag_ABI_compatibility
:
14961 val
= read_uleb128 (p
, &len
, end
);
14963 printf (" Tag_ABI_compatibility: ");
14964 printf (_("flag = %d, vendor = "), val
);
14967 size_t maxlen
= (end
- p
) - 1;
14969 print_symbol ((int) maxlen
, (const char *) p
);
14970 p
+= strnlen ((char *) p
, maxlen
) + 1;
14974 printf (_("<corrupt>"));
14975 p
= (unsigned char *) end
;
14981 case Tag_ABI_conformance
:
14983 printf (" Tag_ABI_conformance: \"");
14986 size_t maxlen
= (end
- p
) - 1;
14988 print_symbol ((int) maxlen
, (const char *) p
);
14989 p
+= strnlen ((char *) p
, maxlen
) + 1;
14993 printf (_("<corrupt>"));
14994 p
= (unsigned char *) end
;
15001 return display_tag_value (tag
, p
, end
);
15005 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15007 unsigned long addr
= 0;
15008 size_t bytes
= end
- p
;
15015 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15017 printf (" 0x%8.8lx ", addr
);
15019 for (j
= 0; j
< 16; j
++)
15022 printf ("%2.2x", p
[j
]);
15030 for (j
= 0; j
< lbytes
; j
++)
15033 if (k
>= ' ' && k
< 0x7f)
15049 static unsigned char *
15050 display_msp430x_attribute (unsigned char * p
,
15051 const unsigned char * const end
)
15057 tag
= read_uleb128 (p
, & len
, end
);
15062 case OFBA_MSPABI_Tag_ISA
:
15063 val
= read_uleb128 (p
, &len
, end
);
15065 printf (" Tag_ISA: ");
15068 case 0: printf (_("None\n")); break;
15069 case 1: printf (_("MSP430\n")); break;
15070 case 2: printf (_("MSP430X\n")); break;
15071 default: printf ("??? (%d)\n", val
); break;
15075 case OFBA_MSPABI_Tag_Code_Model
:
15076 val
= read_uleb128 (p
, &len
, end
);
15078 printf (" Tag_Code_Model: ");
15081 case 0: printf (_("None\n")); break;
15082 case 1: printf (_("Small\n")); break;
15083 case 2: printf (_("Large\n")); break;
15084 default: printf ("??? (%d)\n", val
); break;
15088 case OFBA_MSPABI_Tag_Data_Model
:
15089 val
= read_uleb128 (p
, &len
, end
);
15091 printf (" Tag_Data_Model: ");
15094 case 0: printf (_("None\n")); break;
15095 case 1: printf (_("Small\n")); break;
15096 case 2: printf (_("Large\n")); break;
15097 case 3: printf (_("Restricted Large\n")); break;
15098 default: printf ("??? (%d)\n", val
); break;
15103 printf (_(" <unknown tag %d>: "), tag
);
15110 size_t maxlen
= (end
- p
) - 1;
15112 print_symbol ((int) maxlen
, (const char *) p
);
15113 p
+= strnlen ((char *) p
, maxlen
) + 1;
15117 printf (_("<corrupt>"));
15118 p
= (unsigned char *) end
;
15124 val
= read_uleb128 (p
, &len
, end
);
15126 printf ("%d (0x%x)\n", val
, val
);
15136 process_attributes (Filedata
* filedata
,
15137 const char * public_name
,
15138 unsigned int proc_type
,
15139 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15140 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15142 Elf_Internal_Shdr
* sect
;
15144 bfd_boolean res
= TRUE
;
15146 /* Find the section header so that we get the size. */
15147 for (i
= 0, sect
= filedata
->section_headers
;
15148 i
< filedata
->file_header
.e_shnum
;
15151 unsigned char * contents
;
15154 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15157 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15158 sect
->sh_size
, _("attributes"));
15159 if (contents
== NULL
)
15166 /* The first character is the version of the attributes.
15167 Currently only version 1, (aka 'A') is recognised here. */
15170 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15175 bfd_vma section_len
;
15177 section_len
= sect
->sh_size
- 1;
15180 while (section_len
> 0)
15183 unsigned int namelen
;
15184 bfd_boolean public_section
;
15185 bfd_boolean gnu_section
;
15187 if (section_len
<= 4)
15189 error (_("Tag section ends prematurely\n"));
15193 attr_len
= byte_get (p
, 4);
15196 if (attr_len
> section_len
)
15198 error (_("Bad attribute length (%u > %u)\n"),
15199 (unsigned) attr_len
, (unsigned) section_len
);
15200 attr_len
= section_len
;
15203 /* PR 17531: file: 001-101425-0.004 */
15204 else if (attr_len
< 5)
15206 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15211 section_len
-= attr_len
;
15214 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15215 if (namelen
== 0 || namelen
>= attr_len
)
15217 error (_("Corrupt attribute section name\n"));
15222 printf (_("Attribute Section: "));
15223 print_symbol (INT_MAX
, (const char *) p
);
15226 if (public_name
&& streq ((char *) p
, public_name
))
15227 public_section
= TRUE
;
15229 public_section
= FALSE
;
15231 if (streq ((char *) p
, "gnu"))
15232 gnu_section
= TRUE
;
15234 gnu_section
= FALSE
;
15237 attr_len
-= namelen
;
15239 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15244 unsigned char * end
;
15246 /* PR binutils/17531: Safe handling of corrupt files. */
15249 error (_("Unused bytes at end of section\n"));
15256 size
= byte_get (p
, 4);
15257 if (size
> attr_len
)
15259 error (_("Bad subsection length (%u > %u)\n"),
15260 (unsigned) size
, (unsigned) attr_len
);
15264 /* PR binutils/17531: Safe handling of corrupt files. */
15267 error (_("Bad subsection length (%u < 6)\n"),
15275 end
= p
+ size
- 1;
15276 assert (end
<= contents
+ sect
->sh_size
);
15282 printf (_("File Attributes\n"));
15285 printf (_("Section Attributes:"));
15288 printf (_("Symbol Attributes:"));
15289 /* Fall through. */
15295 val
= read_uleb128 (p
, &j
, end
);
15299 printf (" %d", val
);
15304 printf (_("Unknown tag: %d\n"), tag
);
15305 public_section
= FALSE
;
15309 if (public_section
&& display_pub_attribute
!= NULL
)
15312 p
= display_pub_attribute (p
, end
);
15315 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15318 p
= display_gnu_attribute (p
,
15319 display_proc_gnu_attribute
,
15325 printf (_(" Unknown attribute:\n"));
15326 display_raw_attribute (p
, end
);
15341 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15342 Print the Address, Access and Initial fields of an entry at VMA ADDR
15343 and return the VMA of the next entry, or -1 if there was a problem.
15344 Does not read from DATA_END or beyond. */
15347 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15348 unsigned char * data_end
)
15351 print_vma (addr
, LONG_HEX
);
15353 if (addr
< pltgot
+ 0xfff0)
15354 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15356 printf ("%10s", "");
15359 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15363 unsigned char * from
= data
+ addr
- pltgot
;
15365 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15367 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15368 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15369 return (bfd_vma
) -1;
15373 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15374 print_vma (entry
, LONG_HEX
);
15377 return addr
+ (is_32bit_elf
? 4 : 8);
15380 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15381 PLTGOT. Print the Address and Initial fields of an entry at VMA
15382 ADDR and return the VMA of the next entry. */
15385 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15388 print_vma (addr
, LONG_HEX
);
15391 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15396 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15397 print_vma (entry
, LONG_HEX
);
15399 return addr
+ (is_32bit_elf
? 4 : 8);
15403 print_mips_ases (unsigned int mask
)
15405 if (mask
& AFL_ASE_DSP
)
15406 fputs ("\n\tDSP ASE", stdout
);
15407 if (mask
& AFL_ASE_DSPR2
)
15408 fputs ("\n\tDSP R2 ASE", stdout
);
15409 if (mask
& AFL_ASE_DSPR3
)
15410 fputs ("\n\tDSP R3 ASE", stdout
);
15411 if (mask
& AFL_ASE_EVA
)
15412 fputs ("\n\tEnhanced VA Scheme", stdout
);
15413 if (mask
& AFL_ASE_MCU
)
15414 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15415 if (mask
& AFL_ASE_MDMX
)
15416 fputs ("\n\tMDMX ASE", stdout
);
15417 if (mask
& AFL_ASE_MIPS3D
)
15418 fputs ("\n\tMIPS-3D ASE", stdout
);
15419 if (mask
& AFL_ASE_MT
)
15420 fputs ("\n\tMT ASE", stdout
);
15421 if (mask
& AFL_ASE_SMARTMIPS
)
15422 fputs ("\n\tSmartMIPS ASE", stdout
);
15423 if (mask
& AFL_ASE_VIRT
)
15424 fputs ("\n\tVZ ASE", stdout
);
15425 if (mask
& AFL_ASE_MSA
)
15426 fputs ("\n\tMSA ASE", stdout
);
15427 if (mask
& AFL_ASE_MIPS16
)
15428 fputs ("\n\tMIPS16 ASE", stdout
);
15429 if (mask
& AFL_ASE_MICROMIPS
)
15430 fputs ("\n\tMICROMIPS ASE", stdout
);
15431 if (mask
& AFL_ASE_XPA
)
15432 fputs ("\n\tXPA ASE", stdout
);
15433 if (mask
& AFL_ASE_MIPS16E2
)
15434 fputs ("\n\tMIPS16e2 ASE", stdout
);
15436 fprintf (stdout
, "\n\t%s", _("None"));
15437 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15438 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15442 print_mips_isa_ext (unsigned int isa_ext
)
15447 fputs (_("None"), stdout
);
15450 fputs ("RMI XLR", stdout
);
15452 case AFL_EXT_OCTEON3
:
15453 fputs ("Cavium Networks Octeon3", stdout
);
15455 case AFL_EXT_OCTEON2
:
15456 fputs ("Cavium Networks Octeon2", stdout
);
15458 case AFL_EXT_OCTEONP
:
15459 fputs ("Cavium Networks OcteonP", stdout
);
15461 case AFL_EXT_LOONGSON_3A
:
15462 fputs ("Loongson 3A", stdout
);
15464 case AFL_EXT_OCTEON
:
15465 fputs ("Cavium Networks Octeon", stdout
);
15468 fputs ("Toshiba R5900", stdout
);
15471 fputs ("MIPS R4650", stdout
);
15474 fputs ("LSI R4010", stdout
);
15477 fputs ("NEC VR4100", stdout
);
15480 fputs ("Toshiba R3900", stdout
);
15482 case AFL_EXT_10000
:
15483 fputs ("MIPS R10000", stdout
);
15486 fputs ("Broadcom SB-1", stdout
);
15489 fputs ("NEC VR4111/VR4181", stdout
);
15492 fputs ("NEC VR4120", stdout
);
15495 fputs ("NEC VR5400", stdout
);
15498 fputs ("NEC VR5500", stdout
);
15500 case AFL_EXT_LOONGSON_2E
:
15501 fputs ("ST Microelectronics Loongson 2E", stdout
);
15503 case AFL_EXT_LOONGSON_2F
:
15504 fputs ("ST Microelectronics Loongson 2F", stdout
);
15506 case AFL_EXT_INTERAPTIV_MR2
:
15507 fputs ("Imagination interAptiv MR2", stdout
);
15510 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15515 get_mips_reg_size (int reg_size
)
15517 return (reg_size
== AFL_REG_NONE
) ? 0
15518 : (reg_size
== AFL_REG_32
) ? 32
15519 : (reg_size
== AFL_REG_64
) ? 64
15520 : (reg_size
== AFL_REG_128
) ? 128
15525 process_mips_specific (Filedata
* filedata
)
15527 Elf_Internal_Dyn
* entry
;
15528 Elf_Internal_Shdr
*sect
= NULL
;
15529 size_t liblist_offset
= 0;
15530 size_t liblistno
= 0;
15531 size_t conflictsno
= 0;
15532 size_t options_offset
= 0;
15533 size_t conflicts_offset
= 0;
15534 size_t pltrelsz
= 0;
15536 bfd_vma pltgot
= 0;
15537 bfd_vma mips_pltgot
= 0;
15538 bfd_vma jmprel
= 0;
15539 bfd_vma local_gotno
= 0;
15540 bfd_vma gotsym
= 0;
15541 bfd_vma symtabno
= 0;
15542 bfd_boolean res
= TRUE
;
15544 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15545 display_mips_gnu_attribute
))
15548 sect
= find_section (filedata
, ".MIPS.abiflags");
15552 Elf_External_ABIFlags_v0
*abiflags_ext
;
15553 Elf_Internal_ABIFlags_v0 abiflags_in
;
15555 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15557 error (_("Corrupt MIPS ABI Flags section.\n"));
15562 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15563 sect
->sh_size
, _("MIPS ABI Flags section"));
15566 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15567 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15568 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15569 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15570 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15571 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15572 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15573 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15574 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15575 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15576 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15578 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15579 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15580 if (abiflags_in
.isa_rev
> 1)
15581 printf ("r%d", abiflags_in
.isa_rev
);
15582 printf ("\nGPR size: %d",
15583 get_mips_reg_size (abiflags_in
.gpr_size
));
15584 printf ("\nCPR1 size: %d",
15585 get_mips_reg_size (abiflags_in
.cpr1_size
));
15586 printf ("\nCPR2 size: %d",
15587 get_mips_reg_size (abiflags_in
.cpr2_size
));
15588 fputs ("\nFP ABI: ", stdout
);
15589 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15590 fputs ("ISA Extension: ", stdout
);
15591 print_mips_isa_ext (abiflags_in
.isa_ext
);
15592 fputs ("\nASEs:", stdout
);
15593 print_mips_ases (abiflags_in
.ases
);
15594 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15595 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15596 fputc ('\n', stdout
);
15597 free (abiflags_ext
);
15602 /* We have a lot of special sections. Thanks SGI! */
15603 if (dynamic_section
== NULL
)
15605 /* No dynamic information available. See if there is static GOT. */
15606 sect
= find_section (filedata
, ".got");
15609 unsigned char *data_end
;
15610 unsigned char *data
;
15614 pltgot
= sect
->sh_addr
;
15617 addr_size
= (is_32bit_elf
? 4 : 8);
15618 end
= pltgot
+ sect
->sh_size
;
15620 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15622 _("Global Offset Table data"));
15623 /* PR 12855: Null data is handled gracefully throughout. */
15624 data_end
= data
+ (end
- pltgot
);
15626 printf (_("\nStatic GOT:\n"));
15627 printf (_(" Canonical gp value: "));
15628 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15631 /* In a dynamic binary GOT[0] is reserved for the dynamic
15632 loader to store the lazy resolver pointer, however in
15633 a static binary it may well have been omitted and GOT
15634 reduced to a table of addresses.
15635 PR 21344: Check for the entry being fully available
15636 before fetching it. */
15638 && data
+ ent
- pltgot
+ addr_size
<= data_end
15639 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15641 printf (_(" Reserved entries:\n"));
15642 printf (_(" %*s %10s %*s\n"),
15643 addr_size
* 2, _("Address"), _("Access"),
15644 addr_size
* 2, _("Value"));
15645 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15647 if (ent
== (bfd_vma
) -1)
15648 goto sgot_print_fail
;
15650 /* Check for the MSB of GOT[1] being set, identifying a
15651 GNU object. This entry will be used by some runtime
15652 loaders, to store the module pointer. Otherwise this
15653 is an ordinary local entry.
15654 PR 21344: Check for the entry being fully available
15655 before fetching it. */
15657 && data
+ ent
- pltgot
+ addr_size
<= data_end
15658 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15659 >> (addr_size
* 8 - 1)) != 0)
15661 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15663 if (ent
== (bfd_vma
) -1)
15664 goto sgot_print_fail
;
15669 if (data
!= NULL
&& ent
< end
)
15671 printf (_(" Local entries:\n"));
15672 printf (" %*s %10s %*s\n",
15673 addr_size
* 2, _("Address"), _("Access"),
15674 addr_size
* 2, _("Value"));
15677 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15679 if (ent
== (bfd_vma
) -1)
15680 goto sgot_print_fail
;
15692 for (entry
= dynamic_section
;
15693 /* PR 17531 file: 012-50589-0.004. */
15694 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15696 switch (entry
->d_tag
)
15698 case DT_MIPS_LIBLIST
:
15700 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15701 liblistno
* sizeof (Elf32_External_Lib
));
15703 case DT_MIPS_LIBLISTNO
:
15704 liblistno
= entry
->d_un
.d_val
;
15706 case DT_MIPS_OPTIONS
:
15707 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15709 case DT_MIPS_CONFLICT
:
15711 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15712 conflictsno
* sizeof (Elf32_External_Conflict
));
15714 case DT_MIPS_CONFLICTNO
:
15715 conflictsno
= entry
->d_un
.d_val
;
15718 pltgot
= entry
->d_un
.d_ptr
;
15720 case DT_MIPS_LOCAL_GOTNO
:
15721 local_gotno
= entry
->d_un
.d_val
;
15723 case DT_MIPS_GOTSYM
:
15724 gotsym
= entry
->d_un
.d_val
;
15726 case DT_MIPS_SYMTABNO
:
15727 symtabno
= entry
->d_un
.d_val
;
15729 case DT_MIPS_PLTGOT
:
15730 mips_pltgot
= entry
->d_un
.d_ptr
;
15733 pltrel
= entry
->d_un
.d_val
;
15736 pltrelsz
= entry
->d_un
.d_val
;
15739 jmprel
= entry
->d_un
.d_ptr
;
15745 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15747 Elf32_External_Lib
* elib
;
15750 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15752 sizeof (Elf32_External_Lib
),
15753 _("liblist section data"));
15756 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15757 "\nSection '.liblist' contains %lu entries:\n",
15758 (unsigned long) liblistno
),
15759 (unsigned long) liblistno
);
15760 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15763 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15770 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15771 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15772 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15773 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15774 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15776 tmp
= gmtime (&atime
);
15777 snprintf (timebuf
, sizeof (timebuf
),
15778 "%04u-%02u-%02uT%02u:%02u:%02u",
15779 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15780 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15782 printf ("%3lu: ", (unsigned long) cnt
);
15783 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15784 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15786 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15787 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15788 liblist
.l_version
);
15790 if (liblist
.l_flags
== 0)
15794 static const struct
15801 { " EXACT_MATCH", LL_EXACT_MATCH
},
15802 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15803 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15804 { " EXPORTS", LL_EXPORTS
},
15805 { " DELAY_LOAD", LL_DELAY_LOAD
},
15806 { " DELTA", LL_DELTA
}
15808 int flags
= liblist
.l_flags
;
15811 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15812 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15814 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15815 flags
^= l_flags_vals
[fcnt
].bit
;
15818 printf (" %#x", (unsigned int) flags
);
15830 if (options_offset
!= 0)
15832 Elf_External_Options
* eopt
;
15833 Elf_Internal_Options
* iopt
;
15834 Elf_Internal_Options
* option
;
15837 sect
= filedata
->section_headers
;
15839 /* Find the section header so that we get the size. */
15840 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
15841 /* PR 17533 file: 012-277276-0.004. */
15844 error (_("No MIPS_OPTIONS header found\n"));
15848 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
15849 sect
->sh_size
, _("options"));
15852 iopt
= (Elf_Internal_Options
*)
15853 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15856 error (_("Out of memory allocating space for MIPS options\n"));
15863 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15865 Elf_External_Options
* eoption
;
15867 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15869 option
->kind
= BYTE_GET (eoption
->kind
);
15870 option
->size
= BYTE_GET (eoption
->size
);
15871 option
->section
= BYTE_GET (eoption
->section
);
15872 option
->info
= BYTE_GET (eoption
->info
);
15874 /* PR 17531: file: ffa0fa3b. */
15875 if (option
->size
< sizeof (* eopt
)
15876 || offset
+ option
->size
> sect
->sh_size
)
15878 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15881 offset
+= option
->size
;
15887 printf (ngettext ("\nSection '%s' contains %d entry:\n",
15888 "\nSection '%s' contains %d entries:\n",
15890 printable_section_name (filedata
, sect
), cnt
);
15899 switch (option
->kind
)
15902 /* This shouldn't happen. */
15903 printf (" NULL %d %lx", option
->section
, option
->info
);
15906 printf (" REGINFO ");
15907 if (filedata
->file_header
.e_machine
== EM_MIPS
)
15910 Elf32_External_RegInfo
* ereg
;
15911 Elf32_RegInfo reginfo
;
15913 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15914 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15915 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15916 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15917 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15918 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15919 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15921 printf ("GPR %08lx GP 0x%lx\n",
15922 reginfo
.ri_gprmask
,
15923 (unsigned long) reginfo
.ri_gp_value
);
15924 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15925 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15926 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15931 Elf64_External_RegInfo
* ereg
;
15932 Elf64_Internal_RegInfo reginfo
;
15934 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15935 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15936 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15937 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15938 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15939 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15940 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15942 printf ("GPR %08lx GP 0x",
15943 reginfo
.ri_gprmask
);
15944 printf_vma (reginfo
.ri_gp_value
);
15947 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15948 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15949 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15953 case ODK_EXCEPTIONS
:
15954 fputs (" EXCEPTIONS fpe_min(", stdout
);
15955 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15956 fputs (") fpe_max(", stdout
);
15957 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15958 fputs (")", stdout
);
15960 if (option
->info
& OEX_PAGE0
)
15961 fputs (" PAGE0", stdout
);
15962 if (option
->info
& OEX_SMM
)
15963 fputs (" SMM", stdout
);
15964 if (option
->info
& OEX_FPDBUG
)
15965 fputs (" FPDBUG", stdout
);
15966 if (option
->info
& OEX_DISMISS
)
15967 fputs (" DISMISS", stdout
);
15970 fputs (" PAD ", stdout
);
15971 if (option
->info
& OPAD_PREFIX
)
15972 fputs (" PREFIX", stdout
);
15973 if (option
->info
& OPAD_POSTFIX
)
15974 fputs (" POSTFIX", stdout
);
15975 if (option
->info
& OPAD_SYMBOL
)
15976 fputs (" SYMBOL", stdout
);
15979 fputs (" HWPATCH ", stdout
);
15980 if (option
->info
& OHW_R4KEOP
)
15981 fputs (" R4KEOP", stdout
);
15982 if (option
->info
& OHW_R8KPFETCH
)
15983 fputs (" R8KPFETCH", stdout
);
15984 if (option
->info
& OHW_R5KEOP
)
15985 fputs (" R5KEOP", stdout
);
15986 if (option
->info
& OHW_R5KCVTL
)
15987 fputs (" R5KCVTL", stdout
);
15990 fputs (" FILL ", stdout
);
15991 /* XXX Print content of info word? */
15994 fputs (" TAGS ", stdout
);
15995 /* XXX Print content of info word? */
15998 fputs (" HWAND ", stdout
);
15999 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16000 fputs (" R4KEOP_CHECKED", stdout
);
16001 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16002 fputs (" R4KEOP_CLEAN", stdout
);
16005 fputs (" HWOR ", stdout
);
16006 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16007 fputs (" R4KEOP_CHECKED", stdout
);
16008 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16009 fputs (" R4KEOP_CLEAN", stdout
);
16012 printf (" GP_GROUP %#06lx self-contained %#06lx",
16013 option
->info
& OGP_GROUP
,
16014 (option
->info
& OGP_SELF
) >> 16);
16017 printf (" IDENT %#06lx self-contained %#06lx",
16018 option
->info
& OGP_GROUP
,
16019 (option
->info
& OGP_SELF
) >> 16);
16022 /* This shouldn't happen. */
16023 printf (" %3d ??? %d %lx",
16024 option
->kind
, option
->section
, option
->info
);
16028 len
= sizeof (* eopt
);
16029 while (len
< option
->size
)
16031 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16033 if (ISPRINT (datum
))
16034 printf ("%c", datum
);
16036 printf ("\\%03o", datum
);
16039 fputs ("\n", stdout
);
16041 offset
+= option
->size
;
16051 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16053 Elf32_Conflict
* iconf
;
16056 if (dynamic_symbols
== NULL
)
16058 error (_("conflict list found without a dynamic symbol table\n"));
16062 /* PR 21345 - print a slightly more helpful error message
16063 if we are sure that the cmalloc will fail. */
16064 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16066 error (_("Overlarge number of conflicts detected: %lx\n"),
16067 (long) conflictsno
);
16071 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16074 error (_("Out of memory allocating space for dynamic conflicts\n"));
16080 Elf32_External_Conflict
* econf32
;
16082 econf32
= (Elf32_External_Conflict
*)
16083 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16084 sizeof (* econf32
), _("conflict"));
16088 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16089 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16095 Elf64_External_Conflict
* econf64
;
16097 econf64
= (Elf64_External_Conflict
*)
16098 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16099 sizeof (* econf64
), _("conflict"));
16103 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16104 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16109 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16110 "\nSection '.conflict' contains %lu entries:\n",
16111 (unsigned long) conflictsno
),
16112 (unsigned long) conflictsno
);
16113 puts (_(" Num: Index Value Name"));
16115 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16117 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16119 if (iconf
[cnt
] >= num_dynamic_syms
)
16120 printf (_("<corrupt symbol index>"));
16123 Elf_Internal_Sym
* psym
;
16125 psym
= & dynamic_symbols
[iconf
[cnt
]];
16126 print_vma (psym
->st_value
, FULL_HEX
);
16128 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16129 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16131 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16139 if (pltgot
!= 0 && local_gotno
!= 0)
16141 bfd_vma ent
, local_end
, global_end
;
16143 unsigned char * data
;
16144 unsigned char * data_end
;
16148 addr_size
= (is_32bit_elf
? 4 : 8);
16149 local_end
= pltgot
+ local_gotno
* addr_size
;
16151 /* PR binutils/17533 file: 012-111227-0.004 */
16152 if (symtabno
< gotsym
)
16154 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16155 (unsigned long) gotsym
, (unsigned long) symtabno
);
16159 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16160 /* PR 17531: file: 54c91a34. */
16161 if (global_end
< local_end
)
16163 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16167 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16168 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16169 global_end
- pltgot
, 1,
16170 _("Global Offset Table data"));
16171 /* PR 12855: Null data is handled gracefully throughout. */
16172 data_end
= data
+ (global_end
- pltgot
);
16174 printf (_("\nPrimary GOT:\n"));
16175 printf (_(" Canonical gp value: "));
16176 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16179 printf (_(" Reserved entries:\n"));
16180 printf (_(" %*s %10s %*s Purpose\n"),
16181 addr_size
* 2, _("Address"), _("Access"),
16182 addr_size
* 2, _("Initial"));
16183 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16184 printf (_(" Lazy resolver\n"));
16185 if (ent
== (bfd_vma
) -1)
16186 goto got_print_fail
;
16188 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16189 This entry will be used by some runtime loaders, to store the
16190 module pointer. Otherwise this is an ordinary local entry.
16191 PR 21344: Check for the entry being fully available before
16194 && data
+ ent
- pltgot
+ addr_size
<= data_end
16195 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16196 >> (addr_size
* 8 - 1)) != 0)
16198 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16199 printf (_(" Module pointer (GNU extension)\n"));
16200 if (ent
== (bfd_vma
) -1)
16201 goto got_print_fail
;
16205 if (data
!= NULL
&& ent
< local_end
)
16207 printf (_(" Local entries:\n"));
16208 printf (" %*s %10s %*s\n",
16209 addr_size
* 2, _("Address"), _("Access"),
16210 addr_size
* 2, _("Initial"));
16211 while (ent
< local_end
)
16213 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16215 if (ent
== (bfd_vma
) -1)
16216 goto got_print_fail
;
16221 if (data
!= NULL
&& gotsym
< symtabno
)
16225 printf (_(" Global entries:\n"));
16226 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16227 addr_size
* 2, _("Address"),
16229 addr_size
* 2, _("Initial"),
16230 addr_size
* 2, _("Sym.Val."),
16232 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16233 _("Ndx"), _("Name"));
16235 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16237 for (i
= gotsym
; i
< symtabno
; i
++)
16239 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16242 if (dynamic_symbols
== NULL
)
16243 printf (_("<no dynamic symbols>"));
16244 else if (i
< num_dynamic_syms
)
16246 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16248 print_vma (psym
->st_value
, LONG_HEX
);
16249 printf (" %-7s %3s ",
16250 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16251 get_symbol_index_type (filedata
, psym
->st_shndx
));
16253 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16254 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16256 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16259 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16260 (unsigned long) i
);
16263 if (ent
== (bfd_vma
) -1)
16274 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16277 size_t offset
, rel_offset
;
16278 unsigned long count
, i
;
16279 unsigned char * data
;
16280 int addr_size
, sym_width
;
16281 Elf_Internal_Rela
* rels
;
16283 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16284 if (pltrel
== DT_RELA
)
16286 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16291 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16296 addr_size
= (is_32bit_elf
? 4 : 8);
16297 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16299 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16300 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16301 1, _("Procedure Linkage Table data"));
16305 printf ("\nPLT GOT:\n\n");
16306 printf (_(" Reserved entries:\n"));
16307 printf (_(" %*s %*s Purpose\n"),
16308 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16309 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16310 printf (_(" PLT lazy resolver\n"));
16311 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16312 printf (_(" Module pointer\n"));
16315 printf (_(" Entries:\n"));
16316 printf (" %*s %*s %*s %-7s %3s %s\n",
16317 addr_size
* 2, _("Address"),
16318 addr_size
* 2, _("Initial"),
16319 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16320 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16321 for (i
= 0; i
< count
; i
++)
16323 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16325 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16328 if (idx
>= num_dynamic_syms
)
16329 printf (_("<corrupt symbol index: %lu>"), idx
);
16332 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16334 print_vma (psym
->st_value
, LONG_HEX
);
16335 printf (" %-7s %3s ",
16336 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16337 get_symbol_index_type (filedata
, psym
->st_shndx
));
16338 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16339 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16341 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16356 process_nds32_specific (Filedata
* filedata
)
16358 Elf_Internal_Shdr
*sect
= NULL
;
16360 sect
= find_section (filedata
, ".nds32_e_flags");
16363 unsigned int *flag
;
16365 printf ("\nNDS32 elf flags section:\n");
16366 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16367 sect
->sh_size
, _("NDS32 elf flags section"));
16372 switch ((*flag
) & 0x3)
16375 printf ("(VEC_SIZE):\tNo entry.\n");
16378 printf ("(VEC_SIZE):\t4 bytes\n");
16381 printf ("(VEC_SIZE):\t16 bytes\n");
16384 printf ("(VEC_SIZE):\treserved\n");
16393 process_gnu_liblist (Filedata
* filedata
)
16395 Elf_Internal_Shdr
* section
;
16396 Elf_Internal_Shdr
* string_sec
;
16397 Elf32_External_Lib
* elib
;
16399 size_t strtab_size
;
16401 unsigned long num_liblist
;
16403 bfd_boolean res
= TRUE
;
16408 for (i
= 0, section
= filedata
->section_headers
;
16409 i
< filedata
->file_header
.e_shnum
;
16412 switch (section
->sh_type
)
16414 case SHT_GNU_LIBLIST
:
16415 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16418 elib
= (Elf32_External_Lib
*)
16419 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16420 _("liblist section data"));
16428 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16429 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16430 string_sec
->sh_size
,
16431 _("liblist string table"));
16433 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16440 strtab_size
= string_sec
->sh_size
;
16442 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16443 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16444 "\nLibrary list section '%s' contains %lu entries:\n",
16446 printable_section_name (filedata
, section
),
16449 puts (_(" Library Time Stamp Checksum Version Flags"));
16451 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16459 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16460 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16461 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16462 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16463 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16465 tmp
= gmtime (&atime
);
16466 snprintf (timebuf
, sizeof (timebuf
),
16467 "%04u-%02u-%02uT%02u:%02u:%02u",
16468 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16469 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16471 printf ("%3lu: ", (unsigned long) cnt
);
16473 printf ("%-20s", liblist
.l_name
< strtab_size
16474 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16476 printf ("%-20.20s", liblist
.l_name
< strtab_size
16477 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16478 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16479 liblist
.l_version
, liblist
.l_flags
);
16490 static const char *
16491 get_note_type (Filedata
* filedata
, unsigned e_type
)
16493 static char buff
[64];
16495 if (filedata
->file_header
.e_type
== ET_CORE
)
16499 return _("NT_AUXV (auxiliary vector)");
16501 return _("NT_PRSTATUS (prstatus structure)");
16503 return _("NT_FPREGSET (floating point registers)");
16505 return _("NT_PRPSINFO (prpsinfo structure)");
16506 case NT_TASKSTRUCT
:
16507 return _("NT_TASKSTRUCT (task structure)");
16509 return _("NT_PRXFPREG (user_xfpregs structure)");
16511 return _("NT_PPC_VMX (ppc Altivec registers)");
16513 return _("NT_PPC_VSX (ppc VSX registers)");
16515 return _("NT_PPC_TAR (ppc TAR register)");
16517 return _("NT_PPC_PPR (ppc PPR register)");
16519 return _("NT_PPC_DSCR (ppc DSCR register)");
16521 return _("NT_PPC_EBB (ppc EBB registers)");
16523 return _("NT_PPC_PMU (ppc PMU registers)");
16524 case NT_PPC_TM_CGPR
:
16525 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16526 case NT_PPC_TM_CFPR
:
16527 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16528 case NT_PPC_TM_CVMX
:
16529 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16530 case NT_PPC_TM_CVSX
:
16531 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16532 case NT_PPC_TM_SPR
:
16533 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16534 case NT_PPC_TM_CTAR
:
16535 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16536 case NT_PPC_TM_CPPR
:
16537 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16538 case NT_PPC_TM_CDSCR
:
16539 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16541 return _("NT_386_TLS (x86 TLS information)");
16542 case NT_386_IOPERM
:
16543 return _("NT_386_IOPERM (x86 I/O permissions)");
16544 case NT_X86_XSTATE
:
16545 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16546 case NT_S390_HIGH_GPRS
:
16547 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16548 case NT_S390_TIMER
:
16549 return _("NT_S390_TIMER (s390 timer register)");
16550 case NT_S390_TODCMP
:
16551 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16552 case NT_S390_TODPREG
:
16553 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16555 return _("NT_S390_CTRS (s390 control registers)");
16556 case NT_S390_PREFIX
:
16557 return _("NT_S390_PREFIX (s390 prefix register)");
16558 case NT_S390_LAST_BREAK
:
16559 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16560 case NT_S390_SYSTEM_CALL
:
16561 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16563 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16564 case NT_S390_VXRS_LOW
:
16565 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16566 case NT_S390_VXRS_HIGH
:
16567 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16568 case NT_S390_GS_CB
:
16569 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16570 case NT_S390_GS_BC
:
16571 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16573 return _("NT_ARM_VFP (arm VFP registers)");
16575 return _("NT_ARM_TLS (AArch TLS registers)");
16576 case NT_ARM_HW_BREAK
:
16577 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16578 case NT_ARM_HW_WATCH
:
16579 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16581 return _("NT_PSTATUS (pstatus structure)");
16583 return _("NT_FPREGS (floating point registers)");
16585 return _("NT_PSINFO (psinfo structure)");
16587 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16589 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16590 case NT_WIN32PSTATUS
:
16591 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16593 return _("NT_SIGINFO (siginfo_t data)");
16595 return _("NT_FILE (mapped files)");
16603 return _("NT_VERSION (version)");
16605 return _("NT_ARCH (architecture)");
16606 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16608 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16614 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16619 print_core_note (Elf_Internal_Note
*pnote
)
16621 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16622 bfd_vma count
, page_size
;
16623 unsigned char *descdata
, *filenames
, *descend
;
16625 if (pnote
->type
!= NT_FILE
)
16635 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16636 /* Still "successful". */
16641 if (pnote
->descsz
< 2 * addr_size
)
16643 error (_(" Malformed note - too short for header\n"));
16647 descdata
= (unsigned char *) pnote
->descdata
;
16648 descend
= descdata
+ pnote
->descsz
;
16650 if (descdata
[pnote
->descsz
- 1] != '\0')
16652 error (_(" Malformed note - does not end with \\0\n"));
16656 count
= byte_get (descdata
, addr_size
);
16657 descdata
+= addr_size
;
16659 page_size
= byte_get (descdata
, addr_size
);
16660 descdata
+= addr_size
;
16662 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16663 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16665 error (_(" Malformed note - too short for supplied file count\n"));
16669 printf (_(" Page size: "));
16670 print_vma (page_size
, DEC
);
16673 printf (_(" %*s%*s%*s\n"),
16674 (int) (2 + 2 * addr_size
), _("Start"),
16675 (int) (4 + 2 * addr_size
), _("End"),
16676 (int) (4 + 2 * addr_size
), _("Page Offset"));
16677 filenames
= descdata
+ count
* 3 * addr_size
;
16678 while (count
-- > 0)
16680 bfd_vma start
, end
, file_ofs
;
16682 if (filenames
== descend
)
16684 error (_(" Malformed note - filenames end too early\n"));
16688 start
= byte_get (descdata
, addr_size
);
16689 descdata
+= addr_size
;
16690 end
= byte_get (descdata
, addr_size
);
16691 descdata
+= addr_size
;
16692 file_ofs
= byte_get (descdata
, addr_size
);
16693 descdata
+= addr_size
;
16696 print_vma (start
, FULL_HEX
);
16698 print_vma (end
, FULL_HEX
);
16700 print_vma (file_ofs
, FULL_HEX
);
16701 printf ("\n %s\n", filenames
);
16703 filenames
+= 1 + strlen ((char *) filenames
);
16709 static const char *
16710 get_gnu_elf_note_type (unsigned e_type
)
16712 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16715 case NT_GNU_ABI_TAG
:
16716 return _("NT_GNU_ABI_TAG (ABI version tag)");
16718 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16719 case NT_GNU_BUILD_ID
:
16720 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16721 case NT_GNU_GOLD_VERSION
:
16722 return _("NT_GNU_GOLD_VERSION (gold version)");
16723 case NT_GNU_PROPERTY_TYPE_0
:
16724 return _("NT_GNU_PROPERTY_TYPE_0");
16725 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16726 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16727 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16728 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16731 static char buff
[64];
16733 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16740 decode_x86_isa (unsigned int bitmask
)
16744 unsigned int bit
= bitmask
& (- bitmask
);
16749 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16750 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16751 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16752 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16753 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16754 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16755 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16756 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16757 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16758 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16759 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16760 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16761 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16762 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16763 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16764 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16765 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16766 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16767 default: printf (_("<unknown: %x>"), bit
); break;
16775 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16779 unsigned int bit
= bitmask
& (- bitmask
);
16784 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16787 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16791 /* This should never happen. */
16795 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16798 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16802 /* This should never happen. */
16807 printf (_("<unknown: %x>"), bit
);
16816 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
16818 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16819 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16820 unsigned int size
= is_32bit_elf
? 4 : 8;
16822 printf (_(" Properties: "));
16824 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16826 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16830 while (ptr
< ptr_end
)
16834 unsigned int datasz
;
16836 if ((size_t) (ptr_end
- ptr
) < 8)
16838 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16842 type
= byte_get (ptr
, 4);
16843 datasz
= byte_get (ptr
+ 4, 4);
16847 if (datasz
> (size_t) (ptr_end
- ptr
))
16849 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16854 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16856 if (filedata
->file_header
.e_machine
== EM_X86_64
16857 || filedata
->file_header
.e_machine
== EM_IAMCU
16858 || filedata
->file_header
.e_machine
== EM_386
)
16862 case GNU_PROPERTY_X86_ISA_1_USED
:
16863 printf ("x86 ISA used: ");
16865 printf (_("<corrupt length: %#x> "), datasz
);
16867 decode_x86_isa (byte_get (ptr
, 4));
16870 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16871 printf ("x86 ISA needed: ");
16873 printf (_("<corrupt length: %#x> "), datasz
);
16875 decode_x86_isa (byte_get (ptr
, 4));
16878 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16879 printf ("x86 feature: ");
16881 printf (_("<corrupt length: %#x> "), datasz
);
16883 decode_x86_feature (type
, byte_get (ptr
, 4));
16895 case GNU_PROPERTY_STACK_SIZE
:
16896 printf (_("stack size: "));
16897 if (datasz
!= size
)
16898 printf (_("<corrupt length: %#x> "), datasz
);
16900 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16903 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16904 printf ("no copy on protected ");
16906 printf (_("<corrupt length: %#x> "), datasz
);
16914 if (type
< GNU_PROPERTY_LOPROC
)
16915 printf (_("<unknown type %#x data: "), type
);
16916 else if (type
< GNU_PROPERTY_LOUSER
)
16917 printf (_("<procesor-specific type %#x data: "), type
);
16919 printf (_("<application-specific type %#x data: "), type
);
16920 for (j
= 0; j
< datasz
; ++j
)
16921 printf ("%02x ", ptr
[j
] & 0xff);
16925 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16926 if (ptr
== ptr_end
)
16939 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
16941 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16942 switch (pnote
->type
)
16944 case NT_GNU_BUILD_ID
:
16948 printf (_(" Build ID: "));
16949 for (i
= 0; i
< pnote
->descsz
; ++i
)
16950 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16955 case NT_GNU_ABI_TAG
:
16957 unsigned long os
, major
, minor
, subminor
;
16958 const char *osname
;
16960 /* PR 17531: file: 030-599401-0.004. */
16961 if (pnote
->descsz
< 16)
16963 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16967 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16968 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16969 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16970 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16974 case GNU_ABI_TAG_LINUX
:
16977 case GNU_ABI_TAG_HURD
:
16980 case GNU_ABI_TAG_SOLARIS
:
16981 osname
= "Solaris";
16983 case GNU_ABI_TAG_FREEBSD
:
16984 osname
= "FreeBSD";
16986 case GNU_ABI_TAG_NETBSD
:
16989 case GNU_ABI_TAG_SYLLABLE
:
16990 osname
= "Syllable";
16992 case GNU_ABI_TAG_NACL
:
16996 osname
= "Unknown";
17000 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17001 major
, minor
, subminor
);
17005 case NT_GNU_GOLD_VERSION
:
17009 printf (_(" Version: "));
17010 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17011 printf ("%c", pnote
->descdata
[i
]);
17018 unsigned long num_entries
, mask
;
17020 /* Hardware capabilities information. Word 0 is the number of entries.
17021 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17022 is a series of entries, where each entry is a single byte followed
17023 by a nul terminated string. The byte gives the bit number to test
17024 if enabled in the bitmask. */
17025 printf (_(" Hardware Capabilities: "));
17026 if (pnote
->descsz
< 8)
17028 error (_("<corrupt GNU_HWCAP>\n"));
17031 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17032 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17033 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17034 /* FIXME: Add code to display the entries... */
17038 case NT_GNU_PROPERTY_TYPE_0
:
17039 print_gnu_property_note (filedata
, pnote
);
17043 /* Handle unrecognised types. An error message should have already been
17044 created by get_gnu_elf_note_type(), so all that we need to do is to
17045 display the data. */
17049 printf (_(" Description data: "));
17050 for (i
= 0; i
< pnote
->descsz
; ++i
)
17051 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17060 static const char *
17061 get_v850_elf_note_type (enum v850_notes n_type
)
17063 static char buff
[64];
17067 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17068 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17069 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17070 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17071 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17072 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17074 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17080 print_v850_note (Elf_Internal_Note
* pnote
)
17084 if (pnote
->descsz
!= 4)
17087 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17091 printf (_("not set\n"));
17095 switch (pnote
->type
)
17097 case V850_NOTE_ALIGNMENT
:
17100 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17101 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17105 case V850_NOTE_DATA_SIZE
:
17108 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17109 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17113 case V850_NOTE_FPU_INFO
:
17116 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17117 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17121 case V850_NOTE_MMU_INFO
:
17122 case V850_NOTE_CACHE_INFO
:
17123 case V850_NOTE_SIMD_INFO
:
17124 if (val
== EF_RH850_SIMD
)
17126 printf (_("yes\n"));
17132 /* An 'unknown note type' message will already have been displayed. */
17136 printf (_("unknown value: %x\n"), val
);
17141 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17143 unsigned int version
;
17145 switch (pnote
->type
)
17147 case NT_NETBSD_IDENT
:
17148 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17149 if ((version
/ 10000) % 100)
17150 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17151 version
, version
/ 100000000, (version
/ 1000000) % 100,
17152 (version
/ 10000) % 100 > 26 ? "Z" : "",
17153 'A' + (version
/ 10000) % 26);
17155 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17156 version
, version
/ 100000000, (version
/ 1000000) % 100,
17157 (version
/ 100) % 100);
17160 case NT_NETBSD_MARCH
:
17161 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17166 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17172 static const char *
17173 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17177 case NT_FREEBSD_THRMISC
:
17178 return _("NT_THRMISC (thrmisc structure)");
17179 case NT_FREEBSD_PROCSTAT_PROC
:
17180 return _("NT_PROCSTAT_PROC (proc data)");
17181 case NT_FREEBSD_PROCSTAT_FILES
:
17182 return _("NT_PROCSTAT_FILES (files data)");
17183 case NT_FREEBSD_PROCSTAT_VMMAP
:
17184 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17185 case NT_FREEBSD_PROCSTAT_GROUPS
:
17186 return _("NT_PROCSTAT_GROUPS (groups data)");
17187 case NT_FREEBSD_PROCSTAT_UMASK
:
17188 return _("NT_PROCSTAT_UMASK (umask data)");
17189 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17190 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17191 case NT_FREEBSD_PROCSTAT_OSREL
:
17192 return _("NT_PROCSTAT_OSREL (osreldate data)");
17193 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17194 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17195 case NT_FREEBSD_PROCSTAT_AUXV
:
17196 return _("NT_PROCSTAT_AUXV (auxv data)");
17197 case NT_FREEBSD_PTLWPINFO
:
17198 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17200 return get_note_type (filedata
, e_type
);
17203 static const char *
17204 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17206 static char buff
[64];
17208 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17209 return _("NetBSD procinfo structure");
17211 /* As of Jan 2002 there are no other machine-independent notes
17212 defined for NetBSD core files. If the note type is less
17213 than the start of the machine-dependent note types, we don't
17216 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17218 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17222 switch (filedata
->file_header
.e_machine
)
17224 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17225 and PT_GETFPREGS == mach+2. */
17230 case EM_SPARC32PLUS
:
17234 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17235 return _("PT_GETREGS (reg structure)");
17236 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17237 return _("PT_GETFPREGS (fpreg structure)");
17243 /* On all other arch's, PT_GETREGS == mach+1 and
17244 PT_GETFPREGS == mach+3. */
17248 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17249 return _("PT_GETREGS (reg structure)");
17250 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17251 return _("PT_GETFPREGS (fpreg structure)");
17257 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17258 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17262 static const char *
17263 get_stapsdt_note_type (unsigned e_type
)
17265 static char buff
[64];
17270 return _("NT_STAPSDT (SystemTap probe descriptors)");
17276 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17281 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17283 int addr_size
= is_32bit_elf
? 4 : 8;
17284 char *data
= pnote
->descdata
;
17285 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17286 bfd_vma pc
, base_addr
, semaphore
;
17287 char *provider
, *probe
, *arg_fmt
;
17289 pc
= byte_get ((unsigned char *) data
, addr_size
);
17291 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17293 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17297 data
+= strlen (data
) + 1;
17299 data
+= strlen (data
) + 1;
17301 data
+= strlen (data
) + 1;
17303 printf (_(" Provider: %s\n"), provider
);
17304 printf (_(" Name: %s\n"), probe
);
17305 printf (_(" Location: "));
17306 print_vma (pc
, FULL_HEX
);
17307 printf (_(", Base: "));
17308 print_vma (base_addr
, FULL_HEX
);
17309 printf (_(", Semaphore: "));
17310 print_vma (semaphore
, FULL_HEX
);
17312 printf (_(" Arguments: %s\n"), arg_fmt
);
17314 return data
== data_end
;
17317 static const char *
17318 get_ia64_vms_note_type (unsigned e_type
)
17320 static char buff
[64];
17325 return _("NT_VMS_MHD (module header)");
17327 return _("NT_VMS_LNM (language name)");
17329 return _("NT_VMS_SRC (source files)");
17331 return "NT_VMS_TITLE";
17333 return _("NT_VMS_EIDC (consistency check)");
17334 case NT_VMS_FPMODE
:
17335 return _("NT_VMS_FPMODE (FP mode)");
17336 case NT_VMS_LINKTIME
:
17337 return "NT_VMS_LINKTIME";
17338 case NT_VMS_IMGNAM
:
17339 return _("NT_VMS_IMGNAM (image name)");
17341 return _("NT_VMS_IMGID (image id)");
17342 case NT_VMS_LINKID
:
17343 return _("NT_VMS_LINKID (link id)");
17344 case NT_VMS_IMGBID
:
17345 return _("NT_VMS_IMGBID (build id)");
17346 case NT_VMS_GSTNAM
:
17347 return _("NT_VMS_GSTNAM (sym table name)");
17348 case NT_VMS_ORIG_DYN
:
17349 return "NT_VMS_ORIG_DYN";
17350 case NT_VMS_PATCHTIME
:
17351 return "NT_VMS_PATCHTIME";
17353 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17359 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17361 switch (pnote
->type
)
17364 if (pnote
->descsz
> 36)
17366 size_t l
= strlen (pnote
->descdata
+ 34);
17367 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17368 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17369 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17370 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17373 printf (_(" Invalid size\n"));
17376 printf (_(" Language: %s\n"), pnote
->descdata
);
17379 case NT_VMS_FPMODE
:
17380 printf (_(" Floating Point mode: "));
17381 printf ("0x%016" BFD_VMA_FMT
"x\n",
17382 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17384 case NT_VMS_LINKTIME
:
17385 printf (_(" Link time: "));
17387 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17390 case NT_VMS_PATCHTIME
:
17391 printf (_(" Patch time: "));
17393 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17396 case NT_VMS_ORIG_DYN
:
17397 printf (_(" Major id: %u, minor id: %u\n"),
17398 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17399 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17400 printf (_(" Last modified : "));
17402 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17403 printf (_("\n Link flags : "));
17404 printf ("0x%016" BFD_VMA_FMT
"x\n",
17405 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17406 printf (_(" Header flags: 0x%08x\n"),
17407 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17408 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17411 case NT_VMS_IMGNAM
:
17412 printf (_(" Image name: %s\n"), pnote
->descdata
);
17414 case NT_VMS_GSTNAM
:
17415 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17418 printf (_(" Image id: %s\n"), pnote
->descdata
);
17420 case NT_VMS_LINKID
:
17421 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17429 /* Find the symbol associated with a build attribute that is attached
17430 to address OFFSET. If PNAME is non-NULL then store the name of
17431 the symbol (if found) in the provided pointer, Returns NULL if a
17432 symbol could not be found. */
17434 static Elf_Internal_Sym
*
17435 get_symbol_for_build_attribute (Filedata
* filedata
,
17436 unsigned long offset
,
17437 bfd_boolean is_open_attr
,
17438 const char ** pname
)
17440 static Filedata
* saved_filedata
= NULL
;
17441 static char * strtab
;
17442 static unsigned long strtablen
;
17443 static Elf_Internal_Sym
* symtab
;
17444 static unsigned long nsyms
;
17445 Elf_Internal_Sym
* saved_sym
= NULL
;
17446 Elf_Internal_Sym
* sym
;
17448 if (filedata
->section_headers
!= NULL
17449 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17451 Elf_Internal_Shdr
* symsec
;
17453 /* Load the symbol and string sections. */
17454 for (symsec
= filedata
->section_headers
;
17455 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17458 if (symsec
->sh_type
== SHT_SYMTAB
)
17460 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17462 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17464 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17466 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17467 1, strtab_sec
->sh_size
,
17468 _("string table"));
17469 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17473 saved_filedata
= filedata
;
17476 if (symtab
== NULL
|| strtab
== NULL
)
17479 /* Find a symbol whose value matches offset. */
17480 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17481 if (sym
->st_value
== offset
)
17483 if (sym
->st_name
>= strtablen
)
17484 /* Huh ? This should not happen. */
17487 if (strtab
[sym
->st_name
] == 0)
17492 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17493 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17494 FUNC symbols entirely. */
17495 switch (ELF_ST_TYPE (sym
->st_info
))
17502 /* If the symbol has a size associated
17503 with it then we can stop searching. */
17504 sym
= symtab
+ nsyms
;
17509 /* Ignore function symbols. */
17516 switch (ELF_ST_BIND (sym
->st_info
))
17519 if (saved_sym
== NULL
17520 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17525 if (saved_sym
== NULL
)
17535 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17543 if (saved_sym
&& pname
)
17544 * pname
= strtab
+ saved_sym
->st_name
;
17550 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17551 Filedata
* filedata
)
17553 static unsigned long global_offset
= 0;
17554 static unsigned long global_end
= 0;
17555 static unsigned long func_offset
= 0;
17556 static unsigned long func_end
= 0;
17558 Elf_Internal_Sym
* sym
;
17560 unsigned long start
;
17562 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17564 switch (pnote
->descsz
)
17567 /* A zero-length description means that the range of
17568 the previous note of the same type should be used. */
17571 if (global_end
> global_offset
)
17572 printf (_(" Applies to region from %#lx to %#lx\n"),
17573 global_offset
, global_end
);
17575 printf (_(" Applies to region from %#lx\n"), global_offset
);
17579 if (func_end
> func_offset
)
17580 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
17582 printf (_(" Applies to region from %#lx\n"), func_offset
);
17587 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17594 /* FIXME: We should check that version 3+ notes are being used here... */
17595 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17596 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17600 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17606 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17607 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
17611 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17612 printf (_(" <invalid descsz>"));
17617 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
17619 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
17620 end
= start
+ sym
->st_size
;
17624 /* FIXME: Need to properly allow for section alignment. 16 is just the alignment used on x86_64. */
17625 if (global_end
> 0 && start
> BFD_ALIGN (global_end
, 16))
17626 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17627 global_end
+ 1, start
- 1);
17629 printf (_(" Applies to region from %#lx"), start
);
17630 global_offset
= start
;
17634 printf (_(" to %#lx"), end
);
17640 printf (_(" Applies to region from %#lx"), start
);
17641 func_offset
= start
;
17645 printf (_(" to %#lx"), end
);
17651 printf (_(" (%s)"), name
);
17658 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17660 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17661 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17662 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17664 char name_attribute
;
17665 const char * expected_types
;
17666 const char * name
= pnote
->namedata
;
17670 if (name
== NULL
|| pnote
->namesz
< 2)
17672 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17673 print_symbol (-20, _(" <corrupt name>"));
17682 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17683 if (name
[0] == 'G' && name
[1] == 'A')
17685 if (pnote
->namesz
< 4)
17687 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17688 print_symbol (-20, _(" <corrupt name>"));
17697 switch ((name_type
= * name
))
17699 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17700 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17701 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17702 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17703 printf ("%c", * name
);
17707 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17708 print_symbol (-20, _("<unknown name type>"));
17715 switch ((name_attribute
= * name
))
17717 case GNU_BUILD_ATTRIBUTE_VERSION
:
17718 text
= _("<version>");
17719 expected_types
= string_expected
;
17722 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17723 text
= _("<stack prot>");
17724 expected_types
= "!+*";
17727 case GNU_BUILD_ATTRIBUTE_RELRO
:
17728 text
= _("<relro>");
17729 expected_types
= bool_expected
;
17732 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17733 text
= _("<stack size>");
17734 expected_types
= number_expected
;
17737 case GNU_BUILD_ATTRIBUTE_TOOL
:
17738 text
= _("<tool>");
17739 expected_types
= string_expected
;
17742 case GNU_BUILD_ATTRIBUTE_ABI
:
17744 expected_types
= "$*";
17747 case GNU_BUILD_ATTRIBUTE_PIC
:
17749 expected_types
= number_expected
;
17752 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17753 text
= _("<short enum>");
17754 expected_types
= bool_expected
;
17758 if (ISPRINT (* name
))
17760 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17762 if (len
> left
&& ! do_wide
)
17764 printf ("%.*s:", len
, name
);
17770 static char tmpbuf
[128];
17772 error (_("unrecognised byte in name field: %d\n"), * name
);
17773 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17777 expected_types
= "*$!+";
17782 left
-= printf ("%s", text
);
17784 if (strchr (expected_types
, name_type
) == NULL
)
17785 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17787 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17789 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17790 (unsigned long) pnote
->namesz
,
17791 (long) (name
- pnote
->namedata
));
17795 if (left
< 1 && ! do_wide
)
17800 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17802 unsigned int bytes
;
17803 unsigned long long val
= 0;
17804 unsigned int shift
= 0;
17805 char * decoded
= NULL
;
17807 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17809 /* The -1 is because the name field is always 0 terminated, and we
17810 want to be able to ensure that the shift in the while loop below
17811 will not overflow. */
17814 if (bytes
> sizeof (val
))
17816 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17818 bytes
= sizeof (val
);
17820 /* We do not bother to warn if bytes == 0 as this can
17821 happen with some early versions of the gcc plugin. */
17825 unsigned long byte
= (* name
++) & 0xff;
17827 val
|= byte
<< shift
;
17831 switch (name_attribute
)
17833 case GNU_BUILD_ATTRIBUTE_PIC
:
17836 case 0: decoded
= "static"; break;
17837 case 1: decoded
= "pic"; break;
17838 case 2: decoded
= "PIC"; break;
17839 case 3: decoded
= "pie"; break;
17840 case 4: decoded
= "PIE"; break;
17844 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17847 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17848 case 0: decoded
= "off"; break;
17849 case 1: decoded
= "on"; break;
17850 case 2: decoded
= "all"; break;
17851 case 3: decoded
= "strong"; break;
17852 case 4: decoded
= "explicit"; break;
17860 if (decoded
!= NULL
)
17862 print_symbol (-left
, decoded
);
17873 left
-= printf ("0x%llx", val
);
17875 left
-= printf ("0x%-.*llx", left
, val
);
17879 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17880 left
-= print_symbol (- left
, name
);
17882 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17883 left
-= print_symbol (- left
, "true");
17885 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17886 left
-= print_symbol (- left
, "false");
17890 if (do_wide
&& left
> 0)
17891 printf ("%-*s", left
, " ");
17896 /* Note that by the ELF standard, the name field is already null byte
17897 terminated, and namesz includes the terminating null byte.
17898 I.E. the value of namesz for the name "FSF" is 4.
17900 If the value of namesz is zero, there is no name present. */
17903 process_note (Elf_Internal_Note
* pnote
,
17904 Filedata
* filedata
)
17906 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17909 if (pnote
->namesz
== 0)
17910 /* If there is no note name, then use the default set of
17911 note type strings. */
17912 nt
= get_note_type (filedata
, pnote
->type
);
17914 else if (const_strneq (pnote
->namedata
, "GNU"))
17915 /* GNU-specific object file notes. */
17916 nt
= get_gnu_elf_note_type (pnote
->type
);
17918 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17919 /* FreeBSD-specific core file notes. */
17920 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
17922 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17923 /* NetBSD-specific core file notes. */
17924 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
17926 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17927 /* NetBSD-specific core file notes. */
17928 return process_netbsd_elf_note (pnote
);
17930 else if (strneq (pnote
->namedata
, "SPU/", 4))
17932 /* SPU-specific core file notes. */
17933 nt
= pnote
->namedata
+ 4;
17937 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17938 /* VMS/ia64-specific file notes. */
17939 nt
= get_ia64_vms_note_type (pnote
->type
);
17941 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17942 nt
= get_stapsdt_note_type (pnote
->type
);
17945 /* Don't recognize this note name; just use the default set of
17946 note type strings. */
17947 nt
= get_note_type (filedata
, pnote
->type
);
17951 if (((const_strneq (pnote
->namedata
, "GA")
17952 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17953 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17954 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17955 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17956 print_gnu_build_attribute_name (pnote
);
17958 print_symbol (-20, name
);
17961 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17963 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17965 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17966 return print_ia64_vms_note (pnote
);
17967 else if (const_strneq (pnote
->namedata
, "GNU"))
17968 return print_gnu_note (filedata
, pnote
);
17969 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17970 return print_stapsdt_note (pnote
);
17971 else if (const_strneq (pnote
->namedata
, "CORE"))
17972 return print_core_note (pnote
);
17973 else if (((const_strneq (pnote
->namedata
, "GA")
17974 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17975 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17976 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17977 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17978 return print_gnu_build_attribute_description (pnote
, filedata
);
17984 printf (_(" description data: "));
17985 for (i
= 0; i
< pnote
->descsz
; i
++)
17986 printf ("%02x ", pnote
->descdata
[i
]);
17998 process_notes_at (Filedata
* filedata
,
17999 Elf_Internal_Shdr
* section
,
18004 Elf_External_Note
* pnotes
;
18005 Elf_External_Note
* external
;
18007 bfd_boolean res
= TRUE
;
18014 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18017 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18022 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18025 if (pnotes
== NULL
)
18031 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18033 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18034 (unsigned long) offset
, (unsigned long) length
);
18036 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18037 specifies that notes should be aligned to 4 bytes in 32-bit
18038 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18039 we also support 4 byte alignment in 64-bit objects. If section
18040 alignment is less than 4, we treate alignment as 4 bytes. */
18043 else if (align
!= 4 && align
!= 8)
18045 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18050 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18052 end
= (char *) pnotes
+ length
;
18053 while ((char *) external
< end
)
18055 Elf_Internal_Note inote
;
18058 char * temp
= NULL
;
18059 size_t data_remaining
= end
- (char *) external
;
18061 if (!is_ia64_vms (filedata
))
18063 /* PR binutils/15191
18064 Make sure that there is enough data to read. */
18065 min_notesz
= offsetof (Elf_External_Note
, name
);
18066 if (data_remaining
< min_notesz
)
18068 warn (ngettext ("Corrupt note: only %ld byte remains, "
18069 "not enough for a full note\n",
18070 "Corrupt note: only %ld bytes remain, "
18071 "not enough for a full note\n",
18073 (long) data_remaining
);
18076 data_remaining
-= min_notesz
;
18078 inote
.type
= BYTE_GET (external
->type
);
18079 inote
.namesz
= BYTE_GET (external
->namesz
);
18080 inote
.namedata
= external
->name
;
18081 inote
.descsz
= BYTE_GET (external
->descsz
);
18082 inote
.descdata
= ((char *) external
18083 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18084 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18085 next
= ((char *) external
18086 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18090 Elf64_External_VMS_Note
*vms_external
;
18092 /* PR binutils/15191
18093 Make sure that there is enough data to read. */
18094 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18095 if (data_remaining
< min_notesz
)
18097 warn (ngettext ("Corrupt note: only %ld byte remains, "
18098 "not enough for a full note\n",
18099 "Corrupt note: only %ld bytes remain, "
18100 "not enough for a full note\n",
18102 (long) data_remaining
);
18105 data_remaining
-= min_notesz
;
18107 vms_external
= (Elf64_External_VMS_Note
*) external
;
18108 inote
.type
= BYTE_GET (vms_external
->type
);
18109 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18110 inote
.namedata
= vms_external
->name
;
18111 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18112 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18113 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18114 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18117 /* PR 17531: file: 3443835e. */
18118 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18119 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18120 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18121 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18122 || ((size_t) (next
- inote
.descdata
)
18123 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18125 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18126 (unsigned long) ((char *) external
- (char *) pnotes
));
18127 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18128 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18132 external
= (Elf_External_Note
*) next
;
18134 /* Verify that name is null terminated. It appears that at least
18135 one version of Linux (RedHat 6.0) generates corefiles that don't
18136 comply with the ELF spec by failing to include the null byte in
18138 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18140 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18142 temp
= (char *) malloc (inote
.namesz
+ 1);
18145 error (_("Out of memory allocating space for inote name\n"));
18150 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18151 inote
.namedata
= temp
;
18153 inote
.namedata
[inote
.namesz
] = 0;
18156 if (! process_note (& inote
, filedata
))
18172 process_corefile_note_segments (Filedata
* filedata
)
18174 Elf_Internal_Phdr
* segment
;
18176 bfd_boolean res
= TRUE
;
18178 if (! get_program_headers (filedata
))
18181 for (i
= 0, segment
= filedata
->program_headers
;
18182 i
< filedata
->file_header
.e_phnum
;
18185 if (segment
->p_type
== PT_NOTE
)
18186 if (! process_notes_at (filedata
, NULL
,
18187 (bfd_vma
) segment
->p_offset
,
18188 (bfd_vma
) segment
->p_filesz
,
18189 (bfd_vma
) segment
->p_align
))
18197 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18199 Elf_External_Note
* pnotes
;
18200 Elf_External_Note
* external
;
18202 bfd_boolean res
= TRUE
;
18207 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18209 if (pnotes
== NULL
)
18213 end
= (char*) pnotes
+ length
;
18215 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18216 (unsigned long) offset
, (unsigned long) length
);
18218 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18220 Elf_External_Note
* next
;
18221 Elf_Internal_Note inote
;
18223 inote
.type
= BYTE_GET (external
->type
);
18224 inote
.namesz
= BYTE_GET (external
->namesz
);
18225 inote
.namedata
= external
->name
;
18226 inote
.descsz
= BYTE_GET (external
->descsz
);
18227 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18228 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18230 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18232 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18233 inote
.descdata
= inote
.namedata
;
18237 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18239 if ( ((char *) next
> end
)
18240 || ((char *) next
< (char *) pnotes
))
18242 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18243 (unsigned long) ((char *) external
- (char *) pnotes
));
18244 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18245 inote
.type
, inote
.namesz
, inote
.descsz
);
18251 /* Prevent out-of-bounds indexing. */
18252 if ( inote
.namedata
+ inote
.namesz
> end
18253 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18255 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18256 (unsigned long) ((char *) external
- (char *) pnotes
));
18257 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18258 inote
.type
, inote
.namesz
, inote
.descsz
);
18262 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18264 if (! print_v850_note (& inote
))
18267 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18268 inote
.namesz
, inote
.descsz
);
18278 process_note_sections (Filedata
* filedata
)
18280 Elf_Internal_Shdr
* section
;
18282 unsigned int n
= 0;
18283 bfd_boolean res
= TRUE
;
18285 for (i
= 0, section
= filedata
->section_headers
;
18286 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18289 if (section
->sh_type
== SHT_NOTE
)
18291 if (! process_notes_at (filedata
, section
,
18292 (bfd_vma
) section
->sh_offset
,
18293 (bfd_vma
) section
->sh_size
,
18294 (bfd_vma
) section
->sh_addralign
))
18299 if (( filedata
->file_header
.e_machine
== EM_V800
18300 || filedata
->file_header
.e_machine
== EM_V850
18301 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18302 && section
->sh_type
== SHT_RENESAS_INFO
)
18304 if (! process_v850_notes (filedata
,
18305 (bfd_vma
) section
->sh_offset
,
18306 (bfd_vma
) section
->sh_size
))
18313 /* Try processing NOTE segments instead. */
18314 return process_corefile_note_segments (filedata
);
18320 process_notes (Filedata
* filedata
)
18322 /* If we have not been asked to display the notes then do nothing. */
18326 if (filedata
->file_header
.e_type
!= ET_CORE
)
18327 return process_note_sections (filedata
);
18329 /* No program headers means no NOTE segment. */
18330 if (filedata
->file_header
.e_phnum
> 0)
18331 return process_corefile_note_segments (filedata
);
18333 printf (_("No note segments present in the core file.\n"));
18337 static unsigned char *
18338 display_public_gnu_attributes (unsigned char * start
,
18339 const unsigned char * const end
)
18341 printf (_(" Unknown GNU attribute: %s\n"), start
);
18343 start
+= strnlen ((char *) start
, end
- start
);
18344 display_raw_attribute (start
, end
);
18346 return (unsigned char *) end
;
18349 static unsigned char *
18350 display_generic_attribute (unsigned char * start
,
18352 const unsigned char * const end
)
18355 return (unsigned char *) end
;
18357 return display_tag_value (tag
, start
, end
);
18361 process_arch_specific (Filedata
* filedata
)
18366 switch (filedata
->file_header
.e_machine
)
18369 case EM_ARC_COMPACT
:
18370 case EM_ARC_COMPACT2
:
18371 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18372 display_arc_attribute
,
18373 display_generic_attribute
);
18375 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18376 display_arm_attribute
,
18377 display_generic_attribute
);
18380 case EM_MIPS_RS3_LE
:
18381 return process_mips_specific (filedata
);
18384 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18385 display_msp430x_attribute
,
18386 display_generic_attribute
);
18389 return process_nds32_specific (filedata
);
18393 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18394 display_power_gnu_attribute
);
18398 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18399 display_s390_gnu_attribute
);
18402 case EM_SPARC32PLUS
:
18404 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18405 display_sparc_gnu_attribute
);
18408 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18409 display_tic6x_attribute
,
18410 display_generic_attribute
);
18413 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18414 display_public_gnu_attributes
,
18415 display_generic_attribute
);
18420 get_file_header (Filedata
* filedata
)
18422 /* Read in the identity array. */
18423 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18426 /* Determine how to read the rest of the header. */
18427 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18432 byte_get
= byte_get_little_endian
;
18433 byte_put
= byte_put_little_endian
;
18436 byte_get
= byte_get_big_endian
;
18437 byte_put
= byte_put_big_endian
;
18441 /* For now we only support 32 bit and 64 bit ELF files. */
18442 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18444 /* Read in the rest of the header. */
18447 Elf32_External_Ehdr ehdr32
;
18449 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18452 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18453 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18454 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18455 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18456 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18457 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18458 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18459 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18460 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18461 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18462 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18463 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18464 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18468 Elf64_External_Ehdr ehdr64
;
18470 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18471 we will not be able to cope with the 64bit data found in
18472 64 ELF files. Detect this now and abort before we start
18473 overwriting things. */
18474 if (sizeof (bfd_vma
) < 8)
18476 error (_("This instance of readelf has been built without support for a\n\
18477 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18481 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18484 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18485 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18486 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18487 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18488 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18489 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18490 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18491 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18492 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18493 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18494 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18495 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18496 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18499 if (filedata
->file_header
.e_shoff
)
18501 /* There may be some extensions in the first section header. Don't
18502 bomb if we can't read it. */
18504 get_32bit_section_headers (filedata
, TRUE
);
18506 get_64bit_section_headers (filedata
, TRUE
);
18513 close_file (Filedata
* filedata
)
18517 if (filedata
->handle
)
18518 fclose (filedata
->handle
);
18524 close_debug_file (void * data
)
18526 close_file ((Filedata
*) data
);
18530 open_file (const char * pathname
)
18532 struct stat statbuf
;
18533 Filedata
* filedata
= NULL
;
18535 if (stat (pathname
, & statbuf
) < 0
18536 || ! S_ISREG (statbuf
.st_mode
))
18539 filedata
= calloc (1, sizeof * filedata
);
18540 if (filedata
== NULL
)
18543 filedata
->handle
= fopen (pathname
, "rb");
18544 if (filedata
->handle
== NULL
)
18547 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
18548 filedata
->file_name
= pathname
;
18550 if (! get_file_header (filedata
))
18553 if (filedata
->file_header
.e_shoff
)
18557 /* Read the section headers again, this time for real. */
18559 res
= get_32bit_section_headers (filedata
, FALSE
);
18561 res
= get_64bit_section_headers (filedata
, FALSE
);
18572 if (filedata
->handle
)
18573 fclose (filedata
->handle
);
18580 open_debug_file (const char * pathname
)
18582 return open_file (pathname
);
18585 /* Process one ELF object file according to the command line options.
18586 This file may actually be stored in an archive. The file is
18587 positioned at the start of the ELF object. Returns TRUE if no
18588 problems were encountered, FALSE otherwise. */
18591 process_object (Filedata
* filedata
)
18593 Filedata
* separates
;
18595 bfd_boolean res
= TRUE
;
18597 if (! get_file_header (filedata
))
18599 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
18603 /* Initialise per file variables. */
18604 for (i
= ARRAY_SIZE (version_info
); i
--;)
18605 version_info
[i
] = 0;
18607 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18608 dynamic_info
[i
] = 0;
18609 dynamic_info_DT_GNU_HASH
= 0;
18611 /* Process the file. */
18613 printf (_("\nFile: %s\n"), filedata
->file_name
);
18615 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18616 Note we do this even if cmdline_dump_sects is empty because we
18617 must make sure that the dump_sets array is zeroed out before each
18618 object file is processed. */
18619 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
18620 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
18622 if (cmdline
.num_dump_sects
> 0)
18624 if (filedata
->num_dump_sects
== 0)
18625 /* A sneaky way of allocating the dump_sects array. */
18626 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
18628 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
18629 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
18630 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
18633 if (! process_file_header (filedata
))
18636 if (! process_section_headers (filedata
))
18638 /* Without loaded section headers we cannot process lots of things. */
18639 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18641 if (! do_using_dynamic
)
18642 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18645 if (! process_section_groups (filedata
))
18646 /* Without loaded section groups we cannot process unwind. */
18649 if (process_program_headers (filedata
))
18650 process_dynamic_section (filedata
);
18654 if (! process_relocs (filedata
))
18657 if (! process_unwind (filedata
))
18660 if (! process_symbol_table (filedata
))
18663 if (! process_syminfo (filedata
))
18666 if (! process_version_sections (filedata
))
18669 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
18670 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
18674 if (! process_section_contents (filedata
))
18679 if (! process_section_headers (separates
))
18681 else if (! process_section_contents (separates
))
18685 if (! process_notes (filedata
))
18688 if (! process_gnu_liblist (filedata
))
18691 if (! process_arch_specific (filedata
))
18694 free (filedata
->program_headers
);
18695 filedata
->program_headers
= NULL
;
18697 free (filedata
->section_headers
);
18698 filedata
->section_headers
= NULL
;
18700 free (filedata
->string_table
);
18701 filedata
->string_table
= NULL
;
18702 filedata
->string_table_length
= 0;
18704 if (dynamic_strings
)
18706 free (dynamic_strings
);
18707 dynamic_strings
= NULL
;
18708 dynamic_strings_length
= 0;
18711 if (dynamic_symbols
)
18713 free (dynamic_symbols
);
18714 dynamic_symbols
= NULL
;
18715 num_dynamic_syms
= 0;
18718 if (dynamic_syminfo
)
18720 free (dynamic_syminfo
);
18721 dynamic_syminfo
= NULL
;
18724 if (dynamic_section
)
18726 free (dynamic_section
);
18727 dynamic_section
= NULL
;
18730 if (section_headers_groups
)
18732 free (section_headers_groups
);
18733 section_headers_groups
= NULL
;
18736 if (section_groups
)
18738 struct group_list
* g
;
18739 struct group_list
* next
;
18741 for (i
= 0; i
< group_count
; i
++)
18743 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18750 free (section_groups
);
18751 section_groups
= NULL
;
18754 free_debug_memory ();
18759 /* Process an ELF archive.
18760 On entry the file is positioned just after the ARMAG string.
18761 Returns TRUE upon success, FALSE otherwise. */
18764 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
18766 struct archive_info arch
;
18767 struct archive_info nested_arch
;
18769 bfd_boolean ret
= TRUE
;
18773 /* The ARCH structure is used to hold information about this archive. */
18774 arch
.file_name
= NULL
;
18776 arch
.index_array
= NULL
;
18777 arch
.sym_table
= NULL
;
18778 arch
.longnames
= NULL
;
18780 /* The NESTED_ARCH structure is used as a single-item cache of information
18781 about a nested archive (when members of a thin archive reside within
18782 another regular archive file). */
18783 nested_arch
.file_name
= NULL
;
18784 nested_arch
.file
= NULL
;
18785 nested_arch
.index_array
= NULL
;
18786 nested_arch
.sym_table
= NULL
;
18787 nested_arch
.longnames
= NULL
;
18789 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
18790 is_thin_archive
, do_archive_index
) != 0)
18796 if (do_archive_index
)
18798 if (arch
.sym_table
== NULL
)
18799 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
18802 unsigned long i
, l
;
18803 unsigned long current_pos
;
18805 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18806 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18808 current_pos
= ftell (filedata
->handle
);
18810 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18812 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18814 char * member_name
;
18816 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18818 if (member_name
!= NULL
)
18820 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18822 if (qualified_name
!= NULL
)
18824 printf (_("Contents of binary %s at offset "), qualified_name
);
18825 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18827 free (qualified_name
);
18832 if (l
>= arch
.sym_size
)
18834 error (_("%s: end of the symbol table reached before the end of the index\n"),
18835 filedata
->file_name
);
18839 /* PR 17531: file: 0b6630b2. */
18840 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18841 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18844 if (arch
.uses_64bit_indicies
)
18849 if (l
< arch
.sym_size
)
18851 error (ngettext ("%s: %ld byte remains in the symbol table, "
18852 "but without corresponding entries in "
18853 "the index table\n",
18854 "%s: %ld bytes remain in the symbol table, "
18855 "but without corresponding entries in "
18856 "the index table\n",
18857 arch
.sym_size
- l
),
18858 filedata
->file_name
, arch
.sym_size
- l
);
18862 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
18864 error (_("%s: failed to seek back to start of object files in the archive\n"),
18865 filedata
->file_name
);
18871 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18872 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18873 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18874 && !do_section_groups
&& !do_dyn_syms
)
18876 ret
= TRUE
; /* Archive index only. */
18885 char * qualified_name
;
18887 /* Read the next archive header. */
18888 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18890 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
18893 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
18894 if (got
!= sizeof arch
.arhdr
)
18898 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
18902 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18904 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18909 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18911 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18912 if (archive_file_size
& 01)
18913 ++archive_file_size
;
18915 name
= get_archive_member_name (&arch
, &nested_arch
);
18918 error (_("%s: bad archive file name\n"), filedata
->file_name
);
18922 namelen
= strlen (name
);
18924 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18925 if (qualified_name
== NULL
)
18927 error (_("%s: bad archive file name\n"), filedata
->file_name
);
18932 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18934 /* This is a proxy for an external member of a thin archive. */
18935 Filedata
* member_filedata
;
18936 char * member_file_name
= adjust_relative_path
18937 (filedata
->file_name
, name
, namelen
);
18939 if (member_file_name
== NULL
)
18945 member_filedata
= open_file (member_file_name
);
18946 if (member_filedata
== NULL
)
18948 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18949 free (member_file_name
);
18954 archive_file_offset
= arch
.nested_member_origin
;
18955 member_filedata
->file_name
= qualified_name
;
18957 if (! process_object (member_filedata
))
18960 close_file (member_filedata
);
18961 free (member_file_name
);
18963 else if (is_thin_archive
)
18965 Filedata thin_filedata
;
18967 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
18969 /* PR 15140: Allow for corrupt thin archives. */
18970 if (nested_arch
.file
== NULL
)
18972 error (_("%s: contains corrupt thin archive: %s\n"),
18973 filedata
->file_name
, name
);
18978 /* This is a proxy for a member of a nested archive. */
18979 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18981 /* The nested archive file will have been opened and setup by
18982 get_archive_member_name. */
18983 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18985 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
18990 thin_filedata
.handle
= nested_arch
.file
;
18991 thin_filedata
.file_name
= qualified_name
;
18993 if (! process_object (& thin_filedata
))
18998 archive_file_offset
= arch
.next_arhdr_offset
;
18999 arch
.next_arhdr_offset
+= archive_file_size
;
19001 filedata
->file_name
= qualified_name
;
19002 if (! process_object (filedata
))
19006 if (filedata
->dump_sects
!= NULL
)
19008 free (filedata
->dump_sects
);
19009 filedata
->dump_sects
= NULL
;
19010 filedata
->num_dump_sects
= 0;
19013 free (qualified_name
);
19017 if (nested_arch
.file
!= NULL
)
19018 fclose (nested_arch
.file
);
19019 release_archive (&nested_arch
);
19020 release_archive (&arch
);
19026 process_file (char * file_name
)
19028 Filedata
* filedata
= NULL
;
19029 struct stat statbuf
;
19030 char armag
[SARMAG
];
19031 bfd_boolean ret
= TRUE
;
19033 if (stat (file_name
, &statbuf
) < 0)
19035 if (errno
== ENOENT
)
19036 error (_("'%s': No such file\n"), file_name
);
19038 error (_("Could not locate '%s'. System error message: %s\n"),
19039 file_name
, strerror (errno
));
19043 if (! S_ISREG (statbuf
.st_mode
))
19045 error (_("'%s' is not an ordinary file\n"), file_name
);
19049 filedata
= calloc (1, sizeof * filedata
);
19050 if (filedata
== NULL
)
19052 error (_("Out of memory allocating file data structure\n"));
19056 filedata
->file_name
= file_name
;
19057 filedata
->handle
= fopen (file_name
, "rb");
19058 if (filedata
->handle
== NULL
)
19060 error (_("Input file '%s' is not readable.\n"), file_name
);
19065 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19067 error (_("%s: Failed to read file's magic number\n"), file_name
);
19068 fclose (filedata
->handle
);
19073 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19075 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19077 if (! process_archive (filedata
, FALSE
))
19080 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19082 if ( ! process_archive (filedata
, TRUE
))
19087 if (do_archive_index
)
19088 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19091 rewind (filedata
->handle
);
19092 archive_file_size
= archive_file_offset
= 0;
19094 if (! process_object (filedata
))
19098 fclose (filedata
->handle
);
19104 #ifdef SUPPORT_DISASSEMBLY
19105 /* Needed by the i386 disassembler. For extra credit, someone could
19106 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19110 print_address (unsigned int addr
, FILE * outfile
)
19112 fprintf (outfile
,"0x%8.8x", addr
);
19115 /* Needed by the i386 disassembler. */
19118 db_task_printsym (unsigned int addr
)
19120 print_address (addr
, stderr
);
19125 main (int argc
, char ** argv
)
19129 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19130 setlocale (LC_MESSAGES
, "");
19132 #if defined (HAVE_SETLOCALE)
19133 setlocale (LC_CTYPE
, "");
19135 bindtextdomain (PACKAGE
, LOCALEDIR
);
19136 textdomain (PACKAGE
);
19138 expandargv (&argc
, &argv
);
19140 cmdline
.file_name
= "<cmdline>";
19141 parse_args (& cmdline
, argc
, argv
);
19143 if (optind
< (argc
- 1))
19145 else if (optind
>= argc
)
19147 warn (_("Nothing to do.\n"));
19152 while (optind
< argc
)
19153 if (! process_file (argv
[optind
++]))
19156 if (cmdline
.dump_sects
!= NULL
)
19157 free (cmdline
.dump_sects
);
19159 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;