1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 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/riscv.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.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 char * program_name
= "readelf";
177 static unsigned long archive_file_offset
;
178 static unsigned long archive_file_size
;
179 static bfd_size_type current_file_size
;
180 static unsigned long dynamic_addr
;
181 static bfd_size_type dynamic_size
;
182 static size_t dynamic_nent
;
183 static char * dynamic_strings
;
184 static unsigned long dynamic_strings_length
;
185 static char * string_table
;
186 static unsigned long string_table_length
;
187 static unsigned long num_dynamic_syms
;
188 static Elf_Internal_Sym
* dynamic_symbols
;
189 static Elf_Internal_Syminfo
* dynamic_syminfo
;
190 static unsigned long dynamic_syminfo_offset
;
191 static unsigned int dynamic_syminfo_nent
;
192 static char program_interpreter
[PATH_MAX
];
193 static bfd_vma dynamic_info
[DT_ENCODING
];
194 static bfd_vma dynamic_info_DT_GNU_HASH
;
195 static bfd_vma version_info
[16];
196 static Elf_Internal_Ehdr elf_header
;
197 static Elf_Internal_Shdr
* section_headers
;
198 static Elf_Internal_Phdr
* program_headers
;
199 static Elf_Internal_Dyn
* dynamic_section
;
200 static elf_section_list
* symtab_shndx_list
;
201 static bfd_boolean show_name
= FALSE
;
202 static bfd_boolean do_dynamic
= FALSE
;
203 static bfd_boolean do_syms
= FALSE
;
204 static bfd_boolean do_dyn_syms
= FALSE
;
205 static bfd_boolean do_reloc
= FALSE
;
206 static bfd_boolean do_sections
= FALSE
;
207 static bfd_boolean do_section_groups
= FALSE
;
208 static bfd_boolean do_section_details
= FALSE
;
209 static bfd_boolean do_segments
= FALSE
;
210 static bfd_boolean do_unwind
= FALSE
;
211 static bfd_boolean do_using_dynamic
= FALSE
;
212 static bfd_boolean do_header
= FALSE
;
213 static bfd_boolean do_dump
= FALSE
;
214 static bfd_boolean do_version
= FALSE
;
215 static bfd_boolean do_histogram
= FALSE
;
216 static bfd_boolean do_debugging
= FALSE
;
217 static bfd_boolean do_arch
= FALSE
;
218 static bfd_boolean do_notes
= FALSE
;
219 static bfd_boolean do_archive_index
= FALSE
;
220 static bfd_boolean is_32bit_elf
= FALSE
;
221 static bfd_boolean decompress_dumps
= FALSE
;
225 struct group_list
* next
;
226 unsigned int section_index
;
231 struct group_list
* root
;
232 unsigned int group_index
;
235 static size_t group_count
;
236 static struct group
* section_groups
;
237 static struct group
** section_headers_groups
;
240 /* Flag bits indicating particular types of dump. */
241 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
242 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
243 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
244 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
245 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
247 typedef unsigned char dump_type
;
249 /* A linked list of the section names for which dumps were requested. */
250 struct dump_list_entry
254 struct dump_list_entry
* next
;
256 static struct dump_list_entry
* dump_sects_byname
;
258 /* A dynamic array of flags indicating for which sections a dump
259 has been requested via command line switches. */
260 static dump_type
* cmdline_dump_sects
= NULL
;
261 static unsigned int num_cmdline_dump_sects
= 0;
263 /* A dynamic array of flags indicating for which sections a dump of
264 some kind has been requested. It is reset on a per-object file
265 basis and then initialised from the cmdline_dump_sects array,
266 the results of interpreting the -w switch, and the
267 dump_sects_byname list. */
268 static dump_type
* dump_sects
= NULL
;
269 static unsigned int num_dump_sects
= 0;
272 /* How to print a vma value. */
273 typedef enum print_mode
285 /* Versioned symbol info. */
286 enum versioned_symbol_info
293 static const char * get_symbol_version_string
294 (FILE *, bfd_boolean
, const char *, unsigned long, unsigned,
295 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
299 #define SECTION_NAME(X) \
300 ((X) == NULL ? _("<none>") \
301 : string_table == NULL ? _("<no-name>") \
302 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
303 : string_table + (X)->sh_name))
305 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
307 #define GET_ELF_SYMBOLS(file, section, sym_count) \
308 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
309 : get_64bit_elf_symbols (file, section, sym_count))
311 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
313 already been called and verified that the string exists. */
314 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
316 #define REMOVE_ARCH_BITS(ADDR) \
319 if (elf_header.e_machine == EM_ARM) \
324 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
325 the offset of the current archive member, if we are examining an archive.
326 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
327 using malloc and fill that. In either case return the pointer to the start of
328 the retrieved data or NULL if something went wrong. If something does go wrong
329 and REASON is not NULL then emit an error message using REASON as part of the
333 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
334 bfd_size_type nmemb
, const char * reason
)
337 bfd_size_type amt
= size
* nmemb
;
339 if (size
== 0 || nmemb
== 0)
342 /* If the size_t type is smaller than the bfd_size_type, eg because
343 you are building a 32-bit tool on a 64-bit host, then make sure
344 that when the sizes are cast to (size_t) no information is lost. */
345 if (sizeof (size_t) < sizeof (bfd_size_type
)
346 && ( (bfd_size_type
) ((size_t) size
) != size
347 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
350 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT
"x"
351 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
352 nmemb
, size
, reason
);
356 /* Check for size overflow. */
360 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT
"x"
361 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
362 nmemb
, size
, reason
);
366 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
367 attempting to allocate memory when the read is bound to fail. */
368 if (amt
> current_file_size
369 || offset
+ archive_file_offset
+ amt
> current_file_size
)
372 error (_("Reading 0x%" BFD_VMA_FMT
"x"
373 " bytes extends past end of file for %s\n"),
378 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
381 error (_("Unable to seek to 0x%lx for %s\n"),
382 archive_file_offset
+ offset
, reason
);
389 /* Check for overflow. */
390 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
391 /* + 1 so that we can '\0' terminate invalid string table sections. */
392 mvar
= malloc ((size_t) amt
+ 1);
397 error (_("Out of memory allocating 0x%" BFD_VMA_FMT
"x"
403 ((char *) mvar
)[amt
] = '\0';
406 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
409 error (_("Unable to read in 0x%" BFD_VMA_FMT
"x bytes of %s\n"),
419 /* Print a VMA value in the MODE specified.
420 Returns the number of characters displayed. */
423 print_vma (bfd_vma vma
, print_mode mode
)
435 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
442 return printf ("%5" BFD_VMA_FMT
"d", vma
);
448 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
451 return printf ("%" BFD_VMA_FMT
"d", vma
);
454 return printf ("%" BFD_VMA_FMT
"u", vma
);
457 /* FIXME: Report unrecognised mode ? */
462 /* Display a symbol on stdout. Handles the display of control characters and
463 multibye characters (assuming the host environment supports them).
465 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
467 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
468 padding as necessary.
470 Returns the number of emitted characters. */
473 print_symbol (signed int width
, const char *symbol
)
475 bfd_boolean extra_padding
= FALSE
;
476 signed int num_printed
= 0;
477 #ifdef HAVE_MBSTATE_T
480 unsigned int width_remaining
;
484 /* Keep the width positive. This helps the code below. */
486 extra_padding
= TRUE
;
491 /* Set the remaining width to a very large value.
492 This simplifies the code below. */
493 width_remaining
= INT_MAX
;
495 width_remaining
= width
;
497 #ifdef HAVE_MBSTATE_T
498 /* Initialise the multibyte conversion state. */
499 memset (& state
, 0, sizeof (state
));
502 while (width_remaining
)
505 const char c
= *symbol
++;
510 /* Do not print control characters directly as they can affect terminal
511 settings. Such characters usually appear in the names generated
512 by the assembler for local labels. */
515 if (width_remaining
< 2)
518 printf ("^%c", c
+ 0x40);
519 width_remaining
-= 2;
522 else if (ISPRINT (c
))
530 #ifdef HAVE_MBSTATE_T
533 /* Let printf do the hard work of displaying multibyte characters. */
534 printf ("%.1s", symbol
- 1);
538 #ifdef HAVE_MBSTATE_T
539 /* Try to find out how many bytes made up the character that was
540 just printed. Advance the symbol pointer past the bytes that
542 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
546 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
551 if (extra_padding
&& num_printed
< width
)
553 /* Fill in the remaining spaces. */
554 printf ("%-*s", width
- num_printed
, " ");
561 /* Returns a pointer to a static buffer containing a printable version of
562 the given section's name. Like print_symbol, except that it does not try
563 to print multibyte characters, it just interprets them as hex values. */
566 printable_section_name (const Elf_Internal_Shdr
* sec
)
568 #define MAX_PRINT_SEC_NAME_LEN 128
569 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
570 const char * name
= SECTION_NAME (sec
);
571 char * buf
= sec_name_buf
;
573 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
575 while ((c
= * name
++) != 0)
586 else if (ISPRINT (c
))
593 static char hex
[17] = "0123456789ABCDEF";
598 * buf
++ = hex
[(c
& 0xf0) >> 4];
599 * buf
++ = hex
[c
& 0x0f];
613 printable_section_name_from_index (unsigned long ndx
)
615 if (ndx
>= elf_header
.e_shnum
)
616 return _("<corrupt>");
618 return printable_section_name (section_headers
+ ndx
);
621 /* Return a pointer to section NAME, or NULL if no such section exists. */
623 static Elf_Internal_Shdr
*
624 find_section (const char * name
)
628 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
629 if (streq (SECTION_NAME (section_headers
+ i
), name
))
630 return section_headers
+ i
;
635 /* Return a pointer to a section containing ADDR, or NULL if no such
638 static Elf_Internal_Shdr
*
639 find_section_by_address (bfd_vma addr
)
643 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
645 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
646 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
653 static Elf_Internal_Shdr
*
654 find_section_by_type (unsigned int type
)
658 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
660 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
661 if (sec
->sh_type
== type
)
668 /* Return a pointer to section NAME, or NULL if no such section exists,
669 restricted to the list of sections given in SET. */
671 static Elf_Internal_Shdr
*
672 find_section_in_set (const char * name
, unsigned int * set
)
678 while ((i
= *set
++) > 0)
680 /* See PR 21156 for a reproducer. */
681 if (i
>= elf_header
.e_shnum
)
682 continue; /* FIXME: Should we issue an error message ? */
684 if (streq (SECTION_NAME (section_headers
+ i
), name
))
685 return section_headers
+ i
;
689 return find_section (name
);
692 /* Read an unsigned LEB128 encoded value from DATA.
693 Set *LENGTH_RETURN to the number of bytes read. */
695 static inline unsigned long
696 read_uleb128 (unsigned char * data
,
697 unsigned int * length_return
,
698 const unsigned char * const end
)
700 return read_leb128 (data
, length_return
, FALSE
, end
);
703 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
704 This OS has so many departures from the ELF standard that we test it at
707 static inline bfd_boolean
710 return elf_header
.e_machine
== EM_IA_64
711 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
714 /* Guess the relocation size commonly used by the specific machines. */
717 guess_is_rela (unsigned int e_machine
)
721 /* Targets that use REL relocations. */
736 /* Targets that use RELA relocations. */
740 case EM_ADAPTEVA_EPIPHANY
:
742 case EM_ALTERA_NIOS2
:
745 case EM_ARC_COMPACT2
:
765 case EM_LATTICEMICO32
:
774 case EM_CYGNUS_MN10200
:
776 case EM_CYGNUS_MN10300
:
812 case EM_MICROBLAZE_OLD
:
834 warn (_("Don't know about relocations on this machine architecture\n"));
839 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
840 Returns TRUE upon success, FALSE otherwise. If successful then a
841 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
842 and the number of relocs loaded is placed in *NRELASP. It is the caller's
843 responsibility to free the allocated buffer. */
846 slurp_rela_relocs (FILE * file
,
847 unsigned long rel_offset
,
848 unsigned long rel_size
,
849 Elf_Internal_Rela
** relasp
,
850 unsigned long * nrelasp
)
852 Elf_Internal_Rela
* relas
;
858 Elf32_External_Rela
* erelas
;
860 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
861 rel_size
, _("32-bit relocation data"));
865 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
867 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
868 sizeof (Elf_Internal_Rela
));
873 error (_("out of memory parsing relocs\n"));
877 for (i
= 0; i
< nrelas
; i
++)
879 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
880 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
881 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
888 Elf64_External_Rela
* erelas
;
890 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
891 rel_size
, _("64-bit relocation data"));
895 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
897 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
898 sizeof (Elf_Internal_Rela
));
903 error (_("out of memory parsing relocs\n"));
907 for (i
= 0; i
< nrelas
; i
++)
909 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
910 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
911 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
913 /* The #ifdef BFD64 below is to prevent a compile time
914 warning. We know that if we do not have a 64 bit data
915 type that we will never execute this code anyway. */
917 if (elf_header
.e_machine
== EM_MIPS
918 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
920 /* In little-endian objects, r_info isn't really a
921 64-bit little-endian value: it has a 32-bit
922 little-endian symbol index followed by four
923 individual byte fields. Reorder INFO
925 bfd_vma inf
= relas
[i
].r_info
;
926 inf
= (((inf
& 0xffffffff) << 32)
927 | ((inf
>> 56) & 0xff)
928 | ((inf
>> 40) & 0xff00)
929 | ((inf
>> 24) & 0xff0000)
930 | ((inf
>> 8) & 0xff000000));
931 relas
[i
].r_info
= inf
;
944 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
945 Returns TRUE upon success, FALSE otherwise. If successful then a
946 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
947 and the number of relocs loaded is placed in *NRELSP. It is the caller's
948 responsibility to free the allocated buffer. */
951 slurp_rel_relocs (FILE * file
,
952 unsigned long rel_offset
,
953 unsigned long rel_size
,
954 Elf_Internal_Rela
** relsp
,
955 unsigned long * nrelsp
)
957 Elf_Internal_Rela
* rels
;
963 Elf32_External_Rel
* erels
;
965 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
966 rel_size
, _("32-bit relocation data"));
970 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
972 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
977 error (_("out of memory parsing relocs\n"));
981 for (i
= 0; i
< nrels
; i
++)
983 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
984 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
985 rels
[i
].r_addend
= 0;
992 Elf64_External_Rel
* erels
;
994 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
995 rel_size
, _("64-bit relocation data"));
999 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1001 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1006 error (_("out of memory parsing relocs\n"));
1010 for (i
= 0; i
< nrels
; i
++)
1012 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1013 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1014 rels
[i
].r_addend
= 0;
1016 /* The #ifdef BFD64 below is to prevent a compile time
1017 warning. We know that if we do not have a 64 bit data
1018 type that we will never execute this code anyway. */
1020 if (elf_header
.e_machine
== EM_MIPS
1021 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1023 /* In little-endian objects, r_info isn't really a
1024 64-bit little-endian value: it has a 32-bit
1025 little-endian symbol index followed by four
1026 individual byte fields. Reorder INFO
1028 bfd_vma inf
= rels
[i
].r_info
;
1029 inf
= (((inf
& 0xffffffff) << 32)
1030 | ((inf
>> 56) & 0xff)
1031 | ((inf
>> 40) & 0xff00)
1032 | ((inf
>> 24) & 0xff0000)
1033 | ((inf
>> 8) & 0xff000000));
1034 rels
[i
].r_info
= inf
;
1047 /* Returns the reloc type extracted from the reloc info field. */
1050 get_reloc_type (bfd_vma reloc_info
)
1053 return ELF32_R_TYPE (reloc_info
);
1055 switch (elf_header
.e_machine
)
1058 /* Note: We assume that reloc_info has already been adjusted for us. */
1059 return ELF64_MIPS_R_TYPE (reloc_info
);
1062 return ELF64_R_TYPE_ID (reloc_info
);
1065 return ELF64_R_TYPE (reloc_info
);
1069 /* Return the symbol index extracted from the reloc info field. */
1072 get_reloc_symindex (bfd_vma reloc_info
)
1074 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1077 static inline bfd_boolean
1078 uses_msp430x_relocs (void)
1081 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1082 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1083 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1084 /* TI compiler uses ELFOSABI_NONE. */
1085 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1088 /* Display the contents of the relocation data found at the specified
1092 dump_relocations (FILE * file
,
1093 unsigned long rel_offset
,
1094 unsigned long rel_size
,
1095 Elf_Internal_Sym
* symtab
,
1096 unsigned long nsyms
,
1098 unsigned long strtablen
,
1100 bfd_boolean is_dynsym
)
1103 Elf_Internal_Rela
* rels
;
1104 bfd_boolean res
= TRUE
;
1106 if (is_rela
== UNKNOWN
)
1107 is_rela
= guess_is_rela (elf_header
.e_machine
);
1111 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1116 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1125 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1127 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1132 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1134 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1142 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1144 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1149 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1151 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1155 for (i
= 0; i
< rel_size
; i
++)
1160 bfd_vma symtab_index
;
1163 offset
= rels
[i
].r_offset
;
1164 inf
= rels
[i
].r_info
;
1166 type
= get_reloc_type (inf
);
1167 symtab_index
= get_reloc_symindex (inf
);
1171 printf ("%8.8lx %8.8lx ",
1172 (unsigned long) offset
& 0xffffffff,
1173 (unsigned long) inf
& 0xffffffff);
1177 #if BFD_HOST_64BIT_LONG
1179 ? "%16.16lx %16.16lx "
1180 : "%12.12lx %12.12lx ",
1182 #elif BFD_HOST_64BIT_LONG_LONG
1185 ? "%16.16llx %16.16llx "
1186 : "%12.12llx %12.12llx ",
1190 ? "%16.16I64x %16.16I64x "
1191 : "%12.12I64x %12.12I64x ",
1196 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1197 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1198 _bfd_int64_high (offset
),
1199 _bfd_int64_low (offset
),
1200 _bfd_int64_high (inf
),
1201 _bfd_int64_low (inf
));
1205 switch (elf_header
.e_machine
)
1212 rtype
= elf_aarch64_reloc_type (type
);
1216 case EM_CYGNUS_M32R
:
1217 rtype
= elf_m32r_reloc_type (type
);
1222 rtype
= elf_i386_reloc_type (type
);
1227 rtype
= elf_m68hc11_reloc_type (type
);
1231 rtype
= elf_m68k_reloc_type (type
);
1235 rtype
= elf_i960_reloc_type (type
);
1240 rtype
= elf_avr_reloc_type (type
);
1243 case EM_OLD_SPARCV9
:
1244 case EM_SPARC32PLUS
:
1247 rtype
= elf_sparc_reloc_type (type
);
1251 rtype
= elf_spu_reloc_type (type
);
1255 rtype
= v800_reloc_type (type
);
1258 case EM_CYGNUS_V850
:
1259 rtype
= v850_reloc_type (type
);
1263 case EM_CYGNUS_D10V
:
1264 rtype
= elf_d10v_reloc_type (type
);
1268 case EM_CYGNUS_D30V
:
1269 rtype
= elf_d30v_reloc_type (type
);
1273 rtype
= elf_dlx_reloc_type (type
);
1277 rtype
= elf_sh_reloc_type (type
);
1281 case EM_CYGNUS_MN10300
:
1282 rtype
= elf_mn10300_reloc_type (type
);
1286 case EM_CYGNUS_MN10200
:
1287 rtype
= elf_mn10200_reloc_type (type
);
1291 case EM_CYGNUS_FR30
:
1292 rtype
= elf_fr30_reloc_type (type
);
1296 rtype
= elf_frv_reloc_type (type
);
1300 rtype
= elf_ft32_reloc_type (type
);
1304 rtype
= elf_mcore_reloc_type (type
);
1308 rtype
= elf_mmix_reloc_type (type
);
1312 rtype
= elf_moxie_reloc_type (type
);
1316 if (uses_msp430x_relocs ())
1318 rtype
= elf_msp430x_reloc_type (type
);
1323 rtype
= elf_msp430_reloc_type (type
);
1327 rtype
= elf_nds32_reloc_type (type
);
1331 rtype
= elf_ppc_reloc_type (type
);
1335 rtype
= elf_ppc64_reloc_type (type
);
1339 case EM_MIPS_RS3_LE
:
1340 rtype
= elf_mips_reloc_type (type
);
1344 rtype
= elf_riscv_reloc_type (type
);
1348 rtype
= elf_alpha_reloc_type (type
);
1352 rtype
= elf_arm_reloc_type (type
);
1356 case EM_ARC_COMPACT
:
1357 case EM_ARC_COMPACT2
:
1358 rtype
= elf_arc_reloc_type (type
);
1362 rtype
= elf_hppa_reloc_type (type
);
1368 rtype
= elf_h8_reloc_type (type
);
1372 rtype
= elf_or1k_reloc_type (type
);
1377 rtype
= elf_pj_reloc_type (type
);
1380 rtype
= elf_ia64_reloc_type (type
);
1384 rtype
= elf_cris_reloc_type (type
);
1388 rtype
= elf_i860_reloc_type (type
);
1394 rtype
= elf_x86_64_reloc_type (type
);
1398 rtype
= i370_reloc_type (type
);
1403 rtype
= elf_s390_reloc_type (type
);
1407 rtype
= elf_score_reloc_type (type
);
1411 rtype
= elf_xstormy16_reloc_type (type
);
1415 rtype
= elf_crx_reloc_type (type
);
1419 rtype
= elf_vax_reloc_type (type
);
1423 rtype
= elf_visium_reloc_type (type
);
1426 case EM_ADAPTEVA_EPIPHANY
:
1427 rtype
= elf_epiphany_reloc_type (type
);
1432 rtype
= elf_ip2k_reloc_type (type
);
1436 rtype
= elf_iq2000_reloc_type (type
);
1441 rtype
= elf_xtensa_reloc_type (type
);
1444 case EM_LATTICEMICO32
:
1445 rtype
= elf_lm32_reloc_type (type
);
1450 rtype
= elf_m32c_reloc_type (type
);
1454 rtype
= elf_mt_reloc_type (type
);
1458 rtype
= elf_bfin_reloc_type (type
);
1462 rtype
= elf_mep_reloc_type (type
);
1466 rtype
= elf_cr16_reloc_type (type
);
1470 case EM_MICROBLAZE_OLD
:
1471 rtype
= elf_microblaze_reloc_type (type
);
1475 rtype
= elf_rl78_reloc_type (type
);
1479 rtype
= elf_rx_reloc_type (type
);
1483 rtype
= elf_metag_reloc_type (type
);
1488 rtype
= elf_xc16x_reloc_type (type
);
1492 rtype
= elf_tic6x_reloc_type (type
);
1496 rtype
= elf_tilegx_reloc_type (type
);
1500 rtype
= elf_tilepro_reloc_type (type
);
1503 case EM_WEBASSEMBLY
:
1504 rtype
= elf_wasm32_reloc_type (type
);
1508 rtype
= elf_xgate_reloc_type (type
);
1511 case EM_ALTERA_NIOS2
:
1512 rtype
= elf_nios2_reloc_type (type
);
1516 rtype
= elf_pru_reloc_type (type
);
1521 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1523 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1525 if (elf_header
.e_machine
== EM_ALPHA
1527 && streq (rtype
, "R_ALPHA_LITUSE")
1530 switch (rels
[i
].r_addend
)
1532 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1533 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1534 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1535 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1536 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1537 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1538 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1539 default: rtype
= NULL
;
1543 printf (" (%s)", rtype
);
1547 printf (_("<unknown addend: %lx>"),
1548 (unsigned long) rels
[i
].r_addend
);
1552 else if (symtab_index
)
1554 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1556 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1561 Elf_Internal_Sym
* psym
;
1562 const char * version_string
;
1563 enum versioned_symbol_info sym_info
;
1564 unsigned short vna_other
;
1566 psym
= symtab
+ symtab_index
;
1569 = get_symbol_version_string (file
, is_dynsym
,
1578 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1582 unsigned int width
= is_32bit_elf
? 8 : 14;
1584 /* Relocations against GNU_IFUNC symbols do not use the value
1585 of the symbol as the address to relocate against. Instead
1586 they invoke the function named by the symbol and use its
1587 result as the address for relocation.
1589 To indicate this to the user, do not display the value of
1590 the symbol in the "Symbols's Value" field. Instead show
1591 its name followed by () as a hint that the symbol is
1595 || psym
->st_name
== 0
1596 || psym
->st_name
>= strtablen
)
1599 name
= strtab
+ psym
->st_name
;
1601 len
= print_symbol (width
, name
);
1603 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1605 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1609 print_vma (psym
->st_value
, LONG_HEX
);
1611 printf (is_32bit_elf
? " " : " ");
1614 if (psym
->st_name
== 0)
1616 const char * sec_name
= "<null>";
1619 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1621 if (psym
->st_shndx
< elf_header
.e_shnum
)
1622 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1623 else if (psym
->st_shndx
== SHN_ABS
)
1625 else if (psym
->st_shndx
== SHN_COMMON
)
1626 sec_name
= "COMMON";
1627 else if ((elf_header
.e_machine
== EM_MIPS
1628 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1629 || (elf_header
.e_machine
== EM_TI_C6000
1630 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1631 sec_name
= "SCOMMON";
1632 else if (elf_header
.e_machine
== EM_MIPS
1633 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1634 sec_name
= "SUNDEF";
1635 else if ((elf_header
.e_machine
== EM_X86_64
1636 || elf_header
.e_machine
== EM_L1OM
1637 || elf_header
.e_machine
== EM_K1OM
)
1638 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1639 sec_name
= "LARGE_COMMON";
1640 else if (elf_header
.e_machine
== EM_IA_64
1641 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1642 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1643 sec_name
= "ANSI_COM";
1644 else if (is_ia64_vms ()
1645 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1646 sec_name
= "VMS_SYMVEC";
1649 sprintf (name_buf
, "<section 0x%x>",
1650 (unsigned int) psym
->st_shndx
);
1651 sec_name
= name_buf
;
1654 print_symbol (22, sec_name
);
1656 else if (strtab
== NULL
)
1657 printf (_("<string table index: %3ld>"), psym
->st_name
);
1658 else if (psym
->st_name
>= strtablen
)
1660 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1665 print_symbol (22, strtab
+ psym
->st_name
);
1667 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1673 bfd_vma off
= rels
[i
].r_addend
;
1675 if ((bfd_signed_vma
) off
< 0)
1676 printf (" - %" BFD_VMA_FMT
"x", - off
);
1678 printf (" + %" BFD_VMA_FMT
"x", off
);
1684 bfd_vma off
= rels
[i
].r_addend
;
1686 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1687 if ((bfd_signed_vma
) off
< 0)
1688 printf ("-%" BFD_VMA_FMT
"x", - off
);
1690 printf ("%" BFD_VMA_FMT
"x", off
);
1693 if (elf_header
.e_machine
== EM_SPARCV9
1695 && streq (rtype
, "R_SPARC_OLO10"))
1696 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1701 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1703 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1704 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1705 const char * rtype2
= elf_mips_reloc_type (type2
);
1706 const char * rtype3
= elf_mips_reloc_type (type3
);
1708 printf (" Type2: ");
1711 printf (_("unrecognized: %-7lx"),
1712 (unsigned long) type2
& 0xffffffff);
1714 printf ("%-17.17s", rtype2
);
1716 printf ("\n Type3: ");
1719 printf (_("unrecognized: %-7lx"),
1720 (unsigned long) type3
& 0xffffffff);
1722 printf ("%-17.17s", rtype3
);
1735 get_mips_dynamic_type (unsigned long type
)
1739 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1740 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1741 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1742 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1743 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1744 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1745 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1746 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1747 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1748 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1749 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1750 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1751 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1752 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1753 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1754 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1755 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1756 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1757 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1758 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1759 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1760 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1761 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1762 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1763 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1764 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1765 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1766 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1767 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1768 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1769 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1770 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1771 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1772 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1773 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1774 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1775 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1776 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1777 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1778 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1779 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1780 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1781 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1782 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1783 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1784 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1791 get_sparc64_dynamic_type (unsigned long type
)
1795 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1802 get_ppc_dynamic_type (unsigned long type
)
1806 case DT_PPC_GOT
: return "PPC_GOT";
1807 case DT_PPC_OPT
: return "PPC_OPT";
1814 get_ppc64_dynamic_type (unsigned long type
)
1818 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1819 case DT_PPC64_OPD
: return "PPC64_OPD";
1820 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1821 case DT_PPC64_OPT
: return "PPC64_OPT";
1828 get_parisc_dynamic_type (unsigned long type
)
1832 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1833 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1834 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1835 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1836 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1837 case DT_HP_PREINIT
: return "HP_PREINIT";
1838 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1839 case DT_HP_NEEDED
: return "HP_NEEDED";
1840 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1841 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1842 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1843 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1844 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1845 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1846 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1847 case DT_HP_FILTERED
: return "HP_FILTERED";
1848 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1849 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1850 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1851 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1852 case DT_PLT
: return "PLT";
1853 case DT_PLT_SIZE
: return "PLT_SIZE";
1854 case DT_DLT
: return "DLT";
1855 case DT_DLT_SIZE
: return "DLT_SIZE";
1862 get_ia64_dynamic_type (unsigned long type
)
1866 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1867 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1868 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1869 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1870 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1871 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1872 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1873 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1874 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1875 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1876 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1877 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1878 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1879 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1880 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1881 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1882 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1883 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1884 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1885 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1886 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1887 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1888 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1889 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1890 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1891 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1892 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1893 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1894 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1895 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1896 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1903 get_solaris_section_type (unsigned long type
)
1907 case 0x6fffffee: return "SUNW_ancillary";
1908 case 0x6fffffef: return "SUNW_capchain";
1909 case 0x6ffffff0: return "SUNW_capinfo";
1910 case 0x6ffffff1: return "SUNW_symsort";
1911 case 0x6ffffff2: return "SUNW_tlssort";
1912 case 0x6ffffff3: return "SUNW_LDYNSYM";
1913 case 0x6ffffff4: return "SUNW_dof";
1914 case 0x6ffffff5: return "SUNW_cap";
1915 case 0x6ffffff6: return "SUNW_SIGNATURE";
1916 case 0x6ffffff7: return "SUNW_ANNOTATE";
1917 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1918 case 0x6ffffff9: return "SUNW_DEBUG";
1919 case 0x6ffffffa: return "SUNW_move";
1920 case 0x6ffffffb: return "SUNW_COMDAT";
1921 case 0x6ffffffc: return "SUNW_syminfo";
1922 case 0x6ffffffd: return "SUNW_verdef";
1923 case 0x6ffffffe: return "SUNW_verneed";
1924 case 0x6fffffff: return "SUNW_versym";
1925 case 0x70000000: return "SPARC_GOTDATA";
1926 default: return NULL
;
1931 get_alpha_dynamic_type (unsigned long type
)
1935 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1936 default: return NULL
;
1941 get_score_dynamic_type (unsigned long type
)
1945 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1946 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1947 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1948 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1949 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1950 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1951 default: return NULL
;
1956 get_tic6x_dynamic_type (unsigned long type
)
1960 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1961 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1962 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1963 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1964 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1965 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1966 default: return NULL
;
1971 get_nios2_dynamic_type (unsigned long type
)
1975 case DT_NIOS2_GP
: return "NIOS2_GP";
1976 default: return NULL
;
1981 get_solaris_dynamic_type (unsigned long type
)
1985 case 0x6000000d: return "SUNW_AUXILIARY";
1986 case 0x6000000e: return "SUNW_RTLDINF";
1987 case 0x6000000f: return "SUNW_FILTER";
1988 case 0x60000010: return "SUNW_CAP";
1989 case 0x60000011: return "SUNW_SYMTAB";
1990 case 0x60000012: return "SUNW_SYMSZ";
1991 case 0x60000013: return "SUNW_SORTENT";
1992 case 0x60000014: return "SUNW_SYMSORT";
1993 case 0x60000015: return "SUNW_SYMSORTSZ";
1994 case 0x60000016: return "SUNW_TLSSORT";
1995 case 0x60000017: return "SUNW_TLSSORTSZ";
1996 case 0x60000018: return "SUNW_CAPINFO";
1997 case 0x60000019: return "SUNW_STRPAD";
1998 case 0x6000001a: return "SUNW_CAPCHAIN";
1999 case 0x6000001b: return "SUNW_LDMACH";
2000 case 0x6000001d: return "SUNW_CAPCHAINENT";
2001 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2002 case 0x60000021: return "SUNW_PARENT";
2003 case 0x60000023: return "SUNW_ASLR";
2004 case 0x60000025: return "SUNW_RELAX";
2005 case 0x60000029: return "SUNW_NXHEAP";
2006 case 0x6000002b: return "SUNW_NXSTACK";
2008 case 0x70000001: return "SPARC_REGISTER";
2009 case 0x7ffffffd: return "AUXILIARY";
2010 case 0x7ffffffe: return "USED";
2011 case 0x7fffffff: return "FILTER";
2013 default: return NULL
;
2018 get_dynamic_type (unsigned long type
)
2020 static char buff
[64];
2024 case DT_NULL
: return "NULL";
2025 case DT_NEEDED
: return "NEEDED";
2026 case DT_PLTRELSZ
: return "PLTRELSZ";
2027 case DT_PLTGOT
: return "PLTGOT";
2028 case DT_HASH
: return "HASH";
2029 case DT_STRTAB
: return "STRTAB";
2030 case DT_SYMTAB
: return "SYMTAB";
2031 case DT_RELA
: return "RELA";
2032 case DT_RELASZ
: return "RELASZ";
2033 case DT_RELAENT
: return "RELAENT";
2034 case DT_STRSZ
: return "STRSZ";
2035 case DT_SYMENT
: return "SYMENT";
2036 case DT_INIT
: return "INIT";
2037 case DT_FINI
: return "FINI";
2038 case DT_SONAME
: return "SONAME";
2039 case DT_RPATH
: return "RPATH";
2040 case DT_SYMBOLIC
: return "SYMBOLIC";
2041 case DT_REL
: return "REL";
2042 case DT_RELSZ
: return "RELSZ";
2043 case DT_RELENT
: return "RELENT";
2044 case DT_PLTREL
: return "PLTREL";
2045 case DT_DEBUG
: return "DEBUG";
2046 case DT_TEXTREL
: return "TEXTREL";
2047 case DT_JMPREL
: return "JMPREL";
2048 case DT_BIND_NOW
: return "BIND_NOW";
2049 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2050 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2051 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2052 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2053 case DT_RUNPATH
: return "RUNPATH";
2054 case DT_FLAGS
: return "FLAGS";
2056 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2057 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2058 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2060 case DT_CHECKSUM
: return "CHECKSUM";
2061 case DT_PLTPADSZ
: return "PLTPADSZ";
2062 case DT_MOVEENT
: return "MOVEENT";
2063 case DT_MOVESZ
: return "MOVESZ";
2064 case DT_FEATURE
: return "FEATURE";
2065 case DT_POSFLAG_1
: return "POSFLAG_1";
2066 case DT_SYMINSZ
: return "SYMINSZ";
2067 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2069 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2070 case DT_CONFIG
: return "CONFIG";
2071 case DT_DEPAUDIT
: return "DEPAUDIT";
2072 case DT_AUDIT
: return "AUDIT";
2073 case DT_PLTPAD
: return "PLTPAD";
2074 case DT_MOVETAB
: return "MOVETAB";
2075 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2077 case DT_VERSYM
: return "VERSYM";
2079 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2080 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2081 case DT_RELACOUNT
: return "RELACOUNT";
2082 case DT_RELCOUNT
: return "RELCOUNT";
2083 case DT_FLAGS_1
: return "FLAGS_1";
2084 case DT_VERDEF
: return "VERDEF";
2085 case DT_VERDEFNUM
: return "VERDEFNUM";
2086 case DT_VERNEED
: return "VERNEED";
2087 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2089 case DT_AUXILIARY
: return "AUXILIARY";
2090 case DT_USED
: return "USED";
2091 case DT_FILTER
: return "FILTER";
2093 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2094 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2095 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2096 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2097 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2098 case DT_GNU_HASH
: return "GNU_HASH";
2101 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2103 const char * result
;
2105 switch (elf_header
.e_machine
)
2108 case EM_MIPS_RS3_LE
:
2109 result
= get_mips_dynamic_type (type
);
2112 result
= get_sparc64_dynamic_type (type
);
2115 result
= get_ppc_dynamic_type (type
);
2118 result
= get_ppc64_dynamic_type (type
);
2121 result
= get_ia64_dynamic_type (type
);
2124 result
= get_alpha_dynamic_type (type
);
2127 result
= get_score_dynamic_type (type
);
2130 result
= get_tic6x_dynamic_type (type
);
2132 case EM_ALTERA_NIOS2
:
2133 result
= get_nios2_dynamic_type (type
);
2136 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2137 result
= get_solaris_dynamic_type (type
);
2146 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2148 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2149 || (elf_header
.e_machine
== EM_PARISC
2150 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2152 const char * result
;
2154 switch (elf_header
.e_machine
)
2157 result
= get_parisc_dynamic_type (type
);
2160 result
= get_ia64_dynamic_type (type
);
2163 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2164 result
= get_solaris_dynamic_type (type
);
2173 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2177 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2184 get_file_type (unsigned e_type
)
2186 static char buff
[32];
2190 case ET_NONE
: return _("NONE (None)");
2191 case ET_REL
: return _("REL (Relocatable file)");
2192 case ET_EXEC
: return _("EXEC (Executable file)");
2193 case ET_DYN
: return _("DYN (Shared object file)");
2194 case ET_CORE
: return _("CORE (Core file)");
2197 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2198 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2199 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2200 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2202 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2208 get_machine_name (unsigned e_machine
)
2210 static char buff
[64]; /* XXX */
2214 /* Please keep this switch table sorted by increasing EM_ value. */
2216 case EM_NONE
: return _("None");
2217 case EM_M32
: return "WE32100";
2218 case EM_SPARC
: return "Sparc";
2219 case EM_386
: return "Intel 80386";
2220 case EM_68K
: return "MC68000";
2221 case EM_88K
: return "MC88000";
2222 case EM_IAMCU
: return "Intel MCU";
2223 case EM_860
: return "Intel 80860";
2224 case EM_MIPS
: return "MIPS R3000";
2225 case EM_S370
: return "IBM System/370";
2227 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2228 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2229 case EM_PARISC
: return "HPPA";
2230 case EM_VPP550
: return "Fujitsu VPP500";
2231 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2232 case EM_960
: return "Intel 90860";
2233 case EM_PPC
: return "PowerPC";
2235 case EM_PPC64
: return "PowerPC64";
2237 case EM_S390
: return "IBM S/390";
2238 case EM_SPU
: return "SPU";
2240 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2241 case EM_FR20
: return "Fujitsu FR20";
2242 case EM_RH32
: return "TRW RH32";
2243 case EM_MCORE
: return "MCORE";
2245 case EM_ARM
: return "ARM";
2246 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2247 case EM_SH
: return "Renesas / SuperH SH";
2248 case EM_SPARCV9
: return "Sparc v9";
2249 case EM_TRICORE
: return "Siemens Tricore";
2250 case EM_ARC
: return "ARC";
2251 case EM_H8_300
: return "Renesas H8/300";
2252 case EM_H8_300H
: return "Renesas H8/300H";
2253 case EM_H8S
: return "Renesas H8S";
2254 case EM_H8_500
: return "Renesas H8/500";
2256 case EM_IA_64
: return "Intel IA-64";
2257 case EM_MIPS_X
: return "Stanford MIPS-X";
2258 case EM_COLDFIRE
: return "Motorola Coldfire";
2259 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2260 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2261 case EM_PCP
: return "Siemens PCP";
2262 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2263 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2264 case EM_STARCORE
: return "Motorola Star*Core processor";
2265 case EM_ME16
: return "Toyota ME16 processor";
2267 case EM_ST100
: return "STMicroelectronics ST100 processor";
2268 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2269 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2270 case EM_PDSP
: return "Sony DSP processor";
2271 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2272 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2273 case EM_FX66
: return "Siemens FX66 microcontroller";
2274 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2275 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2276 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2278 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2279 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2280 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2281 case EM_SVX
: return "Silicon Graphics SVx";
2282 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2283 case EM_VAX
: return "Digital VAX";
2284 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2285 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2286 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2287 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2289 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2290 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2291 case EM_PRISM
: return "Vitesse Prism";
2293 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2294 case EM_CYGNUS_FR30
:
2295 case EM_FR30
: return "Fujitsu FR30";
2296 case EM_CYGNUS_D10V
:
2297 case EM_D10V
: return "d10v";
2298 case EM_CYGNUS_D30V
:
2299 case EM_D30V
: return "d30v";
2300 case EM_CYGNUS_V850
:
2301 case EM_V850
: return "Renesas V850";
2302 case EM_CYGNUS_M32R
:
2303 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2304 case EM_CYGNUS_MN10300
:
2305 case EM_MN10300
: return "mn10300";
2307 case EM_CYGNUS_MN10200
:
2308 case EM_MN10200
: return "mn10200";
2309 case EM_PJ
: return "picoJava";
2310 case EM_OR1K
: return "OpenRISC 1000";
2311 case EM_ARC_COMPACT
: return "ARCompact";
2313 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2314 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2315 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2316 case EM_NS32K
: return "National Semiconductor 32000 series";
2317 case EM_TPC
: return "Tenor Network TPC processor";
2318 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2320 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2322 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2323 case EM_MAX
: return "MAX Processor";
2324 case EM_CR
: return "National Semiconductor CompactRISC";
2325 case EM_F2MC16
: return "Fujitsu F2MC16";
2326 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2327 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2328 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2329 case EM_SEP
: return "Sharp embedded microprocessor";
2330 case EM_ARCA
: return "Arca RISC microprocessor";
2332 case EM_UNICORE
: return "Unicore";
2333 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2334 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2335 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2336 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2337 case EM_XGATE
: return "Motorola XGATE embedded processor";
2339 case EM_XC16X
: return "Infineon Technologies xc16x";
2340 case EM_M16C
: return "Renesas M16C series microprocessors";
2341 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2342 case EM_CE
: return "Freescale Communication Engine RISC core";
2344 case EM_M32C
: return "Renesas M32c";
2346 case EM_TSK3000
: return "Altium TSK3000 core";
2347 case EM_RS08
: return "Freescale RS08 embedded processor";
2348 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2349 case EM_SCORE
: return "SUNPLUS S+Core";
2350 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2351 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2352 case EM_LATTICEMICO32
: return "Lattice Mico32";
2353 case EM_SE_C17
: return "Seiko Epson C17 family";
2355 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2356 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2357 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2358 case EM_TI_PRU
: return "TI PRU I/O processor";
2360 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2361 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2362 case EM_R32C
: return "Renesas R32C series microprocessors";
2363 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2364 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2365 case EM_8051
: return "Intel 8051 and variants";
2366 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2367 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2368 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2369 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2371 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2372 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2373 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2374 case EM_RX
: return "Renesas RX";
2375 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2376 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2377 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2380 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2381 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2382 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2384 case EM_L1OM
: return "Intel L1OM";
2385 case EM_K1OM
: return "Intel K1OM";
2386 case EM_INTEL182
: return "Intel (reserved)";
2387 case EM_AARCH64
: return "AArch64";
2388 case EM_ARM184
: return "ARM (reserved)";
2389 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2390 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2391 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2392 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2394 case EM_CUDA
: return "NVIDIA CUDA architecture";
2395 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2396 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2397 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2398 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2399 case EM_ARC_COMPACT2
: return "ARCv2";
2400 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2401 case EM_RL78
: return "Renesas RL78";
2402 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2403 case EM_78K0R
: return "Renesas 78K0R";
2405 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2406 case EM_BA1
: return "Beyond BA1 CPU architecture";
2407 case EM_BA2
: return "Beyond BA2 CPU architecture";
2408 case EM_XCORE
: return "XMOS xCORE processor family";
2409 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2411 case EM_KM32
: return "KM211 KM32 32-bit processor";
2412 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2413 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2414 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2415 case EM_KVARC
: return "KM211 KVARC processor";
2416 case EM_CDP
: return "Paneve CDP architecture family";
2417 case EM_COGE
: return "Cognitive Smart Memory Processor";
2418 case EM_COOL
: return "Bluechip Systems CoolEngine";
2419 case EM_NORC
: return "Nanoradio Optimized RISC";
2420 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2422 case EM_Z80
: return "Zilog Z80";
2423 case EM_VISIUM
: return "CDS VISIUMcore processor";
2424 case EM_FT32
: return "FTDI Chip FT32";
2425 case EM_MOXIE
: return "Moxie";
2426 case EM_AMDGPU
: return "AMD GPU";
2427 case EM_RISCV
: return "RISC-V";
2428 case EM_LANAI
: return "Lanai 32-bit processor";
2429 case EM_BPF
: return "Linux BPF";
2431 /* Large numbers... */
2432 case EM_MT
: return "Morpho Techologies MT processor";
2433 case EM_ALPHA
: return "Alpha";
2434 case EM_WEBASSEMBLY
: return "Web Assembly";
2435 case EM_DLX
: return "OpenDLX";
2436 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2437 case EM_IQ2000
: return "Vitesse IQ2000";
2439 case EM_NIOS32
: return "Altera Nios";
2440 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2441 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2442 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2445 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2451 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2453 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2454 other compilers don't a specific architecture type in the e_flags, and
2455 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2456 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2459 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2460 but also sets a specific architecture type in the e_flags field.
2462 However, when decoding the flags we don't worry if we see an
2463 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2464 ARCEM architecture type. */
2466 switch (e_flags
& EF_ARC_MACH_MSK
)
2468 /* We only expect these to occur for EM_ARC_COMPACT2. */
2469 case EF_ARC_CPU_ARCV2EM
:
2470 strcat (buf
, ", ARC EM");
2472 case EF_ARC_CPU_ARCV2HS
:
2473 strcat (buf
, ", ARC HS");
2476 /* We only expect these to occur for EM_ARC_COMPACT. */
2477 case E_ARC_MACH_ARC600
:
2478 strcat (buf
, ", ARC600");
2480 case E_ARC_MACH_ARC601
:
2481 strcat (buf
, ", ARC601");
2483 case E_ARC_MACH_ARC700
:
2484 strcat (buf
, ", ARC700");
2487 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2488 new ELF with new architecture being read by an old version of
2489 readelf, or (c) An ELF built with non-GNU compiler that does not
2490 set the architecture in the e_flags. */
2492 if (e_machine
== EM_ARC_COMPACT
)
2493 strcat (buf
, ", Unknown ARCompact");
2495 strcat (buf
, ", Unknown ARC");
2499 switch (e_flags
& EF_ARC_OSABI_MSK
)
2501 case E_ARC_OSABI_ORIG
:
2502 strcat (buf
, ", (ABI:legacy)");
2504 case E_ARC_OSABI_V2
:
2505 strcat (buf
, ", (ABI:v2)");
2507 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2508 case E_ARC_OSABI_V3
:
2509 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2511 case E_ARC_OSABI_V4
:
2512 strcat (buf
, ", v4 ABI");
2515 strcat (buf
, ", unrecognised ARC OSABI flag");
2521 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2524 bfd_boolean unknown
= FALSE
;
2526 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2527 e_flags
&= ~ EF_ARM_EABIMASK
;
2529 /* Handle "generic" ARM flags. */
2530 if (e_flags
& EF_ARM_RELEXEC
)
2532 strcat (buf
, ", relocatable executable");
2533 e_flags
&= ~ EF_ARM_RELEXEC
;
2536 /* Now handle EABI specific flags. */
2540 strcat (buf
, ", <unrecognized EABI>");
2545 case EF_ARM_EABI_VER1
:
2546 strcat (buf
, ", Version1 EABI");
2551 /* Process flags one bit at a time. */
2552 flag
= e_flags
& - e_flags
;
2557 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2558 strcat (buf
, ", sorted symbol tables");
2568 case EF_ARM_EABI_VER2
:
2569 strcat (buf
, ", Version2 EABI");
2574 /* Process flags one bit at a time. */
2575 flag
= e_flags
& - e_flags
;
2580 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2581 strcat (buf
, ", sorted symbol tables");
2584 case EF_ARM_DYNSYMSUSESEGIDX
:
2585 strcat (buf
, ", dynamic symbols use segment index");
2588 case EF_ARM_MAPSYMSFIRST
:
2589 strcat (buf
, ", mapping symbols precede others");
2599 case EF_ARM_EABI_VER3
:
2600 strcat (buf
, ", Version3 EABI");
2603 case EF_ARM_EABI_VER4
:
2604 strcat (buf
, ", Version4 EABI");
2609 /* Process flags one bit at a time. */
2610 flag
= e_flags
& - e_flags
;
2616 strcat (buf
, ", BE8");
2620 strcat (buf
, ", LE8");
2630 case EF_ARM_EABI_VER5
:
2631 strcat (buf
, ", Version5 EABI");
2636 /* Process flags one bit at a time. */
2637 flag
= e_flags
& - e_flags
;
2643 strcat (buf
, ", BE8");
2647 strcat (buf
, ", LE8");
2650 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2651 strcat (buf
, ", soft-float ABI");
2654 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2655 strcat (buf
, ", hard-float ABI");
2665 case EF_ARM_EABI_UNKNOWN
:
2666 strcat (buf
, ", GNU EABI");
2671 /* Process flags one bit at a time. */
2672 flag
= e_flags
& - e_flags
;
2677 case EF_ARM_INTERWORK
:
2678 strcat (buf
, ", interworking enabled");
2681 case EF_ARM_APCS_26
:
2682 strcat (buf
, ", uses APCS/26");
2685 case EF_ARM_APCS_FLOAT
:
2686 strcat (buf
, ", uses APCS/float");
2690 strcat (buf
, ", position independent");
2694 strcat (buf
, ", 8 bit structure alignment");
2697 case EF_ARM_NEW_ABI
:
2698 strcat (buf
, ", uses new ABI");
2701 case EF_ARM_OLD_ABI
:
2702 strcat (buf
, ", uses old ABI");
2705 case EF_ARM_SOFT_FLOAT
:
2706 strcat (buf
, ", software FP");
2709 case EF_ARM_VFP_FLOAT
:
2710 strcat (buf
, ", VFP");
2713 case EF_ARM_MAVERICK_FLOAT
:
2714 strcat (buf
, ", Maverick FP");
2725 strcat (buf
,_(", <unknown>"));
2729 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2731 --size
; /* Leave space for null terminator. */
2733 switch (e_flags
& EF_AVR_MACH
)
2735 case E_AVR_MACH_AVR1
:
2736 strncat (buf
, ", avr:1", size
);
2738 case E_AVR_MACH_AVR2
:
2739 strncat (buf
, ", avr:2", size
);
2741 case E_AVR_MACH_AVR25
:
2742 strncat (buf
, ", avr:25", size
);
2744 case E_AVR_MACH_AVR3
:
2745 strncat (buf
, ", avr:3", size
);
2747 case E_AVR_MACH_AVR31
:
2748 strncat (buf
, ", avr:31", size
);
2750 case E_AVR_MACH_AVR35
:
2751 strncat (buf
, ", avr:35", size
);
2753 case E_AVR_MACH_AVR4
:
2754 strncat (buf
, ", avr:4", size
);
2756 case E_AVR_MACH_AVR5
:
2757 strncat (buf
, ", avr:5", size
);
2759 case E_AVR_MACH_AVR51
:
2760 strncat (buf
, ", avr:51", size
);
2762 case E_AVR_MACH_AVR6
:
2763 strncat (buf
, ", avr:6", size
);
2765 case E_AVR_MACH_AVRTINY
:
2766 strncat (buf
, ", avr:100", size
);
2768 case E_AVR_MACH_XMEGA1
:
2769 strncat (buf
, ", avr:101", size
);
2771 case E_AVR_MACH_XMEGA2
:
2772 strncat (buf
, ", avr:102", size
);
2774 case E_AVR_MACH_XMEGA3
:
2775 strncat (buf
, ", avr:103", size
);
2777 case E_AVR_MACH_XMEGA4
:
2778 strncat (buf
, ", avr:104", size
);
2780 case E_AVR_MACH_XMEGA5
:
2781 strncat (buf
, ", avr:105", size
);
2783 case E_AVR_MACH_XMEGA6
:
2784 strncat (buf
, ", avr:106", size
);
2786 case E_AVR_MACH_XMEGA7
:
2787 strncat (buf
, ", avr:107", size
);
2790 strncat (buf
, ", avr:<unknown>", size
);
2794 size
-= strlen (buf
);
2795 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2796 strncat (buf
, ", link-relax", size
);
2800 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2806 bfd_boolean has_fpu
= FALSE
;
2809 static const char *ABI_STRINGS
[] =
2811 "ABI v0", /* use r5 as return register; only used in N1213HC */
2812 "ABI v1", /* use r0 as return register */
2813 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2814 "ABI v2fp", /* for FPU */
2818 static const char *VER_STRINGS
[] =
2820 "Andes ELF V1.3 or older",
2824 static const char *ARCH_STRINGS
[] =
2833 abi
= EF_NDS_ABI
& e_flags
;
2834 arch
= EF_NDS_ARCH
& e_flags
;
2835 config
= EF_NDS_INST
& e_flags
;
2836 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2838 memset (buf
, 0, size
);
2845 case E_NDS_ABI_V2FP
:
2846 case E_NDS_ABI_AABI
:
2847 case E_NDS_ABI_V2FP_PLUS
:
2848 /* In case there are holes in the array. */
2849 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2853 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2859 case E_NDS32_ELF_VER_1_2
:
2860 case E_NDS32_ELF_VER_1_3
:
2861 case E_NDS32_ELF_VER_1_4
:
2862 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2866 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2870 if (E_NDS_ABI_V0
== abi
)
2872 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2873 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2874 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2875 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2881 case E_NDS_ARCH_STAR_V1_0
:
2882 case E_NDS_ARCH_STAR_V2_0
:
2883 case E_NDS_ARCH_STAR_V3_0
:
2884 case E_NDS_ARCH_STAR_V3_M
:
2885 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2889 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2890 /* ARCH version determines how the e_flags are interpreted.
2891 If it is unknown, we cannot proceed. */
2895 /* Newer ABI; Now handle architecture specific flags. */
2896 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2898 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2899 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2901 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2902 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2904 if (config
& E_NDS32_HAS_DIV_INST
)
2905 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2907 if (config
& E_NDS32_HAS_16BIT_INST
)
2908 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2912 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2914 if (version
<= E_NDS32_ELF_VER_1_3
)
2915 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2917 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2920 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2921 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2923 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2924 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2926 if (config
& E_NDS32_HAS_16BIT_INST
)
2928 if (version
<= E_NDS32_ELF_VER_1_3
)
2929 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2931 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2935 if (config
& E_NDS32_HAS_EXT_INST
)
2936 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2938 if (config
& E_NDS32_HAS_EXT2_INST
)
2939 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2941 if (config
& E_NDS32_HAS_FPU_INST
)
2944 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2947 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2950 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2953 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2956 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2961 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2963 case E_NDS32_FPU_REG_8SP_4DP
:
2964 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2966 case E_NDS32_FPU_REG_16SP_8DP
:
2967 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2969 case E_NDS32_FPU_REG_32SP_16DP
:
2970 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2972 case E_NDS32_FPU_REG_32SP_32DP
:
2973 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2978 if (config
& E_NDS32_HAS_AUDIO_INST
)
2979 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2981 if (config
& E_NDS32_HAS_STRING_INST
)
2982 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2984 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2985 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2987 if (config
& E_NDS32_HAS_VIDEO_INST
)
2989 if (version
<= E_NDS32_ELF_VER_1_3
)
2990 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2992 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2995 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2996 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2998 if (config
& E_NDS32_HAS_L2C_INST
)
2999 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3003 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
3005 static char buf
[1024];
3016 case EM_ARC_COMPACT2
:
3017 case EM_ARC_COMPACT
:
3018 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3022 decode_ARM_machine_flags (e_flags
, buf
);
3026 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3030 if (e_flags
& EF_BFIN_PIC
)
3031 strcat (buf
, ", PIC");
3033 if (e_flags
& EF_BFIN_FDPIC
)
3034 strcat (buf
, ", FDPIC");
3036 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3037 strcat (buf
, ", code in L1");
3039 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3040 strcat (buf
, ", data in L1");
3045 switch (e_flags
& EF_FRV_CPU_MASK
)
3047 case EF_FRV_CPU_GENERIC
:
3051 strcat (buf
, ", fr???");
3054 case EF_FRV_CPU_FR300
:
3055 strcat (buf
, ", fr300");
3058 case EF_FRV_CPU_FR400
:
3059 strcat (buf
, ", fr400");
3061 case EF_FRV_CPU_FR405
:
3062 strcat (buf
, ", fr405");
3065 case EF_FRV_CPU_FR450
:
3066 strcat (buf
, ", fr450");
3069 case EF_FRV_CPU_FR500
:
3070 strcat (buf
, ", fr500");
3072 case EF_FRV_CPU_FR550
:
3073 strcat (buf
, ", fr550");
3076 case EF_FRV_CPU_SIMPLE
:
3077 strcat (buf
, ", simple");
3079 case EF_FRV_CPU_TOMCAT
:
3080 strcat (buf
, ", tomcat");
3086 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3087 strcat (buf
, ", m68000");
3088 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3089 strcat (buf
, ", cpu32");
3090 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3091 strcat (buf
, ", fido_a");
3094 char const * isa
= _("unknown");
3095 char const * mac
= _("unknown mac");
3096 char const * additional
= NULL
;
3098 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3100 case EF_M68K_CF_ISA_A_NODIV
:
3102 additional
= ", nodiv";
3104 case EF_M68K_CF_ISA_A
:
3107 case EF_M68K_CF_ISA_A_PLUS
:
3110 case EF_M68K_CF_ISA_B_NOUSP
:
3112 additional
= ", nousp";
3114 case EF_M68K_CF_ISA_B
:
3117 case EF_M68K_CF_ISA_C
:
3120 case EF_M68K_CF_ISA_C_NODIV
:
3122 additional
= ", nodiv";
3125 strcat (buf
, ", cf, isa ");
3128 strcat (buf
, additional
);
3129 if (e_flags
& EF_M68K_CF_FLOAT
)
3130 strcat (buf
, ", float");
3131 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3136 case EF_M68K_CF_MAC
:
3139 case EF_M68K_CF_EMAC
:
3142 case EF_M68K_CF_EMAC_B
:
3155 switch (e_flags
& EF_MEP_CPU_MASK
)
3157 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3158 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3159 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3160 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3161 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3162 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3163 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3166 switch (e_flags
& EF_MEP_COP_MASK
)
3168 case EF_MEP_COP_NONE
: break;
3169 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3170 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3171 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3172 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3173 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3176 if (e_flags
& EF_MEP_LIBRARY
)
3177 strcat (buf
, ", Built for Library");
3179 if (e_flags
& EF_MEP_INDEX_MASK
)
3180 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3181 e_flags
& EF_MEP_INDEX_MASK
);
3183 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3184 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3185 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3189 if (e_flags
& EF_PPC_EMB
)
3190 strcat (buf
, ", emb");
3192 if (e_flags
& EF_PPC_RELOCATABLE
)
3193 strcat (buf
, _(", relocatable"));
3195 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3196 strcat (buf
, _(", relocatable-lib"));
3200 if (e_flags
& EF_PPC64_ABI
)
3202 char abi
[] = ", abiv0";
3204 abi
[6] += e_flags
& EF_PPC64_ABI
;
3210 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3211 strcat (buf
, ", RH850 ABI");
3213 if (e_flags
& EF_V800_850E3
)
3214 strcat (buf
, ", V3 architecture");
3216 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3217 strcat (buf
, ", FPU not used");
3219 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3220 strcat (buf
, ", regmode: COMMON");
3222 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3223 strcat (buf
, ", r4 not used");
3225 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3226 strcat (buf
, ", r30 not used");
3228 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3229 strcat (buf
, ", r5 not used");
3231 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3232 strcat (buf
, ", r2 not used");
3234 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3236 switch (e_flags
& - e_flags
)
3238 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3239 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3240 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3241 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3242 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3243 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3244 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3245 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3246 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3247 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3248 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3249 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3256 case EM_CYGNUS_V850
:
3257 switch (e_flags
& EF_V850_ARCH
)
3259 case E_V850E3V5_ARCH
:
3260 strcat (buf
, ", v850e3v5");
3262 case E_V850E2V3_ARCH
:
3263 strcat (buf
, ", v850e2v3");
3266 strcat (buf
, ", v850e2");
3269 strcat (buf
, ", v850e1");
3272 strcat (buf
, ", v850e");
3275 strcat (buf
, ", v850");
3278 strcat (buf
, _(", unknown v850 architecture variant"));
3284 case EM_CYGNUS_M32R
:
3285 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3286 strcat (buf
, ", m32r");
3290 case EM_MIPS_RS3_LE
:
3291 if (e_flags
& EF_MIPS_NOREORDER
)
3292 strcat (buf
, ", noreorder");
3294 if (e_flags
& EF_MIPS_PIC
)
3295 strcat (buf
, ", pic");
3297 if (e_flags
& EF_MIPS_CPIC
)
3298 strcat (buf
, ", cpic");
3300 if (e_flags
& EF_MIPS_UCODE
)
3301 strcat (buf
, ", ugen_reserved");
3303 if (e_flags
& EF_MIPS_ABI2
)
3304 strcat (buf
, ", abi2");
3306 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3307 strcat (buf
, ", odk first");
3309 if (e_flags
& EF_MIPS_32BITMODE
)
3310 strcat (buf
, ", 32bitmode");
3312 if (e_flags
& EF_MIPS_NAN2008
)
3313 strcat (buf
, ", nan2008");
3315 if (e_flags
& EF_MIPS_FP64
)
3316 strcat (buf
, ", fp64");
3318 switch ((e_flags
& EF_MIPS_MACH
))
3320 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3321 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3322 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3323 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3324 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3325 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3326 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3327 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3328 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3329 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3330 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3331 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3332 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3333 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3334 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3335 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3336 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3337 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3339 /* We simply ignore the field in this case to avoid confusion:
3340 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3343 default: strcat (buf
, _(", unknown CPU")); break;
3346 switch ((e_flags
& EF_MIPS_ABI
))
3348 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3349 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3350 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3351 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3353 /* We simply ignore the field in this case to avoid confusion:
3354 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3355 This means it is likely to be an o32 file, but not for
3358 default: strcat (buf
, _(", unknown ABI")); break;
3361 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3362 strcat (buf
, ", mdmx");
3364 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3365 strcat (buf
, ", mips16");
3367 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3368 strcat (buf
, ", micromips");
3370 switch ((e_flags
& EF_MIPS_ARCH
))
3372 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3373 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3374 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3375 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3376 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3377 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3378 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3379 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3380 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3381 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3382 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3383 default: strcat (buf
, _(", unknown ISA")); break;
3388 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3392 if (e_flags
& EF_RISCV_RVC
)
3393 strcat (buf
, ", RVC");
3395 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3397 case EF_RISCV_FLOAT_ABI_SOFT
:
3398 strcat (buf
, ", soft-float ABI");
3401 case EF_RISCV_FLOAT_ABI_SINGLE
:
3402 strcat (buf
, ", single-float ABI");
3405 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3406 strcat (buf
, ", double-float ABI");
3409 case EF_RISCV_FLOAT_ABI_QUAD
:
3410 strcat (buf
, ", quad-float ABI");
3416 switch ((e_flags
& EF_SH_MACH_MASK
))
3418 case EF_SH1
: strcat (buf
, ", sh1"); break;
3419 case EF_SH2
: strcat (buf
, ", sh2"); break;
3420 case EF_SH3
: strcat (buf
, ", sh3"); break;
3421 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3422 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3423 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3424 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3425 case EF_SH4
: strcat (buf
, ", sh4"); break;
3426 case EF_SH5
: strcat (buf
, ", sh5"); break;
3427 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3428 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3429 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3430 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3431 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3432 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3433 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3434 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3435 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3436 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3437 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3438 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3439 default: strcat (buf
, _(", unknown ISA")); break;
3442 if (e_flags
& EF_SH_PIC
)
3443 strcat (buf
, ", pic");
3445 if (e_flags
& EF_SH_FDPIC
)
3446 strcat (buf
, ", fdpic");
3450 if (e_flags
& EF_OR1K_NODELAY
)
3451 strcat (buf
, ", no delay");
3455 if (e_flags
& EF_SPARC_32PLUS
)
3456 strcat (buf
, ", v8+");
3458 if (e_flags
& EF_SPARC_SUN_US1
)
3459 strcat (buf
, ", ultrasparcI");
3461 if (e_flags
& EF_SPARC_SUN_US3
)
3462 strcat (buf
, ", ultrasparcIII");
3464 if (e_flags
& EF_SPARC_HAL_R1
)
3465 strcat (buf
, ", halr1");
3467 if (e_flags
& EF_SPARC_LEDATA
)
3468 strcat (buf
, ", ledata");
3470 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3471 strcat (buf
, ", tso");
3473 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3474 strcat (buf
, ", pso");
3476 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3477 strcat (buf
, ", rmo");
3481 switch (e_flags
& EF_PARISC_ARCH
)
3483 case EFA_PARISC_1_0
:
3484 strcpy (buf
, ", PA-RISC 1.0");
3486 case EFA_PARISC_1_1
:
3487 strcpy (buf
, ", PA-RISC 1.1");
3489 case EFA_PARISC_2_0
:
3490 strcpy (buf
, ", PA-RISC 2.0");
3495 if (e_flags
& EF_PARISC_TRAPNIL
)
3496 strcat (buf
, ", trapnil");
3497 if (e_flags
& EF_PARISC_EXT
)
3498 strcat (buf
, ", ext");
3499 if (e_flags
& EF_PARISC_LSB
)
3500 strcat (buf
, ", lsb");
3501 if (e_flags
& EF_PARISC_WIDE
)
3502 strcat (buf
, ", wide");
3503 if (e_flags
& EF_PARISC_NO_KABP
)
3504 strcat (buf
, ", no kabp");
3505 if (e_flags
& EF_PARISC_LAZYSWAP
)
3506 strcat (buf
, ", lazyswap");
3511 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3512 strcat (buf
, ", new calling convention");
3514 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3515 strcat (buf
, ", gnu calling convention");
3519 if ((e_flags
& EF_IA_64_ABI64
))
3520 strcat (buf
, ", 64-bit");
3522 strcat (buf
, ", 32-bit");
3523 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3524 strcat (buf
, ", reduced fp model");
3525 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3526 strcat (buf
, ", no function descriptors, constant gp");
3527 else if ((e_flags
& EF_IA_64_CONS_GP
))
3528 strcat (buf
, ", constant gp");
3529 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3530 strcat (buf
, ", absolute");
3531 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3533 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3534 strcat (buf
, ", vms_linkages");
3535 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3537 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3539 case EF_IA_64_VMS_COMCOD_WARNING
:
3540 strcat (buf
, ", warning");
3542 case EF_IA_64_VMS_COMCOD_ERROR
:
3543 strcat (buf
, ", error");
3545 case EF_IA_64_VMS_COMCOD_ABORT
:
3546 strcat (buf
, ", abort");
3549 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3550 e_flags
& EF_IA_64_VMS_COMCOD
);
3551 strcat (buf
, ", <unknown>");
3557 if ((e_flags
& EF_VAX_NONPIC
))
3558 strcat (buf
, ", non-PIC");
3559 if ((e_flags
& EF_VAX_DFLOAT
))
3560 strcat (buf
, ", D-Float");
3561 if ((e_flags
& EF_VAX_GFLOAT
))
3562 strcat (buf
, ", G-Float");
3566 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3567 strcat (buf
, ", mcm");
3568 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3569 strcat (buf
, ", mcm24");
3570 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3571 strcat (buf
, ", gr6");
3575 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3577 case E_FLAG_RL78_ANY_CPU
: break;
3578 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3579 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3580 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3582 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3583 strcat (buf
, ", 64-bit doubles");
3587 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3588 strcat (buf
, ", 64-bit doubles");
3589 if (e_flags
& E_FLAG_RX_DSP
)
3590 strcat (buf
, ", dsp");
3591 if (e_flags
& E_FLAG_RX_PID
)
3592 strcat (buf
, ", pid");
3593 if (e_flags
& E_FLAG_RX_ABI
)
3594 strcat (buf
, ", RX ABI");
3595 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3596 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3597 ? ", uses String instructions" : ", bans String instructions");
3598 if (e_flags
& E_FLAG_RX_V2
)
3599 strcat (buf
, ", V2");
3603 if (e_flags
& EF_S390_HIGH_GPRS
)
3604 strcat (buf
, ", highgprs");
3608 if ((e_flags
& EF_C6000_REL
))
3609 strcat (buf
, ", relocatable module");
3613 strcat (buf
, _(": architecture variant: "));
3614 switch (e_flags
& EF_MSP430_MACH
)
3616 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3617 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3618 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3619 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3620 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3621 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3622 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3623 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3624 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3625 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3626 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3627 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3628 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3629 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3630 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3632 strcat (buf
, _(": unknown")); break;
3635 if (e_flags
& ~ EF_MSP430_MACH
)
3636 strcat (buf
, _(": unknown extra flag bits also present"));
3644 get_osabi_name (unsigned int osabi
)
3646 static char buff
[32];
3650 case ELFOSABI_NONE
: return "UNIX - System V";
3651 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3652 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3653 case ELFOSABI_GNU
: return "UNIX - GNU";
3654 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3655 case ELFOSABI_AIX
: return "UNIX - AIX";
3656 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3657 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3658 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3659 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3660 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3661 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3662 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3663 case ELFOSABI_AROS
: return "AROS";
3664 case ELFOSABI_FENIXOS
: return "FenixOS";
3665 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3666 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3669 switch (elf_header
.e_machine
)
3674 case ELFOSABI_ARM
: return "ARM";
3685 case ELFOSABI_STANDALONE
: return _("Standalone App");
3694 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3695 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3704 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3710 get_aarch64_segment_type (unsigned long type
)
3714 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3715 default: return NULL
;
3720 get_arm_segment_type (unsigned long type
)
3724 case PT_ARM_EXIDX
: return "EXIDX";
3725 default: return NULL
;
3730 get_s390_segment_type (unsigned long type
)
3734 case PT_S390_PGSTE
: return "S390_PGSTE";
3735 default: return NULL
;
3740 get_mips_segment_type (unsigned long type
)
3744 case PT_MIPS_REGINFO
: return "REGINFO";
3745 case PT_MIPS_RTPROC
: return "RTPROC";
3746 case PT_MIPS_OPTIONS
: return "OPTIONS";
3747 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3748 default: return NULL
;
3753 get_parisc_segment_type (unsigned long type
)
3757 case PT_HP_TLS
: return "HP_TLS";
3758 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3759 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3760 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3761 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3762 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3763 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3764 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3765 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3766 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3767 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3768 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3769 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3770 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3771 case PT_HP_STACK
: return "HP_STACK";
3772 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3773 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3774 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3775 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3776 default: return NULL
;
3781 get_ia64_segment_type (unsigned long type
)
3785 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3786 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3787 case PT_HP_TLS
: return "HP_TLS";
3788 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3789 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3790 case PT_IA_64_HP_STACK
: return "HP_STACK";
3791 default: return NULL
;
3796 get_tic6x_segment_type (unsigned long type
)
3800 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3801 default: return NULL
;
3806 get_solaris_segment_type (unsigned long type
)
3810 case 0x6464e550: return "PT_SUNW_UNWIND";
3811 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3812 case 0x6ffffff7: return "PT_LOSUNW";
3813 case 0x6ffffffa: return "PT_SUNWBSS";
3814 case 0x6ffffffb: return "PT_SUNWSTACK";
3815 case 0x6ffffffc: return "PT_SUNWDTRACE";
3816 case 0x6ffffffd: return "PT_SUNWCAP";
3817 case 0x6fffffff: return "PT_HISUNW";
3818 default: return NULL
;
3823 get_segment_type (unsigned long p_type
)
3825 static char buff
[32];
3829 case PT_NULL
: return "NULL";
3830 case PT_LOAD
: return "LOAD";
3831 case PT_DYNAMIC
: return "DYNAMIC";
3832 case PT_INTERP
: return "INTERP";
3833 case PT_NOTE
: return "NOTE";
3834 case PT_SHLIB
: return "SHLIB";
3835 case PT_PHDR
: return "PHDR";
3836 case PT_TLS
: return "TLS";
3837 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3838 case PT_GNU_STACK
: return "GNU_STACK";
3839 case PT_GNU_RELRO
: return "GNU_RELRO";
3842 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3844 sprintf (buff
, "GNU_MBIND+%#lx",
3845 p_type
- PT_GNU_MBIND_LO
);
3847 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3849 const char * result
;
3851 switch (elf_header
.e_machine
)
3854 result
= get_aarch64_segment_type (p_type
);
3857 result
= get_arm_segment_type (p_type
);
3860 case EM_MIPS_RS3_LE
:
3861 result
= get_mips_segment_type (p_type
);
3864 result
= get_parisc_segment_type (p_type
);
3867 result
= get_ia64_segment_type (p_type
);
3870 result
= get_tic6x_segment_type (p_type
);
3874 result
= get_s390_segment_type (p_type
);
3884 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3886 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3888 const char * result
;
3890 switch (elf_header
.e_machine
)
3893 result
= get_parisc_segment_type (p_type
);
3896 result
= get_ia64_segment_type (p_type
);
3899 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3900 result
= get_solaris_segment_type (p_type
);
3909 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3912 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3919 get_arc_section_type_name (unsigned int sh_type
)
3923 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3931 get_mips_section_type_name (unsigned int sh_type
)
3935 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3936 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3937 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3938 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3939 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3940 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3941 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3942 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3943 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3944 case SHT_MIPS_RELD
: return "MIPS_RELD";
3945 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3946 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3947 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3948 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3949 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3950 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3951 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3952 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3953 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3954 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3955 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3956 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3957 case SHT_MIPS_LINE
: return "MIPS_LINE";
3958 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3959 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3960 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3961 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3962 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3963 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3964 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3965 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3966 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3967 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3968 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3969 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3970 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3971 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3972 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3973 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3974 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3982 get_parisc_section_type_name (unsigned int sh_type
)
3986 case SHT_PARISC_EXT
: return "PARISC_EXT";
3987 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3988 case SHT_PARISC_DOC
: return "PARISC_DOC";
3989 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3990 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3991 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3992 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3993 default: return NULL
;
3998 get_ia64_section_type_name (unsigned int sh_type
)
4000 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4001 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4002 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
4006 case SHT_IA_64_EXT
: return "IA_64_EXT";
4007 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4008 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4009 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4010 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4011 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4012 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4013 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4014 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4015 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4023 get_x86_64_section_type_name (unsigned int sh_type
)
4027 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4028 default: return NULL
;
4033 get_aarch64_section_type_name (unsigned int sh_type
)
4037 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4038 default: return NULL
;
4043 get_arm_section_type_name (unsigned int sh_type
)
4047 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4048 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4049 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4050 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4051 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4052 default: return NULL
;
4057 get_tic6x_section_type_name (unsigned int sh_type
)
4061 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4062 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4063 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4064 case SHT_TI_ICODE
: return "TI_ICODE";
4065 case SHT_TI_XREF
: return "TI_XREF";
4066 case SHT_TI_HANDLER
: return "TI_HANDLER";
4067 case SHT_TI_INITINFO
: return "TI_INITINFO";
4068 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4069 default: return NULL
;
4074 get_msp430x_section_type_name (unsigned int sh_type
)
4078 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4079 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4080 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4081 default: return NULL
;
4086 get_v850_section_type_name (unsigned int sh_type
)
4090 case SHT_V850_SCOMMON
: return "V850 Small Common";
4091 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4092 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4093 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4094 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4095 default: return NULL
;
4100 get_section_type_name (unsigned int sh_type
)
4102 static char buff
[32];
4103 const char * result
;
4107 case SHT_NULL
: return "NULL";
4108 case SHT_PROGBITS
: return "PROGBITS";
4109 case SHT_SYMTAB
: return "SYMTAB";
4110 case SHT_STRTAB
: return "STRTAB";
4111 case SHT_RELA
: return "RELA";
4112 case SHT_HASH
: return "HASH";
4113 case SHT_DYNAMIC
: return "DYNAMIC";
4114 case SHT_NOTE
: return "NOTE";
4115 case SHT_NOBITS
: return "NOBITS";
4116 case SHT_REL
: return "REL";
4117 case SHT_SHLIB
: return "SHLIB";
4118 case SHT_DYNSYM
: return "DYNSYM";
4119 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4120 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4121 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4122 case SHT_GNU_HASH
: return "GNU_HASH";
4123 case SHT_GROUP
: return "GROUP";
4124 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4125 case SHT_GNU_verdef
: return "VERDEF";
4126 case SHT_GNU_verneed
: return "VERNEED";
4127 case SHT_GNU_versym
: return "VERSYM";
4128 case 0x6ffffff0: return "VERSYM";
4129 case 0x6ffffffc: return "VERDEF";
4130 case 0x7ffffffd: return "AUXILIARY";
4131 case 0x7fffffff: return "FILTER";
4132 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4135 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4137 switch (elf_header
.e_machine
)
4140 case EM_ARC_COMPACT
:
4141 case EM_ARC_COMPACT2
:
4142 result
= get_arc_section_type_name (sh_type
);
4145 case EM_MIPS_RS3_LE
:
4146 result
= get_mips_section_type_name (sh_type
);
4149 result
= get_parisc_section_type_name (sh_type
);
4152 result
= get_ia64_section_type_name (sh_type
);
4157 result
= get_x86_64_section_type_name (sh_type
);
4160 result
= get_aarch64_section_type_name (sh_type
);
4163 result
= get_arm_section_type_name (sh_type
);
4166 result
= get_tic6x_section_type_name (sh_type
);
4169 result
= get_msp430x_section_type_name (sh_type
);
4173 case EM_CYGNUS_V850
:
4174 result
= get_v850_section_type_name (sh_type
);
4184 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4186 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4188 switch (elf_header
.e_machine
)
4191 result
= get_ia64_section_type_name (sh_type
);
4194 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4195 result
= get_solaris_section_type (sh_type
);
4200 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4201 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4202 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4203 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4215 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4217 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4219 switch (elf_header
.e_machine
)
4223 case EM_CYGNUS_V850
:
4224 result
= get_v850_section_type_name (sh_type
);
4234 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4237 /* This message is probably going to be displayed in a 15
4238 character wide field, so put the hex value first. */
4239 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4245 #define OPTION_DEBUG_DUMP 512
4246 #define OPTION_DYN_SYMS 513
4247 #define OPTION_DWARF_DEPTH 514
4248 #define OPTION_DWARF_START 515
4249 #define OPTION_DWARF_CHECK 516
4251 static struct option options
[] =
4253 {"all", no_argument
, 0, 'a'},
4254 {"file-header", no_argument
, 0, 'h'},
4255 {"program-headers", no_argument
, 0, 'l'},
4256 {"headers", no_argument
, 0, 'e'},
4257 {"histogram", no_argument
, 0, 'I'},
4258 {"segments", no_argument
, 0, 'l'},
4259 {"sections", no_argument
, 0, 'S'},
4260 {"section-headers", no_argument
, 0, 'S'},
4261 {"section-groups", no_argument
, 0, 'g'},
4262 {"section-details", no_argument
, 0, 't'},
4263 {"full-section-name",no_argument
, 0, 'N'},
4264 {"symbols", no_argument
, 0, 's'},
4265 {"syms", no_argument
, 0, 's'},
4266 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4267 {"relocs", no_argument
, 0, 'r'},
4268 {"notes", no_argument
, 0, 'n'},
4269 {"dynamic", no_argument
, 0, 'd'},
4270 {"arch-specific", no_argument
, 0, 'A'},
4271 {"version-info", no_argument
, 0, 'V'},
4272 {"use-dynamic", no_argument
, 0, 'D'},
4273 {"unwind", no_argument
, 0, 'u'},
4274 {"archive-index", no_argument
, 0, 'c'},
4275 {"hex-dump", required_argument
, 0, 'x'},
4276 {"relocated-dump", required_argument
, 0, 'R'},
4277 {"string-dump", required_argument
, 0, 'p'},
4278 {"decompress", no_argument
, 0, 'z'},
4279 #ifdef SUPPORT_DISASSEMBLY
4280 {"instruction-dump", required_argument
, 0, 'i'},
4282 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4284 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4285 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4286 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4288 {"version", no_argument
, 0, 'v'},
4289 {"wide", no_argument
, 0, 'W'},
4290 {"help", no_argument
, 0, 'H'},
4291 {0, no_argument
, 0, 0}
4295 usage (FILE * stream
)
4297 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4298 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4299 fprintf (stream
, _(" Options are:\n\
4300 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4301 -h --file-header Display the ELF file header\n\
4302 -l --program-headers Display the program headers\n\
4303 --segments An alias for --program-headers\n\
4304 -S --section-headers Display the sections' header\n\
4305 --sections An alias for --section-headers\n\
4306 -g --section-groups Display the section groups\n\
4307 -t --section-details Display the section details\n\
4308 -e --headers Equivalent to: -h -l -S\n\
4309 -s --syms Display the symbol table\n\
4310 --symbols An alias for --syms\n\
4311 --dyn-syms Display the dynamic symbol table\n\
4312 -n --notes Display the core notes (if present)\n\
4313 -r --relocs Display the relocations (if present)\n\
4314 -u --unwind Display the unwind info (if present)\n\
4315 -d --dynamic Display the dynamic section (if present)\n\
4316 -V --version-info Display the version sections (if present)\n\
4317 -A --arch-specific Display architecture specific information (if any)\n\
4318 -c --archive-index Display the symbol/file index in an archive\n\
4319 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4320 -x --hex-dump=<number|name>\n\
4321 Dump the contents of section <number|name> as bytes\n\
4322 -p --string-dump=<number|name>\n\
4323 Dump the contents of section <number|name> as strings\n\
4324 -R --relocated-dump=<number|name>\n\
4325 Dump the contents of section <number|name> as relocated bytes\n\
4326 -z --decompress Decompress section before dumping it\n\
4327 -w[lLiaprmfFsoRt] or\n\
4328 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4329 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4330 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4332 Display the contents of DWARF2 debug sections\n"));
4333 fprintf (stream
, _("\
4334 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4335 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4337 #ifdef SUPPORT_DISASSEMBLY
4338 fprintf (stream
, _("\
4339 -i --instruction-dump=<number|name>\n\
4340 Disassemble the contents of section <number|name>\n"));
4342 fprintf (stream
, _("\
4343 -I --histogram Display histogram of bucket list lengths\n\
4344 -W --wide Allow output width to exceed 80 characters\n\
4345 @<file> Read options from <file>\n\
4346 -H --help Display this information\n\
4347 -v --version Display the version number of readelf\n"));
4349 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4350 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4352 exit (stream
== stdout
? 0 : 1);
4355 /* Record the fact that the user wants the contents of section number
4356 SECTION to be displayed using the method(s) encoded as flags bits
4357 in TYPE. Note, TYPE can be zero if we are creating the array for
4361 request_dump_bynumber (unsigned int section
, dump_type type
)
4363 if (section
>= num_dump_sects
)
4365 dump_type
* new_dump_sects
;
4367 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4368 sizeof (* dump_sects
));
4370 if (new_dump_sects
== NULL
)
4371 error (_("Out of memory allocating dump request table.\n"));
4376 /* Copy current flag settings. */
4377 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4382 dump_sects
= new_dump_sects
;
4383 num_dump_sects
= section
+ 1;
4388 dump_sects
[section
] |= type
;
4393 /* Request a dump by section name. */
4396 request_dump_byname (const char * section
, dump_type type
)
4398 struct dump_list_entry
* new_request
;
4400 new_request
= (struct dump_list_entry
*)
4401 malloc (sizeof (struct dump_list_entry
));
4403 error (_("Out of memory allocating dump request table.\n"));
4405 new_request
->name
= strdup (section
);
4406 if (!new_request
->name
)
4407 error (_("Out of memory allocating dump request table.\n"));
4409 new_request
->type
= type
;
4411 new_request
->next
= dump_sects_byname
;
4412 dump_sects_byname
= new_request
;
4416 request_dump (dump_type type
)
4422 section
= strtoul (optarg
, & cp
, 0);
4424 if (! *cp
&& section
>= 0)
4425 request_dump_bynumber (section
, type
);
4427 request_dump_byname (optarg
, type
);
4432 parse_args (int argc
, char ** argv
)
4439 while ((c
= getopt_long
4440 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4458 do_section_groups
= TRUE
;
4461 do_histogram
= TRUE
;
4466 do_section_groups
= TRUE
;
4471 do_section_details
= TRUE
;
4482 do_using_dynamic
= TRUE
;
4506 do_histogram
= TRUE
;
4512 do_archive_index
= TRUE
;
4515 request_dump (HEX_DUMP
);
4518 request_dump (STRING_DUMP
);
4521 request_dump (RELOC_DUMP
);
4524 decompress_dumps
= TRUE
;
4530 do_debugging
= TRUE
;
4531 dwarf_select_sections_all ();
4535 do_debugging
= FALSE
;
4536 dwarf_select_sections_by_letters (optarg
);
4539 case OPTION_DEBUG_DUMP
:
4542 do_debugging
= TRUE
;
4545 do_debugging
= FALSE
;
4546 dwarf_select_sections_by_names (optarg
);
4549 case OPTION_DWARF_DEPTH
:
4553 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4556 case OPTION_DWARF_START
:
4560 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4563 case OPTION_DWARF_CHECK
:
4566 case OPTION_DYN_SYMS
:
4569 #ifdef SUPPORT_DISASSEMBLY
4571 request_dump (DISASS_DUMP
);
4575 print_version (program_name
);
4584 /* xgettext:c-format */
4585 error (_("Invalid option '-%c'\n"), c
);
4592 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4593 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4594 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4595 && !do_section_groups
&& !do_archive_index
4601 get_elf_class (unsigned int elf_class
)
4603 static char buff
[32];
4607 case ELFCLASSNONE
: return _("none");
4608 case ELFCLASS32
: return "ELF32";
4609 case ELFCLASS64
: return "ELF64";
4611 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4617 get_data_encoding (unsigned int encoding
)
4619 static char buff
[32];
4623 case ELFDATANONE
: return _("none");
4624 case ELFDATA2LSB
: return _("2's complement, little endian");
4625 case ELFDATA2MSB
: return _("2's complement, big endian");
4627 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4632 /* Decode the data held in 'elf_header'. */
4635 process_file_header (void)
4637 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4638 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4639 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4640 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4643 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4647 init_dwarf_regnames (elf_header
.e_machine
);
4653 printf (_("ELF Header:\n"));
4654 printf (_(" Magic: "));
4655 for (i
= 0; i
< EI_NIDENT
; i
++)
4656 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4658 printf (_(" Class: %s\n"),
4659 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4660 printf (_(" Data: %s\n"),
4661 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4662 printf (_(" Version: %d %s\n"),
4663 elf_header
.e_ident
[EI_VERSION
],
4664 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4666 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4667 ? _("<unknown: %lx>")
4669 printf (_(" OS/ABI: %s\n"),
4670 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4671 printf (_(" ABI Version: %d\n"),
4672 elf_header
.e_ident
[EI_ABIVERSION
]);
4673 printf (_(" Type: %s\n"),
4674 get_file_type (elf_header
.e_type
));
4675 printf (_(" Machine: %s\n"),
4676 get_machine_name (elf_header
.e_machine
));
4677 printf (_(" Version: 0x%lx\n"),
4678 (unsigned long) elf_header
.e_version
);
4680 printf (_(" Entry point address: "));
4681 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4682 printf (_("\n Start of program headers: "));
4683 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4684 printf (_(" (bytes into file)\n Start of section headers: "));
4685 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4686 printf (_(" (bytes into file)\n"));
4688 printf (_(" Flags: 0x%lx%s\n"),
4689 (unsigned long) elf_header
.e_flags
,
4690 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4691 printf (_(" Size of this header: %ld (bytes)\n"),
4692 (long) elf_header
.e_ehsize
);
4693 printf (_(" Size of program headers: %ld (bytes)\n"),
4694 (long) elf_header
.e_phentsize
);
4695 printf (_(" Number of program headers: %ld"),
4696 (long) elf_header
.e_phnum
);
4697 if (section_headers
!= NULL
4698 && elf_header
.e_phnum
== PN_XNUM
4699 && section_headers
[0].sh_info
!= 0)
4700 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4701 putc ('\n', stdout
);
4702 printf (_(" Size of section headers: %ld (bytes)\n"),
4703 (long) elf_header
.e_shentsize
);
4704 printf (_(" Number of section headers: %ld"),
4705 (long) elf_header
.e_shnum
);
4706 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4707 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4708 putc ('\n', stdout
);
4709 printf (_(" Section header string table index: %ld"),
4710 (long) elf_header
.e_shstrndx
);
4711 if (section_headers
!= NULL
4712 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4713 printf (" (%u)", section_headers
[0].sh_link
);
4714 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4715 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4716 printf (_(" <corrupt: out of range>"));
4717 putc ('\n', stdout
);
4720 if (section_headers
!= NULL
)
4722 if (elf_header
.e_phnum
== PN_XNUM
4723 && section_headers
[0].sh_info
!= 0)
4724 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4725 if (elf_header
.e_shnum
== SHN_UNDEF
)
4726 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4727 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4728 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4729 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4730 elf_header
.e_shstrndx
= SHN_UNDEF
;
4731 free (section_headers
);
4732 section_headers
= NULL
;
4739 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4741 Elf32_External_Phdr
* phdrs
;
4742 Elf32_External_Phdr
* external
;
4743 Elf_Internal_Phdr
* internal
;
4745 unsigned int size
= elf_header
.e_phentsize
;
4746 unsigned int num
= elf_header
.e_phnum
;
4748 /* PR binutils/17531: Cope with unexpected section header sizes. */
4749 if (size
== 0 || num
== 0)
4751 if (size
< sizeof * phdrs
)
4753 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4756 if (size
> sizeof * phdrs
)
4757 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4759 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4760 size
, num
, _("program headers"));
4764 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4765 i
< elf_header
.e_phnum
;
4766 i
++, internal
++, external
++)
4768 internal
->p_type
= BYTE_GET (external
->p_type
);
4769 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4770 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4771 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4772 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4773 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4774 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4775 internal
->p_align
= BYTE_GET (external
->p_align
);
4783 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4785 Elf64_External_Phdr
* phdrs
;
4786 Elf64_External_Phdr
* external
;
4787 Elf_Internal_Phdr
* internal
;
4789 unsigned int size
= elf_header
.e_phentsize
;
4790 unsigned int num
= elf_header
.e_phnum
;
4792 /* PR binutils/17531: Cope with unexpected section header sizes. */
4793 if (size
== 0 || num
== 0)
4795 if (size
< sizeof * phdrs
)
4797 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4800 if (size
> sizeof * phdrs
)
4801 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4803 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4804 size
, num
, _("program headers"));
4808 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4809 i
< elf_header
.e_phnum
;
4810 i
++, internal
++, external
++)
4812 internal
->p_type
= BYTE_GET (external
->p_type
);
4813 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4814 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4815 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4816 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4817 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4818 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4819 internal
->p_align
= BYTE_GET (external
->p_align
);
4826 /* Returns TRUE if the program headers were read into `program_headers'. */
4829 get_program_headers (FILE * file
)
4831 Elf_Internal_Phdr
* phdrs
;
4833 /* Check cache of prior read. */
4834 if (program_headers
!= NULL
)
4837 /* Be kind to memory checkers by looking for
4838 e_phnum values which we know must be invalid. */
4839 if (elf_header
.e_phnum
4840 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4841 >= current_file_size
)
4843 error (_("Too many program headers - %#x - the file is not that big\n"),
4844 elf_header
.e_phnum
);
4848 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4849 sizeof (Elf_Internal_Phdr
));
4852 error (_("Out of memory reading %u program headers\n"),
4853 elf_header
.e_phnum
);
4858 ? get_32bit_program_headers (file
, phdrs
)
4859 : get_64bit_program_headers (file
, phdrs
))
4861 program_headers
= phdrs
;
4869 /* Returns TRUE if the program headers were loaded. */
4872 process_program_headers (FILE * file
)
4874 Elf_Internal_Phdr
* segment
;
4876 Elf_Internal_Phdr
* previous_load
= NULL
;
4878 if (elf_header
.e_phnum
== 0)
4880 /* PR binutils/12467. */
4881 if (elf_header
.e_phoff
!= 0)
4883 warn (_("possibly corrupt ELF header - it has a non-zero program"
4884 " header offset, but no program headers\n"));
4887 else if (do_segments
)
4888 printf (_("\nThere are no program headers in this file.\n"));
4892 if (do_segments
&& !do_header
)
4894 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4895 printf (_("Entry point "));
4896 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4897 printf (_("\nThere are %d program headers, starting at offset "),
4898 elf_header
.e_phnum
);
4899 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4903 if (! get_program_headers (file
))
4908 if (elf_header
.e_phnum
> 1)
4909 printf (_("\nProgram Headers:\n"));
4911 printf (_("\nProgram Headers:\n"));
4915 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4918 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4922 (_(" Type Offset VirtAddr PhysAddr\n"));
4924 (_(" FileSiz MemSiz Flags Align\n"));
4931 for (i
= 0, segment
= program_headers
;
4932 i
< elf_header
.e_phnum
;
4937 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4941 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4942 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4943 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4944 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4945 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4947 (segment
->p_flags
& PF_R
? 'R' : ' '),
4948 (segment
->p_flags
& PF_W
? 'W' : ' '),
4949 (segment
->p_flags
& PF_X
? 'E' : ' '));
4950 printf ("%#lx", (unsigned long) segment
->p_align
);
4954 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4955 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4958 print_vma (segment
->p_offset
, FULL_HEX
);
4962 print_vma (segment
->p_vaddr
, FULL_HEX
);
4964 print_vma (segment
->p_paddr
, FULL_HEX
);
4967 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4968 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4971 print_vma (segment
->p_filesz
, FULL_HEX
);
4975 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4976 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4979 print_vma (segment
->p_memsz
, FULL_HEX
);
4983 (segment
->p_flags
& PF_R
? 'R' : ' '),
4984 (segment
->p_flags
& PF_W
? 'W' : ' '),
4985 (segment
->p_flags
& PF_X
? 'E' : ' '));
4987 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4988 printf ("%#lx", (unsigned long) segment
->p_align
);
4991 print_vma (segment
->p_align
, PREFIX_HEX
);
4996 print_vma (segment
->p_offset
, FULL_HEX
);
4998 print_vma (segment
->p_vaddr
, FULL_HEX
);
5000 print_vma (segment
->p_paddr
, FULL_HEX
);
5002 print_vma (segment
->p_filesz
, FULL_HEX
);
5004 print_vma (segment
->p_memsz
, FULL_HEX
);
5006 (segment
->p_flags
& PF_R
? 'R' : ' '),
5007 (segment
->p_flags
& PF_W
? 'W' : ' '),
5008 (segment
->p_flags
& PF_X
? 'E' : ' '));
5009 print_vma (segment
->p_align
, PREFIX_HEX
);
5012 putc ('\n', stdout
);
5015 switch (segment
->p_type
)
5018 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5019 required by the ELF standard, several programs, including the Linux
5020 kernel, make use of non-ordered segments. */
5022 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5023 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5025 if (segment
->p_memsz
< segment
->p_filesz
)
5026 error (_("the segment's file size is larger than its memory size\n"));
5027 previous_load
= segment
;
5031 /* PR 20815 - Verify that the program header is loaded into memory. */
5032 if (i
> 0 && previous_load
!= NULL
)
5033 error (_("the PHDR segment must occur before any LOAD segment\n"));
5034 if (elf_header
.e_machine
!= EM_PARISC
)
5038 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
5039 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5040 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
5041 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5043 if (j
== elf_header
.e_phnum
)
5044 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5050 error (_("more than one dynamic segment\n"));
5052 /* By default, assume that the .dynamic section is the first
5053 section in the DYNAMIC segment. */
5054 dynamic_addr
= segment
->p_offset
;
5055 dynamic_size
= segment
->p_filesz
;
5057 /* Try to locate the .dynamic section. If there is
5058 a section header table, we can easily locate it. */
5059 if (section_headers
!= NULL
)
5061 Elf_Internal_Shdr
* sec
;
5063 sec
= find_section (".dynamic");
5064 if (sec
== NULL
|| sec
->sh_size
== 0)
5066 /* A corresponding .dynamic section is expected, but on
5067 IA-64/OpenVMS it is OK for it to be missing. */
5068 if (!is_ia64_vms ())
5069 error (_("no .dynamic section in the dynamic segment\n"));
5073 if (sec
->sh_type
== SHT_NOBITS
)
5079 dynamic_addr
= sec
->sh_offset
;
5080 dynamic_size
= sec
->sh_size
;
5082 if (dynamic_addr
< segment
->p_offset
5083 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5084 warn (_("the .dynamic section is not contained"
5085 " within the dynamic segment\n"));
5086 else if (dynamic_addr
> segment
->p_offset
)
5087 warn (_("the .dynamic section is not the first section"
5088 " in the dynamic segment.\n"));
5091 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5092 segment. Check this after matching against the section headers
5093 so we don't warn on debuginfo file (which have NOBITS .dynamic
5095 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5097 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5098 dynamic_addr
= dynamic_size
= 0;
5103 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5105 error (_("Unable to find program interpreter name\n"));
5109 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5111 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5112 error (_("Internal error: failed to create format string to display program interpreter\n"));
5114 program_interpreter
[0] = 0;
5115 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5116 error (_("Unable to read program interpreter name\n"));
5119 printf (_(" [Requesting program interpreter: %s]\n"),
5120 program_interpreter
);
5126 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5128 printf (_("\n Section to Segment mapping:\n"));
5129 printf (_(" Segment Sections...\n"));
5131 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5134 Elf_Internal_Shdr
* section
;
5136 segment
= program_headers
+ i
;
5137 section
= section_headers
+ 1;
5139 printf (" %2.2d ", i
);
5141 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5143 if (!ELF_TBSS_SPECIAL (section
, segment
)
5144 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5145 printf ("%s ", printable_section_name (section
));
5156 /* Find the file offset corresponding to VMA by using the program headers. */
5159 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5161 Elf_Internal_Phdr
* seg
;
5163 if (! get_program_headers (file
))
5165 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5169 for (seg
= program_headers
;
5170 seg
< program_headers
+ elf_header
.e_phnum
;
5173 if (seg
->p_type
!= PT_LOAD
)
5176 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5177 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5178 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5181 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5182 (unsigned long) vma
);
5187 /* Allocate memory and load the sections headers into the global pointer
5188 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5189 generate any error messages if the load fails. */
5192 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5194 Elf32_External_Shdr
* shdrs
;
5195 Elf_Internal_Shdr
* internal
;
5197 unsigned int size
= elf_header
.e_shentsize
;
5198 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5200 /* PR binutils/17531: Cope with unexpected section header sizes. */
5201 if (size
== 0 || num
== 0)
5203 if (size
< sizeof * shdrs
)
5206 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5209 if (!probe
&& size
> sizeof * shdrs
)
5210 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5212 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5214 probe
? NULL
: _("section headers"));
5218 if (section_headers
!= NULL
)
5219 free (section_headers
);
5220 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5221 sizeof (Elf_Internal_Shdr
));
5222 if (section_headers
== NULL
)
5225 error (_("Out of memory reading %u section headers\n"), num
);
5229 for (i
= 0, internal
= section_headers
;
5233 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5234 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5235 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5236 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5237 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5238 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5239 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5240 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5241 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5242 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5243 if (!probe
&& internal
->sh_link
> num
)
5244 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5245 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5246 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5254 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5256 Elf64_External_Shdr
* shdrs
;
5257 Elf_Internal_Shdr
* internal
;
5259 unsigned int size
= elf_header
.e_shentsize
;
5260 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5262 /* PR binutils/17531: Cope with unexpected section header sizes. */
5263 if (size
== 0 || num
== 0)
5265 if (size
< sizeof * shdrs
)
5268 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5271 if (! probe
&& size
> sizeof * shdrs
)
5272 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5274 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5276 probe
? NULL
: _("section headers"));
5280 if (section_headers
!= NULL
)
5281 free (section_headers
);
5282 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5283 sizeof (Elf_Internal_Shdr
));
5284 if (section_headers
== NULL
)
5287 error (_("Out of memory reading %u section headers\n"), num
);
5291 for (i
= 0, internal
= section_headers
;
5295 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5296 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5297 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5298 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5299 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5300 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5301 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5302 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5303 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5304 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5305 if (!probe
&& internal
->sh_link
> num
)
5306 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5307 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5308 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5315 static Elf_Internal_Sym
*
5316 get_32bit_elf_symbols (FILE * file
,
5317 Elf_Internal_Shdr
* section
,
5318 unsigned long * num_syms_return
)
5320 unsigned long number
= 0;
5321 Elf32_External_Sym
* esyms
= NULL
;
5322 Elf_External_Sym_Shndx
* shndx
= NULL
;
5323 Elf_Internal_Sym
* isyms
= NULL
;
5324 Elf_Internal_Sym
* psym
;
5327 if (section
->sh_size
== 0)
5329 if (num_syms_return
!= NULL
)
5330 * num_syms_return
= 0;
5334 /* Run some sanity checks first. */
5335 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5337 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5338 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5342 if (section
->sh_size
> current_file_size
)
5344 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5345 printable_section_name (section
), (unsigned long) section
->sh_size
);
5349 number
= section
->sh_size
/ section
->sh_entsize
;
5351 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5353 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5354 (unsigned long) section
->sh_size
,
5355 printable_section_name (section
),
5356 (unsigned long) section
->sh_entsize
);
5360 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5361 section
->sh_size
, _("symbols"));
5366 elf_section_list
* entry
;
5369 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5370 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5372 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5373 entry
->hdr
->sh_offset
,
5374 1, entry
->hdr
->sh_size
,
5375 _("symbol table section indicies"));
5378 /* PR17531: file: heap-buffer-overflow */
5379 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5381 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5382 printable_section_name (entry
->hdr
),
5383 (unsigned long) entry
->hdr
->sh_size
,
5384 (unsigned long) section
->sh_size
);
5390 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5394 error (_("Out of memory reading %lu symbols\n"),
5395 (unsigned long) number
);
5399 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5401 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5402 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5403 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5404 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5405 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5407 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5408 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5409 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5410 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5411 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5420 if (num_syms_return
!= NULL
)
5421 * num_syms_return
= isyms
== NULL
? 0 : number
;
5426 static Elf_Internal_Sym
*
5427 get_64bit_elf_symbols (FILE * file
,
5428 Elf_Internal_Shdr
* section
,
5429 unsigned long * num_syms_return
)
5431 unsigned long number
= 0;
5432 Elf64_External_Sym
* esyms
= NULL
;
5433 Elf_External_Sym_Shndx
* shndx
= NULL
;
5434 Elf_Internal_Sym
* isyms
= NULL
;
5435 Elf_Internal_Sym
* psym
;
5438 if (section
->sh_size
== 0)
5440 if (num_syms_return
!= NULL
)
5441 * num_syms_return
= 0;
5445 /* Run some sanity checks first. */
5446 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5448 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5449 printable_section_name (section
),
5450 (unsigned long) section
->sh_entsize
);
5454 if (section
->sh_size
> current_file_size
)
5456 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5457 printable_section_name (section
),
5458 (unsigned long) section
->sh_size
);
5462 number
= section
->sh_size
/ section
->sh_entsize
;
5464 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5466 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5467 (unsigned long) section
->sh_size
,
5468 printable_section_name (section
),
5469 (unsigned long) section
->sh_entsize
);
5473 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5474 section
->sh_size
, _("symbols"));
5479 elf_section_list
* entry
;
5482 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5483 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5485 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5486 entry
->hdr
->sh_offset
,
5487 1, entry
->hdr
->sh_size
,
5488 _("symbol table section indicies"));
5491 /* PR17531: file: heap-buffer-overflow */
5492 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5494 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5495 printable_section_name (entry
->hdr
),
5496 (unsigned long) entry
->hdr
->sh_size
,
5497 (unsigned long) section
->sh_size
);
5503 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5507 error (_("Out of memory reading %lu symbols\n"),
5508 (unsigned long) number
);
5512 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5514 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5515 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5516 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5517 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5519 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5521 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5522 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5523 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5525 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5526 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5535 if (num_syms_return
!= NULL
)
5536 * num_syms_return
= isyms
== NULL
? 0 : number
;
5542 get_elf_section_flags (bfd_vma sh_flags
)
5544 static char buff
[1024];
5546 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5548 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5549 bfd_vma os_flags
= 0;
5550 bfd_vma proc_flags
= 0;
5551 bfd_vma unknown_flags
= 0;
5559 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5560 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5561 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5562 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5563 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5564 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5565 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5566 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5567 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5568 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5569 /* IA-64 specific. */
5570 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5571 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5572 /* IA-64 OpenVMS specific. */
5573 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5574 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5575 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5576 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5577 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5578 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5580 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5581 /* SPARC specific. */
5582 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5583 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5585 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5586 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5587 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5589 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5592 if (do_section_details
)
5594 sprintf (buff
, "[%*.*lx]: ",
5595 field_size
, field_size
, (unsigned long) sh_flags
);
5596 p
+= field_size
+ 4;
5603 flag
= sh_flags
& - sh_flags
;
5606 if (do_section_details
)
5610 case SHF_WRITE
: sindex
= 0; break;
5611 case SHF_ALLOC
: sindex
= 1; break;
5612 case SHF_EXECINSTR
: sindex
= 2; break;
5613 case SHF_MERGE
: sindex
= 3; break;
5614 case SHF_STRINGS
: sindex
= 4; break;
5615 case SHF_INFO_LINK
: sindex
= 5; break;
5616 case SHF_LINK_ORDER
: sindex
= 6; break;
5617 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5618 case SHF_GROUP
: sindex
= 8; break;
5619 case SHF_TLS
: sindex
= 9; break;
5620 case SHF_EXCLUDE
: sindex
= 18; break;
5621 case SHF_COMPRESSED
: sindex
= 20; break;
5622 case SHF_GNU_MBIND
: sindex
= 24; break;
5626 switch (elf_header
.e_machine
)
5629 if (flag
== SHF_IA_64_SHORT
)
5631 else if (flag
== SHF_IA_64_NORECOV
)
5634 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5637 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5638 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5639 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5640 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5641 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5642 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5653 case EM_OLD_SPARCV9
:
5654 case EM_SPARC32PLUS
:
5657 if (flag
== SHF_ORDERED
)
5664 case SHF_ENTRYSECT
: sindex
= 21; break;
5665 case SHF_ARM_PURECODE
: sindex
= 22; break;
5666 case SHF_COMDEF
: sindex
= 23; break;
5678 if (p
!= buff
+ field_size
+ 4)
5680 if (size
< (10 + 2))
5682 warn (_("Internal error: not enough buffer room for section flag info"));
5683 return _("<unknown>");
5690 size
-= flags
[sindex
].len
;
5691 p
= stpcpy (p
, flags
[sindex
].str
);
5693 else if (flag
& SHF_MASKOS
)
5695 else if (flag
& SHF_MASKPROC
)
5698 unknown_flags
|= flag
;
5704 case SHF_WRITE
: *p
= 'W'; break;
5705 case SHF_ALLOC
: *p
= 'A'; break;
5706 case SHF_EXECINSTR
: *p
= 'X'; break;
5707 case SHF_MERGE
: *p
= 'M'; break;
5708 case SHF_STRINGS
: *p
= 'S'; break;
5709 case SHF_INFO_LINK
: *p
= 'I'; break;
5710 case SHF_LINK_ORDER
: *p
= 'L'; break;
5711 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5712 case SHF_GROUP
: *p
= 'G'; break;
5713 case SHF_TLS
: *p
= 'T'; break;
5714 case SHF_EXCLUDE
: *p
= 'E'; break;
5715 case SHF_COMPRESSED
: *p
= 'C'; break;
5716 case SHF_GNU_MBIND
: *p
= 'D'; break;
5719 if ((elf_header
.e_machine
== EM_X86_64
5720 || elf_header
.e_machine
== EM_L1OM
5721 || elf_header
.e_machine
== EM_K1OM
)
5722 && flag
== SHF_X86_64_LARGE
)
5724 else if (elf_header
.e_machine
== EM_ARM
5725 && flag
== SHF_ARM_PURECODE
)
5727 else if (flag
& SHF_MASKOS
)
5730 sh_flags
&= ~ SHF_MASKOS
;
5732 else if (flag
& SHF_MASKPROC
)
5735 sh_flags
&= ~ SHF_MASKPROC
;
5745 if (do_section_details
)
5749 size
-= 5 + field_size
;
5750 if (p
!= buff
+ field_size
+ 4)
5754 warn (_("Internal error: not enough buffer room for section flag info"));
5755 return _("<unknown>");
5761 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5762 (unsigned long) os_flags
);
5763 p
+= 5 + field_size
;
5767 size
-= 7 + field_size
;
5768 if (p
!= buff
+ field_size
+ 4)
5772 warn (_("Internal error: not enough buffer room for section flag info"));
5773 return _("<unknown>");
5779 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5780 (unsigned long) proc_flags
);
5781 p
+= 7 + field_size
;
5785 size
-= 10 + field_size
;
5786 if (p
!= buff
+ field_size
+ 4)
5790 warn (_("Internal error: not enough buffer room for section flag info"));
5791 return _("<unknown>");
5797 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5798 (unsigned long) unknown_flags
);
5799 p
+= 10 + field_size
;
5808 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5812 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5814 if (size
< sizeof (* echdr
))
5816 error (_("Compressed section is too small even for a compression header\n"));
5820 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5821 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5822 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5823 return sizeof (*echdr
);
5827 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5829 if (size
< sizeof (* echdr
))
5831 error (_("Compressed section is too small even for a compression header\n"));
5835 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5836 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5837 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5838 return sizeof (*echdr
);
5843 process_section_headers (FILE * file
)
5845 Elf_Internal_Shdr
* section
;
5848 section_headers
= NULL
;
5850 if (elf_header
.e_shnum
== 0)
5852 /* PR binutils/12467. */
5853 if (elf_header
.e_shoff
!= 0)
5855 warn (_("possibly corrupt ELF file header - it has a non-zero"
5856 " section header offset, but no section headers\n"));
5859 else if (do_sections
)
5860 printf (_("\nThere are no sections in this file.\n"));
5865 if (do_sections
&& !do_header
)
5866 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5867 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5871 if (! get_32bit_section_headers (file
, FALSE
))
5876 if (! get_64bit_section_headers (file
, FALSE
))
5880 /* Read in the string table, so that we have names to display. */
5881 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5882 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5884 section
= section_headers
+ elf_header
.e_shstrndx
;
5886 if (section
->sh_size
!= 0)
5888 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5889 1, section
->sh_size
,
5892 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5896 /* Scan the sections for the dynamic symbol table
5897 and dynamic string table and debug sections. */
5898 dynamic_symbols
= NULL
;
5899 dynamic_strings
= NULL
;
5900 dynamic_syminfo
= NULL
;
5901 symtab_shndx_list
= NULL
;
5903 eh_addr_size
= is_32bit_elf
? 4 : 8;
5904 switch (elf_header
.e_machine
)
5907 case EM_MIPS_RS3_LE
:
5908 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5909 FDE addresses. However, the ABI also has a semi-official ILP32
5910 variant for which the normal FDE address size rules apply.
5912 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5913 section, where XX is the size of longs in bits. Unfortunately,
5914 earlier compilers provided no way of distinguishing ILP32 objects
5915 from LP64 objects, so if there's any doubt, we should assume that
5916 the official LP64 form is being used. */
5917 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5918 && find_section (".gcc_compiled_long32") == NULL
)
5924 switch (elf_header
.e_flags
& EF_H8_MACH
)
5926 case E_H8_MACH_H8300
:
5927 case E_H8_MACH_H8300HN
:
5928 case E_H8_MACH_H8300SN
:
5929 case E_H8_MACH_H8300SXN
:
5932 case E_H8_MACH_H8300H
:
5933 case E_H8_MACH_H8300S
:
5934 case E_H8_MACH_H8300SX
:
5942 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5944 case EF_M32C_CPU_M16C
:
5951 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5954 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5955 if (section->sh_entsize != expected_entsize) \
5958 sprintf_vma (buf, section->sh_entsize); \
5959 /* Note: coded this way so that there is a single string for \
5961 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5962 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5963 (unsigned) expected_entsize); \
5964 section->sh_entsize = expected_entsize; \
5969 #define CHECK_ENTSIZE(section, i, type) \
5970 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5971 sizeof (Elf64_External_##type))
5973 for (i
= 0, section
= section_headers
;
5974 i
< elf_header
.e_shnum
;
5977 char * name
= SECTION_NAME (section
);
5979 if (section
->sh_type
== SHT_DYNSYM
)
5981 if (dynamic_symbols
!= NULL
)
5983 error (_("File contains multiple dynamic symbol tables\n"));
5987 CHECK_ENTSIZE (section
, i
, Sym
);
5988 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5990 else if (section
->sh_type
== SHT_STRTAB
5991 && streq (name
, ".dynstr"))
5993 if (dynamic_strings
!= NULL
)
5995 error (_("File contains multiple dynamic string tables\n"));
5999 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
6000 1, section
->sh_size
,
6001 _("dynamic strings"));
6002 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6004 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6006 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6007 entry
->hdr
= section
;
6008 entry
->next
= symtab_shndx_list
;
6009 symtab_shndx_list
= entry
;
6011 else if (section
->sh_type
== SHT_SYMTAB
)
6012 CHECK_ENTSIZE (section
, i
, Sym
);
6013 else if (section
->sh_type
== SHT_GROUP
)
6014 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6015 else if (section
->sh_type
== SHT_REL
)
6016 CHECK_ENTSIZE (section
, i
, Rel
);
6017 else if (section
->sh_type
== SHT_RELA
)
6018 CHECK_ENTSIZE (section
, i
, Rela
);
6019 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6020 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6021 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6022 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6023 || do_debug_addr
|| do_debug_cu_index
)
6024 && (const_strneq (name
, ".debug_")
6025 || const_strneq (name
, ".zdebug_")))
6028 name
+= sizeof (".zdebug_") - 1;
6030 name
+= sizeof (".debug_") - 1;
6033 || (do_debug_info
&& const_strneq (name
, "info"))
6034 || (do_debug_info
&& const_strneq (name
, "types"))
6035 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6036 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6037 || (do_debug_lines
&& const_strneq (name
, "line."))
6038 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6039 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6040 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6041 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6042 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6043 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6044 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6045 || (do_debug_frames
&& const_strneq (name
, "frame"))
6046 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6047 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6048 || (do_debug_str
&& const_strneq (name
, "str"))
6049 || (do_debug_loc
&& const_strneq (name
, "loc"))
6050 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6051 || (do_debug_addr
&& const_strneq (name
, "addr"))
6052 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6053 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6055 request_dump_bynumber (i
, DEBUG_DUMP
);
6057 /* Linkonce section to be combined with .debug_info at link time. */
6058 else if ((do_debugging
|| do_debug_info
)
6059 && const_strneq (name
, ".gnu.linkonce.wi."))
6060 request_dump_bynumber (i
, DEBUG_DUMP
);
6061 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6062 request_dump_bynumber (i
, DEBUG_DUMP
);
6063 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
6064 request_dump_bynumber (i
, DEBUG_DUMP
);
6065 /* Trace sections for Itanium VMS. */
6066 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6067 || do_trace_aranges
)
6068 && const_strneq (name
, ".trace_"))
6070 name
+= sizeof (".trace_") - 1;
6073 || (do_trace_info
&& streq (name
, "info"))
6074 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6075 || (do_trace_aranges
&& streq (name
, "aranges"))
6077 request_dump_bynumber (i
, DEBUG_DUMP
);
6084 if (elf_header
.e_shnum
> 1)
6085 printf (_("\nSection Headers:\n"));
6087 printf (_("\nSection Header:\n"));
6091 if (do_section_details
)
6093 printf (_(" [Nr] Name\n"));
6094 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6098 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6102 if (do_section_details
)
6104 printf (_(" [Nr] Name\n"));
6105 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6109 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6113 if (do_section_details
)
6115 printf (_(" [Nr] Name\n"));
6116 printf (_(" Type Address Offset Link\n"));
6117 printf (_(" Size EntSize Info Align\n"));
6121 printf (_(" [Nr] Name Type Address Offset\n"));
6122 printf (_(" Size EntSize Flags Link Info Align\n"));
6126 if (do_section_details
)
6127 printf (_(" Flags\n"));
6129 for (i
= 0, section
= section_headers
;
6130 i
< elf_header
.e_shnum
;
6133 /* Run some sanity checks on the section header. */
6135 /* Check the sh_link field. */
6136 switch (section
->sh_type
)
6138 case SHT_SYMTAB_SHNDX
:
6142 case SHT_GNU_versym
:
6145 if (section
->sh_link
< 1
6146 || section
->sh_link
>= elf_header
.e_shnum
6147 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6148 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6149 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6150 i
, section
->sh_link
);
6156 case SHT_GNU_verneed
:
6157 case SHT_GNU_verdef
:
6158 case SHT_GNU_LIBLIST
:
6159 if (section
->sh_link
< 1
6160 || section
->sh_link
>= elf_header
.e_shnum
6161 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6162 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6163 i
, section
->sh_link
);
6166 case SHT_INIT_ARRAY
:
6167 case SHT_FINI_ARRAY
:
6168 case SHT_PREINIT_ARRAY
:
6169 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6170 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6171 i
, section
->sh_link
);
6175 /* FIXME: Add support for target specific section types. */
6176 #if 0 /* Currently we do not check other section types as there are too
6177 many special cases. Stab sections for example have a type
6178 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6180 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6181 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6182 i
, section
->sh_link
);
6187 /* Check the sh_info field. */
6188 switch (section
->sh_type
)
6192 if (section
->sh_info
< 1
6193 || section
->sh_info
>= elf_header
.e_shnum
6194 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6195 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6196 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6197 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6198 /* FIXME: Are other section types valid ? */
6199 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6201 if (section
->sh_info
== 0
6202 && (streq (SECTION_NAME (section
), ".rel.dyn")
6203 || streq (SECTION_NAME (section
), ".rela.dyn")))
6204 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6205 of zero. The relocations in these sections may apply
6206 to many different sections. */
6209 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6210 i
, section
->sh_info
);
6216 case SHT_SYMTAB_SHNDX
:
6217 case SHT_INIT_ARRAY
:
6218 case SHT_FINI_ARRAY
:
6219 case SHT_PREINIT_ARRAY
:
6220 if (section
->sh_info
!= 0)
6221 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6222 i
, section
->sh_info
);
6228 /* A symbol index - we assume that it is valid. */
6232 /* FIXME: Add support for target specific section types. */
6233 if (section
->sh_type
== SHT_NOBITS
)
6234 /* NOBITS section headers with non-zero sh_info fields can be
6235 created when a binary is stripped of everything but its debug
6236 information. The stripped sections have their headers
6237 preserved but their types set to SHT_NOBITS. So do not check
6238 this type of section. */
6240 else if (section
->sh_flags
& SHF_INFO_LINK
)
6242 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6243 warn (_("[%2u]: Expected link to another section in info field"), i
);
6245 else if (section
->sh_type
< SHT_LOOS
6246 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6247 && section
->sh_info
!= 0)
6248 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6249 i
, section
->sh_info
);
6253 /* Check the sh_size field. */
6254 if (section
->sh_size
> current_file_size
6255 && section
->sh_type
!= SHT_NOBITS
6256 && section
->sh_type
!= SHT_NULL
6257 && section
->sh_type
< SHT_LOOS
)
6258 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6260 printf (" [%2u] ", i
);
6261 if (do_section_details
)
6262 printf ("%s\n ", printable_section_name (section
));
6264 print_symbol (-17, SECTION_NAME (section
));
6266 printf (do_wide
? " %-15s " : " %-15.15s ",
6267 get_section_type_name (section
->sh_type
));
6271 const char * link_too_big
= NULL
;
6273 print_vma (section
->sh_addr
, LONG_HEX
);
6275 printf ( " %6.6lx %6.6lx %2.2lx",
6276 (unsigned long) section
->sh_offset
,
6277 (unsigned long) section
->sh_size
,
6278 (unsigned long) section
->sh_entsize
);
6280 if (do_section_details
)
6281 fputs (" ", stdout
);
6283 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6285 if (section
->sh_link
>= elf_header
.e_shnum
)
6288 /* The sh_link value is out of range. Normally this indicates
6289 an error but it can have special values in Solaris binaries. */
6290 switch (elf_header
.e_machine
)
6297 case EM_OLD_SPARCV9
:
6298 case EM_SPARC32PLUS
:
6301 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6302 link_too_big
= "BEFORE";
6303 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6304 link_too_big
= "AFTER";
6311 if (do_section_details
)
6313 if (link_too_big
!= NULL
&& * link_too_big
)
6314 printf ("<%s> ", link_too_big
);
6316 printf ("%2u ", section
->sh_link
);
6317 printf ("%3u %2lu\n", section
->sh_info
,
6318 (unsigned long) section
->sh_addralign
);
6321 printf ("%2u %3u %2lu\n",
6324 (unsigned long) section
->sh_addralign
);
6326 if (link_too_big
&& ! * link_too_big
)
6327 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6328 i
, section
->sh_link
);
6332 print_vma (section
->sh_addr
, LONG_HEX
);
6334 if ((long) section
->sh_offset
== section
->sh_offset
)
6335 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6339 print_vma (section
->sh_offset
, LONG_HEX
);
6342 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6343 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6347 print_vma (section
->sh_size
, LONG_HEX
);
6350 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6351 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6355 print_vma (section
->sh_entsize
, LONG_HEX
);
6358 if (do_section_details
)
6359 fputs (" ", stdout
);
6361 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6363 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6365 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6366 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6369 print_vma (section
->sh_addralign
, DEC
);
6373 else if (do_section_details
)
6375 printf (" %-15.15s ",
6376 get_section_type_name (section
->sh_type
));
6377 print_vma (section
->sh_addr
, LONG_HEX
);
6378 if ((long) section
->sh_offset
== section
->sh_offset
)
6379 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6383 print_vma (section
->sh_offset
, LONG_HEX
);
6385 printf (" %u\n ", section
->sh_link
);
6386 print_vma (section
->sh_size
, LONG_HEX
);
6388 print_vma (section
->sh_entsize
, LONG_HEX
);
6390 printf (" %-16u %lu\n",
6392 (unsigned long) section
->sh_addralign
);
6397 print_vma (section
->sh_addr
, LONG_HEX
);
6398 if ((long) section
->sh_offset
== section
->sh_offset
)
6399 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6403 print_vma (section
->sh_offset
, LONG_HEX
);
6406 print_vma (section
->sh_size
, LONG_HEX
);
6408 print_vma (section
->sh_entsize
, LONG_HEX
);
6410 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6412 printf (" %2u %3u %lu\n",
6415 (unsigned long) section
->sh_addralign
);
6418 if (do_section_details
)
6420 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6421 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6423 /* Minimum section size is 12 bytes for 32-bit compression
6424 header + 12 bytes for compressed data header. */
6425 unsigned char buf
[24];
6427 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6428 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6429 sizeof (buf
), _("compression header")))
6431 Elf_Internal_Chdr chdr
;
6433 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6435 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6438 printf (_(" [<unknown>: 0x%x], "),
6440 print_vma (chdr
.ch_size
, LONG_HEX
);
6441 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6447 if (!do_section_details
)
6449 /* The ordering of the letters shown here matches the ordering of the
6450 corresponding SHF_xxx values, and hence the order in which these
6451 letters will be displayed to the user. */
6452 printf (_("Key to Flags:\n\
6453 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6454 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6455 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6456 if (elf_header
.e_machine
== EM_X86_64
6457 || elf_header
.e_machine
== EM_L1OM
6458 || elf_header
.e_machine
== EM_K1OM
)
6459 printf (_("l (large), "));
6460 else if (elf_header
.e_machine
== EM_ARM
)
6461 printf (_("y (purecode), "));
6462 printf ("p (processor specific)\n");
6469 get_group_flags (unsigned int flags
)
6471 static char buff
[128];
6475 else if (flags
== GRP_COMDAT
)
6478 snprintf (buff
, 14, _("[0x%x: "), flags
);
6480 flags
&= ~ GRP_COMDAT
;
6481 if (flags
& GRP_MASKOS
)
6483 strcat (buff
, "<OS specific>");
6484 flags
&= ~ GRP_MASKOS
;
6487 if (flags
& GRP_MASKPROC
)
6489 strcat (buff
, "<PROC specific>");
6490 flags
&= ~ GRP_MASKPROC
;
6494 strcat (buff
, "<unknown>");
6501 process_section_groups (FILE * file
)
6503 Elf_Internal_Shdr
* section
;
6505 struct group
* group
;
6506 Elf_Internal_Shdr
* symtab_sec
;
6507 Elf_Internal_Shdr
* strtab_sec
;
6508 Elf_Internal_Sym
* symtab
;
6509 unsigned long num_syms
;
6513 /* Don't process section groups unless needed. */
6514 if (!do_unwind
&& !do_section_groups
)
6517 if (elf_header
.e_shnum
== 0)
6519 if (do_section_groups
)
6520 printf (_("\nThere are no sections to group in this file.\n"));
6525 if (section_headers
== NULL
)
6527 error (_("Section headers are not available!\n"));
6528 /* PR 13622: This can happen with a corrupt ELF header. */
6532 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6533 sizeof (struct group
*));
6535 if (section_headers_groups
== NULL
)
6537 error (_("Out of memory reading %u section group headers\n"),
6538 elf_header
.e_shnum
);
6542 /* Scan the sections for the group section. */
6544 for (i
= 0, section
= section_headers
;
6545 i
< elf_header
.e_shnum
;
6547 if (section
->sh_type
== SHT_GROUP
)
6550 if (group_count
== 0)
6552 if (do_section_groups
)
6553 printf (_("\nThere are no section groups in this file.\n"));
6558 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6560 if (section_groups
== NULL
)
6562 error (_("Out of memory reading %lu groups\n"),
6563 (unsigned long) group_count
);
6573 for (i
= 0, section
= section_headers
, group
= section_groups
;
6574 i
< elf_header
.e_shnum
;
6577 if (section
->sh_type
== SHT_GROUP
)
6579 const char * name
= printable_section_name (section
);
6580 const char * group_name
;
6581 unsigned char * start
;
6582 unsigned char * indices
;
6583 unsigned int entry
, j
, size
;
6584 Elf_Internal_Shdr
* sec
;
6585 Elf_Internal_Sym
* sym
;
6587 /* Get the symbol table. */
6588 if (section
->sh_link
>= elf_header
.e_shnum
6589 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6592 error (_("Bad sh_link in group section `%s'\n"), name
);
6596 if (symtab_sec
!= sec
)
6601 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6606 error (_("Corrupt header in group section `%s'\n"), name
);
6610 if (section
->sh_info
>= num_syms
)
6612 error (_("Bad sh_info in group section `%s'\n"), name
);
6616 sym
= symtab
+ section
->sh_info
;
6618 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6620 if (sym
->st_shndx
== 0
6621 || sym
->st_shndx
>= elf_header
.e_shnum
)
6623 error (_("Bad sh_info in group section `%s'\n"), name
);
6627 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6636 /* Get the string table. */
6637 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6646 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6652 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6653 1, strtab_sec
->sh_size
,
6655 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6657 group_name
= sym
->st_name
< strtab_size
6658 ? strtab
+ sym
->st_name
: _("<corrupt>");
6661 /* PR 17531: file: loop. */
6662 if (section
->sh_entsize
> section
->sh_size
)
6664 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6665 printable_section_name (section
),
6666 (unsigned long) section
->sh_entsize
,
6667 (unsigned long) section
->sh_size
);
6671 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6672 1, section
->sh_size
,
6678 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6679 entry
= byte_get (indices
, 4);
6682 if (do_section_groups
)
6684 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6685 get_group_flags (entry
), i
, name
, group_name
, size
);
6687 printf (_(" [Index] Name\n"));
6690 group
->group_index
= i
;
6692 for (j
= 0; j
< size
; j
++)
6694 struct group_list
* g
;
6696 entry
= byte_get (indices
, 4);
6699 if (entry
>= elf_header
.e_shnum
)
6701 static unsigned num_group_errors
= 0;
6703 if (num_group_errors
++ < 10)
6705 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6706 entry
, i
, elf_header
.e_shnum
- 1);
6707 if (num_group_errors
== 10)
6708 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6713 if (section_headers_groups
[entry
] != NULL
)
6717 static unsigned num_errs
= 0;
6719 if (num_errs
++ < 10)
6721 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6723 section_headers_groups
[entry
]->group_index
);
6725 warn (_("Further error messages about already contained group sections suppressed\n"));
6731 /* Intel C/C++ compiler may put section 0 in a
6732 section group. We just warn it the first time
6733 and ignore it afterwards. */
6734 static bfd_boolean warned
= FALSE
;
6737 error (_("section 0 in group section [%5u]\n"),
6738 section_headers_groups
[entry
]->group_index
);
6744 section_headers_groups
[entry
] = group
;
6746 if (do_section_groups
)
6748 sec
= section_headers
+ entry
;
6749 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6752 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6753 g
->section_index
= entry
;
6754 g
->next
= group
->root
;
6772 /* Data used to display dynamic fixups. */
6774 struct ia64_vms_dynfixup
6776 bfd_vma needed_ident
; /* Library ident number. */
6777 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6778 bfd_vma fixup_needed
; /* Index of the library. */
6779 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6780 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6783 /* Data used to display dynamic relocations. */
6785 struct ia64_vms_dynimgrela
6787 bfd_vma img_rela_cnt
; /* Number of relocations. */
6788 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6791 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6795 dump_ia64_vms_dynamic_fixups (FILE * file
,
6796 struct ia64_vms_dynfixup
* fixup
,
6797 const char * strtab
,
6798 unsigned int strtab_sz
)
6800 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6802 const char * lib_name
;
6804 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6805 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6806 _("dynamic section image fixups"));
6810 if (fixup
->needed
< strtab_sz
)
6811 lib_name
= strtab
+ fixup
->needed
;
6814 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6815 (unsigned long) fixup
->needed
);
6818 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6819 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6821 (_("Seg Offset Type SymVec DataType\n"));
6823 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6828 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6829 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6830 type
= BYTE_GET (imfs
[i
].type
);
6831 rtype
= elf_ia64_reloc_type (type
);
6833 printf (" 0x%08x ", type
);
6835 printf (" %-32s ", rtype
);
6836 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6837 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6844 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6847 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6849 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6852 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6853 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6854 _("dynamic section image relocations"));
6858 printf (_("\nImage relocs\n"));
6860 (_("Seg Offset Type Addend Seg Sym Off\n"));
6862 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6867 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6868 printf ("%08" BFD_VMA_FMT
"x ",
6869 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6870 type
= BYTE_GET (imrs
[i
].type
);
6871 rtype
= elf_ia64_reloc_type (type
);
6873 printf ("0x%08x ", type
);
6875 printf ("%-31s ", rtype
);
6876 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6877 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6878 printf ("%08" BFD_VMA_FMT
"x\n",
6879 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6886 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6889 process_ia64_vms_dynamic_relocs (FILE *file
)
6891 struct ia64_vms_dynfixup fixup
;
6892 struct ia64_vms_dynimgrela imgrela
;
6893 Elf_Internal_Dyn
*entry
;
6894 bfd_vma strtab_off
= 0;
6895 bfd_vma strtab_sz
= 0;
6896 char *strtab
= NULL
;
6897 bfd_boolean res
= TRUE
;
6899 memset (&fixup
, 0, sizeof (fixup
));
6900 memset (&imgrela
, 0, sizeof (imgrela
));
6902 /* Note: the order of the entries is specified by the OpenVMS specs. */
6903 for (entry
= dynamic_section
;
6904 entry
< dynamic_section
+ dynamic_nent
;
6907 switch (entry
->d_tag
)
6909 case DT_IA_64_VMS_STRTAB_OFFSET
:
6910 strtab_off
= entry
->d_un
.d_val
;
6913 strtab_sz
= entry
->d_un
.d_val
;
6915 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6916 1, strtab_sz
, _("dynamic string section"));
6919 case DT_IA_64_VMS_NEEDED_IDENT
:
6920 fixup
.needed_ident
= entry
->d_un
.d_val
;
6923 fixup
.needed
= entry
->d_un
.d_val
;
6925 case DT_IA_64_VMS_FIXUP_NEEDED
:
6926 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6928 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6929 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6931 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6932 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6933 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6936 case DT_IA_64_VMS_IMG_RELA_CNT
:
6937 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6939 case DT_IA_64_VMS_IMG_RELA_OFF
:
6940 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6941 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6963 dynamic_relocations
[] =
6965 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6966 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6967 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6970 /* Process the reloc section. */
6973 process_relocs (FILE * file
)
6975 unsigned long rel_size
;
6976 unsigned long rel_offset
;
6981 if (do_using_dynamic
)
6985 bfd_boolean has_dynamic_reloc
;
6988 has_dynamic_reloc
= FALSE
;
6990 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6992 is_rela
= dynamic_relocations
[i
].rela
;
6993 name
= dynamic_relocations
[i
].name
;
6994 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6995 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6998 has_dynamic_reloc
= TRUE
;
7000 if (is_rela
== UNKNOWN
)
7002 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7003 switch (dynamic_info
[DT_PLTREL
])
7017 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7018 name
, rel_offset
, rel_size
);
7020 dump_relocations (file
,
7021 offset_from_vma (file
, rel_offset
, rel_size
),
7023 dynamic_symbols
, num_dynamic_syms
,
7024 dynamic_strings
, dynamic_strings_length
,
7025 is_rela
, TRUE
/* is_dynamic */);
7030 if (process_ia64_vms_dynamic_relocs (file
))
7031 has_dynamic_reloc
= TRUE
;
7033 if (! has_dynamic_reloc
)
7034 printf (_("\nThere are no dynamic relocations in this file.\n"));
7038 Elf_Internal_Shdr
* section
;
7040 bfd_boolean found
= FALSE
;
7042 for (i
= 0, section
= section_headers
;
7043 i
< elf_header
.e_shnum
;
7046 if ( section
->sh_type
!= SHT_RELA
7047 && section
->sh_type
!= SHT_REL
)
7050 rel_offset
= section
->sh_offset
;
7051 rel_size
= section
->sh_size
;
7055 Elf_Internal_Shdr
* strsec
;
7058 printf (_("\nRelocation section "));
7060 if (string_table
== NULL
)
7061 printf ("%d", section
->sh_name
);
7063 printf ("'%s'", printable_section_name (section
));
7065 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7066 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
7068 is_rela
= section
->sh_type
== SHT_RELA
;
7070 if (section
->sh_link
!= 0
7071 && section
->sh_link
< elf_header
.e_shnum
)
7073 Elf_Internal_Shdr
* symsec
;
7074 Elf_Internal_Sym
* symtab
;
7075 unsigned long nsyms
;
7076 unsigned long strtablen
= 0;
7077 char * strtab
= NULL
;
7079 symsec
= section_headers
+ section
->sh_link
;
7080 if (symsec
->sh_type
!= SHT_SYMTAB
7081 && symsec
->sh_type
!= SHT_DYNSYM
)
7084 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7089 if (symsec
->sh_link
!= 0
7090 && symsec
->sh_link
< elf_header
.e_shnum
)
7092 strsec
= section_headers
+ symsec
->sh_link
;
7094 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7097 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7100 dump_relocations (file
, rel_offset
, rel_size
,
7101 symtab
, nsyms
, strtab
, strtablen
,
7103 symsec
->sh_type
== SHT_DYNSYM
);
7109 dump_relocations (file
, rel_offset
, rel_size
,
7110 NULL
, 0, NULL
, 0, is_rela
,
7111 FALSE
/* is_dynamic */);
7118 printf (_("\nThere are no relocations in this file.\n"));
7124 /* An absolute address consists of a section and an offset. If the
7125 section is NULL, the offset itself is the address, otherwise, the
7126 address equals to LOAD_ADDRESS(section) + offset. */
7130 unsigned short section
;
7134 #define ABSADDR(a) \
7136 ? section_headers [(a).section].sh_addr + (a).offset \
7139 /* Find the nearest symbol at or below ADDR. Returns the symbol
7140 name, if found, and the offset from the symbol to ADDR. */
7143 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7144 unsigned long nsyms
,
7145 const char * strtab
,
7146 unsigned long strtab_size
,
7147 struct absaddr addr
,
7148 const char ** symname
,
7151 bfd_vma dist
= 0x100000;
7152 Elf_Internal_Sym
* sym
;
7153 Elf_Internal_Sym
* beg
;
7154 Elf_Internal_Sym
* end
;
7155 Elf_Internal_Sym
* best
= NULL
;
7157 REMOVE_ARCH_BITS (addr
.offset
);
7159 end
= symtab
+ nsyms
;
7165 sym
= beg
+ (end
- beg
) / 2;
7167 value
= sym
->st_value
;
7168 REMOVE_ARCH_BITS (value
);
7170 if (sym
->st_name
!= 0
7171 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7172 && addr
.offset
>= value
7173 && addr
.offset
- value
< dist
)
7176 dist
= addr
.offset
- value
;
7181 if (addr
.offset
< value
)
7189 *symname
= (best
->st_name
>= strtab_size
7190 ? _("<corrupt>") : strtab
+ best
->st_name
);
7196 *offset
= addr
.offset
;
7199 static /* signed */ int
7200 symcmp (const void *p
, const void *q
)
7202 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7203 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7205 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7208 /* Process the unwind section. */
7210 #include "unwind-ia64.h"
7212 struct ia64_unw_table_entry
7214 struct absaddr start
;
7216 struct absaddr info
;
7219 struct ia64_unw_aux_info
7221 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7222 unsigned long table_len
; /* Length of unwind table. */
7223 unsigned char * info
; /* Unwind info. */
7224 unsigned long info_size
; /* Size of unwind info. */
7225 bfd_vma info_addr
; /* Starting address of unwind info. */
7226 bfd_vma seg_base
; /* Starting address of segment. */
7227 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7228 unsigned long nsyms
; /* Number of symbols. */
7229 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7230 unsigned long nfuns
; /* Number of entries in funtab. */
7231 char * strtab
; /* The string table. */
7232 unsigned long strtab_size
; /* Size of string table. */
7236 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7238 struct ia64_unw_table_entry
* tp
;
7239 unsigned long j
, nfuns
;
7241 bfd_boolean res
= TRUE
;
7243 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7244 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7245 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7246 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7248 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7250 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7254 const unsigned char * dp
;
7255 const unsigned char * head
;
7256 const unsigned char * end
;
7257 const char * procname
;
7259 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7260 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7262 fputs ("\n<", stdout
);
7266 fputs (procname
, stdout
);
7269 printf ("+%lx", (unsigned long) offset
);
7272 fputs (">: [", stdout
);
7273 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7274 fputc ('-', stdout
);
7275 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7276 printf ("], info at +0x%lx\n",
7277 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7279 /* PR 17531: file: 86232b32. */
7280 if (aux
->info
== NULL
)
7283 /* PR 17531: file: 0997b4d1. */
7284 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7286 warn (_("Invalid offset %lx in table entry %ld\n"),
7287 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7292 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7293 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7295 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7296 (unsigned) UNW_VER (stamp
),
7297 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7298 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7299 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7300 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7302 if (UNW_VER (stamp
) != 1)
7304 printf (_("\tUnknown version.\n"));
7309 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7310 /* PR 17531: file: 16ceda89. */
7311 if (end
> aux
->info
+ aux
->info_size
)
7312 end
= aux
->info
+ aux
->info_size
;
7313 for (dp
= head
+ 8; dp
< end
;)
7314 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7323 slurp_ia64_unwind_table (FILE * file
,
7324 struct ia64_unw_aux_info
* aux
,
7325 Elf_Internal_Shdr
* sec
)
7327 unsigned long size
, nrelas
, i
;
7328 Elf_Internal_Phdr
* seg
;
7329 struct ia64_unw_table_entry
* tep
;
7330 Elf_Internal_Shdr
* relsec
;
7331 Elf_Internal_Rela
* rela
;
7332 Elf_Internal_Rela
* rp
;
7333 unsigned char * table
;
7335 Elf_Internal_Sym
* sym
;
7336 const char * relname
;
7340 /* First, find the starting address of the segment that includes
7343 if (elf_header
.e_phnum
)
7345 if (! get_program_headers (file
))
7348 for (seg
= program_headers
;
7349 seg
< program_headers
+ elf_header
.e_phnum
;
7352 if (seg
->p_type
!= PT_LOAD
)
7355 if (sec
->sh_addr
>= seg
->p_vaddr
7356 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7358 aux
->seg_base
= seg
->p_vaddr
;
7364 /* Second, build the unwind table from the contents of the unwind section: */
7365 size
= sec
->sh_size
;
7366 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7371 aux
->table_len
= size
/ (3 * eh_addr_size
);
7372 aux
->table
= (struct ia64_unw_table_entry
*)
7373 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7376 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7378 tep
->start
.section
= SHN_UNDEF
;
7379 tep
->end
.section
= SHN_UNDEF
;
7380 tep
->info
.section
= SHN_UNDEF
;
7381 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7382 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7383 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7384 tep
->start
.offset
+= aux
->seg_base
;
7385 tep
->end
.offset
+= aux
->seg_base
;
7386 tep
->info
.offset
+= aux
->seg_base
;
7390 /* Third, apply any relocations to the unwind table: */
7391 for (relsec
= section_headers
;
7392 relsec
< section_headers
+ elf_header
.e_shnum
;
7395 if (relsec
->sh_type
!= SHT_RELA
7396 || relsec
->sh_info
>= elf_header
.e_shnum
7397 || section_headers
+ relsec
->sh_info
!= sec
)
7400 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7409 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7411 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7412 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7414 /* PR 17531: file: 9fa67536. */
7415 if (relname
== NULL
)
7417 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7421 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7423 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7427 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7429 /* PR 17531: file: 5bc8d9bf. */
7430 if (i
>= aux
->table_len
)
7432 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7436 switch (rp
->r_offset
/ eh_addr_size
% 3)
7439 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7440 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7443 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7444 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7447 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7448 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7462 ia64_process_unwind (FILE * file
)
7464 Elf_Internal_Shdr
* sec
;
7465 Elf_Internal_Shdr
* unwsec
= NULL
;
7466 Elf_Internal_Shdr
* strsec
;
7467 unsigned long i
, unwcount
= 0, unwstart
= 0;
7468 struct ia64_unw_aux_info aux
;
7469 bfd_boolean res
= TRUE
;
7471 memset (& aux
, 0, sizeof (aux
));
7473 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7475 if (sec
->sh_type
== SHT_SYMTAB
7476 && sec
->sh_link
< elf_header
.e_shnum
)
7478 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7480 strsec
= section_headers
+ sec
->sh_link
;
7481 if (aux
.strtab
!= NULL
)
7483 error (_("Multiple auxillary string tables encountered\n"));
7487 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7490 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7492 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7497 printf (_("\nThere are no unwind sections in this file.\n"));
7499 while (unwcount
-- > 0)
7504 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7505 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7506 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7511 /* We have already counted the number of SHT_IA64_UNWIND
7512 sections so the loop above should never fail. */
7513 assert (unwsec
!= NULL
);
7516 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7518 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7520 /* We need to find which section group it is in. */
7521 struct group_list
* g
;
7523 if (section_headers_groups
== NULL
7524 || section_headers_groups
[i
] == NULL
)
7525 i
= elf_header
.e_shnum
;
7528 g
= section_headers_groups
[i
]->root
;
7530 for (; g
!= NULL
; g
= g
->next
)
7532 sec
= section_headers
+ g
->section_index
;
7534 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7539 i
= elf_header
.e_shnum
;
7542 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7544 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7545 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7546 suffix
= SECTION_NAME (unwsec
) + len
;
7547 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7549 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7550 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7555 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7556 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7557 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7558 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7560 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7561 suffix
= SECTION_NAME (unwsec
) + len
;
7562 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7564 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7565 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7569 if (i
== elf_header
.e_shnum
)
7571 printf (_("\nCould not find unwind info section for "));
7573 if (string_table
== NULL
)
7574 printf ("%d", unwsec
->sh_name
);
7576 printf ("'%s'", printable_section_name (unwsec
));
7580 aux
.info_addr
= sec
->sh_addr
;
7581 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7584 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7586 printf (_("\nUnwind section "));
7588 if (string_table
== NULL
)
7589 printf ("%d", unwsec
->sh_name
);
7591 printf ("'%s'", printable_section_name (unwsec
));
7593 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7594 (unsigned long) unwsec
->sh_offset
,
7595 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7597 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7598 && aux
.table_len
> 0)
7599 dump_ia64_unwind (& aux
);
7602 free ((char *) aux
.table
);
7604 free ((char *) aux
.info
);
7613 free ((char *) aux
.strtab
);
7618 struct hppa_unw_table_entry
7620 struct absaddr start
;
7622 unsigned int Cannot_unwind
:1; /* 0 */
7623 unsigned int Millicode
:1; /* 1 */
7624 unsigned int Millicode_save_sr0
:1; /* 2 */
7625 unsigned int Region_description
:2; /* 3..4 */
7626 unsigned int reserved1
:1; /* 5 */
7627 unsigned int Entry_SR
:1; /* 6 */
7628 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7629 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7630 unsigned int Args_stored
:1; /* 16 */
7631 unsigned int Variable_Frame
:1; /* 17 */
7632 unsigned int Separate_Package_Body
:1; /* 18 */
7633 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7634 unsigned int Stack_Overflow_Check
:1; /* 20 */
7635 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7636 unsigned int Ada_Region
:1; /* 22 */
7637 unsigned int cxx_info
:1; /* 23 */
7638 unsigned int cxx_try_catch
:1; /* 24 */
7639 unsigned int sched_entry_seq
:1; /* 25 */
7640 unsigned int reserved2
:1; /* 26 */
7641 unsigned int Save_SP
:1; /* 27 */
7642 unsigned int Save_RP
:1; /* 28 */
7643 unsigned int Save_MRP_in_frame
:1; /* 29 */
7644 unsigned int extn_ptr_defined
:1; /* 30 */
7645 unsigned int Cleanup_defined
:1; /* 31 */
7647 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7648 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7649 unsigned int Large_frame
:1; /* 2 */
7650 unsigned int Pseudo_SP_Set
:1; /* 3 */
7651 unsigned int reserved4
:1; /* 4 */
7652 unsigned int Total_frame_size
:27; /* 5..31 */
7655 struct hppa_unw_aux_info
7657 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7658 unsigned long table_len
; /* Length of unwind table. */
7659 bfd_vma seg_base
; /* Starting address of segment. */
7660 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7661 unsigned long nsyms
; /* Number of symbols. */
7662 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7663 unsigned long nfuns
; /* Number of entries in funtab. */
7664 char * strtab
; /* The string table. */
7665 unsigned long strtab_size
; /* Size of string table. */
7669 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7671 struct hppa_unw_table_entry
* tp
;
7672 unsigned long j
, nfuns
;
7673 bfd_boolean res
= TRUE
;
7675 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7676 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7677 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7678 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7680 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7682 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7685 const char * procname
;
7687 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7688 aux
->strtab_size
, tp
->start
, &procname
,
7691 fputs ("\n<", stdout
);
7695 fputs (procname
, stdout
);
7698 printf ("+%lx", (unsigned long) offset
);
7701 fputs (">: [", stdout
);
7702 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7703 fputc ('-', stdout
);
7704 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7707 #define PF(_m) if (tp->_m) printf (#_m " ");
7708 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7711 PF(Millicode_save_sr0
);
7712 /* PV(Region_description); */
7718 PF(Separate_Package_Body
);
7719 PF(Frame_Extension_Millicode
);
7720 PF(Stack_Overflow_Check
);
7721 PF(Two_Instruction_SP_Increment
);
7725 PF(sched_entry_seq
);
7728 PF(Save_MRP_in_frame
);
7729 PF(extn_ptr_defined
);
7730 PF(Cleanup_defined
);
7731 PF(MPE_XL_interrupt_marker
);
7732 PF(HP_UX_interrupt_marker
);
7735 PV(Total_frame_size
);
7748 slurp_hppa_unwind_table (FILE * file
,
7749 struct hppa_unw_aux_info
* aux
,
7750 Elf_Internal_Shdr
* sec
)
7752 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7753 Elf_Internal_Phdr
* seg
;
7754 struct hppa_unw_table_entry
* tep
;
7755 Elf_Internal_Shdr
* relsec
;
7756 Elf_Internal_Rela
* rela
;
7757 Elf_Internal_Rela
* rp
;
7758 unsigned char * table
;
7760 Elf_Internal_Sym
* sym
;
7761 const char * relname
;
7763 /* First, find the starting address of the segment that includes
7765 if (elf_header
.e_phnum
)
7767 if (! get_program_headers (file
))
7770 for (seg
= program_headers
;
7771 seg
< program_headers
+ elf_header
.e_phnum
;
7774 if (seg
->p_type
!= PT_LOAD
)
7777 if (sec
->sh_addr
>= seg
->p_vaddr
7778 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7780 aux
->seg_base
= seg
->p_vaddr
;
7786 /* Second, build the unwind table from the contents of the unwind
7788 size
= sec
->sh_size
;
7789 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7795 nentries
= size
/ unw_ent_size
;
7796 size
= unw_ent_size
* nentries
;
7798 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7799 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7801 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7803 unsigned int tmp1
, tmp2
;
7805 tep
->start
.section
= SHN_UNDEF
;
7806 tep
->end
.section
= SHN_UNDEF
;
7808 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7809 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7810 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7811 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7813 tep
->start
.offset
+= aux
->seg_base
;
7814 tep
->end
.offset
+= aux
->seg_base
;
7816 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7817 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7818 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7819 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7820 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7821 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7822 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7823 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7824 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7825 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7826 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7827 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7828 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7829 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7830 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7831 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7832 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7833 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7834 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7835 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7836 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7837 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7838 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7839 tep
->Cleanup_defined
= tmp1
& 0x1;
7841 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7842 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7843 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7844 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7845 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7846 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7850 /* Third, apply any relocations to the unwind table. */
7851 for (relsec
= section_headers
;
7852 relsec
< section_headers
+ elf_header
.e_shnum
;
7855 if (relsec
->sh_type
!= SHT_RELA
7856 || relsec
->sh_info
>= elf_header
.e_shnum
7857 || section_headers
+ relsec
->sh_info
!= sec
)
7860 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7864 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7866 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7867 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7869 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7870 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7872 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7876 i
= rp
->r_offset
/ unw_ent_size
;
7878 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7881 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7882 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7885 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7886 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7896 aux
->table_len
= nentries
;
7902 hppa_process_unwind (FILE * file
)
7904 struct hppa_unw_aux_info aux
;
7905 Elf_Internal_Shdr
* unwsec
= NULL
;
7906 Elf_Internal_Shdr
* strsec
;
7907 Elf_Internal_Shdr
* sec
;
7909 bfd_boolean res
= TRUE
;
7911 if (string_table
== NULL
)
7914 memset (& aux
, 0, sizeof (aux
));
7916 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7918 if (sec
->sh_type
== SHT_SYMTAB
7919 && sec
->sh_link
< elf_header
.e_shnum
)
7921 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7923 strsec
= section_headers
+ sec
->sh_link
;
7924 if (aux
.strtab
!= NULL
)
7926 error (_("Multiple auxillary string tables encountered\n"));
7930 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7933 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7935 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7940 printf (_("\nThere are no unwind sections in this file.\n"));
7942 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7944 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7946 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7947 printable_section_name (sec
),
7948 (unsigned long) sec
->sh_offset
,
7949 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7951 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7954 if (aux
.table_len
> 0)
7956 if (! dump_hppa_unwind (&aux
))
7961 free ((char *) aux
.table
);
7969 free ((char *) aux
.strtab
);
7976 unsigned char * data
; /* The unwind data. */
7977 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7978 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7979 unsigned long nrelas
; /* The number of relocations. */
7980 unsigned int rel_type
; /* REL or RELA ? */
7981 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7984 struct arm_unw_aux_info
7986 FILE * file
; /* The file containing the unwind sections. */
7987 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7988 unsigned long nsyms
; /* Number of symbols. */
7989 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7990 unsigned long nfuns
; /* Number of these symbols. */
7991 char * strtab
; /* The file's string table. */
7992 unsigned long strtab_size
; /* Size of string table. */
7996 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7997 bfd_vma fn
, struct absaddr addr
)
7999 const char *procname
;
8002 if (addr
.section
== SHN_UNDEF
)
8005 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8006 aux
->strtab_size
, addr
, &procname
,
8009 print_vma (fn
, PREFIX_HEX
);
8013 fputs (" <", stdout
);
8014 fputs (procname
, stdout
);
8017 printf ("+0x%lx", (unsigned long) sym_offset
);
8018 fputc ('>', stdout
);
8025 arm_free_section (struct arm_section
*arm_sec
)
8027 if (arm_sec
->data
!= NULL
)
8028 free (arm_sec
->data
);
8030 if (arm_sec
->rela
!= NULL
)
8031 free (arm_sec
->rela
);
8034 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8035 cached section and install SEC instead.
8036 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8037 and return its valued in * WORDP, relocating if necessary.
8038 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8039 relocation's offset in ADDR.
8040 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8041 into the string table of the symbol associated with the reloc. If no
8042 reloc was applied store -1 there.
8043 5) Return TRUE upon success, FALSE otherwise. */
8046 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
8047 struct arm_section
* arm_sec
,
8048 Elf_Internal_Shdr
* sec
,
8049 bfd_vma word_offset
,
8050 unsigned int * wordp
,
8051 struct absaddr
* addr
,
8054 Elf_Internal_Rela
*rp
;
8055 Elf_Internal_Sym
*sym
;
8056 const char * relname
;
8058 bfd_boolean wrapped
;
8060 if (sec
== NULL
|| arm_sec
== NULL
)
8063 addr
->section
= SHN_UNDEF
;
8066 if (sym_name
!= NULL
)
8067 *sym_name
= (bfd_vma
) -1;
8069 /* If necessary, update the section cache. */
8070 if (sec
!= arm_sec
->sec
)
8072 Elf_Internal_Shdr
*relsec
;
8074 arm_free_section (arm_sec
);
8077 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8078 sec
->sh_size
, _("unwind data"));
8079 arm_sec
->rela
= NULL
;
8080 arm_sec
->nrelas
= 0;
8082 for (relsec
= section_headers
;
8083 relsec
< section_headers
+ elf_header
.e_shnum
;
8086 if (relsec
->sh_info
>= elf_header
.e_shnum
8087 || section_headers
+ relsec
->sh_info
!= sec
8088 /* PR 15745: Check the section type as well. */
8089 || (relsec
->sh_type
!= SHT_REL
8090 && relsec
->sh_type
!= SHT_RELA
))
8093 arm_sec
->rel_type
= relsec
->sh_type
;
8094 if (relsec
->sh_type
== SHT_REL
)
8096 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8098 & arm_sec
->rela
, & arm_sec
->nrelas
))
8101 else /* relsec->sh_type == SHT_RELA */
8103 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8105 & arm_sec
->rela
, & arm_sec
->nrelas
))
8111 arm_sec
->next_rela
= arm_sec
->rela
;
8114 /* If there is no unwind data we can do nothing. */
8115 if (arm_sec
->data
== NULL
)
8118 /* If the offset is invalid then fail. */
8119 if (/* PR 21343 *//* PR 18879 */
8121 || word_offset
> (sec
->sh_size
- 4)
8122 || ((bfd_signed_vma
) word_offset
) < 0)
8125 /* Get the word at the required offset. */
8126 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8128 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8129 if (arm_sec
->rela
== NULL
)
8135 /* Look through the relocs to find the one that applies to the provided offset. */
8137 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8139 bfd_vma prelval
, offset
;
8141 if (rp
->r_offset
> word_offset
&& !wrapped
)
8146 if (rp
->r_offset
> word_offset
)
8149 if (rp
->r_offset
& 3)
8151 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8152 (unsigned long) rp
->r_offset
);
8156 if (rp
->r_offset
< word_offset
)
8159 /* PR 17531: file: 027-161405-0.004 */
8160 if (aux
->symtab
== NULL
)
8163 if (arm_sec
->rel_type
== SHT_REL
)
8165 offset
= word
& 0x7fffffff;
8166 if (offset
& 0x40000000)
8167 offset
|= ~ (bfd_vma
) 0x7fffffff;
8169 else if (arm_sec
->rel_type
== SHT_RELA
)
8170 offset
= rp
->r_addend
;
8173 error (_("Unknown section relocation type %d encountered\n"),
8178 /* PR 17531 file: 027-1241568-0.004. */
8179 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8181 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8182 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8186 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8187 offset
+= sym
->st_value
;
8188 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8190 /* Check that we are processing the expected reloc type. */
8191 if (elf_header
.e_machine
== EM_ARM
)
8193 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8194 if (relname
== NULL
)
8196 warn (_("Skipping unknown ARM relocation type: %d\n"),
8197 (int) ELF32_R_TYPE (rp
->r_info
));
8201 if (streq (relname
, "R_ARM_NONE"))
8204 if (! streq (relname
, "R_ARM_PREL31"))
8206 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8210 else if (elf_header
.e_machine
== EM_TI_C6000
)
8212 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8213 if (relname
== NULL
)
8215 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8216 (int) ELF32_R_TYPE (rp
->r_info
));
8220 if (streq (relname
, "R_C6000_NONE"))
8223 if (! streq (relname
, "R_C6000_PREL31"))
8225 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8233 /* This function currently only supports ARM and TI unwinders. */
8234 warn (_("Only TI and ARM unwinders are currently supported\n"));
8238 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8239 addr
->section
= sym
->st_shndx
;
8240 addr
->offset
= offset
;
8243 * sym_name
= sym
->st_name
;
8248 arm_sec
->next_rela
= rp
;
8253 static const char *tic6x_unwind_regnames
[16] =
8255 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8256 "A14", "A13", "A12", "A11", "A10",
8257 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8261 decode_tic6x_unwind_regmask (unsigned int mask
)
8265 for (i
= 12; mask
; mask
>>= 1, i
--)
8269 fputs (tic6x_unwind_regnames
[i
], stdout
);
8271 fputs (", ", stdout
);
8277 if (remaining == 0 && more_words) \
8280 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8281 data_offset, & word, & addr, NULL)) \
8287 #define GET_OP(OP) \
8292 (OP) = word >> 24; \
8297 printf (_("[Truncated opcode]\n")); \
8300 printf ("0x%02x ", OP)
8303 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8305 unsigned int remaining
,
8306 unsigned int more_words
,
8307 bfd_vma data_offset
,
8308 Elf_Internal_Shdr
* data_sec
,
8309 struct arm_section
* data_arm_sec
)
8311 struct absaddr addr
;
8312 bfd_boolean res
= TRUE
;
8314 /* Decode the unwinding instructions. */
8317 unsigned int op
, op2
;
8326 printf (" 0x%02x ", op
);
8328 if ((op
& 0xc0) == 0x00)
8330 int offset
= ((op
& 0x3f) << 2) + 4;
8332 printf (" vsp = vsp + %d", offset
);
8334 else if ((op
& 0xc0) == 0x40)
8336 int offset
= ((op
& 0x3f) << 2) + 4;
8338 printf (" vsp = vsp - %d", offset
);
8340 else if ((op
& 0xf0) == 0x80)
8343 if (op
== 0x80 && op2
== 0)
8344 printf (_("Refuse to unwind"));
8347 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8348 bfd_boolean first
= TRUE
;
8352 for (i
= 0; i
< 12; i
++)
8353 if (mask
& (1 << i
))
8359 printf ("r%d", 4 + i
);
8364 else if ((op
& 0xf0) == 0x90)
8366 if (op
== 0x9d || op
== 0x9f)
8367 printf (_(" [Reserved]"));
8369 printf (" vsp = r%d", op
& 0x0f);
8371 else if ((op
& 0xf0) == 0xa0)
8373 int end
= 4 + (op
& 0x07);
8374 bfd_boolean first
= TRUE
;
8378 for (i
= 4; i
<= end
; i
++)
8394 else if (op
== 0xb0)
8395 printf (_(" finish"));
8396 else if (op
== 0xb1)
8399 if (op2
== 0 || (op2
& 0xf0) != 0)
8400 printf (_("[Spare]"));
8403 unsigned int mask
= op2
& 0x0f;
8404 bfd_boolean first
= TRUE
;
8408 for (i
= 0; i
< 12; i
++)
8409 if (mask
& (1 << i
))
8420 else if (op
== 0xb2)
8422 unsigned char buf
[9];
8423 unsigned int i
, len
;
8424 unsigned long offset
;
8426 for (i
= 0; i
< sizeof (buf
); i
++)
8429 if ((buf
[i
] & 0x80) == 0)
8432 if (i
== sizeof (buf
))
8434 error (_("corrupt change to vsp"));
8439 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8440 assert (len
== i
+ 1);
8441 offset
= offset
* 4 + 0x204;
8442 printf ("vsp = vsp + %ld", offset
);
8445 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8447 unsigned int first
, last
;
8454 printf ("pop {D%d", first
);
8456 printf ("-D%d", first
+ last
);
8459 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8461 unsigned int count
= op
& 0x07;
8465 printf ("-D%d", 8 + count
);
8468 else if (op
>= 0xc0 && op
<= 0xc5)
8470 unsigned int count
= op
& 0x07;
8472 printf (" pop {wR10");
8474 printf ("-wR%d", 10 + count
);
8477 else if (op
== 0xc6)
8479 unsigned int first
, last
;
8484 printf ("pop {wR%d", first
);
8486 printf ("-wR%d", first
+ last
);
8489 else if (op
== 0xc7)
8492 if (op2
== 0 || (op2
& 0xf0) != 0)
8493 printf (_("[Spare]"));
8496 unsigned int mask
= op2
& 0x0f;
8497 bfd_boolean first
= TRUE
;
8501 for (i
= 0; i
< 4; i
++)
8502 if (mask
& (1 << i
))
8508 printf ("wCGR%d", i
);
8515 printf (_(" [unsupported opcode]"));
8526 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8528 unsigned int remaining
,
8529 unsigned int more_words
,
8530 bfd_vma data_offset
,
8531 Elf_Internal_Shdr
* data_sec
,
8532 struct arm_section
* data_arm_sec
)
8534 struct absaddr addr
;
8536 /* Decode the unwinding instructions. */
8539 unsigned int op
, op2
;
8548 printf (" 0x%02x ", op
);
8550 if ((op
& 0xc0) == 0x00)
8552 int offset
= ((op
& 0x3f) << 3) + 8;
8553 printf (" sp = sp + %d", offset
);
8555 else if ((op
& 0xc0) == 0x80)
8558 if (op
== 0x80 && op2
== 0)
8559 printf (_("Refuse to unwind"));
8562 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8564 printf ("pop compact {");
8568 decode_tic6x_unwind_regmask (mask
);
8572 else if ((op
& 0xf0) == 0xc0)
8580 unsigned int offset
;
8584 /* Scan entire instruction first so that GET_OP output is not
8585 interleaved with disassembly. */
8587 for (i
= 0; nregs
< (op
& 0xf); i
++)
8593 regpos
[nregs
].offset
= i
* 2;
8594 regpos
[nregs
].reg
= reg
;
8601 regpos
[nregs
].offset
= i
* 2 + 1;
8602 regpos
[nregs
].reg
= reg
;
8607 printf (_("pop frame {"));
8609 for (i
= i
* 2; i
> 0; i
--)
8611 if (regpos
[reg
].offset
== i
- 1)
8613 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8620 fputs (name
, stdout
);
8627 else if (op
== 0xd0)
8628 printf (" MOV FP, SP");
8629 else if (op
== 0xd1)
8630 printf (" __c6xabi_pop_rts");
8631 else if (op
== 0xd2)
8633 unsigned char buf
[9];
8634 unsigned int i
, len
;
8635 unsigned long offset
;
8637 for (i
= 0; i
< sizeof (buf
); i
++)
8640 if ((buf
[i
] & 0x80) == 0)
8643 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8644 if (i
== sizeof (buf
))
8646 warn (_("Corrupt stack pointer adjustment detected\n"));
8650 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8651 assert (len
== i
+ 1);
8652 offset
= offset
* 8 + 0x408;
8653 printf (_("sp = sp + %ld"), offset
);
8655 else if ((op
& 0xf0) == 0xe0)
8657 if ((op
& 0x0f) == 7)
8660 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8664 printf (_(" [unsupported opcode]"));
8673 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8677 offset
= word
& 0x7fffffff;
8678 if (offset
& 0x40000000)
8679 offset
|= ~ (bfd_vma
) 0x7fffffff;
8681 if (elf_header
.e_machine
== EM_TI_C6000
)
8684 return offset
+ where
;
8688 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8690 unsigned int remaining
,
8691 bfd_vma data_offset
,
8692 Elf_Internal_Shdr
* data_sec
,
8693 struct arm_section
* data_arm_sec
)
8696 unsigned int more_words
= 0;
8697 struct absaddr addr
;
8698 bfd_vma sym_name
= (bfd_vma
) -1;
8699 bfd_boolean res
= FALSE
;
8703 /* Fetch the first word.
8704 Note - when decoding an object file the address extracted
8705 here will always be 0. So we also pass in the sym_name
8706 parameter so that we can find the symbol associated with
8707 the personality routine. */
8708 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8709 & word
, & addr
, & sym_name
))
8715 if ((word
& 0x80000000) == 0)
8717 /* Expand prel31 for personality routine. */
8719 const char *procname
;
8721 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8722 printf (_(" Personality routine: "));
8724 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8725 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8727 procname
= aux
->strtab
+ sym_name
;
8728 print_vma (fn
, PREFIX_HEX
);
8731 fputs (" <", stdout
);
8732 fputs (procname
, stdout
);
8733 fputc ('>', stdout
);
8737 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8738 fputc ('\n', stdout
);
8740 /* The GCC personality routines use the standard compact
8741 encoding, starting with one byte giving the number of
8743 if (procname
!= NULL
8744 && (const_strneq (procname
, "__gcc_personality_v0")
8745 || const_strneq (procname
, "__gxx_personality_v0")
8746 || const_strneq (procname
, "__gcj_personality_v0")
8747 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8754 printf (_(" [Truncated data]\n"));
8757 more_words
= word
>> 24;
8767 /* ARM EHABI Section 6.3:
8769 An exception-handling table entry for the compact model looks like:
8773 1 0 index Data for personalityRoutine[index] */
8775 if (elf_header
.e_machine
== EM_ARM
8776 && (word
& 0x70000000))
8778 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8782 per_index
= (word
>> 24) & 0x7f;
8783 printf (_(" Compact model index: %d\n"), per_index
);
8790 else if (per_index
< 3)
8792 more_words
= (word
>> 16) & 0xff;
8798 switch (elf_header
.e_machine
)
8803 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8804 data_offset
, data_sec
, data_arm_sec
))
8809 warn (_("Unknown ARM compact model index encountered\n"));
8810 printf (_(" [reserved]\n"));
8818 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8819 data_offset
, data_sec
, data_arm_sec
))
8822 else if (per_index
< 5)
8824 if (((word
>> 17) & 0x7f) == 0x7f)
8825 printf (_(" Restore stack from frame pointer\n"));
8827 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8828 printf (_(" Registers restored: "));
8830 printf (" (compact) ");
8831 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8833 printf (_(" Return register: %s\n"),
8834 tic6x_unwind_regnames
[word
& 0xf]);
8837 printf (_(" [reserved (%d)]\n"), per_index
);
8841 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8842 elf_header
.e_machine
);
8846 /* Decode the descriptors. Not implemented. */
8852 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8854 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8855 unsigned int i
, exidx_len
;
8856 unsigned long j
, nfuns
;
8857 bfd_boolean res
= TRUE
;
8859 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8860 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8861 exidx_len
= exidx_sec
->sh_size
/ 8;
8863 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8864 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8865 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8866 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8868 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8870 for (i
= 0; i
< exidx_len
; i
++)
8872 unsigned int exidx_fn
, exidx_entry
;
8873 struct absaddr fn_addr
, entry_addr
;
8876 fputc ('\n', stdout
);
8878 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8879 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8880 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8881 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8884 arm_free_section (& exidx_arm_sec
);
8885 arm_free_section (& extab_arm_sec
);
8889 /* ARM EHABI, Section 5:
8890 An index table entry consists of 2 words.
8891 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8892 if (exidx_fn
& 0x80000000)
8894 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8898 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8900 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8901 fputs (": ", stdout
);
8903 if (exidx_entry
== 1)
8905 print_vma (exidx_entry
, PREFIX_HEX
);
8906 fputs (" [cantunwind]\n", stdout
);
8908 else if (exidx_entry
& 0x80000000)
8910 print_vma (exidx_entry
, PREFIX_HEX
);
8911 fputc ('\n', stdout
);
8912 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8916 bfd_vma table
, table_offset
= 0;
8917 Elf_Internal_Shdr
*table_sec
;
8919 fputs ("@", stdout
);
8920 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8921 print_vma (table
, PREFIX_HEX
);
8924 /* Locate the matching .ARM.extab. */
8925 if (entry_addr
.section
!= SHN_UNDEF
8926 && entry_addr
.section
< elf_header
.e_shnum
)
8928 table_sec
= section_headers
+ entry_addr
.section
;
8929 table_offset
= entry_addr
.offset
;
8931 if (table_offset
> table_sec
->sh_size
8932 || ((bfd_signed_vma
) table_offset
) < 0)
8934 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8935 (unsigned long) table_offset
,
8936 printable_section_name (table_sec
));
8943 table_sec
= find_section_by_address (table
);
8944 if (table_sec
!= NULL
)
8945 table_offset
= table
- table_sec
->sh_addr
;
8948 if (table_sec
== NULL
)
8950 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8951 (unsigned long) table
);
8956 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8965 arm_free_section (&exidx_arm_sec
);
8966 arm_free_section (&extab_arm_sec
);
8971 /* Used for both ARM and C6X unwinding tables. */
8974 arm_process_unwind (FILE *file
)
8976 struct arm_unw_aux_info aux
;
8977 Elf_Internal_Shdr
*unwsec
= NULL
;
8978 Elf_Internal_Shdr
*strsec
;
8979 Elf_Internal_Shdr
*sec
;
8981 unsigned int sec_type
;
8982 bfd_boolean res
= TRUE
;
8984 switch (elf_header
.e_machine
)
8987 sec_type
= SHT_ARM_EXIDX
;
8991 sec_type
= SHT_C6000_UNWIND
;
8995 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8996 elf_header
.e_machine
);
9000 if (string_table
== NULL
)
9003 memset (& aux
, 0, sizeof (aux
));
9006 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9008 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
9010 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
9012 strsec
= section_headers
+ sec
->sh_link
;
9014 /* PR binutils/17531 file: 011-12666-0.004. */
9015 if (aux
.strtab
!= NULL
)
9017 error (_("Multiple string tables found in file.\n"));
9021 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
9022 1, strsec
->sh_size
, _("string table"));
9023 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9025 else if (sec
->sh_type
== sec_type
)
9030 printf (_("\nThere are no unwind sections in this file.\n"));
9032 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9034 if (sec
->sh_type
== sec_type
)
9036 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9037 printable_section_name (sec
),
9038 (unsigned long) sec
->sh_offset
,
9039 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
9041 if (! dump_arm_unwind (&aux
, sec
))
9049 free ((char *) aux
.strtab
);
9055 process_unwind (FILE * file
)
9057 struct unwind_handler
9059 unsigned int machtype
;
9060 bfd_boolean (* handler
)(FILE *);
9063 { EM_ARM
, arm_process_unwind
},
9064 { EM_IA_64
, ia64_process_unwind
},
9065 { EM_PARISC
, hppa_process_unwind
},
9066 { EM_TI_C6000
, arm_process_unwind
},
9074 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9075 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9076 return handlers
[i
].handler (file
);
9078 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9079 get_machine_name (elf_header
.e_machine
));
9084 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9086 switch (entry
->d_tag
)
9089 if (entry
->d_un
.d_val
== 0)
9093 static const char * opts
[] =
9095 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9096 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9097 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9098 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9102 bfd_boolean first
= TRUE
;
9104 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9105 if (entry
->d_un
.d_val
& (1 << cnt
))
9107 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9113 case DT_MIPS_IVERSION
:
9114 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9115 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9119 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9120 /* Note: coded this way so that there is a single string for translation. */
9121 printf (_("<corrupt: %s>"), buf
);
9125 case DT_MIPS_TIME_STAMP
:
9129 time_t atime
= entry
->d_un
.d_val
;
9131 tmp
= gmtime (&atime
);
9132 /* PR 17531: file: 6accc532. */
9134 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9136 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9137 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9138 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9139 printf (_("Time Stamp: %s"), timebuf
);
9143 case DT_MIPS_RLD_VERSION
:
9144 case DT_MIPS_LOCAL_GOTNO
:
9145 case DT_MIPS_CONFLICTNO
:
9146 case DT_MIPS_LIBLISTNO
:
9147 case DT_MIPS_SYMTABNO
:
9148 case DT_MIPS_UNREFEXTNO
:
9149 case DT_MIPS_HIPAGENO
:
9150 case DT_MIPS_DELTA_CLASS_NO
:
9151 case DT_MIPS_DELTA_INSTANCE_NO
:
9152 case DT_MIPS_DELTA_RELOC_NO
:
9153 case DT_MIPS_DELTA_SYM_NO
:
9154 case DT_MIPS_DELTA_CLASSSYM_NO
:
9155 case DT_MIPS_COMPACT_SIZE
:
9156 print_vma (entry
->d_un
.d_val
, DEC
);
9160 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9166 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9168 switch (entry
->d_tag
)
9170 case DT_HP_DLD_FLAGS
:
9179 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9180 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9181 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9182 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9183 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9184 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9185 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9186 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9187 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9188 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9189 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9190 { DT_HP_GST
, "HP_GST" },
9191 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9192 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9193 { DT_HP_NODELETE
, "HP_NODELETE" },
9194 { DT_HP_GROUP
, "HP_GROUP" },
9195 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9197 bfd_boolean first
= TRUE
;
9199 bfd_vma val
= entry
->d_un
.d_val
;
9201 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9202 if (val
& flags
[cnt
].bit
)
9206 fputs (flags
[cnt
].str
, stdout
);
9208 val
^= flags
[cnt
].bit
;
9211 if (val
!= 0 || first
)
9215 print_vma (val
, HEX
);
9221 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9229 /* VMS vs Unix time offset and factor. */
9231 #define VMS_EPOCH_OFFSET 35067168000000000LL
9232 #define VMS_GRANULARITY_FACTOR 10000000
9234 /* Display a VMS time in a human readable format. */
9237 print_vms_time (bfd_int64_t vmstime
)
9242 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9243 tm
= gmtime (&unxtime
);
9244 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9245 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9246 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9251 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9253 switch (entry
->d_tag
)
9255 case DT_IA_64_PLT_RESERVE
:
9256 /* First 3 slots reserved. */
9257 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9259 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9262 case DT_IA_64_VMS_LINKTIME
:
9264 print_vms_time (entry
->d_un
.d_val
);
9268 case DT_IA_64_VMS_LNKFLAGS
:
9269 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9270 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9271 printf (" CALL_DEBUG");
9272 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9273 printf (" NOP0BUFS");
9274 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9275 printf (" P0IMAGE");
9276 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9277 printf (" MKTHREADS");
9278 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9279 printf (" UPCALLS");
9280 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9282 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9283 printf (" INITIALIZE");
9284 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9286 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9287 printf (" EXE_INIT");
9288 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9289 printf (" TBK_IN_IMG");
9290 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9291 printf (" DBG_IN_IMG");
9292 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9293 printf (" TBK_IN_DSF");
9294 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9295 printf (" DBG_IN_DSF");
9296 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9297 printf (" SIGNATURES");
9298 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9299 printf (" REL_SEG_OFF");
9303 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9310 get_32bit_dynamic_section (FILE * file
)
9312 Elf32_External_Dyn
* edyn
;
9313 Elf32_External_Dyn
* ext
;
9314 Elf_Internal_Dyn
* entry
;
9316 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9317 dynamic_size
, _("dynamic section"));
9321 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9322 might not have the luxury of section headers. Look for the DT_NULL
9323 terminator to determine the number of entries. */
9324 for (ext
= edyn
, dynamic_nent
= 0;
9325 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9329 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9333 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9335 if (dynamic_section
== NULL
)
9337 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9338 (unsigned long) dynamic_nent
);
9343 for (ext
= edyn
, entry
= dynamic_section
;
9344 entry
< dynamic_section
+ dynamic_nent
;
9347 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9348 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9357 get_64bit_dynamic_section (FILE * file
)
9359 Elf64_External_Dyn
* edyn
;
9360 Elf64_External_Dyn
* ext
;
9361 Elf_Internal_Dyn
* entry
;
9363 /* Read in the data. */
9364 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9365 dynamic_size
, _("dynamic section"));
9369 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9370 might not have the luxury of section headers. Look for the DT_NULL
9371 terminator to determine the number of entries. */
9372 for (ext
= edyn
, dynamic_nent
= 0;
9373 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9374 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9378 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9382 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9384 if (dynamic_section
== NULL
)
9386 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9387 (unsigned long) dynamic_nent
);
9392 /* Convert from external to internal formats. */
9393 for (ext
= edyn
, entry
= dynamic_section
;
9394 entry
< dynamic_section
+ dynamic_nent
;
9397 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9398 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9407 print_dynamic_flags (bfd_vma flags
)
9409 bfd_boolean first
= TRUE
;
9415 flag
= flags
& - flags
;
9425 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9426 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9427 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9428 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9429 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9430 default: fputs (_("unknown"), stdout
); break;
9436 /* Parse and display the contents of the dynamic section. */
9439 process_dynamic_section (FILE * file
)
9441 Elf_Internal_Dyn
* entry
;
9443 if (dynamic_size
== 0)
9446 printf (_("\nThere is no dynamic section in this file.\n"));
9453 if (! get_32bit_dynamic_section (file
))
9458 if (! get_64bit_dynamic_section (file
))
9462 /* Find the appropriate symbol table. */
9463 if (dynamic_symbols
== NULL
)
9465 for (entry
= dynamic_section
;
9466 entry
< dynamic_section
+ dynamic_nent
;
9469 Elf_Internal_Shdr section
;
9471 if (entry
->d_tag
!= DT_SYMTAB
)
9474 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9476 /* Since we do not know how big the symbol table is,
9477 we default to reading in the entire file (!) and
9478 processing that. This is overkill, I know, but it
9480 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9481 if ((bfd_size_type
) section
.sh_offset
> current_file_size
)
9483 /* See PR 21379 for a reproducer. */
9484 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9488 if (archive_file_offset
!= 0)
9489 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9492 if (fseek (file
, 0, SEEK_END
))
9493 error (_("Unable to seek to end of file!\n"));
9495 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9499 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9501 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9502 section
.sh_name
= string_table_length
;
9504 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9505 if (num_dynamic_syms
< 1)
9507 error (_("Unable to determine the number of symbols to load\n"));
9513 /* Similarly find a string table. */
9514 if (dynamic_strings
== NULL
)
9516 for (entry
= dynamic_section
;
9517 entry
< dynamic_section
+ dynamic_nent
;
9520 unsigned long offset
;
9523 if (entry
->d_tag
!= DT_STRTAB
)
9526 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9528 /* Since we do not know how big the string table is,
9529 we default to reading in the entire file (!) and
9530 processing that. This is overkill, I know, but it
9533 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9535 if (archive_file_offset
!= 0)
9536 str_tab_len
= archive_file_size
- offset
;
9539 if (fseek (file
, 0, SEEK_END
))
9540 error (_("Unable to seek to end of file\n"));
9541 str_tab_len
= ftell (file
) - offset
;
9544 if (str_tab_len
< 1)
9547 (_("Unable to determine the length of the dynamic string table\n"));
9551 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9553 _("dynamic string table"));
9554 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9559 /* And find the syminfo section if available. */
9560 if (dynamic_syminfo
== NULL
)
9562 unsigned long syminsz
= 0;
9564 for (entry
= dynamic_section
;
9565 entry
< dynamic_section
+ dynamic_nent
;
9568 if (entry
->d_tag
== DT_SYMINENT
)
9570 /* Note: these braces are necessary to avoid a syntax
9571 error from the SunOS4 C compiler. */
9572 /* PR binutils/17531: A corrupt file can trigger this test.
9573 So do not use an assert, instead generate an error message. */
9574 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9575 error (_("Bad value (%d) for SYMINENT entry\n"),
9576 (int) entry
->d_un
.d_val
);
9578 else if (entry
->d_tag
== DT_SYMINSZ
)
9579 syminsz
= entry
->d_un
.d_val
;
9580 else if (entry
->d_tag
== DT_SYMINFO
)
9581 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9585 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9587 Elf_External_Syminfo
* extsyminfo
;
9588 Elf_External_Syminfo
* extsym
;
9589 Elf_Internal_Syminfo
* syminfo
;
9591 /* There is a syminfo section. Read the data. */
9592 extsyminfo
= (Elf_External_Syminfo
*)
9593 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9594 _("symbol information"));
9598 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9599 if (dynamic_syminfo
== NULL
)
9601 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9602 (unsigned long) syminsz
);
9606 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9607 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9608 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9609 ++syminfo
, ++extsym
)
9611 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9612 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9619 if (do_dynamic
&& dynamic_addr
)
9620 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9621 dynamic_addr
, (unsigned long) dynamic_nent
);
9623 printf (_(" Tag Type Name/Value\n"));
9625 for (entry
= dynamic_section
;
9626 entry
< dynamic_section
+ dynamic_nent
;
9634 print_vma (entry
->d_tag
, FULL_HEX
);
9635 dtype
= get_dynamic_type (entry
->d_tag
);
9636 printf (" (%s)%*s", dtype
,
9637 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9640 switch (entry
->d_tag
)
9644 print_dynamic_flags (entry
->d_un
.d_val
);
9654 switch (entry
->d_tag
)
9657 printf (_("Auxiliary library"));
9661 printf (_("Filter library"));
9665 printf (_("Configuration file"));
9669 printf (_("Dependency audit library"));
9673 printf (_("Audit library"));
9677 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9678 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9682 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9691 printf (_("Flags:"));
9693 if (entry
->d_un
.d_val
== 0)
9694 printf (_(" None\n"));
9697 unsigned long int val
= entry
->d_un
.d_val
;
9699 if (val
& DTF_1_PARINIT
)
9701 printf (" PARINIT");
9702 val
^= DTF_1_PARINIT
;
9704 if (val
& DTF_1_CONFEXP
)
9706 printf (" CONFEXP");
9707 val
^= DTF_1_CONFEXP
;
9710 printf (" %lx", val
);
9719 printf (_("Flags:"));
9721 if (entry
->d_un
.d_val
== 0)
9722 printf (_(" None\n"));
9725 unsigned long int val
= entry
->d_un
.d_val
;
9727 if (val
& DF_P1_LAZYLOAD
)
9729 printf (" LAZYLOAD");
9730 val
^= DF_P1_LAZYLOAD
;
9732 if (val
& DF_P1_GROUPPERM
)
9734 printf (" GROUPPERM");
9735 val
^= DF_P1_GROUPPERM
;
9738 printf (" %lx", val
);
9747 printf (_("Flags:"));
9748 if (entry
->d_un
.d_val
== 0)
9749 printf (_(" None\n"));
9752 unsigned long int val
= entry
->d_un
.d_val
;
9759 if (val
& DF_1_GLOBAL
)
9764 if (val
& DF_1_GROUP
)
9769 if (val
& DF_1_NODELETE
)
9771 printf (" NODELETE");
9772 val
^= DF_1_NODELETE
;
9774 if (val
& DF_1_LOADFLTR
)
9776 printf (" LOADFLTR");
9777 val
^= DF_1_LOADFLTR
;
9779 if (val
& DF_1_INITFIRST
)
9781 printf (" INITFIRST");
9782 val
^= DF_1_INITFIRST
;
9784 if (val
& DF_1_NOOPEN
)
9789 if (val
& DF_1_ORIGIN
)
9794 if (val
& DF_1_DIRECT
)
9799 if (val
& DF_1_TRANS
)
9804 if (val
& DF_1_INTERPOSE
)
9806 printf (" INTERPOSE");
9807 val
^= DF_1_INTERPOSE
;
9809 if (val
& DF_1_NODEFLIB
)
9811 printf (" NODEFLIB");
9812 val
^= DF_1_NODEFLIB
;
9814 if (val
& DF_1_NODUMP
)
9819 if (val
& DF_1_CONFALT
)
9821 printf (" CONFALT");
9822 val
^= DF_1_CONFALT
;
9824 if (val
& DF_1_ENDFILTEE
)
9826 printf (" ENDFILTEE");
9827 val
^= DF_1_ENDFILTEE
;
9829 if (val
& DF_1_DISPRELDNE
)
9831 printf (" DISPRELDNE");
9832 val
^= DF_1_DISPRELDNE
;
9834 if (val
& DF_1_DISPRELPND
)
9836 printf (" DISPRELPND");
9837 val
^= DF_1_DISPRELPND
;
9839 if (val
& DF_1_NODIRECT
)
9841 printf (" NODIRECT");
9842 val
^= DF_1_NODIRECT
;
9844 if (val
& DF_1_IGNMULDEF
)
9846 printf (" IGNMULDEF");
9847 val
^= DF_1_IGNMULDEF
;
9849 if (val
& DF_1_NOKSYMS
)
9851 printf (" NOKSYMS");
9852 val
^= DF_1_NOKSYMS
;
9854 if (val
& DF_1_NOHDR
)
9859 if (val
& DF_1_EDITED
)
9864 if (val
& DF_1_NORELOC
)
9866 printf (" NORELOC");
9867 val
^= DF_1_NORELOC
;
9869 if (val
& DF_1_SYMINTPOSE
)
9871 printf (" SYMINTPOSE");
9872 val
^= DF_1_SYMINTPOSE
;
9874 if (val
& DF_1_GLOBAUDIT
)
9876 printf (" GLOBAUDIT");
9877 val
^= DF_1_GLOBAUDIT
;
9879 if (val
& DF_1_SINGLETON
)
9881 printf (" SINGLETON");
9882 val
^= DF_1_SINGLETON
;
9884 if (val
& DF_1_STUB
)
9895 printf (" %lx", val
);
9902 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9904 puts (get_dynamic_type (entry
->d_un
.d_val
));
9924 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9930 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9931 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9937 switch (entry
->d_tag
)
9940 printf (_("Shared library: [%s]"), name
);
9942 if (streq (name
, program_interpreter
))
9943 printf (_(" program interpreter"));
9947 printf (_("Library soname: [%s]"), name
);
9951 printf (_("Library rpath: [%s]"), name
);
9955 printf (_("Library runpath: [%s]"), name
);
9959 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9964 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9977 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9982 case DT_INIT_ARRAYSZ
:
9983 case DT_FINI_ARRAYSZ
:
9984 case DT_GNU_CONFLICTSZ
:
9985 case DT_GNU_LIBLISTSZ
:
9988 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9989 printf (_(" (bytes)\n"));
9999 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10008 case DT_INIT_ARRAY
:
10009 case DT_FINI_ARRAY
:
10012 if (entry
->d_tag
== DT_USED
10013 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10015 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10019 printf (_("Not needed object: [%s]\n"), name
);
10024 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10030 /* The value of this entry is ignored. */
10035 case DT_GNU_PRELINKED
:
10039 time_t atime
= entry
->d_un
.d_val
;
10041 tmp
= gmtime (&atime
);
10042 /* PR 17533 file: 041-1244816-0.004. */
10044 printf (_("<corrupt time val: %lx"),
10045 (unsigned long) atime
);
10047 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10048 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10049 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10055 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10058 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10064 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10065 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10070 switch (elf_header
.e_machine
)
10073 case EM_MIPS_RS3_LE
:
10074 dynamic_section_mips_val (entry
);
10077 dynamic_section_parisc_val (entry
);
10080 dynamic_section_ia64_val (entry
);
10083 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10095 get_ver_flags (unsigned int flags
)
10097 static char buff
[32];
10104 if (flags
& VER_FLG_BASE
)
10105 strcat (buff
, "BASE");
10107 if (flags
& VER_FLG_WEAK
)
10109 if (flags
& VER_FLG_BASE
)
10110 strcat (buff
, " | ");
10112 strcat (buff
, "WEAK");
10115 if (flags
& VER_FLG_INFO
)
10117 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10118 strcat (buff
, " | ");
10120 strcat (buff
, "INFO");
10123 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10125 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10126 strcat (buff
, " | ");
10128 strcat (buff
, _("<unknown>"));
10134 /* Display the contents of the version sections. */
10137 process_version_sections (FILE * file
)
10139 Elf_Internal_Shdr
* section
;
10141 bfd_boolean found
= FALSE
;
10146 for (i
= 0, section
= section_headers
;
10147 i
< elf_header
.e_shnum
;
10150 switch (section
->sh_type
)
10152 case SHT_GNU_verdef
:
10154 Elf_External_Verdef
* edefs
;
10162 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10163 printable_section_name (section
),
10166 printf (_(" Addr: 0x"));
10167 printf_vma (section
->sh_addr
);
10168 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10169 (unsigned long) section
->sh_offset
, section
->sh_link
,
10170 printable_section_name_from_index (section
->sh_link
));
10172 edefs
= (Elf_External_Verdef
*)
10173 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10174 _("version definition section"));
10177 endbuf
= (char *) edefs
+ section
->sh_size
;
10179 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10180 end
= (section
->sh_info
< section
->sh_size
10181 ? section
->sh_info
: section
->sh_size
);
10182 for (idx
= cnt
= 0; cnt
< end
; ++cnt
)
10185 Elf_External_Verdef
* edef
;
10186 Elf_Internal_Verdef ent
;
10187 Elf_External_Verdaux
* eaux
;
10188 Elf_Internal_Verdaux aux
;
10192 /* Check for very large indices. */
10193 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10196 vstart
= ((char *) edefs
) + idx
;
10197 if (vstart
+ sizeof (*edef
) > endbuf
)
10200 edef
= (Elf_External_Verdef
*) vstart
;
10202 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10203 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10204 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10205 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10206 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10207 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10208 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10210 printf (_(" %#06x: Rev: %d Flags: %s"),
10211 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10213 printf (_(" Index: %d Cnt: %d "),
10214 ent
.vd_ndx
, ent
.vd_cnt
);
10216 /* Check for overflow and underflow. */
10217 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
)
10218 || (vstart
+ ent
.vd_aux
< vstart
))
10221 vstart
+= ent
.vd_aux
;
10223 eaux
= (Elf_External_Verdaux
*) vstart
;
10225 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10226 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10228 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10229 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10231 printf (_("Name index: %ld\n"), aux
.vda_name
);
10233 isum
= idx
+ ent
.vd_aux
;
10235 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10237 /* Check for overflow. */
10238 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10241 isum
+= aux
.vda_next
;
10242 vstart
+= aux
.vda_next
;
10244 eaux
= (Elf_External_Verdaux
*) vstart
;
10245 if (vstart
+ sizeof (*eaux
) > endbuf
)
10248 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10249 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10251 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10252 printf (_(" %#06x: Parent %d: %s\n"),
10253 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10255 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10256 isum
, j
, aux
.vda_name
);
10259 if (j
< ent
.vd_cnt
)
10260 printf (_(" Version def aux past end of section\n"));
10263 file: id:000001,src:000172+005151,op:splice,rep:2. */
10264 if (idx
+ ent
.vd_next
< idx
)
10267 idx
+= ent
.vd_next
;
10270 if (cnt
< section
->sh_info
)
10271 printf (_(" Version definition past end of section\n"));
10277 case SHT_GNU_verneed
:
10279 Elf_External_Verneed
* eneed
;
10286 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10287 printable_section_name (section
), section
->sh_info
);
10289 printf (_(" Addr: 0x"));
10290 printf_vma (section
->sh_addr
);
10291 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10292 (unsigned long) section
->sh_offset
, section
->sh_link
,
10293 printable_section_name_from_index (section
->sh_link
));
10295 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10296 section
->sh_offset
, 1,
10298 _("Version Needs section"));
10301 endbuf
= (char *) eneed
+ section
->sh_size
;
10303 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10305 Elf_External_Verneed
* entry
;
10306 Elf_Internal_Verneed ent
;
10311 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10314 vstart
= ((char *) eneed
) + idx
;
10315 if (vstart
+ sizeof (*entry
) > endbuf
)
10318 entry
= (Elf_External_Verneed
*) vstart
;
10320 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10321 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10322 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10323 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10324 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10326 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10328 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10329 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10331 printf (_(" File: %lx"), ent
.vn_file
);
10333 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10335 /* Check for overflow. */
10336 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10338 vstart
+= ent
.vn_aux
;
10340 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10342 Elf_External_Vernaux
* eaux
;
10343 Elf_Internal_Vernaux aux
;
10345 if (vstart
+ sizeof (*eaux
) > endbuf
)
10347 eaux
= (Elf_External_Vernaux
*) vstart
;
10349 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10350 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10351 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10352 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10353 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10355 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10356 printf (_(" %#06x: Name: %s"),
10357 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10359 printf (_(" %#06x: Name index: %lx"),
10360 isum
, aux
.vna_name
);
10362 printf (_(" Flags: %s Version: %d\n"),
10363 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10365 /* Check for overflow. */
10366 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10367 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10369 warn (_("Invalid vna_next field of %lx\n"),
10374 isum
+= aux
.vna_next
;
10375 vstart
+= aux
.vna_next
;
10378 if (j
< ent
.vn_cnt
)
10379 warn (_("Missing Version Needs auxillary information\n"));
10381 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10383 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10384 cnt
= section
->sh_info
;
10387 idx
+= ent
.vn_next
;
10390 if (cnt
< section
->sh_info
)
10391 warn (_("Missing Version Needs information\n"));
10397 case SHT_GNU_versym
:
10399 Elf_Internal_Shdr
* link_section
;
10402 unsigned char * edata
;
10403 unsigned short * data
;
10405 Elf_Internal_Sym
* symbols
;
10406 Elf_Internal_Shdr
* string_sec
;
10407 unsigned long num_syms
;
10410 if (section
->sh_link
>= elf_header
.e_shnum
)
10413 link_section
= section_headers
+ section
->sh_link
;
10414 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10416 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10421 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10422 if (symbols
== NULL
)
10425 string_sec
= section_headers
+ link_section
->sh_link
;
10427 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10428 string_sec
->sh_size
,
10429 _("version string table"));
10436 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10437 printable_section_name (section
), (unsigned long) total
);
10439 printf (_(" Addr: "));
10440 printf_vma (section
->sh_addr
);
10441 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10442 (unsigned long) section
->sh_offset
, section
->sh_link
,
10443 printable_section_name (link_section
));
10445 off
= offset_from_vma (file
,
10446 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10447 total
* sizeof (short));
10448 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10450 _("version symbol data"));
10458 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10460 for (cnt
= total
; cnt
--;)
10461 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10466 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10470 char *invalid
= _("*invalid*");
10472 printf (" %03x:", cnt
);
10474 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10475 switch (data
[cnt
+ j
])
10478 fputs (_(" 0 (*local*) "), stdout
);
10482 fputs (_(" 1 (*global*) "), stdout
);
10486 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10487 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10489 /* If this index value is greater than the size of the symbols
10490 array, break to avoid an out-of-bounds read. */
10491 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10493 warn (_("invalid index into symbol array\n"));
10498 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10500 Elf_Internal_Verneed ivn
;
10501 unsigned long offset
;
10503 offset
= offset_from_vma
10504 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10505 sizeof (Elf_External_Verneed
));
10509 Elf_Internal_Vernaux ivna
;
10510 Elf_External_Verneed evn
;
10511 Elf_External_Vernaux evna
;
10512 unsigned long a_off
;
10514 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10515 _("version need")) == NULL
)
10518 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10519 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10521 a_off
= offset
+ ivn
.vn_aux
;
10525 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10526 1, _("version need aux (2)")) == NULL
)
10529 ivna
.vna_other
= 0;
10533 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10534 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10537 a_off
+= ivna
.vna_next
;
10539 while (ivna
.vna_other
!= data
[cnt
+ j
]
10540 && ivna
.vna_next
!= 0);
10542 if (ivna
.vna_other
== data
[cnt
+ j
])
10544 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10546 if (ivna
.vna_name
>= string_sec
->sh_size
)
10549 name
= strtab
+ ivna
.vna_name
;
10553 offset
+= ivn
.vn_next
;
10555 while (ivn
.vn_next
);
10558 if (data
[cnt
+ j
] != 0x8001
10559 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10561 Elf_Internal_Verdef ivd
;
10562 Elf_External_Verdef evd
;
10563 unsigned long offset
;
10565 offset
= offset_from_vma
10566 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10571 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10572 _("version def")) == NULL
)
10575 /* PR 17531: file: 046-1082287-0.004. */
10576 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10581 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10582 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10585 offset
+= ivd
.vd_next
;
10587 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10588 && ivd
.vd_next
!= 0);
10590 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10592 Elf_External_Verdaux evda
;
10593 Elf_Internal_Verdaux ivda
;
10595 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10597 if (get_data (&evda
, file
,
10598 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10600 _("version def aux")) == NULL
)
10603 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10605 if (ivda
.vda_name
>= string_sec
->sh_size
)
10607 else if (name
!= NULL
&& name
!= invalid
)
10608 name
= _("*both*");
10610 name
= strtab
+ ivda
.vda_name
;
10614 nn
+= printf ("(%s%-*s",
10616 12 - (int) strlen (name
),
10620 printf ("%*c", 18 - nn
, ' ');
10638 printf (_("\nNo version information found in this file.\n"));
10643 static const char *
10644 get_symbol_binding (unsigned int binding
)
10646 static char buff
[32];
10650 case STB_LOCAL
: return "LOCAL";
10651 case STB_GLOBAL
: return "GLOBAL";
10652 case STB_WEAK
: return "WEAK";
10654 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10655 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10657 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10659 if (binding
== STB_GNU_UNIQUE
10660 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10661 /* GNU is still using the default value 0. */
10662 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10664 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10667 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10672 static const char *
10673 get_symbol_type (unsigned int type
)
10675 static char buff
[32];
10679 case STT_NOTYPE
: return "NOTYPE";
10680 case STT_OBJECT
: return "OBJECT";
10681 case STT_FUNC
: return "FUNC";
10682 case STT_SECTION
: return "SECTION";
10683 case STT_FILE
: return "FILE";
10684 case STT_COMMON
: return "COMMON";
10685 case STT_TLS
: return "TLS";
10686 case STT_RELC
: return "RELC";
10687 case STT_SRELC
: return "SRELC";
10689 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10691 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10692 return "THUMB_FUNC";
10694 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10697 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10698 return "PARISC_MILLI";
10700 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10702 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10704 if (elf_header
.e_machine
== EM_PARISC
)
10706 if (type
== STT_HP_OPAQUE
)
10707 return "HP_OPAQUE";
10708 if (type
== STT_HP_STUB
)
10712 if (type
== STT_GNU_IFUNC
10713 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10714 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10715 /* GNU is still using the default value 0. */
10716 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10719 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10722 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10727 static const char *
10728 get_symbol_visibility (unsigned int visibility
)
10730 switch (visibility
)
10732 case STV_DEFAULT
: return "DEFAULT";
10733 case STV_INTERNAL
: return "INTERNAL";
10734 case STV_HIDDEN
: return "HIDDEN";
10735 case STV_PROTECTED
: return "PROTECTED";
10737 error (_("Unrecognized visibility value: %u"), visibility
);
10738 return _("<unknown>");
10742 static const char *
10743 get_solaris_symbol_visibility (unsigned int visibility
)
10745 switch (visibility
)
10747 case 4: return "EXPORTED";
10748 case 5: return "SINGLETON";
10749 case 6: return "ELIMINATE";
10750 default: return get_symbol_visibility (visibility
);
10754 static const char *
10755 get_mips_symbol_other (unsigned int other
)
10759 case STO_OPTIONAL
: return "OPTIONAL";
10760 case STO_MIPS_PLT
: return "MIPS PLT";
10761 case STO_MIPS_PIC
: return "MIPS PIC";
10762 case STO_MICROMIPS
: return "MICROMIPS";
10763 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10764 case STO_MIPS16
: return "MIPS16";
10765 default: return NULL
;
10769 static const char *
10770 get_ia64_symbol_other (unsigned int other
)
10772 if (is_ia64_vms ())
10774 static char res
[32];
10778 /* Function types is for images and .STB files only. */
10779 switch (elf_header
.e_type
)
10783 switch (VMS_ST_FUNC_TYPE (other
))
10785 case VMS_SFT_CODE_ADDR
:
10786 strcat (res
, " CA");
10788 case VMS_SFT_SYMV_IDX
:
10789 strcat (res
, " VEC");
10792 strcat (res
, " FD");
10794 case VMS_SFT_RESERVE
:
10795 strcat (res
, " RSV");
10798 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10799 VMS_ST_FUNC_TYPE (other
));
10800 strcat (res
, " <unknown>");
10807 switch (VMS_ST_LINKAGE (other
))
10809 case VMS_STL_IGNORE
:
10810 strcat (res
, " IGN");
10812 case VMS_STL_RESERVE
:
10813 strcat (res
, " RSV");
10816 strcat (res
, " STD");
10819 strcat (res
, " LNK");
10822 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10823 VMS_ST_LINKAGE (other
));
10824 strcat (res
, " <unknown>");
10836 static const char *
10837 get_ppc64_symbol_other (unsigned int other
)
10839 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10841 static char buf
[32];
10842 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10843 PPC64_LOCAL_ENTRY_OFFSET (other
));
10849 static const char *
10850 get_symbol_other (unsigned int other
)
10852 const char * result
= NULL
;
10853 static char buff
[32];
10858 switch (elf_header
.e_machine
)
10861 result
= get_mips_symbol_other (other
);
10864 result
= get_ia64_symbol_other (other
);
10867 result
= get_ppc64_symbol_other (other
);
10877 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10881 static const char *
10882 get_symbol_index_type (unsigned int type
)
10884 static char buff
[32];
10888 case SHN_UNDEF
: return "UND";
10889 case SHN_ABS
: return "ABS";
10890 case SHN_COMMON
: return "COM";
10892 if (type
== SHN_IA_64_ANSI_COMMON
10893 && elf_header
.e_machine
== EM_IA_64
10894 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10896 else if ((elf_header
.e_machine
== EM_X86_64
10897 || elf_header
.e_machine
== EM_L1OM
10898 || elf_header
.e_machine
== EM_K1OM
)
10899 && type
== SHN_X86_64_LCOMMON
)
10900 return "LARGE_COM";
10901 else if ((type
== SHN_MIPS_SCOMMON
10902 && elf_header
.e_machine
== EM_MIPS
)
10903 || (type
== SHN_TIC6X_SCOMMON
10904 && elf_header
.e_machine
== EM_TI_C6000
))
10906 else if (type
== SHN_MIPS_SUNDEFINED
10907 && elf_header
.e_machine
== EM_MIPS
)
10909 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10910 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10911 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10912 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10913 else if (type
>= SHN_LORESERVE
)
10914 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10915 else if (type
>= elf_header
.e_shnum
)
10916 sprintf (buff
, _("bad section index[%3d]"), type
);
10918 sprintf (buff
, "%3d", type
);
10926 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10928 unsigned char * e_data
;
10931 /* If the size_t type is smaller than the bfd_size_type, eg because
10932 you are building a 32-bit tool on a 64-bit host, then make sure
10933 that when (number) is cast to (size_t) no information is lost. */
10934 if (sizeof (size_t) < sizeof (bfd_size_type
)
10935 && (bfd_size_type
) ((size_t) number
) != number
)
10937 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10938 " elements of size %u\n"),
10943 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10944 attempting to allocate memory when the read is bound to fail. */
10945 if (ent_size
* number
> current_file_size
)
10947 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10952 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10953 if (e_data
== NULL
)
10955 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10960 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10962 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10963 number
* ent_size
);
10968 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10969 if (i_data
== NULL
)
10971 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10972 " dynamic entries\n"),
10979 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10987 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10989 Elf_Internal_Sym
* psym
;
10992 n
= print_vma (si
, DEC_5
);
10994 fputs (&" "[n
], stdout
);
10995 printf (" %3lu: ", hn
);
10997 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10999 printf (_("<No info available for dynamic symbol number %lu>\n"),
11000 (unsigned long) si
);
11004 psym
= dynamic_symbols
+ si
;
11005 print_vma (psym
->st_value
, LONG_HEX
);
11007 print_vma (psym
->st_size
, DEC_5
);
11009 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11010 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11012 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11013 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11016 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11018 printf (" %-7s", get_symbol_visibility (vis
));
11019 /* Check to see if any other bits in the st_other field are set.
11020 Note - displaying this information disrupts the layout of the
11021 table being generated, but for the moment this case is very
11023 if (psym
->st_other
^ vis
)
11024 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11027 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
11028 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11029 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11031 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11035 static const char *
11036 get_symbol_version_string (FILE * file
,
11037 bfd_boolean is_dynsym
,
11038 const char * strtab
,
11039 unsigned long int strtab_size
,
11041 Elf_Internal_Sym
* psym
,
11042 enum versioned_symbol_info
* sym_info
,
11043 unsigned short * vna_other
)
11045 unsigned char data
[2];
11046 unsigned short vers_data
;
11047 unsigned long offset
;
11050 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11053 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11054 sizeof data
+ si
* sizeof (vers_data
));
11056 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
11057 sizeof (data
), 1, _("version data")) == NULL
)
11060 vers_data
= byte_get (data
, 2);
11062 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11065 /* Usually we'd only see verdef for defined symbols, and verneed for
11066 undefined symbols. However, symbols defined by the linker in
11067 .dynbss for variables copied from a shared library in order to
11068 avoid text relocations are defined yet have verneed. We could
11069 use a heuristic to detect the special case, for example, check
11070 for verneed first on symbols defined in SHT_NOBITS sections, but
11071 it is simpler and more reliable to just look for both verdef and
11072 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11074 if (psym
->st_shndx
!= SHN_UNDEF
11075 && vers_data
!= 0x8001
11076 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11078 Elf_Internal_Verdef ivd
;
11079 Elf_Internal_Verdaux ivda
;
11080 Elf_External_Verdaux evda
;
11083 off
= offset_from_vma (file
,
11084 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11085 sizeof (Elf_External_Verdef
));
11089 Elf_External_Verdef evd
;
11091 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11092 _("version def")) == NULL
)
11100 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11101 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11102 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11105 off
+= ivd
.vd_next
;
11107 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11109 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11111 off
-= ivd
.vd_next
;
11114 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11115 _("version def aux")) != NULL
)
11117 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11119 if (psym
->st_name
!= ivda
.vda_name
)
11121 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11122 ? symbol_hidden
: symbol_public
);
11123 return (ivda
.vda_name
< strtab_size
11124 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11130 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11132 Elf_External_Verneed evn
;
11133 Elf_Internal_Verneed ivn
;
11134 Elf_Internal_Vernaux ivna
;
11136 offset
= offset_from_vma (file
,
11137 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11141 unsigned long vna_off
;
11143 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11144 _("version need")) == NULL
)
11147 ivna
.vna_other
= 0;
11152 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11153 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11155 vna_off
= offset
+ ivn
.vn_aux
;
11159 Elf_External_Vernaux evna
;
11161 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11162 _("version need aux (3)")) == NULL
)
11165 ivna
.vna_other
= 0;
11170 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11171 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11172 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11175 vna_off
+= ivna
.vna_next
;
11177 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11179 if (ivna
.vna_other
== vers_data
)
11182 offset
+= ivn
.vn_next
;
11184 while (ivn
.vn_next
!= 0);
11186 if (ivna
.vna_other
== vers_data
)
11188 *sym_info
= symbol_undefined
;
11189 *vna_other
= ivna
.vna_other
;
11190 return (ivna
.vna_name
< strtab_size
11191 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11197 /* Dump the symbol table. */
11199 process_symbol_table (FILE * file
)
11201 Elf_Internal_Shdr
* section
;
11202 bfd_size_type nbuckets
= 0;
11203 bfd_size_type nchains
= 0;
11204 bfd_vma
* buckets
= NULL
;
11205 bfd_vma
* chains
= NULL
;
11206 bfd_vma ngnubuckets
= 0;
11207 bfd_vma
* gnubuckets
= NULL
;
11208 bfd_vma
* gnuchains
= NULL
;
11209 bfd_vma gnusymidx
= 0;
11210 bfd_size_type ngnuchains
= 0;
11212 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11215 if (dynamic_info
[DT_HASH
]
11217 || (do_using_dynamic
11219 && dynamic_strings
!= NULL
)))
11221 unsigned char nb
[8];
11222 unsigned char nc
[8];
11223 unsigned int hash_ent_size
= 4;
11225 if ((elf_header
.e_machine
== EM_ALPHA
11226 || elf_header
.e_machine
== EM_S390
11227 || elf_header
.e_machine
== EM_S390_OLD
)
11228 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11232 (archive_file_offset
11233 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11234 sizeof nb
+ sizeof nc
)),
11237 error (_("Unable to seek to start of dynamic information\n"));
11241 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11243 error (_("Failed to read in number of buckets\n"));
11247 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11249 error (_("Failed to read in number of chains\n"));
11253 nbuckets
= byte_get (nb
, hash_ent_size
);
11254 nchains
= byte_get (nc
, hash_ent_size
);
11256 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11257 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11260 if (buckets
== NULL
|| chains
== NULL
)
11262 if (do_using_dynamic
)
11273 if (dynamic_info_DT_GNU_HASH
11275 || (do_using_dynamic
11277 && dynamic_strings
!= NULL
)))
11279 unsigned char nb
[16];
11280 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11281 bfd_vma buckets_vma
;
11284 (archive_file_offset
11285 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11289 error (_("Unable to seek to start of dynamic information\n"));
11293 if (fread (nb
, 16, 1, file
) != 1)
11295 error (_("Failed to read in number of buckets\n"));
11299 ngnubuckets
= byte_get (nb
, 4);
11300 gnusymidx
= byte_get (nb
+ 4, 4);
11301 bitmaskwords
= byte_get (nb
+ 8, 4);
11302 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11304 buckets_vma
+= bitmaskwords
* 4;
11306 buckets_vma
+= bitmaskwords
* 8;
11309 (archive_file_offset
11310 + offset_from_vma (file
, buckets_vma
, 4)),
11313 error (_("Unable to seek to start of dynamic information\n"));
11317 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11319 if (gnubuckets
== NULL
)
11322 for (i
= 0; i
< ngnubuckets
; i
++)
11323 if (gnubuckets
[i
] != 0)
11325 if (gnubuckets
[i
] < gnusymidx
)
11328 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11329 maxchain
= gnubuckets
[i
];
11332 if (maxchain
== 0xffffffff)
11335 maxchain
-= gnusymidx
;
11338 (archive_file_offset
11339 + offset_from_vma (file
, buckets_vma
11340 + 4 * (ngnubuckets
+ maxchain
), 4)),
11343 error (_("Unable to seek to start of dynamic information\n"));
11349 if (fread (nb
, 4, 1, file
) != 1)
11351 error (_("Failed to determine last chain length\n"));
11355 if (maxchain
+ 1 == 0)
11360 while ((byte_get (nb
, 4) & 1) == 0);
11363 (archive_file_offset
11364 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11367 error (_("Unable to seek to start of dynamic information\n"));
11371 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11372 ngnuchains
= maxchain
;
11375 if (gnuchains
== NULL
)
11380 if (do_using_dynamic
)
11385 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11387 && do_using_dynamic
11388 && dynamic_strings
!= NULL
11389 && dynamic_symbols
!= NULL
)
11393 if (dynamic_info
[DT_HASH
])
11397 printf (_("\nSymbol table for image:\n"));
11399 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11401 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11403 for (hn
= 0; hn
< nbuckets
; hn
++)
11408 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11409 print_dynamic_symbol (si
, hn
);
11413 if (dynamic_info_DT_GNU_HASH
)
11415 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11417 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11419 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11421 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11422 if (gnubuckets
[hn
] != 0)
11424 bfd_vma si
= gnubuckets
[hn
];
11425 bfd_vma off
= si
- gnusymidx
;
11429 print_dynamic_symbol (si
, hn
);
11432 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11436 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11437 && section_headers
!= NULL
)
11441 for (i
= 0, section
= section_headers
;
11442 i
< elf_header
.e_shnum
;
11446 char * strtab
= NULL
;
11447 unsigned long int strtab_size
= 0;
11448 Elf_Internal_Sym
* symtab
;
11449 Elf_Internal_Sym
* psym
;
11450 unsigned long num_syms
;
11452 if ((section
->sh_type
!= SHT_SYMTAB
11453 && section
->sh_type
!= SHT_DYNSYM
)
11455 && section
->sh_type
== SHT_SYMTAB
))
11458 if (section
->sh_entsize
== 0)
11460 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11461 printable_section_name (section
));
11465 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11466 printable_section_name (section
),
11467 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11470 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11472 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11474 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11475 if (symtab
== NULL
)
11478 if (section
->sh_link
== elf_header
.e_shstrndx
)
11480 strtab
= string_table
;
11481 strtab_size
= string_table_length
;
11483 else if (section
->sh_link
< elf_header
.e_shnum
)
11485 Elf_Internal_Shdr
* string_sec
;
11487 string_sec
= section_headers
+ section
->sh_link
;
11489 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11490 1, string_sec
->sh_size
,
11491 _("string table"));
11492 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11495 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11497 const char *version_string
;
11498 enum versioned_symbol_info sym_info
;
11499 unsigned short vna_other
;
11501 printf ("%6d: ", si
);
11502 print_vma (psym
->st_value
, LONG_HEX
);
11504 print_vma (psym
->st_size
, DEC_5
);
11505 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11506 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11507 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11508 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11511 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11513 printf (" %-7s", get_symbol_visibility (vis
));
11514 /* Check to see if any other bits in the st_other field are set.
11515 Note - displaying this information disrupts the layout of the
11516 table being generated, but for the moment this case is very rare. */
11517 if (psym
->st_other
^ vis
)
11518 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11520 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11521 print_symbol (25, psym
->st_name
< strtab_size
11522 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11525 = get_symbol_version_string (file
,
11526 section
->sh_type
== SHT_DYNSYM
,
11527 strtab
, strtab_size
, si
,
11528 psym
, &sym_info
, &vna_other
);
11529 if (version_string
)
11531 if (sym_info
== symbol_undefined
)
11532 printf ("@%s (%d)", version_string
, vna_other
);
11534 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11540 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11541 && si
>= section
->sh_info
11542 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11543 && elf_header
.e_machine
!= EM_MIPS
11544 /* Solaris binaries have been found to violate this requirement as
11545 well. Not sure if this is a bug or an ABI requirement. */
11546 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11547 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11548 si
, printable_section_name (section
), section
->sh_info
);
11552 if (strtab
!= string_table
)
11558 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11560 if (do_histogram
&& buckets
!= NULL
)
11562 unsigned long * lengths
;
11563 unsigned long * counts
;
11566 unsigned long maxlength
= 0;
11567 unsigned long nzero_counts
= 0;
11568 unsigned long nsyms
= 0;
11569 unsigned long chained
;
11571 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11572 (unsigned long) nbuckets
);
11574 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11575 if (lengths
== NULL
)
11577 error (_("Out of memory allocating space for histogram buckets\n"));
11581 printf (_(" Length Number %% of total Coverage\n"));
11582 for (hn
= 0; hn
< nbuckets
; ++hn
)
11584 for (si
= buckets
[hn
], chained
= 0;
11585 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11586 si
= chains
[si
], ++chained
)
11589 if (maxlength
< ++lengths
[hn
])
11593 /* PR binutils/17531: A corrupt binary could contain broken
11594 histogram data. Do not go into an infinite loop trying
11596 if (chained
> nchains
)
11598 error (_("histogram chain is corrupt\n"));
11603 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11604 if (counts
== NULL
)
11607 error (_("Out of memory allocating space for histogram counts\n"));
11611 for (hn
= 0; hn
< nbuckets
; ++hn
)
11612 ++counts
[lengths
[hn
]];
11617 printf (" 0 %-10lu (%5.1f%%)\n",
11618 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11619 for (i
= 1; i
<= maxlength
; ++i
)
11621 nzero_counts
+= counts
[i
] * i
;
11622 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11623 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11624 (nzero_counts
* 100.0) / nsyms
);
11632 if (buckets
!= NULL
)
11638 if (do_histogram
&& gnubuckets
!= NULL
)
11640 unsigned long * lengths
;
11641 unsigned long * counts
;
11643 unsigned long maxlength
= 0;
11644 unsigned long nzero_counts
= 0;
11645 unsigned long nsyms
= 0;
11647 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11648 (unsigned long) ngnubuckets
);
11650 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11651 if (lengths
== NULL
)
11653 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11657 printf (_(" Length Number %% of total Coverage\n"));
11659 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11660 if (gnubuckets
[hn
] != 0)
11662 bfd_vma off
, length
= 1;
11664 for (off
= gnubuckets
[hn
] - gnusymidx
;
11665 /* PR 17531 file: 010-77222-0.004. */
11666 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11669 lengths
[hn
] = length
;
11670 if (length
> maxlength
)
11671 maxlength
= length
;
11675 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11676 if (counts
== NULL
)
11679 error (_("Out of memory allocating space for gnu histogram counts\n"));
11683 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11684 ++counts
[lengths
[hn
]];
11686 if (ngnubuckets
> 0)
11689 printf (" 0 %-10lu (%5.1f%%)\n",
11690 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11691 for (j
= 1; j
<= maxlength
; ++j
)
11693 nzero_counts
+= counts
[j
] * j
;
11694 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11695 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11696 (nzero_counts
* 100.0) / nsyms
);
11710 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11714 if (dynamic_syminfo
== NULL
11716 /* No syminfo, this is ok. */
11719 /* There better should be a dynamic symbol section. */
11720 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11724 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11725 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11727 printf (_(" Num: Name BoundTo Flags\n"));
11728 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11730 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11732 printf ("%4d: ", i
);
11733 if (i
>= num_dynamic_syms
)
11734 printf (_("<corrupt index>"));
11735 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11736 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11738 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11741 switch (dynamic_syminfo
[i
].si_boundto
)
11743 case SYMINFO_BT_SELF
:
11744 fputs ("SELF ", stdout
);
11746 case SYMINFO_BT_PARENT
:
11747 fputs ("PARENT ", stdout
);
11750 if (dynamic_syminfo
[i
].si_boundto
> 0
11751 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11752 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11754 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11758 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11762 if (flags
& SYMINFO_FLG_DIRECT
)
11763 printf (" DIRECT");
11764 if (flags
& SYMINFO_FLG_PASSTHRU
)
11765 printf (" PASSTHRU");
11766 if (flags
& SYMINFO_FLG_COPY
)
11768 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11769 printf (" LAZYLOAD");
11777 #define IN_RANGE(START,END,ADDR,OFF) \
11778 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11780 /* Check to see if the given reloc needs to be handled in a target specific
11781 manner. If so then process the reloc and return TRUE otherwise return
11784 If called with reloc == NULL, then this is a signal that reloc processing
11785 for the current section has finished, and any saved state should be
11789 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11790 unsigned char * start
,
11791 unsigned char * end
,
11792 Elf_Internal_Sym
* symtab
,
11793 unsigned long num_syms
)
11795 unsigned int reloc_type
= 0;
11796 unsigned long sym_index
= 0;
11800 reloc_type
= get_reloc_type (reloc
->r_info
);
11801 sym_index
= get_reloc_symindex (reloc
->r_info
);
11804 switch (elf_header
.e_machine
)
11807 case EM_MSP430_OLD
:
11809 static Elf_Internal_Sym
* saved_sym
= NULL
;
11817 switch (reloc_type
)
11819 case 10: /* R_MSP430_SYM_DIFF */
11820 if (uses_msp430x_relocs ())
11822 /* Fall through. */
11823 case 21: /* R_MSP430X_SYM_DIFF */
11825 if (sym_index
>= num_syms
)
11826 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11829 saved_sym
= symtab
+ sym_index
;
11832 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11833 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11834 goto handle_sym_diff
;
11836 case 5: /* R_MSP430_16_BYTE */
11837 case 9: /* R_MSP430_8 */
11838 if (uses_msp430x_relocs ())
11840 goto handle_sym_diff
;
11842 case 2: /* R_MSP430_ABS16 */
11843 case 15: /* R_MSP430X_ABS16 */
11844 if (! uses_msp430x_relocs ())
11846 goto handle_sym_diff
;
11849 if (saved_sym
!= NULL
)
11851 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11854 if (sym_index
>= num_syms
)
11855 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11859 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11860 - saved_sym
->st_value
);
11862 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11863 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11866 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11867 (long) reloc
->r_offset
);
11876 if (saved_sym
!= NULL
)
11877 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11884 case EM_CYGNUS_MN10300
:
11886 static Elf_Internal_Sym
* saved_sym
= NULL
;
11894 switch (reloc_type
)
11896 case 34: /* R_MN10300_ALIGN */
11898 case 33: /* R_MN10300_SYM_DIFF */
11899 if (sym_index
>= num_syms
)
11900 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11903 saved_sym
= symtab
+ sym_index
;
11906 case 1: /* R_MN10300_32 */
11907 case 2: /* R_MN10300_16 */
11908 if (saved_sym
!= NULL
)
11910 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11913 if (sym_index
>= num_syms
)
11914 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11918 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11919 - saved_sym
->st_value
);
11921 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11922 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11924 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11925 (long) reloc
->r_offset
);
11933 if (saved_sym
!= NULL
)
11934 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11942 static bfd_vma saved_sym1
= 0;
11943 static bfd_vma saved_sym2
= 0;
11944 static bfd_vma value
;
11948 saved_sym1
= saved_sym2
= 0;
11952 switch (reloc_type
)
11954 case 0x80: /* R_RL78_SYM. */
11955 saved_sym1
= saved_sym2
;
11956 if (sym_index
>= num_syms
)
11957 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11961 saved_sym2
= symtab
[sym_index
].st_value
;
11962 saved_sym2
+= reloc
->r_addend
;
11966 case 0x83: /* R_RL78_OPsub. */
11967 value
= saved_sym1
- saved_sym2
;
11968 saved_sym2
= saved_sym1
= 0;
11972 case 0x41: /* R_RL78_ABS32. */
11973 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11974 byte_put (start
+ reloc
->r_offset
, value
, 4);
11976 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11977 (long) reloc
->r_offset
);
11981 case 0x43: /* R_RL78_ABS16. */
11982 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11983 byte_put (start
+ reloc
->r_offset
, value
, 2);
11985 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11986 (long) reloc
->r_offset
);
12000 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12001 DWARF debug sections. This is a target specific test. Note - we do not
12002 go through the whole including-target-headers-multiple-times route, (as
12003 we have already done with <elf/h8.h>) because this would become very
12004 messy and even then this function would have to contain target specific
12005 information (the names of the relocs instead of their numeric values).
12006 FIXME: This is not the correct way to solve this problem. The proper way
12007 is to have target specific reloc sizing and typing functions created by
12008 the reloc-macros.h header, in the same way that it already creates the
12009 reloc naming functions. */
12012 is_32bit_abs_reloc (unsigned int reloc_type
)
12014 /* Please keep this table alpha-sorted for ease of visual lookup. */
12015 switch (elf_header
.e_machine
)
12019 return reloc_type
== 1; /* R_386_32. */
12021 return reloc_type
== 1; /* R_68K_32. */
12023 return reloc_type
== 1; /* R_860_32. */
12025 return reloc_type
== 2; /* R_960_32. */
12027 return (reloc_type
== 258
12028 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12029 case EM_ADAPTEVA_EPIPHANY
:
12030 return reloc_type
== 3;
12032 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12034 return reloc_type
== 1; /* R_ARC_32. */
12035 case EM_ARC_COMPACT
:
12036 case EM_ARC_COMPACT2
:
12037 return reloc_type
== 4; /* R_ARC_32. */
12039 return reloc_type
== 2; /* R_ARM_ABS32 */
12042 return reloc_type
== 1;
12044 return reloc_type
== 0x12; /* R_byte4_data. */
12046 return reloc_type
== 3; /* R_CRIS_32. */
12048 return reloc_type
== 3; /* R_CR16_NUM32. */
12050 return reloc_type
== 15; /* R_CRX_NUM32. */
12051 case EM_CYGNUS_FRV
:
12052 return reloc_type
== 1;
12053 case EM_CYGNUS_D10V
:
12055 return reloc_type
== 6; /* R_D10V_32. */
12056 case EM_CYGNUS_D30V
:
12058 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12060 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12061 case EM_CYGNUS_FR30
:
12063 return reloc_type
== 3; /* R_FR30_32. */
12065 return reloc_type
== 1; /* R_FT32_32. */
12069 return reloc_type
== 1; /* R_H8_DIR32. */
12071 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12072 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
12075 return reloc_type
== 2; /* R_IP2K_32. */
12077 return reloc_type
== 2; /* R_IQ2000_32. */
12078 case EM_LATTICEMICO32
:
12079 return reloc_type
== 3; /* R_LM32_32. */
12082 return reloc_type
== 3; /* R_M32C_32. */
12084 return reloc_type
== 34; /* R_M32R_32_RELA. */
12087 return reloc_type
== 6; /* R_M68HC11_32. */
12089 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12090 case EM_CYGNUS_MEP
:
12091 return reloc_type
== 4; /* R_MEP_32. */
12093 return reloc_type
== 2; /* R_METAG_ADDR32. */
12094 case EM_MICROBLAZE
:
12095 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12097 return reloc_type
== 2; /* R_MIPS_32. */
12099 return reloc_type
== 4; /* R_MMIX_32. */
12100 case EM_CYGNUS_MN10200
:
12102 return reloc_type
== 1; /* R_MN10200_32. */
12103 case EM_CYGNUS_MN10300
:
12105 return reloc_type
== 1; /* R_MN10300_32. */
12107 return reloc_type
== 1; /* R_MOXIE_32. */
12108 case EM_MSP430_OLD
:
12110 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12112 return reloc_type
== 2; /* R_MT_32. */
12114 return reloc_type
== 20; /* R_NDS32_RELA. */
12115 case EM_ALTERA_NIOS2
:
12116 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12118 return reloc_type
== 1; /* R_NIOS_32. */
12120 return reloc_type
== 1; /* R_OR1K_32. */
12122 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12123 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12126 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12128 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12130 return reloc_type
== 1; /* R_PPC_ADDR32. */
12132 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12134 return reloc_type
== 1; /* R_RISCV_32. */
12136 return reloc_type
== 1; /* R_RL78_DIR32. */
12138 return reloc_type
== 1; /* R_RX_DIR32. */
12140 return reloc_type
== 1; /* R_I370_ADDR31. */
12143 return reloc_type
== 4; /* R_S390_32. */
12145 return reloc_type
== 8; /* R_SCORE_ABS32. */
12147 return reloc_type
== 1; /* R_SH_DIR32. */
12148 case EM_SPARC32PLUS
:
12151 return reloc_type
== 3 /* R_SPARC_32. */
12152 || reloc_type
== 23; /* R_SPARC_UA32. */
12154 return reloc_type
== 6; /* R_SPU_ADDR32 */
12156 return reloc_type
== 1; /* R_C6000_ABS32. */
12158 return reloc_type
== 2; /* R_TILEGX_32. */
12160 return reloc_type
== 1; /* R_TILEPRO_32. */
12161 case EM_CYGNUS_V850
:
12163 return reloc_type
== 6; /* R_V850_ABS32. */
12165 return reloc_type
== 0x33; /* R_V810_WORD. */
12167 return reloc_type
== 1; /* R_VAX_32. */
12169 return reloc_type
== 3; /* R_VISIUM_32. */
12170 case EM_WEBASSEMBLY
:
12171 return reloc_type
== 1; /* R_WASM32_32. */
12175 return reloc_type
== 10; /* R_X86_64_32. */
12178 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12180 return reloc_type
== 4; /* R_XGATE_32. */
12182 return reloc_type
== 1; /* R_XSTROMY16_32. */
12183 case EM_XTENSA_OLD
:
12185 return reloc_type
== 1; /* R_XTENSA_32. */
12188 static unsigned int prev_warn
= 0;
12190 /* Avoid repeating the same warning multiple times. */
12191 if (prev_warn
!= elf_header
.e_machine
)
12192 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12193 elf_header
.e_machine
);
12194 prev_warn
= elf_header
.e_machine
;
12200 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12201 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12204 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12206 switch (elf_header
.e_machine
)
12207 /* Please keep this table alpha-sorted for ease of visual lookup. */
12211 return reloc_type
== 2; /* R_386_PC32. */
12213 return reloc_type
== 4; /* R_68K_PC32. */
12215 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12216 case EM_ADAPTEVA_EPIPHANY
:
12217 return reloc_type
== 6;
12219 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12220 case EM_ARC_COMPACT
:
12221 case EM_ARC_COMPACT2
:
12222 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12224 return reloc_type
== 3; /* R_ARM_REL32 */
12227 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12228 case EM_MICROBLAZE
:
12229 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12231 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12233 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12235 return reloc_type
== 26; /* R_PPC_REL32. */
12237 return reloc_type
== 26; /* R_PPC64_REL32. */
12240 return reloc_type
== 5; /* R_390_PC32. */
12242 return reloc_type
== 2; /* R_SH_REL32. */
12243 case EM_SPARC32PLUS
:
12246 return reloc_type
== 6; /* R_SPARC_DISP32. */
12248 return reloc_type
== 13; /* R_SPU_REL32. */
12250 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12252 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12254 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12258 return reloc_type
== 2; /* R_X86_64_PC32. */
12259 case EM_XTENSA_OLD
:
12261 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12263 /* Do not abort or issue an error message here. Not all targets use
12264 pc-relative 32-bit relocs in their DWARF debug information and we
12265 have already tested for target coverage in is_32bit_abs_reloc. A
12266 more helpful warning message will be generated by apply_relocations
12267 anyway, so just return. */
12272 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12273 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12276 is_64bit_abs_reloc (unsigned int reloc_type
)
12278 switch (elf_header
.e_machine
)
12281 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12283 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12285 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12287 return reloc_type
== 80; /* R_PARISC_DIR64. */
12289 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12291 return reloc_type
== 2; /* R_RISCV_64. */
12292 case EM_SPARC32PLUS
:
12295 return reloc_type
== 54; /* R_SPARC_UA64. */
12299 return reloc_type
== 1; /* R_X86_64_64. */
12302 return reloc_type
== 22; /* R_S390_64. */
12304 return reloc_type
== 1; /* R_TILEGX_64. */
12306 return reloc_type
== 18; /* R_MIPS_64. */
12312 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12313 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12316 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12318 switch (elf_header
.e_machine
)
12321 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12323 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12325 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12327 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12329 return reloc_type
== 44; /* R_PPC64_REL64. */
12330 case EM_SPARC32PLUS
:
12333 return reloc_type
== 46; /* R_SPARC_DISP64. */
12337 return reloc_type
== 24; /* R_X86_64_PC64. */
12340 return reloc_type
== 23; /* R_S390_PC64. */
12342 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12348 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12349 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12352 is_24bit_abs_reloc (unsigned int reloc_type
)
12354 switch (elf_header
.e_machine
)
12356 case EM_CYGNUS_MN10200
:
12358 return reloc_type
== 4; /* R_MN10200_24. */
12360 return reloc_type
== 5; /* R_FT32_20. */
12366 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12367 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12370 is_16bit_abs_reloc (unsigned int reloc_type
)
12372 /* Please keep this table alpha-sorted for ease of visual lookup. */
12373 switch (elf_header
.e_machine
)
12376 case EM_ARC_COMPACT
:
12377 case EM_ARC_COMPACT2
:
12378 return reloc_type
== 2; /* R_ARC_16. */
12379 case EM_ADAPTEVA_EPIPHANY
:
12380 return reloc_type
== 5;
12383 return reloc_type
== 4; /* R_AVR_16. */
12384 case EM_CYGNUS_D10V
:
12386 return reloc_type
== 3; /* R_D10V_16. */
12390 return reloc_type
== R_H8_DIR16
;
12393 return reloc_type
== 1; /* R_IP2K_16. */
12396 return reloc_type
== 1; /* R_M32C_16 */
12397 case EM_CYGNUS_MN10200
:
12399 return reloc_type
== 2; /* R_MN10200_16. */
12400 case EM_CYGNUS_MN10300
:
12402 return reloc_type
== 2; /* R_MN10300_16. */
12404 if (uses_msp430x_relocs ())
12405 return reloc_type
== 2; /* R_MSP430_ABS16. */
12406 /* Fall through. */
12407 case EM_MSP430_OLD
:
12408 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12410 return reloc_type
== 19; /* R_NDS32_RELA. */
12411 case EM_ALTERA_NIOS2
:
12412 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12414 return reloc_type
== 9; /* R_NIOS_16. */
12416 return reloc_type
== 2; /* R_OR1K_16. */
12418 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12420 return reloc_type
== 2; /* R_C6000_ABS16. */
12422 return reloc_type
== 2; /* R_VISIUM_16. */
12425 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12427 return reloc_type
== 3; /* R_XGATE_16. */
12433 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12434 relocation entries (possibly formerly used for SHT_GROUP sections). */
12437 is_none_reloc (unsigned int reloc_type
)
12439 switch (elf_header
.e_machine
)
12441 case EM_386
: /* R_386_NONE. */
12442 case EM_68K
: /* R_68K_NONE. */
12443 case EM_ADAPTEVA_EPIPHANY
:
12444 case EM_ALPHA
: /* R_ALPHA_NONE. */
12445 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12446 case EM_ARC
: /* R_ARC_NONE. */
12447 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12448 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12449 case EM_ARM
: /* R_ARM_NONE. */
12450 case EM_C166
: /* R_XC16X_NONE. */
12451 case EM_CRIS
: /* R_CRIS_NONE. */
12452 case EM_FT32
: /* R_FT32_NONE. */
12453 case EM_IA_64
: /* R_IA64_NONE. */
12454 case EM_K1OM
: /* R_X86_64_NONE. */
12455 case EM_L1OM
: /* R_X86_64_NONE. */
12456 case EM_M32R
: /* R_M32R_NONE. */
12457 case EM_MIPS
: /* R_MIPS_NONE. */
12458 case EM_MN10300
: /* R_MN10300_NONE. */
12459 case EM_MOXIE
: /* R_MOXIE_NONE. */
12460 case EM_NIOS32
: /* R_NIOS_NONE. */
12461 case EM_OR1K
: /* R_OR1K_NONE. */
12462 case EM_PARISC
: /* R_PARISC_NONE. */
12463 case EM_PPC64
: /* R_PPC64_NONE. */
12464 case EM_PPC
: /* R_PPC_NONE. */
12465 case EM_RISCV
: /* R_RISCV_NONE. */
12466 case EM_S390
: /* R_390_NONE. */
12468 case EM_SH
: /* R_SH_NONE. */
12469 case EM_SPARC32PLUS
:
12470 case EM_SPARC
: /* R_SPARC_NONE. */
12472 case EM_TILEGX
: /* R_TILEGX_NONE. */
12473 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12474 case EM_TI_C6000
:/* R_C6000_NONE. */
12475 case EM_X86_64
: /* R_X86_64_NONE. */
12477 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12478 return reloc_type
== 0;
12481 return reloc_type
== 0 || reloc_type
== 256;
12484 return (reloc_type
== 0 /* R_AVR_NONE. */
12485 || reloc_type
== 30 /* R_AVR_DIFF8. */
12486 || reloc_type
== 31 /* R_AVR_DIFF16. */
12487 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12489 return reloc_type
== 3; /* R_METAG_NONE. */
12491 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12492 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12493 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12494 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12495 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12497 return (reloc_type
== 0 /* R_PRU_NONE. */
12498 || reloc_type
== 65 /* R_PRU_DIFF8. */
12499 || reloc_type
== 66 /* R_PRU_DIFF16. */
12500 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12501 case EM_XTENSA_OLD
:
12503 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12504 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12505 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12506 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12511 /* Returns TRUE if there is a relocation against
12512 section NAME at OFFSET bytes. */
12515 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12517 Elf_Internal_Rela
* relocs
;
12518 Elf_Internal_Rela
* rp
;
12520 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12523 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12525 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12526 if (rp
->r_offset
== offset
)
12532 /* Apply relocations to a section.
12533 Returns TRUE upon success, FALSE otherwise.
12534 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12535 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12536 will be set to the number of relocs loaded.
12538 Note: So far support has been added only for those relocations
12539 which can be found in debug sections. FIXME: Add support for
12540 more relocations ? */
12543 apply_relocations (void * file
,
12544 const Elf_Internal_Shdr
* section
,
12545 unsigned char * start
,
12546 bfd_size_type size
,
12547 void ** relocs_return
,
12548 unsigned long * num_relocs_return
)
12550 Elf_Internal_Shdr
* relsec
;
12551 unsigned char * end
= start
+ size
;
12552 bfd_boolean res
= TRUE
;
12554 if (relocs_return
!= NULL
)
12556 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12557 * num_relocs_return
= 0;
12560 if (elf_header
.e_type
!= ET_REL
)
12561 /* No relocs to apply. */
12564 /* Find the reloc section associated with the section. */
12565 for (relsec
= section_headers
;
12566 relsec
< section_headers
+ elf_header
.e_shnum
;
12569 bfd_boolean is_rela
;
12570 unsigned long num_relocs
;
12571 Elf_Internal_Rela
* relocs
;
12572 Elf_Internal_Rela
* rp
;
12573 Elf_Internal_Shdr
* symsec
;
12574 Elf_Internal_Sym
* symtab
;
12575 unsigned long num_syms
;
12576 Elf_Internal_Sym
* sym
;
12578 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12579 || relsec
->sh_info
>= elf_header
.e_shnum
12580 || section_headers
+ relsec
->sh_info
!= section
12581 || relsec
->sh_size
== 0
12582 || relsec
->sh_link
>= elf_header
.e_shnum
)
12585 is_rela
= relsec
->sh_type
== SHT_RELA
;
12589 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12590 relsec
->sh_size
, & relocs
, & num_relocs
))
12595 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12596 relsec
->sh_size
, & relocs
, & num_relocs
))
12600 /* SH uses RELA but uses in place value instead of the addend field. */
12601 if (elf_header
.e_machine
== EM_SH
)
12604 symsec
= section_headers
+ relsec
->sh_link
;
12605 if (symsec
->sh_type
!= SHT_SYMTAB
12606 && symsec
->sh_type
!= SHT_DYNSYM
)
12608 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12610 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12613 unsigned int reloc_type
;
12614 unsigned int reloc_size
;
12615 unsigned char * rloc
;
12616 unsigned long sym_index
;
12618 reloc_type
= get_reloc_type (rp
->r_info
);
12620 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12622 else if (is_none_reloc (reloc_type
))
12624 else if (is_32bit_abs_reloc (reloc_type
)
12625 || is_32bit_pcrel_reloc (reloc_type
))
12627 else if (is_64bit_abs_reloc (reloc_type
)
12628 || is_64bit_pcrel_reloc (reloc_type
))
12630 else if (is_24bit_abs_reloc (reloc_type
))
12632 else if (is_16bit_abs_reloc (reloc_type
))
12636 static unsigned int prev_reloc
= 0;
12637 if (reloc_type
!= prev_reloc
)
12638 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12639 reloc_type
, printable_section_name (section
));
12640 prev_reloc
= reloc_type
;
12645 rloc
= start
+ rp
->r_offset
;
12646 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12648 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12649 (unsigned long) rp
->r_offset
,
12650 printable_section_name (section
));
12655 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12656 if (sym_index
>= num_syms
)
12658 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12659 sym_index
, printable_section_name (section
));
12663 sym
= symtab
+ sym_index
;
12665 /* If the reloc has a symbol associated with it,
12666 make sure that it is of an appropriate type.
12668 Relocations against symbols without type can happen.
12669 Gcc -feliminate-dwarf2-dups may generate symbols
12670 without type for debug info.
12672 Icc generates relocations against function symbols
12673 instead of local labels.
12675 Relocations against object symbols can happen, eg when
12676 referencing a global array. For an example of this see
12677 the _clz.o binary in libgcc.a. */
12679 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12680 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12682 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12683 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12684 (long int)(rp
- relocs
),
12685 printable_section_name (relsec
));
12692 addend
+= rp
->r_addend
;
12693 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12694 partial_inplace. */
12696 || (elf_header
.e_machine
== EM_XTENSA
12697 && reloc_type
== 1)
12698 || ((elf_header
.e_machine
== EM_PJ
12699 || elf_header
.e_machine
== EM_PJ_OLD
)
12700 && reloc_type
== 1)
12701 || ((elf_header
.e_machine
== EM_D30V
12702 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12703 && reloc_type
== 12))
12704 addend
+= byte_get (rloc
, reloc_size
);
12706 if (is_32bit_pcrel_reloc (reloc_type
)
12707 || is_64bit_pcrel_reloc (reloc_type
))
12709 /* On HPPA, all pc-relative relocations are biased by 8. */
12710 if (elf_header
.e_machine
== EM_PARISC
)
12712 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12716 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12720 /* Let the target specific reloc processing code know that
12721 we have finished with these relocs. */
12722 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12726 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12727 * num_relocs_return
= num_relocs
;
12738 #ifdef SUPPORT_DISASSEMBLY
12740 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12742 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12744 /* FIXME: XXX -- to be done --- XXX */
12750 /* Reads in the contents of SECTION from FILE, returning a pointer
12751 to a malloc'ed buffer or NULL if something went wrong. */
12754 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12756 bfd_size_type num_bytes
;
12758 num_bytes
= section
->sh_size
;
12760 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12762 printf (_("\nSection '%s' has no data to dump.\n"),
12763 printable_section_name (section
));
12767 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12768 _("section contents"));
12771 /* Uncompresses a section that was compressed using zlib, in place. */
12774 uncompress_section_contents (unsigned char **buffer
,
12775 dwarf_size_type uncompressed_size
,
12776 dwarf_size_type
*size
)
12778 dwarf_size_type compressed_size
= *size
;
12779 unsigned char * compressed_buffer
= *buffer
;
12780 unsigned char * uncompressed_buffer
;
12784 /* It is possible the section consists of several compressed
12785 buffers concatenated together, so we uncompress in a loop. */
12786 /* PR 18313: The state field in the z_stream structure is supposed
12787 to be invisible to the user (ie us), but some compilers will
12788 still complain about it being used without initialisation. So
12789 we first zero the entire z_stream structure and then set the fields
12791 memset (& strm
, 0, sizeof strm
);
12792 strm
.avail_in
= compressed_size
;
12793 strm
.next_in
= (Bytef
*) compressed_buffer
;
12794 strm
.avail_out
= uncompressed_size
;
12795 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12797 rc
= inflateInit (& strm
);
12798 while (strm
.avail_in
> 0)
12802 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12803 + (uncompressed_size
- strm
.avail_out
));
12804 rc
= inflate (&strm
, Z_FINISH
);
12805 if (rc
!= Z_STREAM_END
)
12807 rc
= inflateReset (& strm
);
12809 rc
= inflateEnd (& strm
);
12811 || strm
.avail_out
!= 0)
12814 *buffer
= uncompressed_buffer
;
12815 *size
= uncompressed_size
;
12819 free (uncompressed_buffer
);
12820 /* Indicate decompression failure. */
12826 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12828 Elf_Internal_Shdr
* relsec
;
12829 bfd_size_type num_bytes
;
12830 unsigned char * data
;
12831 unsigned char * end
;
12832 unsigned char * real_start
;
12833 unsigned char * start
;
12834 bfd_boolean some_strings_shown
;
12836 real_start
= start
= (unsigned char *) get_section_contents (section
,
12840 num_bytes
= section
->sh_size
;
12842 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12844 if (decompress_dumps
)
12846 dwarf_size_type new_size
= num_bytes
;
12847 dwarf_size_type uncompressed_size
= 0;
12849 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12851 Elf_Internal_Chdr chdr
;
12852 unsigned int compression_header_size
12853 = get_compression_header (& chdr
, (unsigned char *) start
,
12856 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12858 warn (_("section '%s' has unsupported compress type: %d\n"),
12859 printable_section_name (section
), chdr
.ch_type
);
12862 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12864 warn (_("compressed section '%s' is corrupted\n"),
12865 printable_section_name (section
));
12868 uncompressed_size
= chdr
.ch_size
;
12869 start
+= compression_header_size
;
12870 new_size
-= compression_header_size
;
12872 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12874 /* Read the zlib header. In this case, it should be "ZLIB"
12875 followed by the uncompressed section size, 8 bytes in
12876 big-endian order. */
12877 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12878 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12879 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12880 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12881 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12882 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12883 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12884 uncompressed_size
+= start
[11];
12889 if (uncompressed_size
)
12891 if (uncompress_section_contents (& start
,
12892 uncompressed_size
, & new_size
))
12893 num_bytes
= new_size
;
12896 error (_("Unable to decompress section %s\n"),
12897 printable_section_name (section
));
12902 start
= real_start
;
12905 /* If the section being dumped has relocations against it the user might
12906 be expecting these relocations to have been applied. Check for this
12907 case and issue a warning message in order to avoid confusion.
12908 FIXME: Maybe we ought to have an option that dumps a section with
12909 relocs applied ? */
12910 for (relsec
= section_headers
;
12911 relsec
< section_headers
+ elf_header
.e_shnum
;
12914 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12915 || relsec
->sh_info
>= elf_header
.e_shnum
12916 || section_headers
+ relsec
->sh_info
!= section
12917 || relsec
->sh_size
== 0
12918 || relsec
->sh_link
>= elf_header
.e_shnum
)
12921 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12926 end
= start
+ num_bytes
;
12927 some_strings_shown
= FALSE
;
12931 while (!ISPRINT (* data
))
12932 if (++ data
>= end
)
12937 size_t maxlen
= end
- data
;
12940 /* PR 11128: Use two separate invocations in order to work
12941 around bugs in the Solaris 8 implementation of printf. */
12942 printf (" [%6tx] ", data
- start
);
12944 printf (" [%6Ix] ", (size_t) (data
- start
));
12948 print_symbol ((int) maxlen
, (const char *) data
);
12950 data
+= strnlen ((const char *) data
, maxlen
);
12954 printf (_("<corrupt>\n"));
12957 some_strings_shown
= TRUE
;
12961 if (! some_strings_shown
)
12962 printf (_(" No strings found in this section."));
12971 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12973 bfd_boolean relocate
)
12975 Elf_Internal_Shdr
* relsec
;
12976 bfd_size_type bytes
;
12977 bfd_size_type section_size
;
12979 unsigned char * data
;
12980 unsigned char * real_start
;
12981 unsigned char * start
;
12983 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12987 section_size
= section
->sh_size
;
12989 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12991 if (decompress_dumps
)
12993 dwarf_size_type new_size
= section_size
;
12994 dwarf_size_type uncompressed_size
= 0;
12996 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12998 Elf_Internal_Chdr chdr
;
12999 unsigned int compression_header_size
13000 = get_compression_header (& chdr
, start
, section_size
);
13002 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13004 warn (_("section '%s' has unsupported compress type: %d\n"),
13005 printable_section_name (section
), chdr
.ch_type
);
13008 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13010 warn (_("compressed section '%s' is corrupted\n"),
13011 printable_section_name (section
));
13014 uncompressed_size
= chdr
.ch_size
;
13015 start
+= compression_header_size
;
13016 new_size
-= compression_header_size
;
13018 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13020 /* Read the zlib header. In this case, it should be "ZLIB"
13021 followed by the uncompressed section size, 8 bytes in
13022 big-endian order. */
13023 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13024 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13025 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13026 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13027 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13028 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13029 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13030 uncompressed_size
+= start
[11];
13035 if (uncompressed_size
)
13037 if (uncompress_section_contents (& start
, uncompressed_size
,
13040 section_size
= new_size
;
13044 error (_("Unable to decompress section %s\n"),
13045 printable_section_name (section
));
13046 /* FIXME: Print the section anyway ? */
13051 start
= real_start
;
13056 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
13061 /* If the section being dumped has relocations against it the user might
13062 be expecting these relocations to have been applied. Check for this
13063 case and issue a warning message in order to avoid confusion.
13064 FIXME: Maybe we ought to have an option that dumps a section with
13065 relocs applied ? */
13066 for (relsec
= section_headers
;
13067 relsec
< section_headers
+ elf_header
.e_shnum
;
13070 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13071 || relsec
->sh_info
>= elf_header
.e_shnum
13072 || section_headers
+ relsec
->sh_info
!= section
13073 || relsec
->sh_size
== 0
13074 || relsec
->sh_link
>= elf_header
.e_shnum
)
13077 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13082 addr
= section
->sh_addr
;
13083 bytes
= section_size
;
13092 lbytes
= (bytes
> 16 ? 16 : bytes
);
13094 printf (" 0x%8.8lx ", (unsigned long) addr
);
13096 for (j
= 0; j
< 16; j
++)
13099 printf ("%2.2x", data
[j
]);
13107 for (j
= 0; j
< lbytes
; j
++)
13110 if (k
>= ' ' && k
< 0x7f)
13130 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13131 const Elf_Internal_Shdr
* sec
, void * file
)
13133 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13136 /* If it is already loaded, do nothing. */
13137 if (section
->start
!= NULL
)
13140 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13141 section
->address
= sec
->sh_addr
;
13142 section
->user_data
= NULL
;
13143 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13145 sec
->sh_size
, buf
);
13146 if (section
->start
== NULL
)
13150 unsigned char *start
= section
->start
;
13151 dwarf_size_type size
= sec
->sh_size
;
13152 dwarf_size_type uncompressed_size
= 0;
13154 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13156 Elf_Internal_Chdr chdr
;
13157 unsigned int compression_header_size
;
13159 if (size
< (is_32bit_elf
13160 ? sizeof (Elf32_External_Chdr
)
13161 : sizeof (Elf64_External_Chdr
)))
13163 warn (_("compressed section %s is too small to contain a compression header"),
13168 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13170 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13172 warn (_("section '%s' has unsupported compress type: %d\n"),
13173 section
->name
, chdr
.ch_type
);
13176 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13178 warn (_("compressed section '%s' is corrupted\n"),
13182 uncompressed_size
= chdr
.ch_size
;
13183 start
+= compression_header_size
;
13184 size
-= compression_header_size
;
13186 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13188 /* Read the zlib header. In this case, it should be "ZLIB"
13189 followed by the uncompressed section size, 8 bytes in
13190 big-endian order. */
13191 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13192 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13193 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13194 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13195 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13196 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13197 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13198 uncompressed_size
+= start
[11];
13203 if (uncompressed_size
)
13205 if (uncompress_section_contents (&start
, uncompressed_size
,
13208 /* Free the compressed buffer, update the section buffer
13209 and the section size if uncompress is successful. */
13210 free (section
->start
);
13211 section
->start
= start
;
13215 error (_("Unable to decompress section %s\n"),
13216 printable_section_name (sec
));
13221 section
->size
= size
;
13224 if (section
->start
== NULL
)
13227 if (debug_displays
[debug
].relocate
)
13229 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13230 & section
->reloc_info
, & section
->num_relocs
))
13235 section
->reloc_info
= NULL
;
13236 section
->num_relocs
= 0;
13242 /* If this is not NULL, load_debug_section will only look for sections
13243 within the list of sections given here. */
13244 static unsigned int * section_subset
= NULL
;
13247 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13249 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13250 Elf_Internal_Shdr
* sec
;
13252 /* Locate the debug section. */
13253 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13255 section
->name
= section
->uncompressed_name
;
13258 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13260 section
->name
= section
->compressed_name
;
13265 /* If we're loading from a subset of sections, and we've loaded
13266 a section matching this name before, it's likely that it's a
13268 if (section_subset
!= NULL
)
13269 free_debug_section (debug
);
13271 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13275 free_debug_section (enum dwarf_section_display_enum debug
)
13277 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13279 if (section
->start
== NULL
)
13282 free ((char *) section
->start
);
13283 section
->start
= NULL
;
13284 section
->address
= 0;
13289 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13291 char * name
= SECTION_NAME (section
);
13292 const char * print_name
= printable_section_name (section
);
13293 bfd_size_type length
;
13294 bfd_boolean result
= TRUE
;
13297 length
= section
->sh_size
;
13300 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13303 if (section
->sh_type
== SHT_NOBITS
)
13305 /* There is no point in dumping the contents of a debugging section
13306 which has the NOBITS type - the bits in the file will be random.
13307 This can happen when a file containing a .eh_frame section is
13308 stripped with the --only-keep-debug command line option. */
13309 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13314 if (const_strneq (name
, ".gnu.linkonce.wi."))
13315 name
= ".debug_info";
13317 /* See if we know how to display the contents of this section. */
13318 for (i
= 0; i
< max
; i
++)
13319 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13320 || (i
== line
&& const_strneq (name
, ".debug_line."))
13321 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13323 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13324 int secondary
= (section
!= find_section (name
));
13327 free_debug_section ((enum dwarf_section_display_enum
) i
);
13329 if (i
== line
&& const_strneq (name
, ".debug_line."))
13331 else if (streq (sec
->uncompressed_name
, name
))
13332 sec
->name
= sec
->uncompressed_name
;
13334 sec
->name
= sec
->compressed_name
;
13335 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13338 /* If this debug section is part of a CU/TU set in a .dwp file,
13339 restrict load_debug_section to the sections in that set. */
13340 section_subset
= find_cu_tu_set (file
, shndx
);
13342 result
&= debug_displays
[i
].display (sec
, file
);
13344 section_subset
= NULL
;
13346 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13347 free_debug_section ((enum dwarf_section_display_enum
) i
);
13355 printf (_("Unrecognized debug section: %s\n"), print_name
);
13362 /* Set DUMP_SECTS for all sections where dumps were requested
13363 based on section name. */
13366 initialise_dumps_byname (void)
13368 struct dump_list_entry
* cur
;
13370 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13373 bfd_boolean any
= FALSE
;
13375 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13376 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13378 request_dump_bynumber (i
, cur
->type
);
13383 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13389 process_section_contents (FILE * file
)
13391 Elf_Internal_Shdr
* section
;
13393 bfd_boolean res
= TRUE
;
13398 initialise_dumps_byname ();
13400 for (i
= 0, section
= section_headers
;
13401 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13404 #ifdef SUPPORT_DISASSEMBLY
13405 if (dump_sects
[i
] & DISASS_DUMP
)
13406 disassemble_section (section
, file
);
13408 if (dump_sects
[i
] & HEX_DUMP
)
13410 if (! dump_section_as_bytes (section
, file
, FALSE
))
13414 if (dump_sects
[i
] & RELOC_DUMP
)
13416 if (! dump_section_as_bytes (section
, file
, TRUE
))
13420 if (dump_sects
[i
] & STRING_DUMP
)
13422 if (! dump_section_as_strings (section
, file
))
13426 if (dump_sects
[i
] & DEBUG_DUMP
)
13428 if (! display_debug_section (i
, section
, file
))
13433 /* Check to see if the user requested a
13434 dump of a section that does not exist. */
13435 while (i
< num_dump_sects
)
13439 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13449 process_mips_fpe_exception (int mask
)
13453 bfd_boolean first
= TRUE
;
13455 if (mask
& OEX_FPU_INEX
)
13456 fputs ("INEX", stdout
), first
= FALSE
;
13457 if (mask
& OEX_FPU_UFLO
)
13458 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13459 if (mask
& OEX_FPU_OFLO
)
13460 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13461 if (mask
& OEX_FPU_DIV0
)
13462 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13463 if (mask
& OEX_FPU_INVAL
)
13464 printf ("%sINVAL", first
? "" : "|");
13467 fputs ("0", stdout
);
13470 /* Display's the value of TAG at location P. If TAG is
13471 greater than 0 it is assumed to be an unknown tag, and
13472 a message is printed to this effect. Otherwise it is
13473 assumed that a message has already been printed.
13475 If the bottom bit of TAG is set it assumed to have a
13476 string value, otherwise it is assumed to have an integer
13479 Returns an updated P pointing to the first unread byte
13480 beyond the end of TAG's value.
13482 Reads at or beyond END will not be made. */
13484 static unsigned char *
13485 display_tag_value (signed int tag
,
13487 const unsigned char * const end
)
13492 printf (" Tag_unknown_%d: ", tag
);
13496 warn (_("<corrupt tag>\n"));
13500 /* PR 17531 file: 027-19978-0.004. */
13501 size_t maxlen
= (end
- p
) - 1;
13506 print_symbol ((int) maxlen
, (const char *) p
);
13507 p
+= strnlen ((char *) p
, maxlen
) + 1;
13511 printf (_("<corrupt string tag>"));
13512 p
= (unsigned char *) end
;
13520 val
= read_uleb128 (p
, &len
, end
);
13522 printf ("%ld (0x%lx)\n", val
, val
);
13529 /* ARC ABI attributes section. */
13531 static unsigned char *
13532 display_arc_attribute (unsigned char * p
,
13533 const unsigned char * const end
)
13539 tag
= read_uleb128 (p
, &len
, end
);
13544 case Tag_ARC_PCS_config
:
13545 val
= read_uleb128 (p
, &len
, end
);
13547 printf (" Tag_ARC_PCS_config: ");
13551 printf (_("Absent/Non standard\n"));
13554 printf (_("Bare metal/mwdt\n"));
13557 printf (_("Bare metal/newlib\n"));
13560 printf (_("Linux/uclibc\n"));
13563 printf (_("Linux/glibc\n"));
13566 printf (_("Unknown\n"));
13571 case Tag_ARC_CPU_base
:
13572 val
= read_uleb128 (p
, &len
, end
);
13574 printf (" Tag_ARC_CPU_base: ");
13579 printf (_("Absent\n"));
13581 case TAG_CPU_ARC6xx
:
13582 printf ("ARC6xx\n");
13584 case TAG_CPU_ARC7xx
:
13585 printf ("ARC7xx\n");
13587 case TAG_CPU_ARCEM
:
13588 printf ("ARCEM\n");
13590 case TAG_CPU_ARCHS
:
13591 printf ("ARCHS\n");
13596 case Tag_ARC_CPU_variation
:
13597 val
= read_uleb128 (p
, &len
, end
);
13599 printf (" Tag_ARC_CPU_variation: ");
13603 if (val
> 0 && val
< 16)
13604 printf ("Core%d\n", val
);
13606 printf ("Unknown\n");
13610 printf (_("Absent\n"));
13615 case Tag_ARC_CPU_name
:
13616 printf (" Tag_ARC_CPU_name: ");
13617 p
= display_tag_value (-1, p
, end
);
13620 case Tag_ARC_ABI_rf16
:
13621 val
= read_uleb128 (p
, &len
, end
);
13623 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
13626 case Tag_ARC_ABI_osver
:
13627 val
= read_uleb128 (p
, &len
, end
);
13629 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
13632 case Tag_ARC_ABI_pic
:
13633 case Tag_ARC_ABI_sda
:
13634 val
= read_uleb128 (p
, &len
, end
);
13636 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
13637 : " Tag_ARC_ABI_pic: ");
13641 printf (_("Absent\n"));
13650 printf (_("Unknown\n"));
13655 case Tag_ARC_ABI_tls
:
13656 val
= read_uleb128 (p
, &len
, end
);
13658 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
13661 case Tag_ARC_ABI_enumsize
:
13662 val
= read_uleb128 (p
, &len
, end
);
13664 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
13668 case Tag_ARC_ABI_exceptions
:
13669 val
= read_uleb128 (p
, &len
, end
);
13671 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
13675 case Tag_ARC_ABI_double_size
:
13676 val
= read_uleb128 (p
, &len
, end
);
13678 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
13681 case Tag_ARC_ISA_config
:
13682 printf (" Tag_ARC_ISA_config: ");
13683 p
= display_tag_value (-1, p
, end
);
13686 case Tag_ARC_ISA_apex
:
13687 printf (" Tag_ARC_ISA_apex: ");
13688 p
= display_tag_value (-1, p
, end
);
13691 case Tag_ARC_ISA_mpy_option
:
13692 val
= read_uleb128 (p
, &len
, end
);
13694 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
13698 return display_tag_value (tag
& 1, p
, end
);
13704 /* ARM EABI attributes section. */
13709 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13711 const char ** table
;
13712 } arm_attr_public_tag
;
13714 static const char * arm_attr_tag_CPU_arch
[] =
13715 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13716 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13718 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13719 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13720 {"No", "Thumb-1", "Thumb-2", "Yes"};
13721 static const char * arm_attr_tag_FP_arch
[] =
13722 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13723 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13724 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13725 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13726 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13727 "NEON for ARMv8.1"};
13728 static const char * arm_attr_tag_PCS_config
[] =
13729 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13730 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13731 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13732 {"V6", "SB", "TLS", "Unused"};
13733 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13734 {"Absolute", "PC-relative", "SB-relative", "None"};
13735 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13736 {"Absolute", "PC-relative", "None"};
13737 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13738 {"None", "direct", "GOT-indirect"};
13739 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13740 {"None", "??? 1", "2", "??? 3", "4"};
13741 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13742 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13743 {"Unused", "Needed", "Sign only"};
13744 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13745 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13746 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13747 {"Unused", "Finite", "RTABI", "IEEE 754"};
13748 static const char * arm_attr_tag_ABI_enum_size
[] =
13749 {"Unused", "small", "int", "forced to int"};
13750 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13751 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13752 static const char * arm_attr_tag_ABI_VFP_args
[] =
13753 {"AAPCS", "VFP registers", "custom", "compatible"};
13754 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13755 {"AAPCS", "WMMX registers", "custom"};
13756 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13757 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13758 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13759 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13760 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13761 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13762 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13763 static const char * arm_attr_tag_FP_HP_extension
[] =
13764 {"Not Allowed", "Allowed"};
13765 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13766 {"None", "IEEE 754", "Alternative Format"};
13767 static const char * arm_attr_tag_DSP_extension
[] =
13768 {"Follow architecture", "Allowed"};
13769 static const char * arm_attr_tag_MPextension_use
[] =
13770 {"Not Allowed", "Allowed"};
13771 static const char * arm_attr_tag_DIV_use
[] =
13772 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13773 "Allowed in v7-A with integer division extension"};
13774 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13775 static const char * arm_attr_tag_Virtualization_use
[] =
13776 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13777 "TrustZone and Virtualization Extensions"};
13778 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13779 {"Not Allowed", "Allowed"};
13781 #define LOOKUP(id, name) \
13782 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13783 static arm_attr_public_tag arm_attr_public_tags
[] =
13785 {4, "CPU_raw_name", 1, NULL
},
13786 {5, "CPU_name", 1, NULL
},
13787 LOOKUP(6, CPU_arch
),
13788 {7, "CPU_arch_profile", 0, NULL
},
13789 LOOKUP(8, ARM_ISA_use
),
13790 LOOKUP(9, THUMB_ISA_use
),
13791 LOOKUP(10, FP_arch
),
13792 LOOKUP(11, WMMX_arch
),
13793 LOOKUP(12, Advanced_SIMD_arch
),
13794 LOOKUP(13, PCS_config
),
13795 LOOKUP(14, ABI_PCS_R9_use
),
13796 LOOKUP(15, ABI_PCS_RW_data
),
13797 LOOKUP(16, ABI_PCS_RO_data
),
13798 LOOKUP(17, ABI_PCS_GOT_use
),
13799 LOOKUP(18, ABI_PCS_wchar_t
),
13800 LOOKUP(19, ABI_FP_rounding
),
13801 LOOKUP(20, ABI_FP_denormal
),
13802 LOOKUP(21, ABI_FP_exceptions
),
13803 LOOKUP(22, ABI_FP_user_exceptions
),
13804 LOOKUP(23, ABI_FP_number_model
),
13805 {24, "ABI_align_needed", 0, NULL
},
13806 {25, "ABI_align_preserved", 0, NULL
},
13807 LOOKUP(26, ABI_enum_size
),
13808 LOOKUP(27, ABI_HardFP_use
),
13809 LOOKUP(28, ABI_VFP_args
),
13810 LOOKUP(29, ABI_WMMX_args
),
13811 LOOKUP(30, ABI_optimization_goals
),
13812 LOOKUP(31, ABI_FP_optimization_goals
),
13813 {32, "compatibility", 0, NULL
},
13814 LOOKUP(34, CPU_unaligned_access
),
13815 LOOKUP(36, FP_HP_extension
),
13816 LOOKUP(38, ABI_FP_16bit_format
),
13817 LOOKUP(42, MPextension_use
),
13818 LOOKUP(44, DIV_use
),
13819 LOOKUP(46, DSP_extension
),
13820 {64, "nodefaults", 0, NULL
},
13821 {65, "also_compatible_with", 0, NULL
},
13822 LOOKUP(66, T2EE_use
),
13823 {67, "conformance", 1, NULL
},
13824 LOOKUP(68, Virtualization_use
),
13825 LOOKUP(70, MPextension_use_legacy
)
13829 static unsigned char *
13830 display_arm_attribute (unsigned char * p
,
13831 const unsigned char * const end
)
13836 arm_attr_public_tag
* attr
;
13840 tag
= read_uleb128 (p
, &len
, end
);
13843 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13845 if (arm_attr_public_tags
[i
].tag
== tag
)
13847 attr
= &arm_attr_public_tags
[i
];
13854 printf (" Tag_%s: ", attr
->name
);
13855 switch (attr
->type
)
13860 case 7: /* Tag_CPU_arch_profile. */
13861 val
= read_uleb128 (p
, &len
, end
);
13865 case 0: printf (_("None\n")); break;
13866 case 'A': printf (_("Application\n")); break;
13867 case 'R': printf (_("Realtime\n")); break;
13868 case 'M': printf (_("Microcontroller\n")); break;
13869 case 'S': printf (_("Application or Realtime\n")); break;
13870 default: printf ("??? (%d)\n", val
); break;
13874 case 24: /* Tag_align_needed. */
13875 val
= read_uleb128 (p
, &len
, end
);
13879 case 0: printf (_("None\n")); break;
13880 case 1: printf (_("8-byte\n")); break;
13881 case 2: printf (_("4-byte\n")); break;
13882 case 3: printf ("??? 3\n"); break;
13885 printf (_("8-byte and up to %d-byte extended\n"),
13888 printf ("??? (%d)\n", val
);
13893 case 25: /* Tag_align_preserved. */
13894 val
= read_uleb128 (p
, &len
, end
);
13898 case 0: printf (_("None\n")); break;
13899 case 1: printf (_("8-byte, except leaf SP\n")); break;
13900 case 2: printf (_("8-byte\n")); break;
13901 case 3: printf ("??? 3\n"); break;
13904 printf (_("8-byte and up to %d-byte extended\n"),
13907 printf ("??? (%d)\n", val
);
13912 case 32: /* Tag_compatibility. */
13914 val
= read_uleb128 (p
, &len
, end
);
13916 printf (_("flag = %d, vendor = "), val
);
13919 size_t maxlen
= (end
- p
) - 1;
13921 print_symbol ((int) maxlen
, (const char *) p
);
13922 p
+= strnlen ((char *) p
, maxlen
) + 1;
13926 printf (_("<corrupt>"));
13927 p
= (unsigned char *) end
;
13933 case 64: /* Tag_nodefaults. */
13934 /* PR 17531: file: 001-505008-0.01. */
13937 printf (_("True\n"));
13940 case 65: /* Tag_also_compatible_with. */
13941 val
= read_uleb128 (p
, &len
, end
);
13943 if (val
== 6 /* Tag_CPU_arch. */)
13945 val
= read_uleb128 (p
, &len
, end
);
13947 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13948 printf ("??? (%d)\n", val
);
13950 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13954 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13959 printf (_("<unknown: %d>\n"), tag
);
13965 return display_tag_value (-1, p
, end
);
13967 return display_tag_value (0, p
, end
);
13970 assert (attr
->type
& 0x80);
13971 val
= read_uleb128 (p
, &len
, end
);
13973 type
= attr
->type
& 0x7f;
13975 printf ("??? (%d)\n", val
);
13977 printf ("%s\n", attr
->table
[val
]);
13982 return display_tag_value (tag
, p
, end
);
13985 static unsigned char *
13986 display_gnu_attribute (unsigned char * p
,
13987 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13988 const unsigned char * const end
)
13994 tag
= read_uleb128 (p
, &len
, end
);
13997 /* Tag_compatibility is the only generic GNU attribute defined at
14001 val
= read_uleb128 (p
, &len
, end
);
14004 printf (_("flag = %d, vendor = "), val
);
14007 printf (_("<corrupt>\n"));
14008 warn (_("corrupt vendor attribute\n"));
14014 size_t maxlen
= (end
- p
) - 1;
14016 print_symbol ((int) maxlen
, (const char *) p
);
14017 p
+= strnlen ((char *) p
, maxlen
) + 1;
14021 printf (_("<corrupt>"));
14022 p
= (unsigned char *) end
;
14029 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14030 return display_proc_gnu_attribute (p
, tag
, end
);
14032 return display_tag_value (tag
, p
, end
);
14035 static unsigned char *
14036 display_power_gnu_attribute (unsigned char * p
,
14038 const unsigned char * const end
)
14043 if (tag
== Tag_GNU_Power_ABI_FP
)
14045 val
= read_uleb128 (p
, &len
, end
);
14047 printf (" Tag_GNU_Power_ABI_FP: ");
14050 printf (_("<corrupt>\n"));
14055 printf ("(%#x), ", val
);
14060 printf (_("unspecified hard/soft float, "));
14063 printf (_("hard float, "));
14066 printf (_("soft float, "));
14069 printf (_("single-precision hard float, "));
14076 printf (_("unspecified long double\n"));
14079 printf (_("128-bit IBM long double\n"));
14082 printf (_("64-bit long double\n"));
14085 printf (_("128-bit IEEE long double\n"));
14091 if (tag
== Tag_GNU_Power_ABI_Vector
)
14093 val
= read_uleb128 (p
, &len
, end
);
14095 printf (" Tag_GNU_Power_ABI_Vector: ");
14098 printf (_("<corrupt>\n"));
14103 printf ("(%#x), ", val
);
14108 printf (_("unspecified\n"));
14111 printf (_("generic\n"));
14114 printf ("AltiVec\n");
14123 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14125 val
= read_uleb128 (p
, &len
, end
);
14127 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14130 printf (_("<corrupt>\n"));
14135 printf ("(%#x), ", val
);
14140 printf (_("unspecified\n"));
14143 printf ("r3/r4\n");
14146 printf (_("memory\n"));
14155 return display_tag_value (tag
& 1, p
, end
);
14158 static unsigned char *
14159 display_s390_gnu_attribute (unsigned char * p
,
14161 const unsigned char * const end
)
14166 if (tag
== Tag_GNU_S390_ABI_Vector
)
14168 val
= read_uleb128 (p
, &len
, end
);
14170 printf (" Tag_GNU_S390_ABI_Vector: ");
14175 printf (_("any\n"));
14178 printf (_("software\n"));
14181 printf (_("hardware\n"));
14184 printf ("??? (%d)\n", val
);
14190 return display_tag_value (tag
& 1, p
, end
);
14194 display_sparc_hwcaps (unsigned int mask
)
14198 bfd_boolean first
= TRUE
;
14200 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14201 fputs ("mul32", stdout
), first
= FALSE
;
14202 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14203 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14204 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14205 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14206 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14207 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14208 if (mask
& ELF_SPARC_HWCAP_POPC
)
14209 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14210 if (mask
& ELF_SPARC_HWCAP_VIS
)
14211 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14212 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14213 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14214 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14215 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14216 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14217 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14218 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14219 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14220 if (mask
& ELF_SPARC_HWCAP_HPC
)
14221 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14222 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14223 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14224 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14225 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14226 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14227 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14228 if (mask
& ELF_SPARC_HWCAP_IMA
)
14229 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14230 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14231 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14234 fputc ('0', stdout
);
14235 fputc ('\n', stdout
);
14239 display_sparc_hwcaps2 (unsigned int mask
)
14243 bfd_boolean first
= TRUE
;
14245 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14246 fputs ("fjathplus", stdout
), first
= FALSE
;
14247 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14248 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14249 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14250 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14251 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14252 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14253 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14254 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14255 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14256 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14257 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14258 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14259 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14260 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14261 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14262 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14263 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14264 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14265 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14266 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14269 fputc ('0', stdout
);
14270 fputc ('\n', stdout
);
14273 static unsigned char *
14274 display_sparc_gnu_attribute (unsigned char * p
,
14276 const unsigned char * const end
)
14281 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14283 val
= read_uleb128 (p
, &len
, end
);
14285 printf (" Tag_GNU_Sparc_HWCAPS: ");
14286 display_sparc_hwcaps (val
);
14289 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14291 val
= read_uleb128 (p
, &len
, end
);
14293 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14294 display_sparc_hwcaps2 (val
);
14298 return display_tag_value (tag
, p
, end
);
14302 print_mips_fp_abi_value (unsigned int val
)
14306 case Val_GNU_MIPS_ABI_FP_ANY
:
14307 printf (_("Hard or soft float\n"));
14309 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14310 printf (_("Hard float (double precision)\n"));
14312 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14313 printf (_("Hard float (single precision)\n"));
14315 case Val_GNU_MIPS_ABI_FP_SOFT
:
14316 printf (_("Soft float\n"));
14318 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14319 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14321 case Val_GNU_MIPS_ABI_FP_XX
:
14322 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14324 case Val_GNU_MIPS_ABI_FP_64
:
14325 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14327 case Val_GNU_MIPS_ABI_FP_64A
:
14328 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14330 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14331 printf (_("NaN 2008 compatibility\n"));
14334 printf ("??? (%d)\n", val
);
14339 static unsigned char *
14340 display_mips_gnu_attribute (unsigned char * p
,
14342 const unsigned char * const end
)
14344 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14349 val
= read_uleb128 (p
, &len
, end
);
14351 printf (" Tag_GNU_MIPS_ABI_FP: ");
14353 print_mips_fp_abi_value (val
);
14358 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14363 val
= read_uleb128 (p
, &len
, end
);
14365 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14369 case Val_GNU_MIPS_ABI_MSA_ANY
:
14370 printf (_("Any MSA or not\n"));
14372 case Val_GNU_MIPS_ABI_MSA_128
:
14373 printf (_("128-bit MSA\n"));
14376 printf ("??? (%d)\n", val
);
14382 return display_tag_value (tag
& 1, p
, end
);
14385 static unsigned char *
14386 display_tic6x_attribute (unsigned char * p
,
14387 const unsigned char * const end
)
14393 tag
= read_uleb128 (p
, &len
, end
);
14399 val
= read_uleb128 (p
, &len
, end
);
14401 printf (" Tag_ISA: ");
14405 case C6XABI_Tag_ISA_none
:
14406 printf (_("None\n"));
14408 case C6XABI_Tag_ISA_C62X
:
14411 case C6XABI_Tag_ISA_C67X
:
14414 case C6XABI_Tag_ISA_C67XP
:
14415 printf ("C67x+\n");
14417 case C6XABI_Tag_ISA_C64X
:
14420 case C6XABI_Tag_ISA_C64XP
:
14421 printf ("C64x+\n");
14423 case C6XABI_Tag_ISA_C674X
:
14424 printf ("C674x\n");
14427 printf ("??? (%d)\n", val
);
14432 case Tag_ABI_wchar_t
:
14433 val
= read_uleb128 (p
, &len
, end
);
14435 printf (" Tag_ABI_wchar_t: ");
14439 printf (_("Not used\n"));
14442 printf (_("2 bytes\n"));
14445 printf (_("4 bytes\n"));
14448 printf ("??? (%d)\n", val
);
14453 case Tag_ABI_stack_align_needed
:
14454 val
= read_uleb128 (p
, &len
, end
);
14456 printf (" Tag_ABI_stack_align_needed: ");
14460 printf (_("8-byte\n"));
14463 printf (_("16-byte\n"));
14466 printf ("??? (%d)\n", val
);
14471 case Tag_ABI_stack_align_preserved
:
14472 val
= read_uleb128 (p
, &len
, end
);
14474 printf (" Tag_ABI_stack_align_preserved: ");
14478 printf (_("8-byte\n"));
14481 printf (_("16-byte\n"));
14484 printf ("??? (%d)\n", val
);
14490 val
= read_uleb128 (p
, &len
, end
);
14492 printf (" Tag_ABI_DSBT: ");
14496 printf (_("DSBT addressing not used\n"));
14499 printf (_("DSBT addressing used\n"));
14502 printf ("??? (%d)\n", val
);
14508 val
= read_uleb128 (p
, &len
, end
);
14510 printf (" Tag_ABI_PID: ");
14514 printf (_("Data addressing position-dependent\n"));
14517 printf (_("Data addressing position-independent, GOT near DP\n"));
14520 printf (_("Data addressing position-independent, GOT far from DP\n"));
14523 printf ("??? (%d)\n", val
);
14529 val
= read_uleb128 (p
, &len
, end
);
14531 printf (" Tag_ABI_PIC: ");
14535 printf (_("Code addressing position-dependent\n"));
14538 printf (_("Code addressing position-independent\n"));
14541 printf ("??? (%d)\n", val
);
14546 case Tag_ABI_array_object_alignment
:
14547 val
= read_uleb128 (p
, &len
, end
);
14549 printf (" Tag_ABI_array_object_alignment: ");
14553 printf (_("8-byte\n"));
14556 printf (_("4-byte\n"));
14559 printf (_("16-byte\n"));
14562 printf ("??? (%d)\n", val
);
14567 case Tag_ABI_array_object_align_expected
:
14568 val
= read_uleb128 (p
, &len
, end
);
14570 printf (" Tag_ABI_array_object_align_expected: ");
14574 printf (_("8-byte\n"));
14577 printf (_("4-byte\n"));
14580 printf (_("16-byte\n"));
14583 printf ("??? (%d)\n", val
);
14588 case Tag_ABI_compatibility
:
14590 val
= read_uleb128 (p
, &len
, end
);
14592 printf (" Tag_ABI_compatibility: ");
14593 printf (_("flag = %d, vendor = "), val
);
14596 size_t maxlen
= (end
- p
) - 1;
14598 print_symbol ((int) maxlen
, (const char *) p
);
14599 p
+= strnlen ((char *) p
, maxlen
) + 1;
14603 printf (_("<corrupt>"));
14604 p
= (unsigned char *) end
;
14610 case Tag_ABI_conformance
:
14612 printf (" Tag_ABI_conformance: \"");
14615 size_t maxlen
= (end
- p
) - 1;
14617 print_symbol ((int) maxlen
, (const char *) p
);
14618 p
+= strnlen ((char *) p
, maxlen
) + 1;
14622 printf (_("<corrupt>"));
14623 p
= (unsigned char *) end
;
14630 return display_tag_value (tag
, p
, end
);
14634 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14636 unsigned long addr
= 0;
14637 size_t bytes
= end
- p
;
14644 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14646 printf (" 0x%8.8lx ", addr
);
14648 for (j
= 0; j
< 16; j
++)
14651 printf ("%2.2x", p
[j
]);
14659 for (j
= 0; j
< lbytes
; j
++)
14662 if (k
>= ' ' && k
< 0x7f)
14678 static unsigned char *
14679 display_msp430x_attribute (unsigned char * p
,
14680 const unsigned char * const end
)
14686 tag
= read_uleb128 (p
, & len
, end
);
14691 case OFBA_MSPABI_Tag_ISA
:
14692 val
= read_uleb128 (p
, &len
, end
);
14694 printf (" Tag_ISA: ");
14697 case 0: printf (_("None\n")); break;
14698 case 1: printf (_("MSP430\n")); break;
14699 case 2: printf (_("MSP430X\n")); break;
14700 default: printf ("??? (%d)\n", val
); break;
14704 case OFBA_MSPABI_Tag_Code_Model
:
14705 val
= read_uleb128 (p
, &len
, end
);
14707 printf (" Tag_Code_Model: ");
14710 case 0: printf (_("None\n")); break;
14711 case 1: printf (_("Small\n")); break;
14712 case 2: printf (_("Large\n")); break;
14713 default: printf ("??? (%d)\n", val
); break;
14717 case OFBA_MSPABI_Tag_Data_Model
:
14718 val
= read_uleb128 (p
, &len
, end
);
14720 printf (" Tag_Data_Model: ");
14723 case 0: printf (_("None\n")); break;
14724 case 1: printf (_("Small\n")); break;
14725 case 2: printf (_("Large\n")); break;
14726 case 3: printf (_("Restricted Large\n")); break;
14727 default: printf ("??? (%d)\n", val
); break;
14732 printf (_(" <unknown tag %d>: "), tag
);
14739 size_t maxlen
= (end
- p
) - 1;
14741 print_symbol ((int) maxlen
, (const char *) p
);
14742 p
+= strnlen ((char *) p
, maxlen
) + 1;
14746 printf (_("<corrupt>"));
14747 p
= (unsigned char *) end
;
14753 val
= read_uleb128 (p
, &len
, end
);
14755 printf ("%d (0x%x)\n", val
, val
);
14765 process_attributes (FILE * file
,
14766 const char * public_name
,
14767 unsigned int proc_type
,
14768 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14769 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14771 Elf_Internal_Shdr
* sect
;
14773 bfd_boolean res
= TRUE
;
14775 /* Find the section header so that we get the size. */
14776 for (i
= 0, sect
= section_headers
;
14777 i
< elf_header
.e_shnum
;
14780 unsigned char * contents
;
14783 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14786 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14787 sect
->sh_size
, _("attributes"));
14788 if (contents
== NULL
)
14795 /* The first character is the version of the attributes.
14796 Currently only version 1, (aka 'A') is recognised here. */
14799 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14804 bfd_vma section_len
;
14806 section_len
= sect
->sh_size
- 1;
14809 while (section_len
> 0)
14812 unsigned int namelen
;
14813 bfd_boolean public_section
;
14814 bfd_boolean gnu_section
;
14816 if (section_len
<= 4)
14818 error (_("Tag section ends prematurely\n"));
14822 attr_len
= byte_get (p
, 4);
14825 if (attr_len
> section_len
)
14827 error (_("Bad attribute length (%u > %u)\n"),
14828 (unsigned) attr_len
, (unsigned) section_len
);
14829 attr_len
= section_len
;
14832 /* PR 17531: file: 001-101425-0.004 */
14833 else if (attr_len
< 5)
14835 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14840 section_len
-= attr_len
;
14843 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14844 if (namelen
== 0 || namelen
>= attr_len
)
14846 error (_("Corrupt attribute section name\n"));
14851 printf (_("Attribute Section: "));
14852 print_symbol (INT_MAX
, (const char *) p
);
14855 if (public_name
&& streq ((char *) p
, public_name
))
14856 public_section
= TRUE
;
14858 public_section
= FALSE
;
14860 if (streq ((char *) p
, "gnu"))
14861 gnu_section
= TRUE
;
14863 gnu_section
= FALSE
;
14866 attr_len
-= namelen
;
14868 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14873 unsigned char * end
;
14875 /* PR binutils/17531: Safe handling of corrupt files. */
14878 error (_("Unused bytes at end of section\n"));
14885 size
= byte_get (p
, 4);
14886 if (size
> attr_len
)
14888 error (_("Bad subsection length (%u > %u)\n"),
14889 (unsigned) size
, (unsigned) attr_len
);
14893 /* PR binutils/17531: Safe handling of corrupt files. */
14896 error (_("Bad subsection length (%u < 6)\n"),
14904 end
= p
+ size
- 1;
14905 assert (end
<= contents
+ sect
->sh_size
);
14911 printf (_("File Attributes\n"));
14914 printf (_("Section Attributes:"));
14917 printf (_("Symbol Attributes:"));
14918 /* Fall through. */
14924 val
= read_uleb128 (p
, &j
, end
);
14928 printf (" %d", val
);
14933 printf (_("Unknown tag: %d\n"), tag
);
14934 public_section
= FALSE
;
14938 if (public_section
&& display_pub_attribute
!= NULL
)
14941 p
= display_pub_attribute (p
, end
);
14944 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14947 p
= display_gnu_attribute (p
,
14948 display_proc_gnu_attribute
,
14954 printf (_(" Unknown attribute:\n"));
14955 display_raw_attribute (p
, end
);
14970 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14971 Print the Address, Access and Initial fields of an entry at VMA ADDR
14972 and return the VMA of the next entry, or -1 if there was a problem.
14973 Does not read from DATA_END or beyond. */
14976 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14977 unsigned char * data_end
)
14980 print_vma (addr
, LONG_HEX
);
14982 if (addr
< pltgot
+ 0xfff0)
14983 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14985 printf ("%10s", "");
14988 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14992 unsigned char * from
= data
+ addr
- pltgot
;
14994 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14996 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14997 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14998 return (bfd_vma
) -1;
15002 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15003 print_vma (entry
, LONG_HEX
);
15006 return addr
+ (is_32bit_elf
? 4 : 8);
15009 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15010 PLTGOT. Print the Address and Initial fields of an entry at VMA
15011 ADDR and return the VMA of the next entry. */
15014 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15017 print_vma (addr
, LONG_HEX
);
15020 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15025 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15026 print_vma (entry
, LONG_HEX
);
15028 return addr
+ (is_32bit_elf
? 4 : 8);
15032 print_mips_ases (unsigned int mask
)
15034 if (mask
& AFL_ASE_DSP
)
15035 fputs ("\n\tDSP ASE", stdout
);
15036 if (mask
& AFL_ASE_DSPR2
)
15037 fputs ("\n\tDSP R2 ASE", stdout
);
15038 if (mask
& AFL_ASE_DSPR3
)
15039 fputs ("\n\tDSP R3 ASE", stdout
);
15040 if (mask
& AFL_ASE_EVA
)
15041 fputs ("\n\tEnhanced VA Scheme", stdout
);
15042 if (mask
& AFL_ASE_MCU
)
15043 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15044 if (mask
& AFL_ASE_MDMX
)
15045 fputs ("\n\tMDMX ASE", stdout
);
15046 if (mask
& AFL_ASE_MIPS3D
)
15047 fputs ("\n\tMIPS-3D ASE", stdout
);
15048 if (mask
& AFL_ASE_MT
)
15049 fputs ("\n\tMT ASE", stdout
);
15050 if (mask
& AFL_ASE_SMARTMIPS
)
15051 fputs ("\n\tSmartMIPS ASE", stdout
);
15052 if (mask
& AFL_ASE_VIRT
)
15053 fputs ("\n\tVZ ASE", stdout
);
15054 if (mask
& AFL_ASE_MSA
)
15055 fputs ("\n\tMSA ASE", stdout
);
15056 if (mask
& AFL_ASE_MIPS16
)
15057 fputs ("\n\tMIPS16 ASE", stdout
);
15058 if (mask
& AFL_ASE_MICROMIPS
)
15059 fputs ("\n\tMICROMIPS ASE", stdout
);
15060 if (mask
& AFL_ASE_XPA
)
15061 fputs ("\n\tXPA ASE", stdout
);
15062 if (mask
& AFL_ASE_MIPS16E2
)
15063 fputs ("\n\tMIPS16e2 ASE", stdout
);
15065 fprintf (stdout
, "\n\t%s", _("None"));
15066 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15067 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15071 print_mips_isa_ext (unsigned int isa_ext
)
15076 fputs (_("None"), stdout
);
15079 fputs ("RMI XLR", stdout
);
15081 case AFL_EXT_OCTEON3
:
15082 fputs ("Cavium Networks Octeon3", stdout
);
15084 case AFL_EXT_OCTEON2
:
15085 fputs ("Cavium Networks Octeon2", stdout
);
15087 case AFL_EXT_OCTEONP
:
15088 fputs ("Cavium Networks OcteonP", stdout
);
15090 case AFL_EXT_LOONGSON_3A
:
15091 fputs ("Loongson 3A", stdout
);
15093 case AFL_EXT_OCTEON
:
15094 fputs ("Cavium Networks Octeon", stdout
);
15097 fputs ("Toshiba R5900", stdout
);
15100 fputs ("MIPS R4650", stdout
);
15103 fputs ("LSI R4010", stdout
);
15106 fputs ("NEC VR4100", stdout
);
15109 fputs ("Toshiba R3900", stdout
);
15111 case AFL_EXT_10000
:
15112 fputs ("MIPS R10000", stdout
);
15115 fputs ("Broadcom SB-1", stdout
);
15118 fputs ("NEC VR4111/VR4181", stdout
);
15121 fputs ("NEC VR4120", stdout
);
15124 fputs ("NEC VR5400", stdout
);
15127 fputs ("NEC VR5500", stdout
);
15129 case AFL_EXT_LOONGSON_2E
:
15130 fputs ("ST Microelectronics Loongson 2E", stdout
);
15132 case AFL_EXT_LOONGSON_2F
:
15133 fputs ("ST Microelectronics Loongson 2F", stdout
);
15135 case AFL_EXT_INTERAPTIV_MR2
:
15136 fputs ("Imagination interAptiv MR2", stdout
);
15139 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15144 get_mips_reg_size (int reg_size
)
15146 return (reg_size
== AFL_REG_NONE
) ? 0
15147 : (reg_size
== AFL_REG_32
) ? 32
15148 : (reg_size
== AFL_REG_64
) ? 64
15149 : (reg_size
== AFL_REG_128
) ? 128
15154 process_mips_specific (FILE * file
)
15156 Elf_Internal_Dyn
* entry
;
15157 Elf_Internal_Shdr
*sect
= NULL
;
15158 size_t liblist_offset
= 0;
15159 size_t liblistno
= 0;
15160 size_t conflictsno
= 0;
15161 size_t options_offset
= 0;
15162 size_t conflicts_offset
= 0;
15163 size_t pltrelsz
= 0;
15165 bfd_vma pltgot
= 0;
15166 bfd_vma mips_pltgot
= 0;
15167 bfd_vma jmprel
= 0;
15168 bfd_vma local_gotno
= 0;
15169 bfd_vma gotsym
= 0;
15170 bfd_vma symtabno
= 0;
15171 bfd_boolean res
= TRUE
;
15173 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15174 display_mips_gnu_attribute
))
15177 sect
= find_section (".MIPS.abiflags");
15181 Elf_External_ABIFlags_v0
*abiflags_ext
;
15182 Elf_Internal_ABIFlags_v0 abiflags_in
;
15184 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15186 error (_("Corrupt MIPS ABI Flags section.\n"));
15191 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15192 sect
->sh_size
, _("MIPS ABI Flags section"));
15195 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15196 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15197 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15198 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15199 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15200 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15201 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15202 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15203 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15204 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15205 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15207 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15208 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15209 if (abiflags_in
.isa_rev
> 1)
15210 printf ("r%d", abiflags_in
.isa_rev
);
15211 printf ("\nGPR size: %d",
15212 get_mips_reg_size (abiflags_in
.gpr_size
));
15213 printf ("\nCPR1 size: %d",
15214 get_mips_reg_size (abiflags_in
.cpr1_size
));
15215 printf ("\nCPR2 size: %d",
15216 get_mips_reg_size (abiflags_in
.cpr2_size
));
15217 fputs ("\nFP ABI: ", stdout
);
15218 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15219 fputs ("ISA Extension: ", stdout
);
15220 print_mips_isa_ext (abiflags_in
.isa_ext
);
15221 fputs ("\nASEs:", stdout
);
15222 print_mips_ases (abiflags_in
.ases
);
15223 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15224 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15225 fputc ('\n', stdout
);
15226 free (abiflags_ext
);
15231 /* We have a lot of special sections. Thanks SGI! */
15232 if (dynamic_section
== NULL
)
15234 /* No dynamic information available. See if there is static GOT. */
15235 sect
= find_section (".got");
15238 unsigned char *data_end
;
15239 unsigned char *data
;
15243 pltgot
= sect
->sh_addr
;
15246 addr_size
= (is_32bit_elf
? 4 : 8);
15247 end
= pltgot
+ sect
->sh_size
;
15249 data
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
,
15251 _("Global Offset Table data"));
15252 /* PR 12855: Null data is handled gracefully throughout. */
15253 data_end
= data
+ (end
- pltgot
);
15255 printf (_("\nStatic GOT:\n"));
15256 printf (_(" Canonical gp value: "));
15257 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15260 /* In a dynamic binary GOT[0] is reserved for the dynamic
15261 loader to store the lazy resolver pointer, however in
15262 a static binary it may well have been omitted and GOT
15263 reduced to a table of addresses.
15264 PR 21344: Check for the entry being fully available
15265 before fetching it. */
15267 && data
+ ent
- pltgot
+ addr_size
<= data_end
15268 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15270 printf (_(" Reserved entries:\n"));
15271 printf (_(" %*s %10s %*s\n"),
15272 addr_size
* 2, _("Address"), _("Access"),
15273 addr_size
* 2, _("Value"));
15274 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15276 if (ent
== (bfd_vma
) -1)
15277 goto sgot_print_fail
;
15279 /* Check for the MSB of GOT[1] being set, identifying a
15280 GNU object. This entry will be used by some runtime
15281 loaders, to store the module pointer. Otherwise this
15282 is an ordinary local entry.
15283 PR 21344: Check for the entry being fully available
15284 before fetching it. */
15286 && data
+ ent
- pltgot
+ addr_size
<= data_end
15287 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15288 >> (addr_size
* 8 - 1)) != 0)
15290 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15292 if (ent
== (bfd_vma
) -1)
15293 goto sgot_print_fail
;
15300 printf (_(" Local entries:\n"));
15301 printf (" %*s %10s %*s\n",
15302 addr_size
* 2, _("Address"), _("Access"),
15303 addr_size
* 2, _("Value"));
15306 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15308 if (ent
== (bfd_vma
) -1)
15309 goto sgot_print_fail
;
15321 for (entry
= dynamic_section
;
15322 /* PR 17531 file: 012-50589-0.004. */
15323 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15325 switch (entry
->d_tag
)
15327 case DT_MIPS_LIBLIST
:
15329 = offset_from_vma (file
, entry
->d_un
.d_val
,
15330 liblistno
* sizeof (Elf32_External_Lib
));
15332 case DT_MIPS_LIBLISTNO
:
15333 liblistno
= entry
->d_un
.d_val
;
15335 case DT_MIPS_OPTIONS
:
15336 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15338 case DT_MIPS_CONFLICT
:
15340 = offset_from_vma (file
, entry
->d_un
.d_val
,
15341 conflictsno
* sizeof (Elf32_External_Conflict
));
15343 case DT_MIPS_CONFLICTNO
:
15344 conflictsno
= entry
->d_un
.d_val
;
15347 pltgot
= entry
->d_un
.d_ptr
;
15349 case DT_MIPS_LOCAL_GOTNO
:
15350 local_gotno
= entry
->d_un
.d_val
;
15352 case DT_MIPS_GOTSYM
:
15353 gotsym
= entry
->d_un
.d_val
;
15355 case DT_MIPS_SYMTABNO
:
15356 symtabno
= entry
->d_un
.d_val
;
15358 case DT_MIPS_PLTGOT
:
15359 mips_pltgot
= entry
->d_un
.d_ptr
;
15362 pltrel
= entry
->d_un
.d_val
;
15365 pltrelsz
= entry
->d_un
.d_val
;
15368 jmprel
= entry
->d_un
.d_ptr
;
15374 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15376 Elf32_External_Lib
* elib
;
15379 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15381 sizeof (Elf32_External_Lib
),
15382 _("liblist section data"));
15385 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15386 (unsigned long) liblistno
);
15387 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15390 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15397 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15398 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15399 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15400 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15401 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15403 tmp
= gmtime (&atime
);
15404 snprintf (timebuf
, sizeof (timebuf
),
15405 "%04u-%02u-%02uT%02u:%02u:%02u",
15406 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15407 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15409 printf ("%3lu: ", (unsigned long) cnt
);
15410 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15411 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15413 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15414 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15415 liblist
.l_version
);
15417 if (liblist
.l_flags
== 0)
15421 static const struct
15428 { " EXACT_MATCH", LL_EXACT_MATCH
},
15429 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15430 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15431 { " EXPORTS", LL_EXPORTS
},
15432 { " DELAY_LOAD", LL_DELAY_LOAD
},
15433 { " DELTA", LL_DELTA
}
15435 int flags
= liblist
.l_flags
;
15438 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15439 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15441 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15442 flags
^= l_flags_vals
[fcnt
].bit
;
15445 printf (" %#x", (unsigned int) flags
);
15457 if (options_offset
!= 0)
15459 Elf_External_Options
* eopt
;
15460 Elf_Internal_Options
* iopt
;
15461 Elf_Internal_Options
* option
;
15464 sect
= section_headers
;
15466 /* Find the section header so that we get the size. */
15467 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15468 /* PR 17533 file: 012-277276-0.004. */
15471 error (_("No MIPS_OPTIONS header found\n"));
15475 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15476 sect
->sh_size
, _("options"));
15479 iopt
= (Elf_Internal_Options
*)
15480 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15483 error (_("Out of memory allocating space for MIPS options\n"));
15490 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15492 Elf_External_Options
* eoption
;
15494 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15496 option
->kind
= BYTE_GET (eoption
->kind
);
15497 option
->size
= BYTE_GET (eoption
->size
);
15498 option
->section
= BYTE_GET (eoption
->section
);
15499 option
->info
= BYTE_GET (eoption
->info
);
15501 /* PR 17531: file: ffa0fa3b. */
15502 if (option
->size
< sizeof (* eopt
)
15503 || offset
+ option
->size
> sect
->sh_size
)
15505 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15508 offset
+= option
->size
;
15514 printf (_("\nSection '%s' contains %d entries:\n"),
15515 printable_section_name (sect
), cnt
);
15524 switch (option
->kind
)
15527 /* This shouldn't happen. */
15528 printf (" NULL %d %lx", option
->section
, option
->info
);
15531 printf (" REGINFO ");
15532 if (elf_header
.e_machine
== EM_MIPS
)
15535 Elf32_External_RegInfo
* ereg
;
15536 Elf32_RegInfo reginfo
;
15538 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15539 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15540 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15541 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15542 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15543 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15544 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15546 printf ("GPR %08lx GP 0x%lx\n",
15547 reginfo
.ri_gprmask
,
15548 (unsigned long) reginfo
.ri_gp_value
);
15549 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15550 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15551 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15556 Elf64_External_RegInfo
* ereg
;
15557 Elf64_Internal_RegInfo reginfo
;
15559 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15560 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15561 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15562 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15563 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15564 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15565 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15567 printf ("GPR %08lx GP 0x",
15568 reginfo
.ri_gprmask
);
15569 printf_vma (reginfo
.ri_gp_value
);
15572 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15573 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15574 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15578 case ODK_EXCEPTIONS
:
15579 fputs (" EXCEPTIONS fpe_min(", stdout
);
15580 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15581 fputs (") fpe_max(", stdout
);
15582 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15583 fputs (")", stdout
);
15585 if (option
->info
& OEX_PAGE0
)
15586 fputs (" PAGE0", stdout
);
15587 if (option
->info
& OEX_SMM
)
15588 fputs (" SMM", stdout
);
15589 if (option
->info
& OEX_FPDBUG
)
15590 fputs (" FPDBUG", stdout
);
15591 if (option
->info
& OEX_DISMISS
)
15592 fputs (" DISMISS", stdout
);
15595 fputs (" PAD ", stdout
);
15596 if (option
->info
& OPAD_PREFIX
)
15597 fputs (" PREFIX", stdout
);
15598 if (option
->info
& OPAD_POSTFIX
)
15599 fputs (" POSTFIX", stdout
);
15600 if (option
->info
& OPAD_SYMBOL
)
15601 fputs (" SYMBOL", stdout
);
15604 fputs (" HWPATCH ", stdout
);
15605 if (option
->info
& OHW_R4KEOP
)
15606 fputs (" R4KEOP", stdout
);
15607 if (option
->info
& OHW_R8KPFETCH
)
15608 fputs (" R8KPFETCH", stdout
);
15609 if (option
->info
& OHW_R5KEOP
)
15610 fputs (" R5KEOP", stdout
);
15611 if (option
->info
& OHW_R5KCVTL
)
15612 fputs (" R5KCVTL", stdout
);
15615 fputs (" FILL ", stdout
);
15616 /* XXX Print content of info word? */
15619 fputs (" TAGS ", stdout
);
15620 /* XXX Print content of info word? */
15623 fputs (" HWAND ", stdout
);
15624 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15625 fputs (" R4KEOP_CHECKED", stdout
);
15626 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15627 fputs (" R4KEOP_CLEAN", stdout
);
15630 fputs (" HWOR ", stdout
);
15631 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15632 fputs (" R4KEOP_CHECKED", stdout
);
15633 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15634 fputs (" R4KEOP_CLEAN", stdout
);
15637 printf (" GP_GROUP %#06lx self-contained %#06lx",
15638 option
->info
& OGP_GROUP
,
15639 (option
->info
& OGP_SELF
) >> 16);
15642 printf (" IDENT %#06lx self-contained %#06lx",
15643 option
->info
& OGP_GROUP
,
15644 (option
->info
& OGP_SELF
) >> 16);
15647 /* This shouldn't happen. */
15648 printf (" %3d ??? %d %lx",
15649 option
->kind
, option
->section
, option
->info
);
15653 len
= sizeof (* eopt
);
15654 while (len
< option
->size
)
15656 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15658 if (ISPRINT (datum
))
15659 printf ("%c", datum
);
15661 printf ("\\%03o", datum
);
15664 fputs ("\n", stdout
);
15666 offset
+= option
->size
;
15676 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15678 Elf32_Conflict
* iconf
;
15681 if (dynamic_symbols
== NULL
)
15683 error (_("conflict list found without a dynamic symbol table\n"));
15687 /* PR 21345 - print a slightly more helpful error message
15688 if we are sure that the cmalloc will fail. */
15689 if (conflictsno
* sizeof (* iconf
) > current_file_size
)
15691 error (_("Overlarge number of conflicts detected: %lx\n"),
15692 (long) conflictsno
);
15696 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15699 error (_("Out of memory allocating space for dynamic conflicts\n"));
15705 Elf32_External_Conflict
* econf32
;
15707 econf32
= (Elf32_External_Conflict
*)
15708 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15709 sizeof (* econf32
), _("conflict"));
15713 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15714 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15720 Elf64_External_Conflict
* econf64
;
15722 econf64
= (Elf64_External_Conflict
*)
15723 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15724 sizeof (* econf64
), _("conflict"));
15728 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15729 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15734 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15735 (unsigned long) conflictsno
);
15736 puts (_(" Num: Index Value Name"));
15738 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15740 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15742 if (iconf
[cnt
] >= num_dynamic_syms
)
15743 printf (_("<corrupt symbol index>"));
15746 Elf_Internal_Sym
* psym
;
15748 psym
= & dynamic_symbols
[iconf
[cnt
]];
15749 print_vma (psym
->st_value
, FULL_HEX
);
15751 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15752 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15754 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15762 if (pltgot
!= 0 && local_gotno
!= 0)
15764 bfd_vma ent
, local_end
, global_end
;
15766 unsigned char * data
;
15767 unsigned char * data_end
;
15771 addr_size
= (is_32bit_elf
? 4 : 8);
15772 local_end
= pltgot
+ local_gotno
* addr_size
;
15774 /* PR binutils/17533 file: 012-111227-0.004 */
15775 if (symtabno
< gotsym
)
15777 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15778 (unsigned long) gotsym
, (unsigned long) symtabno
);
15782 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15783 /* PR 17531: file: 54c91a34. */
15784 if (global_end
< local_end
)
15786 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15790 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15791 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15792 global_end
- pltgot
, 1,
15793 _("Global Offset Table data"));
15794 /* PR 12855: Null data is handled gracefully throughout. */
15795 data_end
= data
+ (global_end
- pltgot
);
15797 printf (_("\nPrimary GOT:\n"));
15798 printf (_(" Canonical gp value: "));
15799 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15802 printf (_(" Reserved entries:\n"));
15803 printf (_(" %*s %10s %*s Purpose\n"),
15804 addr_size
* 2, _("Address"), _("Access"),
15805 addr_size
* 2, _("Initial"));
15806 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15807 printf (_(" Lazy resolver\n"));
15808 if (ent
== (bfd_vma
) -1)
15809 goto got_print_fail
;
15811 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15812 This entry will be used by some runtime loaders, to store the
15813 module pointer. Otherwise this is an ordinary local entry.
15814 PR 21344: Check for the entry being fully available before
15817 && data
+ ent
- pltgot
+ addr_size
<= data_end
15818 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15819 >> (addr_size
* 8 - 1)) != 0)
15821 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15822 printf (_(" Module pointer (GNU extension)\n"));
15823 if (ent
== (bfd_vma
) -1)
15824 goto got_print_fail
;
15828 if (ent
< local_end
)
15830 printf (_(" Local entries:\n"));
15831 printf (" %*s %10s %*s\n",
15832 addr_size
* 2, _("Address"), _("Access"),
15833 addr_size
* 2, _("Initial"));
15834 while (ent
< local_end
)
15836 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15838 if (ent
== (bfd_vma
) -1)
15839 goto got_print_fail
;
15844 if (gotsym
< symtabno
)
15848 printf (_(" Global entries:\n"));
15849 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15850 addr_size
* 2, _("Address"),
15852 addr_size
* 2, _("Initial"),
15853 addr_size
* 2, _("Sym.Val."),
15855 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15856 _("Ndx"), _("Name"));
15858 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15860 for (i
= gotsym
; i
< symtabno
; i
++)
15862 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15865 if (dynamic_symbols
== NULL
)
15866 printf (_("<no dynamic symbols>"));
15867 else if (i
< num_dynamic_syms
)
15869 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15871 print_vma (psym
->st_value
, LONG_HEX
);
15872 printf (" %-7s %3s ",
15873 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15874 get_symbol_index_type (psym
->st_shndx
));
15876 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15877 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15879 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15882 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15883 (unsigned long) i
);
15886 if (ent
== (bfd_vma
) -1)
15897 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15900 size_t offset
, rel_offset
;
15901 unsigned long count
, i
;
15902 unsigned char * data
;
15903 int addr_size
, sym_width
;
15904 Elf_Internal_Rela
* rels
;
15906 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15907 if (pltrel
== DT_RELA
)
15909 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15914 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15919 addr_size
= (is_32bit_elf
? 4 : 8);
15920 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15922 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15923 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15924 1, _("Procedure Linkage Table data"));
15928 printf ("\nPLT GOT:\n\n");
15929 printf (_(" Reserved entries:\n"));
15930 printf (_(" %*s %*s Purpose\n"),
15931 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15932 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15933 printf (_(" PLT lazy resolver\n"));
15934 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15935 printf (_(" Module pointer\n"));
15938 printf (_(" Entries:\n"));
15939 printf (" %*s %*s %*s %-7s %3s %s\n",
15940 addr_size
* 2, _("Address"),
15941 addr_size
* 2, _("Initial"),
15942 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15943 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15944 for (i
= 0; i
< count
; i
++)
15946 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15948 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15951 if (idx
>= num_dynamic_syms
)
15952 printf (_("<corrupt symbol index: %lu>"), idx
);
15955 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15957 print_vma (psym
->st_value
, LONG_HEX
);
15958 printf (" %-7s %3s ",
15959 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15960 get_symbol_index_type (psym
->st_shndx
));
15961 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15962 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15964 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15979 process_nds32_specific (FILE * file
)
15981 Elf_Internal_Shdr
*sect
= NULL
;
15983 sect
= find_section (".nds32_e_flags");
15986 unsigned int *flag
;
15988 printf ("\nNDS32 elf flags section:\n");
15989 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15990 sect
->sh_size
, _("NDS32 elf flags section"));
15995 switch ((*flag
) & 0x3)
15998 printf ("(VEC_SIZE):\tNo entry.\n");
16001 printf ("(VEC_SIZE):\t4 bytes\n");
16004 printf ("(VEC_SIZE):\t16 bytes\n");
16007 printf ("(VEC_SIZE):\treserved\n");
16016 process_gnu_liblist (FILE * file
)
16018 Elf_Internal_Shdr
* section
;
16019 Elf_Internal_Shdr
* string_sec
;
16020 Elf32_External_Lib
* elib
;
16022 size_t strtab_size
;
16025 bfd_boolean res
= TRUE
;
16030 for (i
= 0, section
= section_headers
;
16031 i
< elf_header
.e_shnum
;
16034 switch (section
->sh_type
)
16036 case SHT_GNU_LIBLIST
:
16037 if (section
->sh_link
>= elf_header
.e_shnum
)
16040 elib
= (Elf32_External_Lib
*)
16041 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
16042 _("liblist section data"));
16050 string_sec
= section_headers
+ section
->sh_link
;
16051 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
16052 string_sec
->sh_size
,
16053 _("liblist string table"));
16055 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16062 strtab_size
= string_sec
->sh_size
;
16064 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16065 printable_section_name (section
),
16066 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
16068 puts (_(" Library Time Stamp Checksum Version Flags"));
16070 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16078 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16079 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16080 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16081 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16082 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16084 tmp
= gmtime (&atime
);
16085 snprintf (timebuf
, sizeof (timebuf
),
16086 "%04u-%02u-%02uT%02u:%02u:%02u",
16087 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16088 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16090 printf ("%3lu: ", (unsigned long) cnt
);
16092 printf ("%-20s", liblist
.l_name
< strtab_size
16093 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16095 printf ("%-20.20s", liblist
.l_name
< strtab_size
16096 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16097 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16098 liblist
.l_version
, liblist
.l_flags
);
16109 static const char *
16110 get_note_type (unsigned e_type
)
16112 static char buff
[64];
16114 if (elf_header
.e_type
== ET_CORE
)
16118 return _("NT_AUXV (auxiliary vector)");
16120 return _("NT_PRSTATUS (prstatus structure)");
16122 return _("NT_FPREGSET (floating point registers)");
16124 return _("NT_PRPSINFO (prpsinfo structure)");
16125 case NT_TASKSTRUCT
:
16126 return _("NT_TASKSTRUCT (task structure)");
16128 return _("NT_PRXFPREG (user_xfpregs structure)");
16130 return _("NT_PPC_VMX (ppc Altivec registers)");
16132 return _("NT_PPC_VSX (ppc VSX registers)");
16134 return _("NT_386_TLS (x86 TLS information)");
16135 case NT_386_IOPERM
:
16136 return _("NT_386_IOPERM (x86 I/O permissions)");
16137 case NT_X86_XSTATE
:
16138 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16139 case NT_S390_HIGH_GPRS
:
16140 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16141 case NT_S390_TIMER
:
16142 return _("NT_S390_TIMER (s390 timer register)");
16143 case NT_S390_TODCMP
:
16144 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16145 case NT_S390_TODPREG
:
16146 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16148 return _("NT_S390_CTRS (s390 control registers)");
16149 case NT_S390_PREFIX
:
16150 return _("NT_S390_PREFIX (s390 prefix register)");
16151 case NT_S390_LAST_BREAK
:
16152 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16153 case NT_S390_SYSTEM_CALL
:
16154 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16156 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16157 case NT_S390_VXRS_LOW
:
16158 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16159 case NT_S390_VXRS_HIGH
:
16160 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16162 return _("NT_ARM_VFP (arm VFP registers)");
16164 return _("NT_ARM_TLS (AArch TLS registers)");
16165 case NT_ARM_HW_BREAK
:
16166 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16167 case NT_ARM_HW_WATCH
:
16168 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16170 return _("NT_PSTATUS (pstatus structure)");
16172 return _("NT_FPREGS (floating point registers)");
16174 return _("NT_PSINFO (psinfo structure)");
16176 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16178 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16179 case NT_WIN32PSTATUS
:
16180 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16182 return _("NT_SIGINFO (siginfo_t data)");
16184 return _("NT_FILE (mapped files)");
16192 return _("NT_VERSION (version)");
16194 return _("NT_ARCH (architecture)");
16195 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16196 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16197 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16198 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16203 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16208 print_core_note (Elf_Internal_Note
*pnote
)
16210 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16211 bfd_vma count
, page_size
;
16212 unsigned char *descdata
, *filenames
, *descend
;
16214 if (pnote
->type
!= NT_FILE
)
16220 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16221 /* Still "successful". */
16226 if (pnote
->descsz
< 2 * addr_size
)
16228 error (_(" Malformed note - too short for header\n"));
16232 descdata
= (unsigned char *) pnote
->descdata
;
16233 descend
= descdata
+ pnote
->descsz
;
16235 if (descdata
[pnote
->descsz
- 1] != '\0')
16237 error (_(" Malformed note - does not end with \\0\n"));
16241 count
= byte_get (descdata
, addr_size
);
16242 descdata
+= addr_size
;
16244 page_size
= byte_get (descdata
, addr_size
);
16245 descdata
+= addr_size
;
16247 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16249 error (_(" Malformed note - too short for supplied file count\n"));
16253 printf (_(" Page size: "));
16254 print_vma (page_size
, DEC
);
16257 printf (_(" %*s%*s%*s\n"),
16258 (int) (2 + 2 * addr_size
), _("Start"),
16259 (int) (4 + 2 * addr_size
), _("End"),
16260 (int) (4 + 2 * addr_size
), _("Page Offset"));
16261 filenames
= descdata
+ count
* 3 * addr_size
;
16262 while (count
-- > 0)
16264 bfd_vma start
, end
, file_ofs
;
16266 if (filenames
== descend
)
16268 error (_(" Malformed note - filenames end too early\n"));
16272 start
= byte_get (descdata
, addr_size
);
16273 descdata
+= addr_size
;
16274 end
= byte_get (descdata
, addr_size
);
16275 descdata
+= addr_size
;
16276 file_ofs
= byte_get (descdata
, addr_size
);
16277 descdata
+= addr_size
;
16280 print_vma (start
, FULL_HEX
);
16282 print_vma (end
, FULL_HEX
);
16284 print_vma (file_ofs
, FULL_HEX
);
16285 printf ("\n %s\n", filenames
);
16287 filenames
+= 1 + strlen ((char *) filenames
);
16293 static const char *
16294 get_gnu_elf_note_type (unsigned e_type
)
16296 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16299 case NT_GNU_ABI_TAG
:
16300 return _("NT_GNU_ABI_TAG (ABI version tag)");
16302 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16303 case NT_GNU_BUILD_ID
:
16304 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16305 case NT_GNU_GOLD_VERSION
:
16306 return _("NT_GNU_GOLD_VERSION (gold version)");
16307 case NT_GNU_PROPERTY_TYPE_0
:
16308 return _("NT_GNU_PROPERTY_TYPE_0");
16309 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16310 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16311 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16312 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16315 static char buff
[64];
16317 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16324 decode_x86_isa (unsigned int bitmask
)
16328 unsigned int bit
= bitmask
& (- bitmask
);
16333 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16334 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16335 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16336 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16337 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16338 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16339 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16340 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16341 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16342 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16343 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16344 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16345 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16346 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16347 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16348 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16349 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16350 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16351 default: printf (_("<unknown: %x>"), bit
); break;
16359 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16363 unsigned int bit
= bitmask
& (- bitmask
);
16368 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16371 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16375 /* This should never happen. */
16379 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16382 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16386 /* This should never happen. */
16391 printf (_("<unknown: %x>"), bit
);
16400 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16402 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16403 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16404 unsigned int size
= is_32bit_elf
? 4 : 8;
16406 printf (_(" Properties: "));
16408 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16410 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16417 unsigned int type
= byte_get (ptr
, 4);
16418 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16422 if ((ptr
+ datasz
) > ptr_end
)
16424 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16429 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16431 if (elf_header
.e_machine
== EM_X86_64
16432 || elf_header
.e_machine
== EM_IAMCU
16433 || elf_header
.e_machine
== EM_386
)
16437 case GNU_PROPERTY_X86_ISA_1_USED
:
16438 printf ("x86 ISA used: ");
16440 printf (_("<corrupt length: %#x> "), datasz
);
16442 decode_x86_isa (byte_get (ptr
, 4));
16445 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16446 printf ("x86 ISA needed: ");
16448 printf (_("<corrupt length: %#x> "), datasz
);
16450 decode_x86_isa (byte_get (ptr
, 4));
16453 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16454 printf ("x86 feature: ");
16456 printf (_("<corrupt length: %#x> "), datasz
);
16458 decode_x86_feature (type
, byte_get (ptr
, 4));
16470 case GNU_PROPERTY_STACK_SIZE
:
16471 printf (_("stack size: "));
16472 if (datasz
!= size
)
16473 printf (_("<corrupt length: %#x> "), datasz
);
16475 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16478 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16479 printf ("no copy on protected ");
16481 printf (_("<corrupt length: %#x> "), datasz
);
16489 if (type
< GNU_PROPERTY_LOPROC
)
16490 printf (_("<unknown type %#x data: "), type
);
16491 else if (type
< GNU_PROPERTY_LOUSER
)
16492 printf (_("<procesor-specific type %#x data: "), type
);
16494 printf (_("<application-specific type %#x data: "), type
);
16495 for (j
= 0; j
< datasz
; ++j
)
16496 printf ("%02x ", ptr
[j
] & 0xff);
16500 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16501 if (ptr
== ptr_end
)
16511 if (ptr
> (ptr_end
- 8))
16513 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16522 print_gnu_note (Elf_Internal_Note
*pnote
)
16524 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16525 switch (pnote
->type
)
16527 case NT_GNU_BUILD_ID
:
16531 printf (_(" Build ID: "));
16532 for (i
= 0; i
< pnote
->descsz
; ++i
)
16533 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16538 case NT_GNU_ABI_TAG
:
16540 unsigned long os
, major
, minor
, subminor
;
16541 const char *osname
;
16543 /* PR 17531: file: 030-599401-0.004. */
16544 if (pnote
->descsz
< 16)
16546 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16550 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16551 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16552 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16553 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16557 case GNU_ABI_TAG_LINUX
:
16560 case GNU_ABI_TAG_HURD
:
16563 case GNU_ABI_TAG_SOLARIS
:
16564 osname
= "Solaris";
16566 case GNU_ABI_TAG_FREEBSD
:
16567 osname
= "FreeBSD";
16569 case GNU_ABI_TAG_NETBSD
:
16572 case GNU_ABI_TAG_SYLLABLE
:
16573 osname
= "Syllable";
16575 case GNU_ABI_TAG_NACL
:
16579 osname
= "Unknown";
16583 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16584 major
, minor
, subminor
);
16588 case NT_GNU_GOLD_VERSION
:
16592 printf (_(" Version: "));
16593 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16594 printf ("%c", pnote
->descdata
[i
]);
16601 unsigned long num_entries
, mask
;
16603 /* Hardware capabilities information. Word 0 is the number of entries.
16604 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16605 is a series of entries, where each entry is a single byte followed
16606 by a nul terminated string. The byte gives the bit number to test
16607 if enabled in the bitmask. */
16608 printf (_(" Hardware Capabilities: "));
16609 if (pnote
->descsz
< 8)
16611 error (_("<corrupt GNU_HWCAP>\n"));
16614 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16615 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16616 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16617 /* FIXME: Add code to display the entries... */
16621 case NT_GNU_PROPERTY_TYPE_0
:
16622 print_gnu_property_note (pnote
);
16626 /* Handle unrecognised types. An error message should have already been
16627 created by get_gnu_elf_note_type(), so all that we need to do is to
16628 display the data. */
16632 printf (_(" Description data: "));
16633 for (i
= 0; i
< pnote
->descsz
; ++i
)
16634 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16643 static const char *
16644 get_v850_elf_note_type (enum v850_notes n_type
)
16646 static char buff
[64];
16650 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16651 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16652 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16653 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16654 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16655 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16657 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16663 print_v850_note (Elf_Internal_Note
* pnote
)
16667 if (pnote
->descsz
!= 4)
16670 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16674 printf (_("not set\n"));
16678 switch (pnote
->type
)
16680 case V850_NOTE_ALIGNMENT
:
16683 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16684 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16688 case V850_NOTE_DATA_SIZE
:
16691 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16692 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16696 case V850_NOTE_FPU_INFO
:
16699 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16700 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16704 case V850_NOTE_MMU_INFO
:
16705 case V850_NOTE_CACHE_INFO
:
16706 case V850_NOTE_SIMD_INFO
:
16707 if (val
== EF_RH850_SIMD
)
16709 printf (_("yes\n"));
16715 /* An 'unknown note type' message will already have been displayed. */
16719 printf (_("unknown value: %x\n"), val
);
16724 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16726 unsigned int version
;
16728 switch (pnote
->type
)
16730 case NT_NETBSD_IDENT
:
16731 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16732 if ((version
/ 10000) % 100)
16733 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16734 version
, version
/ 100000000, (version
/ 1000000) % 100,
16735 (version
/ 10000) % 100 > 26 ? "Z" : "",
16736 'A' + (version
/ 10000) % 26);
16738 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16739 version
, version
/ 100000000, (version
/ 1000000) % 100,
16740 (version
/ 100) % 100);
16743 case NT_NETBSD_MARCH
:
16744 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16749 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16755 static const char *
16756 get_freebsd_elfcore_note_type (unsigned e_type
)
16760 case NT_FREEBSD_THRMISC
:
16761 return _("NT_THRMISC (thrmisc structure)");
16762 case NT_FREEBSD_PROCSTAT_PROC
:
16763 return _("NT_PROCSTAT_PROC (proc data)");
16764 case NT_FREEBSD_PROCSTAT_FILES
:
16765 return _("NT_PROCSTAT_FILES (files data)");
16766 case NT_FREEBSD_PROCSTAT_VMMAP
:
16767 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16768 case NT_FREEBSD_PROCSTAT_GROUPS
:
16769 return _("NT_PROCSTAT_GROUPS (groups data)");
16770 case NT_FREEBSD_PROCSTAT_UMASK
:
16771 return _("NT_PROCSTAT_UMASK (umask data)");
16772 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16773 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16774 case NT_FREEBSD_PROCSTAT_OSREL
:
16775 return _("NT_PROCSTAT_OSREL (osreldate data)");
16776 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16777 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16778 case NT_FREEBSD_PROCSTAT_AUXV
:
16779 return _("NT_PROCSTAT_AUXV (auxv data)");
16781 return get_note_type (e_type
);
16784 static const char *
16785 get_netbsd_elfcore_note_type (unsigned e_type
)
16787 static char buff
[64];
16789 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16791 /* NetBSD core "procinfo" structure. */
16792 return _("NetBSD procinfo structure");
16795 /* As of Jan 2002 there are no other machine-independent notes
16796 defined for NetBSD core files. If the note type is less
16797 than the start of the machine-dependent note types, we don't
16800 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16802 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16806 switch (elf_header
.e_machine
)
16808 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16809 and PT_GETFPREGS == mach+2. */
16814 case EM_SPARC32PLUS
:
16818 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16819 return _("PT_GETREGS (reg structure)");
16820 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16821 return _("PT_GETFPREGS (fpreg structure)");
16827 /* On all other arch's, PT_GETREGS == mach+1 and
16828 PT_GETFPREGS == mach+3. */
16832 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16833 return _("PT_GETREGS (reg structure)");
16834 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16835 return _("PT_GETFPREGS (fpreg structure)");
16841 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16842 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16846 static const char *
16847 get_stapsdt_note_type (unsigned e_type
)
16849 static char buff
[64];
16854 return _("NT_STAPSDT (SystemTap probe descriptors)");
16860 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16865 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16867 int addr_size
= is_32bit_elf
? 4 : 8;
16868 char *data
= pnote
->descdata
;
16869 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16870 bfd_vma pc
, base_addr
, semaphore
;
16871 char *provider
, *probe
, *arg_fmt
;
16873 pc
= byte_get ((unsigned char *) data
, addr_size
);
16875 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16877 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16881 data
+= strlen (data
) + 1;
16883 data
+= strlen (data
) + 1;
16885 data
+= strlen (data
) + 1;
16887 printf (_(" Provider: %s\n"), provider
);
16888 printf (_(" Name: %s\n"), probe
);
16889 printf (_(" Location: "));
16890 print_vma (pc
, FULL_HEX
);
16891 printf (_(", Base: "));
16892 print_vma (base_addr
, FULL_HEX
);
16893 printf (_(", Semaphore: "));
16894 print_vma (semaphore
, FULL_HEX
);
16896 printf (_(" Arguments: %s\n"), arg_fmt
);
16898 return data
== data_end
;
16901 static const char *
16902 get_ia64_vms_note_type (unsigned e_type
)
16904 static char buff
[64];
16909 return _("NT_VMS_MHD (module header)");
16911 return _("NT_VMS_LNM (language name)");
16913 return _("NT_VMS_SRC (source files)");
16915 return "NT_VMS_TITLE";
16917 return _("NT_VMS_EIDC (consistency check)");
16918 case NT_VMS_FPMODE
:
16919 return _("NT_VMS_FPMODE (FP mode)");
16920 case NT_VMS_LINKTIME
:
16921 return "NT_VMS_LINKTIME";
16922 case NT_VMS_IMGNAM
:
16923 return _("NT_VMS_IMGNAM (image name)");
16925 return _("NT_VMS_IMGID (image id)");
16926 case NT_VMS_LINKID
:
16927 return _("NT_VMS_LINKID (link id)");
16928 case NT_VMS_IMGBID
:
16929 return _("NT_VMS_IMGBID (build id)");
16930 case NT_VMS_GSTNAM
:
16931 return _("NT_VMS_GSTNAM (sym table name)");
16932 case NT_VMS_ORIG_DYN
:
16933 return "NT_VMS_ORIG_DYN";
16934 case NT_VMS_PATCHTIME
:
16935 return "NT_VMS_PATCHTIME";
16937 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16943 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16945 switch (pnote
->type
)
16948 if (pnote
->descsz
> 36)
16950 size_t l
= strlen (pnote
->descdata
+ 34);
16951 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16952 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16953 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16954 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16957 printf (_(" Invalid size\n"));
16960 printf (_(" Language: %s\n"), pnote
->descdata
);
16963 case NT_VMS_FPMODE
:
16964 printf (_(" Floating Point mode: "));
16965 printf ("0x%016" BFD_VMA_FMT
"x\n",
16966 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16968 case NT_VMS_LINKTIME
:
16969 printf (_(" Link time: "));
16971 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16974 case NT_VMS_PATCHTIME
:
16975 printf (_(" Patch time: "));
16977 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16980 case NT_VMS_ORIG_DYN
:
16981 printf (_(" Major id: %u, minor id: %u\n"),
16982 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16983 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16984 printf (_(" Last modified : "));
16986 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16987 printf (_("\n Link flags : "));
16988 printf ("0x%016" BFD_VMA_FMT
"x\n",
16989 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16990 printf (_(" Header flags: 0x%08x\n"),
16991 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16992 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16995 case NT_VMS_IMGNAM
:
16996 printf (_(" Image name: %s\n"), pnote
->descdata
);
16998 case NT_VMS_GSTNAM
:
16999 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17002 printf (_(" Image id: %s\n"), pnote
->descdata
);
17004 case NT_VMS_LINKID
:
17005 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17013 /* Print the name of the symbol associated with a build attribute
17014 that is attached to address OFFSET. */
17017 print_symbol_for_build_attribute (FILE * file
,
17018 unsigned long offset
,
17019 bfd_boolean is_open_attr
)
17021 static FILE * saved_file
= NULL
;
17022 static char * strtab
;
17023 static unsigned long strtablen
;
17024 static Elf_Internal_Sym
* symtab
;
17025 static unsigned long nsyms
;
17026 Elf_Internal_Sym
* saved_sym
= NULL
;
17027 Elf_Internal_Sym
* sym
;
17029 if (section_headers
!= NULL
17030 && (saved_file
== NULL
|| file
!= saved_file
))
17032 Elf_Internal_Shdr
* symsec
;
17034 /* Load the symbol and string sections. */
17035 for (symsec
= section_headers
;
17036 symsec
< section_headers
+ elf_header
.e_shnum
;
17039 if (symsec
->sh_type
== SHT_SYMTAB
)
17041 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
17043 if (symsec
->sh_link
< elf_header
.e_shnum
)
17045 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
17047 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
17048 1, strtab_sec
->sh_size
,
17049 _("string table"));
17050 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17057 if (symtab
== NULL
|| strtab
== NULL
)
17063 /* Find a symbol whose value matches offset. */
17064 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17065 if (sym
->st_value
== offset
)
17067 if (sym
->st_name
>= strtablen
)
17068 /* Huh ? This should not happen. */
17071 if (strtab
[sym
->st_name
] == 0)
17076 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17077 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17078 FUNC symbols entirely. */
17079 switch (ELF_ST_TYPE (sym
->st_info
))
17083 /* We can stop searching now. */
17084 sym
= symtab
+ nsyms
;
17092 /* Ignore function symbols. */
17099 switch (ELF_ST_BIND (sym
->st_info
))
17102 if (saved_sym
== NULL
17103 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17108 if (saved_sym
== NULL
)
17118 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17126 printf (" (%s: %s)\n",
17127 is_open_attr
? _("file") : _("func"),
17128 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
17133 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17136 static unsigned long global_offset
= 0;
17137 unsigned long offset
;
17138 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
17139 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17141 if (pnote
->descsz
== 0)
17145 printf (_(" Applies from offset %#lx\n"), global_offset
);
17150 printf (_(" Applies to func at %#lx"), global_offset
);
17151 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
17155 if (pnote
->descsz
!= desc_size
)
17157 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17158 printf (_(" <invalid descsz>"));
17162 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
17166 printf (_(" Applies from offset %#lx"), offset
);
17167 global_offset
= offset
;
17171 printf (_(" Applies to func at %#lx"), offset
);
17174 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
17178 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17180 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17181 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17182 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17184 char name_attribute
;
17185 const char * expected_types
;
17186 const char * name
= pnote
->namedata
;
17190 if (name
== NULL
|| pnote
->namesz
< 2)
17192 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17193 print_symbol (-20, _(" <corrupt name>"));
17199 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17200 if (name
[0] == 'G' && name
[1] == 'A')
17207 switch ((name_type
= * name
))
17209 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17210 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17211 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17212 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17213 printf ("%c", * name
);
17217 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17218 print_symbol (-20, _("<unknown name type>"));
17225 switch ((name_attribute
= * name
))
17227 case GNU_BUILD_ATTRIBUTE_VERSION
:
17228 text
= _("<version>");
17229 expected_types
= string_expected
;
17232 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17233 text
= _("<stack prot>");
17234 expected_types
= "!+*";
17237 case GNU_BUILD_ATTRIBUTE_RELRO
:
17238 text
= _("<relro>");
17239 expected_types
= bool_expected
;
17242 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17243 text
= _("<stack size>");
17244 expected_types
= number_expected
;
17247 case GNU_BUILD_ATTRIBUTE_TOOL
:
17248 text
= _("<tool>");
17249 expected_types
= string_expected
;
17252 case GNU_BUILD_ATTRIBUTE_ABI
:
17254 expected_types
= "$*";
17257 case GNU_BUILD_ATTRIBUTE_PIC
:
17259 expected_types
= number_expected
;
17262 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17263 text
= _("<short enum>");
17264 expected_types
= bool_expected
;
17268 if (ISPRINT (* name
))
17270 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17272 if (len
> left
&& ! do_wide
)
17274 printf ("%.*s:", len
, name
);
17280 static char tmpbuf
[128];
17282 error (_("unrecognised byte in name field: %d\n"), * name
);
17283 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17287 expected_types
= "*$!+";
17292 left
-= printf ("%s", text
);
17294 if (strchr (expected_types
, name_type
) == NULL
)
17295 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17297 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17299 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17300 (unsigned long) pnote
->namesz
,
17301 (long) (name
- pnote
->namedata
));
17305 if (left
< 1 && ! do_wide
)
17310 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17312 unsigned int bytes
;
17313 unsigned long long val
= 0;
17314 unsigned int shift
= 0;
17315 char * decoded
= NULL
;
17317 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17319 /* The -1 is because the name field is always 0 terminated, and we
17320 want to be able to ensure that the shift in the while loop below
17321 will not overflow. */
17324 if (bytes
> sizeof (val
))
17326 fprintf (stderr
, "namesz %lx name %p namedata %p\n",
17327 pnote
->namesz
, name
, pnote
->namedata
);
17328 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17330 bytes
= sizeof (val
);
17332 /* We do not bother to warn if bytes == 0 as this can
17333 happen with some early versions of the gcc plugin. */
17337 unsigned long byte
= (* name
++) & 0xff;
17339 val
|= byte
<< shift
;
17343 switch (name_attribute
)
17345 case GNU_BUILD_ATTRIBUTE_PIC
:
17348 case 0: decoded
= "static"; break;
17349 case 1: decoded
= "pic"; break;
17350 case 2: decoded
= "PIC"; break;
17351 case 3: decoded
= "pie"; break;
17352 case 4: decoded
= "PIE"; break;
17356 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17359 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17360 case 0: decoded
= "off"; break;
17361 case 1: decoded
= "on"; break;
17362 case 2: decoded
= "all"; break;
17363 case 3: decoded
= "strong"; break;
17364 case 4: decoded
= "explicit"; break;
17372 if (decoded
!= NULL
)
17374 print_symbol (-left
, decoded
);
17385 left
-= printf ("0x%llx", val
);
17387 left
-= printf ("0x%-.*llx", left
, val
);
17391 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17392 left
-= print_symbol (- left
, name
);
17394 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17395 left
-= print_symbol (- left
, "true");
17397 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17398 left
-= print_symbol (- left
, "false");
17402 if (do_wide
&& left
> 0)
17403 printf ("%-*s", left
, " ");
17408 /* Note that by the ELF standard, the name field is already null byte
17409 terminated, and namesz includes the terminating null byte.
17410 I.E. the value of namesz for the name "FSF" is 4.
17412 If the value of namesz is zero, there is no name present. */
17415 process_note (Elf_Internal_Note
* pnote
,
17418 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17421 if (pnote
->namesz
== 0)
17422 /* If there is no note name, then use the default set of
17423 note type strings. */
17424 nt
= get_note_type (pnote
->type
);
17426 else if (const_strneq (pnote
->namedata
, "GNU"))
17427 /* GNU-specific object file notes. */
17428 nt
= get_gnu_elf_note_type (pnote
->type
);
17430 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17431 /* FreeBSD-specific core file notes. */
17432 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
17434 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17435 /* NetBSD-specific core file notes. */
17436 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17438 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17439 /* NetBSD-specific core file notes. */
17440 return process_netbsd_elf_note (pnote
);
17442 else if (strneq (pnote
->namedata
, "SPU/", 4))
17444 /* SPU-specific core file notes. */
17445 nt
= pnote
->namedata
+ 4;
17449 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17450 /* VMS/ia64-specific file notes. */
17451 nt
= get_ia64_vms_note_type (pnote
->type
);
17453 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17454 nt
= get_stapsdt_note_type (pnote
->type
);
17457 /* Don't recognize this note name; just use the default set of
17458 note type strings. */
17459 nt
= get_note_type (pnote
->type
);
17463 if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17464 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17465 print_gnu_build_attribute_name (pnote
);
17467 print_symbol (-20, name
);
17470 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17472 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17474 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17475 return print_ia64_vms_note (pnote
);
17476 else if (const_strneq (pnote
->namedata
, "GNU"))
17477 return print_gnu_note (pnote
);
17478 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17479 return print_stapsdt_note (pnote
);
17480 else if (const_strneq (pnote
->namedata
, "CORE"))
17481 return print_core_note (pnote
);
17482 else if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17483 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17484 return print_gnu_build_attribute_description (pnote
, file
);
17490 printf (_(" description data: "));
17491 for (i
= 0; i
< pnote
->descsz
; i
++)
17492 printf ("%02x ", pnote
->descdata
[i
]);
17502 process_notes_at (FILE * file
,
17503 Elf_Internal_Shdr
* section
,
17507 Elf_External_Note
* pnotes
;
17508 Elf_External_Note
* external
;
17510 bfd_boolean res
= TRUE
;
17517 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17520 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17525 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17527 if (pnotes
== NULL
)
17533 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17535 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17536 (unsigned long) offset
, (unsigned long) length
);
17538 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17540 end
= (char *) pnotes
+ length
;
17541 while ((char *) external
< end
)
17543 Elf_Internal_Note inote
;
17546 char * temp
= NULL
;
17547 size_t data_remaining
= end
- (char *) external
;
17549 if (!is_ia64_vms ())
17551 /* PR binutils/15191
17552 Make sure that there is enough data to read. */
17553 min_notesz
= offsetof (Elf_External_Note
, name
);
17554 if (data_remaining
< min_notesz
)
17556 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17557 (int) data_remaining
);
17560 inote
.type
= BYTE_GET (external
->type
);
17561 inote
.namesz
= BYTE_GET (external
->namesz
);
17562 inote
.namedata
= external
->name
;
17563 inote
.descsz
= BYTE_GET (external
->descsz
);
17564 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17565 /* PR 17531: file: 3443835e. */
17566 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17568 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17569 inote
.namesz
, (long)(end
- inote
.namedata
));
17570 inote
.descdata
= inote
.namedata
;
17574 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17575 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17579 Elf64_External_VMS_Note
*vms_external
;
17581 /* PR binutils/15191
17582 Make sure that there is enough data to read. */
17583 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17584 if (data_remaining
< min_notesz
)
17586 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17587 (int) data_remaining
);
17591 vms_external
= (Elf64_External_VMS_Note
*) external
;
17592 inote
.type
= BYTE_GET (vms_external
->type
);
17593 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17594 inote
.namedata
= vms_external
->name
;
17595 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17596 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17597 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17598 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17601 if (inote
.descdata
< (char *) external
+ min_notesz
17602 || next
< (char *) external
+ min_notesz
17603 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17604 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17605 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17606 || data_remaining
< (size_t)(next
- (char *) external
))
17608 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17609 (unsigned long) ((char *) external
- (char *) pnotes
));
17610 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17611 inote
.type
, inote
.namesz
, inote
.descsz
);
17615 external
= (Elf_External_Note
*) next
;
17617 /* Verify that name is null terminated. It appears that at least
17618 one version of Linux (RedHat 6.0) generates corefiles that don't
17619 comply with the ELF spec by failing to include the null byte in
17621 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17623 temp
= (char *) malloc (inote
.namesz
+ 1);
17626 error (_("Out of memory allocating space for inote name\n"));
17631 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17632 temp
[inote
.namesz
] = 0;
17634 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17635 inote
.namedata
= temp
;
17638 if (! process_note (& inote
, file
))
17654 process_corefile_note_segments (FILE * file
)
17656 Elf_Internal_Phdr
* segment
;
17658 bfd_boolean res
= TRUE
;
17660 if (! get_program_headers (file
))
17663 for (i
= 0, segment
= program_headers
;
17664 i
< elf_header
.e_phnum
;
17667 if (segment
->p_type
== PT_NOTE
)
17668 if (! process_notes_at (file
, NULL
,
17669 (bfd_vma
) segment
->p_offset
,
17670 (bfd_vma
) segment
->p_filesz
))
17678 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17680 Elf_External_Note
* pnotes
;
17681 Elf_External_Note
* external
;
17683 bfd_boolean res
= TRUE
;
17688 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17690 if (pnotes
== NULL
)
17694 end
= (char*) pnotes
+ length
;
17696 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17697 (unsigned long) offset
, (unsigned long) length
);
17699 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17701 Elf_External_Note
* next
;
17702 Elf_Internal_Note inote
;
17704 inote
.type
= BYTE_GET (external
->type
);
17705 inote
.namesz
= BYTE_GET (external
->namesz
);
17706 inote
.namedata
= external
->name
;
17707 inote
.descsz
= BYTE_GET (external
->descsz
);
17708 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17709 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17711 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17713 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17714 inote
.descdata
= inote
.namedata
;
17718 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17720 if ( ((char *) next
> end
)
17721 || ((char *) next
< (char *) pnotes
))
17723 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17724 (unsigned long) ((char *) external
- (char *) pnotes
));
17725 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17726 inote
.type
, inote
.namesz
, inote
.descsz
);
17732 /* Prevent out-of-bounds indexing. */
17733 if ( inote
.namedata
+ inote
.namesz
> end
17734 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17736 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17737 (unsigned long) ((char *) external
- (char *) pnotes
));
17738 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17739 inote
.type
, inote
.namesz
, inote
.descsz
);
17743 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17745 if (! print_v850_note (& inote
))
17748 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17749 inote
.namesz
, inote
.descsz
);
17759 process_note_sections (FILE * file
)
17761 Elf_Internal_Shdr
* section
;
17763 unsigned int n
= 0;
17764 bfd_boolean res
= TRUE
;
17766 for (i
= 0, section
= section_headers
;
17767 i
< elf_header
.e_shnum
&& section
!= NULL
;
17770 if (section
->sh_type
== SHT_NOTE
)
17772 if (! process_notes_at (file
, section
,
17773 (bfd_vma
) section
->sh_offset
,
17774 (bfd_vma
) section
->sh_size
))
17779 if (( elf_header
.e_machine
== EM_V800
17780 || elf_header
.e_machine
== EM_V850
17781 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17782 && section
->sh_type
== SHT_RENESAS_INFO
)
17784 if (! process_v850_notes (file
,
17785 (bfd_vma
) section
->sh_offset
,
17786 (bfd_vma
) section
->sh_size
))
17793 /* Try processing NOTE segments instead. */
17794 return process_corefile_note_segments (file
);
17800 process_notes (FILE * file
)
17802 /* If we have not been asked to display the notes then do nothing. */
17806 if (elf_header
.e_type
!= ET_CORE
)
17807 return process_note_sections (file
);
17809 /* No program headers means no NOTE segment. */
17810 if (elf_header
.e_phnum
> 0)
17811 return process_corefile_note_segments (file
);
17813 printf (_("No note segments present in the core file.\n"));
17817 static unsigned char *
17818 display_public_gnu_attributes (unsigned char * start
,
17819 const unsigned char * const end
)
17821 printf (_(" Unknown GNU attribute: %s\n"), start
);
17823 start
+= strnlen ((char *) start
, end
- start
);
17824 display_raw_attribute (start
, end
);
17826 return (unsigned char *) end
;
17829 static unsigned char *
17830 display_generic_attribute (unsigned char * start
,
17832 const unsigned char * const end
)
17835 return (unsigned char *) end
;
17837 return display_tag_value (tag
, start
, end
);
17841 process_arch_specific (FILE * file
)
17846 switch (elf_header
.e_machine
)
17849 case EM_ARC_COMPACT
:
17850 case EM_ARC_COMPACT2
:
17851 return process_attributes (file
, "ARC", SHT_ARC_ATTRIBUTES
,
17852 display_arc_attribute
,
17853 display_generic_attribute
);
17855 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17856 display_arm_attribute
,
17857 display_generic_attribute
);
17860 case EM_MIPS_RS3_LE
:
17861 return process_mips_specific (file
);
17864 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17865 display_msp430x_attribute
,
17866 display_generic_attribute
);
17869 return process_nds32_specific (file
);
17873 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17874 display_power_gnu_attribute
);
17878 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17879 display_s390_gnu_attribute
);
17882 case EM_SPARC32PLUS
:
17884 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17885 display_sparc_gnu_attribute
);
17888 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17889 display_tic6x_attribute
,
17890 display_generic_attribute
);
17893 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17894 display_public_gnu_attributes
,
17895 display_generic_attribute
);
17900 get_file_header (FILE * file
)
17902 /* Read in the identity array. */
17903 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
17906 /* Determine how to read the rest of the header. */
17907 switch (elf_header
.e_ident
[EI_DATA
])
17912 byte_get
= byte_get_little_endian
;
17913 byte_put
= byte_put_little_endian
;
17916 byte_get
= byte_get_big_endian
;
17917 byte_put
= byte_put_big_endian
;
17921 /* For now we only support 32 bit and 64 bit ELF files. */
17922 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
17924 /* Read in the rest of the header. */
17927 Elf32_External_Ehdr ehdr32
;
17929 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
17932 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
17933 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
17934 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
17935 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
17936 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
17937 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
17938 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
17939 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
17940 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
17941 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
17942 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
17943 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
17944 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
17948 Elf64_External_Ehdr ehdr64
;
17950 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17951 we will not be able to cope with the 64bit data found in
17952 64 ELF files. Detect this now and abort before we start
17953 overwriting things. */
17954 if (sizeof (bfd_vma
) < 8)
17956 error (_("This instance of readelf has been built without support for a\n\
17957 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17961 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
17964 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
17965 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
17966 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
17967 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
17968 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
17969 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
17970 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
17971 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
17972 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
17973 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
17974 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
17975 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
17976 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
17979 if (elf_header
.e_shoff
)
17981 /* There may be some extensions in the first section header. Don't
17982 bomb if we can't read it. */
17984 get_32bit_section_headers (file
, TRUE
);
17986 get_64bit_section_headers (file
, TRUE
);
17992 /* Process one ELF object file according to the command line options.
17993 This file may actually be stored in an archive. The file is
17994 positioned at the start of the ELF object. Returns TRUE if no
17995 problems were encountered, FALSE otherwise. */
17998 process_object (char * file_name
, FILE * file
)
18001 bfd_boolean res
= TRUE
;
18003 if (! get_file_header (file
))
18005 error (_("%s: Failed to read file header\n"), file_name
);
18009 /* Initialise per file variables. */
18010 for (i
= ARRAY_SIZE (version_info
); i
--;)
18011 version_info
[i
] = 0;
18013 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18014 dynamic_info
[i
] = 0;
18015 dynamic_info_DT_GNU_HASH
= 0;
18017 /* Process the file. */
18019 printf (_("\nFile: %s\n"), file_name
);
18021 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18022 Note we do this even if cmdline_dump_sects is empty because we
18023 must make sure that the dump_sets array is zeroed out before each
18024 object file is processed. */
18025 if (num_dump_sects
> num_cmdline_dump_sects
)
18026 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
18028 if (num_cmdline_dump_sects
> 0)
18030 if (num_dump_sects
== 0)
18031 /* A sneaky way of allocating the dump_sects array. */
18032 request_dump_bynumber (num_cmdline_dump_sects
, 0);
18034 assert (num_dump_sects
>= num_cmdline_dump_sects
);
18035 memcpy (dump_sects
, cmdline_dump_sects
,
18036 num_cmdline_dump_sects
* sizeof (* dump_sects
));
18039 if (! process_file_header ())
18042 if (! process_section_headers (file
))
18044 /* Without loaded section headers we cannot process lots of things. */
18045 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18047 if (! do_using_dynamic
)
18048 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18051 if (! process_section_groups (file
))
18052 /* Without loaded section groups we cannot process unwind. */
18055 if (process_program_headers (file
))
18056 process_dynamic_section (file
);
18060 if (! process_relocs (file
))
18063 if (! process_unwind (file
))
18066 if (! process_symbol_table (file
))
18069 if (! process_syminfo (file
))
18072 if (! process_version_sections (file
))
18075 if (! process_section_contents (file
))
18078 if (! process_notes (file
))
18081 if (! process_gnu_liblist (file
))
18084 if (! process_arch_specific (file
))
18087 if (program_headers
)
18089 free (program_headers
);
18090 program_headers
= NULL
;
18093 if (section_headers
)
18095 free (section_headers
);
18096 section_headers
= NULL
;
18101 free (string_table
);
18102 string_table
= NULL
;
18103 string_table_length
= 0;
18106 if (dynamic_strings
)
18108 free (dynamic_strings
);
18109 dynamic_strings
= NULL
;
18110 dynamic_strings_length
= 0;
18113 if (dynamic_symbols
)
18115 free (dynamic_symbols
);
18116 dynamic_symbols
= NULL
;
18117 num_dynamic_syms
= 0;
18120 if (dynamic_syminfo
)
18122 free (dynamic_syminfo
);
18123 dynamic_syminfo
= NULL
;
18126 if (dynamic_section
)
18128 free (dynamic_section
);
18129 dynamic_section
= NULL
;
18132 if (section_headers_groups
)
18134 free (section_headers_groups
);
18135 section_headers_groups
= NULL
;
18138 if (section_groups
)
18140 struct group_list
* g
;
18141 struct group_list
* next
;
18143 for (i
= 0; i
< group_count
; i
++)
18145 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18152 free (section_groups
);
18153 section_groups
= NULL
;
18156 free_debug_memory ();
18161 /* Process an ELF archive.
18162 On entry the file is positioned just after the ARMAG string.
18163 Returns TRUE upon success, FALSE otherwise. */
18166 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
18168 struct archive_info arch
;
18169 struct archive_info nested_arch
;
18171 bfd_boolean ret
= TRUE
;
18175 /* The ARCH structure is used to hold information about this archive. */
18176 arch
.file_name
= NULL
;
18178 arch
.index_array
= NULL
;
18179 arch
.sym_table
= NULL
;
18180 arch
.longnames
= NULL
;
18182 /* The NESTED_ARCH structure is used as a single-item cache of information
18183 about a nested archive (when members of a thin archive reside within
18184 another regular archive file). */
18185 nested_arch
.file_name
= NULL
;
18186 nested_arch
.file
= NULL
;
18187 nested_arch
.index_array
= NULL
;
18188 nested_arch
.sym_table
= NULL
;
18189 nested_arch
.longnames
= NULL
;
18191 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
18197 if (do_archive_index
)
18199 if (arch
.sym_table
== NULL
)
18200 error (_("%s: unable to dump the index as none was found\n"), file_name
);
18203 unsigned long i
, l
;
18204 unsigned long current_pos
;
18206 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18207 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18208 current_pos
= ftell (file
);
18210 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18212 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18214 char * member_name
;
18216 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18218 if (member_name
!= NULL
)
18220 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18222 if (qualified_name
!= NULL
)
18224 printf (_("Contents of binary %s at offset "), qualified_name
);
18225 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18227 free (qualified_name
);
18232 if (l
>= arch
.sym_size
)
18234 error (_("%s: end of the symbol table reached before the end of the index\n"),
18239 /* PR 17531: file: 0b6630b2. */
18240 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18241 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18244 if (arch
.uses_64bit_indicies
)
18249 if (l
< arch
.sym_size
)
18251 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18252 file_name
, arch
.sym_size
- l
);
18256 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
18258 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
18264 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18265 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18266 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18267 && !do_section_groups
&& !do_dyn_syms
)
18269 ret
= TRUE
; /* Archive index only. */
18278 char * qualified_name
;
18280 /* Read the next archive header. */
18281 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18283 error (_("%s: failed to seek to next archive header\n"), file_name
);
18286 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
18287 if (got
!= sizeof arch
.arhdr
)
18291 error (_("%s: failed to read archive header\n"), file_name
);
18295 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18297 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18302 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18304 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18305 if (archive_file_size
& 01)
18306 ++archive_file_size
;
18308 name
= get_archive_member_name (&arch
, &nested_arch
);
18311 error (_("%s: bad archive file name\n"), file_name
);
18315 namelen
= strlen (name
);
18317 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18318 if (qualified_name
== NULL
)
18320 error (_("%s: bad archive file name\n"), file_name
);
18325 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18327 /* This is a proxy for an external member of a thin archive. */
18328 FILE * member_file
;
18329 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
18331 if (member_file_name
== NULL
)
18337 member_file
= fopen (member_file_name
, "rb");
18338 if (member_file
== NULL
)
18340 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18341 free (member_file_name
);
18346 archive_file_offset
= arch
.nested_member_origin
;
18348 if (! process_object (qualified_name
, member_file
))
18351 fclose (member_file
);
18352 free (member_file_name
);
18354 else if (is_thin_archive
)
18356 /* PR 15140: Allow for corrupt thin archives. */
18357 if (nested_arch
.file
== NULL
)
18359 error (_("%s: contains corrupt thin archive: %s\n"),
18365 /* This is a proxy for a member of a nested archive. */
18366 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18368 /* The nested archive file will have been opened and setup by
18369 get_archive_member_name. */
18370 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18372 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
18377 if (! process_object (qualified_name
, nested_arch
.file
))
18382 archive_file_offset
= arch
.next_arhdr_offset
;
18383 arch
.next_arhdr_offset
+= archive_file_size
;
18385 if (! process_object (qualified_name
, file
))
18389 if (dump_sects
!= NULL
)
18393 num_dump_sects
= 0;
18396 free (qualified_name
);
18400 if (nested_arch
.file
!= NULL
)
18401 fclose (nested_arch
.file
);
18402 release_archive (&nested_arch
);
18403 release_archive (&arch
);
18409 process_file (char * file_name
)
18412 struct stat statbuf
;
18413 char armag
[SARMAG
];
18414 bfd_boolean ret
= TRUE
;
18416 if (stat (file_name
, &statbuf
) < 0)
18418 if (errno
== ENOENT
)
18419 error (_("'%s': No such file\n"), file_name
);
18421 error (_("Could not locate '%s'. System error message: %s\n"),
18422 file_name
, strerror (errno
));
18426 if (! S_ISREG (statbuf
.st_mode
))
18428 error (_("'%s' is not an ordinary file\n"), file_name
);
18432 file
= fopen (file_name
, "rb");
18435 error (_("Input file '%s' is not readable.\n"), file_name
);
18439 if (fread (armag
, SARMAG
, 1, file
) != 1)
18441 error (_("%s: Failed to read file's magic number\n"), file_name
);
18446 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18448 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18450 if (! process_archive (file_name
, file
, FALSE
))
18453 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18455 if ( ! process_archive (file_name
, file
, TRUE
))
18460 if (do_archive_index
)
18461 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18465 archive_file_size
= archive_file_offset
= 0;
18467 if (! process_object (file_name
, file
))
18472 current_file_size
= 0;
18477 #ifdef SUPPORT_DISASSEMBLY
18478 /* Needed by the i386 disassembler. For extra credit, someone could
18479 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18483 print_address (unsigned int addr
, FILE * outfile
)
18485 fprintf (outfile
,"0x%8.8x", addr
);
18488 /* Needed by the i386 disassembler. */
18490 db_task_printsym (unsigned int addr
)
18492 print_address (addr
, stderr
);
18497 main (int argc
, char ** argv
)
18501 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18502 setlocale (LC_MESSAGES
, "");
18504 #if defined (HAVE_SETLOCALE)
18505 setlocale (LC_CTYPE
, "");
18507 bindtextdomain (PACKAGE
, LOCALEDIR
);
18508 textdomain (PACKAGE
);
18510 expandargv (&argc
, &argv
);
18512 parse_args (argc
, argv
);
18514 if (num_dump_sects
> 0)
18516 /* Make a copy of the dump_sects array. */
18517 cmdline_dump_sects
= (dump_type
*)
18518 malloc (num_dump_sects
* sizeof (* dump_sects
));
18519 if (cmdline_dump_sects
== NULL
)
18520 error (_("Out of memory allocating dump request table.\n"));
18523 memcpy (cmdline_dump_sects
, dump_sects
,
18524 num_dump_sects
* sizeof (* dump_sects
));
18525 num_cmdline_dump_sects
= num_dump_sects
;
18529 if (optind
< (argc
- 1))
18531 else if (optind
>= argc
)
18533 warn (_("Nothing to do.\n"));
18538 while (optind
< argc
)
18539 if (! process_file (argv
[optind
++]))
18542 if (dump_sects
!= NULL
)
18544 if (cmdline_dump_sects
!= NULL
)
18545 free (cmdline_dump_sects
);
18547 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;