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 also helps. */
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");
2512 strcat (buf
, ", unrecognised ARC OSABI flag");
2518 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2521 bfd_boolean unknown
= FALSE
;
2523 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2524 e_flags
&= ~ EF_ARM_EABIMASK
;
2526 /* Handle "generic" ARM flags. */
2527 if (e_flags
& EF_ARM_RELEXEC
)
2529 strcat (buf
, ", relocatable executable");
2530 e_flags
&= ~ EF_ARM_RELEXEC
;
2533 /* Now handle EABI specific flags. */
2537 strcat (buf
, ", <unrecognized EABI>");
2542 case EF_ARM_EABI_VER1
:
2543 strcat (buf
, ", Version1 EABI");
2548 /* Process flags one bit at a time. */
2549 flag
= e_flags
& - e_flags
;
2554 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2555 strcat (buf
, ", sorted symbol tables");
2565 case EF_ARM_EABI_VER2
:
2566 strcat (buf
, ", Version2 EABI");
2571 /* Process flags one bit at a time. */
2572 flag
= e_flags
& - e_flags
;
2577 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2578 strcat (buf
, ", sorted symbol tables");
2581 case EF_ARM_DYNSYMSUSESEGIDX
:
2582 strcat (buf
, ", dynamic symbols use segment index");
2585 case EF_ARM_MAPSYMSFIRST
:
2586 strcat (buf
, ", mapping symbols precede others");
2596 case EF_ARM_EABI_VER3
:
2597 strcat (buf
, ", Version3 EABI");
2600 case EF_ARM_EABI_VER4
:
2601 strcat (buf
, ", Version4 EABI");
2606 /* Process flags one bit at a time. */
2607 flag
= e_flags
& - e_flags
;
2613 strcat (buf
, ", BE8");
2617 strcat (buf
, ", LE8");
2627 case EF_ARM_EABI_VER5
:
2628 strcat (buf
, ", Version5 EABI");
2633 /* Process flags one bit at a time. */
2634 flag
= e_flags
& - e_flags
;
2640 strcat (buf
, ", BE8");
2644 strcat (buf
, ", LE8");
2647 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2648 strcat (buf
, ", soft-float ABI");
2651 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2652 strcat (buf
, ", hard-float ABI");
2662 case EF_ARM_EABI_UNKNOWN
:
2663 strcat (buf
, ", GNU EABI");
2668 /* Process flags one bit at a time. */
2669 flag
= e_flags
& - e_flags
;
2674 case EF_ARM_INTERWORK
:
2675 strcat (buf
, ", interworking enabled");
2678 case EF_ARM_APCS_26
:
2679 strcat (buf
, ", uses APCS/26");
2682 case EF_ARM_APCS_FLOAT
:
2683 strcat (buf
, ", uses APCS/float");
2687 strcat (buf
, ", position independent");
2691 strcat (buf
, ", 8 bit structure alignment");
2694 case EF_ARM_NEW_ABI
:
2695 strcat (buf
, ", uses new ABI");
2698 case EF_ARM_OLD_ABI
:
2699 strcat (buf
, ", uses old ABI");
2702 case EF_ARM_SOFT_FLOAT
:
2703 strcat (buf
, ", software FP");
2706 case EF_ARM_VFP_FLOAT
:
2707 strcat (buf
, ", VFP");
2710 case EF_ARM_MAVERICK_FLOAT
:
2711 strcat (buf
, ", Maverick FP");
2722 strcat (buf
,_(", <unknown>"));
2726 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2728 --size
; /* Leave space for null terminator. */
2730 switch (e_flags
& EF_AVR_MACH
)
2732 case E_AVR_MACH_AVR1
:
2733 strncat (buf
, ", avr:1", size
);
2735 case E_AVR_MACH_AVR2
:
2736 strncat (buf
, ", avr:2", size
);
2738 case E_AVR_MACH_AVR25
:
2739 strncat (buf
, ", avr:25", size
);
2741 case E_AVR_MACH_AVR3
:
2742 strncat (buf
, ", avr:3", size
);
2744 case E_AVR_MACH_AVR31
:
2745 strncat (buf
, ", avr:31", size
);
2747 case E_AVR_MACH_AVR35
:
2748 strncat (buf
, ", avr:35", size
);
2750 case E_AVR_MACH_AVR4
:
2751 strncat (buf
, ", avr:4", size
);
2753 case E_AVR_MACH_AVR5
:
2754 strncat (buf
, ", avr:5", size
);
2756 case E_AVR_MACH_AVR51
:
2757 strncat (buf
, ", avr:51", size
);
2759 case E_AVR_MACH_AVR6
:
2760 strncat (buf
, ", avr:6", size
);
2762 case E_AVR_MACH_AVRTINY
:
2763 strncat (buf
, ", avr:100", size
);
2765 case E_AVR_MACH_XMEGA1
:
2766 strncat (buf
, ", avr:101", size
);
2768 case E_AVR_MACH_XMEGA2
:
2769 strncat (buf
, ", avr:102", size
);
2771 case E_AVR_MACH_XMEGA3
:
2772 strncat (buf
, ", avr:103", size
);
2774 case E_AVR_MACH_XMEGA4
:
2775 strncat (buf
, ", avr:104", size
);
2777 case E_AVR_MACH_XMEGA5
:
2778 strncat (buf
, ", avr:105", size
);
2780 case E_AVR_MACH_XMEGA6
:
2781 strncat (buf
, ", avr:106", size
);
2783 case E_AVR_MACH_XMEGA7
:
2784 strncat (buf
, ", avr:107", size
);
2787 strncat (buf
, ", avr:<unknown>", size
);
2791 size
-= strlen (buf
);
2792 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2793 strncat (buf
, ", link-relax", size
);
2797 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2803 bfd_boolean has_fpu
= FALSE
;
2806 static const char *ABI_STRINGS
[] =
2808 "ABI v0", /* use r5 as return register; only used in N1213HC */
2809 "ABI v1", /* use r0 as return register */
2810 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2811 "ABI v2fp", /* for FPU */
2815 static const char *VER_STRINGS
[] =
2817 "Andes ELF V1.3 or older",
2821 static const char *ARCH_STRINGS
[] =
2830 abi
= EF_NDS_ABI
& e_flags
;
2831 arch
= EF_NDS_ARCH
& e_flags
;
2832 config
= EF_NDS_INST
& e_flags
;
2833 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2835 memset (buf
, 0, size
);
2842 case E_NDS_ABI_V2FP
:
2843 case E_NDS_ABI_AABI
:
2844 case E_NDS_ABI_V2FP_PLUS
:
2845 /* In case there are holes in the array. */
2846 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2850 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2856 case E_NDS32_ELF_VER_1_2
:
2857 case E_NDS32_ELF_VER_1_3
:
2858 case E_NDS32_ELF_VER_1_4
:
2859 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2863 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2867 if (E_NDS_ABI_V0
== abi
)
2869 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2870 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2871 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2872 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2878 case E_NDS_ARCH_STAR_V1_0
:
2879 case E_NDS_ARCH_STAR_V2_0
:
2880 case E_NDS_ARCH_STAR_V3_0
:
2881 case E_NDS_ARCH_STAR_V3_M
:
2882 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2886 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2887 /* ARCH version determines how the e_flags are interpreted.
2888 If it is unknown, we cannot proceed. */
2892 /* Newer ABI; Now handle architecture specific flags. */
2893 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2895 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2896 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2898 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2899 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2901 if (config
& E_NDS32_HAS_DIV_INST
)
2902 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2904 if (config
& E_NDS32_HAS_16BIT_INST
)
2905 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2909 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2911 if (version
<= E_NDS32_ELF_VER_1_3
)
2912 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2914 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2917 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2918 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2920 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2921 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2923 if (config
& E_NDS32_HAS_16BIT_INST
)
2925 if (version
<= E_NDS32_ELF_VER_1_3
)
2926 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2928 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2932 if (config
& E_NDS32_HAS_EXT_INST
)
2933 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2935 if (config
& E_NDS32_HAS_EXT2_INST
)
2936 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2938 if (config
& E_NDS32_HAS_FPU_INST
)
2941 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2944 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2947 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2950 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2953 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2958 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2960 case E_NDS32_FPU_REG_8SP_4DP
:
2961 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2963 case E_NDS32_FPU_REG_16SP_8DP
:
2964 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2966 case E_NDS32_FPU_REG_32SP_16DP
:
2967 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2969 case E_NDS32_FPU_REG_32SP_32DP
:
2970 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2975 if (config
& E_NDS32_HAS_AUDIO_INST
)
2976 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2978 if (config
& E_NDS32_HAS_STRING_INST
)
2979 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2981 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2982 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2984 if (config
& E_NDS32_HAS_VIDEO_INST
)
2986 if (version
<= E_NDS32_ELF_VER_1_3
)
2987 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2989 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2992 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2993 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2995 if (config
& E_NDS32_HAS_L2C_INST
)
2996 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3000 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
3002 static char buf
[1024];
3013 case EM_ARC_COMPACT2
:
3014 case EM_ARC_COMPACT
:
3015 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3019 decode_ARM_machine_flags (e_flags
, buf
);
3023 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3027 if (e_flags
& EF_BFIN_PIC
)
3028 strcat (buf
, ", PIC");
3030 if (e_flags
& EF_BFIN_FDPIC
)
3031 strcat (buf
, ", FDPIC");
3033 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3034 strcat (buf
, ", code in L1");
3036 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3037 strcat (buf
, ", data in L1");
3042 switch (e_flags
& EF_FRV_CPU_MASK
)
3044 case EF_FRV_CPU_GENERIC
:
3048 strcat (buf
, ", fr???");
3051 case EF_FRV_CPU_FR300
:
3052 strcat (buf
, ", fr300");
3055 case EF_FRV_CPU_FR400
:
3056 strcat (buf
, ", fr400");
3058 case EF_FRV_CPU_FR405
:
3059 strcat (buf
, ", fr405");
3062 case EF_FRV_CPU_FR450
:
3063 strcat (buf
, ", fr450");
3066 case EF_FRV_CPU_FR500
:
3067 strcat (buf
, ", fr500");
3069 case EF_FRV_CPU_FR550
:
3070 strcat (buf
, ", fr550");
3073 case EF_FRV_CPU_SIMPLE
:
3074 strcat (buf
, ", simple");
3076 case EF_FRV_CPU_TOMCAT
:
3077 strcat (buf
, ", tomcat");
3083 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3084 strcat (buf
, ", m68000");
3085 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3086 strcat (buf
, ", cpu32");
3087 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3088 strcat (buf
, ", fido_a");
3091 char const * isa
= _("unknown");
3092 char const * mac
= _("unknown mac");
3093 char const * additional
= NULL
;
3095 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3097 case EF_M68K_CF_ISA_A_NODIV
:
3099 additional
= ", nodiv";
3101 case EF_M68K_CF_ISA_A
:
3104 case EF_M68K_CF_ISA_A_PLUS
:
3107 case EF_M68K_CF_ISA_B_NOUSP
:
3109 additional
= ", nousp";
3111 case EF_M68K_CF_ISA_B
:
3114 case EF_M68K_CF_ISA_C
:
3117 case EF_M68K_CF_ISA_C_NODIV
:
3119 additional
= ", nodiv";
3122 strcat (buf
, ", cf, isa ");
3125 strcat (buf
, additional
);
3126 if (e_flags
& EF_M68K_CF_FLOAT
)
3127 strcat (buf
, ", float");
3128 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3133 case EF_M68K_CF_MAC
:
3136 case EF_M68K_CF_EMAC
:
3139 case EF_M68K_CF_EMAC_B
:
3152 switch (e_flags
& EF_MEP_CPU_MASK
)
3154 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3155 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3156 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3157 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3158 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3159 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3160 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3163 switch (e_flags
& EF_MEP_COP_MASK
)
3165 case EF_MEP_COP_NONE
: break;
3166 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3167 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3168 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3169 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3170 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3173 if (e_flags
& EF_MEP_LIBRARY
)
3174 strcat (buf
, ", Built for Library");
3176 if (e_flags
& EF_MEP_INDEX_MASK
)
3177 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3178 e_flags
& EF_MEP_INDEX_MASK
);
3180 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3181 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3182 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3186 if (e_flags
& EF_PPC_EMB
)
3187 strcat (buf
, ", emb");
3189 if (e_flags
& EF_PPC_RELOCATABLE
)
3190 strcat (buf
, _(", relocatable"));
3192 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3193 strcat (buf
, _(", relocatable-lib"));
3197 if (e_flags
& EF_PPC64_ABI
)
3199 char abi
[] = ", abiv0";
3201 abi
[6] += e_flags
& EF_PPC64_ABI
;
3207 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3208 strcat (buf
, ", RH850 ABI");
3210 if (e_flags
& EF_V800_850E3
)
3211 strcat (buf
, ", V3 architecture");
3213 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3214 strcat (buf
, ", FPU not used");
3216 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3217 strcat (buf
, ", regmode: COMMON");
3219 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3220 strcat (buf
, ", r4 not used");
3222 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3223 strcat (buf
, ", r30 not used");
3225 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3226 strcat (buf
, ", r5 not used");
3228 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3229 strcat (buf
, ", r2 not used");
3231 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3233 switch (e_flags
& - e_flags
)
3235 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3236 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3237 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3238 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3239 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3240 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3241 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3242 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3243 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3244 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3245 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3246 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3253 case EM_CYGNUS_V850
:
3254 switch (e_flags
& EF_V850_ARCH
)
3256 case E_V850E3V5_ARCH
:
3257 strcat (buf
, ", v850e3v5");
3259 case E_V850E2V3_ARCH
:
3260 strcat (buf
, ", v850e2v3");
3263 strcat (buf
, ", v850e2");
3266 strcat (buf
, ", v850e1");
3269 strcat (buf
, ", v850e");
3272 strcat (buf
, ", v850");
3275 strcat (buf
, _(", unknown v850 architecture variant"));
3281 case EM_CYGNUS_M32R
:
3282 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3283 strcat (buf
, ", m32r");
3287 case EM_MIPS_RS3_LE
:
3288 if (e_flags
& EF_MIPS_NOREORDER
)
3289 strcat (buf
, ", noreorder");
3291 if (e_flags
& EF_MIPS_PIC
)
3292 strcat (buf
, ", pic");
3294 if (e_flags
& EF_MIPS_CPIC
)
3295 strcat (buf
, ", cpic");
3297 if (e_flags
& EF_MIPS_UCODE
)
3298 strcat (buf
, ", ugen_reserved");
3300 if (e_flags
& EF_MIPS_ABI2
)
3301 strcat (buf
, ", abi2");
3303 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3304 strcat (buf
, ", odk first");
3306 if (e_flags
& EF_MIPS_32BITMODE
)
3307 strcat (buf
, ", 32bitmode");
3309 if (e_flags
& EF_MIPS_NAN2008
)
3310 strcat (buf
, ", nan2008");
3312 if (e_flags
& EF_MIPS_FP64
)
3313 strcat (buf
, ", fp64");
3315 switch ((e_flags
& EF_MIPS_MACH
))
3317 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3318 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3319 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3320 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3321 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3322 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3323 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3324 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3325 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3326 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3327 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3328 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3329 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3330 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3331 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3332 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3333 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3335 /* We simply ignore the field in this case to avoid confusion:
3336 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3339 default: strcat (buf
, _(", unknown CPU")); break;
3342 switch ((e_flags
& EF_MIPS_ABI
))
3344 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3345 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3346 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3347 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3349 /* We simply ignore the field in this case to avoid confusion:
3350 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3351 This means it is likely to be an o32 file, but not for
3354 default: strcat (buf
, _(", unknown ABI")); break;
3357 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3358 strcat (buf
, ", mdmx");
3360 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3361 strcat (buf
, ", mips16");
3363 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3364 strcat (buf
, ", micromips");
3366 switch ((e_flags
& EF_MIPS_ARCH
))
3368 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3369 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3370 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3371 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3372 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3373 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3374 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3375 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3376 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3377 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3378 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3379 default: strcat (buf
, _(", unknown ISA")); break;
3384 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3388 if (e_flags
& EF_RISCV_RVC
)
3389 strcat (buf
, ", RVC");
3391 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3393 case EF_RISCV_FLOAT_ABI_SOFT
:
3394 strcat (buf
, ", soft-float ABI");
3397 case EF_RISCV_FLOAT_ABI_SINGLE
:
3398 strcat (buf
, ", single-float ABI");
3401 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3402 strcat (buf
, ", double-float ABI");
3405 case EF_RISCV_FLOAT_ABI_QUAD
:
3406 strcat (buf
, ", quad-float ABI");
3412 switch ((e_flags
& EF_SH_MACH_MASK
))
3414 case EF_SH1
: strcat (buf
, ", sh1"); break;
3415 case EF_SH2
: strcat (buf
, ", sh2"); break;
3416 case EF_SH3
: strcat (buf
, ", sh3"); break;
3417 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3418 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3419 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3420 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3421 case EF_SH4
: strcat (buf
, ", sh4"); break;
3422 case EF_SH5
: strcat (buf
, ", sh5"); break;
3423 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3424 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3425 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3426 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3427 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3428 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3429 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3430 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3431 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3432 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3433 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3434 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3435 default: strcat (buf
, _(", unknown ISA")); break;
3438 if (e_flags
& EF_SH_PIC
)
3439 strcat (buf
, ", pic");
3441 if (e_flags
& EF_SH_FDPIC
)
3442 strcat (buf
, ", fdpic");
3446 if (e_flags
& EF_OR1K_NODELAY
)
3447 strcat (buf
, ", no delay");
3451 if (e_flags
& EF_SPARC_32PLUS
)
3452 strcat (buf
, ", v8+");
3454 if (e_flags
& EF_SPARC_SUN_US1
)
3455 strcat (buf
, ", ultrasparcI");
3457 if (e_flags
& EF_SPARC_SUN_US3
)
3458 strcat (buf
, ", ultrasparcIII");
3460 if (e_flags
& EF_SPARC_HAL_R1
)
3461 strcat (buf
, ", halr1");
3463 if (e_flags
& EF_SPARC_LEDATA
)
3464 strcat (buf
, ", ledata");
3466 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3467 strcat (buf
, ", tso");
3469 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3470 strcat (buf
, ", pso");
3472 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3473 strcat (buf
, ", rmo");
3477 switch (e_flags
& EF_PARISC_ARCH
)
3479 case EFA_PARISC_1_0
:
3480 strcpy (buf
, ", PA-RISC 1.0");
3482 case EFA_PARISC_1_1
:
3483 strcpy (buf
, ", PA-RISC 1.1");
3485 case EFA_PARISC_2_0
:
3486 strcpy (buf
, ", PA-RISC 2.0");
3491 if (e_flags
& EF_PARISC_TRAPNIL
)
3492 strcat (buf
, ", trapnil");
3493 if (e_flags
& EF_PARISC_EXT
)
3494 strcat (buf
, ", ext");
3495 if (e_flags
& EF_PARISC_LSB
)
3496 strcat (buf
, ", lsb");
3497 if (e_flags
& EF_PARISC_WIDE
)
3498 strcat (buf
, ", wide");
3499 if (e_flags
& EF_PARISC_NO_KABP
)
3500 strcat (buf
, ", no kabp");
3501 if (e_flags
& EF_PARISC_LAZYSWAP
)
3502 strcat (buf
, ", lazyswap");
3507 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3508 strcat (buf
, ", new calling convention");
3510 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3511 strcat (buf
, ", gnu calling convention");
3515 if ((e_flags
& EF_IA_64_ABI64
))
3516 strcat (buf
, ", 64-bit");
3518 strcat (buf
, ", 32-bit");
3519 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3520 strcat (buf
, ", reduced fp model");
3521 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3522 strcat (buf
, ", no function descriptors, constant gp");
3523 else if ((e_flags
& EF_IA_64_CONS_GP
))
3524 strcat (buf
, ", constant gp");
3525 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3526 strcat (buf
, ", absolute");
3527 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3529 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3530 strcat (buf
, ", vms_linkages");
3531 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3533 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3535 case EF_IA_64_VMS_COMCOD_WARNING
:
3536 strcat (buf
, ", warning");
3538 case EF_IA_64_VMS_COMCOD_ERROR
:
3539 strcat (buf
, ", error");
3541 case EF_IA_64_VMS_COMCOD_ABORT
:
3542 strcat (buf
, ", abort");
3545 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3546 e_flags
& EF_IA_64_VMS_COMCOD
);
3547 strcat (buf
, ", <unknown>");
3553 if ((e_flags
& EF_VAX_NONPIC
))
3554 strcat (buf
, ", non-PIC");
3555 if ((e_flags
& EF_VAX_DFLOAT
))
3556 strcat (buf
, ", D-Float");
3557 if ((e_flags
& EF_VAX_GFLOAT
))
3558 strcat (buf
, ", G-Float");
3562 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3563 strcat (buf
, ", mcm");
3564 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3565 strcat (buf
, ", mcm24");
3566 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3567 strcat (buf
, ", gr6");
3571 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3573 case E_FLAG_RL78_ANY_CPU
: break;
3574 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3575 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3576 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3578 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3579 strcat (buf
, ", 64-bit doubles");
3583 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3584 strcat (buf
, ", 64-bit doubles");
3585 if (e_flags
& E_FLAG_RX_DSP
)
3586 strcat (buf
, ", dsp");
3587 if (e_flags
& E_FLAG_RX_PID
)
3588 strcat (buf
, ", pid");
3589 if (e_flags
& E_FLAG_RX_ABI
)
3590 strcat (buf
, ", RX ABI");
3591 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3592 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3593 ? ", uses String instructions" : ", bans String instructions");
3594 if (e_flags
& E_FLAG_RX_V2
)
3595 strcat (buf
, ", V2");
3599 if (e_flags
& EF_S390_HIGH_GPRS
)
3600 strcat (buf
, ", highgprs");
3604 if ((e_flags
& EF_C6000_REL
))
3605 strcat (buf
, ", relocatable module");
3609 strcat (buf
, _(": architecture variant: "));
3610 switch (e_flags
& EF_MSP430_MACH
)
3612 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3613 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3614 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3615 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3616 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3617 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3618 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3619 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3620 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3621 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3622 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3623 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3624 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3625 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3626 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3628 strcat (buf
, _(": unknown")); break;
3631 if (e_flags
& ~ EF_MSP430_MACH
)
3632 strcat (buf
, _(": unknown extra flag bits also present"));
3640 get_osabi_name (unsigned int osabi
)
3642 static char buff
[32];
3646 case ELFOSABI_NONE
: return "UNIX - System V";
3647 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3648 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3649 case ELFOSABI_GNU
: return "UNIX - GNU";
3650 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3651 case ELFOSABI_AIX
: return "UNIX - AIX";
3652 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3653 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3654 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3655 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3656 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3657 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3658 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3659 case ELFOSABI_AROS
: return "AROS";
3660 case ELFOSABI_FENIXOS
: return "FenixOS";
3661 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3662 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3665 switch (elf_header
.e_machine
)
3670 case ELFOSABI_ARM
: return "ARM";
3681 case ELFOSABI_STANDALONE
: return _("Standalone App");
3690 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3691 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3700 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3706 get_aarch64_segment_type (unsigned long type
)
3710 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3711 default: return NULL
;
3716 get_arm_segment_type (unsigned long type
)
3720 case PT_ARM_EXIDX
: return "EXIDX";
3721 default: return NULL
;
3726 get_mips_segment_type (unsigned long type
)
3730 case PT_MIPS_REGINFO
: return "REGINFO";
3731 case PT_MIPS_RTPROC
: return "RTPROC";
3732 case PT_MIPS_OPTIONS
: return "OPTIONS";
3733 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3734 default: return NULL
;
3739 get_parisc_segment_type (unsigned long type
)
3743 case PT_HP_TLS
: return "HP_TLS";
3744 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3745 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3746 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3747 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3748 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3749 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3750 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3751 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3752 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3753 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3754 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3755 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3756 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3757 case PT_HP_STACK
: return "HP_STACK";
3758 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3759 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3760 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3761 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3762 default: return NULL
;
3767 get_ia64_segment_type (unsigned long type
)
3771 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3772 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3773 case PT_HP_TLS
: return "HP_TLS";
3774 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3775 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3776 case PT_IA_64_HP_STACK
: return "HP_STACK";
3777 default: return NULL
;
3782 get_tic6x_segment_type (unsigned long type
)
3786 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3787 default: return NULL
;
3792 get_solaris_segment_type (unsigned long type
)
3796 case 0x6464e550: return "PT_SUNW_UNWIND";
3797 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3798 case 0x6ffffff7: return "PT_LOSUNW";
3799 case 0x6ffffffa: return "PT_SUNWBSS";
3800 case 0x6ffffffb: return "PT_SUNWSTACK";
3801 case 0x6ffffffc: return "PT_SUNWDTRACE";
3802 case 0x6ffffffd: return "PT_SUNWCAP";
3803 case 0x6fffffff: return "PT_HISUNW";
3804 default: return NULL
;
3809 get_segment_type (unsigned long p_type
)
3811 static char buff
[32];
3815 case PT_NULL
: return "NULL";
3816 case PT_LOAD
: return "LOAD";
3817 case PT_DYNAMIC
: return "DYNAMIC";
3818 case PT_INTERP
: return "INTERP";
3819 case PT_NOTE
: return "NOTE";
3820 case PT_SHLIB
: return "SHLIB";
3821 case PT_PHDR
: return "PHDR";
3822 case PT_TLS
: return "TLS";
3823 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3824 case PT_GNU_STACK
: return "GNU_STACK";
3825 case PT_GNU_RELRO
: return "GNU_RELRO";
3828 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3830 sprintf (buff
, "GNU_MBIND+%#lx",
3831 p_type
- PT_GNU_MBIND_LO
);
3833 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3835 const char * result
;
3837 switch (elf_header
.e_machine
)
3840 result
= get_aarch64_segment_type (p_type
);
3843 result
= get_arm_segment_type (p_type
);
3846 case EM_MIPS_RS3_LE
:
3847 result
= get_mips_segment_type (p_type
);
3850 result
= get_parisc_segment_type (p_type
);
3853 result
= get_ia64_segment_type (p_type
);
3856 result
= get_tic6x_segment_type (p_type
);
3866 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3868 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3870 const char * result
;
3872 switch (elf_header
.e_machine
)
3875 result
= get_parisc_segment_type (p_type
);
3878 result
= get_ia64_segment_type (p_type
);
3881 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3882 result
= get_solaris_segment_type (p_type
);
3891 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3894 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3901 get_mips_section_type_name (unsigned int sh_type
)
3905 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3906 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3907 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3908 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3909 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3910 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3911 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3912 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3913 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3914 case SHT_MIPS_RELD
: return "MIPS_RELD";
3915 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3916 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3917 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3918 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3919 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3920 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3921 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3922 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3923 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3924 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3925 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3926 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3927 case SHT_MIPS_LINE
: return "MIPS_LINE";
3928 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3929 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3930 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3931 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3932 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3933 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3934 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3935 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3936 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3937 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3938 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3939 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3940 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3941 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3942 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3943 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3944 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3952 get_parisc_section_type_name (unsigned int sh_type
)
3956 case SHT_PARISC_EXT
: return "PARISC_EXT";
3957 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3958 case SHT_PARISC_DOC
: return "PARISC_DOC";
3959 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3960 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3961 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3962 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3963 default: return NULL
;
3968 get_ia64_section_type_name (unsigned int sh_type
)
3970 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3971 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3972 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3976 case SHT_IA_64_EXT
: return "IA_64_EXT";
3977 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3978 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3979 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3980 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3981 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3982 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3983 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3984 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3985 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3993 get_x86_64_section_type_name (unsigned int sh_type
)
3997 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3998 default: return NULL
;
4003 get_aarch64_section_type_name (unsigned int sh_type
)
4007 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4008 default: return NULL
;
4013 get_arm_section_type_name (unsigned int sh_type
)
4017 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4018 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4019 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4020 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4021 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4022 default: return NULL
;
4027 get_tic6x_section_type_name (unsigned int sh_type
)
4031 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4032 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4033 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4034 case SHT_TI_ICODE
: return "TI_ICODE";
4035 case SHT_TI_XREF
: return "TI_XREF";
4036 case SHT_TI_HANDLER
: return "TI_HANDLER";
4037 case SHT_TI_INITINFO
: return "TI_INITINFO";
4038 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4039 default: return NULL
;
4044 get_msp430x_section_type_name (unsigned int sh_type
)
4048 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4049 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4050 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4051 default: return NULL
;
4056 get_v850_section_type_name (unsigned int sh_type
)
4060 case SHT_V850_SCOMMON
: return "V850 Small Common";
4061 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4062 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4063 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4064 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4065 default: return NULL
;
4070 get_section_type_name (unsigned int sh_type
)
4072 static char buff
[32];
4073 const char * result
;
4077 case SHT_NULL
: return "NULL";
4078 case SHT_PROGBITS
: return "PROGBITS";
4079 case SHT_SYMTAB
: return "SYMTAB";
4080 case SHT_STRTAB
: return "STRTAB";
4081 case SHT_RELA
: return "RELA";
4082 case SHT_HASH
: return "HASH";
4083 case SHT_DYNAMIC
: return "DYNAMIC";
4084 case SHT_NOTE
: return "NOTE";
4085 case SHT_NOBITS
: return "NOBITS";
4086 case SHT_REL
: return "REL";
4087 case SHT_SHLIB
: return "SHLIB";
4088 case SHT_DYNSYM
: return "DYNSYM";
4089 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4090 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4091 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4092 case SHT_GNU_HASH
: return "GNU_HASH";
4093 case SHT_GROUP
: return "GROUP";
4094 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4095 case SHT_GNU_verdef
: return "VERDEF";
4096 case SHT_GNU_verneed
: return "VERNEED";
4097 case SHT_GNU_versym
: return "VERSYM";
4098 case 0x6ffffff0: return "VERSYM";
4099 case 0x6ffffffc: return "VERDEF";
4100 case 0x7ffffffd: return "AUXILIARY";
4101 case 0x7fffffff: return "FILTER";
4102 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4105 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4107 switch (elf_header
.e_machine
)
4110 case EM_MIPS_RS3_LE
:
4111 result
= get_mips_section_type_name (sh_type
);
4114 result
= get_parisc_section_type_name (sh_type
);
4117 result
= get_ia64_section_type_name (sh_type
);
4122 result
= get_x86_64_section_type_name (sh_type
);
4125 result
= get_aarch64_section_type_name (sh_type
);
4128 result
= get_arm_section_type_name (sh_type
);
4131 result
= get_tic6x_section_type_name (sh_type
);
4134 result
= get_msp430x_section_type_name (sh_type
);
4138 case EM_CYGNUS_V850
:
4139 result
= get_v850_section_type_name (sh_type
);
4149 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4151 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4153 switch (elf_header
.e_machine
)
4156 result
= get_ia64_section_type_name (sh_type
);
4159 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4160 result
= get_solaris_section_type (sh_type
);
4165 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4166 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4167 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4168 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4180 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4182 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4184 switch (elf_header
.e_machine
)
4188 case EM_CYGNUS_V850
:
4189 result
= get_v850_section_type_name (sh_type
);
4199 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4202 /* This message is probably going to be displayed in a 15
4203 character wide field, so put the hex value first. */
4204 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4210 #define OPTION_DEBUG_DUMP 512
4211 #define OPTION_DYN_SYMS 513
4212 #define OPTION_DWARF_DEPTH 514
4213 #define OPTION_DWARF_START 515
4214 #define OPTION_DWARF_CHECK 516
4216 static struct option options
[] =
4218 {"all", no_argument
, 0, 'a'},
4219 {"file-header", no_argument
, 0, 'h'},
4220 {"program-headers", no_argument
, 0, 'l'},
4221 {"headers", no_argument
, 0, 'e'},
4222 {"histogram", no_argument
, 0, 'I'},
4223 {"segments", no_argument
, 0, 'l'},
4224 {"sections", no_argument
, 0, 'S'},
4225 {"section-headers", no_argument
, 0, 'S'},
4226 {"section-groups", no_argument
, 0, 'g'},
4227 {"section-details", no_argument
, 0, 't'},
4228 {"full-section-name",no_argument
, 0, 'N'},
4229 {"symbols", no_argument
, 0, 's'},
4230 {"syms", no_argument
, 0, 's'},
4231 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4232 {"relocs", no_argument
, 0, 'r'},
4233 {"notes", no_argument
, 0, 'n'},
4234 {"dynamic", no_argument
, 0, 'd'},
4235 {"arch-specific", no_argument
, 0, 'A'},
4236 {"version-info", no_argument
, 0, 'V'},
4237 {"use-dynamic", no_argument
, 0, 'D'},
4238 {"unwind", no_argument
, 0, 'u'},
4239 {"archive-index", no_argument
, 0, 'c'},
4240 {"hex-dump", required_argument
, 0, 'x'},
4241 {"relocated-dump", required_argument
, 0, 'R'},
4242 {"string-dump", required_argument
, 0, 'p'},
4243 {"decompress", no_argument
, 0, 'z'},
4244 #ifdef SUPPORT_DISASSEMBLY
4245 {"instruction-dump", required_argument
, 0, 'i'},
4247 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4249 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4250 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4251 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4253 {"version", no_argument
, 0, 'v'},
4254 {"wide", no_argument
, 0, 'W'},
4255 {"help", no_argument
, 0, 'H'},
4256 {0, no_argument
, 0, 0}
4260 usage (FILE * stream
)
4262 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4263 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4264 fprintf (stream
, _(" Options are:\n\
4265 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4266 -h --file-header Display the ELF file header\n\
4267 -l --program-headers Display the program headers\n\
4268 --segments An alias for --program-headers\n\
4269 -S --section-headers Display the sections' header\n\
4270 --sections An alias for --section-headers\n\
4271 -g --section-groups Display the section groups\n\
4272 -t --section-details Display the section details\n\
4273 -e --headers Equivalent to: -h -l -S\n\
4274 -s --syms Display the symbol table\n\
4275 --symbols An alias for --syms\n\
4276 --dyn-syms Display the dynamic symbol table\n\
4277 -n --notes Display the core notes (if present)\n\
4278 -r --relocs Display the relocations (if present)\n\
4279 -u --unwind Display the unwind info (if present)\n\
4280 -d --dynamic Display the dynamic section (if present)\n\
4281 -V --version-info Display the version sections (if present)\n\
4282 -A --arch-specific Display architecture specific information (if any)\n\
4283 -c --archive-index Display the symbol/file index in an archive\n\
4284 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4285 -x --hex-dump=<number|name>\n\
4286 Dump the contents of section <number|name> as bytes\n\
4287 -p --string-dump=<number|name>\n\
4288 Dump the contents of section <number|name> as strings\n\
4289 -R --relocated-dump=<number|name>\n\
4290 Dump the contents of section <number|name> as relocated bytes\n\
4291 -z --decompress Decompress section before dumping it\n\
4292 -w[lLiaprmfFsoRt] or\n\
4293 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4294 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4295 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4297 Display the contents of DWARF2 debug sections\n"));
4298 fprintf (stream
, _("\
4299 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4300 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4302 #ifdef SUPPORT_DISASSEMBLY
4303 fprintf (stream
, _("\
4304 -i --instruction-dump=<number|name>\n\
4305 Disassemble the contents of section <number|name>\n"));
4307 fprintf (stream
, _("\
4308 -I --histogram Display histogram of bucket list lengths\n\
4309 -W --wide Allow output width to exceed 80 characters\n\
4310 @<file> Read options from <file>\n\
4311 -H --help Display this information\n\
4312 -v --version Display the version number of readelf\n"));
4314 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4315 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4317 exit (stream
== stdout
? 0 : 1);
4320 /* Record the fact that the user wants the contents of section number
4321 SECTION to be displayed using the method(s) encoded as flags bits
4322 in TYPE. Note, TYPE can be zero if we are creating the array for
4326 request_dump_bynumber (unsigned int section
, dump_type type
)
4328 if (section
>= num_dump_sects
)
4330 dump_type
* new_dump_sects
;
4332 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4333 sizeof (* dump_sects
));
4335 if (new_dump_sects
== NULL
)
4336 error (_("Out of memory allocating dump request table.\n"));
4341 /* Copy current flag settings. */
4342 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4347 dump_sects
= new_dump_sects
;
4348 num_dump_sects
= section
+ 1;
4353 dump_sects
[section
] |= type
;
4358 /* Request a dump by section name. */
4361 request_dump_byname (const char * section
, dump_type type
)
4363 struct dump_list_entry
* new_request
;
4365 new_request
= (struct dump_list_entry
*)
4366 malloc (sizeof (struct dump_list_entry
));
4368 error (_("Out of memory allocating dump request table.\n"));
4370 new_request
->name
= strdup (section
);
4371 if (!new_request
->name
)
4372 error (_("Out of memory allocating dump request table.\n"));
4374 new_request
->type
= type
;
4376 new_request
->next
= dump_sects_byname
;
4377 dump_sects_byname
= new_request
;
4381 request_dump (dump_type type
)
4387 section
= strtoul (optarg
, & cp
, 0);
4389 if (! *cp
&& section
>= 0)
4390 request_dump_bynumber (section
, type
);
4392 request_dump_byname (optarg
, type
);
4397 parse_args (int argc
, char ** argv
)
4404 while ((c
= getopt_long
4405 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4423 do_section_groups
= TRUE
;
4426 do_histogram
= TRUE
;
4431 do_section_groups
= TRUE
;
4436 do_section_details
= TRUE
;
4447 do_using_dynamic
= TRUE
;
4471 do_histogram
= TRUE
;
4477 do_archive_index
= TRUE
;
4480 request_dump (HEX_DUMP
);
4483 request_dump (STRING_DUMP
);
4486 request_dump (RELOC_DUMP
);
4489 decompress_dumps
= TRUE
;
4495 do_debugging
= TRUE
;
4496 dwarf_select_sections_all ();
4500 do_debugging
= FALSE
;
4501 dwarf_select_sections_by_letters (optarg
);
4504 case OPTION_DEBUG_DUMP
:
4507 do_debugging
= TRUE
;
4510 do_debugging
= FALSE
;
4511 dwarf_select_sections_by_names (optarg
);
4514 case OPTION_DWARF_DEPTH
:
4518 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4521 case OPTION_DWARF_START
:
4525 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4528 case OPTION_DWARF_CHECK
:
4531 case OPTION_DYN_SYMS
:
4534 #ifdef SUPPORT_DISASSEMBLY
4536 request_dump (DISASS_DUMP
);
4540 print_version (program_name
);
4549 /* xgettext:c-format */
4550 error (_("Invalid option '-%c'\n"), c
);
4557 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4558 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4559 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4560 && !do_section_groups
&& !do_archive_index
4566 get_elf_class (unsigned int elf_class
)
4568 static char buff
[32];
4572 case ELFCLASSNONE
: return _("none");
4573 case ELFCLASS32
: return "ELF32";
4574 case ELFCLASS64
: return "ELF64";
4576 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4582 get_data_encoding (unsigned int encoding
)
4584 static char buff
[32];
4588 case ELFDATANONE
: return _("none");
4589 case ELFDATA2LSB
: return _("2's complement, little endian");
4590 case ELFDATA2MSB
: return _("2's complement, big endian");
4592 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4597 /* Decode the data held in 'elf_header'. */
4600 process_file_header (void)
4602 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4603 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4604 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4605 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4608 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4612 init_dwarf_regnames (elf_header
.e_machine
);
4618 printf (_("ELF Header:\n"));
4619 printf (_(" Magic: "));
4620 for (i
= 0; i
< EI_NIDENT
; i
++)
4621 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4623 printf (_(" Class: %s\n"),
4624 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4625 printf (_(" Data: %s\n"),
4626 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4627 printf (_(" Version: %d %s\n"),
4628 elf_header
.e_ident
[EI_VERSION
],
4629 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4631 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4632 ? _("<unknown: %lx>")
4634 printf (_(" OS/ABI: %s\n"),
4635 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4636 printf (_(" ABI Version: %d\n"),
4637 elf_header
.e_ident
[EI_ABIVERSION
]);
4638 printf (_(" Type: %s\n"),
4639 get_file_type (elf_header
.e_type
));
4640 printf (_(" Machine: %s\n"),
4641 get_machine_name (elf_header
.e_machine
));
4642 printf (_(" Version: 0x%lx\n"),
4643 (unsigned long) elf_header
.e_version
);
4645 printf (_(" Entry point address: "));
4646 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4647 printf (_("\n Start of program headers: "));
4648 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4649 printf (_(" (bytes into file)\n Start of section headers: "));
4650 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4651 printf (_(" (bytes into file)\n"));
4653 printf (_(" Flags: 0x%lx%s\n"),
4654 (unsigned long) elf_header
.e_flags
,
4655 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4656 printf (_(" Size of this header: %ld (bytes)\n"),
4657 (long) elf_header
.e_ehsize
);
4658 printf (_(" Size of program headers: %ld (bytes)\n"),
4659 (long) elf_header
.e_phentsize
);
4660 printf (_(" Number of program headers: %ld"),
4661 (long) elf_header
.e_phnum
);
4662 if (section_headers
!= NULL
4663 && elf_header
.e_phnum
== PN_XNUM
4664 && section_headers
[0].sh_info
!= 0)
4665 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4666 putc ('\n', stdout
);
4667 printf (_(" Size of section headers: %ld (bytes)\n"),
4668 (long) elf_header
.e_shentsize
);
4669 printf (_(" Number of section headers: %ld"),
4670 (long) elf_header
.e_shnum
);
4671 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4672 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4673 putc ('\n', stdout
);
4674 printf (_(" Section header string table index: %ld"),
4675 (long) elf_header
.e_shstrndx
);
4676 if (section_headers
!= NULL
4677 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4678 printf (" (%u)", section_headers
[0].sh_link
);
4679 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4680 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4681 printf (_(" <corrupt: out of range>"));
4682 putc ('\n', stdout
);
4685 if (section_headers
!= NULL
)
4687 if (elf_header
.e_phnum
== PN_XNUM
4688 && section_headers
[0].sh_info
!= 0)
4689 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4690 if (elf_header
.e_shnum
== SHN_UNDEF
)
4691 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4692 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4693 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4694 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4695 elf_header
.e_shstrndx
= SHN_UNDEF
;
4696 free (section_headers
);
4697 section_headers
= NULL
;
4704 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4706 Elf32_External_Phdr
* phdrs
;
4707 Elf32_External_Phdr
* external
;
4708 Elf_Internal_Phdr
* internal
;
4710 unsigned int size
= elf_header
.e_phentsize
;
4711 unsigned int num
= elf_header
.e_phnum
;
4713 /* PR binutils/17531: Cope with unexpected section header sizes. */
4714 if (size
== 0 || num
== 0)
4716 if (size
< sizeof * phdrs
)
4718 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4721 if (size
> sizeof * phdrs
)
4722 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4724 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4725 size
, num
, _("program headers"));
4729 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4730 i
< elf_header
.e_phnum
;
4731 i
++, internal
++, external
++)
4733 internal
->p_type
= BYTE_GET (external
->p_type
);
4734 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4735 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4736 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4737 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4738 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4739 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4740 internal
->p_align
= BYTE_GET (external
->p_align
);
4748 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4750 Elf64_External_Phdr
* phdrs
;
4751 Elf64_External_Phdr
* external
;
4752 Elf_Internal_Phdr
* internal
;
4754 unsigned int size
= elf_header
.e_phentsize
;
4755 unsigned int num
= elf_header
.e_phnum
;
4757 /* PR binutils/17531: Cope with unexpected section header sizes. */
4758 if (size
== 0 || num
== 0)
4760 if (size
< sizeof * phdrs
)
4762 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4765 if (size
> sizeof * phdrs
)
4766 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4768 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4769 size
, num
, _("program headers"));
4773 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4774 i
< elf_header
.e_phnum
;
4775 i
++, internal
++, external
++)
4777 internal
->p_type
= BYTE_GET (external
->p_type
);
4778 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4779 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4780 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4781 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4782 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4783 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4784 internal
->p_align
= BYTE_GET (external
->p_align
);
4791 /* Returns TRUE if the program headers were read into `program_headers'. */
4794 get_program_headers (FILE * file
)
4796 Elf_Internal_Phdr
* phdrs
;
4798 /* Check cache of prior read. */
4799 if (program_headers
!= NULL
)
4802 /* Be kind to memory checkers by looking for
4803 e_phnum values which we know must be invalid. */
4804 if (elf_header
.e_phnum
4805 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4806 >= current_file_size
)
4808 error (_("Too many program headers - %#x - the file is not that big\n"),
4809 elf_header
.e_phnum
);
4813 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4814 sizeof (Elf_Internal_Phdr
));
4817 error (_("Out of memory reading %u program headers\n"),
4818 elf_header
.e_phnum
);
4823 ? get_32bit_program_headers (file
, phdrs
)
4824 : get_64bit_program_headers (file
, phdrs
))
4826 program_headers
= phdrs
;
4834 /* Returns TRUE if the program headers were loaded. */
4837 process_program_headers (FILE * file
)
4839 Elf_Internal_Phdr
* segment
;
4841 Elf_Internal_Phdr
* previous_load
= NULL
;
4843 if (elf_header
.e_phnum
== 0)
4845 /* PR binutils/12467. */
4846 if (elf_header
.e_phoff
!= 0)
4848 warn (_("possibly corrupt ELF header - it has a non-zero program"
4849 " header offset, but no program headers\n"));
4852 else if (do_segments
)
4853 printf (_("\nThere are no program headers in this file.\n"));
4857 if (do_segments
&& !do_header
)
4859 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4860 printf (_("Entry point "));
4861 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4862 printf (_("\nThere are %d program headers, starting at offset "),
4863 elf_header
.e_phnum
);
4864 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4868 if (! get_program_headers (file
))
4873 if (elf_header
.e_phnum
> 1)
4874 printf (_("\nProgram Headers:\n"));
4876 printf (_("\nProgram Headers:\n"));
4880 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4883 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4887 (_(" Type Offset VirtAddr PhysAddr\n"));
4889 (_(" FileSiz MemSiz Flags Align\n"));
4896 for (i
= 0, segment
= program_headers
;
4897 i
< elf_header
.e_phnum
;
4902 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4906 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4907 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4908 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4909 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4910 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4912 (segment
->p_flags
& PF_R
? 'R' : ' '),
4913 (segment
->p_flags
& PF_W
? 'W' : ' '),
4914 (segment
->p_flags
& PF_X
? 'E' : ' '));
4915 printf ("%#lx", (unsigned long) segment
->p_align
);
4919 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4920 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4923 print_vma (segment
->p_offset
, FULL_HEX
);
4927 print_vma (segment
->p_vaddr
, FULL_HEX
);
4929 print_vma (segment
->p_paddr
, FULL_HEX
);
4932 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4933 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4936 print_vma (segment
->p_filesz
, FULL_HEX
);
4940 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4941 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4944 print_vma (segment
->p_memsz
, FULL_HEX
);
4948 (segment
->p_flags
& PF_R
? 'R' : ' '),
4949 (segment
->p_flags
& PF_W
? 'W' : ' '),
4950 (segment
->p_flags
& PF_X
? 'E' : ' '));
4952 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4953 printf ("%#lx", (unsigned long) segment
->p_align
);
4956 print_vma (segment
->p_align
, PREFIX_HEX
);
4961 print_vma (segment
->p_offset
, FULL_HEX
);
4963 print_vma (segment
->p_vaddr
, FULL_HEX
);
4965 print_vma (segment
->p_paddr
, FULL_HEX
);
4967 print_vma (segment
->p_filesz
, FULL_HEX
);
4969 print_vma (segment
->p_memsz
, FULL_HEX
);
4971 (segment
->p_flags
& PF_R
? 'R' : ' '),
4972 (segment
->p_flags
& PF_W
? 'W' : ' '),
4973 (segment
->p_flags
& PF_X
? 'E' : ' '));
4974 print_vma (segment
->p_align
, PREFIX_HEX
);
4977 putc ('\n', stdout
);
4980 switch (segment
->p_type
)
4983 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4984 required by the ELF standard, several programs, including the Linux
4985 kernel, make use of non-ordered segments. */
4987 && previous_load
->p_vaddr
> segment
->p_vaddr
)
4988 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4990 if (segment
->p_memsz
< segment
->p_filesz
)
4991 error (_("the segment's file size is larger than its memory size\n"));
4992 previous_load
= segment
;
4996 /* PR 20815 - Verify that the program header is loaded into memory. */
4997 if (i
> 0 && previous_load
!= NULL
)
4998 error (_("the PHDR segment must occur before any LOAD segment\n"));
4999 if (elf_header
.e_machine
!= EM_PARISC
)
5003 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
5004 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5005 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
5006 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5008 if (j
== elf_header
.e_phnum
)
5009 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5015 error (_("more than one dynamic segment\n"));
5017 /* By default, assume that the .dynamic section is the first
5018 section in the DYNAMIC segment. */
5019 dynamic_addr
= segment
->p_offset
;
5020 dynamic_size
= segment
->p_filesz
;
5022 /* Try to locate the .dynamic section. If there is
5023 a section header table, we can easily locate it. */
5024 if (section_headers
!= NULL
)
5026 Elf_Internal_Shdr
* sec
;
5028 sec
= find_section (".dynamic");
5029 if (sec
== NULL
|| sec
->sh_size
== 0)
5031 /* A corresponding .dynamic section is expected, but on
5032 IA-64/OpenVMS it is OK for it to be missing. */
5033 if (!is_ia64_vms ())
5034 error (_("no .dynamic section in the dynamic segment\n"));
5038 if (sec
->sh_type
== SHT_NOBITS
)
5044 dynamic_addr
= sec
->sh_offset
;
5045 dynamic_size
= sec
->sh_size
;
5047 if (dynamic_addr
< segment
->p_offset
5048 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5049 warn (_("the .dynamic section is not contained"
5050 " within the dynamic segment\n"));
5051 else if (dynamic_addr
> segment
->p_offset
)
5052 warn (_("the .dynamic section is not the first section"
5053 " in the dynamic segment.\n"));
5056 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5057 segment. Check this after matching against the section headers
5058 so we don't warn on debuginfo file (which have NOBITS .dynamic
5060 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5062 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5063 dynamic_addr
= dynamic_size
= 0;
5068 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5070 error (_("Unable to find program interpreter name\n"));
5074 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5076 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5077 error (_("Internal error: failed to create format string to display program interpreter\n"));
5079 program_interpreter
[0] = 0;
5080 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5081 error (_("Unable to read program interpreter name\n"));
5084 printf (_(" [Requesting program interpreter: %s]\n"),
5085 program_interpreter
);
5091 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5093 printf (_("\n Section to Segment mapping:\n"));
5094 printf (_(" Segment Sections...\n"));
5096 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5099 Elf_Internal_Shdr
* section
;
5101 segment
= program_headers
+ i
;
5102 section
= section_headers
+ 1;
5104 printf (" %2.2d ", i
);
5106 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5108 if (!ELF_TBSS_SPECIAL (section
, segment
)
5109 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5110 printf ("%s ", printable_section_name (section
));
5121 /* Find the file offset corresponding to VMA by using the program headers. */
5124 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5126 Elf_Internal_Phdr
* seg
;
5128 if (! get_program_headers (file
))
5130 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5134 for (seg
= program_headers
;
5135 seg
< program_headers
+ elf_header
.e_phnum
;
5138 if (seg
->p_type
!= PT_LOAD
)
5141 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5142 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5143 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5146 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5147 (unsigned long) vma
);
5152 /* Allocate memory and load the sections headers into the global pointer
5153 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5154 generate any error messages if the load fails. */
5157 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5159 Elf32_External_Shdr
* shdrs
;
5160 Elf_Internal_Shdr
* internal
;
5162 unsigned int size
= elf_header
.e_shentsize
;
5163 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5165 /* PR binutils/17531: Cope with unexpected section header sizes. */
5166 if (size
== 0 || num
== 0)
5168 if (size
< sizeof * shdrs
)
5171 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5174 if (!probe
&& size
> sizeof * shdrs
)
5175 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5177 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5179 probe
? NULL
: _("section headers"));
5183 if (section_headers
!= NULL
)
5184 free (section_headers
);
5185 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5186 sizeof (Elf_Internal_Shdr
));
5187 if (section_headers
== NULL
)
5190 error (_("Out of memory reading %u section headers\n"), num
);
5194 for (i
= 0, internal
= section_headers
;
5198 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5199 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5200 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5201 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5202 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5203 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5204 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5205 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5206 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5207 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5208 if (!probe
&& internal
->sh_link
> num
)
5209 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5210 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5211 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5219 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5221 Elf64_External_Shdr
* shdrs
;
5222 Elf_Internal_Shdr
* internal
;
5224 unsigned int size
= elf_header
.e_shentsize
;
5225 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5227 /* PR binutils/17531: Cope with unexpected section header sizes. */
5228 if (size
== 0 || num
== 0)
5230 if (size
< sizeof * shdrs
)
5233 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5236 if (! probe
&& size
> sizeof * shdrs
)
5237 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5239 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5241 probe
? NULL
: _("section headers"));
5245 if (section_headers
!= NULL
)
5246 free (section_headers
);
5247 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5248 sizeof (Elf_Internal_Shdr
));
5249 if (section_headers
== NULL
)
5252 error (_("Out of memory reading %u section headers\n"), num
);
5256 for (i
= 0, internal
= section_headers
;
5260 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5261 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5262 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5263 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5264 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5265 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5266 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5267 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5268 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5269 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5270 if (!probe
&& internal
->sh_link
> num
)
5271 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5272 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5273 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5280 static Elf_Internal_Sym
*
5281 get_32bit_elf_symbols (FILE * file
,
5282 Elf_Internal_Shdr
* section
,
5283 unsigned long * num_syms_return
)
5285 unsigned long number
= 0;
5286 Elf32_External_Sym
* esyms
= NULL
;
5287 Elf_External_Sym_Shndx
* shndx
= NULL
;
5288 Elf_Internal_Sym
* isyms
= NULL
;
5289 Elf_Internal_Sym
* psym
;
5292 if (section
->sh_size
== 0)
5294 if (num_syms_return
!= NULL
)
5295 * num_syms_return
= 0;
5299 /* Run some sanity checks first. */
5300 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5302 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5303 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5307 if (section
->sh_size
> current_file_size
)
5309 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5310 printable_section_name (section
), (unsigned long) section
->sh_size
);
5314 number
= section
->sh_size
/ section
->sh_entsize
;
5316 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5318 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5319 (unsigned long) section
->sh_size
,
5320 printable_section_name (section
),
5321 (unsigned long) section
->sh_entsize
);
5325 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5326 section
->sh_size
, _("symbols"));
5331 elf_section_list
* entry
;
5334 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5335 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5337 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5338 entry
->hdr
->sh_offset
,
5339 1, entry
->hdr
->sh_size
,
5340 _("symbol table section indicies"));
5343 /* PR17531: file: heap-buffer-overflow */
5344 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5346 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5347 printable_section_name (entry
->hdr
),
5348 (unsigned long) entry
->hdr
->sh_size
,
5349 (unsigned long) section
->sh_size
);
5355 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5359 error (_("Out of memory reading %lu symbols\n"),
5360 (unsigned long) number
);
5364 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5366 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5367 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5368 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5369 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5370 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5372 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5373 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5374 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5375 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5376 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5385 if (num_syms_return
!= NULL
)
5386 * num_syms_return
= isyms
== NULL
? 0 : number
;
5391 static Elf_Internal_Sym
*
5392 get_64bit_elf_symbols (FILE * file
,
5393 Elf_Internal_Shdr
* section
,
5394 unsigned long * num_syms_return
)
5396 unsigned long number
= 0;
5397 Elf64_External_Sym
* esyms
= NULL
;
5398 Elf_External_Sym_Shndx
* shndx
= NULL
;
5399 Elf_Internal_Sym
* isyms
= NULL
;
5400 Elf_Internal_Sym
* psym
;
5403 if (section
->sh_size
== 0)
5405 if (num_syms_return
!= NULL
)
5406 * num_syms_return
= 0;
5410 /* Run some sanity checks first. */
5411 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5413 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5414 printable_section_name (section
),
5415 (unsigned long) section
->sh_entsize
);
5419 if (section
->sh_size
> current_file_size
)
5421 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5422 printable_section_name (section
),
5423 (unsigned long) section
->sh_size
);
5427 number
= section
->sh_size
/ section
->sh_entsize
;
5429 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5431 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5432 (unsigned long) section
->sh_size
,
5433 printable_section_name (section
),
5434 (unsigned long) section
->sh_entsize
);
5438 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5439 section
->sh_size
, _("symbols"));
5444 elf_section_list
* entry
;
5447 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5448 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5450 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5451 entry
->hdr
->sh_offset
,
5452 1, entry
->hdr
->sh_size
,
5453 _("symbol table section indicies"));
5456 /* PR17531: file: heap-buffer-overflow */
5457 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5459 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5460 printable_section_name (entry
->hdr
),
5461 (unsigned long) entry
->hdr
->sh_size
,
5462 (unsigned long) section
->sh_size
);
5468 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5472 error (_("Out of memory reading %lu symbols\n"),
5473 (unsigned long) number
);
5477 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5479 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5480 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5481 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5482 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5484 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5486 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5487 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5488 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5490 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5491 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5500 if (num_syms_return
!= NULL
)
5501 * num_syms_return
= isyms
== NULL
? 0 : number
;
5507 get_elf_section_flags (bfd_vma sh_flags
)
5509 static char buff
[1024];
5511 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5513 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5514 bfd_vma os_flags
= 0;
5515 bfd_vma proc_flags
= 0;
5516 bfd_vma unknown_flags
= 0;
5524 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5525 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5526 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5527 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5528 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5529 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5530 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5531 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5532 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5533 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5534 /* IA-64 specific. */
5535 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5536 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5537 /* IA-64 OpenVMS specific. */
5538 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5539 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5540 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5541 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5542 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5543 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5545 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5546 /* SPARC specific. */
5547 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5548 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5550 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5551 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5552 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5554 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5557 if (do_section_details
)
5559 sprintf (buff
, "[%*.*lx]: ",
5560 field_size
, field_size
, (unsigned long) sh_flags
);
5561 p
+= field_size
+ 4;
5568 flag
= sh_flags
& - sh_flags
;
5571 if (do_section_details
)
5575 case SHF_WRITE
: sindex
= 0; break;
5576 case SHF_ALLOC
: sindex
= 1; break;
5577 case SHF_EXECINSTR
: sindex
= 2; break;
5578 case SHF_MERGE
: sindex
= 3; break;
5579 case SHF_STRINGS
: sindex
= 4; break;
5580 case SHF_INFO_LINK
: sindex
= 5; break;
5581 case SHF_LINK_ORDER
: sindex
= 6; break;
5582 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5583 case SHF_GROUP
: sindex
= 8; break;
5584 case SHF_TLS
: sindex
= 9; break;
5585 case SHF_EXCLUDE
: sindex
= 18; break;
5586 case SHF_COMPRESSED
: sindex
= 20; break;
5587 case SHF_GNU_MBIND
: sindex
= 24; break;
5591 switch (elf_header
.e_machine
)
5594 if (flag
== SHF_IA_64_SHORT
)
5596 else if (flag
== SHF_IA_64_NORECOV
)
5599 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5602 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5603 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5604 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5605 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5606 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5607 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5618 case EM_OLD_SPARCV9
:
5619 case EM_SPARC32PLUS
:
5622 if (flag
== SHF_ORDERED
)
5629 case SHF_ENTRYSECT
: sindex
= 21; break;
5630 case SHF_ARM_PURECODE
: sindex
= 22; break;
5631 case SHF_COMDEF
: sindex
= 23; break;
5643 if (p
!= buff
+ field_size
+ 4)
5645 if (size
< (10 + 2))
5647 warn (_("Internal error: not enough buffer room for section flag info"));
5648 return _("<unknown>");
5655 size
-= flags
[sindex
].len
;
5656 p
= stpcpy (p
, flags
[sindex
].str
);
5658 else if (flag
& SHF_MASKOS
)
5660 else if (flag
& SHF_MASKPROC
)
5663 unknown_flags
|= flag
;
5669 case SHF_WRITE
: *p
= 'W'; break;
5670 case SHF_ALLOC
: *p
= 'A'; break;
5671 case SHF_EXECINSTR
: *p
= 'X'; break;
5672 case SHF_MERGE
: *p
= 'M'; break;
5673 case SHF_STRINGS
: *p
= 'S'; break;
5674 case SHF_INFO_LINK
: *p
= 'I'; break;
5675 case SHF_LINK_ORDER
: *p
= 'L'; break;
5676 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5677 case SHF_GROUP
: *p
= 'G'; break;
5678 case SHF_TLS
: *p
= 'T'; break;
5679 case SHF_EXCLUDE
: *p
= 'E'; break;
5680 case SHF_COMPRESSED
: *p
= 'C'; break;
5681 case SHF_GNU_MBIND
: *p
= 'D'; break;
5684 if ((elf_header
.e_machine
== EM_X86_64
5685 || elf_header
.e_machine
== EM_L1OM
5686 || elf_header
.e_machine
== EM_K1OM
)
5687 && flag
== SHF_X86_64_LARGE
)
5689 else if (elf_header
.e_machine
== EM_ARM
5690 && flag
== SHF_ARM_PURECODE
)
5692 else if (flag
& SHF_MASKOS
)
5695 sh_flags
&= ~ SHF_MASKOS
;
5697 else if (flag
& SHF_MASKPROC
)
5700 sh_flags
&= ~ SHF_MASKPROC
;
5710 if (do_section_details
)
5714 size
-= 5 + field_size
;
5715 if (p
!= buff
+ field_size
+ 4)
5719 warn (_("Internal error: not enough buffer room for section flag info"));
5720 return _("<unknown>");
5726 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5727 (unsigned long) os_flags
);
5728 p
+= 5 + field_size
;
5732 size
-= 7 + field_size
;
5733 if (p
!= buff
+ field_size
+ 4)
5737 warn (_("Internal error: not enough buffer room for section flag info"));
5738 return _("<unknown>");
5744 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5745 (unsigned long) proc_flags
);
5746 p
+= 7 + field_size
;
5750 size
-= 10 + field_size
;
5751 if (p
!= buff
+ field_size
+ 4)
5755 warn (_("Internal error: not enough buffer room for section flag info"));
5756 return _("<unknown>");
5762 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5763 (unsigned long) unknown_flags
);
5764 p
+= 10 + field_size
;
5773 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5777 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5779 if (size
< sizeof (* echdr
))
5781 error (_("Compressed section is too small even for a compression header\n"));
5785 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5786 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5787 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5788 return sizeof (*echdr
);
5792 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5794 if (size
< sizeof (* echdr
))
5796 error (_("Compressed section is too small even for a compression header\n"));
5800 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5801 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5802 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5803 return sizeof (*echdr
);
5808 process_section_headers (FILE * file
)
5810 Elf_Internal_Shdr
* section
;
5813 section_headers
= NULL
;
5815 if (elf_header
.e_shnum
== 0)
5817 /* PR binutils/12467. */
5818 if (elf_header
.e_shoff
!= 0)
5820 warn (_("possibly corrupt ELF file header - it has a non-zero"
5821 " section header offset, but no section headers\n"));
5824 else if (do_sections
)
5825 printf (_("\nThere are no sections in this file.\n"));
5830 if (do_sections
&& !do_header
)
5831 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5832 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5836 if (! get_32bit_section_headers (file
, FALSE
))
5841 if (! get_64bit_section_headers (file
, FALSE
))
5845 /* Read in the string table, so that we have names to display. */
5846 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5847 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5849 section
= section_headers
+ elf_header
.e_shstrndx
;
5851 if (section
->sh_size
!= 0)
5853 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5854 1, section
->sh_size
,
5857 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5861 /* Scan the sections for the dynamic symbol table
5862 and dynamic string table and debug sections. */
5863 dynamic_symbols
= NULL
;
5864 dynamic_strings
= NULL
;
5865 dynamic_syminfo
= NULL
;
5866 symtab_shndx_list
= NULL
;
5868 eh_addr_size
= is_32bit_elf
? 4 : 8;
5869 switch (elf_header
.e_machine
)
5872 case EM_MIPS_RS3_LE
:
5873 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5874 FDE addresses. However, the ABI also has a semi-official ILP32
5875 variant for which the normal FDE address size rules apply.
5877 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5878 section, where XX is the size of longs in bits. Unfortunately,
5879 earlier compilers provided no way of distinguishing ILP32 objects
5880 from LP64 objects, so if there's any doubt, we should assume that
5881 the official LP64 form is being used. */
5882 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5883 && find_section (".gcc_compiled_long32") == NULL
)
5889 switch (elf_header
.e_flags
& EF_H8_MACH
)
5891 case E_H8_MACH_H8300
:
5892 case E_H8_MACH_H8300HN
:
5893 case E_H8_MACH_H8300SN
:
5894 case E_H8_MACH_H8300SXN
:
5897 case E_H8_MACH_H8300H
:
5898 case E_H8_MACH_H8300S
:
5899 case E_H8_MACH_H8300SX
:
5907 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5909 case EF_M32C_CPU_M16C
:
5916 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5919 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5920 if (section->sh_entsize != expected_entsize) \
5923 sprintf_vma (buf, section->sh_entsize); \
5924 /* Note: coded this way so that there is a single string for \
5926 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5927 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5928 (unsigned) expected_entsize); \
5929 section->sh_entsize = expected_entsize; \
5934 #define CHECK_ENTSIZE(section, i, type) \
5935 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5936 sizeof (Elf64_External_##type))
5938 for (i
= 0, section
= section_headers
;
5939 i
< elf_header
.e_shnum
;
5942 char * name
= SECTION_NAME (section
);
5944 if (section
->sh_type
== SHT_DYNSYM
)
5946 if (dynamic_symbols
!= NULL
)
5948 error (_("File contains multiple dynamic symbol tables\n"));
5952 CHECK_ENTSIZE (section
, i
, Sym
);
5953 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5955 else if (section
->sh_type
== SHT_STRTAB
5956 && streq (name
, ".dynstr"))
5958 if (dynamic_strings
!= NULL
)
5960 error (_("File contains multiple dynamic string tables\n"));
5964 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5965 1, section
->sh_size
,
5966 _("dynamic strings"));
5967 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5969 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5971 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5972 entry
->hdr
= section
;
5973 entry
->next
= symtab_shndx_list
;
5974 symtab_shndx_list
= entry
;
5976 else if (section
->sh_type
== SHT_SYMTAB
)
5977 CHECK_ENTSIZE (section
, i
, Sym
);
5978 else if (section
->sh_type
== SHT_GROUP
)
5979 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5980 else if (section
->sh_type
== SHT_REL
)
5981 CHECK_ENTSIZE (section
, i
, Rel
);
5982 else if (section
->sh_type
== SHT_RELA
)
5983 CHECK_ENTSIZE (section
, i
, Rela
);
5984 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5985 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5986 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5987 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5988 || do_debug_addr
|| do_debug_cu_index
)
5989 && (const_strneq (name
, ".debug_")
5990 || const_strneq (name
, ".zdebug_")))
5993 name
+= sizeof (".zdebug_") - 1;
5995 name
+= sizeof (".debug_") - 1;
5998 || (do_debug_info
&& const_strneq (name
, "info"))
5999 || (do_debug_info
&& const_strneq (name
, "types"))
6000 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6001 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6002 || (do_debug_lines
&& const_strneq (name
, "line."))
6003 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6004 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6005 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6006 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6007 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6008 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6009 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6010 || (do_debug_frames
&& const_strneq (name
, "frame"))
6011 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6012 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6013 || (do_debug_str
&& const_strneq (name
, "str"))
6014 || (do_debug_loc
&& const_strneq (name
, "loc"))
6015 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6016 || (do_debug_addr
&& const_strneq (name
, "addr"))
6017 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6018 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6020 request_dump_bynumber (i
, DEBUG_DUMP
);
6022 /* Linkonce section to be combined with .debug_info at link time. */
6023 else if ((do_debugging
|| do_debug_info
)
6024 && const_strneq (name
, ".gnu.linkonce.wi."))
6025 request_dump_bynumber (i
, DEBUG_DUMP
);
6026 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6027 request_dump_bynumber (i
, DEBUG_DUMP
);
6028 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
6029 request_dump_bynumber (i
, DEBUG_DUMP
);
6030 /* Trace sections for Itanium VMS. */
6031 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6032 || do_trace_aranges
)
6033 && const_strneq (name
, ".trace_"))
6035 name
+= sizeof (".trace_") - 1;
6038 || (do_trace_info
&& streq (name
, "info"))
6039 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6040 || (do_trace_aranges
&& streq (name
, "aranges"))
6042 request_dump_bynumber (i
, DEBUG_DUMP
);
6049 if (elf_header
.e_shnum
> 1)
6050 printf (_("\nSection Headers:\n"));
6052 printf (_("\nSection Header:\n"));
6056 if (do_section_details
)
6058 printf (_(" [Nr] Name\n"));
6059 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6063 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6067 if (do_section_details
)
6069 printf (_(" [Nr] Name\n"));
6070 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6074 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6078 if (do_section_details
)
6080 printf (_(" [Nr] Name\n"));
6081 printf (_(" Type Address Offset Link\n"));
6082 printf (_(" Size EntSize Info Align\n"));
6086 printf (_(" [Nr] Name Type Address Offset\n"));
6087 printf (_(" Size EntSize Flags Link Info Align\n"));
6091 if (do_section_details
)
6092 printf (_(" Flags\n"));
6094 for (i
= 0, section
= section_headers
;
6095 i
< elf_header
.e_shnum
;
6098 /* Run some sanity checks on the section header. */
6100 /* Check the sh_link field. */
6101 switch (section
->sh_type
)
6103 case SHT_SYMTAB_SHNDX
:
6107 case SHT_GNU_versym
:
6110 if (section
->sh_link
< 1
6111 || section
->sh_link
>= elf_header
.e_shnum
6112 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6113 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6114 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6115 i
, section
->sh_link
);
6121 case SHT_GNU_verneed
:
6122 case SHT_GNU_verdef
:
6123 case SHT_GNU_LIBLIST
:
6124 if (section
->sh_link
< 1
6125 || section
->sh_link
>= elf_header
.e_shnum
6126 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6127 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6128 i
, section
->sh_link
);
6131 case SHT_INIT_ARRAY
:
6132 case SHT_FINI_ARRAY
:
6133 case SHT_PREINIT_ARRAY
:
6134 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6135 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6136 i
, section
->sh_link
);
6140 /* FIXME: Add support for target specific section types. */
6141 #if 0 /* Currently we do not check other section types as there are too
6142 many special cases. Stab sections for example have a type
6143 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6145 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6146 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6147 i
, section
->sh_link
);
6152 /* Check the sh_info field. */
6153 switch (section
->sh_type
)
6157 if (section
->sh_info
< 1
6158 || section
->sh_info
>= elf_header
.e_shnum
6159 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6160 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6161 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6162 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6163 /* FIXME: Are other section types valid ? */
6164 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6166 if (section
->sh_info
== 0
6167 && (streq (SECTION_NAME (section
), ".rel.dyn")
6168 || streq (SECTION_NAME (section
), ".rela.dyn")))
6169 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6170 of zero. The relocations in these sections may apply
6171 to many different sections. */
6174 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6175 i
, section
->sh_info
);
6181 case SHT_SYMTAB_SHNDX
:
6182 case SHT_INIT_ARRAY
:
6183 case SHT_FINI_ARRAY
:
6184 case SHT_PREINIT_ARRAY
:
6185 if (section
->sh_info
!= 0)
6186 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6187 i
, section
->sh_info
);
6193 /* A symbol index - we assume that it is valid. */
6197 /* FIXME: Add support for target specific section types. */
6198 if (section
->sh_type
== SHT_NOBITS
)
6199 /* NOBITS section headers with non-zero sh_info fields can be
6200 created when a binary is stripped of everything but its debug
6201 information. The stripped sections have their headers
6202 preserved but their types set to SHT_NOBITS. So do not check
6203 this type of section. */
6205 else if (section
->sh_flags
& SHF_INFO_LINK
)
6207 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6208 warn (_("[%2u]: Expected link to another section in info field"), i
);
6210 else if (section
->sh_type
< SHT_LOOS
6211 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6212 && section
->sh_info
!= 0)
6213 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6214 i
, section
->sh_info
);
6218 printf (" [%2u] ", i
);
6219 if (do_section_details
)
6220 printf ("%s\n ", printable_section_name (section
));
6222 print_symbol (-17, SECTION_NAME (section
));
6224 printf (do_wide
? " %-15s " : " %-15.15s ",
6225 get_section_type_name (section
->sh_type
));
6229 const char * link_too_big
= NULL
;
6231 print_vma (section
->sh_addr
, LONG_HEX
);
6233 printf ( " %6.6lx %6.6lx %2.2lx",
6234 (unsigned long) section
->sh_offset
,
6235 (unsigned long) section
->sh_size
,
6236 (unsigned long) section
->sh_entsize
);
6238 if (do_section_details
)
6239 fputs (" ", stdout
);
6241 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6243 if (section
->sh_link
>= elf_header
.e_shnum
)
6246 /* The sh_link value is out of range. Normally this indicates
6247 an error but it can have special values in Solaris binaries. */
6248 switch (elf_header
.e_machine
)
6255 case EM_OLD_SPARCV9
:
6256 case EM_SPARC32PLUS
:
6259 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6260 link_too_big
= "BEFORE";
6261 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6262 link_too_big
= "AFTER";
6269 if (do_section_details
)
6271 if (link_too_big
!= NULL
&& * link_too_big
)
6272 printf ("<%s> ", link_too_big
);
6274 printf ("%2u ", section
->sh_link
);
6275 printf ("%3u %2lu\n", section
->sh_info
,
6276 (unsigned long) section
->sh_addralign
);
6279 printf ("%2u %3u %2lu\n",
6282 (unsigned long) section
->sh_addralign
);
6284 if (link_too_big
&& ! * link_too_big
)
6285 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6286 i
, section
->sh_link
);
6290 print_vma (section
->sh_addr
, LONG_HEX
);
6292 if ((long) section
->sh_offset
== section
->sh_offset
)
6293 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6297 print_vma (section
->sh_offset
, LONG_HEX
);
6300 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6301 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6305 print_vma (section
->sh_size
, LONG_HEX
);
6308 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6309 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6313 print_vma (section
->sh_entsize
, LONG_HEX
);
6316 if (do_section_details
)
6317 fputs (" ", stdout
);
6319 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6321 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6323 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6324 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6327 print_vma (section
->sh_addralign
, DEC
);
6331 else if (do_section_details
)
6333 printf (" %-15.15s ",
6334 get_section_type_name (section
->sh_type
));
6335 print_vma (section
->sh_addr
, LONG_HEX
);
6336 if ((long) section
->sh_offset
== section
->sh_offset
)
6337 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6341 print_vma (section
->sh_offset
, LONG_HEX
);
6343 printf (" %u\n ", section
->sh_link
);
6344 print_vma (section
->sh_size
, LONG_HEX
);
6346 print_vma (section
->sh_entsize
, LONG_HEX
);
6348 printf (" %-16u %lu\n",
6350 (unsigned long) section
->sh_addralign
);
6355 print_vma (section
->sh_addr
, LONG_HEX
);
6356 if ((long) section
->sh_offset
== section
->sh_offset
)
6357 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6361 print_vma (section
->sh_offset
, LONG_HEX
);
6364 print_vma (section
->sh_size
, LONG_HEX
);
6366 print_vma (section
->sh_entsize
, LONG_HEX
);
6368 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6370 printf (" %2u %3u %lu\n",
6373 (unsigned long) section
->sh_addralign
);
6376 if (do_section_details
)
6378 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6379 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6381 /* Minimum section size is 12 bytes for 32-bit compression
6382 header + 12 bytes for compressed data header. */
6383 unsigned char buf
[24];
6385 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6386 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6387 sizeof (buf
), _("compression header")))
6389 Elf_Internal_Chdr chdr
;
6391 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6393 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6396 printf (_(" [<unknown>: 0x%x], "),
6398 print_vma (chdr
.ch_size
, LONG_HEX
);
6399 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6405 if (!do_section_details
)
6407 /* The ordering of the letters shown here matches the ordering of the
6408 corresponding SHF_xxx values, and hence the order in which these
6409 letters will be displayed to the user. */
6410 printf (_("Key to Flags:\n\
6411 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6412 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6413 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6414 if (elf_header
.e_machine
== EM_X86_64
6415 || elf_header
.e_machine
== EM_L1OM
6416 || elf_header
.e_machine
== EM_K1OM
)
6417 printf (_("l (large), "));
6418 else if (elf_header
.e_machine
== EM_ARM
)
6419 printf (_("y (purecode), "));
6420 printf ("p (processor specific)\n");
6427 get_group_flags (unsigned int flags
)
6429 static char buff
[128];
6433 else if (flags
== GRP_COMDAT
)
6436 snprintf (buff
, 14, _("[0x%x: "), flags
);
6438 flags
&= ~ GRP_COMDAT
;
6439 if (flags
& GRP_MASKOS
)
6441 strcat (buff
, "<OS specific>");
6442 flags
&= ~ GRP_MASKOS
;
6445 if (flags
& GRP_MASKPROC
)
6447 strcat (buff
, "<PROC specific>");
6448 flags
&= ~ GRP_MASKPROC
;
6452 strcat (buff
, "<unknown>");
6459 process_section_groups (FILE * file
)
6461 Elf_Internal_Shdr
* section
;
6463 struct group
* group
;
6464 Elf_Internal_Shdr
* symtab_sec
;
6465 Elf_Internal_Shdr
* strtab_sec
;
6466 Elf_Internal_Sym
* symtab
;
6467 unsigned long num_syms
;
6471 /* Don't process section groups unless needed. */
6472 if (!do_unwind
&& !do_section_groups
)
6475 if (elf_header
.e_shnum
== 0)
6477 if (do_section_groups
)
6478 printf (_("\nThere are no sections to group in this file.\n"));
6483 if (section_headers
== NULL
)
6485 error (_("Section headers are not available!\n"));
6486 /* PR 13622: This can happen with a corrupt ELF header. */
6490 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6491 sizeof (struct group
*));
6493 if (section_headers_groups
== NULL
)
6495 error (_("Out of memory reading %u section group headers\n"),
6496 elf_header
.e_shnum
);
6500 /* Scan the sections for the group section. */
6502 for (i
= 0, section
= section_headers
;
6503 i
< elf_header
.e_shnum
;
6505 if (section
->sh_type
== SHT_GROUP
)
6508 if (group_count
== 0)
6510 if (do_section_groups
)
6511 printf (_("\nThere are no section groups in this file.\n"));
6516 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6518 if (section_groups
== NULL
)
6520 error (_("Out of memory reading %lu groups\n"),
6521 (unsigned long) group_count
);
6531 for (i
= 0, section
= section_headers
, group
= section_groups
;
6532 i
< elf_header
.e_shnum
;
6535 if (section
->sh_type
== SHT_GROUP
)
6537 const char * name
= printable_section_name (section
);
6538 const char * group_name
;
6539 unsigned char * start
;
6540 unsigned char * indices
;
6541 unsigned int entry
, j
, size
;
6542 Elf_Internal_Shdr
* sec
;
6543 Elf_Internal_Sym
* sym
;
6545 /* Get the symbol table. */
6546 if (section
->sh_link
>= elf_header
.e_shnum
6547 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6550 error (_("Bad sh_link in group section `%s'\n"), name
);
6554 if (symtab_sec
!= sec
)
6559 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6564 error (_("Corrupt header in group section `%s'\n"), name
);
6568 if (section
->sh_info
>= num_syms
)
6570 error (_("Bad sh_info in group section `%s'\n"), name
);
6574 sym
= symtab
+ section
->sh_info
;
6576 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6578 if (sym
->st_shndx
== 0
6579 || sym
->st_shndx
>= elf_header
.e_shnum
)
6581 error (_("Bad sh_info in group section `%s'\n"), name
);
6585 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6594 /* Get the string table. */
6595 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6604 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6610 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6611 1, strtab_sec
->sh_size
,
6613 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6615 group_name
= sym
->st_name
< strtab_size
6616 ? strtab
+ sym
->st_name
: _("<corrupt>");
6619 /* PR 17531: file: loop. */
6620 if (section
->sh_entsize
> section
->sh_size
)
6622 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6623 printable_section_name (section
),
6624 (unsigned long) section
->sh_entsize
,
6625 (unsigned long) section
->sh_size
);
6629 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6630 1, section
->sh_size
,
6636 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6637 entry
= byte_get (indices
, 4);
6640 if (do_section_groups
)
6642 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6643 get_group_flags (entry
), i
, name
, group_name
, size
);
6645 printf (_(" [Index] Name\n"));
6648 group
->group_index
= i
;
6650 for (j
= 0; j
< size
; j
++)
6652 struct group_list
* g
;
6654 entry
= byte_get (indices
, 4);
6657 if (entry
>= elf_header
.e_shnum
)
6659 static unsigned num_group_errors
= 0;
6661 if (num_group_errors
++ < 10)
6663 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6664 entry
, i
, elf_header
.e_shnum
- 1);
6665 if (num_group_errors
== 10)
6666 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6671 if (section_headers_groups
[entry
] != NULL
)
6675 static unsigned num_errs
= 0;
6677 if (num_errs
++ < 10)
6679 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6681 section_headers_groups
[entry
]->group_index
);
6683 warn (_("Further error messages about already contained group sections suppressed\n"));
6689 /* Intel C/C++ compiler may put section 0 in a
6690 section group. We just warn it the first time
6691 and ignore it afterwards. */
6692 static bfd_boolean warned
= FALSE
;
6695 error (_("section 0 in group section [%5u]\n"),
6696 section_headers_groups
[entry
]->group_index
);
6702 section_headers_groups
[entry
] = group
;
6704 if (do_section_groups
)
6706 sec
= section_headers
+ entry
;
6707 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6710 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6711 g
->section_index
= entry
;
6712 g
->next
= group
->root
;
6730 /* Data used to display dynamic fixups. */
6732 struct ia64_vms_dynfixup
6734 bfd_vma needed_ident
; /* Library ident number. */
6735 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6736 bfd_vma fixup_needed
; /* Index of the library. */
6737 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6738 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6741 /* Data used to display dynamic relocations. */
6743 struct ia64_vms_dynimgrela
6745 bfd_vma img_rela_cnt
; /* Number of relocations. */
6746 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6749 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6753 dump_ia64_vms_dynamic_fixups (FILE * file
,
6754 struct ia64_vms_dynfixup
* fixup
,
6755 const char * strtab
,
6756 unsigned int strtab_sz
)
6758 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6760 const char * lib_name
;
6762 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6763 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6764 _("dynamic section image fixups"));
6768 if (fixup
->needed
< strtab_sz
)
6769 lib_name
= strtab
+ fixup
->needed
;
6772 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6773 (unsigned long) fixup
->needed
);
6776 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6777 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6779 (_("Seg Offset Type SymVec DataType\n"));
6781 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6786 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6787 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6788 type
= BYTE_GET (imfs
[i
].type
);
6789 rtype
= elf_ia64_reloc_type (type
);
6791 printf (" 0x%08x ", type
);
6793 printf (" %-32s ", rtype
);
6794 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6795 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6802 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6805 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6807 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6810 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6811 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6812 _("dynamic section image relocations"));
6816 printf (_("\nImage relocs\n"));
6818 (_("Seg Offset Type Addend Seg Sym Off\n"));
6820 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6825 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6826 printf ("%08" BFD_VMA_FMT
"x ",
6827 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6828 type
= BYTE_GET (imrs
[i
].type
);
6829 rtype
= elf_ia64_reloc_type (type
);
6831 printf ("0x%08x ", type
);
6833 printf ("%-31s ", rtype
);
6834 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6835 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6836 printf ("%08" BFD_VMA_FMT
"x\n",
6837 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6844 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6847 process_ia64_vms_dynamic_relocs (FILE *file
)
6849 struct ia64_vms_dynfixup fixup
;
6850 struct ia64_vms_dynimgrela imgrela
;
6851 Elf_Internal_Dyn
*entry
;
6852 bfd_vma strtab_off
= 0;
6853 bfd_vma strtab_sz
= 0;
6854 char *strtab
= NULL
;
6855 bfd_boolean res
= TRUE
;
6857 memset (&fixup
, 0, sizeof (fixup
));
6858 memset (&imgrela
, 0, sizeof (imgrela
));
6860 /* Note: the order of the entries is specified by the OpenVMS specs. */
6861 for (entry
= dynamic_section
;
6862 entry
< dynamic_section
+ dynamic_nent
;
6865 switch (entry
->d_tag
)
6867 case DT_IA_64_VMS_STRTAB_OFFSET
:
6868 strtab_off
= entry
->d_un
.d_val
;
6871 strtab_sz
= entry
->d_un
.d_val
;
6873 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6874 1, strtab_sz
, _("dynamic string section"));
6877 case DT_IA_64_VMS_NEEDED_IDENT
:
6878 fixup
.needed_ident
= entry
->d_un
.d_val
;
6881 fixup
.needed
= entry
->d_un
.d_val
;
6883 case DT_IA_64_VMS_FIXUP_NEEDED
:
6884 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6886 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6887 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6889 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6890 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6891 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6894 case DT_IA_64_VMS_IMG_RELA_CNT
:
6895 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6897 case DT_IA_64_VMS_IMG_RELA_OFF
:
6898 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6899 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6921 dynamic_relocations
[] =
6923 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6924 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6925 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6928 /* Process the reloc section. */
6931 process_relocs (FILE * file
)
6933 unsigned long rel_size
;
6934 unsigned long rel_offset
;
6939 if (do_using_dynamic
)
6943 bfd_boolean has_dynamic_reloc
;
6946 has_dynamic_reloc
= FALSE
;
6948 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6950 is_rela
= dynamic_relocations
[i
].rela
;
6951 name
= dynamic_relocations
[i
].name
;
6952 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6953 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6956 has_dynamic_reloc
= TRUE
;
6958 if (is_rela
== UNKNOWN
)
6960 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6961 switch (dynamic_info
[DT_PLTREL
])
6975 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6976 name
, rel_offset
, rel_size
);
6978 dump_relocations (file
,
6979 offset_from_vma (file
, rel_offset
, rel_size
),
6981 dynamic_symbols
, num_dynamic_syms
,
6982 dynamic_strings
, dynamic_strings_length
,
6983 is_rela
, TRUE
/* is_dynamic */);
6988 if (process_ia64_vms_dynamic_relocs (file
))
6989 has_dynamic_reloc
= TRUE
;
6991 if (! has_dynamic_reloc
)
6992 printf (_("\nThere are no dynamic relocations in this file.\n"));
6996 Elf_Internal_Shdr
* section
;
6998 bfd_boolean found
= FALSE
;
7000 for (i
= 0, section
= section_headers
;
7001 i
< elf_header
.e_shnum
;
7004 if ( section
->sh_type
!= SHT_RELA
7005 && section
->sh_type
!= SHT_REL
)
7008 rel_offset
= section
->sh_offset
;
7009 rel_size
= section
->sh_size
;
7013 Elf_Internal_Shdr
* strsec
;
7016 printf (_("\nRelocation section "));
7018 if (string_table
== NULL
)
7019 printf ("%d", section
->sh_name
);
7021 printf ("'%s'", printable_section_name (section
));
7023 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7024 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
7026 is_rela
= section
->sh_type
== SHT_RELA
;
7028 if (section
->sh_link
!= 0
7029 && section
->sh_link
< elf_header
.e_shnum
)
7031 Elf_Internal_Shdr
* symsec
;
7032 Elf_Internal_Sym
* symtab
;
7033 unsigned long nsyms
;
7034 unsigned long strtablen
= 0;
7035 char * strtab
= NULL
;
7037 symsec
= section_headers
+ section
->sh_link
;
7038 if (symsec
->sh_type
!= SHT_SYMTAB
7039 && symsec
->sh_type
!= SHT_DYNSYM
)
7042 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7047 if (symsec
->sh_link
!= 0
7048 && symsec
->sh_link
< elf_header
.e_shnum
)
7050 strsec
= section_headers
+ symsec
->sh_link
;
7052 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7055 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7058 dump_relocations (file
, rel_offset
, rel_size
,
7059 symtab
, nsyms
, strtab
, strtablen
,
7061 symsec
->sh_type
== SHT_DYNSYM
);
7067 dump_relocations (file
, rel_offset
, rel_size
,
7068 NULL
, 0, NULL
, 0, is_rela
,
7069 FALSE
/* is_dynamic */);
7076 printf (_("\nThere are no relocations in this file.\n"));
7082 /* An absolute address consists of a section and an offset. If the
7083 section is NULL, the offset itself is the address, otherwise, the
7084 address equals to LOAD_ADDRESS(section) + offset. */
7088 unsigned short section
;
7092 #define ABSADDR(a) \
7094 ? section_headers [(a).section].sh_addr + (a).offset \
7097 /* Find the nearest symbol at or below ADDR. Returns the symbol
7098 name, if found, and the offset from the symbol to ADDR. */
7101 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7102 unsigned long nsyms
,
7103 const char * strtab
,
7104 unsigned long strtab_size
,
7105 struct absaddr addr
,
7106 const char ** symname
,
7109 bfd_vma dist
= 0x100000;
7110 Elf_Internal_Sym
* sym
;
7111 Elf_Internal_Sym
* beg
;
7112 Elf_Internal_Sym
* end
;
7113 Elf_Internal_Sym
* best
= NULL
;
7115 REMOVE_ARCH_BITS (addr
.offset
);
7117 end
= symtab
+ nsyms
;
7123 sym
= beg
+ (end
- beg
) / 2;
7125 value
= sym
->st_value
;
7126 REMOVE_ARCH_BITS (value
);
7128 if (sym
->st_name
!= 0
7129 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7130 && addr
.offset
>= value
7131 && addr
.offset
- value
< dist
)
7134 dist
= addr
.offset
- value
;
7139 if (addr
.offset
< value
)
7147 *symname
= (best
->st_name
>= strtab_size
7148 ? _("<corrupt>") : strtab
+ best
->st_name
);
7154 *offset
= addr
.offset
;
7157 static /* signed */ int
7158 symcmp (const void *p
, const void *q
)
7160 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7161 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7163 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7166 /* Process the unwind section. */
7168 #include "unwind-ia64.h"
7170 struct ia64_unw_table_entry
7172 struct absaddr start
;
7174 struct absaddr info
;
7177 struct ia64_unw_aux_info
7179 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7180 unsigned long table_len
; /* Length of unwind table. */
7181 unsigned char * info
; /* Unwind info. */
7182 unsigned long info_size
; /* Size of unwind info. */
7183 bfd_vma info_addr
; /* Starting address of unwind info. */
7184 bfd_vma seg_base
; /* Starting address of segment. */
7185 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7186 unsigned long nsyms
; /* Number of symbols. */
7187 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7188 unsigned long nfuns
; /* Number of entries in funtab. */
7189 char * strtab
; /* The string table. */
7190 unsigned long strtab_size
; /* Size of string table. */
7194 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7196 struct ia64_unw_table_entry
* tp
;
7197 unsigned long j
, nfuns
;
7199 bfd_boolean res
= TRUE
;
7201 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7202 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7203 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7204 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7206 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7208 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7212 const unsigned char * dp
;
7213 const unsigned char * head
;
7214 const unsigned char * end
;
7215 const char * procname
;
7217 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7218 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7220 fputs ("\n<", stdout
);
7224 fputs (procname
, stdout
);
7227 printf ("+%lx", (unsigned long) offset
);
7230 fputs (">: [", stdout
);
7231 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7232 fputc ('-', stdout
);
7233 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7234 printf ("], info at +0x%lx\n",
7235 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7237 /* PR 17531: file: 86232b32. */
7238 if (aux
->info
== NULL
)
7241 /* PR 17531: file: 0997b4d1. */
7242 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7244 warn (_("Invalid offset %lx in table entry %ld\n"),
7245 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7250 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7251 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7253 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7254 (unsigned) UNW_VER (stamp
),
7255 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7256 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7257 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7258 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7260 if (UNW_VER (stamp
) != 1)
7262 printf (_("\tUnknown version.\n"));
7267 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7268 /* PR 17531: file: 16ceda89. */
7269 if (end
> aux
->info
+ aux
->info_size
)
7270 end
= aux
->info
+ aux
->info_size
;
7271 for (dp
= head
+ 8; dp
< end
;)
7272 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7281 slurp_ia64_unwind_table (FILE * file
,
7282 struct ia64_unw_aux_info
* aux
,
7283 Elf_Internal_Shdr
* sec
)
7285 unsigned long size
, nrelas
, i
;
7286 Elf_Internal_Phdr
* seg
;
7287 struct ia64_unw_table_entry
* tep
;
7288 Elf_Internal_Shdr
* relsec
;
7289 Elf_Internal_Rela
* rela
;
7290 Elf_Internal_Rela
* rp
;
7291 unsigned char * table
;
7293 Elf_Internal_Sym
* sym
;
7294 const char * relname
;
7298 /* First, find the starting address of the segment that includes
7301 if (elf_header
.e_phnum
)
7303 if (! get_program_headers (file
))
7306 for (seg
= program_headers
;
7307 seg
< program_headers
+ elf_header
.e_phnum
;
7310 if (seg
->p_type
!= PT_LOAD
)
7313 if (sec
->sh_addr
>= seg
->p_vaddr
7314 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7316 aux
->seg_base
= seg
->p_vaddr
;
7322 /* Second, build the unwind table from the contents of the unwind section: */
7323 size
= sec
->sh_size
;
7324 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7329 aux
->table_len
= size
/ (3 * eh_addr_size
);
7330 aux
->table
= (struct ia64_unw_table_entry
*)
7331 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7334 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7336 tep
->start
.section
= SHN_UNDEF
;
7337 tep
->end
.section
= SHN_UNDEF
;
7338 tep
->info
.section
= SHN_UNDEF
;
7339 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7340 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7341 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7342 tep
->start
.offset
+= aux
->seg_base
;
7343 tep
->end
.offset
+= aux
->seg_base
;
7344 tep
->info
.offset
+= aux
->seg_base
;
7348 /* Third, apply any relocations to the unwind table: */
7349 for (relsec
= section_headers
;
7350 relsec
< section_headers
+ elf_header
.e_shnum
;
7353 if (relsec
->sh_type
!= SHT_RELA
7354 || relsec
->sh_info
>= elf_header
.e_shnum
7355 || section_headers
+ relsec
->sh_info
!= sec
)
7358 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7367 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7369 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7370 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7372 /* PR 17531: file: 9fa67536. */
7373 if (relname
== NULL
)
7375 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7379 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7381 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7385 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7387 /* PR 17531: file: 5bc8d9bf. */
7388 if (i
>= aux
->table_len
)
7390 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7394 switch (rp
->r_offset
/ eh_addr_size
% 3)
7397 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7398 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7401 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7402 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7405 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7406 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7420 ia64_process_unwind (FILE * file
)
7422 Elf_Internal_Shdr
* sec
;
7423 Elf_Internal_Shdr
* unwsec
= NULL
;
7424 Elf_Internal_Shdr
* strsec
;
7425 unsigned long i
, unwcount
= 0, unwstart
= 0;
7426 struct ia64_unw_aux_info aux
;
7427 bfd_boolean res
= TRUE
;
7429 memset (& aux
, 0, sizeof (aux
));
7431 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7433 if (sec
->sh_type
== SHT_SYMTAB
7434 && sec
->sh_link
< elf_header
.e_shnum
)
7436 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7438 strsec
= section_headers
+ sec
->sh_link
;
7439 if (aux
.strtab
!= NULL
)
7441 error (_("Multiple auxillary string tables encountered\n"));
7445 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7448 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7450 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7455 printf (_("\nThere are no unwind sections in this file.\n"));
7457 while (unwcount
-- > 0)
7462 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7463 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7464 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7469 /* We have already counted the number of SHT_IA64_UNWIND
7470 sections so the loop above should never fail. */
7471 assert (unwsec
!= NULL
);
7474 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7476 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7478 /* We need to find which section group it is in. */
7479 struct group_list
* g
;
7481 if (section_headers_groups
== NULL
7482 || section_headers_groups
[i
] == NULL
)
7483 i
= elf_header
.e_shnum
;
7486 g
= section_headers_groups
[i
]->root
;
7488 for (; g
!= NULL
; g
= g
->next
)
7490 sec
= section_headers
+ g
->section_index
;
7492 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7497 i
= elf_header
.e_shnum
;
7500 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7502 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7503 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7504 suffix
= SECTION_NAME (unwsec
) + len
;
7505 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7507 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7508 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7513 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7514 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7515 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7516 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7518 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7519 suffix
= SECTION_NAME (unwsec
) + len
;
7520 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7522 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7523 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7527 if (i
== elf_header
.e_shnum
)
7529 printf (_("\nCould not find unwind info section for "));
7531 if (string_table
== NULL
)
7532 printf ("%d", unwsec
->sh_name
);
7534 printf ("'%s'", printable_section_name (unwsec
));
7538 aux
.info_addr
= sec
->sh_addr
;
7539 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7542 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7544 printf (_("\nUnwind section "));
7546 if (string_table
== NULL
)
7547 printf ("%d", unwsec
->sh_name
);
7549 printf ("'%s'", printable_section_name (unwsec
));
7551 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7552 (unsigned long) unwsec
->sh_offset
,
7553 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7555 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7556 && aux
.table_len
> 0)
7557 dump_ia64_unwind (& aux
);
7560 free ((char *) aux
.table
);
7562 free ((char *) aux
.info
);
7571 free ((char *) aux
.strtab
);
7576 struct hppa_unw_table_entry
7578 struct absaddr start
;
7580 unsigned int Cannot_unwind
:1; /* 0 */
7581 unsigned int Millicode
:1; /* 1 */
7582 unsigned int Millicode_save_sr0
:1; /* 2 */
7583 unsigned int Region_description
:2; /* 3..4 */
7584 unsigned int reserved1
:1; /* 5 */
7585 unsigned int Entry_SR
:1; /* 6 */
7586 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7587 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7588 unsigned int Args_stored
:1; /* 16 */
7589 unsigned int Variable_Frame
:1; /* 17 */
7590 unsigned int Separate_Package_Body
:1; /* 18 */
7591 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7592 unsigned int Stack_Overflow_Check
:1; /* 20 */
7593 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7594 unsigned int Ada_Region
:1; /* 22 */
7595 unsigned int cxx_info
:1; /* 23 */
7596 unsigned int cxx_try_catch
:1; /* 24 */
7597 unsigned int sched_entry_seq
:1; /* 25 */
7598 unsigned int reserved2
:1; /* 26 */
7599 unsigned int Save_SP
:1; /* 27 */
7600 unsigned int Save_RP
:1; /* 28 */
7601 unsigned int Save_MRP_in_frame
:1; /* 29 */
7602 unsigned int extn_ptr_defined
:1; /* 30 */
7603 unsigned int Cleanup_defined
:1; /* 31 */
7605 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7606 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7607 unsigned int Large_frame
:1; /* 2 */
7608 unsigned int Pseudo_SP_Set
:1; /* 3 */
7609 unsigned int reserved4
:1; /* 4 */
7610 unsigned int Total_frame_size
:27; /* 5..31 */
7613 struct hppa_unw_aux_info
7615 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7616 unsigned long table_len
; /* Length of unwind table. */
7617 bfd_vma seg_base
; /* Starting address of segment. */
7618 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7619 unsigned long nsyms
; /* Number of symbols. */
7620 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7621 unsigned long nfuns
; /* Number of entries in funtab. */
7622 char * strtab
; /* The string table. */
7623 unsigned long strtab_size
; /* Size of string table. */
7627 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7629 struct hppa_unw_table_entry
* tp
;
7630 unsigned long j
, nfuns
;
7631 bfd_boolean res
= TRUE
;
7633 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7634 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7635 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7636 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7638 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7640 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7643 const char * procname
;
7645 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7646 aux
->strtab_size
, tp
->start
, &procname
,
7649 fputs ("\n<", stdout
);
7653 fputs (procname
, stdout
);
7656 printf ("+%lx", (unsigned long) offset
);
7659 fputs (">: [", stdout
);
7660 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7661 fputc ('-', stdout
);
7662 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7665 #define PF(_m) if (tp->_m) printf (#_m " ");
7666 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7669 PF(Millicode_save_sr0
);
7670 /* PV(Region_description); */
7676 PF(Separate_Package_Body
);
7677 PF(Frame_Extension_Millicode
);
7678 PF(Stack_Overflow_Check
);
7679 PF(Two_Instruction_SP_Increment
);
7683 PF(sched_entry_seq
);
7686 PF(Save_MRP_in_frame
);
7687 PF(extn_ptr_defined
);
7688 PF(Cleanup_defined
);
7689 PF(MPE_XL_interrupt_marker
);
7690 PF(HP_UX_interrupt_marker
);
7693 PV(Total_frame_size
);
7706 slurp_hppa_unwind_table (FILE * file
,
7707 struct hppa_unw_aux_info
* aux
,
7708 Elf_Internal_Shdr
* sec
)
7710 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7711 Elf_Internal_Phdr
* seg
;
7712 struct hppa_unw_table_entry
* tep
;
7713 Elf_Internal_Shdr
* relsec
;
7714 Elf_Internal_Rela
* rela
;
7715 Elf_Internal_Rela
* rp
;
7716 unsigned char * table
;
7718 Elf_Internal_Sym
* sym
;
7719 const char * relname
;
7721 /* First, find the starting address of the segment that includes
7723 if (elf_header
.e_phnum
)
7725 if (! get_program_headers (file
))
7728 for (seg
= program_headers
;
7729 seg
< program_headers
+ elf_header
.e_phnum
;
7732 if (seg
->p_type
!= PT_LOAD
)
7735 if (sec
->sh_addr
>= seg
->p_vaddr
7736 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7738 aux
->seg_base
= seg
->p_vaddr
;
7744 /* Second, build the unwind table from the contents of the unwind
7746 size
= sec
->sh_size
;
7747 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7753 nentries
= size
/ unw_ent_size
;
7754 size
= unw_ent_size
* nentries
;
7756 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7757 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7759 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7761 unsigned int tmp1
, tmp2
;
7763 tep
->start
.section
= SHN_UNDEF
;
7764 tep
->end
.section
= SHN_UNDEF
;
7766 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7767 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7768 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7769 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7771 tep
->start
.offset
+= aux
->seg_base
;
7772 tep
->end
.offset
+= aux
->seg_base
;
7774 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7775 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7776 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7777 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7778 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7779 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7780 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7781 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7782 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7783 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7784 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7785 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7786 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7787 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7788 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7789 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7790 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7791 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7792 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7793 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7794 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7795 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7796 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7797 tep
->Cleanup_defined
= tmp1
& 0x1;
7799 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7800 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7801 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7802 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7803 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7804 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7808 /* Third, apply any relocations to the unwind table. */
7809 for (relsec
= section_headers
;
7810 relsec
< section_headers
+ elf_header
.e_shnum
;
7813 if (relsec
->sh_type
!= SHT_RELA
7814 || relsec
->sh_info
>= elf_header
.e_shnum
7815 || section_headers
+ relsec
->sh_info
!= sec
)
7818 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7822 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7824 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7825 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7827 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7828 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7830 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7834 i
= rp
->r_offset
/ unw_ent_size
;
7836 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7839 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7840 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7843 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7844 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7854 aux
->table_len
= nentries
;
7860 hppa_process_unwind (FILE * file
)
7862 struct hppa_unw_aux_info aux
;
7863 Elf_Internal_Shdr
* unwsec
= NULL
;
7864 Elf_Internal_Shdr
* strsec
;
7865 Elf_Internal_Shdr
* sec
;
7867 bfd_boolean res
= TRUE
;
7869 if (string_table
== NULL
)
7872 memset (& aux
, 0, sizeof (aux
));
7874 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7876 if (sec
->sh_type
== SHT_SYMTAB
7877 && sec
->sh_link
< elf_header
.e_shnum
)
7879 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7881 strsec
= section_headers
+ sec
->sh_link
;
7882 if (aux
.strtab
!= NULL
)
7884 error (_("Multiple auxillary string tables encountered\n"));
7888 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7891 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7893 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7898 printf (_("\nThere are no unwind sections in this file.\n"));
7900 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7902 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7904 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7905 printable_section_name (sec
),
7906 (unsigned long) sec
->sh_offset
,
7907 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7909 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7912 if (aux
.table_len
> 0)
7914 if (! dump_hppa_unwind (&aux
))
7919 free ((char *) aux
.table
);
7927 free ((char *) aux
.strtab
);
7934 unsigned char * data
; /* The unwind data. */
7935 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7936 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7937 unsigned long nrelas
; /* The number of relocations. */
7938 unsigned int rel_type
; /* REL or RELA ? */
7939 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7942 struct arm_unw_aux_info
7944 FILE * file
; /* The file containing the unwind sections. */
7945 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7946 unsigned long nsyms
; /* Number of symbols. */
7947 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7948 unsigned long nfuns
; /* Number of these symbols. */
7949 char * strtab
; /* The file's string table. */
7950 unsigned long strtab_size
; /* Size of string table. */
7954 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7955 bfd_vma fn
, struct absaddr addr
)
7957 const char *procname
;
7960 if (addr
.section
== SHN_UNDEF
)
7963 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7964 aux
->strtab_size
, addr
, &procname
,
7967 print_vma (fn
, PREFIX_HEX
);
7971 fputs (" <", stdout
);
7972 fputs (procname
, stdout
);
7975 printf ("+0x%lx", (unsigned long) sym_offset
);
7976 fputc ('>', stdout
);
7983 arm_free_section (struct arm_section
*arm_sec
)
7985 if (arm_sec
->data
!= NULL
)
7986 free (arm_sec
->data
);
7988 if (arm_sec
->rela
!= NULL
)
7989 free (arm_sec
->rela
);
7992 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7993 cached section and install SEC instead.
7994 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7995 and return its valued in * WORDP, relocating if necessary.
7996 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7997 relocation's offset in ADDR.
7998 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7999 into the string table of the symbol associated with the reloc. If no
8000 reloc was applied store -1 there.
8001 5) Return TRUE upon success, FALSE otherwise. */
8004 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
8005 struct arm_section
* arm_sec
,
8006 Elf_Internal_Shdr
* sec
,
8007 bfd_vma word_offset
,
8008 unsigned int * wordp
,
8009 struct absaddr
* addr
,
8012 Elf_Internal_Rela
*rp
;
8013 Elf_Internal_Sym
*sym
;
8014 const char * relname
;
8016 bfd_boolean wrapped
;
8018 if (sec
== NULL
|| arm_sec
== NULL
)
8021 addr
->section
= SHN_UNDEF
;
8024 if (sym_name
!= NULL
)
8025 *sym_name
= (bfd_vma
) -1;
8027 /* If necessary, update the section cache. */
8028 if (sec
!= arm_sec
->sec
)
8030 Elf_Internal_Shdr
*relsec
;
8032 arm_free_section (arm_sec
);
8035 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8036 sec
->sh_size
, _("unwind data"));
8037 arm_sec
->rela
= NULL
;
8038 arm_sec
->nrelas
= 0;
8040 for (relsec
= section_headers
;
8041 relsec
< section_headers
+ elf_header
.e_shnum
;
8044 if (relsec
->sh_info
>= elf_header
.e_shnum
8045 || section_headers
+ relsec
->sh_info
!= sec
8046 /* PR 15745: Check the section type as well. */
8047 || (relsec
->sh_type
!= SHT_REL
8048 && relsec
->sh_type
!= SHT_RELA
))
8051 arm_sec
->rel_type
= relsec
->sh_type
;
8052 if (relsec
->sh_type
== SHT_REL
)
8054 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8056 & arm_sec
->rela
, & arm_sec
->nrelas
))
8059 else /* relsec->sh_type == SHT_RELA */
8061 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8063 & arm_sec
->rela
, & arm_sec
->nrelas
))
8069 arm_sec
->next_rela
= arm_sec
->rela
;
8072 /* If there is no unwind data we can do nothing. */
8073 if (arm_sec
->data
== NULL
)
8076 /* If the offset is invalid then fail. */
8077 if (/* PR 21343 *//* PR 18879 */
8079 || word_offset
> (sec
->sh_size
- 4)
8080 || ((bfd_signed_vma
) word_offset
) < 0)
8083 /* Get the word at the required offset. */
8084 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8086 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8087 if (arm_sec
->rela
== NULL
)
8093 /* Look through the relocs to find the one that applies to the provided offset. */
8095 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8097 bfd_vma prelval
, offset
;
8099 if (rp
->r_offset
> word_offset
&& !wrapped
)
8104 if (rp
->r_offset
> word_offset
)
8107 if (rp
->r_offset
& 3)
8109 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8110 (unsigned long) rp
->r_offset
);
8114 if (rp
->r_offset
< word_offset
)
8117 /* PR 17531: file: 027-161405-0.004 */
8118 if (aux
->symtab
== NULL
)
8121 if (arm_sec
->rel_type
== SHT_REL
)
8123 offset
= word
& 0x7fffffff;
8124 if (offset
& 0x40000000)
8125 offset
|= ~ (bfd_vma
) 0x7fffffff;
8127 else if (arm_sec
->rel_type
== SHT_RELA
)
8128 offset
= rp
->r_addend
;
8131 error (_("Unknown section relocation type %d encountered\n"),
8136 /* PR 17531 file: 027-1241568-0.004. */
8137 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8139 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8140 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8144 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8145 offset
+= sym
->st_value
;
8146 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8148 /* Check that we are processing the expected reloc type. */
8149 if (elf_header
.e_machine
== EM_ARM
)
8151 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8152 if (relname
== NULL
)
8154 warn (_("Skipping unknown ARM relocation type: %d\n"),
8155 (int) ELF32_R_TYPE (rp
->r_info
));
8159 if (streq (relname
, "R_ARM_NONE"))
8162 if (! streq (relname
, "R_ARM_PREL31"))
8164 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8168 else if (elf_header
.e_machine
== EM_TI_C6000
)
8170 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8171 if (relname
== NULL
)
8173 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8174 (int) ELF32_R_TYPE (rp
->r_info
));
8178 if (streq (relname
, "R_C6000_NONE"))
8181 if (! streq (relname
, "R_C6000_PREL31"))
8183 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8191 /* This function currently only supports ARM and TI unwinders. */
8192 warn (_("Only TI and ARM unwinders are currently supported\n"));
8196 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8197 addr
->section
= sym
->st_shndx
;
8198 addr
->offset
= offset
;
8201 * sym_name
= sym
->st_name
;
8206 arm_sec
->next_rela
= rp
;
8211 static const char *tic6x_unwind_regnames
[16] =
8213 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8214 "A14", "A13", "A12", "A11", "A10",
8215 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8219 decode_tic6x_unwind_regmask (unsigned int mask
)
8223 for (i
= 12; mask
; mask
>>= 1, i
--)
8227 fputs (tic6x_unwind_regnames
[i
], stdout
);
8229 fputs (", ", stdout
);
8235 if (remaining == 0 && more_words) \
8238 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8239 data_offset, & word, & addr, NULL)) \
8245 #define GET_OP(OP) \
8250 (OP) = word >> 24; \
8255 printf (_("[Truncated opcode]\n")); \
8258 printf ("0x%02x ", OP)
8261 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8263 unsigned int remaining
,
8264 unsigned int more_words
,
8265 bfd_vma data_offset
,
8266 Elf_Internal_Shdr
* data_sec
,
8267 struct arm_section
* data_arm_sec
)
8269 struct absaddr addr
;
8270 bfd_boolean res
= TRUE
;
8272 /* Decode the unwinding instructions. */
8275 unsigned int op
, op2
;
8284 printf (" 0x%02x ", op
);
8286 if ((op
& 0xc0) == 0x00)
8288 int offset
= ((op
& 0x3f) << 2) + 4;
8290 printf (" vsp = vsp + %d", offset
);
8292 else if ((op
& 0xc0) == 0x40)
8294 int offset
= ((op
& 0x3f) << 2) + 4;
8296 printf (" vsp = vsp - %d", offset
);
8298 else if ((op
& 0xf0) == 0x80)
8301 if (op
== 0x80 && op2
== 0)
8302 printf (_("Refuse to unwind"));
8305 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8306 bfd_boolean first
= TRUE
;
8310 for (i
= 0; i
< 12; i
++)
8311 if (mask
& (1 << i
))
8317 printf ("r%d", 4 + i
);
8322 else if ((op
& 0xf0) == 0x90)
8324 if (op
== 0x9d || op
== 0x9f)
8325 printf (_(" [Reserved]"));
8327 printf (" vsp = r%d", op
& 0x0f);
8329 else if ((op
& 0xf0) == 0xa0)
8331 int end
= 4 + (op
& 0x07);
8332 bfd_boolean first
= TRUE
;
8336 for (i
= 4; i
<= end
; i
++)
8352 else if (op
== 0xb0)
8353 printf (_(" finish"));
8354 else if (op
== 0xb1)
8357 if (op2
== 0 || (op2
& 0xf0) != 0)
8358 printf (_("[Spare]"));
8361 unsigned int mask
= op2
& 0x0f;
8362 bfd_boolean first
= TRUE
;
8366 for (i
= 0; i
< 12; i
++)
8367 if (mask
& (1 << i
))
8378 else if (op
== 0xb2)
8380 unsigned char buf
[9];
8381 unsigned int i
, len
;
8382 unsigned long offset
;
8384 for (i
= 0; i
< sizeof (buf
); i
++)
8387 if ((buf
[i
] & 0x80) == 0)
8390 if (i
== sizeof (buf
))
8392 error (_("corrupt change to vsp"));
8397 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8398 assert (len
== i
+ 1);
8399 offset
= offset
* 4 + 0x204;
8400 printf ("vsp = vsp + %ld", offset
);
8403 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8405 unsigned int first
, last
;
8412 printf ("pop {D%d", first
);
8414 printf ("-D%d", first
+ last
);
8417 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8419 unsigned int count
= op
& 0x07;
8423 printf ("-D%d", 8 + count
);
8426 else if (op
>= 0xc0 && op
<= 0xc5)
8428 unsigned int count
= op
& 0x07;
8430 printf (" pop {wR10");
8432 printf ("-wR%d", 10 + count
);
8435 else if (op
== 0xc6)
8437 unsigned int first
, last
;
8442 printf ("pop {wR%d", first
);
8444 printf ("-wR%d", first
+ last
);
8447 else if (op
== 0xc7)
8450 if (op2
== 0 || (op2
& 0xf0) != 0)
8451 printf (_("[Spare]"));
8454 unsigned int mask
= op2
& 0x0f;
8455 bfd_boolean first
= TRUE
;
8459 for (i
= 0; i
< 4; i
++)
8460 if (mask
& (1 << i
))
8466 printf ("wCGR%d", i
);
8473 printf (_(" [unsupported opcode]"));
8484 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8486 unsigned int remaining
,
8487 unsigned int more_words
,
8488 bfd_vma data_offset
,
8489 Elf_Internal_Shdr
* data_sec
,
8490 struct arm_section
* data_arm_sec
)
8492 struct absaddr addr
;
8494 /* Decode the unwinding instructions. */
8497 unsigned int op
, op2
;
8506 printf (" 0x%02x ", op
);
8508 if ((op
& 0xc0) == 0x00)
8510 int offset
= ((op
& 0x3f) << 3) + 8;
8511 printf (" sp = sp + %d", offset
);
8513 else if ((op
& 0xc0) == 0x80)
8516 if (op
== 0x80 && op2
== 0)
8517 printf (_("Refuse to unwind"));
8520 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8522 printf ("pop compact {");
8526 decode_tic6x_unwind_regmask (mask
);
8530 else if ((op
& 0xf0) == 0xc0)
8538 unsigned int offset
;
8542 /* Scan entire instruction first so that GET_OP output is not
8543 interleaved with disassembly. */
8545 for (i
= 0; nregs
< (op
& 0xf); i
++)
8551 regpos
[nregs
].offset
= i
* 2;
8552 regpos
[nregs
].reg
= reg
;
8559 regpos
[nregs
].offset
= i
* 2 + 1;
8560 regpos
[nregs
].reg
= reg
;
8565 printf (_("pop frame {"));
8567 for (i
= i
* 2; i
> 0; i
--)
8569 if (regpos
[reg
].offset
== i
- 1)
8571 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8578 fputs (name
, stdout
);
8585 else if (op
== 0xd0)
8586 printf (" MOV FP, SP");
8587 else if (op
== 0xd1)
8588 printf (" __c6xabi_pop_rts");
8589 else if (op
== 0xd2)
8591 unsigned char buf
[9];
8592 unsigned int i
, len
;
8593 unsigned long offset
;
8595 for (i
= 0; i
< sizeof (buf
); i
++)
8598 if ((buf
[i
] & 0x80) == 0)
8601 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8602 if (i
== sizeof (buf
))
8604 warn (_("Corrupt stack pointer adjustment detected\n"));
8608 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8609 assert (len
== i
+ 1);
8610 offset
= offset
* 8 + 0x408;
8611 printf (_("sp = sp + %ld"), offset
);
8613 else if ((op
& 0xf0) == 0xe0)
8615 if ((op
& 0x0f) == 7)
8618 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8622 printf (_(" [unsupported opcode]"));
8631 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8635 offset
= word
& 0x7fffffff;
8636 if (offset
& 0x40000000)
8637 offset
|= ~ (bfd_vma
) 0x7fffffff;
8639 if (elf_header
.e_machine
== EM_TI_C6000
)
8642 return offset
+ where
;
8646 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8648 unsigned int remaining
,
8649 bfd_vma data_offset
,
8650 Elf_Internal_Shdr
* data_sec
,
8651 struct arm_section
* data_arm_sec
)
8654 unsigned int more_words
= 0;
8655 struct absaddr addr
;
8656 bfd_vma sym_name
= (bfd_vma
) -1;
8657 bfd_boolean res
= FALSE
;
8661 /* Fetch the first word.
8662 Note - when decoding an object file the address extracted
8663 here will always be 0. So we also pass in the sym_name
8664 parameter so that we can find the symbol associated with
8665 the personality routine. */
8666 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8667 & word
, & addr
, & sym_name
))
8673 if ((word
& 0x80000000) == 0)
8675 /* Expand prel31 for personality routine. */
8677 const char *procname
;
8679 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8680 printf (_(" Personality routine: "));
8682 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8683 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8685 procname
= aux
->strtab
+ sym_name
;
8686 print_vma (fn
, PREFIX_HEX
);
8689 fputs (" <", stdout
);
8690 fputs (procname
, stdout
);
8691 fputc ('>', stdout
);
8695 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8696 fputc ('\n', stdout
);
8698 /* The GCC personality routines use the standard compact
8699 encoding, starting with one byte giving the number of
8701 if (procname
!= NULL
8702 && (const_strneq (procname
, "__gcc_personality_v0")
8703 || const_strneq (procname
, "__gxx_personality_v0")
8704 || const_strneq (procname
, "__gcj_personality_v0")
8705 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8712 printf (_(" [Truncated data]\n"));
8715 more_words
= word
>> 24;
8725 /* ARM EHABI Section 6.3:
8727 An exception-handling table entry for the compact model looks like:
8731 1 0 index Data for personalityRoutine[index] */
8733 if (elf_header
.e_machine
== EM_ARM
8734 && (word
& 0x70000000))
8736 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8740 per_index
= (word
>> 24) & 0x7f;
8741 printf (_(" Compact model index: %d\n"), per_index
);
8748 else if (per_index
< 3)
8750 more_words
= (word
>> 16) & 0xff;
8756 switch (elf_header
.e_machine
)
8761 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8762 data_offset
, data_sec
, data_arm_sec
))
8767 warn (_("Unknown ARM compact model index encountered\n"));
8768 printf (_(" [reserved]\n"));
8776 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8777 data_offset
, data_sec
, data_arm_sec
))
8780 else if (per_index
< 5)
8782 if (((word
>> 17) & 0x7f) == 0x7f)
8783 printf (_(" Restore stack from frame pointer\n"));
8785 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8786 printf (_(" Registers restored: "));
8788 printf (" (compact) ");
8789 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8791 printf (_(" Return register: %s\n"),
8792 tic6x_unwind_regnames
[word
& 0xf]);
8795 printf (_(" [reserved (%d)]\n"), per_index
);
8799 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8800 elf_header
.e_machine
);
8804 /* Decode the descriptors. Not implemented. */
8810 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8812 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8813 unsigned int i
, exidx_len
;
8814 unsigned long j
, nfuns
;
8815 bfd_boolean res
= TRUE
;
8817 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8818 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8819 exidx_len
= exidx_sec
->sh_size
/ 8;
8821 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8822 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8823 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8824 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8826 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8828 for (i
= 0; i
< exidx_len
; i
++)
8830 unsigned int exidx_fn
, exidx_entry
;
8831 struct absaddr fn_addr
, entry_addr
;
8834 fputc ('\n', stdout
);
8836 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8837 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8838 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8839 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8842 arm_free_section (& exidx_arm_sec
);
8843 arm_free_section (& extab_arm_sec
);
8847 /* ARM EHABI, Section 5:
8848 An index table entry consists of 2 words.
8849 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8850 if (exidx_fn
& 0x80000000)
8852 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8856 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8858 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8859 fputs (": ", stdout
);
8861 if (exidx_entry
== 1)
8863 print_vma (exidx_entry
, PREFIX_HEX
);
8864 fputs (" [cantunwind]\n", stdout
);
8866 else if (exidx_entry
& 0x80000000)
8868 print_vma (exidx_entry
, PREFIX_HEX
);
8869 fputc ('\n', stdout
);
8870 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8874 bfd_vma table
, table_offset
= 0;
8875 Elf_Internal_Shdr
*table_sec
;
8877 fputs ("@", stdout
);
8878 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8879 print_vma (table
, PREFIX_HEX
);
8882 /* Locate the matching .ARM.extab. */
8883 if (entry_addr
.section
!= SHN_UNDEF
8884 && entry_addr
.section
< elf_header
.e_shnum
)
8886 table_sec
= section_headers
+ entry_addr
.section
;
8887 table_offset
= entry_addr
.offset
;
8889 if (table_offset
> table_sec
->sh_size
8890 || ((bfd_signed_vma
) table_offset
) < 0)
8892 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8893 (unsigned long) table_offset
,
8894 printable_section_name (table_sec
));
8901 table_sec
= find_section_by_address (table
);
8902 if (table_sec
!= NULL
)
8903 table_offset
= table
- table_sec
->sh_addr
;
8906 if (table_sec
== NULL
)
8908 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8909 (unsigned long) table
);
8914 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8923 arm_free_section (&exidx_arm_sec
);
8924 arm_free_section (&extab_arm_sec
);
8929 /* Used for both ARM and C6X unwinding tables. */
8932 arm_process_unwind (FILE *file
)
8934 struct arm_unw_aux_info aux
;
8935 Elf_Internal_Shdr
*unwsec
= NULL
;
8936 Elf_Internal_Shdr
*strsec
;
8937 Elf_Internal_Shdr
*sec
;
8939 unsigned int sec_type
;
8940 bfd_boolean res
= TRUE
;
8942 switch (elf_header
.e_machine
)
8945 sec_type
= SHT_ARM_EXIDX
;
8949 sec_type
= SHT_C6000_UNWIND
;
8953 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8954 elf_header
.e_machine
);
8958 if (string_table
== NULL
)
8961 memset (& aux
, 0, sizeof (aux
));
8964 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8966 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8968 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8970 strsec
= section_headers
+ sec
->sh_link
;
8972 /* PR binutils/17531 file: 011-12666-0.004. */
8973 if (aux
.strtab
!= NULL
)
8975 error (_("Multiple string tables found in file.\n"));
8979 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8980 1, strsec
->sh_size
, _("string table"));
8981 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8983 else if (sec
->sh_type
== sec_type
)
8988 printf (_("\nThere are no unwind sections in this file.\n"));
8990 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8992 if (sec
->sh_type
== sec_type
)
8994 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8995 printable_section_name (sec
),
8996 (unsigned long) sec
->sh_offset
,
8997 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8999 if (! dump_arm_unwind (&aux
, sec
))
9007 free ((char *) aux
.strtab
);
9013 process_unwind (FILE * file
)
9015 struct unwind_handler
9017 unsigned int machtype
;
9018 bfd_boolean (* handler
)(FILE *);
9021 { EM_ARM
, arm_process_unwind
},
9022 { EM_IA_64
, ia64_process_unwind
},
9023 { EM_PARISC
, hppa_process_unwind
},
9024 { EM_TI_C6000
, arm_process_unwind
},
9032 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9033 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9034 return handlers
[i
].handler (file
);
9036 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9037 get_machine_name (elf_header
.e_machine
));
9042 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9044 switch (entry
->d_tag
)
9047 if (entry
->d_un
.d_val
== 0)
9051 static const char * opts
[] =
9053 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9054 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9055 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9056 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9060 bfd_boolean first
= TRUE
;
9062 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9063 if (entry
->d_un
.d_val
& (1 << cnt
))
9065 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9071 case DT_MIPS_IVERSION
:
9072 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9073 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9077 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9078 /* Note: coded this way so that there is a single string for translation. */
9079 printf (_("<corrupt: %s>"), buf
);
9083 case DT_MIPS_TIME_STAMP
:
9087 time_t atime
= entry
->d_un
.d_val
;
9089 tmp
= gmtime (&atime
);
9090 /* PR 17531: file: 6accc532. */
9092 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9094 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9095 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9096 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9097 printf (_("Time Stamp: %s"), timebuf
);
9101 case DT_MIPS_RLD_VERSION
:
9102 case DT_MIPS_LOCAL_GOTNO
:
9103 case DT_MIPS_CONFLICTNO
:
9104 case DT_MIPS_LIBLISTNO
:
9105 case DT_MIPS_SYMTABNO
:
9106 case DT_MIPS_UNREFEXTNO
:
9107 case DT_MIPS_HIPAGENO
:
9108 case DT_MIPS_DELTA_CLASS_NO
:
9109 case DT_MIPS_DELTA_INSTANCE_NO
:
9110 case DT_MIPS_DELTA_RELOC_NO
:
9111 case DT_MIPS_DELTA_SYM_NO
:
9112 case DT_MIPS_DELTA_CLASSSYM_NO
:
9113 case DT_MIPS_COMPACT_SIZE
:
9114 print_vma (entry
->d_un
.d_val
, DEC
);
9118 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9124 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9126 switch (entry
->d_tag
)
9128 case DT_HP_DLD_FLAGS
:
9137 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9138 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9139 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9140 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9141 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9142 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9143 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9144 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9145 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9146 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9147 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9148 { DT_HP_GST
, "HP_GST" },
9149 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9150 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9151 { DT_HP_NODELETE
, "HP_NODELETE" },
9152 { DT_HP_GROUP
, "HP_GROUP" },
9153 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9155 bfd_boolean first
= TRUE
;
9157 bfd_vma val
= entry
->d_un
.d_val
;
9159 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9160 if (val
& flags
[cnt
].bit
)
9164 fputs (flags
[cnt
].str
, stdout
);
9166 val
^= flags
[cnt
].bit
;
9169 if (val
!= 0 || first
)
9173 print_vma (val
, HEX
);
9179 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9187 /* VMS vs Unix time offset and factor. */
9189 #define VMS_EPOCH_OFFSET 35067168000000000LL
9190 #define VMS_GRANULARITY_FACTOR 10000000
9192 /* Display a VMS time in a human readable format. */
9195 print_vms_time (bfd_int64_t vmstime
)
9200 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9201 tm
= gmtime (&unxtime
);
9202 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9203 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9204 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9209 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9211 switch (entry
->d_tag
)
9213 case DT_IA_64_PLT_RESERVE
:
9214 /* First 3 slots reserved. */
9215 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9217 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9220 case DT_IA_64_VMS_LINKTIME
:
9222 print_vms_time (entry
->d_un
.d_val
);
9226 case DT_IA_64_VMS_LNKFLAGS
:
9227 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9228 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9229 printf (" CALL_DEBUG");
9230 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9231 printf (" NOP0BUFS");
9232 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9233 printf (" P0IMAGE");
9234 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9235 printf (" MKTHREADS");
9236 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9237 printf (" UPCALLS");
9238 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9240 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9241 printf (" INITIALIZE");
9242 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9244 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9245 printf (" EXE_INIT");
9246 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9247 printf (" TBK_IN_IMG");
9248 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9249 printf (" DBG_IN_IMG");
9250 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9251 printf (" TBK_IN_DSF");
9252 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9253 printf (" DBG_IN_DSF");
9254 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9255 printf (" SIGNATURES");
9256 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9257 printf (" REL_SEG_OFF");
9261 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9268 get_32bit_dynamic_section (FILE * file
)
9270 Elf32_External_Dyn
* edyn
;
9271 Elf32_External_Dyn
* ext
;
9272 Elf_Internal_Dyn
* entry
;
9274 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9275 dynamic_size
, _("dynamic section"));
9279 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9280 might not have the luxury of section headers. Look for the DT_NULL
9281 terminator to determine the number of entries. */
9282 for (ext
= edyn
, dynamic_nent
= 0;
9283 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9287 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9291 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9293 if (dynamic_section
== NULL
)
9295 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9296 (unsigned long) dynamic_nent
);
9301 for (ext
= edyn
, entry
= dynamic_section
;
9302 entry
< dynamic_section
+ dynamic_nent
;
9305 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9306 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9315 get_64bit_dynamic_section (FILE * file
)
9317 Elf64_External_Dyn
* edyn
;
9318 Elf64_External_Dyn
* ext
;
9319 Elf_Internal_Dyn
* entry
;
9321 /* Read in the data. */
9322 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9323 dynamic_size
, _("dynamic section"));
9327 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9328 might not have the luxury of section headers. Look for the DT_NULL
9329 terminator to determine the number of entries. */
9330 for (ext
= edyn
, dynamic_nent
= 0;
9331 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9332 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9336 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9340 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9342 if (dynamic_section
== NULL
)
9344 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9345 (unsigned long) dynamic_nent
);
9350 /* Convert from external to internal formats. */
9351 for (ext
= edyn
, entry
= dynamic_section
;
9352 entry
< dynamic_section
+ dynamic_nent
;
9355 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9356 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9365 print_dynamic_flags (bfd_vma flags
)
9367 bfd_boolean first
= TRUE
;
9373 flag
= flags
& - flags
;
9383 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9384 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9385 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9386 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9387 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9388 default: fputs (_("unknown"), stdout
); break;
9394 /* Parse and display the contents of the dynamic section. */
9397 process_dynamic_section (FILE * file
)
9399 Elf_Internal_Dyn
* entry
;
9401 if (dynamic_size
== 0)
9404 printf (_("\nThere is no dynamic section in this file.\n"));
9411 if (! get_32bit_dynamic_section (file
))
9416 if (! get_64bit_dynamic_section (file
))
9420 /* Find the appropriate symbol table. */
9421 if (dynamic_symbols
== NULL
)
9423 for (entry
= dynamic_section
;
9424 entry
< dynamic_section
+ dynamic_nent
;
9427 Elf_Internal_Shdr section
;
9429 if (entry
->d_tag
!= DT_SYMTAB
)
9432 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9434 /* Since we do not know how big the symbol table is,
9435 we default to reading in the entire file (!) and
9436 processing that. This is overkill, I know, but it
9438 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9440 if (archive_file_offset
!= 0)
9441 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9444 if (fseek (file
, 0, SEEK_END
))
9445 error (_("Unable to seek to end of file!\n"));
9447 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9451 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9453 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9454 section
.sh_name
= string_table_length
;
9456 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9457 if (num_dynamic_syms
< 1)
9459 error (_("Unable to determine the number of symbols to load\n"));
9465 /* Similarly find a string table. */
9466 if (dynamic_strings
== NULL
)
9468 for (entry
= dynamic_section
;
9469 entry
< dynamic_section
+ dynamic_nent
;
9472 unsigned long offset
;
9475 if (entry
->d_tag
!= DT_STRTAB
)
9478 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9480 /* Since we do not know how big the string table is,
9481 we default to reading in the entire file (!) and
9482 processing that. This is overkill, I know, but it
9485 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9487 if (archive_file_offset
!= 0)
9488 str_tab_len
= archive_file_size
- offset
;
9491 if (fseek (file
, 0, SEEK_END
))
9492 error (_("Unable to seek to end of file\n"));
9493 str_tab_len
= ftell (file
) - offset
;
9496 if (str_tab_len
< 1)
9499 (_("Unable to determine the length of the dynamic string table\n"));
9503 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9505 _("dynamic string table"));
9506 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9511 /* And find the syminfo section if available. */
9512 if (dynamic_syminfo
== NULL
)
9514 unsigned long syminsz
= 0;
9516 for (entry
= dynamic_section
;
9517 entry
< dynamic_section
+ dynamic_nent
;
9520 if (entry
->d_tag
== DT_SYMINENT
)
9522 /* Note: these braces are necessary to avoid a syntax
9523 error from the SunOS4 C compiler. */
9524 /* PR binutils/17531: A corrupt file can trigger this test.
9525 So do not use an assert, instead generate an error message. */
9526 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9527 error (_("Bad value (%d) for SYMINENT entry\n"),
9528 (int) entry
->d_un
.d_val
);
9530 else if (entry
->d_tag
== DT_SYMINSZ
)
9531 syminsz
= entry
->d_un
.d_val
;
9532 else if (entry
->d_tag
== DT_SYMINFO
)
9533 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9537 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9539 Elf_External_Syminfo
* extsyminfo
;
9540 Elf_External_Syminfo
* extsym
;
9541 Elf_Internal_Syminfo
* syminfo
;
9543 /* There is a syminfo section. Read the data. */
9544 extsyminfo
= (Elf_External_Syminfo
*)
9545 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9546 _("symbol information"));
9550 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9551 if (dynamic_syminfo
== NULL
)
9553 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9554 (unsigned long) syminsz
);
9558 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9559 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9560 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9561 ++syminfo
, ++extsym
)
9563 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9564 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9571 if (do_dynamic
&& dynamic_addr
)
9572 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9573 dynamic_addr
, (unsigned long) dynamic_nent
);
9575 printf (_(" Tag Type Name/Value\n"));
9577 for (entry
= dynamic_section
;
9578 entry
< dynamic_section
+ dynamic_nent
;
9586 print_vma (entry
->d_tag
, FULL_HEX
);
9587 dtype
= get_dynamic_type (entry
->d_tag
);
9588 printf (" (%s)%*s", dtype
,
9589 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9592 switch (entry
->d_tag
)
9596 print_dynamic_flags (entry
->d_un
.d_val
);
9606 switch (entry
->d_tag
)
9609 printf (_("Auxiliary library"));
9613 printf (_("Filter library"));
9617 printf (_("Configuration file"));
9621 printf (_("Dependency audit library"));
9625 printf (_("Audit library"));
9629 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9630 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9634 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9643 printf (_("Flags:"));
9645 if (entry
->d_un
.d_val
== 0)
9646 printf (_(" None\n"));
9649 unsigned long int val
= entry
->d_un
.d_val
;
9651 if (val
& DTF_1_PARINIT
)
9653 printf (" PARINIT");
9654 val
^= DTF_1_PARINIT
;
9656 if (val
& DTF_1_CONFEXP
)
9658 printf (" CONFEXP");
9659 val
^= DTF_1_CONFEXP
;
9662 printf (" %lx", val
);
9671 printf (_("Flags:"));
9673 if (entry
->d_un
.d_val
== 0)
9674 printf (_(" None\n"));
9677 unsigned long int val
= entry
->d_un
.d_val
;
9679 if (val
& DF_P1_LAZYLOAD
)
9681 printf (" LAZYLOAD");
9682 val
^= DF_P1_LAZYLOAD
;
9684 if (val
& DF_P1_GROUPPERM
)
9686 printf (" GROUPPERM");
9687 val
^= DF_P1_GROUPPERM
;
9690 printf (" %lx", val
);
9699 printf (_("Flags:"));
9700 if (entry
->d_un
.d_val
== 0)
9701 printf (_(" None\n"));
9704 unsigned long int val
= entry
->d_un
.d_val
;
9711 if (val
& DF_1_GLOBAL
)
9716 if (val
& DF_1_GROUP
)
9721 if (val
& DF_1_NODELETE
)
9723 printf (" NODELETE");
9724 val
^= DF_1_NODELETE
;
9726 if (val
& DF_1_LOADFLTR
)
9728 printf (" LOADFLTR");
9729 val
^= DF_1_LOADFLTR
;
9731 if (val
& DF_1_INITFIRST
)
9733 printf (" INITFIRST");
9734 val
^= DF_1_INITFIRST
;
9736 if (val
& DF_1_NOOPEN
)
9741 if (val
& DF_1_ORIGIN
)
9746 if (val
& DF_1_DIRECT
)
9751 if (val
& DF_1_TRANS
)
9756 if (val
& DF_1_INTERPOSE
)
9758 printf (" INTERPOSE");
9759 val
^= DF_1_INTERPOSE
;
9761 if (val
& DF_1_NODEFLIB
)
9763 printf (" NODEFLIB");
9764 val
^= DF_1_NODEFLIB
;
9766 if (val
& DF_1_NODUMP
)
9771 if (val
& DF_1_CONFALT
)
9773 printf (" CONFALT");
9774 val
^= DF_1_CONFALT
;
9776 if (val
& DF_1_ENDFILTEE
)
9778 printf (" ENDFILTEE");
9779 val
^= DF_1_ENDFILTEE
;
9781 if (val
& DF_1_DISPRELDNE
)
9783 printf (" DISPRELDNE");
9784 val
^= DF_1_DISPRELDNE
;
9786 if (val
& DF_1_DISPRELPND
)
9788 printf (" DISPRELPND");
9789 val
^= DF_1_DISPRELPND
;
9791 if (val
& DF_1_NODIRECT
)
9793 printf (" NODIRECT");
9794 val
^= DF_1_NODIRECT
;
9796 if (val
& DF_1_IGNMULDEF
)
9798 printf (" IGNMULDEF");
9799 val
^= DF_1_IGNMULDEF
;
9801 if (val
& DF_1_NOKSYMS
)
9803 printf (" NOKSYMS");
9804 val
^= DF_1_NOKSYMS
;
9806 if (val
& DF_1_NOHDR
)
9811 if (val
& DF_1_EDITED
)
9816 if (val
& DF_1_NORELOC
)
9818 printf (" NORELOC");
9819 val
^= DF_1_NORELOC
;
9821 if (val
& DF_1_SYMINTPOSE
)
9823 printf (" SYMINTPOSE");
9824 val
^= DF_1_SYMINTPOSE
;
9826 if (val
& DF_1_GLOBAUDIT
)
9828 printf (" GLOBAUDIT");
9829 val
^= DF_1_GLOBAUDIT
;
9831 if (val
& DF_1_SINGLETON
)
9833 printf (" SINGLETON");
9834 val
^= DF_1_SINGLETON
;
9836 if (val
& DF_1_STUB
)
9847 printf (" %lx", val
);
9854 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9856 puts (get_dynamic_type (entry
->d_un
.d_val
));
9876 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9882 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9883 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9889 switch (entry
->d_tag
)
9892 printf (_("Shared library: [%s]"), name
);
9894 if (streq (name
, program_interpreter
))
9895 printf (_(" program interpreter"));
9899 printf (_("Library soname: [%s]"), name
);
9903 printf (_("Library rpath: [%s]"), name
);
9907 printf (_("Library runpath: [%s]"), name
);
9911 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9916 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9929 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9934 case DT_INIT_ARRAYSZ
:
9935 case DT_FINI_ARRAYSZ
:
9936 case DT_GNU_CONFLICTSZ
:
9937 case DT_GNU_LIBLISTSZ
:
9940 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9941 printf (_(" (bytes)\n"));
9951 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9964 if (entry
->d_tag
== DT_USED
9965 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9967 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9971 printf (_("Not needed object: [%s]\n"), name
);
9976 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9982 /* The value of this entry is ignored. */
9987 case DT_GNU_PRELINKED
:
9991 time_t atime
= entry
->d_un
.d_val
;
9993 tmp
= gmtime (&atime
);
9994 /* PR 17533 file: 041-1244816-0.004. */
9996 printf (_("<corrupt time val: %lx"),
9997 (unsigned long) atime
);
9999 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10000 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10001 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10007 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10010 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10016 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10017 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10022 switch (elf_header
.e_machine
)
10025 case EM_MIPS_RS3_LE
:
10026 dynamic_section_mips_val (entry
);
10029 dynamic_section_parisc_val (entry
);
10032 dynamic_section_ia64_val (entry
);
10035 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10047 get_ver_flags (unsigned int flags
)
10049 static char buff
[32];
10056 if (flags
& VER_FLG_BASE
)
10057 strcat (buff
, "BASE");
10059 if (flags
& VER_FLG_WEAK
)
10061 if (flags
& VER_FLG_BASE
)
10062 strcat (buff
, " | ");
10064 strcat (buff
, "WEAK");
10067 if (flags
& VER_FLG_INFO
)
10069 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10070 strcat (buff
, " | ");
10072 strcat (buff
, "INFO");
10075 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10077 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10078 strcat (buff
, " | ");
10080 strcat (buff
, _("<unknown>"));
10086 /* Display the contents of the version sections. */
10089 process_version_sections (FILE * file
)
10091 Elf_Internal_Shdr
* section
;
10093 bfd_boolean found
= FALSE
;
10098 for (i
= 0, section
= section_headers
;
10099 i
< elf_header
.e_shnum
;
10102 switch (section
->sh_type
)
10104 case SHT_GNU_verdef
:
10106 Elf_External_Verdef
* edefs
;
10114 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10115 printable_section_name (section
),
10118 printf (_(" Addr: 0x"));
10119 printf_vma (section
->sh_addr
);
10120 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10121 (unsigned long) section
->sh_offset
, section
->sh_link
,
10122 printable_section_name_from_index (section
->sh_link
));
10124 edefs
= (Elf_External_Verdef
*)
10125 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10126 _("version definition section"));
10129 endbuf
= (char *) edefs
+ section
->sh_size
;
10131 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10132 end
= (section
->sh_info
< section
->sh_size
10133 ? section
->sh_info
: section
->sh_size
);
10134 for (idx
= cnt
= 0; cnt
< end
; ++cnt
)
10137 Elf_External_Verdef
* edef
;
10138 Elf_Internal_Verdef ent
;
10139 Elf_External_Verdaux
* eaux
;
10140 Elf_Internal_Verdaux aux
;
10144 /* Check for very large indices. */
10145 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10148 vstart
= ((char *) edefs
) + idx
;
10149 if (vstart
+ sizeof (*edef
) > endbuf
)
10152 edef
= (Elf_External_Verdef
*) vstart
;
10154 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10155 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10156 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10157 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10158 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10159 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10160 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10162 printf (_(" %#06x: Rev: %d Flags: %s"),
10163 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10165 printf (_(" Index: %d Cnt: %d "),
10166 ent
.vd_ndx
, ent
.vd_cnt
);
10168 /* Check for overflow. */
10169 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
))
10172 vstart
+= ent
.vd_aux
;
10174 eaux
= (Elf_External_Verdaux
*) vstart
;
10176 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10177 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10179 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10180 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10182 printf (_("Name index: %ld\n"), aux
.vda_name
);
10184 isum
= idx
+ ent
.vd_aux
;
10186 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10188 /* Check for overflow. */
10189 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10192 isum
+= aux
.vda_next
;
10193 vstart
+= aux
.vda_next
;
10195 eaux
= (Elf_External_Verdaux
*) vstart
;
10196 if (vstart
+ sizeof (*eaux
) > endbuf
)
10199 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10200 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10202 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10203 printf (_(" %#06x: Parent %d: %s\n"),
10204 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10206 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10207 isum
, j
, aux
.vda_name
);
10210 if (j
< ent
.vd_cnt
)
10211 printf (_(" Version def aux past end of section\n"));
10214 file: id:000001,src:000172+005151,op:splice,rep:2. */
10215 if (idx
+ ent
.vd_next
< idx
)
10218 idx
+= ent
.vd_next
;
10221 if (cnt
< section
->sh_info
)
10222 printf (_(" Version definition past end of section\n"));
10228 case SHT_GNU_verneed
:
10230 Elf_External_Verneed
* eneed
;
10237 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10238 printable_section_name (section
), section
->sh_info
);
10240 printf (_(" Addr: 0x"));
10241 printf_vma (section
->sh_addr
);
10242 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10243 (unsigned long) section
->sh_offset
, section
->sh_link
,
10244 printable_section_name_from_index (section
->sh_link
));
10246 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10247 section
->sh_offset
, 1,
10249 _("Version Needs section"));
10252 endbuf
= (char *) eneed
+ section
->sh_size
;
10254 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10256 Elf_External_Verneed
* entry
;
10257 Elf_Internal_Verneed ent
;
10262 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10265 vstart
= ((char *) eneed
) + idx
;
10266 if (vstart
+ sizeof (*entry
) > endbuf
)
10269 entry
= (Elf_External_Verneed
*) vstart
;
10271 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10272 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10273 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10274 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10275 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10277 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10279 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10280 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10282 printf (_(" File: %lx"), ent
.vn_file
);
10284 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10286 /* Check for overflow. */
10287 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10289 vstart
+= ent
.vn_aux
;
10291 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10293 Elf_External_Vernaux
* eaux
;
10294 Elf_Internal_Vernaux aux
;
10296 if (vstart
+ sizeof (*eaux
) > endbuf
)
10298 eaux
= (Elf_External_Vernaux
*) vstart
;
10300 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10301 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10302 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10303 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10304 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10306 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10307 printf (_(" %#06x: Name: %s"),
10308 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10310 printf (_(" %#06x: Name index: %lx"),
10311 isum
, aux
.vna_name
);
10313 printf (_(" Flags: %s Version: %d\n"),
10314 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10316 /* Check for overflow. */
10317 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10318 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10320 warn (_("Invalid vna_next field of %lx\n"),
10325 isum
+= aux
.vna_next
;
10326 vstart
+= aux
.vna_next
;
10329 if (j
< ent
.vn_cnt
)
10330 warn (_("Missing Version Needs auxillary information\n"));
10332 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10334 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10335 cnt
= section
->sh_info
;
10338 idx
+= ent
.vn_next
;
10341 if (cnt
< section
->sh_info
)
10342 warn (_("Missing Version Needs information\n"));
10348 case SHT_GNU_versym
:
10350 Elf_Internal_Shdr
* link_section
;
10353 unsigned char * edata
;
10354 unsigned short * data
;
10356 Elf_Internal_Sym
* symbols
;
10357 Elf_Internal_Shdr
* string_sec
;
10358 unsigned long num_syms
;
10361 if (section
->sh_link
>= elf_header
.e_shnum
)
10364 link_section
= section_headers
+ section
->sh_link
;
10365 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10367 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10372 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10373 if (symbols
== NULL
)
10376 string_sec
= section_headers
+ link_section
->sh_link
;
10378 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10379 string_sec
->sh_size
,
10380 _("version string table"));
10387 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10388 printable_section_name (section
), (unsigned long) total
);
10390 printf (_(" Addr: "));
10391 printf_vma (section
->sh_addr
);
10392 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10393 (unsigned long) section
->sh_offset
, section
->sh_link
,
10394 printable_section_name (link_section
));
10396 off
= offset_from_vma (file
,
10397 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10398 total
* sizeof (short));
10399 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10401 _("version symbol data"));
10409 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10411 for (cnt
= total
; cnt
--;)
10412 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10417 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10421 char *invalid
= _("*invalid*");
10423 printf (" %03x:", cnt
);
10425 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10426 switch (data
[cnt
+ j
])
10429 fputs (_(" 0 (*local*) "), stdout
);
10433 fputs (_(" 1 (*global*) "), stdout
);
10437 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10438 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10440 /* If this index value is greater than the size of the symbols
10441 array, break to avoid an out-of-bounds read. */
10442 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10444 warn (_("invalid index into symbol array\n"));
10449 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10451 Elf_Internal_Verneed ivn
;
10452 unsigned long offset
;
10454 offset
= offset_from_vma
10455 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10456 sizeof (Elf_External_Verneed
));
10460 Elf_Internal_Vernaux ivna
;
10461 Elf_External_Verneed evn
;
10462 Elf_External_Vernaux evna
;
10463 unsigned long a_off
;
10465 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10466 _("version need")) == NULL
)
10469 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10470 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10472 a_off
= offset
+ ivn
.vn_aux
;
10476 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10477 1, _("version need aux (2)")) == NULL
)
10480 ivna
.vna_other
= 0;
10484 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10485 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10488 a_off
+= ivna
.vna_next
;
10490 while (ivna
.vna_other
!= data
[cnt
+ j
]
10491 && ivna
.vna_next
!= 0);
10493 if (ivna
.vna_other
== data
[cnt
+ j
])
10495 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10497 if (ivna
.vna_name
>= string_sec
->sh_size
)
10500 name
= strtab
+ ivna
.vna_name
;
10504 offset
+= ivn
.vn_next
;
10506 while (ivn
.vn_next
);
10509 if (data
[cnt
+ j
] != 0x8001
10510 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10512 Elf_Internal_Verdef ivd
;
10513 Elf_External_Verdef evd
;
10514 unsigned long offset
;
10516 offset
= offset_from_vma
10517 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10522 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10523 _("version def")) == NULL
)
10526 /* PR 17531: file: 046-1082287-0.004. */
10527 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10532 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10533 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10536 offset
+= ivd
.vd_next
;
10538 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10539 && ivd
.vd_next
!= 0);
10541 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10543 Elf_External_Verdaux evda
;
10544 Elf_Internal_Verdaux ivda
;
10546 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10548 if (get_data (&evda
, file
,
10549 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10551 _("version def aux")) == NULL
)
10554 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10556 if (ivda
.vda_name
>= string_sec
->sh_size
)
10558 else if (name
!= NULL
&& name
!= invalid
)
10559 name
= _("*both*");
10561 name
= strtab
+ ivda
.vda_name
;
10565 nn
+= printf ("(%s%-*s",
10567 12 - (int) strlen (name
),
10571 printf ("%*c", 18 - nn
, ' ');
10589 printf (_("\nNo version information found in this file.\n"));
10594 static const char *
10595 get_symbol_binding (unsigned int binding
)
10597 static char buff
[32];
10601 case STB_LOCAL
: return "LOCAL";
10602 case STB_GLOBAL
: return "GLOBAL";
10603 case STB_WEAK
: return "WEAK";
10605 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10606 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10608 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10610 if (binding
== STB_GNU_UNIQUE
10611 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10612 /* GNU is still using the default value 0. */
10613 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10615 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10618 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10623 static const char *
10624 get_symbol_type (unsigned int type
)
10626 static char buff
[32];
10630 case STT_NOTYPE
: return "NOTYPE";
10631 case STT_OBJECT
: return "OBJECT";
10632 case STT_FUNC
: return "FUNC";
10633 case STT_SECTION
: return "SECTION";
10634 case STT_FILE
: return "FILE";
10635 case STT_COMMON
: return "COMMON";
10636 case STT_TLS
: return "TLS";
10637 case STT_RELC
: return "RELC";
10638 case STT_SRELC
: return "SRELC";
10640 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10642 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10643 return "THUMB_FUNC";
10645 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10648 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10649 return "PARISC_MILLI";
10651 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10653 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10655 if (elf_header
.e_machine
== EM_PARISC
)
10657 if (type
== STT_HP_OPAQUE
)
10658 return "HP_OPAQUE";
10659 if (type
== STT_HP_STUB
)
10663 if (type
== STT_GNU_IFUNC
10664 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10665 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10666 /* GNU is still using the default value 0. */
10667 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10670 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10673 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10678 static const char *
10679 get_symbol_visibility (unsigned int visibility
)
10681 switch (visibility
)
10683 case STV_DEFAULT
: return "DEFAULT";
10684 case STV_INTERNAL
: return "INTERNAL";
10685 case STV_HIDDEN
: return "HIDDEN";
10686 case STV_PROTECTED
: return "PROTECTED";
10688 error (_("Unrecognized visibility value: %u"), visibility
);
10689 return _("<unknown>");
10693 static const char *
10694 get_solaris_symbol_visibility (unsigned int visibility
)
10696 switch (visibility
)
10698 case 4: return "EXPORTED";
10699 case 5: return "SINGLETON";
10700 case 6: return "ELIMINATE";
10701 default: return get_symbol_visibility (visibility
);
10705 static const char *
10706 get_mips_symbol_other (unsigned int other
)
10710 case STO_OPTIONAL
: return "OPTIONAL";
10711 case STO_MIPS_PLT
: return "MIPS PLT";
10712 case STO_MIPS_PIC
: return "MIPS PIC";
10713 case STO_MICROMIPS
: return "MICROMIPS";
10714 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10715 case STO_MIPS16
: return "MIPS16";
10716 default: return NULL
;
10720 static const char *
10721 get_ia64_symbol_other (unsigned int other
)
10723 if (is_ia64_vms ())
10725 static char res
[32];
10729 /* Function types is for images and .STB files only. */
10730 switch (elf_header
.e_type
)
10734 switch (VMS_ST_FUNC_TYPE (other
))
10736 case VMS_SFT_CODE_ADDR
:
10737 strcat (res
, " CA");
10739 case VMS_SFT_SYMV_IDX
:
10740 strcat (res
, " VEC");
10743 strcat (res
, " FD");
10745 case VMS_SFT_RESERVE
:
10746 strcat (res
, " RSV");
10749 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10750 VMS_ST_FUNC_TYPE (other
));
10751 strcat (res
, " <unknown>");
10758 switch (VMS_ST_LINKAGE (other
))
10760 case VMS_STL_IGNORE
:
10761 strcat (res
, " IGN");
10763 case VMS_STL_RESERVE
:
10764 strcat (res
, " RSV");
10767 strcat (res
, " STD");
10770 strcat (res
, " LNK");
10773 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10774 VMS_ST_LINKAGE (other
));
10775 strcat (res
, " <unknown>");
10787 static const char *
10788 get_ppc64_symbol_other (unsigned int other
)
10790 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10792 static char buf
[32];
10793 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10794 PPC64_LOCAL_ENTRY_OFFSET (other
));
10800 static const char *
10801 get_symbol_other (unsigned int other
)
10803 const char * result
= NULL
;
10804 static char buff
[32];
10809 switch (elf_header
.e_machine
)
10812 result
= get_mips_symbol_other (other
);
10815 result
= get_ia64_symbol_other (other
);
10818 result
= get_ppc64_symbol_other (other
);
10828 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10832 static const char *
10833 get_symbol_index_type (unsigned int type
)
10835 static char buff
[32];
10839 case SHN_UNDEF
: return "UND";
10840 case SHN_ABS
: return "ABS";
10841 case SHN_COMMON
: return "COM";
10843 if (type
== SHN_IA_64_ANSI_COMMON
10844 && elf_header
.e_machine
== EM_IA_64
10845 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10847 else if ((elf_header
.e_machine
== EM_X86_64
10848 || elf_header
.e_machine
== EM_L1OM
10849 || elf_header
.e_machine
== EM_K1OM
)
10850 && type
== SHN_X86_64_LCOMMON
)
10851 return "LARGE_COM";
10852 else if ((type
== SHN_MIPS_SCOMMON
10853 && elf_header
.e_machine
== EM_MIPS
)
10854 || (type
== SHN_TIC6X_SCOMMON
10855 && elf_header
.e_machine
== EM_TI_C6000
))
10857 else if (type
== SHN_MIPS_SUNDEFINED
10858 && elf_header
.e_machine
== EM_MIPS
)
10860 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10861 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10862 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10863 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10864 else if (type
>= SHN_LORESERVE
)
10865 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10866 else if (type
>= elf_header
.e_shnum
)
10867 sprintf (buff
, _("bad section index[%3d]"), type
);
10869 sprintf (buff
, "%3d", type
);
10877 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10879 unsigned char * e_data
;
10882 /* If the size_t type is smaller than the bfd_size_type, eg because
10883 you are building a 32-bit tool on a 64-bit host, then make sure
10884 that when (number) is cast to (size_t) no information is lost. */
10885 if (sizeof (size_t) < sizeof (bfd_size_type
)
10886 && (bfd_size_type
) ((size_t) number
) != number
)
10888 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10889 " elements of size %u\n"),
10894 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10895 attempting to allocate memory when the read is bound to fail. */
10896 if (ent_size
* number
> current_file_size
)
10898 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10903 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10904 if (e_data
== NULL
)
10906 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10911 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10913 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10914 number
* ent_size
);
10919 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10920 if (i_data
== NULL
)
10922 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10923 " dynamic entries\n"),
10930 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10938 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10940 Elf_Internal_Sym
* psym
;
10943 n
= print_vma (si
, DEC_5
);
10945 fputs (&" "[n
], stdout
);
10946 printf (" %3lu: ", hn
);
10948 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10950 printf (_("<No info available for dynamic symbol number %lu>\n"),
10951 (unsigned long) si
);
10955 psym
= dynamic_symbols
+ si
;
10956 print_vma (psym
->st_value
, LONG_HEX
);
10958 print_vma (psym
->st_size
, DEC_5
);
10960 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10961 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10963 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10964 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10967 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10969 printf (" %-7s", get_symbol_visibility (vis
));
10970 /* Check to see if any other bits in the st_other field are set.
10971 Note - displaying this information disrupts the layout of the
10972 table being generated, but for the moment this case is very
10974 if (psym
->st_other
^ vis
)
10975 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10978 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10979 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10980 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10982 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10986 static const char *
10987 get_symbol_version_string (FILE * file
,
10988 bfd_boolean is_dynsym
,
10989 const char * strtab
,
10990 unsigned long int strtab_size
,
10992 Elf_Internal_Sym
* psym
,
10993 enum versioned_symbol_info
* sym_info
,
10994 unsigned short * vna_other
)
10996 unsigned char data
[2];
10997 unsigned short vers_data
;
10998 unsigned long offset
;
11001 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11004 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11005 sizeof data
+ si
* sizeof (vers_data
));
11007 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
11008 sizeof (data
), 1, _("version data")) == NULL
)
11011 vers_data
= byte_get (data
, 2);
11013 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11016 /* Usually we'd only see verdef for defined symbols, and verneed for
11017 undefined symbols. However, symbols defined by the linker in
11018 .dynbss for variables copied from a shared library in order to
11019 avoid text relocations are defined yet have verneed. We could
11020 use a heuristic to detect the special case, for example, check
11021 for verneed first on symbols defined in SHT_NOBITS sections, but
11022 it is simpler and more reliable to just look for both verdef and
11023 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11025 if (psym
->st_shndx
!= SHN_UNDEF
11026 && vers_data
!= 0x8001
11027 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11029 Elf_Internal_Verdef ivd
;
11030 Elf_Internal_Verdaux ivda
;
11031 Elf_External_Verdaux evda
;
11034 off
= offset_from_vma (file
,
11035 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11036 sizeof (Elf_External_Verdef
));
11040 Elf_External_Verdef evd
;
11042 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11043 _("version def")) == NULL
)
11051 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11052 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11053 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11056 off
+= ivd
.vd_next
;
11058 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11060 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11062 off
-= ivd
.vd_next
;
11065 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11066 _("version def aux")) != NULL
)
11068 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11070 if (psym
->st_name
!= ivda
.vda_name
)
11072 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11073 ? symbol_hidden
: symbol_public
);
11074 return (ivda
.vda_name
< strtab_size
11075 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11081 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11083 Elf_External_Verneed evn
;
11084 Elf_Internal_Verneed ivn
;
11085 Elf_Internal_Vernaux ivna
;
11087 offset
= offset_from_vma (file
,
11088 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11092 unsigned long vna_off
;
11094 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11095 _("version need")) == NULL
)
11098 ivna
.vna_other
= 0;
11103 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11104 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11106 vna_off
= offset
+ ivn
.vn_aux
;
11110 Elf_External_Vernaux evna
;
11112 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11113 _("version need aux (3)")) == NULL
)
11116 ivna
.vna_other
= 0;
11121 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11122 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11123 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11126 vna_off
+= ivna
.vna_next
;
11128 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11130 if (ivna
.vna_other
== vers_data
)
11133 offset
+= ivn
.vn_next
;
11135 while (ivn
.vn_next
!= 0);
11137 if (ivna
.vna_other
== vers_data
)
11139 *sym_info
= symbol_undefined
;
11140 *vna_other
= ivna
.vna_other
;
11141 return (ivna
.vna_name
< strtab_size
11142 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11148 /* Dump the symbol table. */
11150 process_symbol_table (FILE * file
)
11152 Elf_Internal_Shdr
* section
;
11153 bfd_size_type nbuckets
= 0;
11154 bfd_size_type nchains
= 0;
11155 bfd_vma
* buckets
= NULL
;
11156 bfd_vma
* chains
= NULL
;
11157 bfd_vma ngnubuckets
= 0;
11158 bfd_vma
* gnubuckets
= NULL
;
11159 bfd_vma
* gnuchains
= NULL
;
11160 bfd_vma gnusymidx
= 0;
11161 bfd_size_type ngnuchains
= 0;
11163 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11166 if (dynamic_info
[DT_HASH
]
11168 || (do_using_dynamic
11170 && dynamic_strings
!= NULL
)))
11172 unsigned char nb
[8];
11173 unsigned char nc
[8];
11174 unsigned int hash_ent_size
= 4;
11176 if ((elf_header
.e_machine
== EM_ALPHA
11177 || elf_header
.e_machine
== EM_S390
11178 || elf_header
.e_machine
== EM_S390_OLD
)
11179 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11183 (archive_file_offset
11184 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11185 sizeof nb
+ sizeof nc
)),
11188 error (_("Unable to seek to start of dynamic information\n"));
11192 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11194 error (_("Failed to read in number of buckets\n"));
11198 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11200 error (_("Failed to read in number of chains\n"));
11204 nbuckets
= byte_get (nb
, hash_ent_size
);
11205 nchains
= byte_get (nc
, hash_ent_size
);
11207 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11208 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11211 if (buckets
== NULL
|| chains
== NULL
)
11213 if (do_using_dynamic
)
11224 if (dynamic_info_DT_GNU_HASH
11226 || (do_using_dynamic
11228 && dynamic_strings
!= NULL
)))
11230 unsigned char nb
[16];
11231 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11232 bfd_vma buckets_vma
;
11235 (archive_file_offset
11236 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11240 error (_("Unable to seek to start of dynamic information\n"));
11244 if (fread (nb
, 16, 1, file
) != 1)
11246 error (_("Failed to read in number of buckets\n"));
11250 ngnubuckets
= byte_get (nb
, 4);
11251 gnusymidx
= byte_get (nb
+ 4, 4);
11252 bitmaskwords
= byte_get (nb
+ 8, 4);
11253 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11255 buckets_vma
+= bitmaskwords
* 4;
11257 buckets_vma
+= bitmaskwords
* 8;
11260 (archive_file_offset
11261 + offset_from_vma (file
, buckets_vma
, 4)),
11264 error (_("Unable to seek to start of dynamic information\n"));
11268 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11270 if (gnubuckets
== NULL
)
11273 for (i
= 0; i
< ngnubuckets
; i
++)
11274 if (gnubuckets
[i
] != 0)
11276 if (gnubuckets
[i
] < gnusymidx
)
11279 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11280 maxchain
= gnubuckets
[i
];
11283 if (maxchain
== 0xffffffff)
11286 maxchain
-= gnusymidx
;
11289 (archive_file_offset
11290 + offset_from_vma (file
, buckets_vma
11291 + 4 * (ngnubuckets
+ maxchain
), 4)),
11294 error (_("Unable to seek to start of dynamic information\n"));
11300 if (fread (nb
, 4, 1, file
) != 1)
11302 error (_("Failed to determine last chain length\n"));
11306 if (maxchain
+ 1 == 0)
11311 while ((byte_get (nb
, 4) & 1) == 0);
11314 (archive_file_offset
11315 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11318 error (_("Unable to seek to start of dynamic information\n"));
11322 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11323 ngnuchains
= maxchain
;
11326 if (gnuchains
== NULL
)
11331 if (do_using_dynamic
)
11336 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11338 && do_using_dynamic
11339 && dynamic_strings
!= NULL
11340 && dynamic_symbols
!= NULL
)
11344 if (dynamic_info
[DT_HASH
])
11348 printf (_("\nSymbol table for image:\n"));
11350 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11352 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11354 for (hn
= 0; hn
< nbuckets
; hn
++)
11359 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11360 print_dynamic_symbol (si
, hn
);
11364 if (dynamic_info_DT_GNU_HASH
)
11366 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11368 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11370 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11372 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11373 if (gnubuckets
[hn
] != 0)
11375 bfd_vma si
= gnubuckets
[hn
];
11376 bfd_vma off
= si
- gnusymidx
;
11380 print_dynamic_symbol (si
, hn
);
11383 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11387 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11388 && section_headers
!= NULL
)
11392 for (i
= 0, section
= section_headers
;
11393 i
< elf_header
.e_shnum
;
11397 char * strtab
= NULL
;
11398 unsigned long int strtab_size
= 0;
11399 Elf_Internal_Sym
* symtab
;
11400 Elf_Internal_Sym
* psym
;
11401 unsigned long num_syms
;
11403 if ((section
->sh_type
!= SHT_SYMTAB
11404 && section
->sh_type
!= SHT_DYNSYM
)
11406 && section
->sh_type
== SHT_SYMTAB
))
11409 if (section
->sh_entsize
== 0)
11411 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11412 printable_section_name (section
));
11416 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11417 printable_section_name (section
),
11418 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11421 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11423 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11425 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11426 if (symtab
== NULL
)
11429 if (section
->sh_link
== elf_header
.e_shstrndx
)
11431 strtab
= string_table
;
11432 strtab_size
= string_table_length
;
11434 else if (section
->sh_link
< elf_header
.e_shnum
)
11436 Elf_Internal_Shdr
* string_sec
;
11438 string_sec
= section_headers
+ section
->sh_link
;
11440 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11441 1, string_sec
->sh_size
,
11442 _("string table"));
11443 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11446 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11448 const char *version_string
;
11449 enum versioned_symbol_info sym_info
;
11450 unsigned short vna_other
;
11452 printf ("%6d: ", si
);
11453 print_vma (psym
->st_value
, LONG_HEX
);
11455 print_vma (psym
->st_size
, DEC_5
);
11456 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11457 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11458 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11459 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11462 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11464 printf (" %-7s", get_symbol_visibility (vis
));
11465 /* Check to see if any other bits in the st_other field are set.
11466 Note - displaying this information disrupts the layout of the
11467 table being generated, but for the moment this case is very rare. */
11468 if (psym
->st_other
^ vis
)
11469 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11471 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11472 print_symbol (25, psym
->st_name
< strtab_size
11473 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11476 = get_symbol_version_string (file
,
11477 section
->sh_type
== SHT_DYNSYM
,
11478 strtab
, strtab_size
, si
,
11479 psym
, &sym_info
, &vna_other
);
11480 if (version_string
)
11482 if (sym_info
== symbol_undefined
)
11483 printf ("@%s (%d)", version_string
, vna_other
);
11485 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11491 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11492 && si
>= section
->sh_info
11493 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11494 && elf_header
.e_machine
!= EM_MIPS
11495 /* Solaris binaries have been found to violate this requirement as
11496 well. Not sure if this is a bug or an ABI requirement. */
11497 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11498 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11499 si
, printable_section_name (section
), section
->sh_info
);
11503 if (strtab
!= string_table
)
11509 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11511 if (do_histogram
&& buckets
!= NULL
)
11513 unsigned long * lengths
;
11514 unsigned long * counts
;
11517 unsigned long maxlength
= 0;
11518 unsigned long nzero_counts
= 0;
11519 unsigned long nsyms
= 0;
11520 unsigned long chained
;
11522 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11523 (unsigned long) nbuckets
);
11525 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11526 if (lengths
== NULL
)
11528 error (_("Out of memory allocating space for histogram buckets\n"));
11532 printf (_(" Length Number %% of total Coverage\n"));
11533 for (hn
= 0; hn
< nbuckets
; ++hn
)
11535 for (si
= buckets
[hn
], chained
= 0;
11536 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11537 si
= chains
[si
], ++chained
)
11540 if (maxlength
< ++lengths
[hn
])
11544 /* PR binutils/17531: A corrupt binary could contain broken
11545 histogram data. Do not go into an infinite loop trying
11547 if (chained
> nchains
)
11549 error (_("histogram chain is corrupt\n"));
11554 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11555 if (counts
== NULL
)
11558 error (_("Out of memory allocating space for histogram counts\n"));
11562 for (hn
= 0; hn
< nbuckets
; ++hn
)
11563 ++counts
[lengths
[hn
]];
11568 printf (" 0 %-10lu (%5.1f%%)\n",
11569 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11570 for (i
= 1; i
<= maxlength
; ++i
)
11572 nzero_counts
+= counts
[i
] * i
;
11573 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11574 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11575 (nzero_counts
* 100.0) / nsyms
);
11583 if (buckets
!= NULL
)
11589 if (do_histogram
&& gnubuckets
!= NULL
)
11591 unsigned long * lengths
;
11592 unsigned long * counts
;
11594 unsigned long maxlength
= 0;
11595 unsigned long nzero_counts
= 0;
11596 unsigned long nsyms
= 0;
11598 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11599 (unsigned long) ngnubuckets
);
11601 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11602 if (lengths
== NULL
)
11604 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11608 printf (_(" Length Number %% of total Coverage\n"));
11610 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11611 if (gnubuckets
[hn
] != 0)
11613 bfd_vma off
, length
= 1;
11615 for (off
= gnubuckets
[hn
] - gnusymidx
;
11616 /* PR 17531 file: 010-77222-0.004. */
11617 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11620 lengths
[hn
] = length
;
11621 if (length
> maxlength
)
11622 maxlength
= length
;
11626 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11627 if (counts
== NULL
)
11630 error (_("Out of memory allocating space for gnu histogram counts\n"));
11634 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11635 ++counts
[lengths
[hn
]];
11637 if (ngnubuckets
> 0)
11640 printf (" 0 %-10lu (%5.1f%%)\n",
11641 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11642 for (j
= 1; j
<= maxlength
; ++j
)
11644 nzero_counts
+= counts
[j
] * j
;
11645 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11646 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11647 (nzero_counts
* 100.0) / nsyms
);
11661 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11665 if (dynamic_syminfo
== NULL
11667 /* No syminfo, this is ok. */
11670 /* There better should be a dynamic symbol section. */
11671 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11675 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11676 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11678 printf (_(" Num: Name BoundTo Flags\n"));
11679 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11681 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11683 printf ("%4d: ", i
);
11684 if (i
>= num_dynamic_syms
)
11685 printf (_("<corrupt index>"));
11686 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11687 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11689 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11692 switch (dynamic_syminfo
[i
].si_boundto
)
11694 case SYMINFO_BT_SELF
:
11695 fputs ("SELF ", stdout
);
11697 case SYMINFO_BT_PARENT
:
11698 fputs ("PARENT ", stdout
);
11701 if (dynamic_syminfo
[i
].si_boundto
> 0
11702 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11703 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11705 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11709 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11713 if (flags
& SYMINFO_FLG_DIRECT
)
11714 printf (" DIRECT");
11715 if (flags
& SYMINFO_FLG_PASSTHRU
)
11716 printf (" PASSTHRU");
11717 if (flags
& SYMINFO_FLG_COPY
)
11719 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11720 printf (" LAZYLOAD");
11728 #define IN_RANGE(START,END,ADDR,OFF) \
11729 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11731 /* Check to see if the given reloc needs to be handled in a target specific
11732 manner. If so then process the reloc and return TRUE otherwise return
11735 If called with reloc == NULL, then this is a signal that reloc processing
11736 for the current section has finished, and any saved state should be
11740 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11741 unsigned char * start
,
11742 unsigned char * end
,
11743 Elf_Internal_Sym
* symtab
,
11744 unsigned long num_syms
)
11746 unsigned int reloc_type
= 0;
11747 unsigned long sym_index
= 0;
11751 reloc_type
= get_reloc_type (reloc
->r_info
);
11752 sym_index
= get_reloc_symindex (reloc
->r_info
);
11755 switch (elf_header
.e_machine
)
11758 case EM_MSP430_OLD
:
11760 static Elf_Internal_Sym
* saved_sym
= NULL
;
11768 switch (reloc_type
)
11770 case 10: /* R_MSP430_SYM_DIFF */
11771 if (uses_msp430x_relocs ())
11773 /* Fall through. */
11774 case 21: /* R_MSP430X_SYM_DIFF */
11776 if (sym_index
>= num_syms
)
11777 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11780 saved_sym
= symtab
+ sym_index
;
11783 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11784 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11785 goto handle_sym_diff
;
11787 case 5: /* R_MSP430_16_BYTE */
11788 case 9: /* R_MSP430_8 */
11789 if (uses_msp430x_relocs ())
11791 goto handle_sym_diff
;
11793 case 2: /* R_MSP430_ABS16 */
11794 case 15: /* R_MSP430X_ABS16 */
11795 if (! uses_msp430x_relocs ())
11797 goto handle_sym_diff
;
11800 if (saved_sym
!= NULL
)
11802 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11805 if (sym_index
>= num_syms
)
11806 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11810 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11811 - saved_sym
->st_value
);
11813 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11814 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11817 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11818 (long) reloc
->r_offset
);
11827 if (saved_sym
!= NULL
)
11828 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11835 case EM_CYGNUS_MN10300
:
11837 static Elf_Internal_Sym
* saved_sym
= NULL
;
11845 switch (reloc_type
)
11847 case 34: /* R_MN10300_ALIGN */
11849 case 33: /* R_MN10300_SYM_DIFF */
11850 if (sym_index
>= num_syms
)
11851 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11854 saved_sym
= symtab
+ sym_index
;
11857 case 1: /* R_MN10300_32 */
11858 case 2: /* R_MN10300_16 */
11859 if (saved_sym
!= NULL
)
11861 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11864 if (sym_index
>= num_syms
)
11865 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11869 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11870 - saved_sym
->st_value
);
11872 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11873 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11875 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11876 (long) reloc
->r_offset
);
11884 if (saved_sym
!= NULL
)
11885 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11893 static bfd_vma saved_sym1
= 0;
11894 static bfd_vma saved_sym2
= 0;
11895 static bfd_vma value
;
11899 saved_sym1
= saved_sym2
= 0;
11903 switch (reloc_type
)
11905 case 0x80: /* R_RL78_SYM. */
11906 saved_sym1
= saved_sym2
;
11907 if (sym_index
>= num_syms
)
11908 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11912 saved_sym2
= symtab
[sym_index
].st_value
;
11913 saved_sym2
+= reloc
->r_addend
;
11917 case 0x83: /* R_RL78_OPsub. */
11918 value
= saved_sym1
- saved_sym2
;
11919 saved_sym2
= saved_sym1
= 0;
11923 case 0x41: /* R_RL78_ABS32. */
11924 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11925 byte_put (start
+ reloc
->r_offset
, value
, 4);
11927 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11928 (long) reloc
->r_offset
);
11932 case 0x43: /* R_RL78_ABS16. */
11933 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11934 byte_put (start
+ reloc
->r_offset
, value
, 2);
11936 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11937 (long) reloc
->r_offset
);
11951 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11952 DWARF debug sections. This is a target specific test. Note - we do not
11953 go through the whole including-target-headers-multiple-times route, (as
11954 we have already done with <elf/h8.h>) because this would become very
11955 messy and even then this function would have to contain target specific
11956 information (the names of the relocs instead of their numeric values).
11957 FIXME: This is not the correct way to solve this problem. The proper way
11958 is to have target specific reloc sizing and typing functions created by
11959 the reloc-macros.h header, in the same way that it already creates the
11960 reloc naming functions. */
11963 is_32bit_abs_reloc (unsigned int reloc_type
)
11965 /* Please keep this table alpha-sorted for ease of visual lookup. */
11966 switch (elf_header
.e_machine
)
11970 return reloc_type
== 1; /* R_386_32. */
11972 return reloc_type
== 1; /* R_68K_32. */
11974 return reloc_type
== 1; /* R_860_32. */
11976 return reloc_type
== 2; /* R_960_32. */
11978 return (reloc_type
== 258
11979 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11980 case EM_ADAPTEVA_EPIPHANY
:
11981 return reloc_type
== 3;
11983 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11985 return reloc_type
== 1; /* R_ARC_32. */
11986 case EM_ARC_COMPACT
:
11987 case EM_ARC_COMPACT2
:
11988 return reloc_type
== 4; /* R_ARC_32. */
11990 return reloc_type
== 2; /* R_ARM_ABS32 */
11993 return reloc_type
== 1;
11995 return reloc_type
== 0x12; /* R_byte4_data. */
11997 return reloc_type
== 3; /* R_CRIS_32. */
11999 return reloc_type
== 3; /* R_CR16_NUM32. */
12001 return reloc_type
== 15; /* R_CRX_NUM32. */
12002 case EM_CYGNUS_FRV
:
12003 return reloc_type
== 1;
12004 case EM_CYGNUS_D10V
:
12006 return reloc_type
== 6; /* R_D10V_32. */
12007 case EM_CYGNUS_D30V
:
12009 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12011 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12012 case EM_CYGNUS_FR30
:
12014 return reloc_type
== 3; /* R_FR30_32. */
12016 return reloc_type
== 1; /* R_FT32_32. */
12020 return reloc_type
== 1; /* R_H8_DIR32. */
12022 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12023 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
12026 return reloc_type
== 2; /* R_IP2K_32. */
12028 return reloc_type
== 2; /* R_IQ2000_32. */
12029 case EM_LATTICEMICO32
:
12030 return reloc_type
== 3; /* R_LM32_32. */
12033 return reloc_type
== 3; /* R_M32C_32. */
12035 return reloc_type
== 34; /* R_M32R_32_RELA. */
12038 return reloc_type
== 6; /* R_M68HC11_32. */
12040 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12041 case EM_CYGNUS_MEP
:
12042 return reloc_type
== 4; /* R_MEP_32. */
12044 return reloc_type
== 2; /* R_METAG_ADDR32. */
12045 case EM_MICROBLAZE
:
12046 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12048 return reloc_type
== 2; /* R_MIPS_32. */
12050 return reloc_type
== 4; /* R_MMIX_32. */
12051 case EM_CYGNUS_MN10200
:
12053 return reloc_type
== 1; /* R_MN10200_32. */
12054 case EM_CYGNUS_MN10300
:
12056 return reloc_type
== 1; /* R_MN10300_32. */
12058 return reloc_type
== 1; /* R_MOXIE_32. */
12059 case EM_MSP430_OLD
:
12061 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12063 return reloc_type
== 2; /* R_MT_32. */
12065 return reloc_type
== 20; /* R_NDS32_RELA. */
12066 case EM_ALTERA_NIOS2
:
12067 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12069 return reloc_type
== 1; /* R_NIOS_32. */
12071 return reloc_type
== 1; /* R_OR1K_32. */
12073 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12074 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12077 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12079 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12081 return reloc_type
== 1; /* R_PPC_ADDR32. */
12083 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12085 return reloc_type
== 1; /* R_RISCV_32. */
12087 return reloc_type
== 1; /* R_RL78_DIR32. */
12089 return reloc_type
== 1; /* R_RX_DIR32. */
12091 return reloc_type
== 1; /* R_I370_ADDR31. */
12094 return reloc_type
== 4; /* R_S390_32. */
12096 return reloc_type
== 8; /* R_SCORE_ABS32. */
12098 return reloc_type
== 1; /* R_SH_DIR32. */
12099 case EM_SPARC32PLUS
:
12102 return reloc_type
== 3 /* R_SPARC_32. */
12103 || reloc_type
== 23; /* R_SPARC_UA32. */
12105 return reloc_type
== 6; /* R_SPU_ADDR32 */
12107 return reloc_type
== 1; /* R_C6000_ABS32. */
12109 return reloc_type
== 2; /* R_TILEGX_32. */
12111 return reloc_type
== 1; /* R_TILEPRO_32. */
12112 case EM_CYGNUS_V850
:
12114 return reloc_type
== 6; /* R_V850_ABS32. */
12116 return reloc_type
== 0x33; /* R_V810_WORD. */
12118 return reloc_type
== 1; /* R_VAX_32. */
12120 return reloc_type
== 3; /* R_VISIUM_32. */
12121 case EM_WEBASSEMBLY
:
12122 return reloc_type
== 1; /* R_WASM32_32. */
12126 return reloc_type
== 10; /* R_X86_64_32. */
12129 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12131 return reloc_type
== 4; /* R_XGATE_32. */
12133 return reloc_type
== 1; /* R_XSTROMY16_32. */
12134 case EM_XTENSA_OLD
:
12136 return reloc_type
== 1; /* R_XTENSA_32. */
12139 static unsigned int prev_warn
= 0;
12141 /* Avoid repeating the same warning multiple times. */
12142 if (prev_warn
!= elf_header
.e_machine
)
12143 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12144 elf_header
.e_machine
);
12145 prev_warn
= elf_header
.e_machine
;
12151 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12152 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12155 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12157 switch (elf_header
.e_machine
)
12158 /* Please keep this table alpha-sorted for ease of visual lookup. */
12162 return reloc_type
== 2; /* R_386_PC32. */
12164 return reloc_type
== 4; /* R_68K_PC32. */
12166 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12167 case EM_ADAPTEVA_EPIPHANY
:
12168 return reloc_type
== 6;
12170 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12171 case EM_ARC_COMPACT
:
12172 case EM_ARC_COMPACT2
:
12173 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12175 return reloc_type
== 3; /* R_ARM_REL32 */
12178 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12179 case EM_MICROBLAZE
:
12180 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12182 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12184 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12186 return reloc_type
== 26; /* R_PPC_REL32. */
12188 return reloc_type
== 26; /* R_PPC64_REL32. */
12191 return reloc_type
== 5; /* R_390_PC32. */
12193 return reloc_type
== 2; /* R_SH_REL32. */
12194 case EM_SPARC32PLUS
:
12197 return reloc_type
== 6; /* R_SPARC_DISP32. */
12199 return reloc_type
== 13; /* R_SPU_REL32. */
12201 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12203 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12205 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12209 return reloc_type
== 2; /* R_X86_64_PC32. */
12210 case EM_XTENSA_OLD
:
12212 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12214 /* Do not abort or issue an error message here. Not all targets use
12215 pc-relative 32-bit relocs in their DWARF debug information and we
12216 have already tested for target coverage in is_32bit_abs_reloc. A
12217 more helpful warning message will be generated by apply_relocations
12218 anyway, so just return. */
12223 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12224 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12227 is_64bit_abs_reloc (unsigned int reloc_type
)
12229 switch (elf_header
.e_machine
)
12232 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12234 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12236 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12238 return reloc_type
== 80; /* R_PARISC_DIR64. */
12240 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12242 return reloc_type
== 2; /* R_RISCV_64. */
12243 case EM_SPARC32PLUS
:
12246 return reloc_type
== 54; /* R_SPARC_UA64. */
12250 return reloc_type
== 1; /* R_X86_64_64. */
12253 return reloc_type
== 22; /* R_S390_64. */
12255 return reloc_type
== 1; /* R_TILEGX_64. */
12257 return reloc_type
== 18; /* R_MIPS_64. */
12263 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12264 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12267 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12269 switch (elf_header
.e_machine
)
12272 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12274 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12276 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12278 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12280 return reloc_type
== 44; /* R_PPC64_REL64. */
12281 case EM_SPARC32PLUS
:
12284 return reloc_type
== 46; /* R_SPARC_DISP64. */
12288 return reloc_type
== 24; /* R_X86_64_PC64. */
12291 return reloc_type
== 23; /* R_S390_PC64. */
12293 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12299 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12300 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12303 is_24bit_abs_reloc (unsigned int reloc_type
)
12305 switch (elf_header
.e_machine
)
12307 case EM_CYGNUS_MN10200
:
12309 return reloc_type
== 4; /* R_MN10200_24. */
12311 return reloc_type
== 5; /* R_FT32_20. */
12317 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12318 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12321 is_16bit_abs_reloc (unsigned int reloc_type
)
12323 /* Please keep this table alpha-sorted for ease of visual lookup. */
12324 switch (elf_header
.e_machine
)
12327 case EM_ARC_COMPACT
:
12328 case EM_ARC_COMPACT2
:
12329 return reloc_type
== 2; /* R_ARC_16. */
12330 case EM_ADAPTEVA_EPIPHANY
:
12331 return reloc_type
== 5;
12334 return reloc_type
== 4; /* R_AVR_16. */
12335 case EM_CYGNUS_D10V
:
12337 return reloc_type
== 3; /* R_D10V_16. */
12341 return reloc_type
== R_H8_DIR16
;
12344 return reloc_type
== 1; /* R_IP2K_16. */
12347 return reloc_type
== 1; /* R_M32C_16 */
12348 case EM_CYGNUS_MN10200
:
12350 return reloc_type
== 2; /* R_MN10200_16. */
12351 case EM_CYGNUS_MN10300
:
12353 return reloc_type
== 2; /* R_MN10300_16. */
12355 if (uses_msp430x_relocs ())
12356 return reloc_type
== 2; /* R_MSP430_ABS16. */
12357 /* Fall through. */
12358 case EM_MSP430_OLD
:
12359 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12361 return reloc_type
== 19; /* R_NDS32_RELA. */
12362 case EM_ALTERA_NIOS2
:
12363 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12365 return reloc_type
== 9; /* R_NIOS_16. */
12367 return reloc_type
== 2; /* R_OR1K_16. */
12369 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12371 return reloc_type
== 2; /* R_C6000_ABS16. */
12373 return reloc_type
== 2; /* R_VISIUM_16. */
12376 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12378 return reloc_type
== 3; /* R_XGATE_16. */
12384 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12385 relocation entries (possibly formerly used for SHT_GROUP sections). */
12388 is_none_reloc (unsigned int reloc_type
)
12390 switch (elf_header
.e_machine
)
12392 case EM_386
: /* R_386_NONE. */
12393 case EM_68K
: /* R_68K_NONE. */
12394 case EM_ADAPTEVA_EPIPHANY
:
12395 case EM_ALPHA
: /* R_ALPHA_NONE. */
12396 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12397 case EM_ARC
: /* R_ARC_NONE. */
12398 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12399 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12400 case EM_ARM
: /* R_ARM_NONE. */
12401 case EM_C166
: /* R_XC16X_NONE. */
12402 case EM_CRIS
: /* R_CRIS_NONE. */
12403 case EM_FT32
: /* R_FT32_NONE. */
12404 case EM_IA_64
: /* R_IA64_NONE. */
12405 case EM_K1OM
: /* R_X86_64_NONE. */
12406 case EM_L1OM
: /* R_X86_64_NONE. */
12407 case EM_M32R
: /* R_M32R_NONE. */
12408 case EM_MIPS
: /* R_MIPS_NONE. */
12409 case EM_MN10300
: /* R_MN10300_NONE. */
12410 case EM_MOXIE
: /* R_MOXIE_NONE. */
12411 case EM_NIOS32
: /* R_NIOS_NONE. */
12412 case EM_OR1K
: /* R_OR1K_NONE. */
12413 case EM_PARISC
: /* R_PARISC_NONE. */
12414 case EM_PPC64
: /* R_PPC64_NONE. */
12415 case EM_PPC
: /* R_PPC_NONE. */
12416 case EM_RISCV
: /* R_RISCV_NONE. */
12417 case EM_S390
: /* R_390_NONE. */
12419 case EM_SH
: /* R_SH_NONE. */
12420 case EM_SPARC32PLUS
:
12421 case EM_SPARC
: /* R_SPARC_NONE. */
12423 case EM_TILEGX
: /* R_TILEGX_NONE. */
12424 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12425 case EM_TI_C6000
:/* R_C6000_NONE. */
12426 case EM_X86_64
: /* R_X86_64_NONE. */
12428 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12429 return reloc_type
== 0;
12432 return reloc_type
== 0 || reloc_type
== 256;
12435 return (reloc_type
== 0 /* R_AVR_NONE. */
12436 || reloc_type
== 30 /* R_AVR_DIFF8. */
12437 || reloc_type
== 31 /* R_AVR_DIFF16. */
12438 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12440 return reloc_type
== 3; /* R_METAG_NONE. */
12442 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12443 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12444 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12445 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12446 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12448 return (reloc_type
== 0 /* R_PRU_NONE. */
12449 || reloc_type
== 65 /* R_PRU_DIFF8. */
12450 || reloc_type
== 66 /* R_PRU_DIFF16. */
12451 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12452 case EM_XTENSA_OLD
:
12454 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12455 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12456 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12457 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12462 /* Returns TRUE if there is a relocation against
12463 section NAME at OFFSET bytes. */
12466 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12468 Elf_Internal_Rela
* relocs
;
12469 Elf_Internal_Rela
* rp
;
12471 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12474 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12476 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12477 if (rp
->r_offset
== offset
)
12483 /* Apply relocations to a section.
12484 Returns TRUE upon success, FALSE otherwise.
12485 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12486 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12487 will be set to the number of relocs loaded.
12489 Note: So far support has been added only for those relocations
12490 which can be found in debug sections. FIXME: Add support for
12491 more relocations ? */
12494 apply_relocations (void * file
,
12495 const Elf_Internal_Shdr
* section
,
12496 unsigned char * start
,
12497 bfd_size_type size
,
12498 void ** relocs_return
,
12499 unsigned long * num_relocs_return
)
12501 Elf_Internal_Shdr
* relsec
;
12502 unsigned char * end
= start
+ size
;
12503 bfd_boolean res
= TRUE
;
12505 if (relocs_return
!= NULL
)
12507 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12508 * num_relocs_return
= 0;
12511 if (elf_header
.e_type
!= ET_REL
)
12512 /* No relocs to apply. */
12515 /* Find the reloc section associated with the section. */
12516 for (relsec
= section_headers
;
12517 relsec
< section_headers
+ elf_header
.e_shnum
;
12520 bfd_boolean is_rela
;
12521 unsigned long num_relocs
;
12522 Elf_Internal_Rela
* relocs
;
12523 Elf_Internal_Rela
* rp
;
12524 Elf_Internal_Shdr
* symsec
;
12525 Elf_Internal_Sym
* symtab
;
12526 unsigned long num_syms
;
12527 Elf_Internal_Sym
* sym
;
12529 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12530 || relsec
->sh_info
>= elf_header
.e_shnum
12531 || section_headers
+ relsec
->sh_info
!= section
12532 || relsec
->sh_size
== 0
12533 || relsec
->sh_link
>= elf_header
.e_shnum
)
12536 is_rela
= relsec
->sh_type
== SHT_RELA
;
12540 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12541 relsec
->sh_size
, & relocs
, & num_relocs
))
12546 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12547 relsec
->sh_size
, & relocs
, & num_relocs
))
12551 /* SH uses RELA but uses in place value instead of the addend field. */
12552 if (elf_header
.e_machine
== EM_SH
)
12555 symsec
= section_headers
+ relsec
->sh_link
;
12556 if (symsec
->sh_type
!= SHT_SYMTAB
12557 && symsec
->sh_type
!= SHT_DYNSYM
)
12559 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12561 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12564 unsigned int reloc_type
;
12565 unsigned int reloc_size
;
12566 unsigned char * rloc
;
12567 unsigned long sym_index
;
12569 reloc_type
= get_reloc_type (rp
->r_info
);
12571 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12573 else if (is_none_reloc (reloc_type
))
12575 else if (is_32bit_abs_reloc (reloc_type
)
12576 || is_32bit_pcrel_reloc (reloc_type
))
12578 else if (is_64bit_abs_reloc (reloc_type
)
12579 || is_64bit_pcrel_reloc (reloc_type
))
12581 else if (is_24bit_abs_reloc (reloc_type
))
12583 else if (is_16bit_abs_reloc (reloc_type
))
12587 static unsigned int prev_reloc
= 0;
12588 if (reloc_type
!= prev_reloc
)
12589 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12590 reloc_type
, printable_section_name (section
));
12591 prev_reloc
= reloc_type
;
12596 rloc
= start
+ rp
->r_offset
;
12597 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12599 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12600 (unsigned long) rp
->r_offset
,
12601 printable_section_name (section
));
12606 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12607 if (sym_index
>= num_syms
)
12609 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12610 sym_index
, printable_section_name (section
));
12614 sym
= symtab
+ sym_index
;
12616 /* If the reloc has a symbol associated with it,
12617 make sure that it is of an appropriate type.
12619 Relocations against symbols without type can happen.
12620 Gcc -feliminate-dwarf2-dups may generate symbols
12621 without type for debug info.
12623 Icc generates relocations against function symbols
12624 instead of local labels.
12626 Relocations against object symbols can happen, eg when
12627 referencing a global array. For an example of this see
12628 the _clz.o binary in libgcc.a. */
12630 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12631 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12633 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12634 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12635 (long int)(rp
- relocs
),
12636 printable_section_name (relsec
));
12643 addend
+= rp
->r_addend
;
12644 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12645 partial_inplace. */
12647 || (elf_header
.e_machine
== EM_XTENSA
12648 && reloc_type
== 1)
12649 || ((elf_header
.e_machine
== EM_PJ
12650 || elf_header
.e_machine
== EM_PJ_OLD
)
12651 && reloc_type
== 1)
12652 || ((elf_header
.e_machine
== EM_D30V
12653 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12654 && reloc_type
== 12))
12655 addend
+= byte_get (rloc
, reloc_size
);
12657 if (is_32bit_pcrel_reloc (reloc_type
)
12658 || is_64bit_pcrel_reloc (reloc_type
))
12660 /* On HPPA, all pc-relative relocations are biased by 8. */
12661 if (elf_header
.e_machine
== EM_PARISC
)
12663 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12667 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12671 /* Let the target specific reloc processing code know that
12672 we have finished with these relocs. */
12673 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12677 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12678 * num_relocs_return
= num_relocs
;
12689 #ifdef SUPPORT_DISASSEMBLY
12691 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12693 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12695 /* FIXME: XXX -- to be done --- XXX */
12701 /* Reads in the contents of SECTION from FILE, returning a pointer
12702 to a malloc'ed buffer or NULL if something went wrong. */
12705 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12707 bfd_size_type num_bytes
;
12709 num_bytes
= section
->sh_size
;
12711 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12713 printf (_("\nSection '%s' has no data to dump.\n"),
12714 printable_section_name (section
));
12718 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12719 _("section contents"));
12722 /* Uncompresses a section that was compressed using zlib, in place. */
12725 uncompress_section_contents (unsigned char **buffer
,
12726 dwarf_size_type uncompressed_size
,
12727 dwarf_size_type
*size
)
12729 dwarf_size_type compressed_size
= *size
;
12730 unsigned char * compressed_buffer
= *buffer
;
12731 unsigned char * uncompressed_buffer
;
12735 /* It is possible the section consists of several compressed
12736 buffers concatenated together, so we uncompress in a loop. */
12737 /* PR 18313: The state field in the z_stream structure is supposed
12738 to be invisible to the user (ie us), but some compilers will
12739 still complain about it being used without initialisation. So
12740 we first zero the entire z_stream structure and then set the fields
12742 memset (& strm
, 0, sizeof strm
);
12743 strm
.avail_in
= compressed_size
;
12744 strm
.next_in
= (Bytef
*) compressed_buffer
;
12745 strm
.avail_out
= uncompressed_size
;
12746 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12748 rc
= inflateInit (& strm
);
12749 while (strm
.avail_in
> 0)
12753 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12754 + (uncompressed_size
- strm
.avail_out
));
12755 rc
= inflate (&strm
, Z_FINISH
);
12756 if (rc
!= Z_STREAM_END
)
12758 rc
= inflateReset (& strm
);
12760 rc
= inflateEnd (& strm
);
12762 || strm
.avail_out
!= 0)
12765 *buffer
= uncompressed_buffer
;
12766 *size
= uncompressed_size
;
12770 free (uncompressed_buffer
);
12771 /* Indicate decompression failure. */
12777 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12779 Elf_Internal_Shdr
* relsec
;
12780 bfd_size_type num_bytes
;
12781 unsigned char * data
;
12782 unsigned char * end
;
12783 unsigned char * real_start
;
12784 unsigned char * start
;
12785 bfd_boolean some_strings_shown
;
12787 real_start
= start
= (unsigned char *) get_section_contents (section
,
12791 num_bytes
= section
->sh_size
;
12793 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12795 if (decompress_dumps
)
12797 dwarf_size_type new_size
= num_bytes
;
12798 dwarf_size_type uncompressed_size
= 0;
12800 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12802 Elf_Internal_Chdr chdr
;
12803 unsigned int compression_header_size
12804 = get_compression_header (& chdr
, (unsigned char *) start
,
12807 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12809 warn (_("section '%s' has unsupported compress type: %d\n"),
12810 printable_section_name (section
), chdr
.ch_type
);
12813 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12815 warn (_("compressed section '%s' is corrupted\n"),
12816 printable_section_name (section
));
12819 uncompressed_size
= chdr
.ch_size
;
12820 start
+= compression_header_size
;
12821 new_size
-= compression_header_size
;
12823 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12825 /* Read the zlib header. In this case, it should be "ZLIB"
12826 followed by the uncompressed section size, 8 bytes in
12827 big-endian order. */
12828 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12829 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12830 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12831 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12832 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12833 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12834 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12835 uncompressed_size
+= start
[11];
12840 if (uncompressed_size
)
12842 if (uncompress_section_contents (& start
,
12843 uncompressed_size
, & new_size
))
12844 num_bytes
= new_size
;
12847 error (_("Unable to decompress section %s\n"),
12848 printable_section_name (section
));
12853 start
= real_start
;
12856 /* If the section being dumped has relocations against it the user might
12857 be expecting these relocations to have been applied. Check for this
12858 case and issue a warning message in order to avoid confusion.
12859 FIXME: Maybe we ought to have an option that dumps a section with
12860 relocs applied ? */
12861 for (relsec
= section_headers
;
12862 relsec
< section_headers
+ elf_header
.e_shnum
;
12865 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12866 || relsec
->sh_info
>= elf_header
.e_shnum
12867 || section_headers
+ relsec
->sh_info
!= section
12868 || relsec
->sh_size
== 0
12869 || relsec
->sh_link
>= elf_header
.e_shnum
)
12872 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12877 end
= start
+ num_bytes
;
12878 some_strings_shown
= FALSE
;
12882 while (!ISPRINT (* data
))
12883 if (++ data
>= end
)
12888 size_t maxlen
= end
- data
;
12891 /* PR 11128: Use two separate invocations in order to work
12892 around bugs in the Solaris 8 implementation of printf. */
12893 printf (" [%6tx] ", data
- start
);
12895 printf (" [%6Ix] ", (size_t) (data
- start
));
12899 print_symbol ((int) maxlen
, (const char *) data
);
12901 data
+= strnlen ((const char *) data
, maxlen
);
12905 printf (_("<corrupt>\n"));
12908 some_strings_shown
= TRUE
;
12912 if (! some_strings_shown
)
12913 printf (_(" No strings found in this section."));
12922 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12924 bfd_boolean relocate
)
12926 Elf_Internal_Shdr
* relsec
;
12927 bfd_size_type bytes
;
12928 bfd_size_type section_size
;
12930 unsigned char * data
;
12931 unsigned char * real_start
;
12932 unsigned char * start
;
12934 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12938 section_size
= section
->sh_size
;
12940 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12942 if (decompress_dumps
)
12944 dwarf_size_type new_size
= section_size
;
12945 dwarf_size_type uncompressed_size
= 0;
12947 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12949 Elf_Internal_Chdr chdr
;
12950 unsigned int compression_header_size
12951 = get_compression_header (& chdr
, start
, section_size
);
12953 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12955 warn (_("section '%s' has unsupported compress type: %d\n"),
12956 printable_section_name (section
), chdr
.ch_type
);
12959 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12961 warn (_("compressed section '%s' is corrupted\n"),
12962 printable_section_name (section
));
12965 uncompressed_size
= chdr
.ch_size
;
12966 start
+= compression_header_size
;
12967 new_size
-= compression_header_size
;
12969 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12971 /* Read the zlib header. In this case, it should be "ZLIB"
12972 followed by the uncompressed section size, 8 bytes in
12973 big-endian order. */
12974 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12975 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12976 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12977 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12978 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12979 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12980 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12981 uncompressed_size
+= start
[11];
12986 if (uncompressed_size
)
12988 if (uncompress_section_contents (& start
, uncompressed_size
,
12991 section_size
= new_size
;
12995 error (_("Unable to decompress section %s\n"),
12996 printable_section_name (section
));
12997 /* FIXME: Print the section anyway ? */
13002 start
= real_start
;
13007 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
13012 /* If the section being dumped has relocations against it the user might
13013 be expecting these relocations to have been applied. Check for this
13014 case and issue a warning message in order to avoid confusion.
13015 FIXME: Maybe we ought to have an option that dumps a section with
13016 relocs applied ? */
13017 for (relsec
= section_headers
;
13018 relsec
< section_headers
+ elf_header
.e_shnum
;
13021 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13022 || relsec
->sh_info
>= elf_header
.e_shnum
13023 || section_headers
+ relsec
->sh_info
!= section
13024 || relsec
->sh_size
== 0
13025 || relsec
->sh_link
>= elf_header
.e_shnum
)
13028 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13033 addr
= section
->sh_addr
;
13034 bytes
= section_size
;
13043 lbytes
= (bytes
> 16 ? 16 : bytes
);
13045 printf (" 0x%8.8lx ", (unsigned long) addr
);
13047 for (j
= 0; j
< 16; j
++)
13050 printf ("%2.2x", data
[j
]);
13058 for (j
= 0; j
< lbytes
; j
++)
13061 if (k
>= ' ' && k
< 0x7f)
13081 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13082 const Elf_Internal_Shdr
* sec
, void * file
)
13084 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13087 /* If it is already loaded, do nothing. */
13088 if (section
->start
!= NULL
)
13091 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13092 section
->address
= sec
->sh_addr
;
13093 section
->user_data
= NULL
;
13094 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13096 sec
->sh_size
, buf
);
13097 if (section
->start
== NULL
)
13101 unsigned char *start
= section
->start
;
13102 dwarf_size_type size
= sec
->sh_size
;
13103 dwarf_size_type uncompressed_size
= 0;
13105 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13107 Elf_Internal_Chdr chdr
;
13108 unsigned int compression_header_size
;
13110 if (size
< (is_32bit_elf
13111 ? sizeof (Elf32_External_Chdr
)
13112 : sizeof (Elf64_External_Chdr
)))
13114 warn (_("compressed section %s is too small to contain a compression header"),
13119 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13121 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13123 warn (_("section '%s' has unsupported compress type: %d\n"),
13124 section
->name
, chdr
.ch_type
);
13127 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13129 warn (_("compressed section '%s' is corrupted\n"),
13133 uncompressed_size
= chdr
.ch_size
;
13134 start
+= compression_header_size
;
13135 size
-= compression_header_size
;
13137 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13139 /* Read the zlib header. In this case, it should be "ZLIB"
13140 followed by the uncompressed section size, 8 bytes in
13141 big-endian order. */
13142 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13143 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13144 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13145 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13146 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13147 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13148 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13149 uncompressed_size
+= start
[11];
13154 if (uncompressed_size
)
13156 if (uncompress_section_contents (&start
, uncompressed_size
,
13159 /* Free the compressed buffer, update the section buffer
13160 and the section size if uncompress is successful. */
13161 free (section
->start
);
13162 section
->start
= start
;
13166 error (_("Unable to decompress section %s\n"),
13167 printable_section_name (sec
));
13172 section
->size
= size
;
13175 if (section
->start
== NULL
)
13178 if (debug_displays
[debug
].relocate
)
13180 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13181 & section
->reloc_info
, & section
->num_relocs
))
13186 section
->reloc_info
= NULL
;
13187 section
->num_relocs
= 0;
13193 /* If this is not NULL, load_debug_section will only look for sections
13194 within the list of sections given here. */
13195 static unsigned int * section_subset
= NULL
;
13198 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13200 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13201 Elf_Internal_Shdr
* sec
;
13203 /* Locate the debug section. */
13204 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13206 section
->name
= section
->uncompressed_name
;
13209 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13211 section
->name
= section
->compressed_name
;
13216 /* If we're loading from a subset of sections, and we've loaded
13217 a section matching this name before, it's likely that it's a
13219 if (section_subset
!= NULL
)
13220 free_debug_section (debug
);
13222 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13226 free_debug_section (enum dwarf_section_display_enum debug
)
13228 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13230 if (section
->start
== NULL
)
13233 free ((char *) section
->start
);
13234 section
->start
= NULL
;
13235 section
->address
= 0;
13240 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13242 char * name
= SECTION_NAME (section
);
13243 const char * print_name
= printable_section_name (section
);
13244 bfd_size_type length
;
13245 bfd_boolean result
= TRUE
;
13248 length
= section
->sh_size
;
13251 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13254 if (section
->sh_type
== SHT_NOBITS
)
13256 /* There is no point in dumping the contents of a debugging section
13257 which has the NOBITS type - the bits in the file will be random.
13258 This can happen when a file containing a .eh_frame section is
13259 stripped with the --only-keep-debug command line option. */
13260 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13265 if (const_strneq (name
, ".gnu.linkonce.wi."))
13266 name
= ".debug_info";
13268 /* See if we know how to display the contents of this section. */
13269 for (i
= 0; i
< max
; i
++)
13270 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13271 || (i
== line
&& const_strneq (name
, ".debug_line."))
13272 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13274 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13275 int secondary
= (section
!= find_section (name
));
13278 free_debug_section ((enum dwarf_section_display_enum
) i
);
13280 if (i
== line
&& const_strneq (name
, ".debug_line."))
13282 else if (streq (sec
->uncompressed_name
, name
))
13283 sec
->name
= sec
->uncompressed_name
;
13285 sec
->name
= sec
->compressed_name
;
13286 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13289 /* If this debug section is part of a CU/TU set in a .dwp file,
13290 restrict load_debug_section to the sections in that set. */
13291 section_subset
= find_cu_tu_set (file
, shndx
);
13293 result
&= debug_displays
[i
].display (sec
, file
);
13295 section_subset
= NULL
;
13297 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13298 free_debug_section ((enum dwarf_section_display_enum
) i
);
13306 printf (_("Unrecognized debug section: %s\n"), print_name
);
13313 /* Set DUMP_SECTS for all sections where dumps were requested
13314 based on section name. */
13317 initialise_dumps_byname (void)
13319 struct dump_list_entry
* cur
;
13321 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13324 bfd_boolean any
= FALSE
;
13326 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13327 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13329 request_dump_bynumber (i
, cur
->type
);
13334 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13340 process_section_contents (FILE * file
)
13342 Elf_Internal_Shdr
* section
;
13344 bfd_boolean res
= TRUE
;
13349 initialise_dumps_byname ();
13351 for (i
= 0, section
= section_headers
;
13352 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13355 #ifdef SUPPORT_DISASSEMBLY
13356 if (dump_sects
[i
] & DISASS_DUMP
)
13357 disassemble_section (section
, file
);
13359 if (dump_sects
[i
] & HEX_DUMP
)
13361 if (! dump_section_as_bytes (section
, file
, FALSE
))
13365 if (dump_sects
[i
] & RELOC_DUMP
)
13367 if (! dump_section_as_bytes (section
, file
, TRUE
))
13371 if (dump_sects
[i
] & STRING_DUMP
)
13373 if (! dump_section_as_strings (section
, file
))
13377 if (dump_sects
[i
] & DEBUG_DUMP
)
13379 if (! display_debug_section (i
, section
, file
))
13384 /* Check to see if the user requested a
13385 dump of a section that does not exist. */
13386 while (i
< num_dump_sects
)
13390 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13400 process_mips_fpe_exception (int mask
)
13404 bfd_boolean first
= TRUE
;
13406 if (mask
& OEX_FPU_INEX
)
13407 fputs ("INEX", stdout
), first
= FALSE
;
13408 if (mask
& OEX_FPU_UFLO
)
13409 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13410 if (mask
& OEX_FPU_OFLO
)
13411 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13412 if (mask
& OEX_FPU_DIV0
)
13413 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13414 if (mask
& OEX_FPU_INVAL
)
13415 printf ("%sINVAL", first
? "" : "|");
13418 fputs ("0", stdout
);
13421 /* Display's the value of TAG at location P. If TAG is
13422 greater than 0 it is assumed to be an unknown tag, and
13423 a message is printed to this effect. Otherwise it is
13424 assumed that a message has already been printed.
13426 If the bottom bit of TAG is set it assumed to have a
13427 string value, otherwise it is assumed to have an integer
13430 Returns an updated P pointing to the first unread byte
13431 beyond the end of TAG's value.
13433 Reads at or beyond END will not be made. */
13435 static unsigned char *
13436 display_tag_value (signed int tag
,
13438 const unsigned char * const end
)
13443 printf (" Tag_unknown_%d: ", tag
);
13447 warn (_("<corrupt tag>\n"));
13451 /* PR 17531 file: 027-19978-0.004. */
13452 size_t maxlen
= (end
- p
) - 1;
13457 print_symbol ((int) maxlen
, (const char *) p
);
13458 p
+= strnlen ((char *) p
, maxlen
) + 1;
13462 printf (_("<corrupt string tag>"));
13463 p
= (unsigned char *) end
;
13471 val
= read_uleb128 (p
, &len
, end
);
13473 printf ("%ld (0x%lx)\n", val
, val
);
13480 /* ARM EABI attributes section. */
13485 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13487 const char ** table
;
13488 } arm_attr_public_tag
;
13490 static const char * arm_attr_tag_CPU_arch
[] =
13491 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13492 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13494 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13495 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13496 {"No", "Thumb-1", "Thumb-2", "Yes"};
13497 static const char * arm_attr_tag_FP_arch
[] =
13498 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13499 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13500 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13501 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13502 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13503 "NEON for ARMv8.1"};
13504 static const char * arm_attr_tag_PCS_config
[] =
13505 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13506 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13507 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13508 {"V6", "SB", "TLS", "Unused"};
13509 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13510 {"Absolute", "PC-relative", "SB-relative", "None"};
13511 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13512 {"Absolute", "PC-relative", "None"};
13513 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13514 {"None", "direct", "GOT-indirect"};
13515 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13516 {"None", "??? 1", "2", "??? 3", "4"};
13517 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13518 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13519 {"Unused", "Needed", "Sign only"};
13520 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13521 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13522 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13523 {"Unused", "Finite", "RTABI", "IEEE 754"};
13524 static const char * arm_attr_tag_ABI_enum_size
[] =
13525 {"Unused", "small", "int", "forced to int"};
13526 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13527 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13528 static const char * arm_attr_tag_ABI_VFP_args
[] =
13529 {"AAPCS", "VFP registers", "custom", "compatible"};
13530 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13531 {"AAPCS", "WMMX registers", "custom"};
13532 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13533 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13534 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13535 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13536 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13537 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13538 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13539 static const char * arm_attr_tag_FP_HP_extension
[] =
13540 {"Not Allowed", "Allowed"};
13541 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13542 {"None", "IEEE 754", "Alternative Format"};
13543 static const char * arm_attr_tag_DSP_extension
[] =
13544 {"Follow architecture", "Allowed"};
13545 static const char * arm_attr_tag_MPextension_use
[] =
13546 {"Not Allowed", "Allowed"};
13547 static const char * arm_attr_tag_DIV_use
[] =
13548 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13549 "Allowed in v7-A with integer division extension"};
13550 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13551 static const char * arm_attr_tag_Virtualization_use
[] =
13552 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13553 "TrustZone and Virtualization Extensions"};
13554 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13555 {"Not Allowed", "Allowed"};
13557 #define LOOKUP(id, name) \
13558 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13559 static arm_attr_public_tag arm_attr_public_tags
[] =
13561 {4, "CPU_raw_name", 1, NULL
},
13562 {5, "CPU_name", 1, NULL
},
13563 LOOKUP(6, CPU_arch
),
13564 {7, "CPU_arch_profile", 0, NULL
},
13565 LOOKUP(8, ARM_ISA_use
),
13566 LOOKUP(9, THUMB_ISA_use
),
13567 LOOKUP(10, FP_arch
),
13568 LOOKUP(11, WMMX_arch
),
13569 LOOKUP(12, Advanced_SIMD_arch
),
13570 LOOKUP(13, PCS_config
),
13571 LOOKUP(14, ABI_PCS_R9_use
),
13572 LOOKUP(15, ABI_PCS_RW_data
),
13573 LOOKUP(16, ABI_PCS_RO_data
),
13574 LOOKUP(17, ABI_PCS_GOT_use
),
13575 LOOKUP(18, ABI_PCS_wchar_t
),
13576 LOOKUP(19, ABI_FP_rounding
),
13577 LOOKUP(20, ABI_FP_denormal
),
13578 LOOKUP(21, ABI_FP_exceptions
),
13579 LOOKUP(22, ABI_FP_user_exceptions
),
13580 LOOKUP(23, ABI_FP_number_model
),
13581 {24, "ABI_align_needed", 0, NULL
},
13582 {25, "ABI_align_preserved", 0, NULL
},
13583 LOOKUP(26, ABI_enum_size
),
13584 LOOKUP(27, ABI_HardFP_use
),
13585 LOOKUP(28, ABI_VFP_args
),
13586 LOOKUP(29, ABI_WMMX_args
),
13587 LOOKUP(30, ABI_optimization_goals
),
13588 LOOKUP(31, ABI_FP_optimization_goals
),
13589 {32, "compatibility", 0, NULL
},
13590 LOOKUP(34, CPU_unaligned_access
),
13591 LOOKUP(36, FP_HP_extension
),
13592 LOOKUP(38, ABI_FP_16bit_format
),
13593 LOOKUP(42, MPextension_use
),
13594 LOOKUP(44, DIV_use
),
13595 LOOKUP(46, DSP_extension
),
13596 {64, "nodefaults", 0, NULL
},
13597 {65, "also_compatible_with", 0, NULL
},
13598 LOOKUP(66, T2EE_use
),
13599 {67, "conformance", 1, NULL
},
13600 LOOKUP(68, Virtualization_use
),
13601 LOOKUP(70, MPextension_use_legacy
)
13605 static unsigned char *
13606 display_arm_attribute (unsigned char * p
,
13607 const unsigned char * const end
)
13612 arm_attr_public_tag
* attr
;
13616 tag
= read_uleb128 (p
, &len
, end
);
13619 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13621 if (arm_attr_public_tags
[i
].tag
== tag
)
13623 attr
= &arm_attr_public_tags
[i
];
13630 printf (" Tag_%s: ", attr
->name
);
13631 switch (attr
->type
)
13636 case 7: /* Tag_CPU_arch_profile. */
13637 val
= read_uleb128 (p
, &len
, end
);
13641 case 0: printf (_("None\n")); break;
13642 case 'A': printf (_("Application\n")); break;
13643 case 'R': printf (_("Realtime\n")); break;
13644 case 'M': printf (_("Microcontroller\n")); break;
13645 case 'S': printf (_("Application or Realtime\n")); break;
13646 default: printf ("??? (%d)\n", val
); break;
13650 case 24: /* Tag_align_needed. */
13651 val
= read_uleb128 (p
, &len
, end
);
13655 case 0: printf (_("None\n")); break;
13656 case 1: printf (_("8-byte\n")); break;
13657 case 2: printf (_("4-byte\n")); break;
13658 case 3: printf ("??? 3\n"); break;
13661 printf (_("8-byte and up to %d-byte extended\n"),
13664 printf ("??? (%d)\n", val
);
13669 case 25: /* Tag_align_preserved. */
13670 val
= read_uleb128 (p
, &len
, end
);
13674 case 0: printf (_("None\n")); break;
13675 case 1: printf (_("8-byte, except leaf SP\n")); break;
13676 case 2: printf (_("8-byte\n")); break;
13677 case 3: printf ("??? 3\n"); break;
13680 printf (_("8-byte and up to %d-byte extended\n"),
13683 printf ("??? (%d)\n", val
);
13688 case 32: /* Tag_compatibility. */
13690 val
= read_uleb128 (p
, &len
, end
);
13692 printf (_("flag = %d, vendor = "), val
);
13695 size_t maxlen
= (end
- p
) - 1;
13697 print_symbol ((int) maxlen
, (const char *) p
);
13698 p
+= strnlen ((char *) p
, maxlen
) + 1;
13702 printf (_("<corrupt>"));
13703 p
= (unsigned char *) end
;
13709 case 64: /* Tag_nodefaults. */
13710 /* PR 17531: file: 001-505008-0.01. */
13713 printf (_("True\n"));
13716 case 65: /* Tag_also_compatible_with. */
13717 val
= read_uleb128 (p
, &len
, end
);
13719 if (val
== 6 /* Tag_CPU_arch. */)
13721 val
= read_uleb128 (p
, &len
, end
);
13723 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13724 printf ("??? (%d)\n", val
);
13726 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13730 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13735 printf (_("<unknown: %d>\n"), tag
);
13741 return display_tag_value (-1, p
, end
);
13743 return display_tag_value (0, p
, end
);
13746 assert (attr
->type
& 0x80);
13747 val
= read_uleb128 (p
, &len
, end
);
13749 type
= attr
->type
& 0x7f;
13751 printf ("??? (%d)\n", val
);
13753 printf ("%s\n", attr
->table
[val
]);
13758 return display_tag_value (tag
, p
, end
);
13761 static unsigned char *
13762 display_gnu_attribute (unsigned char * p
,
13763 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13764 const unsigned char * const end
)
13770 tag
= read_uleb128 (p
, &len
, end
);
13773 /* Tag_compatibility is the only generic GNU attribute defined at
13777 val
= read_uleb128 (p
, &len
, end
);
13780 printf (_("flag = %d, vendor = "), val
);
13783 printf (_("<corrupt>\n"));
13784 warn (_("corrupt vendor attribute\n"));
13790 size_t maxlen
= (end
- p
) - 1;
13792 print_symbol ((int) maxlen
, (const char *) p
);
13793 p
+= strnlen ((char *) p
, maxlen
) + 1;
13797 printf (_("<corrupt>"));
13798 p
= (unsigned char *) end
;
13805 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13806 return display_proc_gnu_attribute (p
, tag
, end
);
13808 return display_tag_value (tag
, p
, end
);
13811 static unsigned char *
13812 display_power_gnu_attribute (unsigned char * p
,
13814 const unsigned char * const end
)
13819 if (tag
== Tag_GNU_Power_ABI_FP
)
13821 val
= read_uleb128 (p
, &len
, end
);
13823 printf (" Tag_GNU_Power_ABI_FP: ");
13826 printf (_("<corrupt>\n"));
13831 printf ("(%#x), ", val
);
13836 printf (_("unspecified hard/soft float, "));
13839 printf (_("hard float, "));
13842 printf (_("soft float, "));
13845 printf (_("single-precision hard float, "));
13852 printf (_("unspecified long double\n"));
13855 printf (_("128-bit IBM long double\n"));
13858 printf (_("64-bit long double\n"));
13861 printf (_("128-bit IEEE long double\n"));
13867 if (tag
== Tag_GNU_Power_ABI_Vector
)
13869 val
= read_uleb128 (p
, &len
, end
);
13871 printf (" Tag_GNU_Power_ABI_Vector: ");
13874 printf (_("<corrupt>\n"));
13879 printf ("(%#x), ", val
);
13884 printf (_("unspecified\n"));
13887 printf (_("generic\n"));
13890 printf ("AltiVec\n");
13899 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13901 val
= read_uleb128 (p
, &len
, end
);
13903 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13906 printf (_("<corrupt>\n"));
13911 printf ("(%#x), ", val
);
13916 printf (_("unspecified\n"));
13919 printf ("r3/r4\n");
13922 printf (_("memory\n"));
13931 return display_tag_value (tag
& 1, p
, end
);
13934 static unsigned char *
13935 display_s390_gnu_attribute (unsigned char * p
,
13937 const unsigned char * const end
)
13942 if (tag
== Tag_GNU_S390_ABI_Vector
)
13944 val
= read_uleb128 (p
, &len
, end
);
13946 printf (" Tag_GNU_S390_ABI_Vector: ");
13951 printf (_("any\n"));
13954 printf (_("software\n"));
13957 printf (_("hardware\n"));
13960 printf ("??? (%d)\n", val
);
13966 return display_tag_value (tag
& 1, p
, end
);
13970 display_sparc_hwcaps (unsigned int mask
)
13974 bfd_boolean first
= TRUE
;
13976 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13977 fputs ("mul32", stdout
), first
= FALSE
;
13978 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13979 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
13980 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13981 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
13982 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13983 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
13984 if (mask
& ELF_SPARC_HWCAP_POPC
)
13985 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
13986 if (mask
& ELF_SPARC_HWCAP_VIS
)
13987 printf ("%svis", first
? "" : "|"), first
= FALSE
;
13988 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13989 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
13990 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13991 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
13992 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13993 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
13994 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13995 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
13996 if (mask
& ELF_SPARC_HWCAP_HPC
)
13997 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
13998 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13999 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14000 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14001 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14002 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14003 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14004 if (mask
& ELF_SPARC_HWCAP_IMA
)
14005 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14006 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14007 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14010 fputc ('0', stdout
);
14011 fputc ('\n', stdout
);
14015 display_sparc_hwcaps2 (unsigned int mask
)
14019 bfd_boolean first
= TRUE
;
14021 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14022 fputs ("fjathplus", stdout
), first
= FALSE
;
14023 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14024 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14025 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14026 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14027 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14028 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14029 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14030 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14031 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14032 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14033 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14034 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14035 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14036 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14037 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14038 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14039 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14040 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14041 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14042 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14045 fputc ('0', stdout
);
14046 fputc ('\n', stdout
);
14049 static unsigned char *
14050 display_sparc_gnu_attribute (unsigned char * p
,
14052 const unsigned char * const end
)
14057 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14059 val
= read_uleb128 (p
, &len
, end
);
14061 printf (" Tag_GNU_Sparc_HWCAPS: ");
14062 display_sparc_hwcaps (val
);
14065 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14067 val
= read_uleb128 (p
, &len
, end
);
14069 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14070 display_sparc_hwcaps2 (val
);
14074 return display_tag_value (tag
, p
, end
);
14078 print_mips_fp_abi_value (unsigned int val
)
14082 case Val_GNU_MIPS_ABI_FP_ANY
:
14083 printf (_("Hard or soft float\n"));
14085 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14086 printf (_("Hard float (double precision)\n"));
14088 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14089 printf (_("Hard float (single precision)\n"));
14091 case Val_GNU_MIPS_ABI_FP_SOFT
:
14092 printf (_("Soft float\n"));
14094 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14095 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14097 case Val_GNU_MIPS_ABI_FP_XX
:
14098 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14100 case Val_GNU_MIPS_ABI_FP_64
:
14101 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14103 case Val_GNU_MIPS_ABI_FP_64A
:
14104 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14106 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14107 printf (_("NaN 2008 compatibility\n"));
14110 printf ("??? (%d)\n", val
);
14115 static unsigned char *
14116 display_mips_gnu_attribute (unsigned char * p
,
14118 const unsigned char * const end
)
14120 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14125 val
= read_uleb128 (p
, &len
, end
);
14127 printf (" Tag_GNU_MIPS_ABI_FP: ");
14129 print_mips_fp_abi_value (val
);
14134 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14139 val
= read_uleb128 (p
, &len
, end
);
14141 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14145 case Val_GNU_MIPS_ABI_MSA_ANY
:
14146 printf (_("Any MSA or not\n"));
14148 case Val_GNU_MIPS_ABI_MSA_128
:
14149 printf (_("128-bit MSA\n"));
14152 printf ("??? (%d)\n", val
);
14158 return display_tag_value (tag
& 1, p
, end
);
14161 static unsigned char *
14162 display_tic6x_attribute (unsigned char * p
,
14163 const unsigned char * const end
)
14169 tag
= read_uleb128 (p
, &len
, end
);
14175 val
= read_uleb128 (p
, &len
, end
);
14177 printf (" Tag_ISA: ");
14181 case C6XABI_Tag_ISA_none
:
14182 printf (_("None\n"));
14184 case C6XABI_Tag_ISA_C62X
:
14187 case C6XABI_Tag_ISA_C67X
:
14190 case C6XABI_Tag_ISA_C67XP
:
14191 printf ("C67x+\n");
14193 case C6XABI_Tag_ISA_C64X
:
14196 case C6XABI_Tag_ISA_C64XP
:
14197 printf ("C64x+\n");
14199 case C6XABI_Tag_ISA_C674X
:
14200 printf ("C674x\n");
14203 printf ("??? (%d)\n", val
);
14208 case Tag_ABI_wchar_t
:
14209 val
= read_uleb128 (p
, &len
, end
);
14211 printf (" Tag_ABI_wchar_t: ");
14215 printf (_("Not used\n"));
14218 printf (_("2 bytes\n"));
14221 printf (_("4 bytes\n"));
14224 printf ("??? (%d)\n", val
);
14229 case Tag_ABI_stack_align_needed
:
14230 val
= read_uleb128 (p
, &len
, end
);
14232 printf (" Tag_ABI_stack_align_needed: ");
14236 printf (_("8-byte\n"));
14239 printf (_("16-byte\n"));
14242 printf ("??? (%d)\n", val
);
14247 case Tag_ABI_stack_align_preserved
:
14248 val
= read_uleb128 (p
, &len
, end
);
14250 printf (" Tag_ABI_stack_align_preserved: ");
14254 printf (_("8-byte\n"));
14257 printf (_("16-byte\n"));
14260 printf ("??? (%d)\n", val
);
14266 val
= read_uleb128 (p
, &len
, end
);
14268 printf (" Tag_ABI_DSBT: ");
14272 printf (_("DSBT addressing not used\n"));
14275 printf (_("DSBT addressing used\n"));
14278 printf ("??? (%d)\n", val
);
14284 val
= read_uleb128 (p
, &len
, end
);
14286 printf (" Tag_ABI_PID: ");
14290 printf (_("Data addressing position-dependent\n"));
14293 printf (_("Data addressing position-independent, GOT near DP\n"));
14296 printf (_("Data addressing position-independent, GOT far from DP\n"));
14299 printf ("??? (%d)\n", val
);
14305 val
= read_uleb128 (p
, &len
, end
);
14307 printf (" Tag_ABI_PIC: ");
14311 printf (_("Code addressing position-dependent\n"));
14314 printf (_("Code addressing position-independent\n"));
14317 printf ("??? (%d)\n", val
);
14322 case Tag_ABI_array_object_alignment
:
14323 val
= read_uleb128 (p
, &len
, end
);
14325 printf (" Tag_ABI_array_object_alignment: ");
14329 printf (_("8-byte\n"));
14332 printf (_("4-byte\n"));
14335 printf (_("16-byte\n"));
14338 printf ("??? (%d)\n", val
);
14343 case Tag_ABI_array_object_align_expected
:
14344 val
= read_uleb128 (p
, &len
, end
);
14346 printf (" Tag_ABI_array_object_align_expected: ");
14350 printf (_("8-byte\n"));
14353 printf (_("4-byte\n"));
14356 printf (_("16-byte\n"));
14359 printf ("??? (%d)\n", val
);
14364 case Tag_ABI_compatibility
:
14366 val
= read_uleb128 (p
, &len
, end
);
14368 printf (" Tag_ABI_compatibility: ");
14369 printf (_("flag = %d, vendor = "), val
);
14372 size_t maxlen
= (end
- p
) - 1;
14374 print_symbol ((int) maxlen
, (const char *) p
);
14375 p
+= strnlen ((char *) p
, maxlen
) + 1;
14379 printf (_("<corrupt>"));
14380 p
= (unsigned char *) end
;
14386 case Tag_ABI_conformance
:
14388 printf (" Tag_ABI_conformance: \"");
14391 size_t maxlen
= (end
- p
) - 1;
14393 print_symbol ((int) maxlen
, (const char *) p
);
14394 p
+= strnlen ((char *) p
, maxlen
) + 1;
14398 printf (_("<corrupt>"));
14399 p
= (unsigned char *) end
;
14406 return display_tag_value (tag
, p
, end
);
14410 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14412 unsigned long addr
= 0;
14413 size_t bytes
= end
- p
;
14420 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14422 printf (" 0x%8.8lx ", addr
);
14424 for (j
= 0; j
< 16; j
++)
14427 printf ("%2.2x", p
[j
]);
14435 for (j
= 0; j
< lbytes
; j
++)
14438 if (k
>= ' ' && k
< 0x7f)
14454 static unsigned char *
14455 display_msp430x_attribute (unsigned char * p
,
14456 const unsigned char * const end
)
14462 tag
= read_uleb128 (p
, & len
, end
);
14467 case OFBA_MSPABI_Tag_ISA
:
14468 val
= read_uleb128 (p
, &len
, end
);
14470 printf (" Tag_ISA: ");
14473 case 0: printf (_("None\n")); break;
14474 case 1: printf (_("MSP430\n")); break;
14475 case 2: printf (_("MSP430X\n")); break;
14476 default: printf ("??? (%d)\n", val
); break;
14480 case OFBA_MSPABI_Tag_Code_Model
:
14481 val
= read_uleb128 (p
, &len
, end
);
14483 printf (" Tag_Code_Model: ");
14486 case 0: printf (_("None\n")); break;
14487 case 1: printf (_("Small\n")); break;
14488 case 2: printf (_("Large\n")); break;
14489 default: printf ("??? (%d)\n", val
); break;
14493 case OFBA_MSPABI_Tag_Data_Model
:
14494 val
= read_uleb128 (p
, &len
, end
);
14496 printf (" Tag_Data_Model: ");
14499 case 0: printf (_("None\n")); break;
14500 case 1: printf (_("Small\n")); break;
14501 case 2: printf (_("Large\n")); break;
14502 case 3: printf (_("Restricted Large\n")); break;
14503 default: printf ("??? (%d)\n", val
); break;
14508 printf (_(" <unknown tag %d>: "), tag
);
14515 size_t maxlen
= (end
- p
) - 1;
14517 print_symbol ((int) maxlen
, (const char *) p
);
14518 p
+= strnlen ((char *) p
, maxlen
) + 1;
14522 printf (_("<corrupt>"));
14523 p
= (unsigned char *) end
;
14529 val
= read_uleb128 (p
, &len
, end
);
14531 printf ("%d (0x%x)\n", val
, val
);
14541 process_attributes (FILE * file
,
14542 const char * public_name
,
14543 unsigned int proc_type
,
14544 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14545 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14547 Elf_Internal_Shdr
* sect
;
14549 bfd_boolean res
= TRUE
;
14551 /* Find the section header so that we get the size. */
14552 for (i
= 0, sect
= section_headers
;
14553 i
< elf_header
.e_shnum
;
14556 unsigned char * contents
;
14559 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14562 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14563 sect
->sh_size
, _("attributes"));
14564 if (contents
== NULL
)
14571 /* The first character is the version of the attributes.
14572 Currently only version 1, (aka 'A') is recognised here. */
14575 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14580 bfd_vma section_len
;
14582 section_len
= sect
->sh_size
- 1;
14585 while (section_len
> 0)
14588 unsigned int namelen
;
14589 bfd_boolean public_section
;
14590 bfd_boolean gnu_section
;
14592 if (section_len
<= 4)
14594 error (_("Tag section ends prematurely\n"));
14598 attr_len
= byte_get (p
, 4);
14601 if (attr_len
> section_len
)
14603 error (_("Bad attribute length (%u > %u)\n"),
14604 (unsigned) attr_len
, (unsigned) section_len
);
14605 attr_len
= section_len
;
14608 /* PR 17531: file: 001-101425-0.004 */
14609 else if (attr_len
< 5)
14611 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14616 section_len
-= attr_len
;
14619 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14620 if (namelen
== 0 || namelen
>= attr_len
)
14622 error (_("Corrupt attribute section name\n"));
14627 printf (_("Attribute Section: "));
14628 print_symbol (INT_MAX
, (const char *) p
);
14631 if (public_name
&& streq ((char *) p
, public_name
))
14632 public_section
= TRUE
;
14634 public_section
= FALSE
;
14636 if (streq ((char *) p
, "gnu"))
14637 gnu_section
= TRUE
;
14639 gnu_section
= FALSE
;
14642 attr_len
-= namelen
;
14644 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14649 unsigned char * end
;
14651 /* PR binutils/17531: Safe handling of corrupt files. */
14654 error (_("Unused bytes at end of section\n"));
14661 size
= byte_get (p
, 4);
14662 if (size
> attr_len
)
14664 error (_("Bad subsection length (%u > %u)\n"),
14665 (unsigned) size
, (unsigned) attr_len
);
14669 /* PR binutils/17531: Safe handling of corrupt files. */
14672 error (_("Bad subsection length (%u < 6)\n"),
14680 end
= p
+ size
- 1;
14681 assert (end
<= contents
+ sect
->sh_size
);
14687 printf (_("File Attributes\n"));
14690 printf (_("Section Attributes:"));
14693 printf (_("Symbol Attributes:"));
14694 /* Fall through. */
14700 val
= read_uleb128 (p
, &j
, end
);
14704 printf (" %d", val
);
14709 printf (_("Unknown tag: %d\n"), tag
);
14710 public_section
= FALSE
;
14714 if (public_section
&& display_pub_attribute
!= NULL
)
14717 p
= display_pub_attribute (p
, end
);
14720 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14723 p
= display_gnu_attribute (p
,
14724 display_proc_gnu_attribute
,
14730 printf (_(" Unknown attribute:\n"));
14731 display_raw_attribute (p
, end
);
14746 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14747 Print the Address, Access and Initial fields of an entry at VMA ADDR
14748 and return the VMA of the next entry, or -1 if there was a problem.
14749 Does not read from DATA_END or beyond. */
14752 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14753 unsigned char * data_end
)
14756 print_vma (addr
, LONG_HEX
);
14758 if (addr
< pltgot
+ 0xfff0)
14759 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14761 printf ("%10s", "");
14764 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14768 unsigned char * from
= data
+ addr
- pltgot
;
14770 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14772 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14773 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14774 return (bfd_vma
) -1;
14778 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14779 print_vma (entry
, LONG_HEX
);
14782 return addr
+ (is_32bit_elf
? 4 : 8);
14785 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14786 PLTGOT. Print the Address and Initial fields of an entry at VMA
14787 ADDR and return the VMA of the next entry. */
14790 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14793 print_vma (addr
, LONG_HEX
);
14796 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14801 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14802 print_vma (entry
, LONG_HEX
);
14804 return addr
+ (is_32bit_elf
? 4 : 8);
14808 print_mips_ases (unsigned int mask
)
14810 if (mask
& AFL_ASE_DSP
)
14811 fputs ("\n\tDSP ASE", stdout
);
14812 if (mask
& AFL_ASE_DSPR2
)
14813 fputs ("\n\tDSP R2 ASE", stdout
);
14814 if (mask
& AFL_ASE_DSPR3
)
14815 fputs ("\n\tDSP R3 ASE", stdout
);
14816 if (mask
& AFL_ASE_EVA
)
14817 fputs ("\n\tEnhanced VA Scheme", stdout
);
14818 if (mask
& AFL_ASE_MCU
)
14819 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14820 if (mask
& AFL_ASE_MDMX
)
14821 fputs ("\n\tMDMX ASE", stdout
);
14822 if (mask
& AFL_ASE_MIPS3D
)
14823 fputs ("\n\tMIPS-3D ASE", stdout
);
14824 if (mask
& AFL_ASE_MT
)
14825 fputs ("\n\tMT ASE", stdout
);
14826 if (mask
& AFL_ASE_SMARTMIPS
)
14827 fputs ("\n\tSmartMIPS ASE", stdout
);
14828 if (mask
& AFL_ASE_VIRT
)
14829 fputs ("\n\tVZ ASE", stdout
);
14830 if (mask
& AFL_ASE_MSA
)
14831 fputs ("\n\tMSA ASE", stdout
);
14832 if (mask
& AFL_ASE_MIPS16
)
14833 fputs ("\n\tMIPS16 ASE", stdout
);
14834 if (mask
& AFL_ASE_MICROMIPS
)
14835 fputs ("\n\tMICROMIPS ASE", stdout
);
14836 if (mask
& AFL_ASE_XPA
)
14837 fputs ("\n\tXPA ASE", stdout
);
14839 fprintf (stdout
, "\n\t%s", _("None"));
14840 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14841 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14845 print_mips_isa_ext (unsigned int isa_ext
)
14850 fputs (_("None"), stdout
);
14853 fputs ("RMI XLR", stdout
);
14855 case AFL_EXT_OCTEON3
:
14856 fputs ("Cavium Networks Octeon3", stdout
);
14858 case AFL_EXT_OCTEON2
:
14859 fputs ("Cavium Networks Octeon2", stdout
);
14861 case AFL_EXT_OCTEONP
:
14862 fputs ("Cavium Networks OcteonP", stdout
);
14864 case AFL_EXT_LOONGSON_3A
:
14865 fputs ("Loongson 3A", stdout
);
14867 case AFL_EXT_OCTEON
:
14868 fputs ("Cavium Networks Octeon", stdout
);
14871 fputs ("Toshiba R5900", stdout
);
14874 fputs ("MIPS R4650", stdout
);
14877 fputs ("LSI R4010", stdout
);
14880 fputs ("NEC VR4100", stdout
);
14883 fputs ("Toshiba R3900", stdout
);
14885 case AFL_EXT_10000
:
14886 fputs ("MIPS R10000", stdout
);
14889 fputs ("Broadcom SB-1", stdout
);
14892 fputs ("NEC VR4111/VR4181", stdout
);
14895 fputs ("NEC VR4120", stdout
);
14898 fputs ("NEC VR5400", stdout
);
14901 fputs ("NEC VR5500", stdout
);
14903 case AFL_EXT_LOONGSON_2E
:
14904 fputs ("ST Microelectronics Loongson 2E", stdout
);
14906 case AFL_EXT_LOONGSON_2F
:
14907 fputs ("ST Microelectronics Loongson 2F", stdout
);
14910 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14915 get_mips_reg_size (int reg_size
)
14917 return (reg_size
== AFL_REG_NONE
) ? 0
14918 : (reg_size
== AFL_REG_32
) ? 32
14919 : (reg_size
== AFL_REG_64
) ? 64
14920 : (reg_size
== AFL_REG_128
) ? 128
14925 process_mips_specific (FILE * file
)
14927 Elf_Internal_Dyn
* entry
;
14928 Elf_Internal_Shdr
*sect
= NULL
;
14929 size_t liblist_offset
= 0;
14930 size_t liblistno
= 0;
14931 size_t conflictsno
= 0;
14932 size_t options_offset
= 0;
14933 size_t conflicts_offset
= 0;
14934 size_t pltrelsz
= 0;
14936 bfd_vma pltgot
= 0;
14937 bfd_vma mips_pltgot
= 0;
14938 bfd_vma jmprel
= 0;
14939 bfd_vma local_gotno
= 0;
14940 bfd_vma gotsym
= 0;
14941 bfd_vma symtabno
= 0;
14942 bfd_boolean res
= TRUE
;
14944 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14945 display_mips_gnu_attribute
))
14948 sect
= find_section (".MIPS.abiflags");
14952 Elf_External_ABIFlags_v0
*abiflags_ext
;
14953 Elf_Internal_ABIFlags_v0 abiflags_in
;
14955 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14957 error (_("Corrupt MIPS ABI Flags section.\n"));
14962 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14963 sect
->sh_size
, _("MIPS ABI Flags section"));
14966 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14967 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14968 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14969 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14970 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14971 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14972 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14973 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14974 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14975 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14976 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14978 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14979 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14980 if (abiflags_in
.isa_rev
> 1)
14981 printf ("r%d", abiflags_in
.isa_rev
);
14982 printf ("\nGPR size: %d",
14983 get_mips_reg_size (abiflags_in
.gpr_size
));
14984 printf ("\nCPR1 size: %d",
14985 get_mips_reg_size (abiflags_in
.cpr1_size
));
14986 printf ("\nCPR2 size: %d",
14987 get_mips_reg_size (abiflags_in
.cpr2_size
));
14988 fputs ("\nFP ABI: ", stdout
);
14989 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14990 fputs ("ISA Extension: ", stdout
);
14991 print_mips_isa_ext (abiflags_in
.isa_ext
);
14992 fputs ("\nASEs:", stdout
);
14993 print_mips_ases (abiflags_in
.ases
);
14994 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14995 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14996 fputc ('\n', stdout
);
14997 free (abiflags_ext
);
15002 /* We have a lot of special sections. Thanks SGI! */
15003 if (dynamic_section
== NULL
)
15004 /* No information available. */
15007 for (entry
= dynamic_section
;
15008 /* PR 17531 file: 012-50589-0.004. */
15009 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15011 switch (entry
->d_tag
)
15013 case DT_MIPS_LIBLIST
:
15015 = offset_from_vma (file
, entry
->d_un
.d_val
,
15016 liblistno
* sizeof (Elf32_External_Lib
));
15018 case DT_MIPS_LIBLISTNO
:
15019 liblistno
= entry
->d_un
.d_val
;
15021 case DT_MIPS_OPTIONS
:
15022 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15024 case DT_MIPS_CONFLICT
:
15026 = offset_from_vma (file
, entry
->d_un
.d_val
,
15027 conflictsno
* sizeof (Elf32_External_Conflict
));
15029 case DT_MIPS_CONFLICTNO
:
15030 conflictsno
= entry
->d_un
.d_val
;
15033 pltgot
= entry
->d_un
.d_ptr
;
15035 case DT_MIPS_LOCAL_GOTNO
:
15036 local_gotno
= entry
->d_un
.d_val
;
15038 case DT_MIPS_GOTSYM
:
15039 gotsym
= entry
->d_un
.d_val
;
15041 case DT_MIPS_SYMTABNO
:
15042 symtabno
= entry
->d_un
.d_val
;
15044 case DT_MIPS_PLTGOT
:
15045 mips_pltgot
= entry
->d_un
.d_ptr
;
15048 pltrel
= entry
->d_un
.d_val
;
15051 pltrelsz
= entry
->d_un
.d_val
;
15054 jmprel
= entry
->d_un
.d_ptr
;
15060 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15062 Elf32_External_Lib
* elib
;
15065 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15067 sizeof (Elf32_External_Lib
),
15068 _("liblist section data"));
15071 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15072 (unsigned long) liblistno
);
15073 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15076 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15083 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15084 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15085 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15086 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15087 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15089 tmp
= gmtime (&atime
);
15090 snprintf (timebuf
, sizeof (timebuf
),
15091 "%04u-%02u-%02uT%02u:%02u:%02u",
15092 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15093 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15095 printf ("%3lu: ", (unsigned long) cnt
);
15096 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15097 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15099 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15100 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15101 liblist
.l_version
);
15103 if (liblist
.l_flags
== 0)
15107 static const struct
15114 { " EXACT_MATCH", LL_EXACT_MATCH
},
15115 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15116 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15117 { " EXPORTS", LL_EXPORTS
},
15118 { " DELAY_LOAD", LL_DELAY_LOAD
},
15119 { " DELTA", LL_DELTA
}
15121 int flags
= liblist
.l_flags
;
15124 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15125 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15127 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15128 flags
^= l_flags_vals
[fcnt
].bit
;
15131 printf (" %#x", (unsigned int) flags
);
15143 if (options_offset
!= 0)
15145 Elf_External_Options
* eopt
;
15146 Elf_Internal_Options
* iopt
;
15147 Elf_Internal_Options
* option
;
15150 sect
= section_headers
;
15152 /* Find the section header so that we get the size. */
15153 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15154 /* PR 17533 file: 012-277276-0.004. */
15157 error (_("No MIPS_OPTIONS header found\n"));
15161 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15162 sect
->sh_size
, _("options"));
15165 iopt
= (Elf_Internal_Options
*)
15166 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15169 error (_("Out of memory allocating space for MIPS options\n"));
15176 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15178 Elf_External_Options
* eoption
;
15180 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15182 option
->kind
= BYTE_GET (eoption
->kind
);
15183 option
->size
= BYTE_GET (eoption
->size
);
15184 option
->section
= BYTE_GET (eoption
->section
);
15185 option
->info
= BYTE_GET (eoption
->info
);
15187 /* PR 17531: file: ffa0fa3b. */
15188 if (option
->size
< sizeof (* eopt
)
15189 || offset
+ option
->size
> sect
->sh_size
)
15191 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15194 offset
+= option
->size
;
15200 printf (_("\nSection '%s' contains %d entries:\n"),
15201 printable_section_name (sect
), cnt
);
15210 switch (option
->kind
)
15213 /* This shouldn't happen. */
15214 printf (" NULL %d %lx", option
->section
, option
->info
);
15217 printf (" REGINFO ");
15218 if (elf_header
.e_machine
== EM_MIPS
)
15221 Elf32_External_RegInfo
* ereg
;
15222 Elf32_RegInfo reginfo
;
15224 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15225 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15226 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15227 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15228 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15229 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15230 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15232 printf ("GPR %08lx GP 0x%lx\n",
15233 reginfo
.ri_gprmask
,
15234 (unsigned long) reginfo
.ri_gp_value
);
15235 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15236 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15237 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15242 Elf64_External_RegInfo
* ereg
;
15243 Elf64_Internal_RegInfo reginfo
;
15245 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15246 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15247 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15248 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15249 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15250 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15251 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15253 printf ("GPR %08lx GP 0x",
15254 reginfo
.ri_gprmask
);
15255 printf_vma (reginfo
.ri_gp_value
);
15258 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15259 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15260 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15264 case ODK_EXCEPTIONS
:
15265 fputs (" EXCEPTIONS fpe_min(", stdout
);
15266 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15267 fputs (") fpe_max(", stdout
);
15268 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15269 fputs (")", stdout
);
15271 if (option
->info
& OEX_PAGE0
)
15272 fputs (" PAGE0", stdout
);
15273 if (option
->info
& OEX_SMM
)
15274 fputs (" SMM", stdout
);
15275 if (option
->info
& OEX_FPDBUG
)
15276 fputs (" FPDBUG", stdout
);
15277 if (option
->info
& OEX_DISMISS
)
15278 fputs (" DISMISS", stdout
);
15281 fputs (" PAD ", stdout
);
15282 if (option
->info
& OPAD_PREFIX
)
15283 fputs (" PREFIX", stdout
);
15284 if (option
->info
& OPAD_POSTFIX
)
15285 fputs (" POSTFIX", stdout
);
15286 if (option
->info
& OPAD_SYMBOL
)
15287 fputs (" SYMBOL", stdout
);
15290 fputs (" HWPATCH ", stdout
);
15291 if (option
->info
& OHW_R4KEOP
)
15292 fputs (" R4KEOP", stdout
);
15293 if (option
->info
& OHW_R8KPFETCH
)
15294 fputs (" R8KPFETCH", stdout
);
15295 if (option
->info
& OHW_R5KEOP
)
15296 fputs (" R5KEOP", stdout
);
15297 if (option
->info
& OHW_R5KCVTL
)
15298 fputs (" R5KCVTL", stdout
);
15301 fputs (" FILL ", stdout
);
15302 /* XXX Print content of info word? */
15305 fputs (" TAGS ", stdout
);
15306 /* XXX Print content of info word? */
15309 fputs (" HWAND ", stdout
);
15310 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15311 fputs (" R4KEOP_CHECKED", stdout
);
15312 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15313 fputs (" R4KEOP_CLEAN", stdout
);
15316 fputs (" HWOR ", stdout
);
15317 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15318 fputs (" R4KEOP_CHECKED", stdout
);
15319 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15320 fputs (" R4KEOP_CLEAN", stdout
);
15323 printf (" GP_GROUP %#06lx self-contained %#06lx",
15324 option
->info
& OGP_GROUP
,
15325 (option
->info
& OGP_SELF
) >> 16);
15328 printf (" IDENT %#06lx self-contained %#06lx",
15329 option
->info
& OGP_GROUP
,
15330 (option
->info
& OGP_SELF
) >> 16);
15333 /* This shouldn't happen. */
15334 printf (" %3d ??? %d %lx",
15335 option
->kind
, option
->section
, option
->info
);
15339 len
= sizeof (* eopt
);
15340 while (len
< option
->size
)
15342 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15344 if (ISPRINT (datum
))
15345 printf ("%c", datum
);
15347 printf ("\\%03o", datum
);
15350 fputs ("\n", stdout
);
15352 offset
+= option
->size
;
15362 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15364 Elf32_Conflict
* iconf
;
15367 if (dynamic_symbols
== NULL
)
15369 error (_("conflict list found without a dynamic symbol table\n"));
15373 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15376 error (_("Out of memory allocating space for dynamic conflicts\n"));
15382 Elf32_External_Conflict
* econf32
;
15384 econf32
= (Elf32_External_Conflict
*)
15385 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15386 sizeof (* econf32
), _("conflict"));
15390 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15391 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15397 Elf64_External_Conflict
* econf64
;
15399 econf64
= (Elf64_External_Conflict
*)
15400 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15401 sizeof (* econf64
), _("conflict"));
15405 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15406 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15411 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15412 (unsigned long) conflictsno
);
15413 puts (_(" Num: Index Value Name"));
15415 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15417 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15419 if (iconf
[cnt
] >= num_dynamic_syms
)
15420 printf (_("<corrupt symbol index>"));
15423 Elf_Internal_Sym
* psym
;
15425 psym
= & dynamic_symbols
[iconf
[cnt
]];
15426 print_vma (psym
->st_value
, FULL_HEX
);
15428 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15429 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15431 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15439 if (pltgot
!= 0 && local_gotno
!= 0)
15441 bfd_vma ent
, local_end
, global_end
;
15443 unsigned char * data
;
15444 unsigned char * data_end
;
15448 addr_size
= (is_32bit_elf
? 4 : 8);
15449 local_end
= pltgot
+ local_gotno
* addr_size
;
15451 /* PR binutils/17533 file: 012-111227-0.004 */
15452 if (symtabno
< gotsym
)
15454 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15455 (unsigned long) gotsym
, (unsigned long) symtabno
);
15459 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15460 /* PR 17531: file: 54c91a34. */
15461 if (global_end
< local_end
)
15463 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15467 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15468 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15469 global_end
- pltgot
, 1,
15470 _("Global Offset Table data"));
15473 data_end
= data
+ (global_end
- pltgot
);
15475 printf (_("\nPrimary GOT:\n"));
15476 printf (_(" Canonical gp value: "));
15477 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15480 printf (_(" Reserved entries:\n"));
15481 printf (_(" %*s %10s %*s Purpose\n"),
15482 addr_size
* 2, _("Address"), _("Access"),
15483 addr_size
* 2, _("Initial"));
15484 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15485 printf (_(" Lazy resolver\n"));
15486 if (ent
== (bfd_vma
) -1)
15487 goto got_print_fail
;
15492 if (data
+ ent
- pltgot
> data_end
- addr_size
)
15494 error (_("Invalid got entry - %#lx - overflows GOT table\n"),
15496 goto got_print_fail
;
15499 if (byte_get (data
+ ent
- pltgot
, addr_size
)
15500 >> (addr_size
* 8 - 1) != 0)
15502 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15503 printf (_(" Module pointer (GNU extension)\n"));
15504 if (ent
== (bfd_vma
) -1)
15505 goto got_print_fail
;
15510 if (ent
< local_end
)
15512 printf (_(" Local entries:\n"));
15513 printf (" %*s %10s %*s\n",
15514 addr_size
* 2, _("Address"), _("Access"),
15515 addr_size
* 2, _("Initial"));
15516 while (ent
< local_end
)
15518 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15520 if (ent
== (bfd_vma
) -1)
15521 goto got_print_fail
;
15526 if (gotsym
< symtabno
)
15530 printf (_(" Global entries:\n"));
15531 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15532 addr_size
* 2, _("Address"),
15534 addr_size
* 2, _("Initial"),
15535 addr_size
* 2, _("Sym.Val."),
15537 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15538 _("Ndx"), _("Name"));
15540 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15542 for (i
= gotsym
; i
< symtabno
; i
++)
15544 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15547 if (dynamic_symbols
== NULL
)
15548 printf (_("<no dynamic symbols>"));
15549 else if (i
< num_dynamic_syms
)
15551 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15553 print_vma (psym
->st_value
, LONG_HEX
);
15554 printf (" %-7s %3s ",
15555 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15556 get_symbol_index_type (psym
->st_shndx
));
15558 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15559 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15561 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15564 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15565 (unsigned long) i
);
15568 if (ent
== (bfd_vma
) -1)
15579 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15582 size_t offset
, rel_offset
;
15583 unsigned long count
, i
;
15584 unsigned char * data
;
15585 int addr_size
, sym_width
;
15586 Elf_Internal_Rela
* rels
;
15588 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15589 if (pltrel
== DT_RELA
)
15591 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15596 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15601 addr_size
= (is_32bit_elf
? 4 : 8);
15602 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15604 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15605 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15606 1, _("Procedure Linkage Table data"));
15610 printf ("\nPLT GOT:\n\n");
15611 printf (_(" Reserved entries:\n"));
15612 printf (_(" %*s %*s Purpose\n"),
15613 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15614 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15615 printf (_(" PLT lazy resolver\n"));
15616 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15617 printf (_(" Module pointer\n"));
15620 printf (_(" Entries:\n"));
15621 printf (" %*s %*s %*s %-7s %3s %s\n",
15622 addr_size
* 2, _("Address"),
15623 addr_size
* 2, _("Initial"),
15624 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15625 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15626 for (i
= 0; i
< count
; i
++)
15628 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15630 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15633 if (idx
>= num_dynamic_syms
)
15634 printf (_("<corrupt symbol index: %lu>"), idx
);
15637 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15639 print_vma (psym
->st_value
, LONG_HEX
);
15640 printf (" %-7s %3s ",
15641 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15642 get_symbol_index_type (psym
->st_shndx
));
15643 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15644 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15646 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15661 process_nds32_specific (FILE * file
)
15663 Elf_Internal_Shdr
*sect
= NULL
;
15665 sect
= find_section (".nds32_e_flags");
15668 unsigned int *flag
;
15670 printf ("\nNDS32 elf flags section:\n");
15671 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15672 sect
->sh_size
, _("NDS32 elf flags section"));
15677 switch ((*flag
) & 0x3)
15680 printf ("(VEC_SIZE):\tNo entry.\n");
15683 printf ("(VEC_SIZE):\t4 bytes\n");
15686 printf ("(VEC_SIZE):\t16 bytes\n");
15689 printf ("(VEC_SIZE):\treserved\n");
15698 process_gnu_liblist (FILE * file
)
15700 Elf_Internal_Shdr
* section
;
15701 Elf_Internal_Shdr
* string_sec
;
15702 Elf32_External_Lib
* elib
;
15704 size_t strtab_size
;
15707 bfd_boolean res
= TRUE
;
15712 for (i
= 0, section
= section_headers
;
15713 i
< elf_header
.e_shnum
;
15716 switch (section
->sh_type
)
15718 case SHT_GNU_LIBLIST
:
15719 if (section
->sh_link
>= elf_header
.e_shnum
)
15722 elib
= (Elf32_External_Lib
*)
15723 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15724 _("liblist section data"));
15732 string_sec
= section_headers
+ section
->sh_link
;
15733 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15734 string_sec
->sh_size
,
15735 _("liblist string table"));
15737 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15744 strtab_size
= string_sec
->sh_size
;
15746 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15747 printable_section_name (section
),
15748 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15750 puts (_(" Library Time Stamp Checksum Version Flags"));
15752 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15760 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15761 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15762 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15763 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15764 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15766 tmp
= gmtime (&atime
);
15767 snprintf (timebuf
, sizeof (timebuf
),
15768 "%04u-%02u-%02uT%02u:%02u:%02u",
15769 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15770 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15772 printf ("%3lu: ", (unsigned long) cnt
);
15774 printf ("%-20s", liblist
.l_name
< strtab_size
15775 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15777 printf ("%-20.20s", liblist
.l_name
< strtab_size
15778 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15779 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15780 liblist
.l_version
, liblist
.l_flags
);
15791 static const char *
15792 get_note_type (unsigned e_type
)
15794 static char buff
[64];
15796 if (elf_header
.e_type
== ET_CORE
)
15800 return _("NT_AUXV (auxiliary vector)");
15802 return _("NT_PRSTATUS (prstatus structure)");
15804 return _("NT_FPREGSET (floating point registers)");
15806 return _("NT_PRPSINFO (prpsinfo structure)");
15807 case NT_TASKSTRUCT
:
15808 return _("NT_TASKSTRUCT (task structure)");
15810 return _("NT_PRXFPREG (user_xfpregs structure)");
15812 return _("NT_PPC_VMX (ppc Altivec registers)");
15814 return _("NT_PPC_VSX (ppc VSX registers)");
15816 return _("NT_386_TLS (x86 TLS information)");
15817 case NT_386_IOPERM
:
15818 return _("NT_386_IOPERM (x86 I/O permissions)");
15819 case NT_X86_XSTATE
:
15820 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15821 case NT_S390_HIGH_GPRS
:
15822 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15823 case NT_S390_TIMER
:
15824 return _("NT_S390_TIMER (s390 timer register)");
15825 case NT_S390_TODCMP
:
15826 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15827 case NT_S390_TODPREG
:
15828 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15830 return _("NT_S390_CTRS (s390 control registers)");
15831 case NT_S390_PREFIX
:
15832 return _("NT_S390_PREFIX (s390 prefix register)");
15833 case NT_S390_LAST_BREAK
:
15834 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15835 case NT_S390_SYSTEM_CALL
:
15836 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15838 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15839 case NT_S390_VXRS_LOW
:
15840 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15841 case NT_S390_VXRS_HIGH
:
15842 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15844 return _("NT_ARM_VFP (arm VFP registers)");
15846 return _("NT_ARM_TLS (AArch TLS registers)");
15847 case NT_ARM_HW_BREAK
:
15848 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15849 case NT_ARM_HW_WATCH
:
15850 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15852 return _("NT_PSTATUS (pstatus structure)");
15854 return _("NT_FPREGS (floating point registers)");
15856 return _("NT_PSINFO (psinfo structure)");
15858 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15860 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15861 case NT_WIN32PSTATUS
:
15862 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15864 return _("NT_SIGINFO (siginfo_t data)");
15866 return _("NT_FILE (mapped files)");
15874 return _("NT_VERSION (version)");
15876 return _("NT_ARCH (architecture)");
15877 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
15878 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15879 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
15880 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15885 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15890 print_core_note (Elf_Internal_Note
*pnote
)
15892 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15893 bfd_vma count
, page_size
;
15894 unsigned char *descdata
, *filenames
, *descend
;
15896 if (pnote
->type
!= NT_FILE
)
15902 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15903 /* Still "successful". */
15908 if (pnote
->descsz
< 2 * addr_size
)
15910 error (_(" Malformed note - too short for header\n"));
15914 descdata
= (unsigned char *) pnote
->descdata
;
15915 descend
= descdata
+ pnote
->descsz
;
15917 if (descdata
[pnote
->descsz
- 1] != '\0')
15919 error (_(" Malformed note - does not end with \\0\n"));
15923 count
= byte_get (descdata
, addr_size
);
15924 descdata
+= addr_size
;
15926 page_size
= byte_get (descdata
, addr_size
);
15927 descdata
+= addr_size
;
15929 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15931 error (_(" Malformed note - too short for supplied file count\n"));
15935 printf (_(" Page size: "));
15936 print_vma (page_size
, DEC
);
15939 printf (_(" %*s%*s%*s\n"),
15940 (int) (2 + 2 * addr_size
), _("Start"),
15941 (int) (4 + 2 * addr_size
), _("End"),
15942 (int) (4 + 2 * addr_size
), _("Page Offset"));
15943 filenames
= descdata
+ count
* 3 * addr_size
;
15944 while (count
-- > 0)
15946 bfd_vma start
, end
, file_ofs
;
15948 if (filenames
== descend
)
15950 error (_(" Malformed note - filenames end too early\n"));
15954 start
= byte_get (descdata
, addr_size
);
15955 descdata
+= addr_size
;
15956 end
= byte_get (descdata
, addr_size
);
15957 descdata
+= addr_size
;
15958 file_ofs
= byte_get (descdata
, addr_size
);
15959 descdata
+= addr_size
;
15962 print_vma (start
, FULL_HEX
);
15964 print_vma (end
, FULL_HEX
);
15966 print_vma (file_ofs
, FULL_HEX
);
15967 printf ("\n %s\n", filenames
);
15969 filenames
+= 1 + strlen ((char *) filenames
);
15975 static const char *
15976 get_gnu_elf_note_type (unsigned e_type
)
15978 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15981 case NT_GNU_ABI_TAG
:
15982 return _("NT_GNU_ABI_TAG (ABI version tag)");
15984 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15985 case NT_GNU_BUILD_ID
:
15986 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15987 case NT_GNU_GOLD_VERSION
:
15988 return _("NT_GNU_GOLD_VERSION (gold version)");
15989 case NT_GNU_PROPERTY_TYPE_0
:
15990 return _("NT_GNU_PROPERTY_TYPE_0");
15991 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
15992 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15993 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
15994 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15997 static char buff
[64];
15999 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16006 decode_x86_isa (unsigned int bitmask
)
16010 unsigned int bit
= bitmask
& (- bitmask
);
16015 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16016 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16017 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16018 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16019 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16020 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16021 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16022 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16023 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16024 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16025 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16026 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16027 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16028 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16029 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16030 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16031 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16032 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16033 default: printf (_("<unknown: %x>"), bit
); break;
16041 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16043 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16044 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16045 unsigned int size
= is_32bit_elf
? 4 : 8;
16047 printf (_(" Properties: "));
16049 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16051 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16058 unsigned int type
= byte_get (ptr
, 4);
16059 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16063 if ((ptr
+ datasz
) > ptr_end
)
16065 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16070 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16072 if (elf_header
.e_machine
== EM_X86_64
16073 || elf_header
.e_machine
== EM_IAMCU
16074 || elf_header
.e_machine
== EM_386
)
16078 case GNU_PROPERTY_X86_ISA_1_USED
:
16079 printf ("x86 ISA used: ");
16081 printf (_("<corrupt length: %#x> "), datasz
);
16083 decode_x86_isa (byte_get (ptr
, 4));
16086 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16087 printf ("x86 ISA needed: ");
16089 printf (_("<corrupt length: %#x> "), datasz
);
16091 decode_x86_isa (byte_get (ptr
, 4));
16103 case GNU_PROPERTY_STACK_SIZE
:
16104 printf (_("stack size: "));
16105 if (datasz
!= size
)
16106 printf (_("<corrupt length: %#x> "), datasz
);
16108 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16111 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16112 printf ("no copy on protected ");
16114 printf (_("<corrupt length: %#x> "), datasz
);
16122 if (type
< GNU_PROPERTY_LOPROC
)
16123 printf (_("<unknown type %#x data: "), type
);
16124 else if (type
< GNU_PROPERTY_LOUSER
)
16125 printf (_("<procesor-specific type %#x data: "), type
);
16127 printf (_("<application-specific type %#x data: "), type
);
16128 for (j
= 0; j
< datasz
; ++j
)
16129 printf ("%02x ", ptr
[j
] & 0xff);
16133 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16134 if (ptr
== ptr_end
)
16144 if (ptr
> (ptr_end
- 8))
16146 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16155 print_gnu_note (Elf_Internal_Note
*pnote
)
16157 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16158 switch (pnote
->type
)
16160 case NT_GNU_BUILD_ID
:
16164 printf (_(" Build ID: "));
16165 for (i
= 0; i
< pnote
->descsz
; ++i
)
16166 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16171 case NT_GNU_ABI_TAG
:
16173 unsigned long os
, major
, minor
, subminor
;
16174 const char *osname
;
16176 /* PR 17531: file: 030-599401-0.004. */
16177 if (pnote
->descsz
< 16)
16179 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16183 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16184 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16185 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16186 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16190 case GNU_ABI_TAG_LINUX
:
16193 case GNU_ABI_TAG_HURD
:
16196 case GNU_ABI_TAG_SOLARIS
:
16197 osname
= "Solaris";
16199 case GNU_ABI_TAG_FREEBSD
:
16200 osname
= "FreeBSD";
16202 case GNU_ABI_TAG_NETBSD
:
16205 case GNU_ABI_TAG_SYLLABLE
:
16206 osname
= "Syllable";
16208 case GNU_ABI_TAG_NACL
:
16212 osname
= "Unknown";
16216 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16217 major
, minor
, subminor
);
16221 case NT_GNU_GOLD_VERSION
:
16225 printf (_(" Version: "));
16226 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16227 printf ("%c", pnote
->descdata
[i
]);
16234 unsigned long num_entries
, mask
;
16236 /* Hardware capabilities information. Word 0 is the number of entries.
16237 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16238 is a series of entries, where each entry is a single byte followed
16239 by a nul terminated string. The byte gives the bit number to test
16240 if enabled in the bitmask. */
16241 printf (_(" Hardware Capabilities: "));
16242 if (pnote
->descsz
< 8)
16244 error (_("<corrupt GNU_HWCAP>\n"));
16247 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16248 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16249 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16250 /* FIXME: Add code to display the entries... */
16254 case NT_GNU_PROPERTY_TYPE_0
:
16255 print_gnu_property_note (pnote
);
16259 /* Handle unrecognised types. An error message should have already been
16260 created by get_gnu_elf_note_type(), so all that we need to do is to
16261 display the data. */
16265 printf (_(" Description data: "));
16266 for (i
= 0; i
< pnote
->descsz
; ++i
)
16267 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16276 static const char *
16277 get_v850_elf_note_type (enum v850_notes n_type
)
16279 static char buff
[64];
16283 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16284 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16285 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16286 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16287 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16288 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16290 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16296 print_v850_note (Elf_Internal_Note
* pnote
)
16300 if (pnote
->descsz
!= 4)
16303 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16307 printf (_("not set\n"));
16311 switch (pnote
->type
)
16313 case V850_NOTE_ALIGNMENT
:
16316 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16317 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16321 case V850_NOTE_DATA_SIZE
:
16324 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16325 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16329 case V850_NOTE_FPU_INFO
:
16332 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16333 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16337 case V850_NOTE_MMU_INFO
:
16338 case V850_NOTE_CACHE_INFO
:
16339 case V850_NOTE_SIMD_INFO
:
16340 if (val
== EF_RH850_SIMD
)
16342 printf (_("yes\n"));
16348 /* An 'unknown note type' message will already have been displayed. */
16352 printf (_("unknown value: %x\n"), val
);
16357 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16359 unsigned int version
;
16361 switch (pnote
->type
)
16363 case NT_NETBSD_IDENT
:
16364 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16365 if ((version
/ 10000) % 100)
16366 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16367 version
, version
/ 100000000, (version
/ 1000000) % 100,
16368 (version
/ 10000) % 100 > 26 ? "Z" : "",
16369 'A' + (version
/ 10000) % 26);
16371 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16372 version
, version
/ 100000000, (version
/ 1000000) % 100,
16373 (version
/ 100) % 100);
16376 case NT_NETBSD_MARCH
:
16377 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16382 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16388 static const char *
16389 get_freebsd_elfcore_note_type (unsigned e_type
)
16393 case NT_FREEBSD_THRMISC
:
16394 return _("NT_THRMISC (thrmisc structure)");
16395 case NT_FREEBSD_PROCSTAT_PROC
:
16396 return _("NT_PROCSTAT_PROC (proc data)");
16397 case NT_FREEBSD_PROCSTAT_FILES
:
16398 return _("NT_PROCSTAT_FILES (files data)");
16399 case NT_FREEBSD_PROCSTAT_VMMAP
:
16400 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16401 case NT_FREEBSD_PROCSTAT_GROUPS
:
16402 return _("NT_PROCSTAT_GROUPS (groups data)");
16403 case NT_FREEBSD_PROCSTAT_UMASK
:
16404 return _("NT_PROCSTAT_UMASK (umask data)");
16405 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16406 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16407 case NT_FREEBSD_PROCSTAT_OSREL
:
16408 return _("NT_PROCSTAT_OSREL (osreldate data)");
16409 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16410 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16411 case NT_FREEBSD_PROCSTAT_AUXV
:
16412 return _("NT_PROCSTAT_AUXV (auxv data)");
16414 return get_note_type (e_type
);
16417 static const char *
16418 get_netbsd_elfcore_note_type (unsigned e_type
)
16420 static char buff
[64];
16422 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16424 /* NetBSD core "procinfo" structure. */
16425 return _("NetBSD procinfo structure");
16428 /* As of Jan 2002 there are no other machine-independent notes
16429 defined for NetBSD core files. If the note type is less
16430 than the start of the machine-dependent note types, we don't
16433 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16435 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16439 switch (elf_header
.e_machine
)
16441 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16442 and PT_GETFPREGS == mach+2. */
16447 case EM_SPARC32PLUS
:
16451 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16452 return _("PT_GETREGS (reg structure)");
16453 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16454 return _("PT_GETFPREGS (fpreg structure)");
16460 /* On all other arch's, PT_GETREGS == mach+1 and
16461 PT_GETFPREGS == mach+3. */
16465 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16466 return _("PT_GETREGS (reg structure)");
16467 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16468 return _("PT_GETFPREGS (fpreg structure)");
16474 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16475 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16479 static const char *
16480 get_stapsdt_note_type (unsigned e_type
)
16482 static char buff
[64];
16487 return _("NT_STAPSDT (SystemTap probe descriptors)");
16493 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16498 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16500 int addr_size
= is_32bit_elf
? 4 : 8;
16501 char *data
= pnote
->descdata
;
16502 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16503 bfd_vma pc
, base_addr
, semaphore
;
16504 char *provider
, *probe
, *arg_fmt
;
16506 pc
= byte_get ((unsigned char *) data
, addr_size
);
16508 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16510 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16514 data
+= strlen (data
) + 1;
16516 data
+= strlen (data
) + 1;
16518 data
+= strlen (data
) + 1;
16520 printf (_(" Provider: %s\n"), provider
);
16521 printf (_(" Name: %s\n"), probe
);
16522 printf (_(" Location: "));
16523 print_vma (pc
, FULL_HEX
);
16524 printf (_(", Base: "));
16525 print_vma (base_addr
, FULL_HEX
);
16526 printf (_(", Semaphore: "));
16527 print_vma (semaphore
, FULL_HEX
);
16529 printf (_(" Arguments: %s\n"), arg_fmt
);
16531 return data
== data_end
;
16534 static const char *
16535 get_ia64_vms_note_type (unsigned e_type
)
16537 static char buff
[64];
16542 return _("NT_VMS_MHD (module header)");
16544 return _("NT_VMS_LNM (language name)");
16546 return _("NT_VMS_SRC (source files)");
16548 return "NT_VMS_TITLE";
16550 return _("NT_VMS_EIDC (consistency check)");
16551 case NT_VMS_FPMODE
:
16552 return _("NT_VMS_FPMODE (FP mode)");
16553 case NT_VMS_LINKTIME
:
16554 return "NT_VMS_LINKTIME";
16555 case NT_VMS_IMGNAM
:
16556 return _("NT_VMS_IMGNAM (image name)");
16558 return _("NT_VMS_IMGID (image id)");
16559 case NT_VMS_LINKID
:
16560 return _("NT_VMS_LINKID (link id)");
16561 case NT_VMS_IMGBID
:
16562 return _("NT_VMS_IMGBID (build id)");
16563 case NT_VMS_GSTNAM
:
16564 return _("NT_VMS_GSTNAM (sym table name)");
16565 case NT_VMS_ORIG_DYN
:
16566 return "NT_VMS_ORIG_DYN";
16567 case NT_VMS_PATCHTIME
:
16568 return "NT_VMS_PATCHTIME";
16570 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16576 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16578 switch (pnote
->type
)
16581 if (pnote
->descsz
> 36)
16583 size_t l
= strlen (pnote
->descdata
+ 34);
16584 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16585 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16586 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16587 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16590 printf (_(" Invalid size\n"));
16593 printf (_(" Language: %s\n"), pnote
->descdata
);
16596 case NT_VMS_FPMODE
:
16597 printf (_(" Floating Point mode: "));
16598 printf ("0x%016" BFD_VMA_FMT
"x\n",
16599 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16601 case NT_VMS_LINKTIME
:
16602 printf (_(" Link time: "));
16604 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16607 case NT_VMS_PATCHTIME
:
16608 printf (_(" Patch time: "));
16610 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16613 case NT_VMS_ORIG_DYN
:
16614 printf (_(" Major id: %u, minor id: %u\n"),
16615 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16616 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16617 printf (_(" Last modified : "));
16619 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16620 printf (_("\n Link flags : "));
16621 printf ("0x%016" BFD_VMA_FMT
"x\n",
16622 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16623 printf (_(" Header flags: 0x%08x\n"),
16624 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16625 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16628 case NT_VMS_IMGNAM
:
16629 printf (_(" Image name: %s\n"), pnote
->descdata
);
16631 case NT_VMS_GSTNAM
:
16632 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16635 printf (_(" Image id: %s\n"), pnote
->descdata
);
16637 case NT_VMS_LINKID
:
16638 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16646 /* Print the name of the symbol associated with a build attribute
16647 that is attached to address OFFSET. */
16650 print_symbol_for_build_attribute (FILE * file
,
16651 unsigned long offset
,
16652 bfd_boolean is_open_attr
)
16654 static FILE * saved_file
= NULL
;
16655 static char * strtab
;
16656 static unsigned long strtablen
;
16657 static Elf_Internal_Sym
* symtab
;
16658 static unsigned long nsyms
;
16659 Elf_Internal_Sym
* saved_sym
= NULL
;
16660 Elf_Internal_Sym
* sym
;
16662 if (saved_file
== NULL
|| file
!= saved_file
)
16664 Elf_Internal_Shdr
* symsec
;
16666 /* Load the symbol and string sections. */
16667 for (symsec
= section_headers
;
16668 symsec
< section_headers
+ elf_header
.e_shnum
;
16671 if (symsec
->sh_type
== SHT_SYMTAB
)
16673 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
16675 if (symsec
->sh_link
< elf_header
.e_shnum
)
16677 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
16679 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
16680 1, strtab_sec
->sh_size
,
16681 _("string table"));
16682 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
16689 if (symtab
== NULL
|| strtab
== NULL
)
16695 /* Find a symbol whose value matches offset. */
16696 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
16697 if (sym
->st_value
== offset
)
16699 if (sym
->st_name
>= strtablen
)
16700 /* Huh ? This should not happen. */
16703 if (strtab
[sym
->st_name
] == 0)
16708 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
16709 and FILE or OBJECT symbols over NOTYPE symbols. We skip
16710 FUNC symbols entirely. */
16711 switch (ELF_ST_TYPE (sym
->st_info
))
16715 /* We can stop searching now. */
16716 sym
= symtab
+ nsyms
;
16724 /* Ignore function symbols. */
16731 switch (ELF_ST_BIND (sym
->st_info
))
16734 if (saved_sym
== NULL
16735 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
16740 if (saved_sym
== NULL
)
16750 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
16758 printf (" (%s: %s)\n",
16759 is_open_attr
? _("file") : _("func"),
16760 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
16765 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
16768 static unsigned long global_offset
= 0;
16769 unsigned long offset
;
16770 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
16771 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
16773 if (pnote
->descsz
== 0)
16777 printf (_(" Applies from offset %#lx\n"), global_offset
);
16782 printf (_(" Applies to func at %#lx"), global_offset
);
16783 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
16787 if (pnote
->descsz
!= desc_size
)
16789 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
16790 printf (_(" <invalid descsz>"));
16794 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
16798 printf (_(" Applies from offset %#lx"), offset
);
16799 global_offset
= offset
;
16803 printf (_(" Applies to func at %#lx"), offset
);
16806 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
16810 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
16813 char name_attribute
;
16814 char * expected_types
;
16815 const char * name
= pnote
->namedata
;
16819 if (name
== NULL
|| pnote
->namesz
< 2)
16821 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
16822 print_symbol (-20, _(" <corrupt name field>"));
16826 switch ((name_type
= * name
))
16828 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
16829 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
16830 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
16831 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
16832 printf ("%c", * name
);
16835 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
16836 print_symbol (-20, _("<unknown name type>"));
16844 switch ((name_attribute
= * name
))
16846 case GNU_BUILD_ATTRIBUTE_VERSION
:
16847 text
= _("<version>");
16848 expected_types
= "$";
16851 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
16852 text
= _("<stack prot>");
16853 expected_types
= "!+*";
16856 case GNU_BUILD_ATTRIBUTE_RELRO
:
16857 text
= _("<relro>");
16858 expected_types
= "!+";
16861 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
16862 text
= _("<stack size>");
16863 expected_types
= "*";
16866 case GNU_BUILD_ATTRIBUTE_TOOL
:
16867 text
= _("<tool>");
16868 expected_types
= "$";
16871 case GNU_BUILD_ATTRIBUTE_ABI
:
16873 expected_types
= "$*";
16876 case GNU_BUILD_ATTRIBUTE_PIC
:
16878 expected_types
= "*";
16881 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
16882 text
= _("<short enum>");
16883 expected_types
= "!+";
16888 if (ISPRINT (* name
))
16890 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
16892 if (len
> left
&& ! do_wide
)
16894 printf ("%.*s:", len
, name
);
16900 error (_("unexpected character in name field\n"));
16901 print_symbol (- left
, _("<unknown attribute>"));
16904 expected_types
= "*$!+";
16910 printf ("%s", text
);
16911 left
-= strlen (text
);
16914 if (strchr (expected_types
, name_type
) == NULL
)
16915 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
16917 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
16919 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
16920 (unsigned long) pnote
->namesz
,
16921 (long) (name
- pnote
->namedata
));
16925 if (left
< 1 && ! do_wide
)
16930 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
16932 unsigned int bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
16933 unsigned long val
= 0;
16934 unsigned int shift
= 0;
16935 char * decoded
= NULL
;
16939 unsigned long byte
= (* name
++) & 0xff;
16941 val
|= byte
<< shift
;
16945 switch (name_attribute
)
16947 case GNU_BUILD_ATTRIBUTE_PIC
:
16950 case 0: decoded
= "static"; break;
16951 case 1: decoded
= "pic"; break;
16952 case 2: decoded
= "PIC"; break;
16953 case 3: decoded
= "pie"; break;
16954 case 4: decoded
= "PIE"; break;
16958 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
16961 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
16962 case 0: decoded
= "off"; break;
16963 case 1: decoded
= "on"; break;
16964 case 2: decoded
= "all"; break;
16965 case 3: decoded
= "strong"; break;
16966 case 4: decoded
= "explicit"; break;
16974 if (decoded
!= NULL
)
16975 print_symbol (-left
, decoded
);
16979 left
-= printf ("0x%lx", val
);
16981 left
-= printf ("0x%-.*lx", left
, val
);
16985 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
16986 left
-= print_symbol (- left
, name
);
16988 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
16989 left
-= print_symbol (- left
, "true");
16991 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
16992 left
-= print_symbol (- left
, "false");
16996 if (do_wide
&& left
> 0)
16997 printf ("%-*s", left
, " ");
17002 /* Note that by the ELF standard, the name field is already null byte
17003 terminated, and namesz includes the terminating null byte.
17004 I.E. the value of namesz for the name "FSF" is 4.
17006 If the value of namesz is zero, there is no name present. */
17009 process_note (Elf_Internal_Note
* pnote
,
17012 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17015 if (pnote
->namesz
== 0)
17016 /* If there is no note name, then use the default set of
17017 note type strings. */
17018 nt
= get_note_type (pnote
->type
);
17020 else if (const_strneq (pnote
->namedata
, "GNU"))
17021 /* GNU-specific object file notes. */
17022 nt
= get_gnu_elf_note_type (pnote
->type
);
17024 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17025 /* FreeBSD-specific core file notes. */
17026 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
17028 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17029 /* NetBSD-specific core file notes. */
17030 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17032 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17033 /* NetBSD-specific core file notes. */
17034 return process_netbsd_elf_note (pnote
);
17036 else if (strneq (pnote
->namedata
, "SPU/", 4))
17038 /* SPU-specific core file notes. */
17039 nt
= pnote
->namedata
+ 4;
17043 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17044 /* VMS/ia64-specific file notes. */
17045 nt
= get_ia64_vms_note_type (pnote
->type
);
17047 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17048 nt
= get_stapsdt_note_type (pnote
->type
);
17051 /* Don't recognize this note name; just use the default set of
17052 note type strings. */
17053 nt
= get_note_type (pnote
->type
);
17057 if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17058 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17059 print_gnu_build_attribute_name (pnote
);
17061 print_symbol (-20, name
);
17064 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17066 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17068 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17069 return print_ia64_vms_note (pnote
);
17070 else if (const_strneq (pnote
->namedata
, "GNU"))
17071 return print_gnu_note (pnote
);
17072 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17073 return print_stapsdt_note (pnote
);
17074 else if (const_strneq (pnote
->namedata
, "CORE"))
17075 return print_core_note (pnote
);
17076 else if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17077 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17078 return print_gnu_build_attribute_description (pnote
, file
);
17084 printf (_(" description data: "));
17085 for (i
= 0; i
< pnote
->descsz
; i
++)
17086 printf ("%02x ", pnote
->descdata
[i
]);
17096 process_notes_at (FILE * file
,
17097 Elf_Internal_Shdr
* section
,
17101 Elf_External_Note
* pnotes
;
17102 Elf_External_Note
* external
;
17104 bfd_boolean res
= TRUE
;
17111 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17114 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17119 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17121 if (pnotes
== NULL
)
17127 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17129 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17130 (unsigned long) offset
, (unsigned long) length
);
17132 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17134 end
= (char *) pnotes
+ length
;
17135 while ((char *) external
< end
)
17137 Elf_Internal_Note inote
;
17140 char * temp
= NULL
;
17141 size_t data_remaining
= end
- (char *) external
;
17143 if (!is_ia64_vms ())
17145 /* PR binutils/15191
17146 Make sure that there is enough data to read. */
17147 min_notesz
= offsetof (Elf_External_Note
, name
);
17148 if (data_remaining
< min_notesz
)
17150 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17151 (int) data_remaining
);
17154 inote
.type
= BYTE_GET (external
->type
);
17155 inote
.namesz
= BYTE_GET (external
->namesz
);
17156 inote
.namedata
= external
->name
;
17157 inote
.descsz
= BYTE_GET (external
->descsz
);
17158 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17159 /* PR 17531: file: 3443835e. */
17160 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17162 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17163 inote
.namesz
, (long)(end
- inote
.namedata
));
17164 inote
.descdata
= inote
.namedata
;
17168 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17169 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17173 Elf64_External_VMS_Note
*vms_external
;
17175 /* PR binutils/15191
17176 Make sure that there is enough data to read. */
17177 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17178 if (data_remaining
< min_notesz
)
17180 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17181 (int) data_remaining
);
17185 vms_external
= (Elf64_External_VMS_Note
*) external
;
17186 inote
.type
= BYTE_GET (vms_external
->type
);
17187 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17188 inote
.namedata
= vms_external
->name
;
17189 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17190 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17191 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17192 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17195 if (inote
.descdata
< (char *) external
+ min_notesz
17196 || next
< (char *) external
+ min_notesz
17197 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17198 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17199 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17200 || data_remaining
< (size_t)(next
- (char *) external
))
17202 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17203 (unsigned long) ((char *) external
- (char *) pnotes
));
17204 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17205 inote
.type
, inote
.namesz
, inote
.descsz
);
17209 external
= (Elf_External_Note
*) next
;
17211 /* Verify that name is null terminated. It appears that at least
17212 one version of Linux (RedHat 6.0) generates corefiles that don't
17213 comply with the ELF spec by failing to include the null byte in
17215 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17217 temp
= (char *) malloc (inote
.namesz
+ 1);
17220 error (_("Out of memory allocating space for inote name\n"));
17225 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17226 temp
[inote
.namesz
] = 0;
17228 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17229 inote
.namedata
= temp
;
17232 if (! process_note (& inote
, file
))
17248 process_corefile_note_segments (FILE * file
)
17250 Elf_Internal_Phdr
* segment
;
17252 bfd_boolean res
= TRUE
;
17254 if (! get_program_headers (file
))
17257 for (i
= 0, segment
= program_headers
;
17258 i
< elf_header
.e_phnum
;
17261 if (segment
->p_type
== PT_NOTE
)
17262 if (! process_notes_at (file
, NULL
,
17263 (bfd_vma
) segment
->p_offset
,
17264 (bfd_vma
) segment
->p_filesz
))
17272 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17274 Elf_External_Note
* pnotes
;
17275 Elf_External_Note
* external
;
17277 bfd_boolean res
= TRUE
;
17282 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17284 if (pnotes
== NULL
)
17288 end
= (char*) pnotes
+ length
;
17290 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17291 (unsigned long) offset
, (unsigned long) length
);
17293 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17295 Elf_External_Note
* next
;
17296 Elf_Internal_Note inote
;
17298 inote
.type
= BYTE_GET (external
->type
);
17299 inote
.namesz
= BYTE_GET (external
->namesz
);
17300 inote
.namedata
= external
->name
;
17301 inote
.descsz
= BYTE_GET (external
->descsz
);
17302 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17303 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17305 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17307 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17308 inote
.descdata
= inote
.namedata
;
17312 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17314 if ( ((char *) next
> end
)
17315 || ((char *) next
< (char *) pnotes
))
17317 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17318 (unsigned long) ((char *) external
- (char *) pnotes
));
17319 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17320 inote
.type
, inote
.namesz
, inote
.descsz
);
17326 /* Prevent out-of-bounds indexing. */
17327 if ( inote
.namedata
+ inote
.namesz
> end
17328 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17330 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17331 (unsigned long) ((char *) external
- (char *) pnotes
));
17332 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17333 inote
.type
, inote
.namesz
, inote
.descsz
);
17337 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17339 if (! print_v850_note (& inote
))
17342 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17343 inote
.namesz
, inote
.descsz
);
17353 process_note_sections (FILE * file
)
17355 Elf_Internal_Shdr
* section
;
17357 unsigned int n
= 0;
17358 bfd_boolean res
= TRUE
;
17360 for (i
= 0, section
= section_headers
;
17361 i
< elf_header
.e_shnum
&& section
!= NULL
;
17364 if (section
->sh_type
== SHT_NOTE
)
17366 if (! process_notes_at (file
, section
,
17367 (bfd_vma
) section
->sh_offset
,
17368 (bfd_vma
) section
->sh_size
))
17373 if (( elf_header
.e_machine
== EM_V800
17374 || elf_header
.e_machine
== EM_V850
17375 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17376 && section
->sh_type
== SHT_RENESAS_INFO
)
17378 if (! process_v850_notes (file
,
17379 (bfd_vma
) section
->sh_offset
,
17380 (bfd_vma
) section
->sh_size
))
17387 /* Try processing NOTE segments instead. */
17388 return process_corefile_note_segments (file
);
17394 process_notes (FILE * file
)
17396 /* If we have not been asked to display the notes then do nothing. */
17400 if (elf_header
.e_type
!= ET_CORE
)
17401 return process_note_sections (file
);
17403 /* No program headers means no NOTE segment. */
17404 if (elf_header
.e_phnum
> 0)
17405 return process_corefile_note_segments (file
);
17407 printf (_("No note segments present in the core file.\n"));
17411 static unsigned char *
17412 display_public_gnu_attributes (unsigned char * start
,
17413 const unsigned char * const end
)
17415 printf (_(" Unknown GNU attribute: %s\n"), start
);
17417 start
+= strnlen ((char *) start
, end
- start
);
17418 display_raw_attribute (start
, end
);
17420 return (unsigned char *) end
;
17423 static unsigned char *
17424 display_generic_attribute (unsigned char * start
,
17426 const unsigned char * const end
)
17429 return (unsigned char *) end
;
17431 return display_tag_value (tag
, start
, end
);
17435 process_arch_specific (FILE * file
)
17440 switch (elf_header
.e_machine
)
17443 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17444 display_arm_attribute
,
17445 display_generic_attribute
);
17448 case EM_MIPS_RS3_LE
:
17449 return process_mips_specific (file
);
17452 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17453 display_msp430x_attribute
,
17454 display_generic_attribute
);
17457 return process_nds32_specific (file
);
17461 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17462 display_power_gnu_attribute
);
17466 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17467 display_s390_gnu_attribute
);
17470 case EM_SPARC32PLUS
:
17472 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17473 display_sparc_gnu_attribute
);
17476 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17477 display_tic6x_attribute
,
17478 display_generic_attribute
);
17481 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17482 display_public_gnu_attributes
,
17483 display_generic_attribute
);
17488 get_file_header (FILE * file
)
17490 /* Read in the identity array. */
17491 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
17494 /* Determine how to read the rest of the header. */
17495 switch (elf_header
.e_ident
[EI_DATA
])
17500 byte_get
= byte_get_little_endian
;
17501 byte_put
= byte_put_little_endian
;
17504 byte_get
= byte_get_big_endian
;
17505 byte_put
= byte_put_big_endian
;
17509 /* For now we only support 32 bit and 64 bit ELF files. */
17510 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
17512 /* Read in the rest of the header. */
17515 Elf32_External_Ehdr ehdr32
;
17517 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
17520 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
17521 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
17522 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
17523 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
17524 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
17525 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
17526 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
17527 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
17528 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
17529 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
17530 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
17531 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
17532 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
17536 Elf64_External_Ehdr ehdr64
;
17538 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17539 we will not be able to cope with the 64bit data found in
17540 64 ELF files. Detect this now and abort before we start
17541 overwriting things. */
17542 if (sizeof (bfd_vma
) < 8)
17544 error (_("This instance of readelf has been built without support for a\n\
17545 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17549 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
17552 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
17553 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
17554 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
17555 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
17556 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
17557 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
17558 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
17559 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
17560 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
17561 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
17562 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
17563 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
17564 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
17567 if (elf_header
.e_shoff
)
17569 /* There may be some extensions in the first section header. Don't
17570 bomb if we can't read it. */
17572 get_32bit_section_headers (file
, TRUE
);
17574 get_64bit_section_headers (file
, TRUE
);
17580 /* Process one ELF object file according to the command line options.
17581 This file may actually be stored in an archive. The file is
17582 positioned at the start of the ELF object. Returns TRUE if no
17583 problems were encountered, FALSE otherwise. */
17586 process_object (char * file_name
, FILE * file
)
17589 bfd_boolean res
= TRUE
;
17591 if (! get_file_header (file
))
17593 error (_("%s: Failed to read file header\n"), file_name
);
17597 /* Initialise per file variables. */
17598 for (i
= ARRAY_SIZE (version_info
); i
--;)
17599 version_info
[i
] = 0;
17601 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
17602 dynamic_info
[i
] = 0;
17603 dynamic_info_DT_GNU_HASH
= 0;
17605 /* Process the file. */
17607 printf (_("\nFile: %s\n"), file_name
);
17609 /* Initialise the dump_sects array from the cmdline_dump_sects array.
17610 Note we do this even if cmdline_dump_sects is empty because we
17611 must make sure that the dump_sets array is zeroed out before each
17612 object file is processed. */
17613 if (num_dump_sects
> num_cmdline_dump_sects
)
17614 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
17616 if (num_cmdline_dump_sects
> 0)
17618 if (num_dump_sects
== 0)
17619 /* A sneaky way of allocating the dump_sects array. */
17620 request_dump_bynumber (num_cmdline_dump_sects
, 0);
17622 assert (num_dump_sects
>= num_cmdline_dump_sects
);
17623 memcpy (dump_sects
, cmdline_dump_sects
,
17624 num_cmdline_dump_sects
* sizeof (* dump_sects
));
17627 if (! process_file_header ())
17630 if (! process_section_headers (file
))
17632 /* Without loaded section headers we cannot process lots of things. */
17633 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
17635 if (! do_using_dynamic
)
17636 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
17639 if (! process_section_groups (file
))
17640 /* Without loaded section groups we cannot process unwind. */
17643 if (process_program_headers (file
))
17644 process_dynamic_section (file
);
17648 if (! process_relocs (file
))
17651 if (! process_unwind (file
))
17654 if (! process_symbol_table (file
))
17657 if (! process_syminfo (file
))
17660 if (! process_version_sections (file
))
17663 if (! process_section_contents (file
))
17666 if (! process_notes (file
))
17669 if (! process_gnu_liblist (file
))
17672 if (! process_arch_specific (file
))
17675 if (program_headers
)
17677 free (program_headers
);
17678 program_headers
= NULL
;
17681 if (section_headers
)
17683 free (section_headers
);
17684 section_headers
= NULL
;
17689 free (string_table
);
17690 string_table
= NULL
;
17691 string_table_length
= 0;
17694 if (dynamic_strings
)
17696 free (dynamic_strings
);
17697 dynamic_strings
= NULL
;
17698 dynamic_strings_length
= 0;
17701 if (dynamic_symbols
)
17703 free (dynamic_symbols
);
17704 dynamic_symbols
= NULL
;
17705 num_dynamic_syms
= 0;
17708 if (dynamic_syminfo
)
17710 free (dynamic_syminfo
);
17711 dynamic_syminfo
= NULL
;
17714 if (dynamic_section
)
17716 free (dynamic_section
);
17717 dynamic_section
= NULL
;
17720 if (section_headers_groups
)
17722 free (section_headers_groups
);
17723 section_headers_groups
= NULL
;
17726 if (section_groups
)
17728 struct group_list
* g
;
17729 struct group_list
* next
;
17731 for (i
= 0; i
< group_count
; i
++)
17733 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
17740 free (section_groups
);
17741 section_groups
= NULL
;
17744 free_debug_memory ();
17749 /* Process an ELF archive.
17750 On entry the file is positioned just after the ARMAG string.
17751 Returns TRUE upon success, FALSE otherwise. */
17754 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
17756 struct archive_info arch
;
17757 struct archive_info nested_arch
;
17759 bfd_boolean ret
= TRUE
;
17763 /* The ARCH structure is used to hold information about this archive. */
17764 arch
.file_name
= NULL
;
17766 arch
.index_array
= NULL
;
17767 arch
.sym_table
= NULL
;
17768 arch
.longnames
= NULL
;
17770 /* The NESTED_ARCH structure is used as a single-item cache of information
17771 about a nested archive (when members of a thin archive reside within
17772 another regular archive file). */
17773 nested_arch
.file_name
= NULL
;
17774 nested_arch
.file
= NULL
;
17775 nested_arch
.index_array
= NULL
;
17776 nested_arch
.sym_table
= NULL
;
17777 nested_arch
.longnames
= NULL
;
17779 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
17785 if (do_archive_index
)
17787 if (arch
.sym_table
== NULL
)
17788 error (_("%s: unable to dump the index as none was found\n"), file_name
);
17791 unsigned long i
, l
;
17792 unsigned long current_pos
;
17794 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17795 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
17796 current_pos
= ftell (file
);
17798 for (i
= l
= 0; i
< arch
.index_num
; i
++)
17800 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
17802 char * member_name
;
17804 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
17806 if (member_name
!= NULL
)
17808 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
17810 if (qualified_name
!= NULL
)
17812 printf (_("Contents of binary %s at offset "), qualified_name
);
17813 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
17815 free (qualified_name
);
17820 if (l
>= arch
.sym_size
)
17822 error (_("%s: end of the symbol table reached before the end of the index\n"),
17827 /* PR 17531: file: 0b6630b2. */
17828 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
17829 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
17832 if (arch
.uses_64bit_indicies
)
17837 if (l
< arch
.sym_size
)
17839 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17840 file_name
, arch
.sym_size
- l
);
17844 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
17846 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
17852 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
17853 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
17854 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
17855 && !do_section_groups
&& !do_dyn_syms
)
17857 ret
= TRUE
; /* Archive index only. */
17866 char * qualified_name
;
17868 /* Read the next archive header. */
17869 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
17871 error (_("%s: failed to seek to next archive header\n"), file_name
);
17874 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
17875 if (got
!= sizeof arch
.arhdr
)
17879 error (_("%s: failed to read archive header\n"), file_name
);
17883 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
17885 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
17890 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
17892 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
17893 if (archive_file_size
& 01)
17894 ++archive_file_size
;
17896 name
= get_archive_member_name (&arch
, &nested_arch
);
17899 error (_("%s: bad archive file name\n"), file_name
);
17903 namelen
= strlen (name
);
17905 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
17906 if (qualified_name
== NULL
)
17908 error (_("%s: bad archive file name\n"), file_name
);
17913 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
17915 /* This is a proxy for an external member of a thin archive. */
17916 FILE * member_file
;
17917 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
17919 if (member_file_name
== NULL
)
17925 member_file
= fopen (member_file_name
, "rb");
17926 if (member_file
== NULL
)
17928 error (_("Input file '%s' is not readable.\n"), member_file_name
);
17929 free (member_file_name
);
17934 archive_file_offset
= arch
.nested_member_origin
;
17936 if (! process_object (qualified_name
, member_file
))
17939 fclose (member_file
);
17940 free (member_file_name
);
17942 else if (is_thin_archive
)
17944 /* PR 15140: Allow for corrupt thin archives. */
17945 if (nested_arch
.file
== NULL
)
17947 error (_("%s: contains corrupt thin archive: %s\n"),
17953 /* This is a proxy for a member of a nested archive. */
17954 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
17956 /* The nested archive file will have been opened and setup by
17957 get_archive_member_name. */
17958 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17960 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17965 if (! process_object (qualified_name
, nested_arch
.file
))
17970 archive_file_offset
= arch
.next_arhdr_offset
;
17971 arch
.next_arhdr_offset
+= archive_file_size
;
17973 if (! process_object (qualified_name
, file
))
17977 if (dump_sects
!= NULL
)
17981 num_dump_sects
= 0;
17984 free (qualified_name
);
17988 if (nested_arch
.file
!= NULL
)
17989 fclose (nested_arch
.file
);
17990 release_archive (&nested_arch
);
17991 release_archive (&arch
);
17997 process_file (char * file_name
)
18000 struct stat statbuf
;
18001 char armag
[SARMAG
];
18002 bfd_boolean ret
= TRUE
;
18004 if (stat (file_name
, &statbuf
) < 0)
18006 if (errno
== ENOENT
)
18007 error (_("'%s': No such file\n"), file_name
);
18009 error (_("Could not locate '%s'. System error message: %s\n"),
18010 file_name
, strerror (errno
));
18014 if (! S_ISREG (statbuf
.st_mode
))
18016 error (_("'%s' is not an ordinary file\n"), file_name
);
18020 file
= fopen (file_name
, "rb");
18023 error (_("Input file '%s' is not readable.\n"), file_name
);
18027 if (fread (armag
, SARMAG
, 1, file
) != 1)
18029 error (_("%s: Failed to read file's magic number\n"), file_name
);
18034 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18036 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18038 if (! process_archive (file_name
, file
, FALSE
))
18041 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18043 if ( ! process_archive (file_name
, file
, TRUE
))
18048 if (do_archive_index
)
18049 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18053 archive_file_size
= archive_file_offset
= 0;
18055 if (! process_object (file_name
, file
))
18060 current_file_size
= 0;
18065 #ifdef SUPPORT_DISASSEMBLY
18066 /* Needed by the i386 disassembler. For extra credit, someone could
18067 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18071 print_address (unsigned int addr
, FILE * outfile
)
18073 fprintf (outfile
,"0x%8.8x", addr
);
18076 /* Needed by the i386 disassembler. */
18078 db_task_printsym (unsigned int addr
)
18080 print_address (addr
, stderr
);
18085 main (int argc
, char ** argv
)
18089 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18090 setlocale (LC_MESSAGES
, "");
18092 #if defined (HAVE_SETLOCALE)
18093 setlocale (LC_CTYPE
, "");
18095 bindtextdomain (PACKAGE
, LOCALEDIR
);
18096 textdomain (PACKAGE
);
18098 expandargv (&argc
, &argv
);
18100 parse_args (argc
, argv
);
18102 if (num_dump_sects
> 0)
18104 /* Make a copy of the dump_sects array. */
18105 cmdline_dump_sects
= (dump_type
*)
18106 malloc (num_dump_sects
* sizeof (* dump_sects
));
18107 if (cmdline_dump_sects
== NULL
)
18108 error (_("Out of memory allocating dump request table.\n"));
18111 memcpy (cmdline_dump_sects
, dump_sects
,
18112 num_dump_sects
* sizeof (* dump_sects
));
18113 num_cmdline_dump_sects
= num_dump_sects
;
18117 if (optind
< (argc
- 1))
18119 else if (optind
>= argc
)
18121 warn (_("Nothing to do.\n"));
18126 while (optind
< argc
)
18127 if (! process_file (argv
[optind
++]))
18130 if (dump_sects
!= NULL
)
18132 if (cmdline_dump_sects
!= NULL
)
18133 free (cmdline_dump_sects
);
18135 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;