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");
2511 case E_ARC_OSABI_V4
:
2512 strcat (buf
, ", v4 ABI");
2515 strcat (buf
, ", unrecognised ARC OSABI flag");
2521 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2524 bfd_boolean unknown
= FALSE
;
2526 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2527 e_flags
&= ~ EF_ARM_EABIMASK
;
2529 /* Handle "generic" ARM flags. */
2530 if (e_flags
& EF_ARM_RELEXEC
)
2532 strcat (buf
, ", relocatable executable");
2533 e_flags
&= ~ EF_ARM_RELEXEC
;
2536 /* Now handle EABI specific flags. */
2540 strcat (buf
, ", <unrecognized EABI>");
2545 case EF_ARM_EABI_VER1
:
2546 strcat (buf
, ", Version1 EABI");
2551 /* Process flags one bit at a time. */
2552 flag
= e_flags
& - e_flags
;
2557 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2558 strcat (buf
, ", sorted symbol tables");
2568 case EF_ARM_EABI_VER2
:
2569 strcat (buf
, ", Version2 EABI");
2574 /* Process flags one bit at a time. */
2575 flag
= e_flags
& - e_flags
;
2580 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2581 strcat (buf
, ", sorted symbol tables");
2584 case EF_ARM_DYNSYMSUSESEGIDX
:
2585 strcat (buf
, ", dynamic symbols use segment index");
2588 case EF_ARM_MAPSYMSFIRST
:
2589 strcat (buf
, ", mapping symbols precede others");
2599 case EF_ARM_EABI_VER3
:
2600 strcat (buf
, ", Version3 EABI");
2603 case EF_ARM_EABI_VER4
:
2604 strcat (buf
, ", Version4 EABI");
2609 /* Process flags one bit at a time. */
2610 flag
= e_flags
& - e_flags
;
2616 strcat (buf
, ", BE8");
2620 strcat (buf
, ", LE8");
2630 case EF_ARM_EABI_VER5
:
2631 strcat (buf
, ", Version5 EABI");
2636 /* Process flags one bit at a time. */
2637 flag
= e_flags
& - e_flags
;
2643 strcat (buf
, ", BE8");
2647 strcat (buf
, ", LE8");
2650 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2651 strcat (buf
, ", soft-float ABI");
2654 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2655 strcat (buf
, ", hard-float ABI");
2665 case EF_ARM_EABI_UNKNOWN
:
2666 strcat (buf
, ", GNU EABI");
2671 /* Process flags one bit at a time. */
2672 flag
= e_flags
& - e_flags
;
2677 case EF_ARM_INTERWORK
:
2678 strcat (buf
, ", interworking enabled");
2681 case EF_ARM_APCS_26
:
2682 strcat (buf
, ", uses APCS/26");
2685 case EF_ARM_APCS_FLOAT
:
2686 strcat (buf
, ", uses APCS/float");
2690 strcat (buf
, ", position independent");
2694 strcat (buf
, ", 8 bit structure alignment");
2697 case EF_ARM_NEW_ABI
:
2698 strcat (buf
, ", uses new ABI");
2701 case EF_ARM_OLD_ABI
:
2702 strcat (buf
, ", uses old ABI");
2705 case EF_ARM_SOFT_FLOAT
:
2706 strcat (buf
, ", software FP");
2709 case EF_ARM_VFP_FLOAT
:
2710 strcat (buf
, ", VFP");
2713 case EF_ARM_MAVERICK_FLOAT
:
2714 strcat (buf
, ", Maverick FP");
2725 strcat (buf
,_(", <unknown>"));
2729 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2731 --size
; /* Leave space for null terminator. */
2733 switch (e_flags
& EF_AVR_MACH
)
2735 case E_AVR_MACH_AVR1
:
2736 strncat (buf
, ", avr:1", size
);
2738 case E_AVR_MACH_AVR2
:
2739 strncat (buf
, ", avr:2", size
);
2741 case E_AVR_MACH_AVR25
:
2742 strncat (buf
, ", avr:25", size
);
2744 case E_AVR_MACH_AVR3
:
2745 strncat (buf
, ", avr:3", size
);
2747 case E_AVR_MACH_AVR31
:
2748 strncat (buf
, ", avr:31", size
);
2750 case E_AVR_MACH_AVR35
:
2751 strncat (buf
, ", avr:35", size
);
2753 case E_AVR_MACH_AVR4
:
2754 strncat (buf
, ", avr:4", size
);
2756 case E_AVR_MACH_AVR5
:
2757 strncat (buf
, ", avr:5", size
);
2759 case E_AVR_MACH_AVR51
:
2760 strncat (buf
, ", avr:51", size
);
2762 case E_AVR_MACH_AVR6
:
2763 strncat (buf
, ", avr:6", size
);
2765 case E_AVR_MACH_AVRTINY
:
2766 strncat (buf
, ", avr:100", size
);
2768 case E_AVR_MACH_XMEGA1
:
2769 strncat (buf
, ", avr:101", size
);
2771 case E_AVR_MACH_XMEGA2
:
2772 strncat (buf
, ", avr:102", size
);
2774 case E_AVR_MACH_XMEGA3
:
2775 strncat (buf
, ", avr:103", size
);
2777 case E_AVR_MACH_XMEGA4
:
2778 strncat (buf
, ", avr:104", size
);
2780 case E_AVR_MACH_XMEGA5
:
2781 strncat (buf
, ", avr:105", size
);
2783 case E_AVR_MACH_XMEGA6
:
2784 strncat (buf
, ", avr:106", size
);
2786 case E_AVR_MACH_XMEGA7
:
2787 strncat (buf
, ", avr:107", size
);
2790 strncat (buf
, ", avr:<unknown>", size
);
2794 size
-= strlen (buf
);
2795 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2796 strncat (buf
, ", link-relax", size
);
2800 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2806 bfd_boolean has_fpu
= FALSE
;
2809 static const char *ABI_STRINGS
[] =
2811 "ABI v0", /* use r5 as return register; only used in N1213HC */
2812 "ABI v1", /* use r0 as return register */
2813 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2814 "ABI v2fp", /* for FPU */
2818 static const char *VER_STRINGS
[] =
2820 "Andes ELF V1.3 or older",
2824 static const char *ARCH_STRINGS
[] =
2833 abi
= EF_NDS_ABI
& e_flags
;
2834 arch
= EF_NDS_ARCH
& e_flags
;
2835 config
= EF_NDS_INST
& e_flags
;
2836 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2838 memset (buf
, 0, size
);
2845 case E_NDS_ABI_V2FP
:
2846 case E_NDS_ABI_AABI
:
2847 case E_NDS_ABI_V2FP_PLUS
:
2848 /* In case there are holes in the array. */
2849 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2853 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2859 case E_NDS32_ELF_VER_1_2
:
2860 case E_NDS32_ELF_VER_1_3
:
2861 case E_NDS32_ELF_VER_1_4
:
2862 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2866 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2870 if (E_NDS_ABI_V0
== abi
)
2872 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2873 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2874 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2875 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2881 case E_NDS_ARCH_STAR_V1_0
:
2882 case E_NDS_ARCH_STAR_V2_0
:
2883 case E_NDS_ARCH_STAR_V3_0
:
2884 case E_NDS_ARCH_STAR_V3_M
:
2885 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2889 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2890 /* ARCH version determines how the e_flags are interpreted.
2891 If it is unknown, we cannot proceed. */
2895 /* Newer ABI; Now handle architecture specific flags. */
2896 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2898 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2899 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2901 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2902 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2904 if (config
& E_NDS32_HAS_DIV_INST
)
2905 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2907 if (config
& E_NDS32_HAS_16BIT_INST
)
2908 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2912 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2914 if (version
<= E_NDS32_ELF_VER_1_3
)
2915 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2917 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2920 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2921 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2923 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2924 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2926 if (config
& E_NDS32_HAS_16BIT_INST
)
2928 if (version
<= E_NDS32_ELF_VER_1_3
)
2929 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2931 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2935 if (config
& E_NDS32_HAS_EXT_INST
)
2936 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2938 if (config
& E_NDS32_HAS_EXT2_INST
)
2939 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2941 if (config
& E_NDS32_HAS_FPU_INST
)
2944 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2947 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2950 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2953 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2956 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2961 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2963 case E_NDS32_FPU_REG_8SP_4DP
:
2964 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2966 case E_NDS32_FPU_REG_16SP_8DP
:
2967 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2969 case E_NDS32_FPU_REG_32SP_16DP
:
2970 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2972 case E_NDS32_FPU_REG_32SP_32DP
:
2973 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2978 if (config
& E_NDS32_HAS_AUDIO_INST
)
2979 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2981 if (config
& E_NDS32_HAS_STRING_INST
)
2982 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2984 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2985 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2987 if (config
& E_NDS32_HAS_VIDEO_INST
)
2989 if (version
<= E_NDS32_ELF_VER_1_3
)
2990 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2992 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2995 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2996 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2998 if (config
& E_NDS32_HAS_L2C_INST
)
2999 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3003 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
3005 static char buf
[1024];
3016 case EM_ARC_COMPACT2
:
3017 case EM_ARC_COMPACT
:
3018 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3022 decode_ARM_machine_flags (e_flags
, buf
);
3026 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3030 if (e_flags
& EF_BFIN_PIC
)
3031 strcat (buf
, ", PIC");
3033 if (e_flags
& EF_BFIN_FDPIC
)
3034 strcat (buf
, ", FDPIC");
3036 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3037 strcat (buf
, ", code in L1");
3039 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3040 strcat (buf
, ", data in L1");
3045 switch (e_flags
& EF_FRV_CPU_MASK
)
3047 case EF_FRV_CPU_GENERIC
:
3051 strcat (buf
, ", fr???");
3054 case EF_FRV_CPU_FR300
:
3055 strcat (buf
, ", fr300");
3058 case EF_FRV_CPU_FR400
:
3059 strcat (buf
, ", fr400");
3061 case EF_FRV_CPU_FR405
:
3062 strcat (buf
, ", fr405");
3065 case EF_FRV_CPU_FR450
:
3066 strcat (buf
, ", fr450");
3069 case EF_FRV_CPU_FR500
:
3070 strcat (buf
, ", fr500");
3072 case EF_FRV_CPU_FR550
:
3073 strcat (buf
, ", fr550");
3076 case EF_FRV_CPU_SIMPLE
:
3077 strcat (buf
, ", simple");
3079 case EF_FRV_CPU_TOMCAT
:
3080 strcat (buf
, ", tomcat");
3086 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3087 strcat (buf
, ", m68000");
3088 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3089 strcat (buf
, ", cpu32");
3090 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3091 strcat (buf
, ", fido_a");
3094 char const * isa
= _("unknown");
3095 char const * mac
= _("unknown mac");
3096 char const * additional
= NULL
;
3098 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3100 case EF_M68K_CF_ISA_A_NODIV
:
3102 additional
= ", nodiv";
3104 case EF_M68K_CF_ISA_A
:
3107 case EF_M68K_CF_ISA_A_PLUS
:
3110 case EF_M68K_CF_ISA_B_NOUSP
:
3112 additional
= ", nousp";
3114 case EF_M68K_CF_ISA_B
:
3117 case EF_M68K_CF_ISA_C
:
3120 case EF_M68K_CF_ISA_C_NODIV
:
3122 additional
= ", nodiv";
3125 strcat (buf
, ", cf, isa ");
3128 strcat (buf
, additional
);
3129 if (e_flags
& EF_M68K_CF_FLOAT
)
3130 strcat (buf
, ", float");
3131 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3136 case EF_M68K_CF_MAC
:
3139 case EF_M68K_CF_EMAC
:
3142 case EF_M68K_CF_EMAC_B
:
3155 switch (e_flags
& EF_MEP_CPU_MASK
)
3157 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3158 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3159 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3160 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3161 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3162 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3163 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3166 switch (e_flags
& EF_MEP_COP_MASK
)
3168 case EF_MEP_COP_NONE
: break;
3169 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3170 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3171 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3172 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3173 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3176 if (e_flags
& EF_MEP_LIBRARY
)
3177 strcat (buf
, ", Built for Library");
3179 if (e_flags
& EF_MEP_INDEX_MASK
)
3180 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3181 e_flags
& EF_MEP_INDEX_MASK
);
3183 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3184 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3185 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3189 if (e_flags
& EF_PPC_EMB
)
3190 strcat (buf
, ", emb");
3192 if (e_flags
& EF_PPC_RELOCATABLE
)
3193 strcat (buf
, _(", relocatable"));
3195 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3196 strcat (buf
, _(", relocatable-lib"));
3200 if (e_flags
& EF_PPC64_ABI
)
3202 char abi
[] = ", abiv0";
3204 abi
[6] += e_flags
& EF_PPC64_ABI
;
3210 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3211 strcat (buf
, ", RH850 ABI");
3213 if (e_flags
& EF_V800_850E3
)
3214 strcat (buf
, ", V3 architecture");
3216 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3217 strcat (buf
, ", FPU not used");
3219 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3220 strcat (buf
, ", regmode: COMMON");
3222 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3223 strcat (buf
, ", r4 not used");
3225 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3226 strcat (buf
, ", r30 not used");
3228 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3229 strcat (buf
, ", r5 not used");
3231 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3232 strcat (buf
, ", r2 not used");
3234 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3236 switch (e_flags
& - e_flags
)
3238 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3239 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3240 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3241 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3242 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3243 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3244 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3245 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3246 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3247 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3248 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3249 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3256 case EM_CYGNUS_V850
:
3257 switch (e_flags
& EF_V850_ARCH
)
3259 case E_V850E3V5_ARCH
:
3260 strcat (buf
, ", v850e3v5");
3262 case E_V850E2V3_ARCH
:
3263 strcat (buf
, ", v850e2v3");
3266 strcat (buf
, ", v850e2");
3269 strcat (buf
, ", v850e1");
3272 strcat (buf
, ", v850e");
3275 strcat (buf
, ", v850");
3278 strcat (buf
, _(", unknown v850 architecture variant"));
3284 case EM_CYGNUS_M32R
:
3285 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3286 strcat (buf
, ", m32r");
3290 case EM_MIPS_RS3_LE
:
3291 if (e_flags
& EF_MIPS_NOREORDER
)
3292 strcat (buf
, ", noreorder");
3294 if (e_flags
& EF_MIPS_PIC
)
3295 strcat (buf
, ", pic");
3297 if (e_flags
& EF_MIPS_CPIC
)
3298 strcat (buf
, ", cpic");
3300 if (e_flags
& EF_MIPS_UCODE
)
3301 strcat (buf
, ", ugen_reserved");
3303 if (e_flags
& EF_MIPS_ABI2
)
3304 strcat (buf
, ", abi2");
3306 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3307 strcat (buf
, ", odk first");
3309 if (e_flags
& EF_MIPS_32BITMODE
)
3310 strcat (buf
, ", 32bitmode");
3312 if (e_flags
& EF_MIPS_NAN2008
)
3313 strcat (buf
, ", nan2008");
3315 if (e_flags
& EF_MIPS_FP64
)
3316 strcat (buf
, ", fp64");
3318 switch ((e_flags
& EF_MIPS_MACH
))
3320 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3321 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3322 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3323 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3324 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3325 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3326 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3327 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3328 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3329 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3330 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3331 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3332 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3333 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3334 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3335 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3336 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3338 /* We simply ignore the field in this case to avoid confusion:
3339 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3342 default: strcat (buf
, _(", unknown CPU")); break;
3345 switch ((e_flags
& EF_MIPS_ABI
))
3347 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3348 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3349 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3350 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3352 /* We simply ignore the field in this case to avoid confusion:
3353 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3354 This means it is likely to be an o32 file, but not for
3357 default: strcat (buf
, _(", unknown ABI")); break;
3360 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3361 strcat (buf
, ", mdmx");
3363 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3364 strcat (buf
, ", mips16");
3366 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3367 strcat (buf
, ", micromips");
3369 switch ((e_flags
& EF_MIPS_ARCH
))
3371 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3372 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3373 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3374 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3375 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3376 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3377 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3378 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3379 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3380 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3381 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3382 default: strcat (buf
, _(", unknown ISA")); break;
3387 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3391 if (e_flags
& EF_RISCV_RVC
)
3392 strcat (buf
, ", RVC");
3394 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3396 case EF_RISCV_FLOAT_ABI_SOFT
:
3397 strcat (buf
, ", soft-float ABI");
3400 case EF_RISCV_FLOAT_ABI_SINGLE
:
3401 strcat (buf
, ", single-float ABI");
3404 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3405 strcat (buf
, ", double-float ABI");
3408 case EF_RISCV_FLOAT_ABI_QUAD
:
3409 strcat (buf
, ", quad-float ABI");
3415 switch ((e_flags
& EF_SH_MACH_MASK
))
3417 case EF_SH1
: strcat (buf
, ", sh1"); break;
3418 case EF_SH2
: strcat (buf
, ", sh2"); break;
3419 case EF_SH3
: strcat (buf
, ", sh3"); break;
3420 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3421 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3422 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3423 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3424 case EF_SH4
: strcat (buf
, ", sh4"); break;
3425 case EF_SH5
: strcat (buf
, ", sh5"); break;
3426 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3427 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3428 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3429 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3430 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3431 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3432 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3433 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3434 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3435 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3436 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3437 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3438 default: strcat (buf
, _(", unknown ISA")); break;
3441 if (e_flags
& EF_SH_PIC
)
3442 strcat (buf
, ", pic");
3444 if (e_flags
& EF_SH_FDPIC
)
3445 strcat (buf
, ", fdpic");
3449 if (e_flags
& EF_OR1K_NODELAY
)
3450 strcat (buf
, ", no delay");
3454 if (e_flags
& EF_SPARC_32PLUS
)
3455 strcat (buf
, ", v8+");
3457 if (e_flags
& EF_SPARC_SUN_US1
)
3458 strcat (buf
, ", ultrasparcI");
3460 if (e_flags
& EF_SPARC_SUN_US3
)
3461 strcat (buf
, ", ultrasparcIII");
3463 if (e_flags
& EF_SPARC_HAL_R1
)
3464 strcat (buf
, ", halr1");
3466 if (e_flags
& EF_SPARC_LEDATA
)
3467 strcat (buf
, ", ledata");
3469 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3470 strcat (buf
, ", tso");
3472 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3473 strcat (buf
, ", pso");
3475 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3476 strcat (buf
, ", rmo");
3480 switch (e_flags
& EF_PARISC_ARCH
)
3482 case EFA_PARISC_1_0
:
3483 strcpy (buf
, ", PA-RISC 1.0");
3485 case EFA_PARISC_1_1
:
3486 strcpy (buf
, ", PA-RISC 1.1");
3488 case EFA_PARISC_2_0
:
3489 strcpy (buf
, ", PA-RISC 2.0");
3494 if (e_flags
& EF_PARISC_TRAPNIL
)
3495 strcat (buf
, ", trapnil");
3496 if (e_flags
& EF_PARISC_EXT
)
3497 strcat (buf
, ", ext");
3498 if (e_flags
& EF_PARISC_LSB
)
3499 strcat (buf
, ", lsb");
3500 if (e_flags
& EF_PARISC_WIDE
)
3501 strcat (buf
, ", wide");
3502 if (e_flags
& EF_PARISC_NO_KABP
)
3503 strcat (buf
, ", no kabp");
3504 if (e_flags
& EF_PARISC_LAZYSWAP
)
3505 strcat (buf
, ", lazyswap");
3510 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3511 strcat (buf
, ", new calling convention");
3513 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3514 strcat (buf
, ", gnu calling convention");
3518 if ((e_flags
& EF_IA_64_ABI64
))
3519 strcat (buf
, ", 64-bit");
3521 strcat (buf
, ", 32-bit");
3522 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3523 strcat (buf
, ", reduced fp model");
3524 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3525 strcat (buf
, ", no function descriptors, constant gp");
3526 else if ((e_flags
& EF_IA_64_CONS_GP
))
3527 strcat (buf
, ", constant gp");
3528 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3529 strcat (buf
, ", absolute");
3530 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3532 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3533 strcat (buf
, ", vms_linkages");
3534 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3536 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3538 case EF_IA_64_VMS_COMCOD_WARNING
:
3539 strcat (buf
, ", warning");
3541 case EF_IA_64_VMS_COMCOD_ERROR
:
3542 strcat (buf
, ", error");
3544 case EF_IA_64_VMS_COMCOD_ABORT
:
3545 strcat (buf
, ", abort");
3548 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3549 e_flags
& EF_IA_64_VMS_COMCOD
);
3550 strcat (buf
, ", <unknown>");
3556 if ((e_flags
& EF_VAX_NONPIC
))
3557 strcat (buf
, ", non-PIC");
3558 if ((e_flags
& EF_VAX_DFLOAT
))
3559 strcat (buf
, ", D-Float");
3560 if ((e_flags
& EF_VAX_GFLOAT
))
3561 strcat (buf
, ", G-Float");
3565 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3566 strcat (buf
, ", mcm");
3567 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3568 strcat (buf
, ", mcm24");
3569 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3570 strcat (buf
, ", gr6");
3574 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3576 case E_FLAG_RL78_ANY_CPU
: break;
3577 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3578 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3579 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3581 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3582 strcat (buf
, ", 64-bit doubles");
3586 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3587 strcat (buf
, ", 64-bit doubles");
3588 if (e_flags
& E_FLAG_RX_DSP
)
3589 strcat (buf
, ", dsp");
3590 if (e_flags
& E_FLAG_RX_PID
)
3591 strcat (buf
, ", pid");
3592 if (e_flags
& E_FLAG_RX_ABI
)
3593 strcat (buf
, ", RX ABI");
3594 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3595 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3596 ? ", uses String instructions" : ", bans String instructions");
3597 if (e_flags
& E_FLAG_RX_V2
)
3598 strcat (buf
, ", V2");
3602 if (e_flags
& EF_S390_HIGH_GPRS
)
3603 strcat (buf
, ", highgprs");
3607 if ((e_flags
& EF_C6000_REL
))
3608 strcat (buf
, ", relocatable module");
3612 strcat (buf
, _(": architecture variant: "));
3613 switch (e_flags
& EF_MSP430_MACH
)
3615 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3616 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3617 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3618 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3619 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3620 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3621 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3622 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3623 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3624 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3625 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3626 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3627 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3628 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3629 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3631 strcat (buf
, _(": unknown")); break;
3634 if (e_flags
& ~ EF_MSP430_MACH
)
3635 strcat (buf
, _(": unknown extra flag bits also present"));
3643 get_osabi_name (unsigned int osabi
)
3645 static char buff
[32];
3649 case ELFOSABI_NONE
: return "UNIX - System V";
3650 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3651 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3652 case ELFOSABI_GNU
: return "UNIX - GNU";
3653 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3654 case ELFOSABI_AIX
: return "UNIX - AIX";
3655 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3656 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3657 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3658 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3659 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3660 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3661 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3662 case ELFOSABI_AROS
: return "AROS";
3663 case ELFOSABI_FENIXOS
: return "FenixOS";
3664 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3665 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3668 switch (elf_header
.e_machine
)
3673 case ELFOSABI_ARM
: return "ARM";
3684 case ELFOSABI_STANDALONE
: return _("Standalone App");
3693 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3694 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3703 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3709 get_aarch64_segment_type (unsigned long type
)
3713 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3714 default: return NULL
;
3719 get_arm_segment_type (unsigned long type
)
3723 case PT_ARM_EXIDX
: return "EXIDX";
3724 default: return NULL
;
3729 get_mips_segment_type (unsigned long type
)
3733 case PT_MIPS_REGINFO
: return "REGINFO";
3734 case PT_MIPS_RTPROC
: return "RTPROC";
3735 case PT_MIPS_OPTIONS
: return "OPTIONS";
3736 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3737 default: return NULL
;
3742 get_parisc_segment_type (unsigned long type
)
3746 case PT_HP_TLS
: return "HP_TLS";
3747 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3748 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3749 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3750 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3751 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3752 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3753 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3754 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3755 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3756 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3757 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3758 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3759 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3760 case PT_HP_STACK
: return "HP_STACK";
3761 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3762 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3763 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3764 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3765 default: return NULL
;
3770 get_ia64_segment_type (unsigned long type
)
3774 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3775 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3776 case PT_HP_TLS
: return "HP_TLS";
3777 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3778 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3779 case PT_IA_64_HP_STACK
: return "HP_STACK";
3780 default: return NULL
;
3785 get_tic6x_segment_type (unsigned long type
)
3789 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3790 default: return NULL
;
3795 get_solaris_segment_type (unsigned long type
)
3799 case 0x6464e550: return "PT_SUNW_UNWIND";
3800 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3801 case 0x6ffffff7: return "PT_LOSUNW";
3802 case 0x6ffffffa: return "PT_SUNWBSS";
3803 case 0x6ffffffb: return "PT_SUNWSTACK";
3804 case 0x6ffffffc: return "PT_SUNWDTRACE";
3805 case 0x6ffffffd: return "PT_SUNWCAP";
3806 case 0x6fffffff: return "PT_HISUNW";
3807 default: return NULL
;
3812 get_segment_type (unsigned long p_type
)
3814 static char buff
[32];
3818 case PT_NULL
: return "NULL";
3819 case PT_LOAD
: return "LOAD";
3820 case PT_DYNAMIC
: return "DYNAMIC";
3821 case PT_INTERP
: return "INTERP";
3822 case PT_NOTE
: return "NOTE";
3823 case PT_SHLIB
: return "SHLIB";
3824 case PT_PHDR
: return "PHDR";
3825 case PT_TLS
: return "TLS";
3826 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3827 case PT_GNU_STACK
: return "GNU_STACK";
3828 case PT_GNU_RELRO
: return "GNU_RELRO";
3831 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3833 sprintf (buff
, "GNU_MBIND+%#lx",
3834 p_type
- PT_GNU_MBIND_LO
);
3836 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3838 const char * result
;
3840 switch (elf_header
.e_machine
)
3843 result
= get_aarch64_segment_type (p_type
);
3846 result
= get_arm_segment_type (p_type
);
3849 case EM_MIPS_RS3_LE
:
3850 result
= get_mips_segment_type (p_type
);
3853 result
= get_parisc_segment_type (p_type
);
3856 result
= get_ia64_segment_type (p_type
);
3859 result
= get_tic6x_segment_type (p_type
);
3869 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3871 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3873 const char * result
;
3875 switch (elf_header
.e_machine
)
3878 result
= get_parisc_segment_type (p_type
);
3881 result
= get_ia64_segment_type (p_type
);
3884 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3885 result
= get_solaris_segment_type (p_type
);
3894 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3897 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3904 get_arc_section_type_name (unsigned int sh_type
)
3908 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3916 get_mips_section_type_name (unsigned int sh_type
)
3920 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3921 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3922 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3923 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3924 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3925 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3926 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3927 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3928 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3929 case SHT_MIPS_RELD
: return "MIPS_RELD";
3930 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3931 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3932 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3933 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3934 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3935 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3936 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3937 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3938 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3939 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3940 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3941 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3942 case SHT_MIPS_LINE
: return "MIPS_LINE";
3943 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3944 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3945 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3946 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3947 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3948 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3949 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3950 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3951 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3952 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3953 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3954 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3955 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3956 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3957 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3958 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3959 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3967 get_parisc_section_type_name (unsigned int sh_type
)
3971 case SHT_PARISC_EXT
: return "PARISC_EXT";
3972 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3973 case SHT_PARISC_DOC
: return "PARISC_DOC";
3974 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3975 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3976 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3977 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3978 default: return NULL
;
3983 get_ia64_section_type_name (unsigned int sh_type
)
3985 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3986 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3987 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3991 case SHT_IA_64_EXT
: return "IA_64_EXT";
3992 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3993 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3994 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3995 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3996 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3997 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3998 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3999 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4000 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4008 get_x86_64_section_type_name (unsigned int sh_type
)
4012 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4013 default: return NULL
;
4018 get_aarch64_section_type_name (unsigned int sh_type
)
4022 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4023 default: return NULL
;
4028 get_arm_section_type_name (unsigned int sh_type
)
4032 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4033 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4034 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4035 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4036 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4037 default: return NULL
;
4042 get_tic6x_section_type_name (unsigned int sh_type
)
4046 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4047 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4048 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4049 case SHT_TI_ICODE
: return "TI_ICODE";
4050 case SHT_TI_XREF
: return "TI_XREF";
4051 case SHT_TI_HANDLER
: return "TI_HANDLER";
4052 case SHT_TI_INITINFO
: return "TI_INITINFO";
4053 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4054 default: return NULL
;
4059 get_msp430x_section_type_name (unsigned int sh_type
)
4063 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4064 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4065 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4066 default: return NULL
;
4071 get_v850_section_type_name (unsigned int sh_type
)
4075 case SHT_V850_SCOMMON
: return "V850 Small Common";
4076 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4077 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4078 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4079 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4080 default: return NULL
;
4085 get_section_type_name (unsigned int sh_type
)
4087 static char buff
[32];
4088 const char * result
;
4092 case SHT_NULL
: return "NULL";
4093 case SHT_PROGBITS
: return "PROGBITS";
4094 case SHT_SYMTAB
: return "SYMTAB";
4095 case SHT_STRTAB
: return "STRTAB";
4096 case SHT_RELA
: return "RELA";
4097 case SHT_HASH
: return "HASH";
4098 case SHT_DYNAMIC
: return "DYNAMIC";
4099 case SHT_NOTE
: return "NOTE";
4100 case SHT_NOBITS
: return "NOBITS";
4101 case SHT_REL
: return "REL";
4102 case SHT_SHLIB
: return "SHLIB";
4103 case SHT_DYNSYM
: return "DYNSYM";
4104 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4105 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4106 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4107 case SHT_GNU_HASH
: return "GNU_HASH";
4108 case SHT_GROUP
: return "GROUP";
4109 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4110 case SHT_GNU_verdef
: return "VERDEF";
4111 case SHT_GNU_verneed
: return "VERNEED";
4112 case SHT_GNU_versym
: return "VERSYM";
4113 case 0x6ffffff0: return "VERSYM";
4114 case 0x6ffffffc: return "VERDEF";
4115 case 0x7ffffffd: return "AUXILIARY";
4116 case 0x7fffffff: return "FILTER";
4117 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4120 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4122 switch (elf_header
.e_machine
)
4125 case EM_ARC_COMPACT
:
4126 case EM_ARC_COMPACT2
:
4127 result
= get_arc_section_type_name (sh_type
);
4130 case EM_MIPS_RS3_LE
:
4131 result
= get_mips_section_type_name (sh_type
);
4134 result
= get_parisc_section_type_name (sh_type
);
4137 result
= get_ia64_section_type_name (sh_type
);
4142 result
= get_x86_64_section_type_name (sh_type
);
4145 result
= get_aarch64_section_type_name (sh_type
);
4148 result
= get_arm_section_type_name (sh_type
);
4151 result
= get_tic6x_section_type_name (sh_type
);
4154 result
= get_msp430x_section_type_name (sh_type
);
4158 case EM_CYGNUS_V850
:
4159 result
= get_v850_section_type_name (sh_type
);
4169 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4171 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4173 switch (elf_header
.e_machine
)
4176 result
= get_ia64_section_type_name (sh_type
);
4179 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4180 result
= get_solaris_section_type (sh_type
);
4185 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4186 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4187 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4188 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4200 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4202 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4204 switch (elf_header
.e_machine
)
4208 case EM_CYGNUS_V850
:
4209 result
= get_v850_section_type_name (sh_type
);
4219 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4222 /* This message is probably going to be displayed in a 15
4223 character wide field, so put the hex value first. */
4224 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4230 #define OPTION_DEBUG_DUMP 512
4231 #define OPTION_DYN_SYMS 513
4232 #define OPTION_DWARF_DEPTH 514
4233 #define OPTION_DWARF_START 515
4234 #define OPTION_DWARF_CHECK 516
4236 static struct option options
[] =
4238 {"all", no_argument
, 0, 'a'},
4239 {"file-header", no_argument
, 0, 'h'},
4240 {"program-headers", no_argument
, 0, 'l'},
4241 {"headers", no_argument
, 0, 'e'},
4242 {"histogram", no_argument
, 0, 'I'},
4243 {"segments", no_argument
, 0, 'l'},
4244 {"sections", no_argument
, 0, 'S'},
4245 {"section-headers", no_argument
, 0, 'S'},
4246 {"section-groups", no_argument
, 0, 'g'},
4247 {"section-details", no_argument
, 0, 't'},
4248 {"full-section-name",no_argument
, 0, 'N'},
4249 {"symbols", no_argument
, 0, 's'},
4250 {"syms", no_argument
, 0, 's'},
4251 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4252 {"relocs", no_argument
, 0, 'r'},
4253 {"notes", no_argument
, 0, 'n'},
4254 {"dynamic", no_argument
, 0, 'd'},
4255 {"arch-specific", no_argument
, 0, 'A'},
4256 {"version-info", no_argument
, 0, 'V'},
4257 {"use-dynamic", no_argument
, 0, 'D'},
4258 {"unwind", no_argument
, 0, 'u'},
4259 {"archive-index", no_argument
, 0, 'c'},
4260 {"hex-dump", required_argument
, 0, 'x'},
4261 {"relocated-dump", required_argument
, 0, 'R'},
4262 {"string-dump", required_argument
, 0, 'p'},
4263 {"decompress", no_argument
, 0, 'z'},
4264 #ifdef SUPPORT_DISASSEMBLY
4265 {"instruction-dump", required_argument
, 0, 'i'},
4267 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4269 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4270 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4271 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4273 {"version", no_argument
, 0, 'v'},
4274 {"wide", no_argument
, 0, 'W'},
4275 {"help", no_argument
, 0, 'H'},
4276 {0, no_argument
, 0, 0}
4280 usage (FILE * stream
)
4282 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4283 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4284 fprintf (stream
, _(" Options are:\n\
4285 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4286 -h --file-header Display the ELF file header\n\
4287 -l --program-headers Display the program headers\n\
4288 --segments An alias for --program-headers\n\
4289 -S --section-headers Display the sections' header\n\
4290 --sections An alias for --section-headers\n\
4291 -g --section-groups Display the section groups\n\
4292 -t --section-details Display the section details\n\
4293 -e --headers Equivalent to: -h -l -S\n\
4294 -s --syms Display the symbol table\n\
4295 --symbols An alias for --syms\n\
4296 --dyn-syms Display the dynamic symbol table\n\
4297 -n --notes Display the core notes (if present)\n\
4298 -r --relocs Display the relocations (if present)\n\
4299 -u --unwind Display the unwind info (if present)\n\
4300 -d --dynamic Display the dynamic section (if present)\n\
4301 -V --version-info Display the version sections (if present)\n\
4302 -A --arch-specific Display architecture specific information (if any)\n\
4303 -c --archive-index Display the symbol/file index in an archive\n\
4304 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4305 -x --hex-dump=<number|name>\n\
4306 Dump the contents of section <number|name> as bytes\n\
4307 -p --string-dump=<number|name>\n\
4308 Dump the contents of section <number|name> as strings\n\
4309 -R --relocated-dump=<number|name>\n\
4310 Dump the contents of section <number|name> as relocated bytes\n\
4311 -z --decompress Decompress section before dumping it\n\
4312 -w[lLiaprmfFsoRt] or\n\
4313 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4314 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4315 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4317 Display the contents of DWARF2 debug sections\n"));
4318 fprintf (stream
, _("\
4319 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4320 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4322 #ifdef SUPPORT_DISASSEMBLY
4323 fprintf (stream
, _("\
4324 -i --instruction-dump=<number|name>\n\
4325 Disassemble the contents of section <number|name>\n"));
4327 fprintf (stream
, _("\
4328 -I --histogram Display histogram of bucket list lengths\n\
4329 -W --wide Allow output width to exceed 80 characters\n\
4330 @<file> Read options from <file>\n\
4331 -H --help Display this information\n\
4332 -v --version Display the version number of readelf\n"));
4334 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4335 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4337 exit (stream
== stdout
? 0 : 1);
4340 /* Record the fact that the user wants the contents of section number
4341 SECTION to be displayed using the method(s) encoded as flags bits
4342 in TYPE. Note, TYPE can be zero if we are creating the array for
4346 request_dump_bynumber (unsigned int section
, dump_type type
)
4348 if (section
>= num_dump_sects
)
4350 dump_type
* new_dump_sects
;
4352 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4353 sizeof (* dump_sects
));
4355 if (new_dump_sects
== NULL
)
4356 error (_("Out of memory allocating dump request table.\n"));
4361 /* Copy current flag settings. */
4362 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4367 dump_sects
= new_dump_sects
;
4368 num_dump_sects
= section
+ 1;
4373 dump_sects
[section
] |= type
;
4378 /* Request a dump by section name. */
4381 request_dump_byname (const char * section
, dump_type type
)
4383 struct dump_list_entry
* new_request
;
4385 new_request
= (struct dump_list_entry
*)
4386 malloc (sizeof (struct dump_list_entry
));
4388 error (_("Out of memory allocating dump request table.\n"));
4390 new_request
->name
= strdup (section
);
4391 if (!new_request
->name
)
4392 error (_("Out of memory allocating dump request table.\n"));
4394 new_request
->type
= type
;
4396 new_request
->next
= dump_sects_byname
;
4397 dump_sects_byname
= new_request
;
4401 request_dump (dump_type type
)
4407 section
= strtoul (optarg
, & cp
, 0);
4409 if (! *cp
&& section
>= 0)
4410 request_dump_bynumber (section
, type
);
4412 request_dump_byname (optarg
, type
);
4417 parse_args (int argc
, char ** argv
)
4424 while ((c
= getopt_long
4425 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4443 do_section_groups
= TRUE
;
4446 do_histogram
= TRUE
;
4451 do_section_groups
= TRUE
;
4456 do_section_details
= TRUE
;
4467 do_using_dynamic
= TRUE
;
4491 do_histogram
= TRUE
;
4497 do_archive_index
= TRUE
;
4500 request_dump (HEX_DUMP
);
4503 request_dump (STRING_DUMP
);
4506 request_dump (RELOC_DUMP
);
4509 decompress_dumps
= TRUE
;
4515 do_debugging
= TRUE
;
4516 dwarf_select_sections_all ();
4520 do_debugging
= FALSE
;
4521 dwarf_select_sections_by_letters (optarg
);
4524 case OPTION_DEBUG_DUMP
:
4527 do_debugging
= TRUE
;
4530 do_debugging
= FALSE
;
4531 dwarf_select_sections_by_names (optarg
);
4534 case OPTION_DWARF_DEPTH
:
4538 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4541 case OPTION_DWARF_START
:
4545 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4548 case OPTION_DWARF_CHECK
:
4551 case OPTION_DYN_SYMS
:
4554 #ifdef SUPPORT_DISASSEMBLY
4556 request_dump (DISASS_DUMP
);
4560 print_version (program_name
);
4569 /* xgettext:c-format */
4570 error (_("Invalid option '-%c'\n"), c
);
4577 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4578 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4579 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4580 && !do_section_groups
&& !do_archive_index
4586 get_elf_class (unsigned int elf_class
)
4588 static char buff
[32];
4592 case ELFCLASSNONE
: return _("none");
4593 case ELFCLASS32
: return "ELF32";
4594 case ELFCLASS64
: return "ELF64";
4596 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4602 get_data_encoding (unsigned int encoding
)
4604 static char buff
[32];
4608 case ELFDATANONE
: return _("none");
4609 case ELFDATA2LSB
: return _("2's complement, little endian");
4610 case ELFDATA2MSB
: return _("2's complement, big endian");
4612 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4617 /* Decode the data held in 'elf_header'. */
4620 process_file_header (void)
4622 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4623 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4624 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4625 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4628 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4632 init_dwarf_regnames (elf_header
.e_machine
);
4638 printf (_("ELF Header:\n"));
4639 printf (_(" Magic: "));
4640 for (i
= 0; i
< EI_NIDENT
; i
++)
4641 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4643 printf (_(" Class: %s\n"),
4644 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4645 printf (_(" Data: %s\n"),
4646 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4647 printf (_(" Version: %d %s\n"),
4648 elf_header
.e_ident
[EI_VERSION
],
4649 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4651 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4652 ? _("<unknown: %lx>")
4654 printf (_(" OS/ABI: %s\n"),
4655 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4656 printf (_(" ABI Version: %d\n"),
4657 elf_header
.e_ident
[EI_ABIVERSION
]);
4658 printf (_(" Type: %s\n"),
4659 get_file_type (elf_header
.e_type
));
4660 printf (_(" Machine: %s\n"),
4661 get_machine_name (elf_header
.e_machine
));
4662 printf (_(" Version: 0x%lx\n"),
4663 (unsigned long) elf_header
.e_version
);
4665 printf (_(" Entry point address: "));
4666 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4667 printf (_("\n Start of program headers: "));
4668 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4669 printf (_(" (bytes into file)\n Start of section headers: "));
4670 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4671 printf (_(" (bytes into file)\n"));
4673 printf (_(" Flags: 0x%lx%s\n"),
4674 (unsigned long) elf_header
.e_flags
,
4675 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4676 printf (_(" Size of this header: %ld (bytes)\n"),
4677 (long) elf_header
.e_ehsize
);
4678 printf (_(" Size of program headers: %ld (bytes)\n"),
4679 (long) elf_header
.e_phentsize
);
4680 printf (_(" Number of program headers: %ld"),
4681 (long) elf_header
.e_phnum
);
4682 if (section_headers
!= NULL
4683 && elf_header
.e_phnum
== PN_XNUM
4684 && section_headers
[0].sh_info
!= 0)
4685 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4686 putc ('\n', stdout
);
4687 printf (_(" Size of section headers: %ld (bytes)\n"),
4688 (long) elf_header
.e_shentsize
);
4689 printf (_(" Number of section headers: %ld"),
4690 (long) elf_header
.e_shnum
);
4691 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4692 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4693 putc ('\n', stdout
);
4694 printf (_(" Section header string table index: %ld"),
4695 (long) elf_header
.e_shstrndx
);
4696 if (section_headers
!= NULL
4697 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4698 printf (" (%u)", section_headers
[0].sh_link
);
4699 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4700 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4701 printf (_(" <corrupt: out of range>"));
4702 putc ('\n', stdout
);
4705 if (section_headers
!= NULL
)
4707 if (elf_header
.e_phnum
== PN_XNUM
4708 && section_headers
[0].sh_info
!= 0)
4709 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4710 if (elf_header
.e_shnum
== SHN_UNDEF
)
4711 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4712 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4713 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4714 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4715 elf_header
.e_shstrndx
= SHN_UNDEF
;
4716 free (section_headers
);
4717 section_headers
= NULL
;
4724 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4726 Elf32_External_Phdr
* phdrs
;
4727 Elf32_External_Phdr
* external
;
4728 Elf_Internal_Phdr
* internal
;
4730 unsigned int size
= elf_header
.e_phentsize
;
4731 unsigned int num
= elf_header
.e_phnum
;
4733 /* PR binutils/17531: Cope with unexpected section header sizes. */
4734 if (size
== 0 || num
== 0)
4736 if (size
< sizeof * phdrs
)
4738 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4741 if (size
> sizeof * phdrs
)
4742 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4744 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4745 size
, num
, _("program headers"));
4749 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4750 i
< elf_header
.e_phnum
;
4751 i
++, internal
++, external
++)
4753 internal
->p_type
= BYTE_GET (external
->p_type
);
4754 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4755 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4756 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4757 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4758 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4759 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4760 internal
->p_align
= BYTE_GET (external
->p_align
);
4768 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4770 Elf64_External_Phdr
* phdrs
;
4771 Elf64_External_Phdr
* external
;
4772 Elf_Internal_Phdr
* internal
;
4774 unsigned int size
= elf_header
.e_phentsize
;
4775 unsigned int num
= elf_header
.e_phnum
;
4777 /* PR binutils/17531: Cope with unexpected section header sizes. */
4778 if (size
== 0 || num
== 0)
4780 if (size
< sizeof * phdrs
)
4782 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4785 if (size
> sizeof * phdrs
)
4786 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4788 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4789 size
, num
, _("program headers"));
4793 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4794 i
< elf_header
.e_phnum
;
4795 i
++, internal
++, external
++)
4797 internal
->p_type
= BYTE_GET (external
->p_type
);
4798 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4799 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4800 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4801 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4802 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4803 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4804 internal
->p_align
= BYTE_GET (external
->p_align
);
4811 /* Returns TRUE if the program headers were read into `program_headers'. */
4814 get_program_headers (FILE * file
)
4816 Elf_Internal_Phdr
* phdrs
;
4818 /* Check cache of prior read. */
4819 if (program_headers
!= NULL
)
4822 /* Be kind to memory checkers by looking for
4823 e_phnum values which we know must be invalid. */
4824 if (elf_header
.e_phnum
4825 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4826 >= current_file_size
)
4828 error (_("Too many program headers - %#x - the file is not that big\n"),
4829 elf_header
.e_phnum
);
4833 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4834 sizeof (Elf_Internal_Phdr
));
4837 error (_("Out of memory reading %u program headers\n"),
4838 elf_header
.e_phnum
);
4843 ? get_32bit_program_headers (file
, phdrs
)
4844 : get_64bit_program_headers (file
, phdrs
))
4846 program_headers
= phdrs
;
4854 /* Returns TRUE if the program headers were loaded. */
4857 process_program_headers (FILE * file
)
4859 Elf_Internal_Phdr
* segment
;
4861 Elf_Internal_Phdr
* previous_load
= NULL
;
4863 if (elf_header
.e_phnum
== 0)
4865 /* PR binutils/12467. */
4866 if (elf_header
.e_phoff
!= 0)
4868 warn (_("possibly corrupt ELF header - it has a non-zero program"
4869 " header offset, but no program headers\n"));
4872 else if (do_segments
)
4873 printf (_("\nThere are no program headers in this file.\n"));
4877 if (do_segments
&& !do_header
)
4879 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4880 printf (_("Entry point "));
4881 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4882 printf (_("\nThere are %d program headers, starting at offset "),
4883 elf_header
.e_phnum
);
4884 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4888 if (! get_program_headers (file
))
4893 if (elf_header
.e_phnum
> 1)
4894 printf (_("\nProgram Headers:\n"));
4896 printf (_("\nProgram Headers:\n"));
4900 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4903 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4907 (_(" Type Offset VirtAddr PhysAddr\n"));
4909 (_(" FileSiz MemSiz Flags Align\n"));
4916 for (i
= 0, segment
= program_headers
;
4917 i
< elf_header
.e_phnum
;
4922 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4926 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4927 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4928 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4929 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4930 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4932 (segment
->p_flags
& PF_R
? 'R' : ' '),
4933 (segment
->p_flags
& PF_W
? 'W' : ' '),
4934 (segment
->p_flags
& PF_X
? 'E' : ' '));
4935 printf ("%#lx", (unsigned long) segment
->p_align
);
4939 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4940 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4943 print_vma (segment
->p_offset
, FULL_HEX
);
4947 print_vma (segment
->p_vaddr
, FULL_HEX
);
4949 print_vma (segment
->p_paddr
, FULL_HEX
);
4952 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4953 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4956 print_vma (segment
->p_filesz
, FULL_HEX
);
4960 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4961 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4964 print_vma (segment
->p_memsz
, FULL_HEX
);
4968 (segment
->p_flags
& PF_R
? 'R' : ' '),
4969 (segment
->p_flags
& PF_W
? 'W' : ' '),
4970 (segment
->p_flags
& PF_X
? 'E' : ' '));
4972 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4973 printf ("%#lx", (unsigned long) segment
->p_align
);
4976 print_vma (segment
->p_align
, PREFIX_HEX
);
4981 print_vma (segment
->p_offset
, FULL_HEX
);
4983 print_vma (segment
->p_vaddr
, FULL_HEX
);
4985 print_vma (segment
->p_paddr
, FULL_HEX
);
4987 print_vma (segment
->p_filesz
, FULL_HEX
);
4989 print_vma (segment
->p_memsz
, FULL_HEX
);
4991 (segment
->p_flags
& PF_R
? 'R' : ' '),
4992 (segment
->p_flags
& PF_W
? 'W' : ' '),
4993 (segment
->p_flags
& PF_X
? 'E' : ' '));
4994 print_vma (segment
->p_align
, PREFIX_HEX
);
4997 putc ('\n', stdout
);
5000 switch (segment
->p_type
)
5003 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5004 required by the ELF standard, several programs, including the Linux
5005 kernel, make use of non-ordered segments. */
5007 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5008 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5010 if (segment
->p_memsz
< segment
->p_filesz
)
5011 error (_("the segment's file size is larger than its memory size\n"));
5012 previous_load
= segment
;
5016 /* PR 20815 - Verify that the program header is loaded into memory. */
5017 if (i
> 0 && previous_load
!= NULL
)
5018 error (_("the PHDR segment must occur before any LOAD segment\n"));
5019 if (elf_header
.e_machine
!= EM_PARISC
)
5023 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
5024 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5025 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
5026 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5028 if (j
== elf_header
.e_phnum
)
5029 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5035 error (_("more than one dynamic segment\n"));
5037 /* By default, assume that the .dynamic section is the first
5038 section in the DYNAMIC segment. */
5039 dynamic_addr
= segment
->p_offset
;
5040 dynamic_size
= segment
->p_filesz
;
5042 /* Try to locate the .dynamic section. If there is
5043 a section header table, we can easily locate it. */
5044 if (section_headers
!= NULL
)
5046 Elf_Internal_Shdr
* sec
;
5048 sec
= find_section (".dynamic");
5049 if (sec
== NULL
|| sec
->sh_size
== 0)
5051 /* A corresponding .dynamic section is expected, but on
5052 IA-64/OpenVMS it is OK for it to be missing. */
5053 if (!is_ia64_vms ())
5054 error (_("no .dynamic section in the dynamic segment\n"));
5058 if (sec
->sh_type
== SHT_NOBITS
)
5064 dynamic_addr
= sec
->sh_offset
;
5065 dynamic_size
= sec
->sh_size
;
5067 if (dynamic_addr
< segment
->p_offset
5068 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5069 warn (_("the .dynamic section is not contained"
5070 " within the dynamic segment\n"));
5071 else if (dynamic_addr
> segment
->p_offset
)
5072 warn (_("the .dynamic section is not the first section"
5073 " in the dynamic segment.\n"));
5076 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5077 segment. Check this after matching against the section headers
5078 so we don't warn on debuginfo file (which have NOBITS .dynamic
5080 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5082 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5083 dynamic_addr
= dynamic_size
= 0;
5088 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5090 error (_("Unable to find program interpreter name\n"));
5094 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5096 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5097 error (_("Internal error: failed to create format string to display program interpreter\n"));
5099 program_interpreter
[0] = 0;
5100 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5101 error (_("Unable to read program interpreter name\n"));
5104 printf (_(" [Requesting program interpreter: %s]\n"),
5105 program_interpreter
);
5111 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5113 printf (_("\n Section to Segment mapping:\n"));
5114 printf (_(" Segment Sections...\n"));
5116 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5119 Elf_Internal_Shdr
* section
;
5121 segment
= program_headers
+ i
;
5122 section
= section_headers
+ 1;
5124 printf (" %2.2d ", i
);
5126 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5128 if (!ELF_TBSS_SPECIAL (section
, segment
)
5129 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5130 printf ("%s ", printable_section_name (section
));
5141 /* Find the file offset corresponding to VMA by using the program headers. */
5144 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5146 Elf_Internal_Phdr
* seg
;
5148 if (! get_program_headers (file
))
5150 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5154 for (seg
= program_headers
;
5155 seg
< program_headers
+ elf_header
.e_phnum
;
5158 if (seg
->p_type
!= PT_LOAD
)
5161 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5162 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5163 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5166 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5167 (unsigned long) vma
);
5172 /* Allocate memory and load the sections headers into the global pointer
5173 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5174 generate any error messages if the load fails. */
5177 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5179 Elf32_External_Shdr
* shdrs
;
5180 Elf_Internal_Shdr
* internal
;
5182 unsigned int size
= elf_header
.e_shentsize
;
5183 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5185 /* PR binutils/17531: Cope with unexpected section header sizes. */
5186 if (size
== 0 || num
== 0)
5188 if (size
< sizeof * shdrs
)
5191 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5194 if (!probe
&& size
> sizeof * shdrs
)
5195 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5197 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5199 probe
? NULL
: _("section headers"));
5203 if (section_headers
!= NULL
)
5204 free (section_headers
);
5205 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5206 sizeof (Elf_Internal_Shdr
));
5207 if (section_headers
== NULL
)
5210 error (_("Out of memory reading %u section headers\n"), num
);
5214 for (i
= 0, internal
= section_headers
;
5218 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5219 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5220 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5221 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5222 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5223 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5224 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5225 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5226 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5227 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5228 if (!probe
&& internal
->sh_link
> num
)
5229 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5230 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5231 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5239 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5241 Elf64_External_Shdr
* shdrs
;
5242 Elf_Internal_Shdr
* internal
;
5244 unsigned int size
= elf_header
.e_shentsize
;
5245 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5247 /* PR binutils/17531: Cope with unexpected section header sizes. */
5248 if (size
== 0 || num
== 0)
5250 if (size
< sizeof * shdrs
)
5253 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5256 if (! probe
&& size
> sizeof * shdrs
)
5257 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5259 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5261 probe
? NULL
: _("section headers"));
5265 if (section_headers
!= NULL
)
5266 free (section_headers
);
5267 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5268 sizeof (Elf_Internal_Shdr
));
5269 if (section_headers
== NULL
)
5272 error (_("Out of memory reading %u section headers\n"), num
);
5276 for (i
= 0, internal
= section_headers
;
5280 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5281 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5282 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5283 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5284 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5285 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5286 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5287 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5288 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5289 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5290 if (!probe
&& internal
->sh_link
> num
)
5291 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5292 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5293 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5300 static Elf_Internal_Sym
*
5301 get_32bit_elf_symbols (FILE * file
,
5302 Elf_Internal_Shdr
* section
,
5303 unsigned long * num_syms_return
)
5305 unsigned long number
= 0;
5306 Elf32_External_Sym
* esyms
= NULL
;
5307 Elf_External_Sym_Shndx
* shndx
= NULL
;
5308 Elf_Internal_Sym
* isyms
= NULL
;
5309 Elf_Internal_Sym
* psym
;
5312 if (section
->sh_size
== 0)
5314 if (num_syms_return
!= NULL
)
5315 * num_syms_return
= 0;
5319 /* Run some sanity checks first. */
5320 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5322 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5323 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5327 if (section
->sh_size
> current_file_size
)
5329 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5330 printable_section_name (section
), (unsigned long) section
->sh_size
);
5334 number
= section
->sh_size
/ section
->sh_entsize
;
5336 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5338 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5339 (unsigned long) section
->sh_size
,
5340 printable_section_name (section
),
5341 (unsigned long) section
->sh_entsize
);
5345 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5346 section
->sh_size
, _("symbols"));
5351 elf_section_list
* entry
;
5354 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5355 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5357 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5358 entry
->hdr
->sh_offset
,
5359 1, entry
->hdr
->sh_size
,
5360 _("symbol table section indicies"));
5363 /* PR17531: file: heap-buffer-overflow */
5364 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5366 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5367 printable_section_name (entry
->hdr
),
5368 (unsigned long) entry
->hdr
->sh_size
,
5369 (unsigned long) section
->sh_size
);
5375 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5379 error (_("Out of memory reading %lu symbols\n"),
5380 (unsigned long) number
);
5384 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5386 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5387 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5388 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5389 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5390 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5392 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5393 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5394 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5395 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5396 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5405 if (num_syms_return
!= NULL
)
5406 * num_syms_return
= isyms
== NULL
? 0 : number
;
5411 static Elf_Internal_Sym
*
5412 get_64bit_elf_symbols (FILE * file
,
5413 Elf_Internal_Shdr
* section
,
5414 unsigned long * num_syms_return
)
5416 unsigned long number
= 0;
5417 Elf64_External_Sym
* esyms
= NULL
;
5418 Elf_External_Sym_Shndx
* shndx
= NULL
;
5419 Elf_Internal_Sym
* isyms
= NULL
;
5420 Elf_Internal_Sym
* psym
;
5423 if (section
->sh_size
== 0)
5425 if (num_syms_return
!= NULL
)
5426 * num_syms_return
= 0;
5430 /* Run some sanity checks first. */
5431 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5433 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5434 printable_section_name (section
),
5435 (unsigned long) section
->sh_entsize
);
5439 if (section
->sh_size
> current_file_size
)
5441 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5442 printable_section_name (section
),
5443 (unsigned long) section
->sh_size
);
5447 number
= section
->sh_size
/ section
->sh_entsize
;
5449 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5451 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5452 (unsigned long) section
->sh_size
,
5453 printable_section_name (section
),
5454 (unsigned long) section
->sh_entsize
);
5458 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5459 section
->sh_size
, _("symbols"));
5464 elf_section_list
* entry
;
5467 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5468 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5470 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5471 entry
->hdr
->sh_offset
,
5472 1, entry
->hdr
->sh_size
,
5473 _("symbol table section indicies"));
5476 /* PR17531: file: heap-buffer-overflow */
5477 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5479 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5480 printable_section_name (entry
->hdr
),
5481 (unsigned long) entry
->hdr
->sh_size
,
5482 (unsigned long) section
->sh_size
);
5488 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5492 error (_("Out of memory reading %lu symbols\n"),
5493 (unsigned long) number
);
5497 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5499 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5500 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5501 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5502 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5504 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5506 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5507 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5508 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5510 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5511 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5520 if (num_syms_return
!= NULL
)
5521 * num_syms_return
= isyms
== NULL
? 0 : number
;
5527 get_elf_section_flags (bfd_vma sh_flags
)
5529 static char buff
[1024];
5531 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5533 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5534 bfd_vma os_flags
= 0;
5535 bfd_vma proc_flags
= 0;
5536 bfd_vma unknown_flags
= 0;
5544 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5545 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5546 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5547 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5548 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5549 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5550 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5551 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5552 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5553 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5554 /* IA-64 specific. */
5555 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5556 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5557 /* IA-64 OpenVMS specific. */
5558 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5559 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5560 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5561 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5562 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5563 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5565 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5566 /* SPARC specific. */
5567 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5568 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5570 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5571 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5572 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5574 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5577 if (do_section_details
)
5579 sprintf (buff
, "[%*.*lx]: ",
5580 field_size
, field_size
, (unsigned long) sh_flags
);
5581 p
+= field_size
+ 4;
5588 flag
= sh_flags
& - sh_flags
;
5591 if (do_section_details
)
5595 case SHF_WRITE
: sindex
= 0; break;
5596 case SHF_ALLOC
: sindex
= 1; break;
5597 case SHF_EXECINSTR
: sindex
= 2; break;
5598 case SHF_MERGE
: sindex
= 3; break;
5599 case SHF_STRINGS
: sindex
= 4; break;
5600 case SHF_INFO_LINK
: sindex
= 5; break;
5601 case SHF_LINK_ORDER
: sindex
= 6; break;
5602 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5603 case SHF_GROUP
: sindex
= 8; break;
5604 case SHF_TLS
: sindex
= 9; break;
5605 case SHF_EXCLUDE
: sindex
= 18; break;
5606 case SHF_COMPRESSED
: sindex
= 20; break;
5607 case SHF_GNU_MBIND
: sindex
= 24; break;
5611 switch (elf_header
.e_machine
)
5614 if (flag
== SHF_IA_64_SHORT
)
5616 else if (flag
== SHF_IA_64_NORECOV
)
5619 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5622 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5623 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5624 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5625 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5626 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5627 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5638 case EM_OLD_SPARCV9
:
5639 case EM_SPARC32PLUS
:
5642 if (flag
== SHF_ORDERED
)
5649 case SHF_ENTRYSECT
: sindex
= 21; break;
5650 case SHF_ARM_PURECODE
: sindex
= 22; break;
5651 case SHF_COMDEF
: sindex
= 23; break;
5663 if (p
!= buff
+ field_size
+ 4)
5665 if (size
< (10 + 2))
5667 warn (_("Internal error: not enough buffer room for section flag info"));
5668 return _("<unknown>");
5675 size
-= flags
[sindex
].len
;
5676 p
= stpcpy (p
, flags
[sindex
].str
);
5678 else if (flag
& SHF_MASKOS
)
5680 else if (flag
& SHF_MASKPROC
)
5683 unknown_flags
|= flag
;
5689 case SHF_WRITE
: *p
= 'W'; break;
5690 case SHF_ALLOC
: *p
= 'A'; break;
5691 case SHF_EXECINSTR
: *p
= 'X'; break;
5692 case SHF_MERGE
: *p
= 'M'; break;
5693 case SHF_STRINGS
: *p
= 'S'; break;
5694 case SHF_INFO_LINK
: *p
= 'I'; break;
5695 case SHF_LINK_ORDER
: *p
= 'L'; break;
5696 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5697 case SHF_GROUP
: *p
= 'G'; break;
5698 case SHF_TLS
: *p
= 'T'; break;
5699 case SHF_EXCLUDE
: *p
= 'E'; break;
5700 case SHF_COMPRESSED
: *p
= 'C'; break;
5701 case SHF_GNU_MBIND
: *p
= 'D'; break;
5704 if ((elf_header
.e_machine
== EM_X86_64
5705 || elf_header
.e_machine
== EM_L1OM
5706 || elf_header
.e_machine
== EM_K1OM
)
5707 && flag
== SHF_X86_64_LARGE
)
5709 else if (elf_header
.e_machine
== EM_ARM
5710 && flag
== SHF_ARM_PURECODE
)
5712 else if (flag
& SHF_MASKOS
)
5715 sh_flags
&= ~ SHF_MASKOS
;
5717 else if (flag
& SHF_MASKPROC
)
5720 sh_flags
&= ~ SHF_MASKPROC
;
5730 if (do_section_details
)
5734 size
-= 5 + field_size
;
5735 if (p
!= buff
+ field_size
+ 4)
5739 warn (_("Internal error: not enough buffer room for section flag info"));
5740 return _("<unknown>");
5746 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5747 (unsigned long) os_flags
);
5748 p
+= 5 + field_size
;
5752 size
-= 7 + field_size
;
5753 if (p
!= buff
+ field_size
+ 4)
5757 warn (_("Internal error: not enough buffer room for section flag info"));
5758 return _("<unknown>");
5764 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5765 (unsigned long) proc_flags
);
5766 p
+= 7 + field_size
;
5770 size
-= 10 + field_size
;
5771 if (p
!= buff
+ field_size
+ 4)
5775 warn (_("Internal error: not enough buffer room for section flag info"));
5776 return _("<unknown>");
5782 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5783 (unsigned long) unknown_flags
);
5784 p
+= 10 + field_size
;
5793 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5797 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5799 if (size
< sizeof (* echdr
))
5801 error (_("Compressed section is too small even for a compression header\n"));
5805 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5806 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5807 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5808 return sizeof (*echdr
);
5812 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5814 if (size
< sizeof (* echdr
))
5816 error (_("Compressed section is too small even for a compression header\n"));
5820 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5821 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5822 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5823 return sizeof (*echdr
);
5828 process_section_headers (FILE * file
)
5830 Elf_Internal_Shdr
* section
;
5833 section_headers
= NULL
;
5835 if (elf_header
.e_shnum
== 0)
5837 /* PR binutils/12467. */
5838 if (elf_header
.e_shoff
!= 0)
5840 warn (_("possibly corrupt ELF file header - it has a non-zero"
5841 " section header offset, but no section headers\n"));
5844 else if (do_sections
)
5845 printf (_("\nThere are no sections in this file.\n"));
5850 if (do_sections
&& !do_header
)
5851 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5852 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5856 if (! get_32bit_section_headers (file
, FALSE
))
5861 if (! get_64bit_section_headers (file
, FALSE
))
5865 /* Read in the string table, so that we have names to display. */
5866 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5867 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5869 section
= section_headers
+ elf_header
.e_shstrndx
;
5871 if (section
->sh_size
!= 0)
5873 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5874 1, section
->sh_size
,
5877 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5881 /* Scan the sections for the dynamic symbol table
5882 and dynamic string table and debug sections. */
5883 dynamic_symbols
= NULL
;
5884 dynamic_strings
= NULL
;
5885 dynamic_syminfo
= NULL
;
5886 symtab_shndx_list
= NULL
;
5888 eh_addr_size
= is_32bit_elf
? 4 : 8;
5889 switch (elf_header
.e_machine
)
5892 case EM_MIPS_RS3_LE
:
5893 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5894 FDE addresses. However, the ABI also has a semi-official ILP32
5895 variant for which the normal FDE address size rules apply.
5897 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5898 section, where XX is the size of longs in bits. Unfortunately,
5899 earlier compilers provided no way of distinguishing ILP32 objects
5900 from LP64 objects, so if there's any doubt, we should assume that
5901 the official LP64 form is being used. */
5902 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5903 && find_section (".gcc_compiled_long32") == NULL
)
5909 switch (elf_header
.e_flags
& EF_H8_MACH
)
5911 case E_H8_MACH_H8300
:
5912 case E_H8_MACH_H8300HN
:
5913 case E_H8_MACH_H8300SN
:
5914 case E_H8_MACH_H8300SXN
:
5917 case E_H8_MACH_H8300H
:
5918 case E_H8_MACH_H8300S
:
5919 case E_H8_MACH_H8300SX
:
5927 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5929 case EF_M32C_CPU_M16C
:
5936 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5939 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5940 if (section->sh_entsize != expected_entsize) \
5943 sprintf_vma (buf, section->sh_entsize); \
5944 /* Note: coded this way so that there is a single string for \
5946 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5947 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5948 (unsigned) expected_entsize); \
5949 section->sh_entsize = expected_entsize; \
5954 #define CHECK_ENTSIZE(section, i, type) \
5955 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5956 sizeof (Elf64_External_##type))
5958 for (i
= 0, section
= section_headers
;
5959 i
< elf_header
.e_shnum
;
5962 char * name
= SECTION_NAME (section
);
5964 if (section
->sh_type
== SHT_DYNSYM
)
5966 if (dynamic_symbols
!= NULL
)
5968 error (_("File contains multiple dynamic symbol tables\n"));
5972 CHECK_ENTSIZE (section
, i
, Sym
);
5973 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5975 else if (section
->sh_type
== SHT_STRTAB
5976 && streq (name
, ".dynstr"))
5978 if (dynamic_strings
!= NULL
)
5980 error (_("File contains multiple dynamic string tables\n"));
5984 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5985 1, section
->sh_size
,
5986 _("dynamic strings"));
5987 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5989 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5991 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5992 entry
->hdr
= section
;
5993 entry
->next
= symtab_shndx_list
;
5994 symtab_shndx_list
= entry
;
5996 else if (section
->sh_type
== SHT_SYMTAB
)
5997 CHECK_ENTSIZE (section
, i
, Sym
);
5998 else if (section
->sh_type
== SHT_GROUP
)
5999 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6000 else if (section
->sh_type
== SHT_REL
)
6001 CHECK_ENTSIZE (section
, i
, Rel
);
6002 else if (section
->sh_type
== SHT_RELA
)
6003 CHECK_ENTSIZE (section
, i
, Rela
);
6004 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6005 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6006 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6007 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6008 || do_debug_addr
|| do_debug_cu_index
)
6009 && (const_strneq (name
, ".debug_")
6010 || const_strneq (name
, ".zdebug_")))
6013 name
+= sizeof (".zdebug_") - 1;
6015 name
+= sizeof (".debug_") - 1;
6018 || (do_debug_info
&& const_strneq (name
, "info"))
6019 || (do_debug_info
&& const_strneq (name
, "types"))
6020 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6021 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6022 || (do_debug_lines
&& const_strneq (name
, "line."))
6023 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6024 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6025 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6026 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6027 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6028 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6029 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6030 || (do_debug_frames
&& const_strneq (name
, "frame"))
6031 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6032 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6033 || (do_debug_str
&& const_strneq (name
, "str"))
6034 || (do_debug_loc
&& const_strneq (name
, "loc"))
6035 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6036 || (do_debug_addr
&& const_strneq (name
, "addr"))
6037 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6038 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6040 request_dump_bynumber (i
, DEBUG_DUMP
);
6042 /* Linkonce section to be combined with .debug_info at link time. */
6043 else if ((do_debugging
|| do_debug_info
)
6044 && const_strneq (name
, ".gnu.linkonce.wi."))
6045 request_dump_bynumber (i
, DEBUG_DUMP
);
6046 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6047 request_dump_bynumber (i
, DEBUG_DUMP
);
6048 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
6049 request_dump_bynumber (i
, DEBUG_DUMP
);
6050 /* Trace sections for Itanium VMS. */
6051 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6052 || do_trace_aranges
)
6053 && const_strneq (name
, ".trace_"))
6055 name
+= sizeof (".trace_") - 1;
6058 || (do_trace_info
&& streq (name
, "info"))
6059 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6060 || (do_trace_aranges
&& streq (name
, "aranges"))
6062 request_dump_bynumber (i
, DEBUG_DUMP
);
6069 if (elf_header
.e_shnum
> 1)
6070 printf (_("\nSection Headers:\n"));
6072 printf (_("\nSection Header:\n"));
6076 if (do_section_details
)
6078 printf (_(" [Nr] Name\n"));
6079 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6083 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6087 if (do_section_details
)
6089 printf (_(" [Nr] Name\n"));
6090 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6094 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6098 if (do_section_details
)
6100 printf (_(" [Nr] Name\n"));
6101 printf (_(" Type Address Offset Link\n"));
6102 printf (_(" Size EntSize Info Align\n"));
6106 printf (_(" [Nr] Name Type Address Offset\n"));
6107 printf (_(" Size EntSize Flags Link Info Align\n"));
6111 if (do_section_details
)
6112 printf (_(" Flags\n"));
6114 for (i
= 0, section
= section_headers
;
6115 i
< elf_header
.e_shnum
;
6118 /* Run some sanity checks on the section header. */
6120 /* Check the sh_link field. */
6121 switch (section
->sh_type
)
6123 case SHT_SYMTAB_SHNDX
:
6127 case SHT_GNU_versym
:
6130 if (section
->sh_link
< 1
6131 || section
->sh_link
>= elf_header
.e_shnum
6132 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6133 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6134 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6135 i
, section
->sh_link
);
6141 case SHT_GNU_verneed
:
6142 case SHT_GNU_verdef
:
6143 case SHT_GNU_LIBLIST
:
6144 if (section
->sh_link
< 1
6145 || section
->sh_link
>= elf_header
.e_shnum
6146 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6147 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6148 i
, section
->sh_link
);
6151 case SHT_INIT_ARRAY
:
6152 case SHT_FINI_ARRAY
:
6153 case SHT_PREINIT_ARRAY
:
6154 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6155 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6156 i
, section
->sh_link
);
6160 /* FIXME: Add support for target specific section types. */
6161 #if 0 /* Currently we do not check other section types as there are too
6162 many special cases. Stab sections for example have a type
6163 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6165 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6166 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6167 i
, section
->sh_link
);
6172 /* Check the sh_info field. */
6173 switch (section
->sh_type
)
6177 if (section
->sh_info
< 1
6178 || section
->sh_info
>= elf_header
.e_shnum
6179 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6180 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6181 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6182 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6183 /* FIXME: Are other section types valid ? */
6184 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6186 if (section
->sh_info
== 0
6187 && (streq (SECTION_NAME (section
), ".rel.dyn")
6188 || streq (SECTION_NAME (section
), ".rela.dyn")))
6189 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6190 of zero. The relocations in these sections may apply
6191 to many different sections. */
6194 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6195 i
, section
->sh_info
);
6201 case SHT_SYMTAB_SHNDX
:
6202 case SHT_INIT_ARRAY
:
6203 case SHT_FINI_ARRAY
:
6204 case SHT_PREINIT_ARRAY
:
6205 if (section
->sh_info
!= 0)
6206 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6207 i
, section
->sh_info
);
6213 /* A symbol index - we assume that it is valid. */
6217 /* FIXME: Add support for target specific section types. */
6218 if (section
->sh_type
== SHT_NOBITS
)
6219 /* NOBITS section headers with non-zero sh_info fields can be
6220 created when a binary is stripped of everything but its debug
6221 information. The stripped sections have their headers
6222 preserved but their types set to SHT_NOBITS. So do not check
6223 this type of section. */
6225 else if (section
->sh_flags
& SHF_INFO_LINK
)
6227 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6228 warn (_("[%2u]: Expected link to another section in info field"), i
);
6230 else if (section
->sh_type
< SHT_LOOS
6231 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6232 && section
->sh_info
!= 0)
6233 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6234 i
, section
->sh_info
);
6238 /* Check the sh_size field. */
6239 if (section
->sh_size
> current_file_size
6240 && section
->sh_type
!= SHT_NOBITS
6241 && section
->sh_type
!= SHT_NULL
6242 && section
->sh_type
< SHT_LOOS
)
6243 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6245 printf (" [%2u] ", i
);
6246 if (do_section_details
)
6247 printf ("%s\n ", printable_section_name (section
));
6249 print_symbol (-17, SECTION_NAME (section
));
6251 printf (do_wide
? " %-15s " : " %-15.15s ",
6252 get_section_type_name (section
->sh_type
));
6256 const char * link_too_big
= NULL
;
6258 print_vma (section
->sh_addr
, LONG_HEX
);
6260 printf ( " %6.6lx %6.6lx %2.2lx",
6261 (unsigned long) section
->sh_offset
,
6262 (unsigned long) section
->sh_size
,
6263 (unsigned long) section
->sh_entsize
);
6265 if (do_section_details
)
6266 fputs (" ", stdout
);
6268 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6270 if (section
->sh_link
>= elf_header
.e_shnum
)
6273 /* The sh_link value is out of range. Normally this indicates
6274 an error but it can have special values in Solaris binaries. */
6275 switch (elf_header
.e_machine
)
6282 case EM_OLD_SPARCV9
:
6283 case EM_SPARC32PLUS
:
6286 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6287 link_too_big
= "BEFORE";
6288 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6289 link_too_big
= "AFTER";
6296 if (do_section_details
)
6298 if (link_too_big
!= NULL
&& * link_too_big
)
6299 printf ("<%s> ", link_too_big
);
6301 printf ("%2u ", section
->sh_link
);
6302 printf ("%3u %2lu\n", section
->sh_info
,
6303 (unsigned long) section
->sh_addralign
);
6306 printf ("%2u %3u %2lu\n",
6309 (unsigned long) section
->sh_addralign
);
6311 if (link_too_big
&& ! * link_too_big
)
6312 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6313 i
, section
->sh_link
);
6317 print_vma (section
->sh_addr
, LONG_HEX
);
6319 if ((long) section
->sh_offset
== section
->sh_offset
)
6320 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6324 print_vma (section
->sh_offset
, LONG_HEX
);
6327 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6328 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6332 print_vma (section
->sh_size
, LONG_HEX
);
6335 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6336 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6340 print_vma (section
->sh_entsize
, LONG_HEX
);
6343 if (do_section_details
)
6344 fputs (" ", stdout
);
6346 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6348 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6350 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6351 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6354 print_vma (section
->sh_addralign
, DEC
);
6358 else if (do_section_details
)
6360 printf (" %-15.15s ",
6361 get_section_type_name (section
->sh_type
));
6362 print_vma (section
->sh_addr
, LONG_HEX
);
6363 if ((long) section
->sh_offset
== section
->sh_offset
)
6364 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6368 print_vma (section
->sh_offset
, LONG_HEX
);
6370 printf (" %u\n ", section
->sh_link
);
6371 print_vma (section
->sh_size
, LONG_HEX
);
6373 print_vma (section
->sh_entsize
, LONG_HEX
);
6375 printf (" %-16u %lu\n",
6377 (unsigned long) section
->sh_addralign
);
6382 print_vma (section
->sh_addr
, LONG_HEX
);
6383 if ((long) section
->sh_offset
== section
->sh_offset
)
6384 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6388 print_vma (section
->sh_offset
, LONG_HEX
);
6391 print_vma (section
->sh_size
, LONG_HEX
);
6393 print_vma (section
->sh_entsize
, LONG_HEX
);
6395 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6397 printf (" %2u %3u %lu\n",
6400 (unsigned long) section
->sh_addralign
);
6403 if (do_section_details
)
6405 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6406 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6408 /* Minimum section size is 12 bytes for 32-bit compression
6409 header + 12 bytes for compressed data header. */
6410 unsigned char buf
[24];
6412 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6413 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6414 sizeof (buf
), _("compression header")))
6416 Elf_Internal_Chdr chdr
;
6418 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6420 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6423 printf (_(" [<unknown>: 0x%x], "),
6425 print_vma (chdr
.ch_size
, LONG_HEX
);
6426 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6432 if (!do_section_details
)
6434 /* The ordering of the letters shown here matches the ordering of the
6435 corresponding SHF_xxx values, and hence the order in which these
6436 letters will be displayed to the user. */
6437 printf (_("Key to Flags:\n\
6438 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6439 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6440 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6441 if (elf_header
.e_machine
== EM_X86_64
6442 || elf_header
.e_machine
== EM_L1OM
6443 || elf_header
.e_machine
== EM_K1OM
)
6444 printf (_("l (large), "));
6445 else if (elf_header
.e_machine
== EM_ARM
)
6446 printf (_("y (purecode), "));
6447 printf ("p (processor specific)\n");
6454 get_group_flags (unsigned int flags
)
6456 static char buff
[128];
6460 else if (flags
== GRP_COMDAT
)
6463 snprintf (buff
, 14, _("[0x%x: "), flags
);
6465 flags
&= ~ GRP_COMDAT
;
6466 if (flags
& GRP_MASKOS
)
6468 strcat (buff
, "<OS specific>");
6469 flags
&= ~ GRP_MASKOS
;
6472 if (flags
& GRP_MASKPROC
)
6474 strcat (buff
, "<PROC specific>");
6475 flags
&= ~ GRP_MASKPROC
;
6479 strcat (buff
, "<unknown>");
6486 process_section_groups (FILE * file
)
6488 Elf_Internal_Shdr
* section
;
6490 struct group
* group
;
6491 Elf_Internal_Shdr
* symtab_sec
;
6492 Elf_Internal_Shdr
* strtab_sec
;
6493 Elf_Internal_Sym
* symtab
;
6494 unsigned long num_syms
;
6498 /* Don't process section groups unless needed. */
6499 if (!do_unwind
&& !do_section_groups
)
6502 if (elf_header
.e_shnum
== 0)
6504 if (do_section_groups
)
6505 printf (_("\nThere are no sections to group in this file.\n"));
6510 if (section_headers
== NULL
)
6512 error (_("Section headers are not available!\n"));
6513 /* PR 13622: This can happen with a corrupt ELF header. */
6517 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6518 sizeof (struct group
*));
6520 if (section_headers_groups
== NULL
)
6522 error (_("Out of memory reading %u section group headers\n"),
6523 elf_header
.e_shnum
);
6527 /* Scan the sections for the group section. */
6529 for (i
= 0, section
= section_headers
;
6530 i
< elf_header
.e_shnum
;
6532 if (section
->sh_type
== SHT_GROUP
)
6535 if (group_count
== 0)
6537 if (do_section_groups
)
6538 printf (_("\nThere are no section groups in this file.\n"));
6543 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6545 if (section_groups
== NULL
)
6547 error (_("Out of memory reading %lu groups\n"),
6548 (unsigned long) group_count
);
6558 for (i
= 0, section
= section_headers
, group
= section_groups
;
6559 i
< elf_header
.e_shnum
;
6562 if (section
->sh_type
== SHT_GROUP
)
6564 const char * name
= printable_section_name (section
);
6565 const char * group_name
;
6566 unsigned char * start
;
6567 unsigned char * indices
;
6568 unsigned int entry
, j
, size
;
6569 Elf_Internal_Shdr
* sec
;
6570 Elf_Internal_Sym
* sym
;
6572 /* Get the symbol table. */
6573 if (section
->sh_link
>= elf_header
.e_shnum
6574 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6577 error (_("Bad sh_link in group section `%s'\n"), name
);
6581 if (symtab_sec
!= sec
)
6586 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6591 error (_("Corrupt header in group section `%s'\n"), name
);
6595 if (section
->sh_info
>= num_syms
)
6597 error (_("Bad sh_info in group section `%s'\n"), name
);
6601 sym
= symtab
+ section
->sh_info
;
6603 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6605 if (sym
->st_shndx
== 0
6606 || sym
->st_shndx
>= elf_header
.e_shnum
)
6608 error (_("Bad sh_info in group section `%s'\n"), name
);
6612 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6621 /* Get the string table. */
6622 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6631 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6637 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6638 1, strtab_sec
->sh_size
,
6640 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6642 group_name
= sym
->st_name
< strtab_size
6643 ? strtab
+ sym
->st_name
: _("<corrupt>");
6646 /* PR 17531: file: loop. */
6647 if (section
->sh_entsize
> section
->sh_size
)
6649 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6650 printable_section_name (section
),
6651 (unsigned long) section
->sh_entsize
,
6652 (unsigned long) section
->sh_size
);
6656 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6657 1, section
->sh_size
,
6663 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6664 entry
= byte_get (indices
, 4);
6667 if (do_section_groups
)
6669 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6670 get_group_flags (entry
), i
, name
, group_name
, size
);
6672 printf (_(" [Index] Name\n"));
6675 group
->group_index
= i
;
6677 for (j
= 0; j
< size
; j
++)
6679 struct group_list
* g
;
6681 entry
= byte_get (indices
, 4);
6684 if (entry
>= elf_header
.e_shnum
)
6686 static unsigned num_group_errors
= 0;
6688 if (num_group_errors
++ < 10)
6690 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6691 entry
, i
, elf_header
.e_shnum
- 1);
6692 if (num_group_errors
== 10)
6693 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6698 if (section_headers_groups
[entry
] != NULL
)
6702 static unsigned num_errs
= 0;
6704 if (num_errs
++ < 10)
6706 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6708 section_headers_groups
[entry
]->group_index
);
6710 warn (_("Further error messages about already contained group sections suppressed\n"));
6716 /* Intel C/C++ compiler may put section 0 in a
6717 section group. We just warn it the first time
6718 and ignore it afterwards. */
6719 static bfd_boolean warned
= FALSE
;
6722 error (_("section 0 in group section [%5u]\n"),
6723 section_headers_groups
[entry
]->group_index
);
6729 section_headers_groups
[entry
] = group
;
6731 if (do_section_groups
)
6733 sec
= section_headers
+ entry
;
6734 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6737 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6738 g
->section_index
= entry
;
6739 g
->next
= group
->root
;
6757 /* Data used to display dynamic fixups. */
6759 struct ia64_vms_dynfixup
6761 bfd_vma needed_ident
; /* Library ident number. */
6762 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6763 bfd_vma fixup_needed
; /* Index of the library. */
6764 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6765 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6768 /* Data used to display dynamic relocations. */
6770 struct ia64_vms_dynimgrela
6772 bfd_vma img_rela_cnt
; /* Number of relocations. */
6773 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6776 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6780 dump_ia64_vms_dynamic_fixups (FILE * file
,
6781 struct ia64_vms_dynfixup
* fixup
,
6782 const char * strtab
,
6783 unsigned int strtab_sz
)
6785 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6787 const char * lib_name
;
6789 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6790 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6791 _("dynamic section image fixups"));
6795 if (fixup
->needed
< strtab_sz
)
6796 lib_name
= strtab
+ fixup
->needed
;
6799 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6800 (unsigned long) fixup
->needed
);
6803 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6804 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6806 (_("Seg Offset Type SymVec DataType\n"));
6808 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6813 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6814 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6815 type
= BYTE_GET (imfs
[i
].type
);
6816 rtype
= elf_ia64_reloc_type (type
);
6818 printf (" 0x%08x ", type
);
6820 printf (" %-32s ", rtype
);
6821 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6822 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6829 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6832 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6834 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6837 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6838 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6839 _("dynamic section image relocations"));
6843 printf (_("\nImage relocs\n"));
6845 (_("Seg Offset Type Addend Seg Sym Off\n"));
6847 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6852 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6853 printf ("%08" BFD_VMA_FMT
"x ",
6854 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6855 type
= BYTE_GET (imrs
[i
].type
);
6856 rtype
= elf_ia64_reloc_type (type
);
6858 printf ("0x%08x ", type
);
6860 printf ("%-31s ", rtype
);
6861 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6862 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6863 printf ("%08" BFD_VMA_FMT
"x\n",
6864 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6871 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6874 process_ia64_vms_dynamic_relocs (FILE *file
)
6876 struct ia64_vms_dynfixup fixup
;
6877 struct ia64_vms_dynimgrela imgrela
;
6878 Elf_Internal_Dyn
*entry
;
6879 bfd_vma strtab_off
= 0;
6880 bfd_vma strtab_sz
= 0;
6881 char *strtab
= NULL
;
6882 bfd_boolean res
= TRUE
;
6884 memset (&fixup
, 0, sizeof (fixup
));
6885 memset (&imgrela
, 0, sizeof (imgrela
));
6887 /* Note: the order of the entries is specified by the OpenVMS specs. */
6888 for (entry
= dynamic_section
;
6889 entry
< dynamic_section
+ dynamic_nent
;
6892 switch (entry
->d_tag
)
6894 case DT_IA_64_VMS_STRTAB_OFFSET
:
6895 strtab_off
= entry
->d_un
.d_val
;
6898 strtab_sz
= entry
->d_un
.d_val
;
6900 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6901 1, strtab_sz
, _("dynamic string section"));
6904 case DT_IA_64_VMS_NEEDED_IDENT
:
6905 fixup
.needed_ident
= entry
->d_un
.d_val
;
6908 fixup
.needed
= entry
->d_un
.d_val
;
6910 case DT_IA_64_VMS_FIXUP_NEEDED
:
6911 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6913 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6914 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6916 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6917 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6918 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6921 case DT_IA_64_VMS_IMG_RELA_CNT
:
6922 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6924 case DT_IA_64_VMS_IMG_RELA_OFF
:
6925 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6926 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6948 dynamic_relocations
[] =
6950 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6951 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6952 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6955 /* Process the reloc section. */
6958 process_relocs (FILE * file
)
6960 unsigned long rel_size
;
6961 unsigned long rel_offset
;
6966 if (do_using_dynamic
)
6970 bfd_boolean has_dynamic_reloc
;
6973 has_dynamic_reloc
= FALSE
;
6975 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6977 is_rela
= dynamic_relocations
[i
].rela
;
6978 name
= dynamic_relocations
[i
].name
;
6979 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6980 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6983 has_dynamic_reloc
= TRUE
;
6985 if (is_rela
== UNKNOWN
)
6987 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6988 switch (dynamic_info
[DT_PLTREL
])
7002 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7003 name
, rel_offset
, rel_size
);
7005 dump_relocations (file
,
7006 offset_from_vma (file
, rel_offset
, rel_size
),
7008 dynamic_symbols
, num_dynamic_syms
,
7009 dynamic_strings
, dynamic_strings_length
,
7010 is_rela
, TRUE
/* is_dynamic */);
7015 if (process_ia64_vms_dynamic_relocs (file
))
7016 has_dynamic_reloc
= TRUE
;
7018 if (! has_dynamic_reloc
)
7019 printf (_("\nThere are no dynamic relocations in this file.\n"));
7023 Elf_Internal_Shdr
* section
;
7025 bfd_boolean found
= FALSE
;
7027 for (i
= 0, section
= section_headers
;
7028 i
< elf_header
.e_shnum
;
7031 if ( section
->sh_type
!= SHT_RELA
7032 && section
->sh_type
!= SHT_REL
)
7035 rel_offset
= section
->sh_offset
;
7036 rel_size
= section
->sh_size
;
7040 Elf_Internal_Shdr
* strsec
;
7043 printf (_("\nRelocation section "));
7045 if (string_table
== NULL
)
7046 printf ("%d", section
->sh_name
);
7048 printf ("'%s'", printable_section_name (section
));
7050 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7051 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
7053 is_rela
= section
->sh_type
== SHT_RELA
;
7055 if (section
->sh_link
!= 0
7056 && section
->sh_link
< elf_header
.e_shnum
)
7058 Elf_Internal_Shdr
* symsec
;
7059 Elf_Internal_Sym
* symtab
;
7060 unsigned long nsyms
;
7061 unsigned long strtablen
= 0;
7062 char * strtab
= NULL
;
7064 symsec
= section_headers
+ section
->sh_link
;
7065 if (symsec
->sh_type
!= SHT_SYMTAB
7066 && symsec
->sh_type
!= SHT_DYNSYM
)
7069 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7074 if (symsec
->sh_link
!= 0
7075 && symsec
->sh_link
< elf_header
.e_shnum
)
7077 strsec
= section_headers
+ symsec
->sh_link
;
7079 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7082 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7085 dump_relocations (file
, rel_offset
, rel_size
,
7086 symtab
, nsyms
, strtab
, strtablen
,
7088 symsec
->sh_type
== SHT_DYNSYM
);
7094 dump_relocations (file
, rel_offset
, rel_size
,
7095 NULL
, 0, NULL
, 0, is_rela
,
7096 FALSE
/* is_dynamic */);
7103 printf (_("\nThere are no relocations in this file.\n"));
7109 /* An absolute address consists of a section and an offset. If the
7110 section is NULL, the offset itself is the address, otherwise, the
7111 address equals to LOAD_ADDRESS(section) + offset. */
7115 unsigned short section
;
7119 #define ABSADDR(a) \
7121 ? section_headers [(a).section].sh_addr + (a).offset \
7124 /* Find the nearest symbol at or below ADDR. Returns the symbol
7125 name, if found, and the offset from the symbol to ADDR. */
7128 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7129 unsigned long nsyms
,
7130 const char * strtab
,
7131 unsigned long strtab_size
,
7132 struct absaddr addr
,
7133 const char ** symname
,
7136 bfd_vma dist
= 0x100000;
7137 Elf_Internal_Sym
* sym
;
7138 Elf_Internal_Sym
* beg
;
7139 Elf_Internal_Sym
* end
;
7140 Elf_Internal_Sym
* best
= NULL
;
7142 REMOVE_ARCH_BITS (addr
.offset
);
7144 end
= symtab
+ nsyms
;
7150 sym
= beg
+ (end
- beg
) / 2;
7152 value
= sym
->st_value
;
7153 REMOVE_ARCH_BITS (value
);
7155 if (sym
->st_name
!= 0
7156 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7157 && addr
.offset
>= value
7158 && addr
.offset
- value
< dist
)
7161 dist
= addr
.offset
- value
;
7166 if (addr
.offset
< value
)
7174 *symname
= (best
->st_name
>= strtab_size
7175 ? _("<corrupt>") : strtab
+ best
->st_name
);
7181 *offset
= addr
.offset
;
7184 static /* signed */ int
7185 symcmp (const void *p
, const void *q
)
7187 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7188 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7190 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7193 /* Process the unwind section. */
7195 #include "unwind-ia64.h"
7197 struct ia64_unw_table_entry
7199 struct absaddr start
;
7201 struct absaddr info
;
7204 struct ia64_unw_aux_info
7206 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7207 unsigned long table_len
; /* Length of unwind table. */
7208 unsigned char * info
; /* Unwind info. */
7209 unsigned long info_size
; /* Size of unwind info. */
7210 bfd_vma info_addr
; /* Starting address of unwind info. */
7211 bfd_vma seg_base
; /* Starting address of segment. */
7212 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7213 unsigned long nsyms
; /* Number of symbols. */
7214 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7215 unsigned long nfuns
; /* Number of entries in funtab. */
7216 char * strtab
; /* The string table. */
7217 unsigned long strtab_size
; /* Size of string table. */
7221 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7223 struct ia64_unw_table_entry
* tp
;
7224 unsigned long j
, nfuns
;
7226 bfd_boolean res
= TRUE
;
7228 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7229 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7230 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7231 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7233 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7235 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7239 const unsigned char * dp
;
7240 const unsigned char * head
;
7241 const unsigned char * end
;
7242 const char * procname
;
7244 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7245 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7247 fputs ("\n<", stdout
);
7251 fputs (procname
, stdout
);
7254 printf ("+%lx", (unsigned long) offset
);
7257 fputs (">: [", stdout
);
7258 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7259 fputc ('-', stdout
);
7260 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7261 printf ("], info at +0x%lx\n",
7262 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7264 /* PR 17531: file: 86232b32. */
7265 if (aux
->info
== NULL
)
7268 /* PR 17531: file: 0997b4d1. */
7269 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7271 warn (_("Invalid offset %lx in table entry %ld\n"),
7272 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7277 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7278 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7280 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7281 (unsigned) UNW_VER (stamp
),
7282 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7283 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7284 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7285 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7287 if (UNW_VER (stamp
) != 1)
7289 printf (_("\tUnknown version.\n"));
7294 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7295 /* PR 17531: file: 16ceda89. */
7296 if (end
> aux
->info
+ aux
->info_size
)
7297 end
= aux
->info
+ aux
->info_size
;
7298 for (dp
= head
+ 8; dp
< end
;)
7299 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7308 slurp_ia64_unwind_table (FILE * file
,
7309 struct ia64_unw_aux_info
* aux
,
7310 Elf_Internal_Shdr
* sec
)
7312 unsigned long size
, nrelas
, i
;
7313 Elf_Internal_Phdr
* seg
;
7314 struct ia64_unw_table_entry
* tep
;
7315 Elf_Internal_Shdr
* relsec
;
7316 Elf_Internal_Rela
* rela
;
7317 Elf_Internal_Rela
* rp
;
7318 unsigned char * table
;
7320 Elf_Internal_Sym
* sym
;
7321 const char * relname
;
7325 /* First, find the starting address of the segment that includes
7328 if (elf_header
.e_phnum
)
7330 if (! get_program_headers (file
))
7333 for (seg
= program_headers
;
7334 seg
< program_headers
+ elf_header
.e_phnum
;
7337 if (seg
->p_type
!= PT_LOAD
)
7340 if (sec
->sh_addr
>= seg
->p_vaddr
7341 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7343 aux
->seg_base
= seg
->p_vaddr
;
7349 /* Second, build the unwind table from the contents of the unwind section: */
7350 size
= sec
->sh_size
;
7351 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7356 aux
->table_len
= size
/ (3 * eh_addr_size
);
7357 aux
->table
= (struct ia64_unw_table_entry
*)
7358 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7361 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7363 tep
->start
.section
= SHN_UNDEF
;
7364 tep
->end
.section
= SHN_UNDEF
;
7365 tep
->info
.section
= SHN_UNDEF
;
7366 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7367 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7368 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7369 tep
->start
.offset
+= aux
->seg_base
;
7370 tep
->end
.offset
+= aux
->seg_base
;
7371 tep
->info
.offset
+= aux
->seg_base
;
7375 /* Third, apply any relocations to the unwind table: */
7376 for (relsec
= section_headers
;
7377 relsec
< section_headers
+ elf_header
.e_shnum
;
7380 if (relsec
->sh_type
!= SHT_RELA
7381 || relsec
->sh_info
>= elf_header
.e_shnum
7382 || section_headers
+ relsec
->sh_info
!= sec
)
7385 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7394 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7396 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7397 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7399 /* PR 17531: file: 9fa67536. */
7400 if (relname
== NULL
)
7402 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7406 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7408 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7412 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7414 /* PR 17531: file: 5bc8d9bf. */
7415 if (i
>= aux
->table_len
)
7417 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7421 switch (rp
->r_offset
/ eh_addr_size
% 3)
7424 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7425 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7428 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7429 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7432 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7433 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7447 ia64_process_unwind (FILE * file
)
7449 Elf_Internal_Shdr
* sec
;
7450 Elf_Internal_Shdr
* unwsec
= NULL
;
7451 Elf_Internal_Shdr
* strsec
;
7452 unsigned long i
, unwcount
= 0, unwstart
= 0;
7453 struct ia64_unw_aux_info aux
;
7454 bfd_boolean res
= TRUE
;
7456 memset (& aux
, 0, sizeof (aux
));
7458 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7460 if (sec
->sh_type
== SHT_SYMTAB
7461 && sec
->sh_link
< elf_header
.e_shnum
)
7463 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7465 strsec
= section_headers
+ sec
->sh_link
;
7466 if (aux
.strtab
!= NULL
)
7468 error (_("Multiple auxillary string tables encountered\n"));
7472 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7475 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7477 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7482 printf (_("\nThere are no unwind sections in this file.\n"));
7484 while (unwcount
-- > 0)
7489 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7490 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7491 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7496 /* We have already counted the number of SHT_IA64_UNWIND
7497 sections so the loop above should never fail. */
7498 assert (unwsec
!= NULL
);
7501 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7503 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7505 /* We need to find which section group it is in. */
7506 struct group_list
* g
;
7508 if (section_headers_groups
== NULL
7509 || section_headers_groups
[i
] == NULL
)
7510 i
= elf_header
.e_shnum
;
7513 g
= section_headers_groups
[i
]->root
;
7515 for (; g
!= NULL
; g
= g
->next
)
7517 sec
= section_headers
+ g
->section_index
;
7519 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7524 i
= elf_header
.e_shnum
;
7527 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7529 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7530 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7531 suffix
= SECTION_NAME (unwsec
) + len
;
7532 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7534 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7535 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7540 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7541 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7542 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7543 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7545 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7546 suffix
= SECTION_NAME (unwsec
) + len
;
7547 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7549 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7550 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7554 if (i
== elf_header
.e_shnum
)
7556 printf (_("\nCould not find unwind info section for "));
7558 if (string_table
== NULL
)
7559 printf ("%d", unwsec
->sh_name
);
7561 printf ("'%s'", printable_section_name (unwsec
));
7565 aux
.info_addr
= sec
->sh_addr
;
7566 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7569 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7571 printf (_("\nUnwind section "));
7573 if (string_table
== NULL
)
7574 printf ("%d", unwsec
->sh_name
);
7576 printf ("'%s'", printable_section_name (unwsec
));
7578 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7579 (unsigned long) unwsec
->sh_offset
,
7580 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7582 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7583 && aux
.table_len
> 0)
7584 dump_ia64_unwind (& aux
);
7587 free ((char *) aux
.table
);
7589 free ((char *) aux
.info
);
7598 free ((char *) aux
.strtab
);
7603 struct hppa_unw_table_entry
7605 struct absaddr start
;
7607 unsigned int Cannot_unwind
:1; /* 0 */
7608 unsigned int Millicode
:1; /* 1 */
7609 unsigned int Millicode_save_sr0
:1; /* 2 */
7610 unsigned int Region_description
:2; /* 3..4 */
7611 unsigned int reserved1
:1; /* 5 */
7612 unsigned int Entry_SR
:1; /* 6 */
7613 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7614 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7615 unsigned int Args_stored
:1; /* 16 */
7616 unsigned int Variable_Frame
:1; /* 17 */
7617 unsigned int Separate_Package_Body
:1; /* 18 */
7618 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7619 unsigned int Stack_Overflow_Check
:1; /* 20 */
7620 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7621 unsigned int Ada_Region
:1; /* 22 */
7622 unsigned int cxx_info
:1; /* 23 */
7623 unsigned int cxx_try_catch
:1; /* 24 */
7624 unsigned int sched_entry_seq
:1; /* 25 */
7625 unsigned int reserved2
:1; /* 26 */
7626 unsigned int Save_SP
:1; /* 27 */
7627 unsigned int Save_RP
:1; /* 28 */
7628 unsigned int Save_MRP_in_frame
:1; /* 29 */
7629 unsigned int extn_ptr_defined
:1; /* 30 */
7630 unsigned int Cleanup_defined
:1; /* 31 */
7632 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7633 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7634 unsigned int Large_frame
:1; /* 2 */
7635 unsigned int Pseudo_SP_Set
:1; /* 3 */
7636 unsigned int reserved4
:1; /* 4 */
7637 unsigned int Total_frame_size
:27; /* 5..31 */
7640 struct hppa_unw_aux_info
7642 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7643 unsigned long table_len
; /* Length of unwind table. */
7644 bfd_vma seg_base
; /* Starting address of segment. */
7645 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7646 unsigned long nsyms
; /* Number of symbols. */
7647 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7648 unsigned long nfuns
; /* Number of entries in funtab. */
7649 char * strtab
; /* The string table. */
7650 unsigned long strtab_size
; /* Size of string table. */
7654 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7656 struct hppa_unw_table_entry
* tp
;
7657 unsigned long j
, nfuns
;
7658 bfd_boolean res
= TRUE
;
7660 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7661 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7662 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7663 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7665 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7667 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7670 const char * procname
;
7672 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7673 aux
->strtab_size
, tp
->start
, &procname
,
7676 fputs ("\n<", stdout
);
7680 fputs (procname
, stdout
);
7683 printf ("+%lx", (unsigned long) offset
);
7686 fputs (">: [", stdout
);
7687 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7688 fputc ('-', stdout
);
7689 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7692 #define PF(_m) if (tp->_m) printf (#_m " ");
7693 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7696 PF(Millicode_save_sr0
);
7697 /* PV(Region_description); */
7703 PF(Separate_Package_Body
);
7704 PF(Frame_Extension_Millicode
);
7705 PF(Stack_Overflow_Check
);
7706 PF(Two_Instruction_SP_Increment
);
7710 PF(sched_entry_seq
);
7713 PF(Save_MRP_in_frame
);
7714 PF(extn_ptr_defined
);
7715 PF(Cleanup_defined
);
7716 PF(MPE_XL_interrupt_marker
);
7717 PF(HP_UX_interrupt_marker
);
7720 PV(Total_frame_size
);
7733 slurp_hppa_unwind_table (FILE * file
,
7734 struct hppa_unw_aux_info
* aux
,
7735 Elf_Internal_Shdr
* sec
)
7737 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7738 Elf_Internal_Phdr
* seg
;
7739 struct hppa_unw_table_entry
* tep
;
7740 Elf_Internal_Shdr
* relsec
;
7741 Elf_Internal_Rela
* rela
;
7742 Elf_Internal_Rela
* rp
;
7743 unsigned char * table
;
7745 Elf_Internal_Sym
* sym
;
7746 const char * relname
;
7748 /* First, find the starting address of the segment that includes
7750 if (elf_header
.e_phnum
)
7752 if (! get_program_headers (file
))
7755 for (seg
= program_headers
;
7756 seg
< program_headers
+ elf_header
.e_phnum
;
7759 if (seg
->p_type
!= PT_LOAD
)
7762 if (sec
->sh_addr
>= seg
->p_vaddr
7763 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7765 aux
->seg_base
= seg
->p_vaddr
;
7771 /* Second, build the unwind table from the contents of the unwind
7773 size
= sec
->sh_size
;
7774 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7780 nentries
= size
/ unw_ent_size
;
7781 size
= unw_ent_size
* nentries
;
7783 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7784 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7786 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7788 unsigned int tmp1
, tmp2
;
7790 tep
->start
.section
= SHN_UNDEF
;
7791 tep
->end
.section
= SHN_UNDEF
;
7793 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7794 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7795 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7796 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7798 tep
->start
.offset
+= aux
->seg_base
;
7799 tep
->end
.offset
+= aux
->seg_base
;
7801 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7802 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7803 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7804 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7805 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7806 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7807 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7808 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7809 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7810 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7811 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7812 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7813 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7814 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7815 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7816 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7817 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7818 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7819 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7820 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7821 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7822 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7823 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7824 tep
->Cleanup_defined
= tmp1
& 0x1;
7826 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7827 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7828 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7829 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7830 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7831 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7835 /* Third, apply any relocations to the unwind table. */
7836 for (relsec
= section_headers
;
7837 relsec
< section_headers
+ elf_header
.e_shnum
;
7840 if (relsec
->sh_type
!= SHT_RELA
7841 || relsec
->sh_info
>= elf_header
.e_shnum
7842 || section_headers
+ relsec
->sh_info
!= sec
)
7845 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7849 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7851 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7852 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7854 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7855 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7857 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7861 i
= rp
->r_offset
/ unw_ent_size
;
7863 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7866 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7867 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7870 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7871 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7881 aux
->table_len
= nentries
;
7887 hppa_process_unwind (FILE * file
)
7889 struct hppa_unw_aux_info aux
;
7890 Elf_Internal_Shdr
* unwsec
= NULL
;
7891 Elf_Internal_Shdr
* strsec
;
7892 Elf_Internal_Shdr
* sec
;
7894 bfd_boolean res
= TRUE
;
7896 if (string_table
== NULL
)
7899 memset (& aux
, 0, sizeof (aux
));
7901 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7903 if (sec
->sh_type
== SHT_SYMTAB
7904 && sec
->sh_link
< elf_header
.e_shnum
)
7906 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7908 strsec
= section_headers
+ sec
->sh_link
;
7909 if (aux
.strtab
!= NULL
)
7911 error (_("Multiple auxillary string tables encountered\n"));
7915 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7918 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7920 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7925 printf (_("\nThere are no unwind sections in this file.\n"));
7927 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7929 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7931 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7932 printable_section_name (sec
),
7933 (unsigned long) sec
->sh_offset
,
7934 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7936 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7939 if (aux
.table_len
> 0)
7941 if (! dump_hppa_unwind (&aux
))
7946 free ((char *) aux
.table
);
7954 free ((char *) aux
.strtab
);
7961 unsigned char * data
; /* The unwind data. */
7962 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7963 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7964 unsigned long nrelas
; /* The number of relocations. */
7965 unsigned int rel_type
; /* REL or RELA ? */
7966 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7969 struct arm_unw_aux_info
7971 FILE * file
; /* The file containing the unwind sections. */
7972 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7973 unsigned long nsyms
; /* Number of symbols. */
7974 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7975 unsigned long nfuns
; /* Number of these symbols. */
7976 char * strtab
; /* The file's string table. */
7977 unsigned long strtab_size
; /* Size of string table. */
7981 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7982 bfd_vma fn
, struct absaddr addr
)
7984 const char *procname
;
7987 if (addr
.section
== SHN_UNDEF
)
7990 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7991 aux
->strtab_size
, addr
, &procname
,
7994 print_vma (fn
, PREFIX_HEX
);
7998 fputs (" <", stdout
);
7999 fputs (procname
, stdout
);
8002 printf ("+0x%lx", (unsigned long) sym_offset
);
8003 fputc ('>', stdout
);
8010 arm_free_section (struct arm_section
*arm_sec
)
8012 if (arm_sec
->data
!= NULL
)
8013 free (arm_sec
->data
);
8015 if (arm_sec
->rela
!= NULL
)
8016 free (arm_sec
->rela
);
8019 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8020 cached section and install SEC instead.
8021 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8022 and return its valued in * WORDP, relocating if necessary.
8023 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8024 relocation's offset in ADDR.
8025 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8026 into the string table of the symbol associated with the reloc. If no
8027 reloc was applied store -1 there.
8028 5) Return TRUE upon success, FALSE otherwise. */
8031 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
8032 struct arm_section
* arm_sec
,
8033 Elf_Internal_Shdr
* sec
,
8034 bfd_vma word_offset
,
8035 unsigned int * wordp
,
8036 struct absaddr
* addr
,
8039 Elf_Internal_Rela
*rp
;
8040 Elf_Internal_Sym
*sym
;
8041 const char * relname
;
8043 bfd_boolean wrapped
;
8045 if (sec
== NULL
|| arm_sec
== NULL
)
8048 addr
->section
= SHN_UNDEF
;
8051 if (sym_name
!= NULL
)
8052 *sym_name
= (bfd_vma
) -1;
8054 /* If necessary, update the section cache. */
8055 if (sec
!= arm_sec
->sec
)
8057 Elf_Internal_Shdr
*relsec
;
8059 arm_free_section (arm_sec
);
8062 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8063 sec
->sh_size
, _("unwind data"));
8064 arm_sec
->rela
= NULL
;
8065 arm_sec
->nrelas
= 0;
8067 for (relsec
= section_headers
;
8068 relsec
< section_headers
+ elf_header
.e_shnum
;
8071 if (relsec
->sh_info
>= elf_header
.e_shnum
8072 || section_headers
+ relsec
->sh_info
!= sec
8073 /* PR 15745: Check the section type as well. */
8074 || (relsec
->sh_type
!= SHT_REL
8075 && relsec
->sh_type
!= SHT_RELA
))
8078 arm_sec
->rel_type
= relsec
->sh_type
;
8079 if (relsec
->sh_type
== SHT_REL
)
8081 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8083 & arm_sec
->rela
, & arm_sec
->nrelas
))
8086 else /* relsec->sh_type == SHT_RELA */
8088 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8090 & arm_sec
->rela
, & arm_sec
->nrelas
))
8096 arm_sec
->next_rela
= arm_sec
->rela
;
8099 /* If there is no unwind data we can do nothing. */
8100 if (arm_sec
->data
== NULL
)
8103 /* If the offset is invalid then fail. */
8104 if (/* PR 21343 *//* PR 18879 */
8106 || word_offset
> (sec
->sh_size
- 4)
8107 || ((bfd_signed_vma
) word_offset
) < 0)
8110 /* Get the word at the required offset. */
8111 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8113 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8114 if (arm_sec
->rela
== NULL
)
8120 /* Look through the relocs to find the one that applies to the provided offset. */
8122 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8124 bfd_vma prelval
, offset
;
8126 if (rp
->r_offset
> word_offset
&& !wrapped
)
8131 if (rp
->r_offset
> word_offset
)
8134 if (rp
->r_offset
& 3)
8136 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8137 (unsigned long) rp
->r_offset
);
8141 if (rp
->r_offset
< word_offset
)
8144 /* PR 17531: file: 027-161405-0.004 */
8145 if (aux
->symtab
== NULL
)
8148 if (arm_sec
->rel_type
== SHT_REL
)
8150 offset
= word
& 0x7fffffff;
8151 if (offset
& 0x40000000)
8152 offset
|= ~ (bfd_vma
) 0x7fffffff;
8154 else if (arm_sec
->rel_type
== SHT_RELA
)
8155 offset
= rp
->r_addend
;
8158 error (_("Unknown section relocation type %d encountered\n"),
8163 /* PR 17531 file: 027-1241568-0.004. */
8164 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8166 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8167 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8171 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8172 offset
+= sym
->st_value
;
8173 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8175 /* Check that we are processing the expected reloc type. */
8176 if (elf_header
.e_machine
== EM_ARM
)
8178 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8179 if (relname
== NULL
)
8181 warn (_("Skipping unknown ARM relocation type: %d\n"),
8182 (int) ELF32_R_TYPE (rp
->r_info
));
8186 if (streq (relname
, "R_ARM_NONE"))
8189 if (! streq (relname
, "R_ARM_PREL31"))
8191 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8195 else if (elf_header
.e_machine
== EM_TI_C6000
)
8197 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8198 if (relname
== NULL
)
8200 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8201 (int) ELF32_R_TYPE (rp
->r_info
));
8205 if (streq (relname
, "R_C6000_NONE"))
8208 if (! streq (relname
, "R_C6000_PREL31"))
8210 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8218 /* This function currently only supports ARM and TI unwinders. */
8219 warn (_("Only TI and ARM unwinders are currently supported\n"));
8223 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8224 addr
->section
= sym
->st_shndx
;
8225 addr
->offset
= offset
;
8228 * sym_name
= sym
->st_name
;
8233 arm_sec
->next_rela
= rp
;
8238 static const char *tic6x_unwind_regnames
[16] =
8240 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8241 "A14", "A13", "A12", "A11", "A10",
8242 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8246 decode_tic6x_unwind_regmask (unsigned int mask
)
8250 for (i
= 12; mask
; mask
>>= 1, i
--)
8254 fputs (tic6x_unwind_regnames
[i
], stdout
);
8256 fputs (", ", stdout
);
8262 if (remaining == 0 && more_words) \
8265 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8266 data_offset, & word, & addr, NULL)) \
8272 #define GET_OP(OP) \
8277 (OP) = word >> 24; \
8282 printf (_("[Truncated opcode]\n")); \
8285 printf ("0x%02x ", OP)
8288 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8290 unsigned int remaining
,
8291 unsigned int more_words
,
8292 bfd_vma data_offset
,
8293 Elf_Internal_Shdr
* data_sec
,
8294 struct arm_section
* data_arm_sec
)
8296 struct absaddr addr
;
8297 bfd_boolean res
= TRUE
;
8299 /* Decode the unwinding instructions. */
8302 unsigned int op
, op2
;
8311 printf (" 0x%02x ", op
);
8313 if ((op
& 0xc0) == 0x00)
8315 int offset
= ((op
& 0x3f) << 2) + 4;
8317 printf (" vsp = vsp + %d", offset
);
8319 else if ((op
& 0xc0) == 0x40)
8321 int offset
= ((op
& 0x3f) << 2) + 4;
8323 printf (" vsp = vsp - %d", offset
);
8325 else if ((op
& 0xf0) == 0x80)
8328 if (op
== 0x80 && op2
== 0)
8329 printf (_("Refuse to unwind"));
8332 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8333 bfd_boolean first
= TRUE
;
8337 for (i
= 0; i
< 12; i
++)
8338 if (mask
& (1 << i
))
8344 printf ("r%d", 4 + i
);
8349 else if ((op
& 0xf0) == 0x90)
8351 if (op
== 0x9d || op
== 0x9f)
8352 printf (_(" [Reserved]"));
8354 printf (" vsp = r%d", op
& 0x0f);
8356 else if ((op
& 0xf0) == 0xa0)
8358 int end
= 4 + (op
& 0x07);
8359 bfd_boolean first
= TRUE
;
8363 for (i
= 4; i
<= end
; i
++)
8379 else if (op
== 0xb0)
8380 printf (_(" finish"));
8381 else if (op
== 0xb1)
8384 if (op2
== 0 || (op2
& 0xf0) != 0)
8385 printf (_("[Spare]"));
8388 unsigned int mask
= op2
& 0x0f;
8389 bfd_boolean first
= TRUE
;
8393 for (i
= 0; i
< 12; i
++)
8394 if (mask
& (1 << i
))
8405 else if (op
== 0xb2)
8407 unsigned char buf
[9];
8408 unsigned int i
, len
;
8409 unsigned long offset
;
8411 for (i
= 0; i
< sizeof (buf
); i
++)
8414 if ((buf
[i
] & 0x80) == 0)
8417 if (i
== sizeof (buf
))
8419 error (_("corrupt change to vsp"));
8424 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8425 assert (len
== i
+ 1);
8426 offset
= offset
* 4 + 0x204;
8427 printf ("vsp = vsp + %ld", offset
);
8430 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8432 unsigned int first
, last
;
8439 printf ("pop {D%d", first
);
8441 printf ("-D%d", first
+ last
);
8444 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8446 unsigned int count
= op
& 0x07;
8450 printf ("-D%d", 8 + count
);
8453 else if (op
>= 0xc0 && op
<= 0xc5)
8455 unsigned int count
= op
& 0x07;
8457 printf (" pop {wR10");
8459 printf ("-wR%d", 10 + count
);
8462 else if (op
== 0xc6)
8464 unsigned int first
, last
;
8469 printf ("pop {wR%d", first
);
8471 printf ("-wR%d", first
+ last
);
8474 else if (op
== 0xc7)
8477 if (op2
== 0 || (op2
& 0xf0) != 0)
8478 printf (_("[Spare]"));
8481 unsigned int mask
= op2
& 0x0f;
8482 bfd_boolean first
= TRUE
;
8486 for (i
= 0; i
< 4; i
++)
8487 if (mask
& (1 << i
))
8493 printf ("wCGR%d", i
);
8500 printf (_(" [unsupported opcode]"));
8511 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8513 unsigned int remaining
,
8514 unsigned int more_words
,
8515 bfd_vma data_offset
,
8516 Elf_Internal_Shdr
* data_sec
,
8517 struct arm_section
* data_arm_sec
)
8519 struct absaddr addr
;
8521 /* Decode the unwinding instructions. */
8524 unsigned int op
, op2
;
8533 printf (" 0x%02x ", op
);
8535 if ((op
& 0xc0) == 0x00)
8537 int offset
= ((op
& 0x3f) << 3) + 8;
8538 printf (" sp = sp + %d", offset
);
8540 else if ((op
& 0xc0) == 0x80)
8543 if (op
== 0x80 && op2
== 0)
8544 printf (_("Refuse to unwind"));
8547 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8549 printf ("pop compact {");
8553 decode_tic6x_unwind_regmask (mask
);
8557 else if ((op
& 0xf0) == 0xc0)
8565 unsigned int offset
;
8569 /* Scan entire instruction first so that GET_OP output is not
8570 interleaved with disassembly. */
8572 for (i
= 0; nregs
< (op
& 0xf); i
++)
8578 regpos
[nregs
].offset
= i
* 2;
8579 regpos
[nregs
].reg
= reg
;
8586 regpos
[nregs
].offset
= i
* 2 + 1;
8587 regpos
[nregs
].reg
= reg
;
8592 printf (_("pop frame {"));
8594 for (i
= i
* 2; i
> 0; i
--)
8596 if (regpos
[reg
].offset
== i
- 1)
8598 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8605 fputs (name
, stdout
);
8612 else if (op
== 0xd0)
8613 printf (" MOV FP, SP");
8614 else if (op
== 0xd1)
8615 printf (" __c6xabi_pop_rts");
8616 else if (op
== 0xd2)
8618 unsigned char buf
[9];
8619 unsigned int i
, len
;
8620 unsigned long offset
;
8622 for (i
= 0; i
< sizeof (buf
); i
++)
8625 if ((buf
[i
] & 0x80) == 0)
8628 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8629 if (i
== sizeof (buf
))
8631 warn (_("Corrupt stack pointer adjustment detected\n"));
8635 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8636 assert (len
== i
+ 1);
8637 offset
= offset
* 8 + 0x408;
8638 printf (_("sp = sp + %ld"), offset
);
8640 else if ((op
& 0xf0) == 0xe0)
8642 if ((op
& 0x0f) == 7)
8645 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8649 printf (_(" [unsupported opcode]"));
8658 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8662 offset
= word
& 0x7fffffff;
8663 if (offset
& 0x40000000)
8664 offset
|= ~ (bfd_vma
) 0x7fffffff;
8666 if (elf_header
.e_machine
== EM_TI_C6000
)
8669 return offset
+ where
;
8673 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8675 unsigned int remaining
,
8676 bfd_vma data_offset
,
8677 Elf_Internal_Shdr
* data_sec
,
8678 struct arm_section
* data_arm_sec
)
8681 unsigned int more_words
= 0;
8682 struct absaddr addr
;
8683 bfd_vma sym_name
= (bfd_vma
) -1;
8684 bfd_boolean res
= FALSE
;
8688 /* Fetch the first word.
8689 Note - when decoding an object file the address extracted
8690 here will always be 0. So we also pass in the sym_name
8691 parameter so that we can find the symbol associated with
8692 the personality routine. */
8693 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8694 & word
, & addr
, & sym_name
))
8700 if ((word
& 0x80000000) == 0)
8702 /* Expand prel31 for personality routine. */
8704 const char *procname
;
8706 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8707 printf (_(" Personality routine: "));
8709 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8710 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8712 procname
= aux
->strtab
+ sym_name
;
8713 print_vma (fn
, PREFIX_HEX
);
8716 fputs (" <", stdout
);
8717 fputs (procname
, stdout
);
8718 fputc ('>', stdout
);
8722 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8723 fputc ('\n', stdout
);
8725 /* The GCC personality routines use the standard compact
8726 encoding, starting with one byte giving the number of
8728 if (procname
!= NULL
8729 && (const_strneq (procname
, "__gcc_personality_v0")
8730 || const_strneq (procname
, "__gxx_personality_v0")
8731 || const_strneq (procname
, "__gcj_personality_v0")
8732 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8739 printf (_(" [Truncated data]\n"));
8742 more_words
= word
>> 24;
8752 /* ARM EHABI Section 6.3:
8754 An exception-handling table entry for the compact model looks like:
8758 1 0 index Data for personalityRoutine[index] */
8760 if (elf_header
.e_machine
== EM_ARM
8761 && (word
& 0x70000000))
8763 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8767 per_index
= (word
>> 24) & 0x7f;
8768 printf (_(" Compact model index: %d\n"), per_index
);
8775 else if (per_index
< 3)
8777 more_words
= (word
>> 16) & 0xff;
8783 switch (elf_header
.e_machine
)
8788 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8789 data_offset
, data_sec
, data_arm_sec
))
8794 warn (_("Unknown ARM compact model index encountered\n"));
8795 printf (_(" [reserved]\n"));
8803 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8804 data_offset
, data_sec
, data_arm_sec
))
8807 else if (per_index
< 5)
8809 if (((word
>> 17) & 0x7f) == 0x7f)
8810 printf (_(" Restore stack from frame pointer\n"));
8812 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8813 printf (_(" Registers restored: "));
8815 printf (" (compact) ");
8816 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8818 printf (_(" Return register: %s\n"),
8819 tic6x_unwind_regnames
[word
& 0xf]);
8822 printf (_(" [reserved (%d)]\n"), per_index
);
8826 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8827 elf_header
.e_machine
);
8831 /* Decode the descriptors. Not implemented. */
8837 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8839 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8840 unsigned int i
, exidx_len
;
8841 unsigned long j
, nfuns
;
8842 bfd_boolean res
= TRUE
;
8844 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8845 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8846 exidx_len
= exidx_sec
->sh_size
/ 8;
8848 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8849 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8850 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8851 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8853 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8855 for (i
= 0; i
< exidx_len
; i
++)
8857 unsigned int exidx_fn
, exidx_entry
;
8858 struct absaddr fn_addr
, entry_addr
;
8861 fputc ('\n', stdout
);
8863 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8864 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8865 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8866 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8869 arm_free_section (& exidx_arm_sec
);
8870 arm_free_section (& extab_arm_sec
);
8874 /* ARM EHABI, Section 5:
8875 An index table entry consists of 2 words.
8876 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8877 if (exidx_fn
& 0x80000000)
8879 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8883 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8885 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8886 fputs (": ", stdout
);
8888 if (exidx_entry
== 1)
8890 print_vma (exidx_entry
, PREFIX_HEX
);
8891 fputs (" [cantunwind]\n", stdout
);
8893 else if (exidx_entry
& 0x80000000)
8895 print_vma (exidx_entry
, PREFIX_HEX
);
8896 fputc ('\n', stdout
);
8897 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8901 bfd_vma table
, table_offset
= 0;
8902 Elf_Internal_Shdr
*table_sec
;
8904 fputs ("@", stdout
);
8905 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8906 print_vma (table
, PREFIX_HEX
);
8909 /* Locate the matching .ARM.extab. */
8910 if (entry_addr
.section
!= SHN_UNDEF
8911 && entry_addr
.section
< elf_header
.e_shnum
)
8913 table_sec
= section_headers
+ entry_addr
.section
;
8914 table_offset
= entry_addr
.offset
;
8916 if (table_offset
> table_sec
->sh_size
8917 || ((bfd_signed_vma
) table_offset
) < 0)
8919 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8920 (unsigned long) table_offset
,
8921 printable_section_name (table_sec
));
8928 table_sec
= find_section_by_address (table
);
8929 if (table_sec
!= NULL
)
8930 table_offset
= table
- table_sec
->sh_addr
;
8933 if (table_sec
== NULL
)
8935 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8936 (unsigned long) table
);
8941 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8950 arm_free_section (&exidx_arm_sec
);
8951 arm_free_section (&extab_arm_sec
);
8956 /* Used for both ARM and C6X unwinding tables. */
8959 arm_process_unwind (FILE *file
)
8961 struct arm_unw_aux_info aux
;
8962 Elf_Internal_Shdr
*unwsec
= NULL
;
8963 Elf_Internal_Shdr
*strsec
;
8964 Elf_Internal_Shdr
*sec
;
8966 unsigned int sec_type
;
8967 bfd_boolean res
= TRUE
;
8969 switch (elf_header
.e_machine
)
8972 sec_type
= SHT_ARM_EXIDX
;
8976 sec_type
= SHT_C6000_UNWIND
;
8980 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8981 elf_header
.e_machine
);
8985 if (string_table
== NULL
)
8988 memset (& aux
, 0, sizeof (aux
));
8991 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8993 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8995 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8997 strsec
= section_headers
+ sec
->sh_link
;
8999 /* PR binutils/17531 file: 011-12666-0.004. */
9000 if (aux
.strtab
!= NULL
)
9002 error (_("Multiple string tables found in file.\n"));
9006 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
9007 1, strsec
->sh_size
, _("string table"));
9008 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9010 else if (sec
->sh_type
== sec_type
)
9015 printf (_("\nThere are no unwind sections in this file.\n"));
9017 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9019 if (sec
->sh_type
== sec_type
)
9021 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9022 printable_section_name (sec
),
9023 (unsigned long) sec
->sh_offset
,
9024 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
9026 if (! dump_arm_unwind (&aux
, sec
))
9034 free ((char *) aux
.strtab
);
9040 process_unwind (FILE * file
)
9042 struct unwind_handler
9044 unsigned int machtype
;
9045 bfd_boolean (* handler
)(FILE *);
9048 { EM_ARM
, arm_process_unwind
},
9049 { EM_IA_64
, ia64_process_unwind
},
9050 { EM_PARISC
, hppa_process_unwind
},
9051 { EM_TI_C6000
, arm_process_unwind
},
9059 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9060 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9061 return handlers
[i
].handler (file
);
9063 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9064 get_machine_name (elf_header
.e_machine
));
9069 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9071 switch (entry
->d_tag
)
9074 if (entry
->d_un
.d_val
== 0)
9078 static const char * opts
[] =
9080 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9081 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9082 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9083 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9087 bfd_boolean first
= TRUE
;
9089 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9090 if (entry
->d_un
.d_val
& (1 << cnt
))
9092 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9098 case DT_MIPS_IVERSION
:
9099 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9100 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9104 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9105 /* Note: coded this way so that there is a single string for translation. */
9106 printf (_("<corrupt: %s>"), buf
);
9110 case DT_MIPS_TIME_STAMP
:
9114 time_t atime
= entry
->d_un
.d_val
;
9116 tmp
= gmtime (&atime
);
9117 /* PR 17531: file: 6accc532. */
9119 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9121 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9122 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9123 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9124 printf (_("Time Stamp: %s"), timebuf
);
9128 case DT_MIPS_RLD_VERSION
:
9129 case DT_MIPS_LOCAL_GOTNO
:
9130 case DT_MIPS_CONFLICTNO
:
9131 case DT_MIPS_LIBLISTNO
:
9132 case DT_MIPS_SYMTABNO
:
9133 case DT_MIPS_UNREFEXTNO
:
9134 case DT_MIPS_HIPAGENO
:
9135 case DT_MIPS_DELTA_CLASS_NO
:
9136 case DT_MIPS_DELTA_INSTANCE_NO
:
9137 case DT_MIPS_DELTA_RELOC_NO
:
9138 case DT_MIPS_DELTA_SYM_NO
:
9139 case DT_MIPS_DELTA_CLASSSYM_NO
:
9140 case DT_MIPS_COMPACT_SIZE
:
9141 print_vma (entry
->d_un
.d_val
, DEC
);
9145 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9151 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9153 switch (entry
->d_tag
)
9155 case DT_HP_DLD_FLAGS
:
9164 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9165 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9166 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9167 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9168 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9169 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9170 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9171 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9172 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9173 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9174 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9175 { DT_HP_GST
, "HP_GST" },
9176 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9177 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9178 { DT_HP_NODELETE
, "HP_NODELETE" },
9179 { DT_HP_GROUP
, "HP_GROUP" },
9180 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9182 bfd_boolean first
= TRUE
;
9184 bfd_vma val
= entry
->d_un
.d_val
;
9186 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9187 if (val
& flags
[cnt
].bit
)
9191 fputs (flags
[cnt
].str
, stdout
);
9193 val
^= flags
[cnt
].bit
;
9196 if (val
!= 0 || first
)
9200 print_vma (val
, HEX
);
9206 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9214 /* VMS vs Unix time offset and factor. */
9216 #define VMS_EPOCH_OFFSET 35067168000000000LL
9217 #define VMS_GRANULARITY_FACTOR 10000000
9219 /* Display a VMS time in a human readable format. */
9222 print_vms_time (bfd_int64_t vmstime
)
9227 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9228 tm
= gmtime (&unxtime
);
9229 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9230 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9231 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9236 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9238 switch (entry
->d_tag
)
9240 case DT_IA_64_PLT_RESERVE
:
9241 /* First 3 slots reserved. */
9242 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9244 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9247 case DT_IA_64_VMS_LINKTIME
:
9249 print_vms_time (entry
->d_un
.d_val
);
9253 case DT_IA_64_VMS_LNKFLAGS
:
9254 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9255 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9256 printf (" CALL_DEBUG");
9257 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9258 printf (" NOP0BUFS");
9259 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9260 printf (" P0IMAGE");
9261 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9262 printf (" MKTHREADS");
9263 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9264 printf (" UPCALLS");
9265 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9267 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9268 printf (" INITIALIZE");
9269 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9271 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9272 printf (" EXE_INIT");
9273 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9274 printf (" TBK_IN_IMG");
9275 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9276 printf (" DBG_IN_IMG");
9277 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9278 printf (" TBK_IN_DSF");
9279 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9280 printf (" DBG_IN_DSF");
9281 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9282 printf (" SIGNATURES");
9283 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9284 printf (" REL_SEG_OFF");
9288 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9295 get_32bit_dynamic_section (FILE * file
)
9297 Elf32_External_Dyn
* edyn
;
9298 Elf32_External_Dyn
* ext
;
9299 Elf_Internal_Dyn
* entry
;
9301 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9302 dynamic_size
, _("dynamic section"));
9306 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9307 might not have the luxury of section headers. Look for the DT_NULL
9308 terminator to determine the number of entries. */
9309 for (ext
= edyn
, dynamic_nent
= 0;
9310 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9314 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9318 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9320 if (dynamic_section
== NULL
)
9322 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9323 (unsigned long) dynamic_nent
);
9328 for (ext
= edyn
, entry
= dynamic_section
;
9329 entry
< dynamic_section
+ dynamic_nent
;
9332 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9333 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9342 get_64bit_dynamic_section (FILE * file
)
9344 Elf64_External_Dyn
* edyn
;
9345 Elf64_External_Dyn
* ext
;
9346 Elf_Internal_Dyn
* entry
;
9348 /* Read in the data. */
9349 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9350 dynamic_size
, _("dynamic section"));
9354 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9355 might not have the luxury of section headers. Look for the DT_NULL
9356 terminator to determine the number of entries. */
9357 for (ext
= edyn
, dynamic_nent
= 0;
9358 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9359 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9363 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9367 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9369 if (dynamic_section
== NULL
)
9371 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9372 (unsigned long) dynamic_nent
);
9377 /* Convert from external to internal formats. */
9378 for (ext
= edyn
, entry
= dynamic_section
;
9379 entry
< dynamic_section
+ dynamic_nent
;
9382 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9383 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9392 print_dynamic_flags (bfd_vma flags
)
9394 bfd_boolean first
= TRUE
;
9400 flag
= flags
& - flags
;
9410 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9411 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9412 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9413 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9414 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9415 default: fputs (_("unknown"), stdout
); break;
9421 /* Parse and display the contents of the dynamic section. */
9424 process_dynamic_section (FILE * file
)
9426 Elf_Internal_Dyn
* entry
;
9428 if (dynamic_size
== 0)
9431 printf (_("\nThere is no dynamic section in this file.\n"));
9438 if (! get_32bit_dynamic_section (file
))
9443 if (! get_64bit_dynamic_section (file
))
9447 /* Find the appropriate symbol table. */
9448 if (dynamic_symbols
== NULL
)
9450 for (entry
= dynamic_section
;
9451 entry
< dynamic_section
+ dynamic_nent
;
9454 Elf_Internal_Shdr section
;
9456 if (entry
->d_tag
!= DT_SYMTAB
)
9459 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9461 /* Since we do not know how big the symbol table is,
9462 we default to reading in the entire file (!) and
9463 processing that. This is overkill, I know, but it
9465 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9466 if ((bfd_size_type
) section
.sh_offset
> current_file_size
)
9468 /* See PR 21379 for a reproducer. */
9469 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9473 if (archive_file_offset
!= 0)
9474 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9477 if (fseek (file
, 0, SEEK_END
))
9478 error (_("Unable to seek to end of file!\n"));
9480 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9484 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9486 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9487 section
.sh_name
= string_table_length
;
9489 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9490 if (num_dynamic_syms
< 1)
9492 error (_("Unable to determine the number of symbols to load\n"));
9498 /* Similarly find a string table. */
9499 if (dynamic_strings
== NULL
)
9501 for (entry
= dynamic_section
;
9502 entry
< dynamic_section
+ dynamic_nent
;
9505 unsigned long offset
;
9508 if (entry
->d_tag
!= DT_STRTAB
)
9511 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9513 /* Since we do not know how big the string table is,
9514 we default to reading in the entire file (!) and
9515 processing that. This is overkill, I know, but it
9518 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9520 if (archive_file_offset
!= 0)
9521 str_tab_len
= archive_file_size
- offset
;
9524 if (fseek (file
, 0, SEEK_END
))
9525 error (_("Unable to seek to end of file\n"));
9526 str_tab_len
= ftell (file
) - offset
;
9529 if (str_tab_len
< 1)
9532 (_("Unable to determine the length of the dynamic string table\n"));
9536 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9538 _("dynamic string table"));
9539 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9544 /* And find the syminfo section if available. */
9545 if (dynamic_syminfo
== NULL
)
9547 unsigned long syminsz
= 0;
9549 for (entry
= dynamic_section
;
9550 entry
< dynamic_section
+ dynamic_nent
;
9553 if (entry
->d_tag
== DT_SYMINENT
)
9555 /* Note: these braces are necessary to avoid a syntax
9556 error from the SunOS4 C compiler. */
9557 /* PR binutils/17531: A corrupt file can trigger this test.
9558 So do not use an assert, instead generate an error message. */
9559 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9560 error (_("Bad value (%d) for SYMINENT entry\n"),
9561 (int) entry
->d_un
.d_val
);
9563 else if (entry
->d_tag
== DT_SYMINSZ
)
9564 syminsz
= entry
->d_un
.d_val
;
9565 else if (entry
->d_tag
== DT_SYMINFO
)
9566 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9570 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9572 Elf_External_Syminfo
* extsyminfo
;
9573 Elf_External_Syminfo
* extsym
;
9574 Elf_Internal_Syminfo
* syminfo
;
9576 /* There is a syminfo section. Read the data. */
9577 extsyminfo
= (Elf_External_Syminfo
*)
9578 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9579 _("symbol information"));
9583 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9584 if (dynamic_syminfo
== NULL
)
9586 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9587 (unsigned long) syminsz
);
9591 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9592 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9593 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9594 ++syminfo
, ++extsym
)
9596 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9597 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9604 if (do_dynamic
&& dynamic_addr
)
9605 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9606 dynamic_addr
, (unsigned long) dynamic_nent
);
9608 printf (_(" Tag Type Name/Value\n"));
9610 for (entry
= dynamic_section
;
9611 entry
< dynamic_section
+ dynamic_nent
;
9619 print_vma (entry
->d_tag
, FULL_HEX
);
9620 dtype
= get_dynamic_type (entry
->d_tag
);
9621 printf (" (%s)%*s", dtype
,
9622 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9625 switch (entry
->d_tag
)
9629 print_dynamic_flags (entry
->d_un
.d_val
);
9639 switch (entry
->d_tag
)
9642 printf (_("Auxiliary library"));
9646 printf (_("Filter library"));
9650 printf (_("Configuration file"));
9654 printf (_("Dependency audit library"));
9658 printf (_("Audit library"));
9662 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9663 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9667 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9676 printf (_("Flags:"));
9678 if (entry
->d_un
.d_val
== 0)
9679 printf (_(" None\n"));
9682 unsigned long int val
= entry
->d_un
.d_val
;
9684 if (val
& DTF_1_PARINIT
)
9686 printf (" PARINIT");
9687 val
^= DTF_1_PARINIT
;
9689 if (val
& DTF_1_CONFEXP
)
9691 printf (" CONFEXP");
9692 val
^= DTF_1_CONFEXP
;
9695 printf (" %lx", val
);
9704 printf (_("Flags:"));
9706 if (entry
->d_un
.d_val
== 0)
9707 printf (_(" None\n"));
9710 unsigned long int val
= entry
->d_un
.d_val
;
9712 if (val
& DF_P1_LAZYLOAD
)
9714 printf (" LAZYLOAD");
9715 val
^= DF_P1_LAZYLOAD
;
9717 if (val
& DF_P1_GROUPPERM
)
9719 printf (" GROUPPERM");
9720 val
^= DF_P1_GROUPPERM
;
9723 printf (" %lx", val
);
9732 printf (_("Flags:"));
9733 if (entry
->d_un
.d_val
== 0)
9734 printf (_(" None\n"));
9737 unsigned long int val
= entry
->d_un
.d_val
;
9744 if (val
& DF_1_GLOBAL
)
9749 if (val
& DF_1_GROUP
)
9754 if (val
& DF_1_NODELETE
)
9756 printf (" NODELETE");
9757 val
^= DF_1_NODELETE
;
9759 if (val
& DF_1_LOADFLTR
)
9761 printf (" LOADFLTR");
9762 val
^= DF_1_LOADFLTR
;
9764 if (val
& DF_1_INITFIRST
)
9766 printf (" INITFIRST");
9767 val
^= DF_1_INITFIRST
;
9769 if (val
& DF_1_NOOPEN
)
9774 if (val
& DF_1_ORIGIN
)
9779 if (val
& DF_1_DIRECT
)
9784 if (val
& DF_1_TRANS
)
9789 if (val
& DF_1_INTERPOSE
)
9791 printf (" INTERPOSE");
9792 val
^= DF_1_INTERPOSE
;
9794 if (val
& DF_1_NODEFLIB
)
9796 printf (" NODEFLIB");
9797 val
^= DF_1_NODEFLIB
;
9799 if (val
& DF_1_NODUMP
)
9804 if (val
& DF_1_CONFALT
)
9806 printf (" CONFALT");
9807 val
^= DF_1_CONFALT
;
9809 if (val
& DF_1_ENDFILTEE
)
9811 printf (" ENDFILTEE");
9812 val
^= DF_1_ENDFILTEE
;
9814 if (val
& DF_1_DISPRELDNE
)
9816 printf (" DISPRELDNE");
9817 val
^= DF_1_DISPRELDNE
;
9819 if (val
& DF_1_DISPRELPND
)
9821 printf (" DISPRELPND");
9822 val
^= DF_1_DISPRELPND
;
9824 if (val
& DF_1_NODIRECT
)
9826 printf (" NODIRECT");
9827 val
^= DF_1_NODIRECT
;
9829 if (val
& DF_1_IGNMULDEF
)
9831 printf (" IGNMULDEF");
9832 val
^= DF_1_IGNMULDEF
;
9834 if (val
& DF_1_NOKSYMS
)
9836 printf (" NOKSYMS");
9837 val
^= DF_1_NOKSYMS
;
9839 if (val
& DF_1_NOHDR
)
9844 if (val
& DF_1_EDITED
)
9849 if (val
& DF_1_NORELOC
)
9851 printf (" NORELOC");
9852 val
^= DF_1_NORELOC
;
9854 if (val
& DF_1_SYMINTPOSE
)
9856 printf (" SYMINTPOSE");
9857 val
^= DF_1_SYMINTPOSE
;
9859 if (val
& DF_1_GLOBAUDIT
)
9861 printf (" GLOBAUDIT");
9862 val
^= DF_1_GLOBAUDIT
;
9864 if (val
& DF_1_SINGLETON
)
9866 printf (" SINGLETON");
9867 val
^= DF_1_SINGLETON
;
9869 if (val
& DF_1_STUB
)
9880 printf (" %lx", val
);
9887 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9889 puts (get_dynamic_type (entry
->d_un
.d_val
));
9909 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9915 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9916 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9922 switch (entry
->d_tag
)
9925 printf (_("Shared library: [%s]"), name
);
9927 if (streq (name
, program_interpreter
))
9928 printf (_(" program interpreter"));
9932 printf (_("Library soname: [%s]"), name
);
9936 printf (_("Library rpath: [%s]"), name
);
9940 printf (_("Library runpath: [%s]"), name
);
9944 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9949 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9962 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9967 case DT_INIT_ARRAYSZ
:
9968 case DT_FINI_ARRAYSZ
:
9969 case DT_GNU_CONFLICTSZ
:
9970 case DT_GNU_LIBLISTSZ
:
9973 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9974 printf (_(" (bytes)\n"));
9984 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9997 if (entry
->d_tag
== DT_USED
9998 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10000 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10004 printf (_("Not needed object: [%s]\n"), name
);
10009 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10015 /* The value of this entry is ignored. */
10020 case DT_GNU_PRELINKED
:
10024 time_t atime
= entry
->d_un
.d_val
;
10026 tmp
= gmtime (&atime
);
10027 /* PR 17533 file: 041-1244816-0.004. */
10029 printf (_("<corrupt time val: %lx"),
10030 (unsigned long) atime
);
10032 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10033 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10034 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10040 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10043 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10049 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10050 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10055 switch (elf_header
.e_machine
)
10058 case EM_MIPS_RS3_LE
:
10059 dynamic_section_mips_val (entry
);
10062 dynamic_section_parisc_val (entry
);
10065 dynamic_section_ia64_val (entry
);
10068 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10080 get_ver_flags (unsigned int flags
)
10082 static char buff
[32];
10089 if (flags
& VER_FLG_BASE
)
10090 strcat (buff
, "BASE");
10092 if (flags
& VER_FLG_WEAK
)
10094 if (flags
& VER_FLG_BASE
)
10095 strcat (buff
, " | ");
10097 strcat (buff
, "WEAK");
10100 if (flags
& VER_FLG_INFO
)
10102 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10103 strcat (buff
, " | ");
10105 strcat (buff
, "INFO");
10108 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10110 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10111 strcat (buff
, " | ");
10113 strcat (buff
, _("<unknown>"));
10119 /* Display the contents of the version sections. */
10122 process_version_sections (FILE * file
)
10124 Elf_Internal_Shdr
* section
;
10126 bfd_boolean found
= FALSE
;
10131 for (i
= 0, section
= section_headers
;
10132 i
< elf_header
.e_shnum
;
10135 switch (section
->sh_type
)
10137 case SHT_GNU_verdef
:
10139 Elf_External_Verdef
* edefs
;
10147 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10148 printable_section_name (section
),
10151 printf (_(" Addr: 0x"));
10152 printf_vma (section
->sh_addr
);
10153 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10154 (unsigned long) section
->sh_offset
, section
->sh_link
,
10155 printable_section_name_from_index (section
->sh_link
));
10157 edefs
= (Elf_External_Verdef
*)
10158 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10159 _("version definition section"));
10162 endbuf
= (char *) edefs
+ section
->sh_size
;
10164 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10165 end
= (section
->sh_info
< section
->sh_size
10166 ? section
->sh_info
: section
->sh_size
);
10167 for (idx
= cnt
= 0; cnt
< end
; ++cnt
)
10170 Elf_External_Verdef
* edef
;
10171 Elf_Internal_Verdef ent
;
10172 Elf_External_Verdaux
* eaux
;
10173 Elf_Internal_Verdaux aux
;
10177 /* Check for very large indices. */
10178 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10181 vstart
= ((char *) edefs
) + idx
;
10182 if (vstart
+ sizeof (*edef
) > endbuf
)
10185 edef
= (Elf_External_Verdef
*) vstart
;
10187 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10188 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10189 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10190 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10191 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10192 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10193 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10195 printf (_(" %#06x: Rev: %d Flags: %s"),
10196 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10198 printf (_(" Index: %d Cnt: %d "),
10199 ent
.vd_ndx
, ent
.vd_cnt
);
10201 /* Check for overflow and underflow. */
10202 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
)
10203 || (vstart
+ ent
.vd_aux
< vstart
))
10206 vstart
+= ent
.vd_aux
;
10208 eaux
= (Elf_External_Verdaux
*) vstart
;
10210 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10211 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10213 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10214 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10216 printf (_("Name index: %ld\n"), aux
.vda_name
);
10218 isum
= idx
+ ent
.vd_aux
;
10220 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10222 /* Check for overflow. */
10223 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10226 isum
+= aux
.vda_next
;
10227 vstart
+= aux
.vda_next
;
10229 eaux
= (Elf_External_Verdaux
*) vstart
;
10230 if (vstart
+ sizeof (*eaux
) > endbuf
)
10233 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10234 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10236 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10237 printf (_(" %#06x: Parent %d: %s\n"),
10238 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10240 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10241 isum
, j
, aux
.vda_name
);
10244 if (j
< ent
.vd_cnt
)
10245 printf (_(" Version def aux past end of section\n"));
10248 file: id:000001,src:000172+005151,op:splice,rep:2. */
10249 if (idx
+ ent
.vd_next
< idx
)
10252 idx
+= ent
.vd_next
;
10255 if (cnt
< section
->sh_info
)
10256 printf (_(" Version definition past end of section\n"));
10262 case SHT_GNU_verneed
:
10264 Elf_External_Verneed
* eneed
;
10271 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10272 printable_section_name (section
), section
->sh_info
);
10274 printf (_(" Addr: 0x"));
10275 printf_vma (section
->sh_addr
);
10276 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10277 (unsigned long) section
->sh_offset
, section
->sh_link
,
10278 printable_section_name_from_index (section
->sh_link
));
10280 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10281 section
->sh_offset
, 1,
10283 _("Version Needs section"));
10286 endbuf
= (char *) eneed
+ section
->sh_size
;
10288 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10290 Elf_External_Verneed
* entry
;
10291 Elf_Internal_Verneed ent
;
10296 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10299 vstart
= ((char *) eneed
) + idx
;
10300 if (vstart
+ sizeof (*entry
) > endbuf
)
10303 entry
= (Elf_External_Verneed
*) vstart
;
10305 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10306 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10307 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10308 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10309 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10311 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10313 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10314 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10316 printf (_(" File: %lx"), ent
.vn_file
);
10318 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10320 /* Check for overflow. */
10321 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10323 vstart
+= ent
.vn_aux
;
10325 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10327 Elf_External_Vernaux
* eaux
;
10328 Elf_Internal_Vernaux aux
;
10330 if (vstart
+ sizeof (*eaux
) > endbuf
)
10332 eaux
= (Elf_External_Vernaux
*) vstart
;
10334 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10335 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10336 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10337 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10338 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10340 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10341 printf (_(" %#06x: Name: %s"),
10342 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10344 printf (_(" %#06x: Name index: %lx"),
10345 isum
, aux
.vna_name
);
10347 printf (_(" Flags: %s Version: %d\n"),
10348 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10350 /* Check for overflow. */
10351 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10352 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10354 warn (_("Invalid vna_next field of %lx\n"),
10359 isum
+= aux
.vna_next
;
10360 vstart
+= aux
.vna_next
;
10363 if (j
< ent
.vn_cnt
)
10364 warn (_("Missing Version Needs auxillary information\n"));
10366 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10368 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10369 cnt
= section
->sh_info
;
10372 idx
+= ent
.vn_next
;
10375 if (cnt
< section
->sh_info
)
10376 warn (_("Missing Version Needs information\n"));
10382 case SHT_GNU_versym
:
10384 Elf_Internal_Shdr
* link_section
;
10387 unsigned char * edata
;
10388 unsigned short * data
;
10390 Elf_Internal_Sym
* symbols
;
10391 Elf_Internal_Shdr
* string_sec
;
10392 unsigned long num_syms
;
10395 if (section
->sh_link
>= elf_header
.e_shnum
)
10398 link_section
= section_headers
+ section
->sh_link
;
10399 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10401 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10406 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10407 if (symbols
== NULL
)
10410 string_sec
= section_headers
+ link_section
->sh_link
;
10412 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10413 string_sec
->sh_size
,
10414 _("version string table"));
10421 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10422 printable_section_name (section
), (unsigned long) total
);
10424 printf (_(" Addr: "));
10425 printf_vma (section
->sh_addr
);
10426 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10427 (unsigned long) section
->sh_offset
, section
->sh_link
,
10428 printable_section_name (link_section
));
10430 off
= offset_from_vma (file
,
10431 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10432 total
* sizeof (short));
10433 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10435 _("version symbol data"));
10443 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10445 for (cnt
= total
; cnt
--;)
10446 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10451 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10455 char *invalid
= _("*invalid*");
10457 printf (" %03x:", cnt
);
10459 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10460 switch (data
[cnt
+ j
])
10463 fputs (_(" 0 (*local*) "), stdout
);
10467 fputs (_(" 1 (*global*) "), stdout
);
10471 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10472 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10474 /* If this index value is greater than the size of the symbols
10475 array, break to avoid an out-of-bounds read. */
10476 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10478 warn (_("invalid index into symbol array\n"));
10483 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10485 Elf_Internal_Verneed ivn
;
10486 unsigned long offset
;
10488 offset
= offset_from_vma
10489 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10490 sizeof (Elf_External_Verneed
));
10494 Elf_Internal_Vernaux ivna
;
10495 Elf_External_Verneed evn
;
10496 Elf_External_Vernaux evna
;
10497 unsigned long a_off
;
10499 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10500 _("version need")) == NULL
)
10503 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10504 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10506 a_off
= offset
+ ivn
.vn_aux
;
10510 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10511 1, _("version need aux (2)")) == NULL
)
10514 ivna
.vna_other
= 0;
10518 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10519 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10522 a_off
+= ivna
.vna_next
;
10524 while (ivna
.vna_other
!= data
[cnt
+ j
]
10525 && ivna
.vna_next
!= 0);
10527 if (ivna
.vna_other
== data
[cnt
+ j
])
10529 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10531 if (ivna
.vna_name
>= string_sec
->sh_size
)
10534 name
= strtab
+ ivna
.vna_name
;
10538 offset
+= ivn
.vn_next
;
10540 while (ivn
.vn_next
);
10543 if (data
[cnt
+ j
] != 0x8001
10544 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10546 Elf_Internal_Verdef ivd
;
10547 Elf_External_Verdef evd
;
10548 unsigned long offset
;
10550 offset
= offset_from_vma
10551 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10556 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10557 _("version def")) == NULL
)
10560 /* PR 17531: file: 046-1082287-0.004. */
10561 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10566 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10567 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10570 offset
+= ivd
.vd_next
;
10572 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10573 && ivd
.vd_next
!= 0);
10575 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10577 Elf_External_Verdaux evda
;
10578 Elf_Internal_Verdaux ivda
;
10580 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10582 if (get_data (&evda
, file
,
10583 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10585 _("version def aux")) == NULL
)
10588 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10590 if (ivda
.vda_name
>= string_sec
->sh_size
)
10592 else if (name
!= NULL
&& name
!= invalid
)
10593 name
= _("*both*");
10595 name
= strtab
+ ivda
.vda_name
;
10599 nn
+= printf ("(%s%-*s",
10601 12 - (int) strlen (name
),
10605 printf ("%*c", 18 - nn
, ' ');
10623 printf (_("\nNo version information found in this file.\n"));
10628 static const char *
10629 get_symbol_binding (unsigned int binding
)
10631 static char buff
[32];
10635 case STB_LOCAL
: return "LOCAL";
10636 case STB_GLOBAL
: return "GLOBAL";
10637 case STB_WEAK
: return "WEAK";
10639 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10640 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10642 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10644 if (binding
== STB_GNU_UNIQUE
10645 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10646 /* GNU is still using the default value 0. */
10647 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10649 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10652 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10657 static const char *
10658 get_symbol_type (unsigned int type
)
10660 static char buff
[32];
10664 case STT_NOTYPE
: return "NOTYPE";
10665 case STT_OBJECT
: return "OBJECT";
10666 case STT_FUNC
: return "FUNC";
10667 case STT_SECTION
: return "SECTION";
10668 case STT_FILE
: return "FILE";
10669 case STT_COMMON
: return "COMMON";
10670 case STT_TLS
: return "TLS";
10671 case STT_RELC
: return "RELC";
10672 case STT_SRELC
: return "SRELC";
10674 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10676 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10677 return "THUMB_FUNC";
10679 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10682 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10683 return "PARISC_MILLI";
10685 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10687 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10689 if (elf_header
.e_machine
== EM_PARISC
)
10691 if (type
== STT_HP_OPAQUE
)
10692 return "HP_OPAQUE";
10693 if (type
== STT_HP_STUB
)
10697 if (type
== STT_GNU_IFUNC
10698 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10699 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10700 /* GNU is still using the default value 0. */
10701 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10704 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10707 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10712 static const char *
10713 get_symbol_visibility (unsigned int visibility
)
10715 switch (visibility
)
10717 case STV_DEFAULT
: return "DEFAULT";
10718 case STV_INTERNAL
: return "INTERNAL";
10719 case STV_HIDDEN
: return "HIDDEN";
10720 case STV_PROTECTED
: return "PROTECTED";
10722 error (_("Unrecognized visibility value: %u"), visibility
);
10723 return _("<unknown>");
10727 static const char *
10728 get_solaris_symbol_visibility (unsigned int visibility
)
10730 switch (visibility
)
10732 case 4: return "EXPORTED";
10733 case 5: return "SINGLETON";
10734 case 6: return "ELIMINATE";
10735 default: return get_symbol_visibility (visibility
);
10739 static const char *
10740 get_mips_symbol_other (unsigned int other
)
10744 case STO_OPTIONAL
: return "OPTIONAL";
10745 case STO_MIPS_PLT
: return "MIPS PLT";
10746 case STO_MIPS_PIC
: return "MIPS PIC";
10747 case STO_MICROMIPS
: return "MICROMIPS";
10748 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10749 case STO_MIPS16
: return "MIPS16";
10750 default: return NULL
;
10754 static const char *
10755 get_ia64_symbol_other (unsigned int other
)
10757 if (is_ia64_vms ())
10759 static char res
[32];
10763 /* Function types is for images and .STB files only. */
10764 switch (elf_header
.e_type
)
10768 switch (VMS_ST_FUNC_TYPE (other
))
10770 case VMS_SFT_CODE_ADDR
:
10771 strcat (res
, " CA");
10773 case VMS_SFT_SYMV_IDX
:
10774 strcat (res
, " VEC");
10777 strcat (res
, " FD");
10779 case VMS_SFT_RESERVE
:
10780 strcat (res
, " RSV");
10783 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10784 VMS_ST_FUNC_TYPE (other
));
10785 strcat (res
, " <unknown>");
10792 switch (VMS_ST_LINKAGE (other
))
10794 case VMS_STL_IGNORE
:
10795 strcat (res
, " IGN");
10797 case VMS_STL_RESERVE
:
10798 strcat (res
, " RSV");
10801 strcat (res
, " STD");
10804 strcat (res
, " LNK");
10807 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10808 VMS_ST_LINKAGE (other
));
10809 strcat (res
, " <unknown>");
10821 static const char *
10822 get_ppc64_symbol_other (unsigned int other
)
10824 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10826 static char buf
[32];
10827 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10828 PPC64_LOCAL_ENTRY_OFFSET (other
));
10834 static const char *
10835 get_symbol_other (unsigned int other
)
10837 const char * result
= NULL
;
10838 static char buff
[32];
10843 switch (elf_header
.e_machine
)
10846 result
= get_mips_symbol_other (other
);
10849 result
= get_ia64_symbol_other (other
);
10852 result
= get_ppc64_symbol_other (other
);
10862 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10866 static const char *
10867 get_symbol_index_type (unsigned int type
)
10869 static char buff
[32];
10873 case SHN_UNDEF
: return "UND";
10874 case SHN_ABS
: return "ABS";
10875 case SHN_COMMON
: return "COM";
10877 if (type
== SHN_IA_64_ANSI_COMMON
10878 && elf_header
.e_machine
== EM_IA_64
10879 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10881 else if ((elf_header
.e_machine
== EM_X86_64
10882 || elf_header
.e_machine
== EM_L1OM
10883 || elf_header
.e_machine
== EM_K1OM
)
10884 && type
== SHN_X86_64_LCOMMON
)
10885 return "LARGE_COM";
10886 else if ((type
== SHN_MIPS_SCOMMON
10887 && elf_header
.e_machine
== EM_MIPS
)
10888 || (type
== SHN_TIC6X_SCOMMON
10889 && elf_header
.e_machine
== EM_TI_C6000
))
10891 else if (type
== SHN_MIPS_SUNDEFINED
10892 && elf_header
.e_machine
== EM_MIPS
)
10894 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10895 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10896 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10897 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10898 else if (type
>= SHN_LORESERVE
)
10899 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10900 else if (type
>= elf_header
.e_shnum
)
10901 sprintf (buff
, _("bad section index[%3d]"), type
);
10903 sprintf (buff
, "%3d", type
);
10911 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10913 unsigned char * e_data
;
10916 /* If the size_t type is smaller than the bfd_size_type, eg because
10917 you are building a 32-bit tool on a 64-bit host, then make sure
10918 that when (number) is cast to (size_t) no information is lost. */
10919 if (sizeof (size_t) < sizeof (bfd_size_type
)
10920 && (bfd_size_type
) ((size_t) number
) != number
)
10922 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10923 " elements of size %u\n"),
10928 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10929 attempting to allocate memory when the read is bound to fail. */
10930 if (ent_size
* number
> current_file_size
)
10932 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10937 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10938 if (e_data
== NULL
)
10940 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10945 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10947 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10948 number
* ent_size
);
10953 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10954 if (i_data
== NULL
)
10956 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10957 " dynamic entries\n"),
10964 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10972 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10974 Elf_Internal_Sym
* psym
;
10977 n
= print_vma (si
, DEC_5
);
10979 fputs (&" "[n
], stdout
);
10980 printf (" %3lu: ", hn
);
10982 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10984 printf (_("<No info available for dynamic symbol number %lu>\n"),
10985 (unsigned long) si
);
10989 psym
= dynamic_symbols
+ si
;
10990 print_vma (psym
->st_value
, LONG_HEX
);
10992 print_vma (psym
->st_size
, DEC_5
);
10994 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10995 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10997 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10998 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11001 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11003 printf (" %-7s", get_symbol_visibility (vis
));
11004 /* Check to see if any other bits in the st_other field are set.
11005 Note - displaying this information disrupts the layout of the
11006 table being generated, but for the moment this case is very
11008 if (psym
->st_other
^ vis
)
11009 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11012 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
11013 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11014 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11016 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11020 static const char *
11021 get_symbol_version_string (FILE * file
,
11022 bfd_boolean is_dynsym
,
11023 const char * strtab
,
11024 unsigned long int strtab_size
,
11026 Elf_Internal_Sym
* psym
,
11027 enum versioned_symbol_info
* sym_info
,
11028 unsigned short * vna_other
)
11030 unsigned char data
[2];
11031 unsigned short vers_data
;
11032 unsigned long offset
;
11035 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11038 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11039 sizeof data
+ si
* sizeof (vers_data
));
11041 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
11042 sizeof (data
), 1, _("version data")) == NULL
)
11045 vers_data
= byte_get (data
, 2);
11047 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11050 /* Usually we'd only see verdef for defined symbols, and verneed for
11051 undefined symbols. However, symbols defined by the linker in
11052 .dynbss for variables copied from a shared library in order to
11053 avoid text relocations are defined yet have verneed. We could
11054 use a heuristic to detect the special case, for example, check
11055 for verneed first on symbols defined in SHT_NOBITS sections, but
11056 it is simpler and more reliable to just look for both verdef and
11057 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11059 if (psym
->st_shndx
!= SHN_UNDEF
11060 && vers_data
!= 0x8001
11061 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11063 Elf_Internal_Verdef ivd
;
11064 Elf_Internal_Verdaux ivda
;
11065 Elf_External_Verdaux evda
;
11068 off
= offset_from_vma (file
,
11069 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11070 sizeof (Elf_External_Verdef
));
11074 Elf_External_Verdef evd
;
11076 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11077 _("version def")) == NULL
)
11085 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11086 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11087 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11090 off
+= ivd
.vd_next
;
11092 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11094 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11096 off
-= ivd
.vd_next
;
11099 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11100 _("version def aux")) != NULL
)
11102 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11104 if (psym
->st_name
!= ivda
.vda_name
)
11106 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11107 ? symbol_hidden
: symbol_public
);
11108 return (ivda
.vda_name
< strtab_size
11109 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11115 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11117 Elf_External_Verneed evn
;
11118 Elf_Internal_Verneed ivn
;
11119 Elf_Internal_Vernaux ivna
;
11121 offset
= offset_from_vma (file
,
11122 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11126 unsigned long vna_off
;
11128 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11129 _("version need")) == NULL
)
11132 ivna
.vna_other
= 0;
11137 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11138 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11140 vna_off
= offset
+ ivn
.vn_aux
;
11144 Elf_External_Vernaux evna
;
11146 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11147 _("version need aux (3)")) == NULL
)
11150 ivna
.vna_other
= 0;
11155 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11156 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11157 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11160 vna_off
+= ivna
.vna_next
;
11162 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11164 if (ivna
.vna_other
== vers_data
)
11167 offset
+= ivn
.vn_next
;
11169 while (ivn
.vn_next
!= 0);
11171 if (ivna
.vna_other
== vers_data
)
11173 *sym_info
= symbol_undefined
;
11174 *vna_other
= ivna
.vna_other
;
11175 return (ivna
.vna_name
< strtab_size
11176 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11182 /* Dump the symbol table. */
11184 process_symbol_table (FILE * file
)
11186 Elf_Internal_Shdr
* section
;
11187 bfd_size_type nbuckets
= 0;
11188 bfd_size_type nchains
= 0;
11189 bfd_vma
* buckets
= NULL
;
11190 bfd_vma
* chains
= NULL
;
11191 bfd_vma ngnubuckets
= 0;
11192 bfd_vma
* gnubuckets
= NULL
;
11193 bfd_vma
* gnuchains
= NULL
;
11194 bfd_vma gnusymidx
= 0;
11195 bfd_size_type ngnuchains
= 0;
11197 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11200 if (dynamic_info
[DT_HASH
]
11202 || (do_using_dynamic
11204 && dynamic_strings
!= NULL
)))
11206 unsigned char nb
[8];
11207 unsigned char nc
[8];
11208 unsigned int hash_ent_size
= 4;
11210 if ((elf_header
.e_machine
== EM_ALPHA
11211 || elf_header
.e_machine
== EM_S390
11212 || elf_header
.e_machine
== EM_S390_OLD
)
11213 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11217 (archive_file_offset
11218 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11219 sizeof nb
+ sizeof nc
)),
11222 error (_("Unable to seek to start of dynamic information\n"));
11226 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11228 error (_("Failed to read in number of buckets\n"));
11232 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11234 error (_("Failed to read in number of chains\n"));
11238 nbuckets
= byte_get (nb
, hash_ent_size
);
11239 nchains
= byte_get (nc
, hash_ent_size
);
11241 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11242 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11245 if (buckets
== NULL
|| chains
== NULL
)
11247 if (do_using_dynamic
)
11258 if (dynamic_info_DT_GNU_HASH
11260 || (do_using_dynamic
11262 && dynamic_strings
!= NULL
)))
11264 unsigned char nb
[16];
11265 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11266 bfd_vma buckets_vma
;
11269 (archive_file_offset
11270 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11274 error (_("Unable to seek to start of dynamic information\n"));
11278 if (fread (nb
, 16, 1, file
) != 1)
11280 error (_("Failed to read in number of buckets\n"));
11284 ngnubuckets
= byte_get (nb
, 4);
11285 gnusymidx
= byte_get (nb
+ 4, 4);
11286 bitmaskwords
= byte_get (nb
+ 8, 4);
11287 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11289 buckets_vma
+= bitmaskwords
* 4;
11291 buckets_vma
+= bitmaskwords
* 8;
11294 (archive_file_offset
11295 + offset_from_vma (file
, buckets_vma
, 4)),
11298 error (_("Unable to seek to start of dynamic information\n"));
11302 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11304 if (gnubuckets
== NULL
)
11307 for (i
= 0; i
< ngnubuckets
; i
++)
11308 if (gnubuckets
[i
] != 0)
11310 if (gnubuckets
[i
] < gnusymidx
)
11313 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11314 maxchain
= gnubuckets
[i
];
11317 if (maxchain
== 0xffffffff)
11320 maxchain
-= gnusymidx
;
11323 (archive_file_offset
11324 + offset_from_vma (file
, buckets_vma
11325 + 4 * (ngnubuckets
+ maxchain
), 4)),
11328 error (_("Unable to seek to start of dynamic information\n"));
11334 if (fread (nb
, 4, 1, file
) != 1)
11336 error (_("Failed to determine last chain length\n"));
11340 if (maxchain
+ 1 == 0)
11345 while ((byte_get (nb
, 4) & 1) == 0);
11348 (archive_file_offset
11349 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11352 error (_("Unable to seek to start of dynamic information\n"));
11356 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11357 ngnuchains
= maxchain
;
11360 if (gnuchains
== NULL
)
11365 if (do_using_dynamic
)
11370 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11372 && do_using_dynamic
11373 && dynamic_strings
!= NULL
11374 && dynamic_symbols
!= NULL
)
11378 if (dynamic_info
[DT_HASH
])
11382 printf (_("\nSymbol table for image:\n"));
11384 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11386 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11388 for (hn
= 0; hn
< nbuckets
; hn
++)
11393 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11394 print_dynamic_symbol (si
, hn
);
11398 if (dynamic_info_DT_GNU_HASH
)
11400 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11402 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11404 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11406 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11407 if (gnubuckets
[hn
] != 0)
11409 bfd_vma si
= gnubuckets
[hn
];
11410 bfd_vma off
= si
- gnusymidx
;
11414 print_dynamic_symbol (si
, hn
);
11417 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11421 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11422 && section_headers
!= NULL
)
11426 for (i
= 0, section
= section_headers
;
11427 i
< elf_header
.e_shnum
;
11431 char * strtab
= NULL
;
11432 unsigned long int strtab_size
= 0;
11433 Elf_Internal_Sym
* symtab
;
11434 Elf_Internal_Sym
* psym
;
11435 unsigned long num_syms
;
11437 if ((section
->sh_type
!= SHT_SYMTAB
11438 && section
->sh_type
!= SHT_DYNSYM
)
11440 && section
->sh_type
== SHT_SYMTAB
))
11443 if (section
->sh_entsize
== 0)
11445 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11446 printable_section_name (section
));
11450 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11451 printable_section_name (section
),
11452 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11455 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11457 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11459 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11460 if (symtab
== NULL
)
11463 if (section
->sh_link
== elf_header
.e_shstrndx
)
11465 strtab
= string_table
;
11466 strtab_size
= string_table_length
;
11468 else if (section
->sh_link
< elf_header
.e_shnum
)
11470 Elf_Internal_Shdr
* string_sec
;
11472 string_sec
= section_headers
+ section
->sh_link
;
11474 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11475 1, string_sec
->sh_size
,
11476 _("string table"));
11477 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11480 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11482 const char *version_string
;
11483 enum versioned_symbol_info sym_info
;
11484 unsigned short vna_other
;
11486 printf ("%6d: ", si
);
11487 print_vma (psym
->st_value
, LONG_HEX
);
11489 print_vma (psym
->st_size
, DEC_5
);
11490 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11491 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11492 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11493 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11496 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11498 printf (" %-7s", get_symbol_visibility (vis
));
11499 /* Check to see if any other bits in the st_other field are set.
11500 Note - displaying this information disrupts the layout of the
11501 table being generated, but for the moment this case is very rare. */
11502 if (psym
->st_other
^ vis
)
11503 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11505 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11506 print_symbol (25, psym
->st_name
< strtab_size
11507 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11510 = get_symbol_version_string (file
,
11511 section
->sh_type
== SHT_DYNSYM
,
11512 strtab
, strtab_size
, si
,
11513 psym
, &sym_info
, &vna_other
);
11514 if (version_string
)
11516 if (sym_info
== symbol_undefined
)
11517 printf ("@%s (%d)", version_string
, vna_other
);
11519 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11525 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11526 && si
>= section
->sh_info
11527 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11528 && elf_header
.e_machine
!= EM_MIPS
11529 /* Solaris binaries have been found to violate this requirement as
11530 well. Not sure if this is a bug or an ABI requirement. */
11531 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11532 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11533 si
, printable_section_name (section
), section
->sh_info
);
11537 if (strtab
!= string_table
)
11543 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11545 if (do_histogram
&& buckets
!= NULL
)
11547 unsigned long * lengths
;
11548 unsigned long * counts
;
11551 unsigned long maxlength
= 0;
11552 unsigned long nzero_counts
= 0;
11553 unsigned long nsyms
= 0;
11554 unsigned long chained
;
11556 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11557 (unsigned long) nbuckets
);
11559 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11560 if (lengths
== NULL
)
11562 error (_("Out of memory allocating space for histogram buckets\n"));
11566 printf (_(" Length Number %% of total Coverage\n"));
11567 for (hn
= 0; hn
< nbuckets
; ++hn
)
11569 for (si
= buckets
[hn
], chained
= 0;
11570 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11571 si
= chains
[si
], ++chained
)
11574 if (maxlength
< ++lengths
[hn
])
11578 /* PR binutils/17531: A corrupt binary could contain broken
11579 histogram data. Do not go into an infinite loop trying
11581 if (chained
> nchains
)
11583 error (_("histogram chain is corrupt\n"));
11588 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11589 if (counts
== NULL
)
11592 error (_("Out of memory allocating space for histogram counts\n"));
11596 for (hn
= 0; hn
< nbuckets
; ++hn
)
11597 ++counts
[lengths
[hn
]];
11602 printf (" 0 %-10lu (%5.1f%%)\n",
11603 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11604 for (i
= 1; i
<= maxlength
; ++i
)
11606 nzero_counts
+= counts
[i
] * i
;
11607 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11608 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11609 (nzero_counts
* 100.0) / nsyms
);
11617 if (buckets
!= NULL
)
11623 if (do_histogram
&& gnubuckets
!= NULL
)
11625 unsigned long * lengths
;
11626 unsigned long * counts
;
11628 unsigned long maxlength
= 0;
11629 unsigned long nzero_counts
= 0;
11630 unsigned long nsyms
= 0;
11632 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11633 (unsigned long) ngnubuckets
);
11635 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11636 if (lengths
== NULL
)
11638 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11642 printf (_(" Length Number %% of total Coverage\n"));
11644 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11645 if (gnubuckets
[hn
] != 0)
11647 bfd_vma off
, length
= 1;
11649 for (off
= gnubuckets
[hn
] - gnusymidx
;
11650 /* PR 17531 file: 010-77222-0.004. */
11651 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11654 lengths
[hn
] = length
;
11655 if (length
> maxlength
)
11656 maxlength
= length
;
11660 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11661 if (counts
== NULL
)
11664 error (_("Out of memory allocating space for gnu histogram counts\n"));
11668 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11669 ++counts
[lengths
[hn
]];
11671 if (ngnubuckets
> 0)
11674 printf (" 0 %-10lu (%5.1f%%)\n",
11675 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11676 for (j
= 1; j
<= maxlength
; ++j
)
11678 nzero_counts
+= counts
[j
] * j
;
11679 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11680 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11681 (nzero_counts
* 100.0) / nsyms
);
11695 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11699 if (dynamic_syminfo
== NULL
11701 /* No syminfo, this is ok. */
11704 /* There better should be a dynamic symbol section. */
11705 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11709 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11710 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11712 printf (_(" Num: Name BoundTo Flags\n"));
11713 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11715 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11717 printf ("%4d: ", i
);
11718 if (i
>= num_dynamic_syms
)
11719 printf (_("<corrupt index>"));
11720 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11721 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11723 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11726 switch (dynamic_syminfo
[i
].si_boundto
)
11728 case SYMINFO_BT_SELF
:
11729 fputs ("SELF ", stdout
);
11731 case SYMINFO_BT_PARENT
:
11732 fputs ("PARENT ", stdout
);
11735 if (dynamic_syminfo
[i
].si_boundto
> 0
11736 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11737 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11739 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11743 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11747 if (flags
& SYMINFO_FLG_DIRECT
)
11748 printf (" DIRECT");
11749 if (flags
& SYMINFO_FLG_PASSTHRU
)
11750 printf (" PASSTHRU");
11751 if (flags
& SYMINFO_FLG_COPY
)
11753 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11754 printf (" LAZYLOAD");
11762 #define IN_RANGE(START,END,ADDR,OFF) \
11763 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11765 /* Check to see if the given reloc needs to be handled in a target specific
11766 manner. If so then process the reloc and return TRUE otherwise return
11769 If called with reloc == NULL, then this is a signal that reloc processing
11770 for the current section has finished, and any saved state should be
11774 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11775 unsigned char * start
,
11776 unsigned char * end
,
11777 Elf_Internal_Sym
* symtab
,
11778 unsigned long num_syms
)
11780 unsigned int reloc_type
= 0;
11781 unsigned long sym_index
= 0;
11785 reloc_type
= get_reloc_type (reloc
->r_info
);
11786 sym_index
= get_reloc_symindex (reloc
->r_info
);
11789 switch (elf_header
.e_machine
)
11792 case EM_MSP430_OLD
:
11794 static Elf_Internal_Sym
* saved_sym
= NULL
;
11802 switch (reloc_type
)
11804 case 10: /* R_MSP430_SYM_DIFF */
11805 if (uses_msp430x_relocs ())
11807 /* Fall through. */
11808 case 21: /* R_MSP430X_SYM_DIFF */
11810 if (sym_index
>= num_syms
)
11811 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11814 saved_sym
= symtab
+ sym_index
;
11817 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11818 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11819 goto handle_sym_diff
;
11821 case 5: /* R_MSP430_16_BYTE */
11822 case 9: /* R_MSP430_8 */
11823 if (uses_msp430x_relocs ())
11825 goto handle_sym_diff
;
11827 case 2: /* R_MSP430_ABS16 */
11828 case 15: /* R_MSP430X_ABS16 */
11829 if (! uses_msp430x_relocs ())
11831 goto handle_sym_diff
;
11834 if (saved_sym
!= NULL
)
11836 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11839 if (sym_index
>= num_syms
)
11840 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11844 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11845 - saved_sym
->st_value
);
11847 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11848 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11851 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11852 (long) reloc
->r_offset
);
11861 if (saved_sym
!= NULL
)
11862 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11869 case EM_CYGNUS_MN10300
:
11871 static Elf_Internal_Sym
* saved_sym
= NULL
;
11879 switch (reloc_type
)
11881 case 34: /* R_MN10300_ALIGN */
11883 case 33: /* R_MN10300_SYM_DIFF */
11884 if (sym_index
>= num_syms
)
11885 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11888 saved_sym
= symtab
+ sym_index
;
11891 case 1: /* R_MN10300_32 */
11892 case 2: /* R_MN10300_16 */
11893 if (saved_sym
!= NULL
)
11895 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11898 if (sym_index
>= num_syms
)
11899 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11903 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11904 - saved_sym
->st_value
);
11906 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11907 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11909 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11910 (long) reloc
->r_offset
);
11918 if (saved_sym
!= NULL
)
11919 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11927 static bfd_vma saved_sym1
= 0;
11928 static bfd_vma saved_sym2
= 0;
11929 static bfd_vma value
;
11933 saved_sym1
= saved_sym2
= 0;
11937 switch (reloc_type
)
11939 case 0x80: /* R_RL78_SYM. */
11940 saved_sym1
= saved_sym2
;
11941 if (sym_index
>= num_syms
)
11942 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11946 saved_sym2
= symtab
[sym_index
].st_value
;
11947 saved_sym2
+= reloc
->r_addend
;
11951 case 0x83: /* R_RL78_OPsub. */
11952 value
= saved_sym1
- saved_sym2
;
11953 saved_sym2
= saved_sym1
= 0;
11957 case 0x41: /* R_RL78_ABS32. */
11958 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11959 byte_put (start
+ reloc
->r_offset
, value
, 4);
11961 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11962 (long) reloc
->r_offset
);
11966 case 0x43: /* R_RL78_ABS16. */
11967 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11968 byte_put (start
+ reloc
->r_offset
, value
, 2);
11970 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11971 (long) reloc
->r_offset
);
11985 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11986 DWARF debug sections. This is a target specific test. Note - we do not
11987 go through the whole including-target-headers-multiple-times route, (as
11988 we have already done with <elf/h8.h>) because this would become very
11989 messy and even then this function would have to contain target specific
11990 information (the names of the relocs instead of their numeric values).
11991 FIXME: This is not the correct way to solve this problem. The proper way
11992 is to have target specific reloc sizing and typing functions created by
11993 the reloc-macros.h header, in the same way that it already creates the
11994 reloc naming functions. */
11997 is_32bit_abs_reloc (unsigned int reloc_type
)
11999 /* Please keep this table alpha-sorted for ease of visual lookup. */
12000 switch (elf_header
.e_machine
)
12004 return reloc_type
== 1; /* R_386_32. */
12006 return reloc_type
== 1; /* R_68K_32. */
12008 return reloc_type
== 1; /* R_860_32. */
12010 return reloc_type
== 2; /* R_960_32. */
12012 return (reloc_type
== 258
12013 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12014 case EM_ADAPTEVA_EPIPHANY
:
12015 return reloc_type
== 3;
12017 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12019 return reloc_type
== 1; /* R_ARC_32. */
12020 case EM_ARC_COMPACT
:
12021 case EM_ARC_COMPACT2
:
12022 return reloc_type
== 4; /* R_ARC_32. */
12024 return reloc_type
== 2; /* R_ARM_ABS32 */
12027 return reloc_type
== 1;
12029 return reloc_type
== 0x12; /* R_byte4_data. */
12031 return reloc_type
== 3; /* R_CRIS_32. */
12033 return reloc_type
== 3; /* R_CR16_NUM32. */
12035 return reloc_type
== 15; /* R_CRX_NUM32. */
12036 case EM_CYGNUS_FRV
:
12037 return reloc_type
== 1;
12038 case EM_CYGNUS_D10V
:
12040 return reloc_type
== 6; /* R_D10V_32. */
12041 case EM_CYGNUS_D30V
:
12043 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12045 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12046 case EM_CYGNUS_FR30
:
12048 return reloc_type
== 3; /* R_FR30_32. */
12050 return reloc_type
== 1; /* R_FT32_32. */
12054 return reloc_type
== 1; /* R_H8_DIR32. */
12056 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12057 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
12060 return reloc_type
== 2; /* R_IP2K_32. */
12062 return reloc_type
== 2; /* R_IQ2000_32. */
12063 case EM_LATTICEMICO32
:
12064 return reloc_type
== 3; /* R_LM32_32. */
12067 return reloc_type
== 3; /* R_M32C_32. */
12069 return reloc_type
== 34; /* R_M32R_32_RELA. */
12072 return reloc_type
== 6; /* R_M68HC11_32. */
12074 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12075 case EM_CYGNUS_MEP
:
12076 return reloc_type
== 4; /* R_MEP_32. */
12078 return reloc_type
== 2; /* R_METAG_ADDR32. */
12079 case EM_MICROBLAZE
:
12080 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12082 return reloc_type
== 2; /* R_MIPS_32. */
12084 return reloc_type
== 4; /* R_MMIX_32. */
12085 case EM_CYGNUS_MN10200
:
12087 return reloc_type
== 1; /* R_MN10200_32. */
12088 case EM_CYGNUS_MN10300
:
12090 return reloc_type
== 1; /* R_MN10300_32. */
12092 return reloc_type
== 1; /* R_MOXIE_32. */
12093 case EM_MSP430_OLD
:
12095 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12097 return reloc_type
== 2; /* R_MT_32. */
12099 return reloc_type
== 20; /* R_NDS32_RELA. */
12100 case EM_ALTERA_NIOS2
:
12101 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12103 return reloc_type
== 1; /* R_NIOS_32. */
12105 return reloc_type
== 1; /* R_OR1K_32. */
12107 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12108 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12111 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12113 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12115 return reloc_type
== 1; /* R_PPC_ADDR32. */
12117 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12119 return reloc_type
== 1; /* R_RISCV_32. */
12121 return reloc_type
== 1; /* R_RL78_DIR32. */
12123 return reloc_type
== 1; /* R_RX_DIR32. */
12125 return reloc_type
== 1; /* R_I370_ADDR31. */
12128 return reloc_type
== 4; /* R_S390_32. */
12130 return reloc_type
== 8; /* R_SCORE_ABS32. */
12132 return reloc_type
== 1; /* R_SH_DIR32. */
12133 case EM_SPARC32PLUS
:
12136 return reloc_type
== 3 /* R_SPARC_32. */
12137 || reloc_type
== 23; /* R_SPARC_UA32. */
12139 return reloc_type
== 6; /* R_SPU_ADDR32 */
12141 return reloc_type
== 1; /* R_C6000_ABS32. */
12143 return reloc_type
== 2; /* R_TILEGX_32. */
12145 return reloc_type
== 1; /* R_TILEPRO_32. */
12146 case EM_CYGNUS_V850
:
12148 return reloc_type
== 6; /* R_V850_ABS32. */
12150 return reloc_type
== 0x33; /* R_V810_WORD. */
12152 return reloc_type
== 1; /* R_VAX_32. */
12154 return reloc_type
== 3; /* R_VISIUM_32. */
12155 case EM_WEBASSEMBLY
:
12156 return reloc_type
== 1; /* R_WASM32_32. */
12160 return reloc_type
== 10; /* R_X86_64_32. */
12163 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12165 return reloc_type
== 4; /* R_XGATE_32. */
12167 return reloc_type
== 1; /* R_XSTROMY16_32. */
12168 case EM_XTENSA_OLD
:
12170 return reloc_type
== 1; /* R_XTENSA_32. */
12173 static unsigned int prev_warn
= 0;
12175 /* Avoid repeating the same warning multiple times. */
12176 if (prev_warn
!= elf_header
.e_machine
)
12177 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12178 elf_header
.e_machine
);
12179 prev_warn
= elf_header
.e_machine
;
12185 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12186 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12189 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12191 switch (elf_header
.e_machine
)
12192 /* Please keep this table alpha-sorted for ease of visual lookup. */
12196 return reloc_type
== 2; /* R_386_PC32. */
12198 return reloc_type
== 4; /* R_68K_PC32. */
12200 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12201 case EM_ADAPTEVA_EPIPHANY
:
12202 return reloc_type
== 6;
12204 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12205 case EM_ARC_COMPACT
:
12206 case EM_ARC_COMPACT2
:
12207 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12209 return reloc_type
== 3; /* R_ARM_REL32 */
12212 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12213 case EM_MICROBLAZE
:
12214 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12216 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12218 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12220 return reloc_type
== 26; /* R_PPC_REL32. */
12222 return reloc_type
== 26; /* R_PPC64_REL32. */
12225 return reloc_type
== 5; /* R_390_PC32. */
12227 return reloc_type
== 2; /* R_SH_REL32. */
12228 case EM_SPARC32PLUS
:
12231 return reloc_type
== 6; /* R_SPARC_DISP32. */
12233 return reloc_type
== 13; /* R_SPU_REL32. */
12235 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12237 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12239 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12243 return reloc_type
== 2; /* R_X86_64_PC32. */
12244 case EM_XTENSA_OLD
:
12246 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12248 /* Do not abort or issue an error message here. Not all targets use
12249 pc-relative 32-bit relocs in their DWARF debug information and we
12250 have already tested for target coverage in is_32bit_abs_reloc. A
12251 more helpful warning message will be generated by apply_relocations
12252 anyway, so just return. */
12257 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12258 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12261 is_64bit_abs_reloc (unsigned int reloc_type
)
12263 switch (elf_header
.e_machine
)
12266 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12268 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12270 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12272 return reloc_type
== 80; /* R_PARISC_DIR64. */
12274 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12276 return reloc_type
== 2; /* R_RISCV_64. */
12277 case EM_SPARC32PLUS
:
12280 return reloc_type
== 54; /* R_SPARC_UA64. */
12284 return reloc_type
== 1; /* R_X86_64_64. */
12287 return reloc_type
== 22; /* R_S390_64. */
12289 return reloc_type
== 1; /* R_TILEGX_64. */
12291 return reloc_type
== 18; /* R_MIPS_64. */
12297 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12298 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12301 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12303 switch (elf_header
.e_machine
)
12306 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12308 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12310 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12312 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12314 return reloc_type
== 44; /* R_PPC64_REL64. */
12315 case EM_SPARC32PLUS
:
12318 return reloc_type
== 46; /* R_SPARC_DISP64. */
12322 return reloc_type
== 24; /* R_X86_64_PC64. */
12325 return reloc_type
== 23; /* R_S390_PC64. */
12327 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12333 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12334 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12337 is_24bit_abs_reloc (unsigned int reloc_type
)
12339 switch (elf_header
.e_machine
)
12341 case EM_CYGNUS_MN10200
:
12343 return reloc_type
== 4; /* R_MN10200_24. */
12345 return reloc_type
== 5; /* R_FT32_20. */
12351 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12352 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12355 is_16bit_abs_reloc (unsigned int reloc_type
)
12357 /* Please keep this table alpha-sorted for ease of visual lookup. */
12358 switch (elf_header
.e_machine
)
12361 case EM_ARC_COMPACT
:
12362 case EM_ARC_COMPACT2
:
12363 return reloc_type
== 2; /* R_ARC_16. */
12364 case EM_ADAPTEVA_EPIPHANY
:
12365 return reloc_type
== 5;
12368 return reloc_type
== 4; /* R_AVR_16. */
12369 case EM_CYGNUS_D10V
:
12371 return reloc_type
== 3; /* R_D10V_16. */
12375 return reloc_type
== R_H8_DIR16
;
12378 return reloc_type
== 1; /* R_IP2K_16. */
12381 return reloc_type
== 1; /* R_M32C_16 */
12382 case EM_CYGNUS_MN10200
:
12384 return reloc_type
== 2; /* R_MN10200_16. */
12385 case EM_CYGNUS_MN10300
:
12387 return reloc_type
== 2; /* R_MN10300_16. */
12389 if (uses_msp430x_relocs ())
12390 return reloc_type
== 2; /* R_MSP430_ABS16. */
12391 /* Fall through. */
12392 case EM_MSP430_OLD
:
12393 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12395 return reloc_type
== 19; /* R_NDS32_RELA. */
12396 case EM_ALTERA_NIOS2
:
12397 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12399 return reloc_type
== 9; /* R_NIOS_16. */
12401 return reloc_type
== 2; /* R_OR1K_16. */
12403 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12405 return reloc_type
== 2; /* R_C6000_ABS16. */
12407 return reloc_type
== 2; /* R_VISIUM_16. */
12410 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12412 return reloc_type
== 3; /* R_XGATE_16. */
12418 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12419 relocation entries (possibly formerly used for SHT_GROUP sections). */
12422 is_none_reloc (unsigned int reloc_type
)
12424 switch (elf_header
.e_machine
)
12426 case EM_386
: /* R_386_NONE. */
12427 case EM_68K
: /* R_68K_NONE. */
12428 case EM_ADAPTEVA_EPIPHANY
:
12429 case EM_ALPHA
: /* R_ALPHA_NONE. */
12430 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12431 case EM_ARC
: /* R_ARC_NONE. */
12432 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12433 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12434 case EM_ARM
: /* R_ARM_NONE. */
12435 case EM_C166
: /* R_XC16X_NONE. */
12436 case EM_CRIS
: /* R_CRIS_NONE. */
12437 case EM_FT32
: /* R_FT32_NONE. */
12438 case EM_IA_64
: /* R_IA64_NONE. */
12439 case EM_K1OM
: /* R_X86_64_NONE. */
12440 case EM_L1OM
: /* R_X86_64_NONE. */
12441 case EM_M32R
: /* R_M32R_NONE. */
12442 case EM_MIPS
: /* R_MIPS_NONE. */
12443 case EM_MN10300
: /* R_MN10300_NONE. */
12444 case EM_MOXIE
: /* R_MOXIE_NONE. */
12445 case EM_NIOS32
: /* R_NIOS_NONE. */
12446 case EM_OR1K
: /* R_OR1K_NONE. */
12447 case EM_PARISC
: /* R_PARISC_NONE. */
12448 case EM_PPC64
: /* R_PPC64_NONE. */
12449 case EM_PPC
: /* R_PPC_NONE. */
12450 case EM_RISCV
: /* R_RISCV_NONE. */
12451 case EM_S390
: /* R_390_NONE. */
12453 case EM_SH
: /* R_SH_NONE. */
12454 case EM_SPARC32PLUS
:
12455 case EM_SPARC
: /* R_SPARC_NONE. */
12457 case EM_TILEGX
: /* R_TILEGX_NONE. */
12458 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12459 case EM_TI_C6000
:/* R_C6000_NONE. */
12460 case EM_X86_64
: /* R_X86_64_NONE. */
12462 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12463 return reloc_type
== 0;
12466 return reloc_type
== 0 || reloc_type
== 256;
12469 return (reloc_type
== 0 /* R_AVR_NONE. */
12470 || reloc_type
== 30 /* R_AVR_DIFF8. */
12471 || reloc_type
== 31 /* R_AVR_DIFF16. */
12472 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12474 return reloc_type
== 3; /* R_METAG_NONE. */
12476 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12477 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12478 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12479 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12480 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12482 return (reloc_type
== 0 /* R_PRU_NONE. */
12483 || reloc_type
== 65 /* R_PRU_DIFF8. */
12484 || reloc_type
== 66 /* R_PRU_DIFF16. */
12485 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12486 case EM_XTENSA_OLD
:
12488 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12489 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12490 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12491 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12496 /* Returns TRUE if there is a relocation against
12497 section NAME at OFFSET bytes. */
12500 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12502 Elf_Internal_Rela
* relocs
;
12503 Elf_Internal_Rela
* rp
;
12505 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12508 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12510 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12511 if (rp
->r_offset
== offset
)
12517 /* Apply relocations to a section.
12518 Returns TRUE upon success, FALSE otherwise.
12519 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12520 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12521 will be set to the number of relocs loaded.
12523 Note: So far support has been added only for those relocations
12524 which can be found in debug sections. FIXME: Add support for
12525 more relocations ? */
12528 apply_relocations (void * file
,
12529 const Elf_Internal_Shdr
* section
,
12530 unsigned char * start
,
12531 bfd_size_type size
,
12532 void ** relocs_return
,
12533 unsigned long * num_relocs_return
)
12535 Elf_Internal_Shdr
* relsec
;
12536 unsigned char * end
= start
+ size
;
12537 bfd_boolean res
= TRUE
;
12539 if (relocs_return
!= NULL
)
12541 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12542 * num_relocs_return
= 0;
12545 if (elf_header
.e_type
!= ET_REL
)
12546 /* No relocs to apply. */
12549 /* Find the reloc section associated with the section. */
12550 for (relsec
= section_headers
;
12551 relsec
< section_headers
+ elf_header
.e_shnum
;
12554 bfd_boolean is_rela
;
12555 unsigned long num_relocs
;
12556 Elf_Internal_Rela
* relocs
;
12557 Elf_Internal_Rela
* rp
;
12558 Elf_Internal_Shdr
* symsec
;
12559 Elf_Internal_Sym
* symtab
;
12560 unsigned long num_syms
;
12561 Elf_Internal_Sym
* sym
;
12563 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12564 || relsec
->sh_info
>= elf_header
.e_shnum
12565 || section_headers
+ relsec
->sh_info
!= section
12566 || relsec
->sh_size
== 0
12567 || relsec
->sh_link
>= elf_header
.e_shnum
)
12570 is_rela
= relsec
->sh_type
== SHT_RELA
;
12574 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12575 relsec
->sh_size
, & relocs
, & num_relocs
))
12580 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12581 relsec
->sh_size
, & relocs
, & num_relocs
))
12585 /* SH uses RELA but uses in place value instead of the addend field. */
12586 if (elf_header
.e_machine
== EM_SH
)
12589 symsec
= section_headers
+ relsec
->sh_link
;
12590 if (symsec
->sh_type
!= SHT_SYMTAB
12591 && symsec
->sh_type
!= SHT_DYNSYM
)
12593 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12595 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12598 unsigned int reloc_type
;
12599 unsigned int reloc_size
;
12600 unsigned char * rloc
;
12601 unsigned long sym_index
;
12603 reloc_type
= get_reloc_type (rp
->r_info
);
12605 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12607 else if (is_none_reloc (reloc_type
))
12609 else if (is_32bit_abs_reloc (reloc_type
)
12610 || is_32bit_pcrel_reloc (reloc_type
))
12612 else if (is_64bit_abs_reloc (reloc_type
)
12613 || is_64bit_pcrel_reloc (reloc_type
))
12615 else if (is_24bit_abs_reloc (reloc_type
))
12617 else if (is_16bit_abs_reloc (reloc_type
))
12621 static unsigned int prev_reloc
= 0;
12622 if (reloc_type
!= prev_reloc
)
12623 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12624 reloc_type
, printable_section_name (section
));
12625 prev_reloc
= reloc_type
;
12630 rloc
= start
+ rp
->r_offset
;
12631 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12633 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12634 (unsigned long) rp
->r_offset
,
12635 printable_section_name (section
));
12640 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12641 if (sym_index
>= num_syms
)
12643 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12644 sym_index
, printable_section_name (section
));
12648 sym
= symtab
+ sym_index
;
12650 /* If the reloc has a symbol associated with it,
12651 make sure that it is of an appropriate type.
12653 Relocations against symbols without type can happen.
12654 Gcc -feliminate-dwarf2-dups may generate symbols
12655 without type for debug info.
12657 Icc generates relocations against function symbols
12658 instead of local labels.
12660 Relocations against object symbols can happen, eg when
12661 referencing a global array. For an example of this see
12662 the _clz.o binary in libgcc.a. */
12664 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12665 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12667 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12668 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12669 (long int)(rp
- relocs
),
12670 printable_section_name (relsec
));
12677 addend
+= rp
->r_addend
;
12678 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12679 partial_inplace. */
12681 || (elf_header
.e_machine
== EM_XTENSA
12682 && reloc_type
== 1)
12683 || ((elf_header
.e_machine
== EM_PJ
12684 || elf_header
.e_machine
== EM_PJ_OLD
)
12685 && reloc_type
== 1)
12686 || ((elf_header
.e_machine
== EM_D30V
12687 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12688 && reloc_type
== 12))
12689 addend
+= byte_get (rloc
, reloc_size
);
12691 if (is_32bit_pcrel_reloc (reloc_type
)
12692 || is_64bit_pcrel_reloc (reloc_type
))
12694 /* On HPPA, all pc-relative relocations are biased by 8. */
12695 if (elf_header
.e_machine
== EM_PARISC
)
12697 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12701 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12705 /* Let the target specific reloc processing code know that
12706 we have finished with these relocs. */
12707 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12711 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12712 * num_relocs_return
= num_relocs
;
12723 #ifdef SUPPORT_DISASSEMBLY
12725 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12727 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12729 /* FIXME: XXX -- to be done --- XXX */
12735 /* Reads in the contents of SECTION from FILE, returning a pointer
12736 to a malloc'ed buffer or NULL if something went wrong. */
12739 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12741 bfd_size_type num_bytes
;
12743 num_bytes
= section
->sh_size
;
12745 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12747 printf (_("\nSection '%s' has no data to dump.\n"),
12748 printable_section_name (section
));
12752 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12753 _("section contents"));
12756 /* Uncompresses a section that was compressed using zlib, in place. */
12759 uncompress_section_contents (unsigned char **buffer
,
12760 dwarf_size_type uncompressed_size
,
12761 dwarf_size_type
*size
)
12763 dwarf_size_type compressed_size
= *size
;
12764 unsigned char * compressed_buffer
= *buffer
;
12765 unsigned char * uncompressed_buffer
;
12769 /* It is possible the section consists of several compressed
12770 buffers concatenated together, so we uncompress in a loop. */
12771 /* PR 18313: The state field in the z_stream structure is supposed
12772 to be invisible to the user (ie us), but some compilers will
12773 still complain about it being used without initialisation. So
12774 we first zero the entire z_stream structure and then set the fields
12776 memset (& strm
, 0, sizeof strm
);
12777 strm
.avail_in
= compressed_size
;
12778 strm
.next_in
= (Bytef
*) compressed_buffer
;
12779 strm
.avail_out
= uncompressed_size
;
12780 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12782 rc
= inflateInit (& strm
);
12783 while (strm
.avail_in
> 0)
12787 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12788 + (uncompressed_size
- strm
.avail_out
));
12789 rc
= inflate (&strm
, Z_FINISH
);
12790 if (rc
!= Z_STREAM_END
)
12792 rc
= inflateReset (& strm
);
12794 rc
= inflateEnd (& strm
);
12796 || strm
.avail_out
!= 0)
12799 *buffer
= uncompressed_buffer
;
12800 *size
= uncompressed_size
;
12804 free (uncompressed_buffer
);
12805 /* Indicate decompression failure. */
12811 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12813 Elf_Internal_Shdr
* relsec
;
12814 bfd_size_type num_bytes
;
12815 unsigned char * data
;
12816 unsigned char * end
;
12817 unsigned char * real_start
;
12818 unsigned char * start
;
12819 bfd_boolean some_strings_shown
;
12821 real_start
= start
= (unsigned char *) get_section_contents (section
,
12825 num_bytes
= section
->sh_size
;
12827 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12829 if (decompress_dumps
)
12831 dwarf_size_type new_size
= num_bytes
;
12832 dwarf_size_type uncompressed_size
= 0;
12834 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12836 Elf_Internal_Chdr chdr
;
12837 unsigned int compression_header_size
12838 = get_compression_header (& chdr
, (unsigned char *) start
,
12841 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12843 warn (_("section '%s' has unsupported compress type: %d\n"),
12844 printable_section_name (section
), chdr
.ch_type
);
12847 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12849 warn (_("compressed section '%s' is corrupted\n"),
12850 printable_section_name (section
));
12853 uncompressed_size
= chdr
.ch_size
;
12854 start
+= compression_header_size
;
12855 new_size
-= compression_header_size
;
12857 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12859 /* Read the zlib header. In this case, it should be "ZLIB"
12860 followed by the uncompressed section size, 8 bytes in
12861 big-endian order. */
12862 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12863 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12864 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12865 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12866 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12867 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12868 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12869 uncompressed_size
+= start
[11];
12874 if (uncompressed_size
)
12876 if (uncompress_section_contents (& start
,
12877 uncompressed_size
, & new_size
))
12878 num_bytes
= new_size
;
12881 error (_("Unable to decompress section %s\n"),
12882 printable_section_name (section
));
12887 start
= real_start
;
12890 /* If the section being dumped has relocations against it the user might
12891 be expecting these relocations to have been applied. Check for this
12892 case and issue a warning message in order to avoid confusion.
12893 FIXME: Maybe we ought to have an option that dumps a section with
12894 relocs applied ? */
12895 for (relsec
= section_headers
;
12896 relsec
< section_headers
+ elf_header
.e_shnum
;
12899 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12900 || relsec
->sh_info
>= elf_header
.e_shnum
12901 || section_headers
+ relsec
->sh_info
!= section
12902 || relsec
->sh_size
== 0
12903 || relsec
->sh_link
>= elf_header
.e_shnum
)
12906 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12911 end
= start
+ num_bytes
;
12912 some_strings_shown
= FALSE
;
12916 while (!ISPRINT (* data
))
12917 if (++ data
>= end
)
12922 size_t maxlen
= end
- data
;
12925 /* PR 11128: Use two separate invocations in order to work
12926 around bugs in the Solaris 8 implementation of printf. */
12927 printf (" [%6tx] ", data
- start
);
12929 printf (" [%6Ix] ", (size_t) (data
- start
));
12933 print_symbol ((int) maxlen
, (const char *) data
);
12935 data
+= strnlen ((const char *) data
, maxlen
);
12939 printf (_("<corrupt>\n"));
12942 some_strings_shown
= TRUE
;
12946 if (! some_strings_shown
)
12947 printf (_(" No strings found in this section."));
12956 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12958 bfd_boolean relocate
)
12960 Elf_Internal_Shdr
* relsec
;
12961 bfd_size_type bytes
;
12962 bfd_size_type section_size
;
12964 unsigned char * data
;
12965 unsigned char * real_start
;
12966 unsigned char * start
;
12968 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12972 section_size
= section
->sh_size
;
12974 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12976 if (decompress_dumps
)
12978 dwarf_size_type new_size
= section_size
;
12979 dwarf_size_type uncompressed_size
= 0;
12981 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12983 Elf_Internal_Chdr chdr
;
12984 unsigned int compression_header_size
12985 = get_compression_header (& chdr
, start
, section_size
);
12987 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12989 warn (_("section '%s' has unsupported compress type: %d\n"),
12990 printable_section_name (section
), chdr
.ch_type
);
12993 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12995 warn (_("compressed section '%s' is corrupted\n"),
12996 printable_section_name (section
));
12999 uncompressed_size
= chdr
.ch_size
;
13000 start
+= compression_header_size
;
13001 new_size
-= compression_header_size
;
13003 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13005 /* Read the zlib header. In this case, it should be "ZLIB"
13006 followed by the uncompressed section size, 8 bytes in
13007 big-endian order. */
13008 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13009 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13010 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13011 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13012 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13013 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13014 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13015 uncompressed_size
+= start
[11];
13020 if (uncompressed_size
)
13022 if (uncompress_section_contents (& start
, uncompressed_size
,
13025 section_size
= new_size
;
13029 error (_("Unable to decompress section %s\n"),
13030 printable_section_name (section
));
13031 /* FIXME: Print the section anyway ? */
13036 start
= real_start
;
13041 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
13046 /* If the section being dumped has relocations against it the user might
13047 be expecting these relocations to have been applied. Check for this
13048 case and issue a warning message in order to avoid confusion.
13049 FIXME: Maybe we ought to have an option that dumps a section with
13050 relocs applied ? */
13051 for (relsec
= section_headers
;
13052 relsec
< section_headers
+ elf_header
.e_shnum
;
13055 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13056 || relsec
->sh_info
>= elf_header
.e_shnum
13057 || section_headers
+ relsec
->sh_info
!= section
13058 || relsec
->sh_size
== 0
13059 || relsec
->sh_link
>= elf_header
.e_shnum
)
13062 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13067 addr
= section
->sh_addr
;
13068 bytes
= section_size
;
13077 lbytes
= (bytes
> 16 ? 16 : bytes
);
13079 printf (" 0x%8.8lx ", (unsigned long) addr
);
13081 for (j
= 0; j
< 16; j
++)
13084 printf ("%2.2x", data
[j
]);
13092 for (j
= 0; j
< lbytes
; j
++)
13095 if (k
>= ' ' && k
< 0x7f)
13115 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13116 const Elf_Internal_Shdr
* sec
, void * file
)
13118 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13121 /* If it is already loaded, do nothing. */
13122 if (section
->start
!= NULL
)
13125 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13126 section
->address
= sec
->sh_addr
;
13127 section
->user_data
= NULL
;
13128 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13130 sec
->sh_size
, buf
);
13131 if (section
->start
== NULL
)
13135 unsigned char *start
= section
->start
;
13136 dwarf_size_type size
= sec
->sh_size
;
13137 dwarf_size_type uncompressed_size
= 0;
13139 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13141 Elf_Internal_Chdr chdr
;
13142 unsigned int compression_header_size
;
13144 if (size
< (is_32bit_elf
13145 ? sizeof (Elf32_External_Chdr
)
13146 : sizeof (Elf64_External_Chdr
)))
13148 warn (_("compressed section %s is too small to contain a compression header"),
13153 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13155 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13157 warn (_("section '%s' has unsupported compress type: %d\n"),
13158 section
->name
, chdr
.ch_type
);
13161 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13163 warn (_("compressed section '%s' is corrupted\n"),
13167 uncompressed_size
= chdr
.ch_size
;
13168 start
+= compression_header_size
;
13169 size
-= compression_header_size
;
13171 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13173 /* Read the zlib header. In this case, it should be "ZLIB"
13174 followed by the uncompressed section size, 8 bytes in
13175 big-endian order. */
13176 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13177 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13178 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13179 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13180 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13181 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13182 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13183 uncompressed_size
+= start
[11];
13188 if (uncompressed_size
)
13190 if (uncompress_section_contents (&start
, uncompressed_size
,
13193 /* Free the compressed buffer, update the section buffer
13194 and the section size if uncompress is successful. */
13195 free (section
->start
);
13196 section
->start
= start
;
13200 error (_("Unable to decompress section %s\n"),
13201 printable_section_name (sec
));
13206 section
->size
= size
;
13209 if (section
->start
== NULL
)
13212 if (debug_displays
[debug
].relocate
)
13214 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13215 & section
->reloc_info
, & section
->num_relocs
))
13220 section
->reloc_info
= NULL
;
13221 section
->num_relocs
= 0;
13227 /* If this is not NULL, load_debug_section will only look for sections
13228 within the list of sections given here. */
13229 static unsigned int * section_subset
= NULL
;
13232 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13234 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13235 Elf_Internal_Shdr
* sec
;
13237 /* Locate the debug section. */
13238 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13240 section
->name
= section
->uncompressed_name
;
13243 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13245 section
->name
= section
->compressed_name
;
13250 /* If we're loading from a subset of sections, and we've loaded
13251 a section matching this name before, it's likely that it's a
13253 if (section_subset
!= NULL
)
13254 free_debug_section (debug
);
13256 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13260 free_debug_section (enum dwarf_section_display_enum debug
)
13262 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13264 if (section
->start
== NULL
)
13267 free ((char *) section
->start
);
13268 section
->start
= NULL
;
13269 section
->address
= 0;
13274 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13276 char * name
= SECTION_NAME (section
);
13277 const char * print_name
= printable_section_name (section
);
13278 bfd_size_type length
;
13279 bfd_boolean result
= TRUE
;
13282 length
= section
->sh_size
;
13285 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13288 if (section
->sh_type
== SHT_NOBITS
)
13290 /* There is no point in dumping the contents of a debugging section
13291 which has the NOBITS type - the bits in the file will be random.
13292 This can happen when a file containing a .eh_frame section is
13293 stripped with the --only-keep-debug command line option. */
13294 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13299 if (const_strneq (name
, ".gnu.linkonce.wi."))
13300 name
= ".debug_info";
13302 /* See if we know how to display the contents of this section. */
13303 for (i
= 0; i
< max
; i
++)
13304 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13305 || (i
== line
&& const_strneq (name
, ".debug_line."))
13306 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13308 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13309 int secondary
= (section
!= find_section (name
));
13312 free_debug_section ((enum dwarf_section_display_enum
) i
);
13314 if (i
== line
&& const_strneq (name
, ".debug_line."))
13316 else if (streq (sec
->uncompressed_name
, name
))
13317 sec
->name
= sec
->uncompressed_name
;
13319 sec
->name
= sec
->compressed_name
;
13320 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13323 /* If this debug section is part of a CU/TU set in a .dwp file,
13324 restrict load_debug_section to the sections in that set. */
13325 section_subset
= find_cu_tu_set (file
, shndx
);
13327 result
&= debug_displays
[i
].display (sec
, file
);
13329 section_subset
= NULL
;
13331 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13332 free_debug_section ((enum dwarf_section_display_enum
) i
);
13340 printf (_("Unrecognized debug section: %s\n"), print_name
);
13347 /* Set DUMP_SECTS for all sections where dumps were requested
13348 based on section name. */
13351 initialise_dumps_byname (void)
13353 struct dump_list_entry
* cur
;
13355 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13358 bfd_boolean any
= FALSE
;
13360 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13361 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13363 request_dump_bynumber (i
, cur
->type
);
13368 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13374 process_section_contents (FILE * file
)
13376 Elf_Internal_Shdr
* section
;
13378 bfd_boolean res
= TRUE
;
13383 initialise_dumps_byname ();
13385 for (i
= 0, section
= section_headers
;
13386 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13389 #ifdef SUPPORT_DISASSEMBLY
13390 if (dump_sects
[i
] & DISASS_DUMP
)
13391 disassemble_section (section
, file
);
13393 if (dump_sects
[i
] & HEX_DUMP
)
13395 if (! dump_section_as_bytes (section
, file
, FALSE
))
13399 if (dump_sects
[i
] & RELOC_DUMP
)
13401 if (! dump_section_as_bytes (section
, file
, TRUE
))
13405 if (dump_sects
[i
] & STRING_DUMP
)
13407 if (! dump_section_as_strings (section
, file
))
13411 if (dump_sects
[i
] & DEBUG_DUMP
)
13413 if (! display_debug_section (i
, section
, file
))
13418 /* Check to see if the user requested a
13419 dump of a section that does not exist. */
13420 while (i
< num_dump_sects
)
13424 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13434 process_mips_fpe_exception (int mask
)
13438 bfd_boolean first
= TRUE
;
13440 if (mask
& OEX_FPU_INEX
)
13441 fputs ("INEX", stdout
), first
= FALSE
;
13442 if (mask
& OEX_FPU_UFLO
)
13443 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13444 if (mask
& OEX_FPU_OFLO
)
13445 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13446 if (mask
& OEX_FPU_DIV0
)
13447 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13448 if (mask
& OEX_FPU_INVAL
)
13449 printf ("%sINVAL", first
? "" : "|");
13452 fputs ("0", stdout
);
13455 /* Display's the value of TAG at location P. If TAG is
13456 greater than 0 it is assumed to be an unknown tag, and
13457 a message is printed to this effect. Otherwise it is
13458 assumed that a message has already been printed.
13460 If the bottom bit of TAG is set it assumed to have a
13461 string value, otherwise it is assumed to have an integer
13464 Returns an updated P pointing to the first unread byte
13465 beyond the end of TAG's value.
13467 Reads at or beyond END will not be made. */
13469 static unsigned char *
13470 display_tag_value (signed int tag
,
13472 const unsigned char * const end
)
13477 printf (" Tag_unknown_%d: ", tag
);
13481 warn (_("<corrupt tag>\n"));
13485 /* PR 17531 file: 027-19978-0.004. */
13486 size_t maxlen
= (end
- p
) - 1;
13491 print_symbol ((int) maxlen
, (const char *) p
);
13492 p
+= strnlen ((char *) p
, maxlen
) + 1;
13496 printf (_("<corrupt string tag>"));
13497 p
= (unsigned char *) end
;
13505 val
= read_uleb128 (p
, &len
, end
);
13507 printf ("%ld (0x%lx)\n", val
, val
);
13514 /* ARC ABI attributes section. */
13516 static unsigned char *
13517 display_arc_attribute (unsigned char * p
,
13518 const unsigned char * const end
)
13524 tag
= read_uleb128 (p
, &len
, end
);
13529 case Tag_ARC_PCS_config
:
13530 val
= read_uleb128 (p
, &len
, end
);
13532 printf (" Tag_ARC_PCS_config: ");
13536 printf (_("Absent/Non standard\n"));
13539 printf (_("Bare metal/mwdt\n"));
13542 printf (_("Bare metal/newlib\n"));
13545 printf (_("Linux/uclibc\n"));
13548 printf (_("Linux/glibc\n"));
13551 printf (_("Unknown\n"));
13556 case Tag_ARC_CPU_base
:
13557 val
= read_uleb128 (p
, &len
, end
);
13559 printf (" Tag_ARC_CPU_base: ");
13564 printf (_("Absent\n"));
13566 case TAG_CPU_ARC6xx
:
13567 printf ("ARC6xx\n");
13569 case TAG_CPU_ARC7xx
:
13570 printf ("ARC7xx\n");
13572 case TAG_CPU_ARCEM
:
13573 printf ("ARCEM\n");
13575 case TAG_CPU_ARCHS
:
13576 printf ("ARCHS\n");
13581 case Tag_ARC_CPU_variation
:
13582 val
= read_uleb128 (p
, &len
, end
);
13584 printf (" Tag_ARC_CPU_variation: ");
13588 if (val
> 0 && val
< 16)
13589 printf ("Core%d\n", val
);
13591 printf ("Unknown\n");
13595 printf (_("Absent\n"));
13600 case Tag_ARC_CPU_name
:
13601 printf (" Tag_ARC_CPU_name: ");
13602 p
= display_tag_value (-1, p
, end
);
13605 case Tag_ARC_ABI_rf16
:
13606 val
= read_uleb128 (p
, &len
, end
);
13608 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
13611 case Tag_ARC_ABI_osver
:
13612 val
= read_uleb128 (p
, &len
, end
);
13614 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
13617 case Tag_ARC_ABI_pic
:
13618 case Tag_ARC_ABI_sda
:
13619 val
= read_uleb128 (p
, &len
, end
);
13621 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
13622 : " Tag_ARC_ABI_pic: ");
13626 printf (_("Absent\n"));
13635 printf (_("Unknown\n"));
13640 case Tag_ARC_ABI_tls
:
13641 val
= read_uleb128 (p
, &len
, end
);
13643 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
13646 case Tag_ARC_ABI_enumsize
:
13647 val
= read_uleb128 (p
, &len
, end
);
13649 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
13653 case Tag_ARC_ABI_exceptions
:
13654 val
= read_uleb128 (p
, &len
, end
);
13656 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
13660 case Tag_ARC_ABI_double_size
:
13661 val
= read_uleb128 (p
, &len
, end
);
13663 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
13666 case Tag_ARC_ISA_config
:
13667 printf (" Tag_ARC_ISA_config: ");
13668 p
= display_tag_value (-1, p
, end
);
13671 case Tag_ARC_ISA_apex
:
13672 printf (" Tag_ARC_ISA_apex: ");
13673 p
= display_tag_value (-1, p
, end
);
13676 case Tag_ARC_ISA_mpy_option
:
13677 val
= read_uleb128 (p
, &len
, end
);
13679 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
13683 return display_tag_value (tag
& 1, p
, end
);
13689 /* ARM EABI attributes section. */
13694 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13696 const char ** table
;
13697 } arm_attr_public_tag
;
13699 static const char * arm_attr_tag_CPU_arch
[] =
13700 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13701 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13703 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13704 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13705 {"No", "Thumb-1", "Thumb-2", "Yes"};
13706 static const char * arm_attr_tag_FP_arch
[] =
13707 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13708 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13709 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13710 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13711 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13712 "NEON for ARMv8.1"};
13713 static const char * arm_attr_tag_PCS_config
[] =
13714 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13715 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13716 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13717 {"V6", "SB", "TLS", "Unused"};
13718 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13719 {"Absolute", "PC-relative", "SB-relative", "None"};
13720 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13721 {"Absolute", "PC-relative", "None"};
13722 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13723 {"None", "direct", "GOT-indirect"};
13724 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13725 {"None", "??? 1", "2", "??? 3", "4"};
13726 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13727 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13728 {"Unused", "Needed", "Sign only"};
13729 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13730 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13731 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13732 {"Unused", "Finite", "RTABI", "IEEE 754"};
13733 static const char * arm_attr_tag_ABI_enum_size
[] =
13734 {"Unused", "small", "int", "forced to int"};
13735 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13736 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13737 static const char * arm_attr_tag_ABI_VFP_args
[] =
13738 {"AAPCS", "VFP registers", "custom", "compatible"};
13739 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13740 {"AAPCS", "WMMX registers", "custom"};
13741 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13742 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13743 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13744 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13745 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13746 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13747 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13748 static const char * arm_attr_tag_FP_HP_extension
[] =
13749 {"Not Allowed", "Allowed"};
13750 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13751 {"None", "IEEE 754", "Alternative Format"};
13752 static const char * arm_attr_tag_DSP_extension
[] =
13753 {"Follow architecture", "Allowed"};
13754 static const char * arm_attr_tag_MPextension_use
[] =
13755 {"Not Allowed", "Allowed"};
13756 static const char * arm_attr_tag_DIV_use
[] =
13757 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13758 "Allowed in v7-A with integer division extension"};
13759 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13760 static const char * arm_attr_tag_Virtualization_use
[] =
13761 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13762 "TrustZone and Virtualization Extensions"};
13763 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13764 {"Not Allowed", "Allowed"};
13766 #define LOOKUP(id, name) \
13767 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13768 static arm_attr_public_tag arm_attr_public_tags
[] =
13770 {4, "CPU_raw_name", 1, NULL
},
13771 {5, "CPU_name", 1, NULL
},
13772 LOOKUP(6, CPU_arch
),
13773 {7, "CPU_arch_profile", 0, NULL
},
13774 LOOKUP(8, ARM_ISA_use
),
13775 LOOKUP(9, THUMB_ISA_use
),
13776 LOOKUP(10, FP_arch
),
13777 LOOKUP(11, WMMX_arch
),
13778 LOOKUP(12, Advanced_SIMD_arch
),
13779 LOOKUP(13, PCS_config
),
13780 LOOKUP(14, ABI_PCS_R9_use
),
13781 LOOKUP(15, ABI_PCS_RW_data
),
13782 LOOKUP(16, ABI_PCS_RO_data
),
13783 LOOKUP(17, ABI_PCS_GOT_use
),
13784 LOOKUP(18, ABI_PCS_wchar_t
),
13785 LOOKUP(19, ABI_FP_rounding
),
13786 LOOKUP(20, ABI_FP_denormal
),
13787 LOOKUP(21, ABI_FP_exceptions
),
13788 LOOKUP(22, ABI_FP_user_exceptions
),
13789 LOOKUP(23, ABI_FP_number_model
),
13790 {24, "ABI_align_needed", 0, NULL
},
13791 {25, "ABI_align_preserved", 0, NULL
},
13792 LOOKUP(26, ABI_enum_size
),
13793 LOOKUP(27, ABI_HardFP_use
),
13794 LOOKUP(28, ABI_VFP_args
),
13795 LOOKUP(29, ABI_WMMX_args
),
13796 LOOKUP(30, ABI_optimization_goals
),
13797 LOOKUP(31, ABI_FP_optimization_goals
),
13798 {32, "compatibility", 0, NULL
},
13799 LOOKUP(34, CPU_unaligned_access
),
13800 LOOKUP(36, FP_HP_extension
),
13801 LOOKUP(38, ABI_FP_16bit_format
),
13802 LOOKUP(42, MPextension_use
),
13803 LOOKUP(44, DIV_use
),
13804 LOOKUP(46, DSP_extension
),
13805 {64, "nodefaults", 0, NULL
},
13806 {65, "also_compatible_with", 0, NULL
},
13807 LOOKUP(66, T2EE_use
),
13808 {67, "conformance", 1, NULL
},
13809 LOOKUP(68, Virtualization_use
),
13810 LOOKUP(70, MPextension_use_legacy
)
13814 static unsigned char *
13815 display_arm_attribute (unsigned char * p
,
13816 const unsigned char * const end
)
13821 arm_attr_public_tag
* attr
;
13825 tag
= read_uleb128 (p
, &len
, end
);
13828 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13830 if (arm_attr_public_tags
[i
].tag
== tag
)
13832 attr
= &arm_attr_public_tags
[i
];
13839 printf (" Tag_%s: ", attr
->name
);
13840 switch (attr
->type
)
13845 case 7: /* Tag_CPU_arch_profile. */
13846 val
= read_uleb128 (p
, &len
, end
);
13850 case 0: printf (_("None\n")); break;
13851 case 'A': printf (_("Application\n")); break;
13852 case 'R': printf (_("Realtime\n")); break;
13853 case 'M': printf (_("Microcontroller\n")); break;
13854 case 'S': printf (_("Application or Realtime\n")); break;
13855 default: printf ("??? (%d)\n", val
); break;
13859 case 24: /* Tag_align_needed. */
13860 val
= read_uleb128 (p
, &len
, end
);
13864 case 0: printf (_("None\n")); break;
13865 case 1: printf (_("8-byte\n")); break;
13866 case 2: printf (_("4-byte\n")); break;
13867 case 3: printf ("??? 3\n"); break;
13870 printf (_("8-byte and up to %d-byte extended\n"),
13873 printf ("??? (%d)\n", val
);
13878 case 25: /* Tag_align_preserved. */
13879 val
= read_uleb128 (p
, &len
, end
);
13883 case 0: printf (_("None\n")); break;
13884 case 1: printf (_("8-byte, except leaf SP\n")); break;
13885 case 2: printf (_("8-byte\n")); break;
13886 case 3: printf ("??? 3\n"); break;
13889 printf (_("8-byte and up to %d-byte extended\n"),
13892 printf ("??? (%d)\n", val
);
13897 case 32: /* Tag_compatibility. */
13899 val
= read_uleb128 (p
, &len
, end
);
13901 printf (_("flag = %d, vendor = "), val
);
13904 size_t maxlen
= (end
- p
) - 1;
13906 print_symbol ((int) maxlen
, (const char *) p
);
13907 p
+= strnlen ((char *) p
, maxlen
) + 1;
13911 printf (_("<corrupt>"));
13912 p
= (unsigned char *) end
;
13918 case 64: /* Tag_nodefaults. */
13919 /* PR 17531: file: 001-505008-0.01. */
13922 printf (_("True\n"));
13925 case 65: /* Tag_also_compatible_with. */
13926 val
= read_uleb128 (p
, &len
, end
);
13928 if (val
== 6 /* Tag_CPU_arch. */)
13930 val
= read_uleb128 (p
, &len
, end
);
13932 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13933 printf ("??? (%d)\n", val
);
13935 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13939 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13944 printf (_("<unknown: %d>\n"), tag
);
13950 return display_tag_value (-1, p
, end
);
13952 return display_tag_value (0, p
, end
);
13955 assert (attr
->type
& 0x80);
13956 val
= read_uleb128 (p
, &len
, end
);
13958 type
= attr
->type
& 0x7f;
13960 printf ("??? (%d)\n", val
);
13962 printf ("%s\n", attr
->table
[val
]);
13967 return display_tag_value (tag
, p
, end
);
13970 static unsigned char *
13971 display_gnu_attribute (unsigned char * p
,
13972 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13973 const unsigned char * const end
)
13979 tag
= read_uleb128 (p
, &len
, end
);
13982 /* Tag_compatibility is the only generic GNU attribute defined at
13986 val
= read_uleb128 (p
, &len
, end
);
13989 printf (_("flag = %d, vendor = "), val
);
13992 printf (_("<corrupt>\n"));
13993 warn (_("corrupt vendor attribute\n"));
13999 size_t maxlen
= (end
- p
) - 1;
14001 print_symbol ((int) maxlen
, (const char *) p
);
14002 p
+= strnlen ((char *) p
, maxlen
) + 1;
14006 printf (_("<corrupt>"));
14007 p
= (unsigned char *) end
;
14014 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14015 return display_proc_gnu_attribute (p
, tag
, end
);
14017 return display_tag_value (tag
, p
, end
);
14020 static unsigned char *
14021 display_power_gnu_attribute (unsigned char * p
,
14023 const unsigned char * const end
)
14028 if (tag
== Tag_GNU_Power_ABI_FP
)
14030 val
= read_uleb128 (p
, &len
, end
);
14032 printf (" Tag_GNU_Power_ABI_FP: ");
14035 printf (_("<corrupt>\n"));
14040 printf ("(%#x), ", val
);
14045 printf (_("unspecified hard/soft float, "));
14048 printf (_("hard float, "));
14051 printf (_("soft float, "));
14054 printf (_("single-precision hard float, "));
14061 printf (_("unspecified long double\n"));
14064 printf (_("128-bit IBM long double\n"));
14067 printf (_("64-bit long double\n"));
14070 printf (_("128-bit IEEE long double\n"));
14076 if (tag
== Tag_GNU_Power_ABI_Vector
)
14078 val
= read_uleb128 (p
, &len
, end
);
14080 printf (" Tag_GNU_Power_ABI_Vector: ");
14083 printf (_("<corrupt>\n"));
14088 printf ("(%#x), ", val
);
14093 printf (_("unspecified\n"));
14096 printf (_("generic\n"));
14099 printf ("AltiVec\n");
14108 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14110 val
= read_uleb128 (p
, &len
, end
);
14112 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14115 printf (_("<corrupt>\n"));
14120 printf ("(%#x), ", val
);
14125 printf (_("unspecified\n"));
14128 printf ("r3/r4\n");
14131 printf (_("memory\n"));
14140 return display_tag_value (tag
& 1, p
, end
);
14143 static unsigned char *
14144 display_s390_gnu_attribute (unsigned char * p
,
14146 const unsigned char * const end
)
14151 if (tag
== Tag_GNU_S390_ABI_Vector
)
14153 val
= read_uleb128 (p
, &len
, end
);
14155 printf (" Tag_GNU_S390_ABI_Vector: ");
14160 printf (_("any\n"));
14163 printf (_("software\n"));
14166 printf (_("hardware\n"));
14169 printf ("??? (%d)\n", val
);
14175 return display_tag_value (tag
& 1, p
, end
);
14179 display_sparc_hwcaps (unsigned int mask
)
14183 bfd_boolean first
= TRUE
;
14185 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14186 fputs ("mul32", stdout
), first
= FALSE
;
14187 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14188 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14189 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14190 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14191 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14192 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14193 if (mask
& ELF_SPARC_HWCAP_POPC
)
14194 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14195 if (mask
& ELF_SPARC_HWCAP_VIS
)
14196 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14197 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14198 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14199 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14200 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14201 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14202 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14203 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14204 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14205 if (mask
& ELF_SPARC_HWCAP_HPC
)
14206 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14207 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14208 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14209 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14210 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14211 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14212 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14213 if (mask
& ELF_SPARC_HWCAP_IMA
)
14214 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14215 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14216 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14219 fputc ('0', stdout
);
14220 fputc ('\n', stdout
);
14224 display_sparc_hwcaps2 (unsigned int mask
)
14228 bfd_boolean first
= TRUE
;
14230 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14231 fputs ("fjathplus", stdout
), first
= FALSE
;
14232 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14233 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14234 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14235 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14236 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14237 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14238 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14239 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14240 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14241 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14242 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14243 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14244 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14245 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14246 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14247 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14248 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14249 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14250 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14251 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14254 fputc ('0', stdout
);
14255 fputc ('\n', stdout
);
14258 static unsigned char *
14259 display_sparc_gnu_attribute (unsigned char * p
,
14261 const unsigned char * const end
)
14266 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14268 val
= read_uleb128 (p
, &len
, end
);
14270 printf (" Tag_GNU_Sparc_HWCAPS: ");
14271 display_sparc_hwcaps (val
);
14274 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14276 val
= read_uleb128 (p
, &len
, end
);
14278 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14279 display_sparc_hwcaps2 (val
);
14283 return display_tag_value (tag
, p
, end
);
14287 print_mips_fp_abi_value (unsigned int val
)
14291 case Val_GNU_MIPS_ABI_FP_ANY
:
14292 printf (_("Hard or soft float\n"));
14294 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14295 printf (_("Hard float (double precision)\n"));
14297 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14298 printf (_("Hard float (single precision)\n"));
14300 case Val_GNU_MIPS_ABI_FP_SOFT
:
14301 printf (_("Soft float\n"));
14303 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14304 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14306 case Val_GNU_MIPS_ABI_FP_XX
:
14307 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14309 case Val_GNU_MIPS_ABI_FP_64
:
14310 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14312 case Val_GNU_MIPS_ABI_FP_64A
:
14313 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14315 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14316 printf (_("NaN 2008 compatibility\n"));
14319 printf ("??? (%d)\n", val
);
14324 static unsigned char *
14325 display_mips_gnu_attribute (unsigned char * p
,
14327 const unsigned char * const end
)
14329 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14334 val
= read_uleb128 (p
, &len
, end
);
14336 printf (" Tag_GNU_MIPS_ABI_FP: ");
14338 print_mips_fp_abi_value (val
);
14343 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14348 val
= read_uleb128 (p
, &len
, end
);
14350 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14354 case Val_GNU_MIPS_ABI_MSA_ANY
:
14355 printf (_("Any MSA or not\n"));
14357 case Val_GNU_MIPS_ABI_MSA_128
:
14358 printf (_("128-bit MSA\n"));
14361 printf ("??? (%d)\n", val
);
14367 return display_tag_value (tag
& 1, p
, end
);
14370 static unsigned char *
14371 display_tic6x_attribute (unsigned char * p
,
14372 const unsigned char * const end
)
14378 tag
= read_uleb128 (p
, &len
, end
);
14384 val
= read_uleb128 (p
, &len
, end
);
14386 printf (" Tag_ISA: ");
14390 case C6XABI_Tag_ISA_none
:
14391 printf (_("None\n"));
14393 case C6XABI_Tag_ISA_C62X
:
14396 case C6XABI_Tag_ISA_C67X
:
14399 case C6XABI_Tag_ISA_C67XP
:
14400 printf ("C67x+\n");
14402 case C6XABI_Tag_ISA_C64X
:
14405 case C6XABI_Tag_ISA_C64XP
:
14406 printf ("C64x+\n");
14408 case C6XABI_Tag_ISA_C674X
:
14409 printf ("C674x\n");
14412 printf ("??? (%d)\n", val
);
14417 case Tag_ABI_wchar_t
:
14418 val
= read_uleb128 (p
, &len
, end
);
14420 printf (" Tag_ABI_wchar_t: ");
14424 printf (_("Not used\n"));
14427 printf (_("2 bytes\n"));
14430 printf (_("4 bytes\n"));
14433 printf ("??? (%d)\n", val
);
14438 case Tag_ABI_stack_align_needed
:
14439 val
= read_uleb128 (p
, &len
, end
);
14441 printf (" Tag_ABI_stack_align_needed: ");
14445 printf (_("8-byte\n"));
14448 printf (_("16-byte\n"));
14451 printf ("??? (%d)\n", val
);
14456 case Tag_ABI_stack_align_preserved
:
14457 val
= read_uleb128 (p
, &len
, end
);
14459 printf (" Tag_ABI_stack_align_preserved: ");
14463 printf (_("8-byte\n"));
14466 printf (_("16-byte\n"));
14469 printf ("??? (%d)\n", val
);
14475 val
= read_uleb128 (p
, &len
, end
);
14477 printf (" Tag_ABI_DSBT: ");
14481 printf (_("DSBT addressing not used\n"));
14484 printf (_("DSBT addressing used\n"));
14487 printf ("??? (%d)\n", val
);
14493 val
= read_uleb128 (p
, &len
, end
);
14495 printf (" Tag_ABI_PID: ");
14499 printf (_("Data addressing position-dependent\n"));
14502 printf (_("Data addressing position-independent, GOT near DP\n"));
14505 printf (_("Data addressing position-independent, GOT far from DP\n"));
14508 printf ("??? (%d)\n", val
);
14514 val
= read_uleb128 (p
, &len
, end
);
14516 printf (" Tag_ABI_PIC: ");
14520 printf (_("Code addressing position-dependent\n"));
14523 printf (_("Code addressing position-independent\n"));
14526 printf ("??? (%d)\n", val
);
14531 case Tag_ABI_array_object_alignment
:
14532 val
= read_uleb128 (p
, &len
, end
);
14534 printf (" Tag_ABI_array_object_alignment: ");
14538 printf (_("8-byte\n"));
14541 printf (_("4-byte\n"));
14544 printf (_("16-byte\n"));
14547 printf ("??? (%d)\n", val
);
14552 case Tag_ABI_array_object_align_expected
:
14553 val
= read_uleb128 (p
, &len
, end
);
14555 printf (" Tag_ABI_array_object_align_expected: ");
14559 printf (_("8-byte\n"));
14562 printf (_("4-byte\n"));
14565 printf (_("16-byte\n"));
14568 printf ("??? (%d)\n", val
);
14573 case Tag_ABI_compatibility
:
14575 val
= read_uleb128 (p
, &len
, end
);
14577 printf (" Tag_ABI_compatibility: ");
14578 printf (_("flag = %d, vendor = "), val
);
14581 size_t maxlen
= (end
- p
) - 1;
14583 print_symbol ((int) maxlen
, (const char *) p
);
14584 p
+= strnlen ((char *) p
, maxlen
) + 1;
14588 printf (_("<corrupt>"));
14589 p
= (unsigned char *) end
;
14595 case Tag_ABI_conformance
:
14597 printf (" Tag_ABI_conformance: \"");
14600 size_t maxlen
= (end
- p
) - 1;
14602 print_symbol ((int) maxlen
, (const char *) p
);
14603 p
+= strnlen ((char *) p
, maxlen
) + 1;
14607 printf (_("<corrupt>"));
14608 p
= (unsigned char *) end
;
14615 return display_tag_value (tag
, p
, end
);
14619 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14621 unsigned long addr
= 0;
14622 size_t bytes
= end
- p
;
14629 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14631 printf (" 0x%8.8lx ", addr
);
14633 for (j
= 0; j
< 16; j
++)
14636 printf ("%2.2x", p
[j
]);
14644 for (j
= 0; j
< lbytes
; j
++)
14647 if (k
>= ' ' && k
< 0x7f)
14663 static unsigned char *
14664 display_msp430x_attribute (unsigned char * p
,
14665 const unsigned char * const end
)
14671 tag
= read_uleb128 (p
, & len
, end
);
14676 case OFBA_MSPABI_Tag_ISA
:
14677 val
= read_uleb128 (p
, &len
, end
);
14679 printf (" Tag_ISA: ");
14682 case 0: printf (_("None\n")); break;
14683 case 1: printf (_("MSP430\n")); break;
14684 case 2: printf (_("MSP430X\n")); break;
14685 default: printf ("??? (%d)\n", val
); break;
14689 case OFBA_MSPABI_Tag_Code_Model
:
14690 val
= read_uleb128 (p
, &len
, end
);
14692 printf (" Tag_Code_Model: ");
14695 case 0: printf (_("None\n")); break;
14696 case 1: printf (_("Small\n")); break;
14697 case 2: printf (_("Large\n")); break;
14698 default: printf ("??? (%d)\n", val
); break;
14702 case OFBA_MSPABI_Tag_Data_Model
:
14703 val
= read_uleb128 (p
, &len
, end
);
14705 printf (" Tag_Data_Model: ");
14708 case 0: printf (_("None\n")); break;
14709 case 1: printf (_("Small\n")); break;
14710 case 2: printf (_("Large\n")); break;
14711 case 3: printf (_("Restricted Large\n")); break;
14712 default: printf ("??? (%d)\n", val
); break;
14717 printf (_(" <unknown tag %d>: "), tag
);
14724 size_t maxlen
= (end
- p
) - 1;
14726 print_symbol ((int) maxlen
, (const char *) p
);
14727 p
+= strnlen ((char *) p
, maxlen
) + 1;
14731 printf (_("<corrupt>"));
14732 p
= (unsigned char *) end
;
14738 val
= read_uleb128 (p
, &len
, end
);
14740 printf ("%d (0x%x)\n", val
, val
);
14750 process_attributes (FILE * file
,
14751 const char * public_name
,
14752 unsigned int proc_type
,
14753 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14754 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14756 Elf_Internal_Shdr
* sect
;
14758 bfd_boolean res
= TRUE
;
14760 /* Find the section header so that we get the size. */
14761 for (i
= 0, sect
= section_headers
;
14762 i
< elf_header
.e_shnum
;
14765 unsigned char * contents
;
14768 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14771 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14772 sect
->sh_size
, _("attributes"));
14773 if (contents
== NULL
)
14780 /* The first character is the version of the attributes.
14781 Currently only version 1, (aka 'A') is recognised here. */
14784 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14789 bfd_vma section_len
;
14791 section_len
= sect
->sh_size
- 1;
14794 while (section_len
> 0)
14797 unsigned int namelen
;
14798 bfd_boolean public_section
;
14799 bfd_boolean gnu_section
;
14801 if (section_len
<= 4)
14803 error (_("Tag section ends prematurely\n"));
14807 attr_len
= byte_get (p
, 4);
14810 if (attr_len
> section_len
)
14812 error (_("Bad attribute length (%u > %u)\n"),
14813 (unsigned) attr_len
, (unsigned) section_len
);
14814 attr_len
= section_len
;
14817 /* PR 17531: file: 001-101425-0.004 */
14818 else if (attr_len
< 5)
14820 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14825 section_len
-= attr_len
;
14828 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14829 if (namelen
== 0 || namelen
>= attr_len
)
14831 error (_("Corrupt attribute section name\n"));
14836 printf (_("Attribute Section: "));
14837 print_symbol (INT_MAX
, (const char *) p
);
14840 if (public_name
&& streq ((char *) p
, public_name
))
14841 public_section
= TRUE
;
14843 public_section
= FALSE
;
14845 if (streq ((char *) p
, "gnu"))
14846 gnu_section
= TRUE
;
14848 gnu_section
= FALSE
;
14851 attr_len
-= namelen
;
14853 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14858 unsigned char * end
;
14860 /* PR binutils/17531: Safe handling of corrupt files. */
14863 error (_("Unused bytes at end of section\n"));
14870 size
= byte_get (p
, 4);
14871 if (size
> attr_len
)
14873 error (_("Bad subsection length (%u > %u)\n"),
14874 (unsigned) size
, (unsigned) attr_len
);
14878 /* PR binutils/17531: Safe handling of corrupt files. */
14881 error (_("Bad subsection length (%u < 6)\n"),
14889 end
= p
+ size
- 1;
14890 assert (end
<= contents
+ sect
->sh_size
);
14896 printf (_("File Attributes\n"));
14899 printf (_("Section Attributes:"));
14902 printf (_("Symbol Attributes:"));
14903 /* Fall through. */
14909 val
= read_uleb128 (p
, &j
, end
);
14913 printf (" %d", val
);
14918 printf (_("Unknown tag: %d\n"), tag
);
14919 public_section
= FALSE
;
14923 if (public_section
&& display_pub_attribute
!= NULL
)
14926 p
= display_pub_attribute (p
, end
);
14929 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14932 p
= display_gnu_attribute (p
,
14933 display_proc_gnu_attribute
,
14939 printf (_(" Unknown attribute:\n"));
14940 display_raw_attribute (p
, end
);
14955 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14956 Print the Address, Access and Initial fields of an entry at VMA ADDR
14957 and return the VMA of the next entry, or -1 if there was a problem.
14958 Does not read from DATA_END or beyond. */
14961 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14962 unsigned char * data_end
)
14965 print_vma (addr
, LONG_HEX
);
14967 if (addr
< pltgot
+ 0xfff0)
14968 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14970 printf ("%10s", "");
14973 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14977 unsigned char * from
= data
+ addr
- pltgot
;
14979 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14981 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14982 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14983 return (bfd_vma
) -1;
14987 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14988 print_vma (entry
, LONG_HEX
);
14991 return addr
+ (is_32bit_elf
? 4 : 8);
14994 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14995 PLTGOT. Print the Address and Initial fields of an entry at VMA
14996 ADDR and return the VMA of the next entry. */
14999 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15002 print_vma (addr
, LONG_HEX
);
15005 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15010 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15011 print_vma (entry
, LONG_HEX
);
15013 return addr
+ (is_32bit_elf
? 4 : 8);
15017 print_mips_ases (unsigned int mask
)
15019 if (mask
& AFL_ASE_DSP
)
15020 fputs ("\n\tDSP ASE", stdout
);
15021 if (mask
& AFL_ASE_DSPR2
)
15022 fputs ("\n\tDSP R2 ASE", stdout
);
15023 if (mask
& AFL_ASE_DSPR3
)
15024 fputs ("\n\tDSP R3 ASE", stdout
);
15025 if (mask
& AFL_ASE_EVA
)
15026 fputs ("\n\tEnhanced VA Scheme", stdout
);
15027 if (mask
& AFL_ASE_MCU
)
15028 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15029 if (mask
& AFL_ASE_MDMX
)
15030 fputs ("\n\tMDMX ASE", stdout
);
15031 if (mask
& AFL_ASE_MIPS3D
)
15032 fputs ("\n\tMIPS-3D ASE", stdout
);
15033 if (mask
& AFL_ASE_MT
)
15034 fputs ("\n\tMT ASE", stdout
);
15035 if (mask
& AFL_ASE_SMARTMIPS
)
15036 fputs ("\n\tSmartMIPS ASE", stdout
);
15037 if (mask
& AFL_ASE_VIRT
)
15038 fputs ("\n\tVZ ASE", stdout
);
15039 if (mask
& AFL_ASE_MSA
)
15040 fputs ("\n\tMSA ASE", stdout
);
15041 if (mask
& AFL_ASE_MIPS16
)
15042 fputs ("\n\tMIPS16 ASE", stdout
);
15043 if (mask
& AFL_ASE_MICROMIPS
)
15044 fputs ("\n\tMICROMIPS ASE", stdout
);
15045 if (mask
& AFL_ASE_XPA
)
15046 fputs ("\n\tXPA ASE", stdout
);
15047 if (mask
& AFL_ASE_MIPS16E2
)
15048 fputs ("\n\tMIPS16e2 ASE", stdout
);
15050 fprintf (stdout
, "\n\t%s", _("None"));
15051 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15052 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15056 print_mips_isa_ext (unsigned int isa_ext
)
15061 fputs (_("None"), stdout
);
15064 fputs ("RMI XLR", stdout
);
15066 case AFL_EXT_OCTEON3
:
15067 fputs ("Cavium Networks Octeon3", stdout
);
15069 case AFL_EXT_OCTEON2
:
15070 fputs ("Cavium Networks Octeon2", stdout
);
15072 case AFL_EXT_OCTEONP
:
15073 fputs ("Cavium Networks OcteonP", stdout
);
15075 case AFL_EXT_LOONGSON_3A
:
15076 fputs ("Loongson 3A", stdout
);
15078 case AFL_EXT_OCTEON
:
15079 fputs ("Cavium Networks Octeon", stdout
);
15082 fputs ("Toshiba R5900", stdout
);
15085 fputs ("MIPS R4650", stdout
);
15088 fputs ("LSI R4010", stdout
);
15091 fputs ("NEC VR4100", stdout
);
15094 fputs ("Toshiba R3900", stdout
);
15096 case AFL_EXT_10000
:
15097 fputs ("MIPS R10000", stdout
);
15100 fputs ("Broadcom SB-1", stdout
);
15103 fputs ("NEC VR4111/VR4181", stdout
);
15106 fputs ("NEC VR4120", stdout
);
15109 fputs ("NEC VR5400", stdout
);
15112 fputs ("NEC VR5500", stdout
);
15114 case AFL_EXT_LOONGSON_2E
:
15115 fputs ("ST Microelectronics Loongson 2E", stdout
);
15117 case AFL_EXT_LOONGSON_2F
:
15118 fputs ("ST Microelectronics Loongson 2F", stdout
);
15121 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15126 get_mips_reg_size (int reg_size
)
15128 return (reg_size
== AFL_REG_NONE
) ? 0
15129 : (reg_size
== AFL_REG_32
) ? 32
15130 : (reg_size
== AFL_REG_64
) ? 64
15131 : (reg_size
== AFL_REG_128
) ? 128
15136 process_mips_specific (FILE * file
)
15138 Elf_Internal_Dyn
* entry
;
15139 Elf_Internal_Shdr
*sect
= NULL
;
15140 size_t liblist_offset
= 0;
15141 size_t liblistno
= 0;
15142 size_t conflictsno
= 0;
15143 size_t options_offset
= 0;
15144 size_t conflicts_offset
= 0;
15145 size_t pltrelsz
= 0;
15147 bfd_vma pltgot
= 0;
15148 bfd_vma mips_pltgot
= 0;
15149 bfd_vma jmprel
= 0;
15150 bfd_vma local_gotno
= 0;
15151 bfd_vma gotsym
= 0;
15152 bfd_vma symtabno
= 0;
15153 bfd_boolean res
= TRUE
;
15155 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15156 display_mips_gnu_attribute
))
15159 sect
= find_section (".MIPS.abiflags");
15163 Elf_External_ABIFlags_v0
*abiflags_ext
;
15164 Elf_Internal_ABIFlags_v0 abiflags_in
;
15166 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15168 error (_("Corrupt MIPS ABI Flags section.\n"));
15173 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15174 sect
->sh_size
, _("MIPS ABI Flags section"));
15177 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15178 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15179 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15180 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15181 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15182 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15183 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15184 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15185 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15186 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15187 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15189 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15190 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15191 if (abiflags_in
.isa_rev
> 1)
15192 printf ("r%d", abiflags_in
.isa_rev
);
15193 printf ("\nGPR size: %d",
15194 get_mips_reg_size (abiflags_in
.gpr_size
));
15195 printf ("\nCPR1 size: %d",
15196 get_mips_reg_size (abiflags_in
.cpr1_size
));
15197 printf ("\nCPR2 size: %d",
15198 get_mips_reg_size (abiflags_in
.cpr2_size
));
15199 fputs ("\nFP ABI: ", stdout
);
15200 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15201 fputs ("ISA Extension: ", stdout
);
15202 print_mips_isa_ext (abiflags_in
.isa_ext
);
15203 fputs ("\nASEs:", stdout
);
15204 print_mips_ases (abiflags_in
.ases
);
15205 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15206 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15207 fputc ('\n', stdout
);
15208 free (abiflags_ext
);
15213 /* We have a lot of special sections. Thanks SGI! */
15214 if (dynamic_section
== NULL
)
15216 /* No dynamic information available. See if there is static GOT. */
15217 sect
= find_section (".got");
15220 unsigned char *data_end
;
15221 unsigned char *data
;
15225 pltgot
= sect
->sh_addr
;
15228 addr_size
= (is_32bit_elf
? 4 : 8);
15229 end
= pltgot
+ sect
->sh_size
;
15231 data
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
,
15233 _("Global Offset Table data"));
15234 /* PR 12855: Null data is handled gracefully throughout. */
15235 data_end
= data
+ (end
- pltgot
);
15237 printf (_("\nStatic GOT:\n"));
15238 printf (_(" Canonical gp value: "));
15239 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15242 /* In a dynamic binary GOT[0] is reserved for the dynamic
15243 loader to store the lazy resolver pointer, however in
15244 a static binary it may well have been omitted and GOT
15245 reduced to a table of addresses.
15246 PR 21344: Check for the entry being fully available
15247 before fetching it. */
15249 && data
+ ent
- pltgot
+ addr_size
<= data_end
15250 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15252 printf (_(" Reserved entries:\n"));
15253 printf (_(" %*s %10s %*s\n"),
15254 addr_size
* 2, _("Address"), _("Access"),
15255 addr_size
* 2, _("Value"));
15256 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15258 if (ent
== (bfd_vma
) -1)
15259 goto sgot_print_fail
;
15261 /* Check for the MSB of GOT[1] being set, identifying a
15262 GNU object. This entry will be used by some runtime
15263 loaders, to store the module pointer. Otherwise this
15264 is an ordinary local entry.
15265 PR 21344: Check for the entry being fully available
15266 before fetching it. */
15268 && data
+ ent
- pltgot
+ addr_size
<= data_end
15269 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15270 >> (addr_size
* 8 - 1)) != 0)
15272 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15274 if (ent
== (bfd_vma
) -1)
15275 goto sgot_print_fail
;
15282 printf (_(" Local entries:\n"));
15283 printf (" %*s %10s %*s\n",
15284 addr_size
* 2, _("Address"), _("Access"),
15285 addr_size
* 2, _("Value"));
15288 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15290 if (ent
== (bfd_vma
) -1)
15291 goto sgot_print_fail
;
15303 for (entry
= dynamic_section
;
15304 /* PR 17531 file: 012-50589-0.004. */
15305 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15307 switch (entry
->d_tag
)
15309 case DT_MIPS_LIBLIST
:
15311 = offset_from_vma (file
, entry
->d_un
.d_val
,
15312 liblistno
* sizeof (Elf32_External_Lib
));
15314 case DT_MIPS_LIBLISTNO
:
15315 liblistno
= entry
->d_un
.d_val
;
15317 case DT_MIPS_OPTIONS
:
15318 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15320 case DT_MIPS_CONFLICT
:
15322 = offset_from_vma (file
, entry
->d_un
.d_val
,
15323 conflictsno
* sizeof (Elf32_External_Conflict
));
15325 case DT_MIPS_CONFLICTNO
:
15326 conflictsno
= entry
->d_un
.d_val
;
15329 pltgot
= entry
->d_un
.d_ptr
;
15331 case DT_MIPS_LOCAL_GOTNO
:
15332 local_gotno
= entry
->d_un
.d_val
;
15334 case DT_MIPS_GOTSYM
:
15335 gotsym
= entry
->d_un
.d_val
;
15337 case DT_MIPS_SYMTABNO
:
15338 symtabno
= entry
->d_un
.d_val
;
15340 case DT_MIPS_PLTGOT
:
15341 mips_pltgot
= entry
->d_un
.d_ptr
;
15344 pltrel
= entry
->d_un
.d_val
;
15347 pltrelsz
= entry
->d_un
.d_val
;
15350 jmprel
= entry
->d_un
.d_ptr
;
15356 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15358 Elf32_External_Lib
* elib
;
15361 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15363 sizeof (Elf32_External_Lib
),
15364 _("liblist section data"));
15367 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15368 (unsigned long) liblistno
);
15369 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15372 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15379 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15380 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15381 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15382 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15383 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15385 tmp
= gmtime (&atime
);
15386 snprintf (timebuf
, sizeof (timebuf
),
15387 "%04u-%02u-%02uT%02u:%02u:%02u",
15388 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15389 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15391 printf ("%3lu: ", (unsigned long) cnt
);
15392 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15393 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15395 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15396 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15397 liblist
.l_version
);
15399 if (liblist
.l_flags
== 0)
15403 static const struct
15410 { " EXACT_MATCH", LL_EXACT_MATCH
},
15411 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15412 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15413 { " EXPORTS", LL_EXPORTS
},
15414 { " DELAY_LOAD", LL_DELAY_LOAD
},
15415 { " DELTA", LL_DELTA
}
15417 int flags
= liblist
.l_flags
;
15420 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15421 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15423 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15424 flags
^= l_flags_vals
[fcnt
].bit
;
15427 printf (" %#x", (unsigned int) flags
);
15439 if (options_offset
!= 0)
15441 Elf_External_Options
* eopt
;
15442 Elf_Internal_Options
* iopt
;
15443 Elf_Internal_Options
* option
;
15446 sect
= section_headers
;
15448 /* Find the section header so that we get the size. */
15449 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15450 /* PR 17533 file: 012-277276-0.004. */
15453 error (_("No MIPS_OPTIONS header found\n"));
15457 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15458 sect
->sh_size
, _("options"));
15461 iopt
= (Elf_Internal_Options
*)
15462 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15465 error (_("Out of memory allocating space for MIPS options\n"));
15472 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15474 Elf_External_Options
* eoption
;
15476 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15478 option
->kind
= BYTE_GET (eoption
->kind
);
15479 option
->size
= BYTE_GET (eoption
->size
);
15480 option
->section
= BYTE_GET (eoption
->section
);
15481 option
->info
= BYTE_GET (eoption
->info
);
15483 /* PR 17531: file: ffa0fa3b. */
15484 if (option
->size
< sizeof (* eopt
)
15485 || offset
+ option
->size
> sect
->sh_size
)
15487 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15490 offset
+= option
->size
;
15496 printf (_("\nSection '%s' contains %d entries:\n"),
15497 printable_section_name (sect
), cnt
);
15506 switch (option
->kind
)
15509 /* This shouldn't happen. */
15510 printf (" NULL %d %lx", option
->section
, option
->info
);
15513 printf (" REGINFO ");
15514 if (elf_header
.e_machine
== EM_MIPS
)
15517 Elf32_External_RegInfo
* ereg
;
15518 Elf32_RegInfo reginfo
;
15520 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15521 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15522 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15523 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15524 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15525 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15526 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15528 printf ("GPR %08lx GP 0x%lx\n",
15529 reginfo
.ri_gprmask
,
15530 (unsigned long) reginfo
.ri_gp_value
);
15531 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15532 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15533 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15538 Elf64_External_RegInfo
* ereg
;
15539 Elf64_Internal_RegInfo reginfo
;
15541 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15542 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15543 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15544 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15545 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15546 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15547 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15549 printf ("GPR %08lx GP 0x",
15550 reginfo
.ri_gprmask
);
15551 printf_vma (reginfo
.ri_gp_value
);
15554 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15555 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15556 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15560 case ODK_EXCEPTIONS
:
15561 fputs (" EXCEPTIONS fpe_min(", stdout
);
15562 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15563 fputs (") fpe_max(", stdout
);
15564 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15565 fputs (")", stdout
);
15567 if (option
->info
& OEX_PAGE0
)
15568 fputs (" PAGE0", stdout
);
15569 if (option
->info
& OEX_SMM
)
15570 fputs (" SMM", stdout
);
15571 if (option
->info
& OEX_FPDBUG
)
15572 fputs (" FPDBUG", stdout
);
15573 if (option
->info
& OEX_DISMISS
)
15574 fputs (" DISMISS", stdout
);
15577 fputs (" PAD ", stdout
);
15578 if (option
->info
& OPAD_PREFIX
)
15579 fputs (" PREFIX", stdout
);
15580 if (option
->info
& OPAD_POSTFIX
)
15581 fputs (" POSTFIX", stdout
);
15582 if (option
->info
& OPAD_SYMBOL
)
15583 fputs (" SYMBOL", stdout
);
15586 fputs (" HWPATCH ", stdout
);
15587 if (option
->info
& OHW_R4KEOP
)
15588 fputs (" R4KEOP", stdout
);
15589 if (option
->info
& OHW_R8KPFETCH
)
15590 fputs (" R8KPFETCH", stdout
);
15591 if (option
->info
& OHW_R5KEOP
)
15592 fputs (" R5KEOP", stdout
);
15593 if (option
->info
& OHW_R5KCVTL
)
15594 fputs (" R5KCVTL", stdout
);
15597 fputs (" FILL ", stdout
);
15598 /* XXX Print content of info word? */
15601 fputs (" TAGS ", stdout
);
15602 /* XXX Print content of info word? */
15605 fputs (" HWAND ", stdout
);
15606 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15607 fputs (" R4KEOP_CHECKED", stdout
);
15608 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15609 fputs (" R4KEOP_CLEAN", stdout
);
15612 fputs (" HWOR ", stdout
);
15613 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15614 fputs (" R4KEOP_CHECKED", stdout
);
15615 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15616 fputs (" R4KEOP_CLEAN", stdout
);
15619 printf (" GP_GROUP %#06lx self-contained %#06lx",
15620 option
->info
& OGP_GROUP
,
15621 (option
->info
& OGP_SELF
) >> 16);
15624 printf (" IDENT %#06lx self-contained %#06lx",
15625 option
->info
& OGP_GROUP
,
15626 (option
->info
& OGP_SELF
) >> 16);
15629 /* This shouldn't happen. */
15630 printf (" %3d ??? %d %lx",
15631 option
->kind
, option
->section
, option
->info
);
15635 len
= sizeof (* eopt
);
15636 while (len
< option
->size
)
15638 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15640 if (ISPRINT (datum
))
15641 printf ("%c", datum
);
15643 printf ("\\%03o", datum
);
15646 fputs ("\n", stdout
);
15648 offset
+= option
->size
;
15658 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15660 Elf32_Conflict
* iconf
;
15663 if (dynamic_symbols
== NULL
)
15665 error (_("conflict list found without a dynamic symbol table\n"));
15669 /* PR 21345 - print a slightly more helpful error message
15670 if we are sure that the cmalloc will fail. */
15671 if (conflictsno
* sizeof (* iconf
) > current_file_size
)
15673 error (_("Overlarge number of conflicts detected: %lx\n"),
15674 (long) conflictsno
);
15678 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15681 error (_("Out of memory allocating space for dynamic conflicts\n"));
15687 Elf32_External_Conflict
* econf32
;
15689 econf32
= (Elf32_External_Conflict
*)
15690 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15691 sizeof (* econf32
), _("conflict"));
15695 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15696 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15702 Elf64_External_Conflict
* econf64
;
15704 econf64
= (Elf64_External_Conflict
*)
15705 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15706 sizeof (* econf64
), _("conflict"));
15710 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15711 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15716 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15717 (unsigned long) conflictsno
);
15718 puts (_(" Num: Index Value Name"));
15720 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15722 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15724 if (iconf
[cnt
] >= num_dynamic_syms
)
15725 printf (_("<corrupt symbol index>"));
15728 Elf_Internal_Sym
* psym
;
15730 psym
= & dynamic_symbols
[iconf
[cnt
]];
15731 print_vma (psym
->st_value
, FULL_HEX
);
15733 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15734 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15736 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15744 if (pltgot
!= 0 && local_gotno
!= 0)
15746 bfd_vma ent
, local_end
, global_end
;
15748 unsigned char * data
;
15749 unsigned char * data_end
;
15753 addr_size
= (is_32bit_elf
? 4 : 8);
15754 local_end
= pltgot
+ local_gotno
* addr_size
;
15756 /* PR binutils/17533 file: 012-111227-0.004 */
15757 if (symtabno
< gotsym
)
15759 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15760 (unsigned long) gotsym
, (unsigned long) symtabno
);
15764 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15765 /* PR 17531: file: 54c91a34. */
15766 if (global_end
< local_end
)
15768 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15772 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15773 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15774 global_end
- pltgot
, 1,
15775 _("Global Offset Table data"));
15776 /* PR 12855: Null data is handled gracefully throughout. */
15777 data_end
= data
+ (global_end
- pltgot
);
15779 printf (_("\nPrimary GOT:\n"));
15780 printf (_(" Canonical gp value: "));
15781 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15784 printf (_(" Reserved entries:\n"));
15785 printf (_(" %*s %10s %*s Purpose\n"),
15786 addr_size
* 2, _("Address"), _("Access"),
15787 addr_size
* 2, _("Initial"));
15788 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15789 printf (_(" Lazy resolver\n"));
15790 if (ent
== (bfd_vma
) -1)
15791 goto got_print_fail
;
15793 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15794 This entry will be used by some runtime loaders, to store the
15795 module pointer. Otherwise this is an ordinary local entry.
15796 PR 21344: Check for the entry being fully available before
15799 && data
+ ent
- pltgot
+ addr_size
<= data_end
15800 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15801 >> (addr_size
* 8 - 1)) != 0)
15803 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15804 printf (_(" Module pointer (GNU extension)\n"));
15805 if (ent
== (bfd_vma
) -1)
15806 goto got_print_fail
;
15810 if (ent
< local_end
)
15812 printf (_(" Local entries:\n"));
15813 printf (" %*s %10s %*s\n",
15814 addr_size
* 2, _("Address"), _("Access"),
15815 addr_size
* 2, _("Initial"));
15816 while (ent
< local_end
)
15818 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15820 if (ent
== (bfd_vma
) -1)
15821 goto got_print_fail
;
15826 if (gotsym
< symtabno
)
15830 printf (_(" Global entries:\n"));
15831 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15832 addr_size
* 2, _("Address"),
15834 addr_size
* 2, _("Initial"),
15835 addr_size
* 2, _("Sym.Val."),
15837 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15838 _("Ndx"), _("Name"));
15840 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15842 for (i
= gotsym
; i
< symtabno
; i
++)
15844 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15847 if (dynamic_symbols
== NULL
)
15848 printf (_("<no dynamic symbols>"));
15849 else if (i
< num_dynamic_syms
)
15851 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15853 print_vma (psym
->st_value
, LONG_HEX
);
15854 printf (" %-7s %3s ",
15855 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15856 get_symbol_index_type (psym
->st_shndx
));
15858 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15859 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15861 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15864 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15865 (unsigned long) i
);
15868 if (ent
== (bfd_vma
) -1)
15879 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15882 size_t offset
, rel_offset
;
15883 unsigned long count
, i
;
15884 unsigned char * data
;
15885 int addr_size
, sym_width
;
15886 Elf_Internal_Rela
* rels
;
15888 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15889 if (pltrel
== DT_RELA
)
15891 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15896 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15901 addr_size
= (is_32bit_elf
? 4 : 8);
15902 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15904 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15905 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15906 1, _("Procedure Linkage Table data"));
15910 printf ("\nPLT GOT:\n\n");
15911 printf (_(" Reserved entries:\n"));
15912 printf (_(" %*s %*s Purpose\n"),
15913 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15914 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15915 printf (_(" PLT lazy resolver\n"));
15916 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15917 printf (_(" Module pointer\n"));
15920 printf (_(" Entries:\n"));
15921 printf (" %*s %*s %*s %-7s %3s %s\n",
15922 addr_size
* 2, _("Address"),
15923 addr_size
* 2, _("Initial"),
15924 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15925 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15926 for (i
= 0; i
< count
; i
++)
15928 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15930 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15933 if (idx
>= num_dynamic_syms
)
15934 printf (_("<corrupt symbol index: %lu>"), idx
);
15937 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15939 print_vma (psym
->st_value
, LONG_HEX
);
15940 printf (" %-7s %3s ",
15941 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15942 get_symbol_index_type (psym
->st_shndx
));
15943 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15944 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15946 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15961 process_nds32_specific (FILE * file
)
15963 Elf_Internal_Shdr
*sect
= NULL
;
15965 sect
= find_section (".nds32_e_flags");
15968 unsigned int *flag
;
15970 printf ("\nNDS32 elf flags section:\n");
15971 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15972 sect
->sh_size
, _("NDS32 elf flags section"));
15977 switch ((*flag
) & 0x3)
15980 printf ("(VEC_SIZE):\tNo entry.\n");
15983 printf ("(VEC_SIZE):\t4 bytes\n");
15986 printf ("(VEC_SIZE):\t16 bytes\n");
15989 printf ("(VEC_SIZE):\treserved\n");
15998 process_gnu_liblist (FILE * file
)
16000 Elf_Internal_Shdr
* section
;
16001 Elf_Internal_Shdr
* string_sec
;
16002 Elf32_External_Lib
* elib
;
16004 size_t strtab_size
;
16007 bfd_boolean res
= TRUE
;
16012 for (i
= 0, section
= section_headers
;
16013 i
< elf_header
.e_shnum
;
16016 switch (section
->sh_type
)
16018 case SHT_GNU_LIBLIST
:
16019 if (section
->sh_link
>= elf_header
.e_shnum
)
16022 elib
= (Elf32_External_Lib
*)
16023 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
16024 _("liblist section data"));
16032 string_sec
= section_headers
+ section
->sh_link
;
16033 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
16034 string_sec
->sh_size
,
16035 _("liblist string table"));
16037 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16044 strtab_size
= string_sec
->sh_size
;
16046 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16047 printable_section_name (section
),
16048 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
16050 puts (_(" Library Time Stamp Checksum Version Flags"));
16052 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16060 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16061 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16062 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16063 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16064 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16066 tmp
= gmtime (&atime
);
16067 snprintf (timebuf
, sizeof (timebuf
),
16068 "%04u-%02u-%02uT%02u:%02u:%02u",
16069 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16070 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16072 printf ("%3lu: ", (unsigned long) cnt
);
16074 printf ("%-20s", liblist
.l_name
< strtab_size
16075 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16077 printf ("%-20.20s", liblist
.l_name
< strtab_size
16078 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16079 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16080 liblist
.l_version
, liblist
.l_flags
);
16091 static const char *
16092 get_note_type (unsigned e_type
)
16094 static char buff
[64];
16096 if (elf_header
.e_type
== ET_CORE
)
16100 return _("NT_AUXV (auxiliary vector)");
16102 return _("NT_PRSTATUS (prstatus structure)");
16104 return _("NT_FPREGSET (floating point registers)");
16106 return _("NT_PRPSINFO (prpsinfo structure)");
16107 case NT_TASKSTRUCT
:
16108 return _("NT_TASKSTRUCT (task structure)");
16110 return _("NT_PRXFPREG (user_xfpregs structure)");
16112 return _("NT_PPC_VMX (ppc Altivec registers)");
16114 return _("NT_PPC_VSX (ppc VSX registers)");
16116 return _("NT_386_TLS (x86 TLS information)");
16117 case NT_386_IOPERM
:
16118 return _("NT_386_IOPERM (x86 I/O permissions)");
16119 case NT_X86_XSTATE
:
16120 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16121 case NT_S390_HIGH_GPRS
:
16122 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16123 case NT_S390_TIMER
:
16124 return _("NT_S390_TIMER (s390 timer register)");
16125 case NT_S390_TODCMP
:
16126 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16127 case NT_S390_TODPREG
:
16128 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16130 return _("NT_S390_CTRS (s390 control registers)");
16131 case NT_S390_PREFIX
:
16132 return _("NT_S390_PREFIX (s390 prefix register)");
16133 case NT_S390_LAST_BREAK
:
16134 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16135 case NT_S390_SYSTEM_CALL
:
16136 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16138 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16139 case NT_S390_VXRS_LOW
:
16140 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16141 case NT_S390_VXRS_HIGH
:
16142 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16144 return _("NT_ARM_VFP (arm VFP registers)");
16146 return _("NT_ARM_TLS (AArch TLS registers)");
16147 case NT_ARM_HW_BREAK
:
16148 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16149 case NT_ARM_HW_WATCH
:
16150 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16152 return _("NT_PSTATUS (pstatus structure)");
16154 return _("NT_FPREGS (floating point registers)");
16156 return _("NT_PSINFO (psinfo structure)");
16158 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16160 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16161 case NT_WIN32PSTATUS
:
16162 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16164 return _("NT_SIGINFO (siginfo_t data)");
16166 return _("NT_FILE (mapped files)");
16174 return _("NT_VERSION (version)");
16176 return _("NT_ARCH (architecture)");
16177 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16178 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16179 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16180 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16185 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16190 print_core_note (Elf_Internal_Note
*pnote
)
16192 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16193 bfd_vma count
, page_size
;
16194 unsigned char *descdata
, *filenames
, *descend
;
16196 if (pnote
->type
!= NT_FILE
)
16202 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16203 /* Still "successful". */
16208 if (pnote
->descsz
< 2 * addr_size
)
16210 error (_(" Malformed note - too short for header\n"));
16214 descdata
= (unsigned char *) pnote
->descdata
;
16215 descend
= descdata
+ pnote
->descsz
;
16217 if (descdata
[pnote
->descsz
- 1] != '\0')
16219 error (_(" Malformed note - does not end with \\0\n"));
16223 count
= byte_get (descdata
, addr_size
);
16224 descdata
+= addr_size
;
16226 page_size
= byte_get (descdata
, addr_size
);
16227 descdata
+= addr_size
;
16229 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16231 error (_(" Malformed note - too short for supplied file count\n"));
16235 printf (_(" Page size: "));
16236 print_vma (page_size
, DEC
);
16239 printf (_(" %*s%*s%*s\n"),
16240 (int) (2 + 2 * addr_size
), _("Start"),
16241 (int) (4 + 2 * addr_size
), _("End"),
16242 (int) (4 + 2 * addr_size
), _("Page Offset"));
16243 filenames
= descdata
+ count
* 3 * addr_size
;
16244 while (count
-- > 0)
16246 bfd_vma start
, end
, file_ofs
;
16248 if (filenames
== descend
)
16250 error (_(" Malformed note - filenames end too early\n"));
16254 start
= byte_get (descdata
, addr_size
);
16255 descdata
+= addr_size
;
16256 end
= byte_get (descdata
, addr_size
);
16257 descdata
+= addr_size
;
16258 file_ofs
= byte_get (descdata
, addr_size
);
16259 descdata
+= addr_size
;
16262 print_vma (start
, FULL_HEX
);
16264 print_vma (end
, FULL_HEX
);
16266 print_vma (file_ofs
, FULL_HEX
);
16267 printf ("\n %s\n", filenames
);
16269 filenames
+= 1 + strlen ((char *) filenames
);
16275 static const char *
16276 get_gnu_elf_note_type (unsigned e_type
)
16278 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16281 case NT_GNU_ABI_TAG
:
16282 return _("NT_GNU_ABI_TAG (ABI version tag)");
16284 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16285 case NT_GNU_BUILD_ID
:
16286 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16287 case NT_GNU_GOLD_VERSION
:
16288 return _("NT_GNU_GOLD_VERSION (gold version)");
16289 case NT_GNU_PROPERTY_TYPE_0
:
16290 return _("NT_GNU_PROPERTY_TYPE_0");
16291 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16292 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16293 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16294 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16297 static char buff
[64];
16299 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16306 decode_x86_isa (unsigned int bitmask
)
16310 unsigned int bit
= bitmask
& (- bitmask
);
16315 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16316 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16317 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16318 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16319 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16320 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16321 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16322 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16323 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16324 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16325 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16326 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16327 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16328 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16329 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16330 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16331 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16332 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16333 default: printf (_("<unknown: %x>"), bit
); break;
16341 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16343 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16344 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16345 unsigned int size
= is_32bit_elf
? 4 : 8;
16347 printf (_(" Properties: "));
16349 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16351 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16358 unsigned int type
= byte_get (ptr
, 4);
16359 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16363 if ((ptr
+ datasz
) > ptr_end
)
16365 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16370 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16372 if (elf_header
.e_machine
== EM_X86_64
16373 || elf_header
.e_machine
== EM_IAMCU
16374 || elf_header
.e_machine
== EM_386
)
16378 case GNU_PROPERTY_X86_ISA_1_USED
:
16379 printf ("x86 ISA used: ");
16381 printf (_("<corrupt length: %#x> "), datasz
);
16383 decode_x86_isa (byte_get (ptr
, 4));
16386 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16387 printf ("x86 ISA needed: ");
16389 printf (_("<corrupt length: %#x> "), datasz
);
16391 decode_x86_isa (byte_get (ptr
, 4));
16403 case GNU_PROPERTY_STACK_SIZE
:
16404 printf (_("stack size: "));
16405 if (datasz
!= size
)
16406 printf (_("<corrupt length: %#x> "), datasz
);
16408 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16411 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16412 printf ("no copy on protected ");
16414 printf (_("<corrupt length: %#x> "), datasz
);
16422 if (type
< GNU_PROPERTY_LOPROC
)
16423 printf (_("<unknown type %#x data: "), type
);
16424 else if (type
< GNU_PROPERTY_LOUSER
)
16425 printf (_("<procesor-specific type %#x data: "), type
);
16427 printf (_("<application-specific type %#x data: "), type
);
16428 for (j
= 0; j
< datasz
; ++j
)
16429 printf ("%02x ", ptr
[j
] & 0xff);
16433 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16434 if (ptr
== ptr_end
)
16444 if (ptr
> (ptr_end
- 8))
16446 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16455 print_gnu_note (Elf_Internal_Note
*pnote
)
16457 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16458 switch (pnote
->type
)
16460 case NT_GNU_BUILD_ID
:
16464 printf (_(" Build ID: "));
16465 for (i
= 0; i
< pnote
->descsz
; ++i
)
16466 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16471 case NT_GNU_ABI_TAG
:
16473 unsigned long os
, major
, minor
, subminor
;
16474 const char *osname
;
16476 /* PR 17531: file: 030-599401-0.004. */
16477 if (pnote
->descsz
< 16)
16479 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16483 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16484 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16485 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16486 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16490 case GNU_ABI_TAG_LINUX
:
16493 case GNU_ABI_TAG_HURD
:
16496 case GNU_ABI_TAG_SOLARIS
:
16497 osname
= "Solaris";
16499 case GNU_ABI_TAG_FREEBSD
:
16500 osname
= "FreeBSD";
16502 case GNU_ABI_TAG_NETBSD
:
16505 case GNU_ABI_TAG_SYLLABLE
:
16506 osname
= "Syllable";
16508 case GNU_ABI_TAG_NACL
:
16512 osname
= "Unknown";
16516 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16517 major
, minor
, subminor
);
16521 case NT_GNU_GOLD_VERSION
:
16525 printf (_(" Version: "));
16526 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16527 printf ("%c", pnote
->descdata
[i
]);
16534 unsigned long num_entries
, mask
;
16536 /* Hardware capabilities information. Word 0 is the number of entries.
16537 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16538 is a series of entries, where each entry is a single byte followed
16539 by a nul terminated string. The byte gives the bit number to test
16540 if enabled in the bitmask. */
16541 printf (_(" Hardware Capabilities: "));
16542 if (pnote
->descsz
< 8)
16544 error (_("<corrupt GNU_HWCAP>\n"));
16547 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16548 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16549 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16550 /* FIXME: Add code to display the entries... */
16554 case NT_GNU_PROPERTY_TYPE_0
:
16555 print_gnu_property_note (pnote
);
16559 /* Handle unrecognised types. An error message should have already been
16560 created by get_gnu_elf_note_type(), so all that we need to do is to
16561 display the data. */
16565 printf (_(" Description data: "));
16566 for (i
= 0; i
< pnote
->descsz
; ++i
)
16567 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16576 static const char *
16577 get_v850_elf_note_type (enum v850_notes n_type
)
16579 static char buff
[64];
16583 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16584 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16585 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16586 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16587 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16588 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16590 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16596 print_v850_note (Elf_Internal_Note
* pnote
)
16600 if (pnote
->descsz
!= 4)
16603 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16607 printf (_("not set\n"));
16611 switch (pnote
->type
)
16613 case V850_NOTE_ALIGNMENT
:
16616 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16617 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16621 case V850_NOTE_DATA_SIZE
:
16624 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16625 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16629 case V850_NOTE_FPU_INFO
:
16632 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16633 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16637 case V850_NOTE_MMU_INFO
:
16638 case V850_NOTE_CACHE_INFO
:
16639 case V850_NOTE_SIMD_INFO
:
16640 if (val
== EF_RH850_SIMD
)
16642 printf (_("yes\n"));
16648 /* An 'unknown note type' message will already have been displayed. */
16652 printf (_("unknown value: %x\n"), val
);
16657 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16659 unsigned int version
;
16661 switch (pnote
->type
)
16663 case NT_NETBSD_IDENT
:
16664 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16665 if ((version
/ 10000) % 100)
16666 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16667 version
, version
/ 100000000, (version
/ 1000000) % 100,
16668 (version
/ 10000) % 100 > 26 ? "Z" : "",
16669 'A' + (version
/ 10000) % 26);
16671 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16672 version
, version
/ 100000000, (version
/ 1000000) % 100,
16673 (version
/ 100) % 100);
16676 case NT_NETBSD_MARCH
:
16677 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16682 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16688 static const char *
16689 get_freebsd_elfcore_note_type (unsigned e_type
)
16693 case NT_FREEBSD_THRMISC
:
16694 return _("NT_THRMISC (thrmisc structure)");
16695 case NT_FREEBSD_PROCSTAT_PROC
:
16696 return _("NT_PROCSTAT_PROC (proc data)");
16697 case NT_FREEBSD_PROCSTAT_FILES
:
16698 return _("NT_PROCSTAT_FILES (files data)");
16699 case NT_FREEBSD_PROCSTAT_VMMAP
:
16700 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16701 case NT_FREEBSD_PROCSTAT_GROUPS
:
16702 return _("NT_PROCSTAT_GROUPS (groups data)");
16703 case NT_FREEBSD_PROCSTAT_UMASK
:
16704 return _("NT_PROCSTAT_UMASK (umask data)");
16705 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16706 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16707 case NT_FREEBSD_PROCSTAT_OSREL
:
16708 return _("NT_PROCSTAT_OSREL (osreldate data)");
16709 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16710 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16711 case NT_FREEBSD_PROCSTAT_AUXV
:
16712 return _("NT_PROCSTAT_AUXV (auxv data)");
16714 return get_note_type (e_type
);
16717 static const char *
16718 get_netbsd_elfcore_note_type (unsigned e_type
)
16720 static char buff
[64];
16722 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16724 /* NetBSD core "procinfo" structure. */
16725 return _("NetBSD procinfo structure");
16728 /* As of Jan 2002 there are no other machine-independent notes
16729 defined for NetBSD core files. If the note type is less
16730 than the start of the machine-dependent note types, we don't
16733 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16735 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16739 switch (elf_header
.e_machine
)
16741 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16742 and PT_GETFPREGS == mach+2. */
16747 case EM_SPARC32PLUS
:
16751 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16752 return _("PT_GETREGS (reg structure)");
16753 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16754 return _("PT_GETFPREGS (fpreg structure)");
16760 /* On all other arch's, PT_GETREGS == mach+1 and
16761 PT_GETFPREGS == mach+3. */
16765 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16766 return _("PT_GETREGS (reg structure)");
16767 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16768 return _("PT_GETFPREGS (fpreg structure)");
16774 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16775 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16779 static const char *
16780 get_stapsdt_note_type (unsigned e_type
)
16782 static char buff
[64];
16787 return _("NT_STAPSDT (SystemTap probe descriptors)");
16793 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16798 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16800 int addr_size
= is_32bit_elf
? 4 : 8;
16801 char *data
= pnote
->descdata
;
16802 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16803 bfd_vma pc
, base_addr
, semaphore
;
16804 char *provider
, *probe
, *arg_fmt
;
16806 pc
= byte_get ((unsigned char *) data
, addr_size
);
16808 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16810 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16814 data
+= strlen (data
) + 1;
16816 data
+= strlen (data
) + 1;
16818 data
+= strlen (data
) + 1;
16820 printf (_(" Provider: %s\n"), provider
);
16821 printf (_(" Name: %s\n"), probe
);
16822 printf (_(" Location: "));
16823 print_vma (pc
, FULL_HEX
);
16824 printf (_(", Base: "));
16825 print_vma (base_addr
, FULL_HEX
);
16826 printf (_(", Semaphore: "));
16827 print_vma (semaphore
, FULL_HEX
);
16829 printf (_(" Arguments: %s\n"), arg_fmt
);
16831 return data
== data_end
;
16834 static const char *
16835 get_ia64_vms_note_type (unsigned e_type
)
16837 static char buff
[64];
16842 return _("NT_VMS_MHD (module header)");
16844 return _("NT_VMS_LNM (language name)");
16846 return _("NT_VMS_SRC (source files)");
16848 return "NT_VMS_TITLE";
16850 return _("NT_VMS_EIDC (consistency check)");
16851 case NT_VMS_FPMODE
:
16852 return _("NT_VMS_FPMODE (FP mode)");
16853 case NT_VMS_LINKTIME
:
16854 return "NT_VMS_LINKTIME";
16855 case NT_VMS_IMGNAM
:
16856 return _("NT_VMS_IMGNAM (image name)");
16858 return _("NT_VMS_IMGID (image id)");
16859 case NT_VMS_LINKID
:
16860 return _("NT_VMS_LINKID (link id)");
16861 case NT_VMS_IMGBID
:
16862 return _("NT_VMS_IMGBID (build id)");
16863 case NT_VMS_GSTNAM
:
16864 return _("NT_VMS_GSTNAM (sym table name)");
16865 case NT_VMS_ORIG_DYN
:
16866 return "NT_VMS_ORIG_DYN";
16867 case NT_VMS_PATCHTIME
:
16868 return "NT_VMS_PATCHTIME";
16870 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16876 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16878 switch (pnote
->type
)
16881 if (pnote
->descsz
> 36)
16883 size_t l
= strlen (pnote
->descdata
+ 34);
16884 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16885 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16886 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16887 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16890 printf (_(" Invalid size\n"));
16893 printf (_(" Language: %s\n"), pnote
->descdata
);
16896 case NT_VMS_FPMODE
:
16897 printf (_(" Floating Point mode: "));
16898 printf ("0x%016" BFD_VMA_FMT
"x\n",
16899 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16901 case NT_VMS_LINKTIME
:
16902 printf (_(" Link time: "));
16904 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16907 case NT_VMS_PATCHTIME
:
16908 printf (_(" Patch time: "));
16910 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16913 case NT_VMS_ORIG_DYN
:
16914 printf (_(" Major id: %u, minor id: %u\n"),
16915 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16916 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16917 printf (_(" Last modified : "));
16919 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16920 printf (_("\n Link flags : "));
16921 printf ("0x%016" BFD_VMA_FMT
"x\n",
16922 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16923 printf (_(" Header flags: 0x%08x\n"),
16924 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16925 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16928 case NT_VMS_IMGNAM
:
16929 printf (_(" Image name: %s\n"), pnote
->descdata
);
16931 case NT_VMS_GSTNAM
:
16932 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16935 printf (_(" Image id: %s\n"), pnote
->descdata
);
16937 case NT_VMS_LINKID
:
16938 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16946 /* Print the name of the symbol associated with a build attribute
16947 that is attached to address OFFSET. */
16950 print_symbol_for_build_attribute (FILE * file
,
16951 unsigned long offset
,
16952 bfd_boolean is_open_attr
)
16954 static FILE * saved_file
= NULL
;
16955 static char * strtab
;
16956 static unsigned long strtablen
;
16957 static Elf_Internal_Sym
* symtab
;
16958 static unsigned long nsyms
;
16959 Elf_Internal_Sym
* saved_sym
= NULL
;
16960 Elf_Internal_Sym
* sym
;
16962 if (section_headers
!= NULL
16963 && (saved_file
== NULL
|| file
!= saved_file
))
16965 Elf_Internal_Shdr
* symsec
;
16967 /* Load the symbol and string sections. */
16968 for (symsec
= section_headers
;
16969 symsec
< section_headers
+ elf_header
.e_shnum
;
16972 if (symsec
->sh_type
== SHT_SYMTAB
)
16974 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
16976 if (symsec
->sh_link
< elf_header
.e_shnum
)
16978 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
16980 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
16981 1, strtab_sec
->sh_size
,
16982 _("string table"));
16983 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
16990 if (symtab
== NULL
|| strtab
== NULL
)
16996 /* Find a symbol whose value matches offset. */
16997 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
16998 if (sym
->st_value
== offset
)
17000 if (sym
->st_name
>= strtablen
)
17001 /* Huh ? This should not happen. */
17004 if (strtab
[sym
->st_name
] == 0)
17009 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17010 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17011 FUNC symbols entirely. */
17012 switch (ELF_ST_TYPE (sym
->st_info
))
17016 /* We can stop searching now. */
17017 sym
= symtab
+ nsyms
;
17025 /* Ignore function symbols. */
17032 switch (ELF_ST_BIND (sym
->st_info
))
17035 if (saved_sym
== NULL
17036 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17041 if (saved_sym
== NULL
)
17051 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17059 printf (" (%s: %s)\n",
17060 is_open_attr
? _("file") : _("func"),
17061 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
17066 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17069 static unsigned long global_offset
= 0;
17070 unsigned long offset
;
17071 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
17072 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17074 if (pnote
->descsz
== 0)
17078 printf (_(" Applies from offset %#lx\n"), global_offset
);
17083 printf (_(" Applies to func at %#lx"), global_offset
);
17084 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
17088 if (pnote
->descsz
!= desc_size
)
17090 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17091 printf (_(" <invalid descsz>"));
17095 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
17099 printf (_(" Applies from offset %#lx"), offset
);
17100 global_offset
= offset
;
17104 printf (_(" Applies to func at %#lx"), offset
);
17107 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
17111 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17113 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17114 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17115 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17117 char name_attribute
;
17118 const char * expected_types
;
17119 const char * name
= pnote
->namedata
;
17123 if (name
== NULL
|| pnote
->namesz
< 2)
17125 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17126 print_symbol (-20, _(" <corrupt name>"));
17130 switch ((name_type
= * name
))
17132 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17133 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17134 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17135 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17136 printf ("%c", * name
);
17139 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17140 print_symbol (-20, _("<unknown name type>"));
17148 switch ((name_attribute
= * name
))
17150 case GNU_BUILD_ATTRIBUTE_VERSION
:
17151 text
= _("<version>");
17152 expected_types
= string_expected
;
17155 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17156 text
= _("<stack prot>");
17157 expected_types
= "!+*";
17160 case GNU_BUILD_ATTRIBUTE_RELRO
:
17161 text
= _("<relro>");
17162 expected_types
= bool_expected
;
17165 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17166 text
= _("<stack size>");
17167 expected_types
= number_expected
;
17170 case GNU_BUILD_ATTRIBUTE_TOOL
:
17171 text
= _("<tool>");
17172 expected_types
= string_expected
;
17175 case GNU_BUILD_ATTRIBUTE_ABI
:
17177 expected_types
= "$*";
17180 case GNU_BUILD_ATTRIBUTE_PIC
:
17182 expected_types
= number_expected
;
17185 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17186 text
= _("<short enum>");
17187 expected_types
= bool_expected
;
17191 if (ISPRINT (* name
))
17193 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17195 if (len
> left
&& ! do_wide
)
17197 printf ("%.*s:", len
, name
);
17203 static char tmpbuf
[128];
17204 error (_("unrecognised byte in name field: %d\n"), * name
);
17205 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17209 expected_types
= "*$!+";
17215 printf ("%s", text
);
17216 left
-= strlen (text
);
17219 if (strchr (expected_types
, name_type
) == NULL
)
17220 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17222 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17224 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17225 (unsigned long) pnote
->namesz
,
17226 (long) (name
- pnote
->namedata
));
17230 if (left
< 1 && ! do_wide
)
17235 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17237 unsigned int bytes
;
17238 unsigned long long val
= 0;
17239 unsigned int shift
= 0;
17240 char * decoded
= NULL
;
17242 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17244 /* The -1 is because the name field is always 0 terminated, and we
17245 want to be able to ensure that the shift in the while loop below
17246 will not overflow. */
17249 if (bytes
> sizeof (val
))
17251 fprintf (stderr
, "namesz %lx name %p namedata %p\n",
17252 pnote
->namesz
, name
, pnote
->namedata
);
17253 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17255 bytes
= sizeof (val
);
17257 /* We do not bother to warn if bytes == 0 as this can
17258 happen with some early versions of the gcc plugin. */
17262 unsigned long byte
= (* name
++) & 0xff;
17264 val
|= byte
<< shift
;
17268 switch (name_attribute
)
17270 case GNU_BUILD_ATTRIBUTE_PIC
:
17273 case 0: decoded
= "static"; break;
17274 case 1: decoded
= "pic"; break;
17275 case 2: decoded
= "PIC"; break;
17276 case 3: decoded
= "pie"; break;
17277 case 4: decoded
= "PIE"; break;
17281 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17284 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17285 case 0: decoded
= "off"; break;
17286 case 1: decoded
= "on"; break;
17287 case 2: decoded
= "all"; break;
17288 case 3: decoded
= "strong"; break;
17289 case 4: decoded
= "explicit"; break;
17297 if (decoded
!= NULL
)
17299 print_symbol (-left
, decoded
);
17310 left
-= printf ("0x%llx", val
);
17312 left
-= printf ("0x%-.*llx", left
, val
);
17316 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17317 left
-= print_symbol (- left
, name
);
17319 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17320 left
-= print_symbol (- left
, "true");
17322 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17323 left
-= print_symbol (- left
, "false");
17327 if (do_wide
&& left
> 0)
17328 printf ("%-*s", left
, " ");
17333 /* Note that by the ELF standard, the name field is already null byte
17334 terminated, and namesz includes the terminating null byte.
17335 I.E. the value of namesz for the name "FSF" is 4.
17337 If the value of namesz is zero, there is no name present. */
17340 process_note (Elf_Internal_Note
* pnote
,
17343 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17346 if (pnote
->namesz
== 0)
17347 /* If there is no note name, then use the default set of
17348 note type strings. */
17349 nt
= get_note_type (pnote
->type
);
17351 else if (const_strneq (pnote
->namedata
, "GNU"))
17352 /* GNU-specific object file notes. */
17353 nt
= get_gnu_elf_note_type (pnote
->type
);
17355 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17356 /* FreeBSD-specific core file notes. */
17357 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
17359 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17360 /* NetBSD-specific core file notes. */
17361 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17363 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17364 /* NetBSD-specific core file notes. */
17365 return process_netbsd_elf_note (pnote
);
17367 else if (strneq (pnote
->namedata
, "SPU/", 4))
17369 /* SPU-specific core file notes. */
17370 nt
= pnote
->namedata
+ 4;
17374 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17375 /* VMS/ia64-specific file notes. */
17376 nt
= get_ia64_vms_note_type (pnote
->type
);
17378 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17379 nt
= get_stapsdt_note_type (pnote
->type
);
17382 /* Don't recognize this note name; just use the default set of
17383 note type strings. */
17384 nt
= get_note_type (pnote
->type
);
17388 if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17389 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17390 print_gnu_build_attribute_name (pnote
);
17392 print_symbol (-20, name
);
17395 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17397 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17399 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17400 return print_ia64_vms_note (pnote
);
17401 else if (const_strneq (pnote
->namedata
, "GNU"))
17402 return print_gnu_note (pnote
);
17403 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17404 return print_stapsdt_note (pnote
);
17405 else if (const_strneq (pnote
->namedata
, "CORE"))
17406 return print_core_note (pnote
);
17407 else if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17408 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17409 return print_gnu_build_attribute_description (pnote
, file
);
17415 printf (_(" description data: "));
17416 for (i
= 0; i
< pnote
->descsz
; i
++)
17417 printf ("%02x ", pnote
->descdata
[i
]);
17427 process_notes_at (FILE * file
,
17428 Elf_Internal_Shdr
* section
,
17432 Elf_External_Note
* pnotes
;
17433 Elf_External_Note
* external
;
17435 bfd_boolean res
= TRUE
;
17442 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17445 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17450 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17452 if (pnotes
== NULL
)
17458 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17460 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17461 (unsigned long) offset
, (unsigned long) length
);
17463 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17465 end
= (char *) pnotes
+ length
;
17466 while ((char *) external
< end
)
17468 Elf_Internal_Note inote
;
17471 char * temp
= NULL
;
17472 size_t data_remaining
= end
- (char *) external
;
17474 if (!is_ia64_vms ())
17476 /* PR binutils/15191
17477 Make sure that there is enough data to read. */
17478 min_notesz
= offsetof (Elf_External_Note
, name
);
17479 if (data_remaining
< min_notesz
)
17481 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17482 (int) data_remaining
);
17485 inote
.type
= BYTE_GET (external
->type
);
17486 inote
.namesz
= BYTE_GET (external
->namesz
);
17487 inote
.namedata
= external
->name
;
17488 inote
.descsz
= BYTE_GET (external
->descsz
);
17489 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17490 /* PR 17531: file: 3443835e. */
17491 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17493 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17494 inote
.namesz
, (long)(end
- inote
.namedata
));
17495 inote
.descdata
= inote
.namedata
;
17499 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17500 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17504 Elf64_External_VMS_Note
*vms_external
;
17506 /* PR binutils/15191
17507 Make sure that there is enough data to read. */
17508 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17509 if (data_remaining
< min_notesz
)
17511 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17512 (int) data_remaining
);
17516 vms_external
= (Elf64_External_VMS_Note
*) external
;
17517 inote
.type
= BYTE_GET (vms_external
->type
);
17518 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17519 inote
.namedata
= vms_external
->name
;
17520 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17521 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17522 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17523 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17526 if (inote
.descdata
< (char *) external
+ min_notesz
17527 || next
< (char *) external
+ min_notesz
17528 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17529 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17530 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17531 || data_remaining
< (size_t)(next
- (char *) external
))
17533 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17534 (unsigned long) ((char *) external
- (char *) pnotes
));
17535 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17536 inote
.type
, inote
.namesz
, inote
.descsz
);
17540 external
= (Elf_External_Note
*) next
;
17542 /* Verify that name is null terminated. It appears that at least
17543 one version of Linux (RedHat 6.0) generates corefiles that don't
17544 comply with the ELF spec by failing to include the null byte in
17546 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17548 temp
= (char *) malloc (inote
.namesz
+ 1);
17551 error (_("Out of memory allocating space for inote name\n"));
17556 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17557 temp
[inote
.namesz
] = 0;
17559 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17560 inote
.namedata
= temp
;
17563 if (! process_note (& inote
, file
))
17579 process_corefile_note_segments (FILE * file
)
17581 Elf_Internal_Phdr
* segment
;
17583 bfd_boolean res
= TRUE
;
17585 if (! get_program_headers (file
))
17588 for (i
= 0, segment
= program_headers
;
17589 i
< elf_header
.e_phnum
;
17592 if (segment
->p_type
== PT_NOTE
)
17593 if (! process_notes_at (file
, NULL
,
17594 (bfd_vma
) segment
->p_offset
,
17595 (bfd_vma
) segment
->p_filesz
))
17603 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17605 Elf_External_Note
* pnotes
;
17606 Elf_External_Note
* external
;
17608 bfd_boolean res
= TRUE
;
17613 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17615 if (pnotes
== NULL
)
17619 end
= (char*) pnotes
+ length
;
17621 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17622 (unsigned long) offset
, (unsigned long) length
);
17624 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17626 Elf_External_Note
* next
;
17627 Elf_Internal_Note inote
;
17629 inote
.type
= BYTE_GET (external
->type
);
17630 inote
.namesz
= BYTE_GET (external
->namesz
);
17631 inote
.namedata
= external
->name
;
17632 inote
.descsz
= BYTE_GET (external
->descsz
);
17633 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17634 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17636 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17638 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17639 inote
.descdata
= inote
.namedata
;
17643 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17645 if ( ((char *) next
> end
)
17646 || ((char *) next
< (char *) pnotes
))
17648 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17649 (unsigned long) ((char *) external
- (char *) pnotes
));
17650 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17651 inote
.type
, inote
.namesz
, inote
.descsz
);
17657 /* Prevent out-of-bounds indexing. */
17658 if ( inote
.namedata
+ inote
.namesz
> end
17659 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17661 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17662 (unsigned long) ((char *) external
- (char *) pnotes
));
17663 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17664 inote
.type
, inote
.namesz
, inote
.descsz
);
17668 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17670 if (! print_v850_note (& inote
))
17673 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17674 inote
.namesz
, inote
.descsz
);
17684 process_note_sections (FILE * file
)
17686 Elf_Internal_Shdr
* section
;
17688 unsigned int n
= 0;
17689 bfd_boolean res
= TRUE
;
17691 for (i
= 0, section
= section_headers
;
17692 i
< elf_header
.e_shnum
&& section
!= NULL
;
17695 if (section
->sh_type
== SHT_NOTE
)
17697 if (! process_notes_at (file
, section
,
17698 (bfd_vma
) section
->sh_offset
,
17699 (bfd_vma
) section
->sh_size
))
17704 if (( elf_header
.e_machine
== EM_V800
17705 || elf_header
.e_machine
== EM_V850
17706 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17707 && section
->sh_type
== SHT_RENESAS_INFO
)
17709 if (! process_v850_notes (file
,
17710 (bfd_vma
) section
->sh_offset
,
17711 (bfd_vma
) section
->sh_size
))
17718 /* Try processing NOTE segments instead. */
17719 return process_corefile_note_segments (file
);
17725 process_notes (FILE * file
)
17727 /* If we have not been asked to display the notes then do nothing. */
17731 if (elf_header
.e_type
!= ET_CORE
)
17732 return process_note_sections (file
);
17734 /* No program headers means no NOTE segment. */
17735 if (elf_header
.e_phnum
> 0)
17736 return process_corefile_note_segments (file
);
17738 printf (_("No note segments present in the core file.\n"));
17742 static unsigned char *
17743 display_public_gnu_attributes (unsigned char * start
,
17744 const unsigned char * const end
)
17746 printf (_(" Unknown GNU attribute: %s\n"), start
);
17748 start
+= strnlen ((char *) start
, end
- start
);
17749 display_raw_attribute (start
, end
);
17751 return (unsigned char *) end
;
17754 static unsigned char *
17755 display_generic_attribute (unsigned char * start
,
17757 const unsigned char * const end
)
17760 return (unsigned char *) end
;
17762 return display_tag_value (tag
, start
, end
);
17766 process_arch_specific (FILE * file
)
17771 switch (elf_header
.e_machine
)
17774 case EM_ARC_COMPACT
:
17775 case EM_ARC_COMPACT2
:
17776 return process_attributes (file
, "ARC", SHT_ARC_ATTRIBUTES
,
17777 display_arc_attribute
,
17778 display_generic_attribute
);
17780 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17781 display_arm_attribute
,
17782 display_generic_attribute
);
17785 case EM_MIPS_RS3_LE
:
17786 return process_mips_specific (file
);
17789 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17790 display_msp430x_attribute
,
17791 display_generic_attribute
);
17794 return process_nds32_specific (file
);
17798 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17799 display_power_gnu_attribute
);
17803 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17804 display_s390_gnu_attribute
);
17807 case EM_SPARC32PLUS
:
17809 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17810 display_sparc_gnu_attribute
);
17813 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17814 display_tic6x_attribute
,
17815 display_generic_attribute
);
17818 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17819 display_public_gnu_attributes
,
17820 display_generic_attribute
);
17825 get_file_header (FILE * file
)
17827 /* Read in the identity array. */
17828 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
17831 /* Determine how to read the rest of the header. */
17832 switch (elf_header
.e_ident
[EI_DATA
])
17837 byte_get
= byte_get_little_endian
;
17838 byte_put
= byte_put_little_endian
;
17841 byte_get
= byte_get_big_endian
;
17842 byte_put
= byte_put_big_endian
;
17846 /* For now we only support 32 bit and 64 bit ELF files. */
17847 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
17849 /* Read in the rest of the header. */
17852 Elf32_External_Ehdr ehdr32
;
17854 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
17857 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
17858 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
17859 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
17860 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
17861 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
17862 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
17863 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
17864 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
17865 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
17866 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
17867 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
17868 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
17869 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
17873 Elf64_External_Ehdr ehdr64
;
17875 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17876 we will not be able to cope with the 64bit data found in
17877 64 ELF files. Detect this now and abort before we start
17878 overwriting things. */
17879 if (sizeof (bfd_vma
) < 8)
17881 error (_("This instance of readelf has been built without support for a\n\
17882 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17886 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
17889 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
17890 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
17891 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
17892 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
17893 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
17894 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
17895 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
17896 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
17897 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
17898 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
17899 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
17900 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
17901 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
17904 if (elf_header
.e_shoff
)
17906 /* There may be some extensions in the first section header. Don't
17907 bomb if we can't read it. */
17909 get_32bit_section_headers (file
, TRUE
);
17911 get_64bit_section_headers (file
, TRUE
);
17917 /* Process one ELF object file according to the command line options.
17918 This file may actually be stored in an archive. The file is
17919 positioned at the start of the ELF object. Returns TRUE if no
17920 problems were encountered, FALSE otherwise. */
17923 process_object (char * file_name
, FILE * file
)
17926 bfd_boolean res
= TRUE
;
17928 if (! get_file_header (file
))
17930 error (_("%s: Failed to read file header\n"), file_name
);
17934 /* Initialise per file variables. */
17935 for (i
= ARRAY_SIZE (version_info
); i
--;)
17936 version_info
[i
] = 0;
17938 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
17939 dynamic_info
[i
] = 0;
17940 dynamic_info_DT_GNU_HASH
= 0;
17942 /* Process the file. */
17944 printf (_("\nFile: %s\n"), file_name
);
17946 /* Initialise the dump_sects array from the cmdline_dump_sects array.
17947 Note we do this even if cmdline_dump_sects is empty because we
17948 must make sure that the dump_sets array is zeroed out before each
17949 object file is processed. */
17950 if (num_dump_sects
> num_cmdline_dump_sects
)
17951 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
17953 if (num_cmdline_dump_sects
> 0)
17955 if (num_dump_sects
== 0)
17956 /* A sneaky way of allocating the dump_sects array. */
17957 request_dump_bynumber (num_cmdline_dump_sects
, 0);
17959 assert (num_dump_sects
>= num_cmdline_dump_sects
);
17960 memcpy (dump_sects
, cmdline_dump_sects
,
17961 num_cmdline_dump_sects
* sizeof (* dump_sects
));
17964 if (! process_file_header ())
17967 if (! process_section_headers (file
))
17969 /* Without loaded section headers we cannot process lots of things. */
17970 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
17972 if (! do_using_dynamic
)
17973 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
17976 if (! process_section_groups (file
))
17977 /* Without loaded section groups we cannot process unwind. */
17980 if (process_program_headers (file
))
17981 process_dynamic_section (file
);
17985 if (! process_relocs (file
))
17988 if (! process_unwind (file
))
17991 if (! process_symbol_table (file
))
17994 if (! process_syminfo (file
))
17997 if (! process_version_sections (file
))
18000 if (! process_section_contents (file
))
18003 if (! process_notes (file
))
18006 if (! process_gnu_liblist (file
))
18009 if (! process_arch_specific (file
))
18012 if (program_headers
)
18014 free (program_headers
);
18015 program_headers
= NULL
;
18018 if (section_headers
)
18020 free (section_headers
);
18021 section_headers
= NULL
;
18026 free (string_table
);
18027 string_table
= NULL
;
18028 string_table_length
= 0;
18031 if (dynamic_strings
)
18033 free (dynamic_strings
);
18034 dynamic_strings
= NULL
;
18035 dynamic_strings_length
= 0;
18038 if (dynamic_symbols
)
18040 free (dynamic_symbols
);
18041 dynamic_symbols
= NULL
;
18042 num_dynamic_syms
= 0;
18045 if (dynamic_syminfo
)
18047 free (dynamic_syminfo
);
18048 dynamic_syminfo
= NULL
;
18051 if (dynamic_section
)
18053 free (dynamic_section
);
18054 dynamic_section
= NULL
;
18057 if (section_headers_groups
)
18059 free (section_headers_groups
);
18060 section_headers_groups
= NULL
;
18063 if (section_groups
)
18065 struct group_list
* g
;
18066 struct group_list
* next
;
18068 for (i
= 0; i
< group_count
; i
++)
18070 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18077 free (section_groups
);
18078 section_groups
= NULL
;
18081 free_debug_memory ();
18086 /* Process an ELF archive.
18087 On entry the file is positioned just after the ARMAG string.
18088 Returns TRUE upon success, FALSE otherwise. */
18091 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
18093 struct archive_info arch
;
18094 struct archive_info nested_arch
;
18096 bfd_boolean ret
= TRUE
;
18100 /* The ARCH structure is used to hold information about this archive. */
18101 arch
.file_name
= NULL
;
18103 arch
.index_array
= NULL
;
18104 arch
.sym_table
= NULL
;
18105 arch
.longnames
= NULL
;
18107 /* The NESTED_ARCH structure is used as a single-item cache of information
18108 about a nested archive (when members of a thin archive reside within
18109 another regular archive file). */
18110 nested_arch
.file_name
= NULL
;
18111 nested_arch
.file
= NULL
;
18112 nested_arch
.index_array
= NULL
;
18113 nested_arch
.sym_table
= NULL
;
18114 nested_arch
.longnames
= NULL
;
18116 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
18122 if (do_archive_index
)
18124 if (arch
.sym_table
== NULL
)
18125 error (_("%s: unable to dump the index as none was found\n"), file_name
);
18128 unsigned long i
, l
;
18129 unsigned long current_pos
;
18131 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18132 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18133 current_pos
= ftell (file
);
18135 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18137 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18139 char * member_name
;
18141 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18143 if (member_name
!= NULL
)
18145 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18147 if (qualified_name
!= NULL
)
18149 printf (_("Contents of binary %s at offset "), qualified_name
);
18150 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18152 free (qualified_name
);
18157 if (l
>= arch
.sym_size
)
18159 error (_("%s: end of the symbol table reached before the end of the index\n"),
18164 /* PR 17531: file: 0b6630b2. */
18165 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18166 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18169 if (arch
.uses_64bit_indicies
)
18174 if (l
< arch
.sym_size
)
18176 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18177 file_name
, arch
.sym_size
- l
);
18181 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
18183 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
18189 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18190 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18191 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18192 && !do_section_groups
&& !do_dyn_syms
)
18194 ret
= TRUE
; /* Archive index only. */
18203 char * qualified_name
;
18205 /* Read the next archive header. */
18206 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18208 error (_("%s: failed to seek to next archive header\n"), file_name
);
18211 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
18212 if (got
!= sizeof arch
.arhdr
)
18216 error (_("%s: failed to read archive header\n"), file_name
);
18220 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18222 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18227 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18229 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18230 if (archive_file_size
& 01)
18231 ++archive_file_size
;
18233 name
= get_archive_member_name (&arch
, &nested_arch
);
18236 error (_("%s: bad archive file name\n"), file_name
);
18240 namelen
= strlen (name
);
18242 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18243 if (qualified_name
== NULL
)
18245 error (_("%s: bad archive file name\n"), file_name
);
18250 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18252 /* This is a proxy for an external member of a thin archive. */
18253 FILE * member_file
;
18254 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
18256 if (member_file_name
== NULL
)
18262 member_file
= fopen (member_file_name
, "rb");
18263 if (member_file
== NULL
)
18265 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18266 free (member_file_name
);
18271 archive_file_offset
= arch
.nested_member_origin
;
18273 if (! process_object (qualified_name
, member_file
))
18276 fclose (member_file
);
18277 free (member_file_name
);
18279 else if (is_thin_archive
)
18281 /* PR 15140: Allow for corrupt thin archives. */
18282 if (nested_arch
.file
== NULL
)
18284 error (_("%s: contains corrupt thin archive: %s\n"),
18290 /* This is a proxy for a member of a nested archive. */
18291 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18293 /* The nested archive file will have been opened and setup by
18294 get_archive_member_name. */
18295 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18297 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
18302 if (! process_object (qualified_name
, nested_arch
.file
))
18307 archive_file_offset
= arch
.next_arhdr_offset
;
18308 arch
.next_arhdr_offset
+= archive_file_size
;
18310 if (! process_object (qualified_name
, file
))
18314 if (dump_sects
!= NULL
)
18318 num_dump_sects
= 0;
18321 free (qualified_name
);
18325 if (nested_arch
.file
!= NULL
)
18326 fclose (nested_arch
.file
);
18327 release_archive (&nested_arch
);
18328 release_archive (&arch
);
18334 process_file (char * file_name
)
18337 struct stat statbuf
;
18338 char armag
[SARMAG
];
18339 bfd_boolean ret
= TRUE
;
18341 if (stat (file_name
, &statbuf
) < 0)
18343 if (errno
== ENOENT
)
18344 error (_("'%s': No such file\n"), file_name
);
18346 error (_("Could not locate '%s'. System error message: %s\n"),
18347 file_name
, strerror (errno
));
18351 if (! S_ISREG (statbuf
.st_mode
))
18353 error (_("'%s' is not an ordinary file\n"), file_name
);
18357 file
= fopen (file_name
, "rb");
18360 error (_("Input file '%s' is not readable.\n"), file_name
);
18364 if (fread (armag
, SARMAG
, 1, file
) != 1)
18366 error (_("%s: Failed to read file's magic number\n"), file_name
);
18371 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18373 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18375 if (! process_archive (file_name
, file
, FALSE
))
18378 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18380 if ( ! process_archive (file_name
, file
, TRUE
))
18385 if (do_archive_index
)
18386 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18390 archive_file_size
= archive_file_offset
= 0;
18392 if (! process_object (file_name
, file
))
18397 current_file_size
= 0;
18402 #ifdef SUPPORT_DISASSEMBLY
18403 /* Needed by the i386 disassembler. For extra credit, someone could
18404 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18408 print_address (unsigned int addr
, FILE * outfile
)
18410 fprintf (outfile
,"0x%8.8x", addr
);
18413 /* Needed by the i386 disassembler. */
18415 db_task_printsym (unsigned int addr
)
18417 print_address (addr
, stderr
);
18422 main (int argc
, char ** argv
)
18426 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18427 setlocale (LC_MESSAGES
, "");
18429 #if defined (HAVE_SETLOCALE)
18430 setlocale (LC_CTYPE
, "");
18432 bindtextdomain (PACKAGE
, LOCALEDIR
);
18433 textdomain (PACKAGE
);
18435 expandargv (&argc
, &argv
);
18437 parse_args (argc
, argv
);
18439 if (num_dump_sects
> 0)
18441 /* Make a copy of the dump_sects array. */
18442 cmdline_dump_sects
= (dump_type
*)
18443 malloc (num_dump_sects
* sizeof (* dump_sects
));
18444 if (cmdline_dump_sects
== NULL
)
18445 error (_("Out of memory allocating dump request table.\n"));
18448 memcpy (cmdline_dump_sects
, dump_sects
,
18449 num_dump_sects
* sizeof (* dump_sects
));
18450 num_cmdline_dump_sects
= num_dump_sects
;
18454 if (optind
< (argc
- 1))
18456 else if (optind
>= argc
)
18458 warn (_("Nothing to do.\n"));
18463 while (optind
< argc
)
18464 if (! process_file (argv
[optind
++]))
18467 if (dump_sects
!= NULL
)
18469 if (cmdline_dump_sects
!= NULL
)
18470 free (cmdline_dump_sects
);
18472 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;