1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/riscv.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/wasm32.h"
155 #include "elf/x86-64.h"
156 #include "elf/xc16x.h"
157 #include "elf/xgate.h"
158 #include "elf/xstormy16.h"
159 #include "elf/xtensa.h"
162 #include "libiberty.h"
163 #include "safe-ctype.h"
164 #include "filenames.h"
167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
170 typedef struct elf_section_list
172 Elf_Internal_Shdr
* hdr
;
173 struct elf_section_list
* next
;
176 char * program_name
= "readelf";
177 static unsigned long archive_file_offset
;
178 static unsigned long archive_file_size
;
179 static bfd_size_type current_file_size
;
180 static unsigned long dynamic_addr
;
181 static bfd_size_type dynamic_size
;
182 static size_t dynamic_nent
;
183 static char * dynamic_strings
;
184 static unsigned long dynamic_strings_length
;
185 static char * string_table
;
186 static unsigned long string_table_length
;
187 static unsigned long num_dynamic_syms
;
188 static Elf_Internal_Sym
* dynamic_symbols
;
189 static Elf_Internal_Syminfo
* dynamic_syminfo
;
190 static unsigned long dynamic_syminfo_offset
;
191 static unsigned int dynamic_syminfo_nent
;
192 static char program_interpreter
[PATH_MAX
];
193 static bfd_vma dynamic_info
[DT_ENCODING
];
194 static bfd_vma dynamic_info_DT_GNU_HASH
;
195 static bfd_vma version_info
[16];
196 static Elf_Internal_Ehdr elf_header
;
197 static Elf_Internal_Shdr
* section_headers
;
198 static Elf_Internal_Phdr
* program_headers
;
199 static Elf_Internal_Dyn
* dynamic_section
;
200 static elf_section_list
* symtab_shndx_list
;
201 static bfd_boolean show_name
= FALSE
;
202 static bfd_boolean do_dynamic
= FALSE
;
203 static bfd_boolean do_syms
= FALSE
;
204 static bfd_boolean do_dyn_syms
= FALSE
;
205 static bfd_boolean do_reloc
= FALSE
;
206 static bfd_boolean do_sections
= FALSE
;
207 static bfd_boolean do_section_groups
= FALSE
;
208 static bfd_boolean do_section_details
= FALSE
;
209 static bfd_boolean do_segments
= FALSE
;
210 static bfd_boolean do_unwind
= FALSE
;
211 static bfd_boolean do_using_dynamic
= FALSE
;
212 static bfd_boolean do_header
= FALSE
;
213 static bfd_boolean do_dump
= FALSE
;
214 static bfd_boolean do_version
= FALSE
;
215 static bfd_boolean do_histogram
= FALSE
;
216 static bfd_boolean do_debugging
= FALSE
;
217 static bfd_boolean do_arch
= FALSE
;
218 static bfd_boolean do_notes
= FALSE
;
219 static bfd_boolean do_archive_index
= FALSE
;
220 static bfd_boolean is_32bit_elf
= FALSE
;
221 static bfd_boolean decompress_dumps
= FALSE
;
225 struct group_list
* next
;
226 unsigned int section_index
;
231 struct group_list
* root
;
232 unsigned int group_index
;
235 static size_t group_count
;
236 static struct group
* section_groups
;
237 static struct group
** section_headers_groups
;
240 /* Flag bits indicating particular types of dump. */
241 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
242 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
243 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
244 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
245 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
247 typedef unsigned char dump_type
;
249 /* A linked list of the section names for which dumps were requested. */
250 struct dump_list_entry
254 struct dump_list_entry
* next
;
256 static struct dump_list_entry
* dump_sects_byname
;
258 /* A dynamic array of flags indicating for which sections a dump
259 has been requested via command line switches. */
260 static dump_type
* cmdline_dump_sects
= NULL
;
261 static unsigned int num_cmdline_dump_sects
= 0;
263 /* A dynamic array of flags indicating for which sections a dump of
264 some kind has been requested. It is reset on a per-object file
265 basis and then initialised from the cmdline_dump_sects array,
266 the results of interpreting the -w switch, and the
267 dump_sects_byname list. */
268 static dump_type
* dump_sects
= NULL
;
269 static unsigned int num_dump_sects
= 0;
272 /* How to print a vma value. */
273 typedef enum print_mode
285 /* Versioned symbol info. */
286 enum versioned_symbol_info
293 static const char * get_symbol_version_string
294 (FILE *, bfd_boolean
, const char *, unsigned long, unsigned,
295 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
299 #define SECTION_NAME(X) \
300 ((X) == NULL ? _("<none>") \
301 : string_table == NULL ? _("<no-name>") \
302 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
303 : string_table + (X)->sh_name))
305 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
307 #define GET_ELF_SYMBOLS(file, section, sym_count) \
308 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
309 : get_64bit_elf_symbols (file, section, sym_count))
311 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
313 already been called and verified that the string exists. */
314 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
316 #define REMOVE_ARCH_BITS(ADDR) \
319 if (elf_header.e_machine == EM_ARM) \
324 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
325 the offset of the current archive member, if we are examining an archive.
326 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
327 using malloc and fill that. In either case return the pointer to the start of
328 the retrieved data or NULL if something went wrong. If something does go wrong
329 and REASON is not NULL then emit an error message using REASON as part of the
333 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
334 bfd_size_type nmemb
, const char * reason
)
337 bfd_size_type amt
= size
* nmemb
;
339 if (size
== 0 || nmemb
== 0)
342 /* If the size_t type is smaller than the bfd_size_type, eg because
343 you are building a 32-bit tool on a 64-bit host, then make sure
344 that when the sizes are cast to (size_t) no information is lost. */
345 if (sizeof (size_t) < sizeof (bfd_size_type
)
346 && ( (bfd_size_type
) ((size_t) size
) != size
347 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
350 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT
"x"
351 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
352 nmemb
, size
, reason
);
356 /* Check for size overflow. */
360 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT
"x"
361 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
362 nmemb
, size
, reason
);
366 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
367 attempting to allocate memory when the read is bound to fail. */
368 if (amt
> current_file_size
369 || offset
+ archive_file_offset
+ amt
> current_file_size
)
372 error (_("Reading 0x%" BFD_VMA_FMT
"x"
373 " bytes extends past end of file for %s\n"),
378 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
381 error (_("Unable to seek to 0x%lx for %s\n"),
382 archive_file_offset
+ offset
, reason
);
389 /* Check for overflow. */
390 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
391 /* + 1 so that we can '\0' terminate invalid string table sections. */
392 mvar
= malloc ((size_t) amt
+ 1);
397 error (_("Out of memory allocating 0x%" BFD_VMA_FMT
"x"
403 ((char *) mvar
)[amt
] = '\0';
406 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
409 error (_("Unable to read in 0x%" BFD_VMA_FMT
"x bytes of %s\n"),
419 /* Print a VMA value in the MODE specified.
420 Returns the number of characters displayed. */
423 print_vma (bfd_vma vma
, print_mode mode
)
435 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
442 return printf ("%5" BFD_VMA_FMT
"d", vma
);
448 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
451 return printf ("%" BFD_VMA_FMT
"d", vma
);
454 return printf ("%" BFD_VMA_FMT
"u", vma
);
457 /* FIXME: Report unrecognised mode ? */
462 /* Display a symbol on stdout. Handles the display of control characters and
463 multibye characters (assuming the host environment supports them).
465 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
467 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
468 padding as necessary.
470 Returns the number of emitted characters. */
473 print_symbol (signed int width
, const char *symbol
)
475 bfd_boolean extra_padding
= FALSE
;
476 signed int num_printed
= 0;
477 #ifdef HAVE_MBSTATE_T
480 unsigned int width_remaining
;
484 /* Keep the width positive. This also helps. */
486 extra_padding
= TRUE
;
491 /* Set the remaining width to a very large value.
492 This simplifies the code below. */
493 width_remaining
= INT_MAX
;
495 width_remaining
= width
;
497 #ifdef HAVE_MBSTATE_T
498 /* Initialise the multibyte conversion state. */
499 memset (& state
, 0, sizeof (state
));
502 while (width_remaining
)
505 const char c
= *symbol
++;
510 /* Do not print control characters directly as they can affect terminal
511 settings. Such characters usually appear in the names generated
512 by the assembler for local labels. */
515 if (width_remaining
< 2)
518 printf ("^%c", c
+ 0x40);
519 width_remaining
-= 2;
522 else if (ISPRINT (c
))
530 #ifdef HAVE_MBSTATE_T
533 /* Let printf do the hard work of displaying multibyte characters. */
534 printf ("%.1s", symbol
- 1);
538 #ifdef HAVE_MBSTATE_T
539 /* Try to find out how many bytes made up the character that was
540 just printed. Advance the symbol pointer past the bytes that
542 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
546 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
551 if (extra_padding
&& num_printed
< width
)
553 /* Fill in the remaining spaces. */
554 printf ("%-*s", width
- num_printed
, " ");
561 /* Returns a pointer to a static buffer containing a printable version of
562 the given section's name. Like print_symbol, except that it does not try
563 to print multibyte characters, it just interprets them as hex values. */
566 printable_section_name (const Elf_Internal_Shdr
* sec
)
568 #define MAX_PRINT_SEC_NAME_LEN 128
569 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
570 const char * name
= SECTION_NAME (sec
);
571 char * buf
= sec_name_buf
;
573 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
575 while ((c
= * name
++) != 0)
586 else if (ISPRINT (c
))
593 static char hex
[17] = "0123456789ABCDEF";
598 * buf
++ = hex
[(c
& 0xf0) >> 4];
599 * buf
++ = hex
[c
& 0x0f];
613 printable_section_name_from_index (unsigned long ndx
)
615 if (ndx
>= elf_header
.e_shnum
)
616 return _("<corrupt>");
618 return printable_section_name (section_headers
+ ndx
);
621 /* Return a pointer to section NAME, or NULL if no such section exists. */
623 static Elf_Internal_Shdr
*
624 find_section (const char * name
)
628 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
629 if (streq (SECTION_NAME (section_headers
+ i
), name
))
630 return section_headers
+ i
;
635 /* Return a pointer to a section containing ADDR, or NULL if no such
638 static Elf_Internal_Shdr
*
639 find_section_by_address (bfd_vma addr
)
643 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
645 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
646 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
653 static Elf_Internal_Shdr
*
654 find_section_by_type (unsigned int type
)
658 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
660 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
661 if (sec
->sh_type
== type
)
668 /* Return a pointer to section NAME, or NULL if no such section exists,
669 restricted to the list of sections given in SET. */
671 static Elf_Internal_Shdr
*
672 find_section_in_set (const char * name
, unsigned int * set
)
678 while ((i
= *set
++) > 0)
680 /* See PR 21156 for a reproducer. */
681 if (i
>= elf_header
.e_shnum
)
682 continue; /* FIXME: Should we issue an error message ? */
684 if (streq (SECTION_NAME (section_headers
+ i
), name
))
685 return section_headers
+ i
;
689 return find_section (name
);
692 /* Read an unsigned LEB128 encoded value from DATA.
693 Set *LENGTH_RETURN to the number of bytes read. */
695 static inline unsigned long
696 read_uleb128 (unsigned char * data
,
697 unsigned int * length_return
,
698 const unsigned char * const end
)
700 return read_leb128 (data
, length_return
, FALSE
, end
);
703 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
704 This OS has so many departures from the ELF standard that we test it at
707 static inline bfd_boolean
710 return elf_header
.e_machine
== EM_IA_64
711 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
714 /* Guess the relocation size commonly used by the specific machines. */
717 guess_is_rela (unsigned int e_machine
)
721 /* Targets that use REL relocations. */
736 /* Targets that use RELA relocations. */
740 case EM_ADAPTEVA_EPIPHANY
:
742 case EM_ALTERA_NIOS2
:
745 case EM_ARC_COMPACT2
:
765 case EM_LATTICEMICO32
:
774 case EM_CYGNUS_MN10200
:
776 case EM_CYGNUS_MN10300
:
812 case EM_MICROBLAZE_OLD
:
834 warn (_("Don't know about relocations on this machine architecture\n"));
839 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
840 Returns TRUE upon success, FALSE otherwise. If successful then a
841 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
842 and the number of relocs loaded is placed in *NRELASP. It is the caller's
843 responsibility to free the allocated buffer. */
846 slurp_rela_relocs (FILE * file
,
847 unsigned long rel_offset
,
848 unsigned long rel_size
,
849 Elf_Internal_Rela
** relasp
,
850 unsigned long * nrelasp
)
852 Elf_Internal_Rela
* relas
;
858 Elf32_External_Rela
* erelas
;
860 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
861 rel_size
, _("32-bit relocation data"));
865 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
867 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
868 sizeof (Elf_Internal_Rela
));
873 error (_("out of memory parsing relocs\n"));
877 for (i
= 0; i
< nrelas
; i
++)
879 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
880 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
881 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
888 Elf64_External_Rela
* erelas
;
890 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
891 rel_size
, _("64-bit relocation data"));
895 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
897 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
898 sizeof (Elf_Internal_Rela
));
903 error (_("out of memory parsing relocs\n"));
907 for (i
= 0; i
< nrelas
; i
++)
909 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
910 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
911 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
913 /* The #ifdef BFD64 below is to prevent a compile time
914 warning. We know that if we do not have a 64 bit data
915 type that we will never execute this code anyway. */
917 if (elf_header
.e_machine
== EM_MIPS
918 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
920 /* In little-endian objects, r_info isn't really a
921 64-bit little-endian value: it has a 32-bit
922 little-endian symbol index followed by four
923 individual byte fields. Reorder INFO
925 bfd_vma inf
= relas
[i
].r_info
;
926 inf
= (((inf
& 0xffffffff) << 32)
927 | ((inf
>> 56) & 0xff)
928 | ((inf
>> 40) & 0xff00)
929 | ((inf
>> 24) & 0xff0000)
930 | ((inf
>> 8) & 0xff000000));
931 relas
[i
].r_info
= inf
;
944 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
945 Returns TRUE upon success, FALSE otherwise. If successful then a
946 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
947 and the number of relocs loaded is placed in *NRELSP. It is the caller's
948 responsibility to free the allocated buffer. */
951 slurp_rel_relocs (FILE * file
,
952 unsigned long rel_offset
,
953 unsigned long rel_size
,
954 Elf_Internal_Rela
** relsp
,
955 unsigned long * nrelsp
)
957 Elf_Internal_Rela
* rels
;
963 Elf32_External_Rel
* erels
;
965 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
966 rel_size
, _("32-bit relocation data"));
970 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
972 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
977 error (_("out of memory parsing relocs\n"));
981 for (i
= 0; i
< nrels
; i
++)
983 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
984 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
985 rels
[i
].r_addend
= 0;
992 Elf64_External_Rel
* erels
;
994 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
995 rel_size
, _("64-bit relocation data"));
999 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1001 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1006 error (_("out of memory parsing relocs\n"));
1010 for (i
= 0; i
< nrels
; i
++)
1012 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1013 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1014 rels
[i
].r_addend
= 0;
1016 /* The #ifdef BFD64 below is to prevent a compile time
1017 warning. We know that if we do not have a 64 bit data
1018 type that we will never execute this code anyway. */
1020 if (elf_header
.e_machine
== EM_MIPS
1021 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1023 /* In little-endian objects, r_info isn't really a
1024 64-bit little-endian value: it has a 32-bit
1025 little-endian symbol index followed by four
1026 individual byte fields. Reorder INFO
1028 bfd_vma inf
= rels
[i
].r_info
;
1029 inf
= (((inf
& 0xffffffff) << 32)
1030 | ((inf
>> 56) & 0xff)
1031 | ((inf
>> 40) & 0xff00)
1032 | ((inf
>> 24) & 0xff0000)
1033 | ((inf
>> 8) & 0xff000000));
1034 rels
[i
].r_info
= inf
;
1047 /* Returns the reloc type extracted from the reloc info field. */
1050 get_reloc_type (bfd_vma reloc_info
)
1053 return ELF32_R_TYPE (reloc_info
);
1055 switch (elf_header
.e_machine
)
1058 /* Note: We assume that reloc_info has already been adjusted for us. */
1059 return ELF64_MIPS_R_TYPE (reloc_info
);
1062 return ELF64_R_TYPE_ID (reloc_info
);
1065 return ELF64_R_TYPE (reloc_info
);
1069 /* Return the symbol index extracted from the reloc info field. */
1072 get_reloc_symindex (bfd_vma reloc_info
)
1074 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1077 static inline bfd_boolean
1078 uses_msp430x_relocs (void)
1081 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1082 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1083 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1084 /* TI compiler uses ELFOSABI_NONE. */
1085 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1088 /* Display the contents of the relocation data found at the specified
1092 dump_relocations (FILE * file
,
1093 unsigned long rel_offset
,
1094 unsigned long rel_size
,
1095 Elf_Internal_Sym
* symtab
,
1096 unsigned long nsyms
,
1098 unsigned long strtablen
,
1100 bfd_boolean is_dynsym
)
1103 Elf_Internal_Rela
* rels
;
1104 bfd_boolean res
= TRUE
;
1106 if (is_rela
== UNKNOWN
)
1107 is_rela
= guess_is_rela (elf_header
.e_machine
);
1111 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1116 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1125 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1127 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1132 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1134 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1142 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1144 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1149 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1151 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1155 for (i
= 0; i
< rel_size
; i
++)
1160 bfd_vma symtab_index
;
1163 offset
= rels
[i
].r_offset
;
1164 inf
= rels
[i
].r_info
;
1166 type
= get_reloc_type (inf
);
1167 symtab_index
= get_reloc_symindex (inf
);
1171 printf ("%8.8lx %8.8lx ",
1172 (unsigned long) offset
& 0xffffffff,
1173 (unsigned long) inf
& 0xffffffff);
1177 #if BFD_HOST_64BIT_LONG
1179 ? "%16.16lx %16.16lx "
1180 : "%12.12lx %12.12lx ",
1182 #elif BFD_HOST_64BIT_LONG_LONG
1185 ? "%16.16llx %16.16llx "
1186 : "%12.12llx %12.12llx ",
1190 ? "%16.16I64x %16.16I64x "
1191 : "%12.12I64x %12.12I64x ",
1196 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1197 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1198 _bfd_int64_high (offset
),
1199 _bfd_int64_low (offset
),
1200 _bfd_int64_high (inf
),
1201 _bfd_int64_low (inf
));
1205 switch (elf_header
.e_machine
)
1212 rtype
= elf_aarch64_reloc_type (type
);
1216 case EM_CYGNUS_M32R
:
1217 rtype
= elf_m32r_reloc_type (type
);
1222 rtype
= elf_i386_reloc_type (type
);
1227 rtype
= elf_m68hc11_reloc_type (type
);
1231 rtype
= elf_m68k_reloc_type (type
);
1235 rtype
= elf_i960_reloc_type (type
);
1240 rtype
= elf_avr_reloc_type (type
);
1243 case EM_OLD_SPARCV9
:
1244 case EM_SPARC32PLUS
:
1247 rtype
= elf_sparc_reloc_type (type
);
1251 rtype
= elf_spu_reloc_type (type
);
1255 rtype
= v800_reloc_type (type
);
1258 case EM_CYGNUS_V850
:
1259 rtype
= v850_reloc_type (type
);
1263 case EM_CYGNUS_D10V
:
1264 rtype
= elf_d10v_reloc_type (type
);
1268 case EM_CYGNUS_D30V
:
1269 rtype
= elf_d30v_reloc_type (type
);
1273 rtype
= elf_dlx_reloc_type (type
);
1277 rtype
= elf_sh_reloc_type (type
);
1281 case EM_CYGNUS_MN10300
:
1282 rtype
= elf_mn10300_reloc_type (type
);
1286 case EM_CYGNUS_MN10200
:
1287 rtype
= elf_mn10200_reloc_type (type
);
1291 case EM_CYGNUS_FR30
:
1292 rtype
= elf_fr30_reloc_type (type
);
1296 rtype
= elf_frv_reloc_type (type
);
1300 rtype
= elf_ft32_reloc_type (type
);
1304 rtype
= elf_mcore_reloc_type (type
);
1308 rtype
= elf_mmix_reloc_type (type
);
1312 rtype
= elf_moxie_reloc_type (type
);
1316 if (uses_msp430x_relocs ())
1318 rtype
= elf_msp430x_reloc_type (type
);
1323 rtype
= elf_msp430_reloc_type (type
);
1327 rtype
= elf_nds32_reloc_type (type
);
1331 rtype
= elf_ppc_reloc_type (type
);
1335 rtype
= elf_ppc64_reloc_type (type
);
1339 case EM_MIPS_RS3_LE
:
1340 rtype
= elf_mips_reloc_type (type
);
1344 rtype
= elf_riscv_reloc_type (type
);
1348 rtype
= elf_alpha_reloc_type (type
);
1352 rtype
= elf_arm_reloc_type (type
);
1356 case EM_ARC_COMPACT
:
1357 case EM_ARC_COMPACT2
:
1358 rtype
= elf_arc_reloc_type (type
);
1362 rtype
= elf_hppa_reloc_type (type
);
1368 rtype
= elf_h8_reloc_type (type
);
1372 rtype
= elf_or1k_reloc_type (type
);
1377 rtype
= elf_pj_reloc_type (type
);
1380 rtype
= elf_ia64_reloc_type (type
);
1384 rtype
= elf_cris_reloc_type (type
);
1388 rtype
= elf_i860_reloc_type (type
);
1394 rtype
= elf_x86_64_reloc_type (type
);
1398 rtype
= i370_reloc_type (type
);
1403 rtype
= elf_s390_reloc_type (type
);
1407 rtype
= elf_score_reloc_type (type
);
1411 rtype
= elf_xstormy16_reloc_type (type
);
1415 rtype
= elf_crx_reloc_type (type
);
1419 rtype
= elf_vax_reloc_type (type
);
1423 rtype
= elf_visium_reloc_type (type
);
1426 case EM_ADAPTEVA_EPIPHANY
:
1427 rtype
= elf_epiphany_reloc_type (type
);
1432 rtype
= elf_ip2k_reloc_type (type
);
1436 rtype
= elf_iq2000_reloc_type (type
);
1441 rtype
= elf_xtensa_reloc_type (type
);
1444 case EM_LATTICEMICO32
:
1445 rtype
= elf_lm32_reloc_type (type
);
1450 rtype
= elf_m32c_reloc_type (type
);
1454 rtype
= elf_mt_reloc_type (type
);
1458 rtype
= elf_bfin_reloc_type (type
);
1462 rtype
= elf_mep_reloc_type (type
);
1466 rtype
= elf_cr16_reloc_type (type
);
1470 case EM_MICROBLAZE_OLD
:
1471 rtype
= elf_microblaze_reloc_type (type
);
1475 rtype
= elf_rl78_reloc_type (type
);
1479 rtype
= elf_rx_reloc_type (type
);
1483 rtype
= elf_metag_reloc_type (type
);
1488 rtype
= elf_xc16x_reloc_type (type
);
1492 rtype
= elf_tic6x_reloc_type (type
);
1496 rtype
= elf_tilegx_reloc_type (type
);
1500 rtype
= elf_tilepro_reloc_type (type
);
1503 case EM_WEBASSEMBLY
:
1504 rtype
= elf_wasm32_reloc_type (type
);
1508 rtype
= elf_xgate_reloc_type (type
);
1511 case EM_ALTERA_NIOS2
:
1512 rtype
= elf_nios2_reloc_type (type
);
1516 rtype
= elf_pru_reloc_type (type
);
1521 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1523 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1525 if (elf_header
.e_machine
== EM_ALPHA
1527 && streq (rtype
, "R_ALPHA_LITUSE")
1530 switch (rels
[i
].r_addend
)
1532 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1533 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1534 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1535 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1536 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1537 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1538 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1539 default: rtype
= NULL
;
1543 printf (" (%s)", rtype
);
1547 printf (_("<unknown addend: %lx>"),
1548 (unsigned long) rels
[i
].r_addend
);
1552 else if (symtab_index
)
1554 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1556 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1561 Elf_Internal_Sym
* psym
;
1562 const char * version_string
;
1563 enum versioned_symbol_info sym_info
;
1564 unsigned short vna_other
;
1566 psym
= symtab
+ symtab_index
;
1569 = get_symbol_version_string (file
, is_dynsym
,
1578 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1582 unsigned int width
= is_32bit_elf
? 8 : 14;
1584 /* Relocations against GNU_IFUNC symbols do not use the value
1585 of the symbol as the address to relocate against. Instead
1586 they invoke the function named by the symbol and use its
1587 result as the address for relocation.
1589 To indicate this to the user, do not display the value of
1590 the symbol in the "Symbols's Value" field. Instead show
1591 its name followed by () as a hint that the symbol is
1595 || psym
->st_name
== 0
1596 || psym
->st_name
>= strtablen
)
1599 name
= strtab
+ psym
->st_name
;
1601 len
= print_symbol (width
, name
);
1603 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1605 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1609 print_vma (psym
->st_value
, LONG_HEX
);
1611 printf (is_32bit_elf
? " " : " ");
1614 if (psym
->st_name
== 0)
1616 const char * sec_name
= "<null>";
1619 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1621 if (psym
->st_shndx
< elf_header
.e_shnum
)
1622 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1623 else if (psym
->st_shndx
== SHN_ABS
)
1625 else if (psym
->st_shndx
== SHN_COMMON
)
1626 sec_name
= "COMMON";
1627 else if ((elf_header
.e_machine
== EM_MIPS
1628 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1629 || (elf_header
.e_machine
== EM_TI_C6000
1630 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1631 sec_name
= "SCOMMON";
1632 else if (elf_header
.e_machine
== EM_MIPS
1633 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1634 sec_name
= "SUNDEF";
1635 else if ((elf_header
.e_machine
== EM_X86_64
1636 || elf_header
.e_machine
== EM_L1OM
1637 || elf_header
.e_machine
== EM_K1OM
)
1638 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1639 sec_name
= "LARGE_COMMON";
1640 else if (elf_header
.e_machine
== EM_IA_64
1641 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1642 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1643 sec_name
= "ANSI_COM";
1644 else if (is_ia64_vms ()
1645 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1646 sec_name
= "VMS_SYMVEC";
1649 sprintf (name_buf
, "<section 0x%x>",
1650 (unsigned int) psym
->st_shndx
);
1651 sec_name
= name_buf
;
1654 print_symbol (22, sec_name
);
1656 else if (strtab
== NULL
)
1657 printf (_("<string table index: %3ld>"), psym
->st_name
);
1658 else if (psym
->st_name
>= strtablen
)
1660 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1665 print_symbol (22, strtab
+ psym
->st_name
);
1667 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1673 bfd_vma off
= rels
[i
].r_addend
;
1675 if ((bfd_signed_vma
) off
< 0)
1676 printf (" - %" BFD_VMA_FMT
"x", - off
);
1678 printf (" + %" BFD_VMA_FMT
"x", off
);
1684 bfd_vma off
= rels
[i
].r_addend
;
1686 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1687 if ((bfd_signed_vma
) off
< 0)
1688 printf ("-%" BFD_VMA_FMT
"x", - off
);
1690 printf ("%" BFD_VMA_FMT
"x", off
);
1693 if (elf_header
.e_machine
== EM_SPARCV9
1695 && streq (rtype
, "R_SPARC_OLO10"))
1696 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1701 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1703 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1704 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1705 const char * rtype2
= elf_mips_reloc_type (type2
);
1706 const char * rtype3
= elf_mips_reloc_type (type3
);
1708 printf (" Type2: ");
1711 printf (_("unrecognized: %-7lx"),
1712 (unsigned long) type2
& 0xffffffff);
1714 printf ("%-17.17s", rtype2
);
1716 printf ("\n Type3: ");
1719 printf (_("unrecognized: %-7lx"),
1720 (unsigned long) type3
& 0xffffffff);
1722 printf ("%-17.17s", rtype3
);
1735 get_mips_dynamic_type (unsigned long type
)
1739 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1740 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1741 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1742 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1743 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1744 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1745 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1746 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1747 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1748 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1749 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1750 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1751 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1752 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1753 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1754 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1755 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1756 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1757 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1758 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1759 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1760 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1761 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1762 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1763 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1764 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1765 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1766 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1767 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1768 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1769 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1770 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1771 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1772 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1773 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1774 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1775 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1776 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1777 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1778 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1779 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1780 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1781 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1782 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1783 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1784 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1791 get_sparc64_dynamic_type (unsigned long type
)
1795 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1802 get_ppc_dynamic_type (unsigned long type
)
1806 case DT_PPC_GOT
: return "PPC_GOT";
1807 case DT_PPC_OPT
: return "PPC_OPT";
1814 get_ppc64_dynamic_type (unsigned long type
)
1818 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1819 case DT_PPC64_OPD
: return "PPC64_OPD";
1820 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1821 case DT_PPC64_OPT
: return "PPC64_OPT";
1828 get_parisc_dynamic_type (unsigned long type
)
1832 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1833 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1834 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1835 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1836 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1837 case DT_HP_PREINIT
: return "HP_PREINIT";
1838 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1839 case DT_HP_NEEDED
: return "HP_NEEDED";
1840 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1841 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1842 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1843 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1844 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1845 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1846 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1847 case DT_HP_FILTERED
: return "HP_FILTERED";
1848 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1849 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1850 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1851 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1852 case DT_PLT
: return "PLT";
1853 case DT_PLT_SIZE
: return "PLT_SIZE";
1854 case DT_DLT
: return "DLT";
1855 case DT_DLT_SIZE
: return "DLT_SIZE";
1862 get_ia64_dynamic_type (unsigned long type
)
1866 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1867 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1868 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1869 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1870 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1871 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1872 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1873 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1874 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1875 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1876 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1877 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1878 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1879 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1880 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1881 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1882 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1883 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1884 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1885 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1886 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1887 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1888 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1889 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1890 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1891 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1892 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1893 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1894 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1895 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1896 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1903 get_solaris_section_type (unsigned long type
)
1907 case 0x6fffffee: return "SUNW_ancillary";
1908 case 0x6fffffef: return "SUNW_capchain";
1909 case 0x6ffffff0: return "SUNW_capinfo";
1910 case 0x6ffffff1: return "SUNW_symsort";
1911 case 0x6ffffff2: return "SUNW_tlssort";
1912 case 0x6ffffff3: return "SUNW_LDYNSYM";
1913 case 0x6ffffff4: return "SUNW_dof";
1914 case 0x6ffffff5: return "SUNW_cap";
1915 case 0x6ffffff6: return "SUNW_SIGNATURE";
1916 case 0x6ffffff7: return "SUNW_ANNOTATE";
1917 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1918 case 0x6ffffff9: return "SUNW_DEBUG";
1919 case 0x6ffffffa: return "SUNW_move";
1920 case 0x6ffffffb: return "SUNW_COMDAT";
1921 case 0x6ffffffc: return "SUNW_syminfo";
1922 case 0x6ffffffd: return "SUNW_verdef";
1923 case 0x6ffffffe: return "SUNW_verneed";
1924 case 0x6fffffff: return "SUNW_versym";
1925 case 0x70000000: return "SPARC_GOTDATA";
1926 default: return NULL
;
1931 get_alpha_dynamic_type (unsigned long type
)
1935 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1936 default: return NULL
;
1941 get_score_dynamic_type (unsigned long type
)
1945 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1946 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1947 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1948 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1949 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1950 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1951 default: return NULL
;
1956 get_tic6x_dynamic_type (unsigned long type
)
1960 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1961 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1962 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1963 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1964 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1965 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1966 default: return NULL
;
1971 get_nios2_dynamic_type (unsigned long type
)
1975 case DT_NIOS2_GP
: return "NIOS2_GP";
1976 default: return NULL
;
1981 get_solaris_dynamic_type (unsigned long type
)
1985 case 0x6000000d: return "SUNW_AUXILIARY";
1986 case 0x6000000e: return "SUNW_RTLDINF";
1987 case 0x6000000f: return "SUNW_FILTER";
1988 case 0x60000010: return "SUNW_CAP";
1989 case 0x60000011: return "SUNW_SYMTAB";
1990 case 0x60000012: return "SUNW_SYMSZ";
1991 case 0x60000013: return "SUNW_SORTENT";
1992 case 0x60000014: return "SUNW_SYMSORT";
1993 case 0x60000015: return "SUNW_SYMSORTSZ";
1994 case 0x60000016: return "SUNW_TLSSORT";
1995 case 0x60000017: return "SUNW_TLSSORTSZ";
1996 case 0x60000018: return "SUNW_CAPINFO";
1997 case 0x60000019: return "SUNW_STRPAD";
1998 case 0x6000001a: return "SUNW_CAPCHAIN";
1999 case 0x6000001b: return "SUNW_LDMACH";
2000 case 0x6000001d: return "SUNW_CAPCHAINENT";
2001 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2002 case 0x60000021: return "SUNW_PARENT";
2003 case 0x60000023: return "SUNW_ASLR";
2004 case 0x60000025: return "SUNW_RELAX";
2005 case 0x60000029: return "SUNW_NXHEAP";
2006 case 0x6000002b: return "SUNW_NXSTACK";
2008 case 0x70000001: return "SPARC_REGISTER";
2009 case 0x7ffffffd: return "AUXILIARY";
2010 case 0x7ffffffe: return "USED";
2011 case 0x7fffffff: return "FILTER";
2013 default: return NULL
;
2018 get_dynamic_type (unsigned long type
)
2020 static char buff
[64];
2024 case DT_NULL
: return "NULL";
2025 case DT_NEEDED
: return "NEEDED";
2026 case DT_PLTRELSZ
: return "PLTRELSZ";
2027 case DT_PLTGOT
: return "PLTGOT";
2028 case DT_HASH
: return "HASH";
2029 case DT_STRTAB
: return "STRTAB";
2030 case DT_SYMTAB
: return "SYMTAB";
2031 case DT_RELA
: return "RELA";
2032 case DT_RELASZ
: return "RELASZ";
2033 case DT_RELAENT
: return "RELAENT";
2034 case DT_STRSZ
: return "STRSZ";
2035 case DT_SYMENT
: return "SYMENT";
2036 case DT_INIT
: return "INIT";
2037 case DT_FINI
: return "FINI";
2038 case DT_SONAME
: return "SONAME";
2039 case DT_RPATH
: return "RPATH";
2040 case DT_SYMBOLIC
: return "SYMBOLIC";
2041 case DT_REL
: return "REL";
2042 case DT_RELSZ
: return "RELSZ";
2043 case DT_RELENT
: return "RELENT";
2044 case DT_PLTREL
: return "PLTREL";
2045 case DT_DEBUG
: return "DEBUG";
2046 case DT_TEXTREL
: return "TEXTREL";
2047 case DT_JMPREL
: return "JMPREL";
2048 case DT_BIND_NOW
: return "BIND_NOW";
2049 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2050 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2051 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2052 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2053 case DT_RUNPATH
: return "RUNPATH";
2054 case DT_FLAGS
: return "FLAGS";
2056 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2057 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2058 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2060 case DT_CHECKSUM
: return "CHECKSUM";
2061 case DT_PLTPADSZ
: return "PLTPADSZ";
2062 case DT_MOVEENT
: return "MOVEENT";
2063 case DT_MOVESZ
: return "MOVESZ";
2064 case DT_FEATURE
: return "FEATURE";
2065 case DT_POSFLAG_1
: return "POSFLAG_1";
2066 case DT_SYMINSZ
: return "SYMINSZ";
2067 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2069 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2070 case DT_CONFIG
: return "CONFIG";
2071 case DT_DEPAUDIT
: return "DEPAUDIT";
2072 case DT_AUDIT
: return "AUDIT";
2073 case DT_PLTPAD
: return "PLTPAD";
2074 case DT_MOVETAB
: return "MOVETAB";
2075 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2077 case DT_VERSYM
: return "VERSYM";
2079 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2080 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2081 case DT_RELACOUNT
: return "RELACOUNT";
2082 case DT_RELCOUNT
: return "RELCOUNT";
2083 case DT_FLAGS_1
: return "FLAGS_1";
2084 case DT_VERDEF
: return "VERDEF";
2085 case DT_VERDEFNUM
: return "VERDEFNUM";
2086 case DT_VERNEED
: return "VERNEED";
2087 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2089 case DT_AUXILIARY
: return "AUXILIARY";
2090 case DT_USED
: return "USED";
2091 case DT_FILTER
: return "FILTER";
2093 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2094 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2095 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2096 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2097 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2098 case DT_GNU_HASH
: return "GNU_HASH";
2101 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2103 const char * result
;
2105 switch (elf_header
.e_machine
)
2108 case EM_MIPS_RS3_LE
:
2109 result
= get_mips_dynamic_type (type
);
2112 result
= get_sparc64_dynamic_type (type
);
2115 result
= get_ppc_dynamic_type (type
);
2118 result
= get_ppc64_dynamic_type (type
);
2121 result
= get_ia64_dynamic_type (type
);
2124 result
= get_alpha_dynamic_type (type
);
2127 result
= get_score_dynamic_type (type
);
2130 result
= get_tic6x_dynamic_type (type
);
2132 case EM_ALTERA_NIOS2
:
2133 result
= get_nios2_dynamic_type (type
);
2136 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2137 result
= get_solaris_dynamic_type (type
);
2146 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2148 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2149 || (elf_header
.e_machine
== EM_PARISC
2150 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2152 const char * result
;
2154 switch (elf_header
.e_machine
)
2157 result
= get_parisc_dynamic_type (type
);
2160 result
= get_ia64_dynamic_type (type
);
2163 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2164 result
= get_solaris_dynamic_type (type
);
2173 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2177 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2184 get_file_type (unsigned e_type
)
2186 static char buff
[32];
2190 case ET_NONE
: return _("NONE (None)");
2191 case ET_REL
: return _("REL (Relocatable file)");
2192 case ET_EXEC
: return _("EXEC (Executable file)");
2193 case ET_DYN
: return _("DYN (Shared object file)");
2194 case ET_CORE
: return _("CORE (Core file)");
2197 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2198 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2199 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2200 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2202 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2208 get_machine_name (unsigned e_machine
)
2210 static char buff
[64]; /* XXX */
2214 /* Please keep this switch table sorted by increasing EM_ value. */
2216 case EM_NONE
: return _("None");
2217 case EM_M32
: return "WE32100";
2218 case EM_SPARC
: return "Sparc";
2219 case EM_386
: return "Intel 80386";
2220 case EM_68K
: return "MC68000";
2221 case EM_88K
: return "MC88000";
2222 case EM_IAMCU
: return "Intel MCU";
2223 case EM_860
: return "Intel 80860";
2224 case EM_MIPS
: return "MIPS R3000";
2225 case EM_S370
: return "IBM System/370";
2227 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2228 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2229 case EM_PARISC
: return "HPPA";
2230 case EM_VPP550
: return "Fujitsu VPP500";
2231 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2232 case EM_960
: return "Intel 90860";
2233 case EM_PPC
: return "PowerPC";
2235 case EM_PPC64
: return "PowerPC64";
2237 case EM_S390
: return "IBM S/390";
2238 case EM_SPU
: return "SPU";
2240 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2241 case EM_FR20
: return "Fujitsu FR20";
2242 case EM_RH32
: return "TRW RH32";
2243 case EM_MCORE
: return "MCORE";
2245 case EM_ARM
: return "ARM";
2246 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2247 case EM_SH
: return "Renesas / SuperH SH";
2248 case EM_SPARCV9
: return "Sparc v9";
2249 case EM_TRICORE
: return "Siemens Tricore";
2250 case EM_ARC
: return "ARC";
2251 case EM_H8_300
: return "Renesas H8/300";
2252 case EM_H8_300H
: return "Renesas H8/300H";
2253 case EM_H8S
: return "Renesas H8S";
2254 case EM_H8_500
: return "Renesas H8/500";
2256 case EM_IA_64
: return "Intel IA-64";
2257 case EM_MIPS_X
: return "Stanford MIPS-X";
2258 case EM_COLDFIRE
: return "Motorola Coldfire";
2259 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2260 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2261 case EM_PCP
: return "Siemens PCP";
2262 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2263 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2264 case EM_STARCORE
: return "Motorola Star*Core processor";
2265 case EM_ME16
: return "Toyota ME16 processor";
2267 case EM_ST100
: return "STMicroelectronics ST100 processor";
2268 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2269 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2270 case EM_PDSP
: return "Sony DSP processor";
2271 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2272 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2273 case EM_FX66
: return "Siemens FX66 microcontroller";
2274 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2275 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2276 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2278 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2279 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2280 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2281 case EM_SVX
: return "Silicon Graphics SVx";
2282 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2283 case EM_VAX
: return "Digital VAX";
2284 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2285 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2286 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2287 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2289 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2290 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2291 case EM_PRISM
: return "Vitesse Prism";
2293 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2294 case EM_CYGNUS_FR30
:
2295 case EM_FR30
: return "Fujitsu FR30";
2296 case EM_CYGNUS_D10V
:
2297 case EM_D10V
: return "d10v";
2298 case EM_CYGNUS_D30V
:
2299 case EM_D30V
: return "d30v";
2300 case EM_CYGNUS_V850
:
2301 case EM_V850
: return "Renesas V850";
2302 case EM_CYGNUS_M32R
:
2303 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2304 case EM_CYGNUS_MN10300
:
2305 case EM_MN10300
: return "mn10300";
2307 case EM_CYGNUS_MN10200
:
2308 case EM_MN10200
: return "mn10200";
2309 case EM_PJ
: return "picoJava";
2310 case EM_OR1K
: return "OpenRISC 1000";
2311 case EM_ARC_COMPACT
: return "ARCompact";
2313 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2314 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2315 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2316 case EM_NS32K
: return "National Semiconductor 32000 series";
2317 case EM_TPC
: return "Tenor Network TPC processor";
2318 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2320 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2322 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2323 case EM_MAX
: return "MAX Processor";
2324 case EM_CR
: return "National Semiconductor CompactRISC";
2325 case EM_F2MC16
: return "Fujitsu F2MC16";
2326 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2327 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2328 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2329 case EM_SEP
: return "Sharp embedded microprocessor";
2330 case EM_ARCA
: return "Arca RISC microprocessor";
2332 case EM_UNICORE
: return "Unicore";
2333 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2334 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2335 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2336 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2337 case EM_XGATE
: return "Motorola XGATE embedded processor";
2339 case EM_XC16X
: return "Infineon Technologies xc16x";
2340 case EM_M16C
: return "Renesas M16C series microprocessors";
2341 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2342 case EM_CE
: return "Freescale Communication Engine RISC core";
2344 case EM_M32C
: return "Renesas M32c";
2346 case EM_TSK3000
: return "Altium TSK3000 core";
2347 case EM_RS08
: return "Freescale RS08 embedded processor";
2348 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2349 case EM_SCORE
: return "SUNPLUS S+Core";
2350 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2351 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2352 case EM_LATTICEMICO32
: return "Lattice Mico32";
2353 case EM_SE_C17
: return "Seiko Epson C17 family";
2355 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2356 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2357 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2358 case EM_TI_PRU
: return "TI PRU I/O processor";
2360 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2361 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2362 case EM_R32C
: return "Renesas R32C series microprocessors";
2363 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2364 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2365 case EM_8051
: return "Intel 8051 and variants";
2366 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2367 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2368 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2369 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2371 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2372 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2373 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2374 case EM_RX
: return "Renesas RX";
2375 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2376 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2377 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2380 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2381 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2382 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2384 case EM_L1OM
: return "Intel L1OM";
2385 case EM_K1OM
: return "Intel K1OM";
2386 case EM_INTEL182
: return "Intel (reserved)";
2387 case EM_AARCH64
: return "AArch64";
2388 case EM_ARM184
: return "ARM (reserved)";
2389 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2390 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2391 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2392 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2394 case EM_CUDA
: return "NVIDIA CUDA architecture";
2395 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2396 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2397 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2398 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2399 case EM_ARC_COMPACT2
: return "ARCv2";
2400 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2401 case EM_RL78
: return "Renesas RL78";
2402 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2403 case EM_78K0R
: return "Renesas 78K0R";
2405 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2406 case EM_BA1
: return "Beyond BA1 CPU architecture";
2407 case EM_BA2
: return "Beyond BA2 CPU architecture";
2408 case EM_XCORE
: return "XMOS xCORE processor family";
2409 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2411 case EM_KM32
: return "KM211 KM32 32-bit processor";
2412 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2413 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2414 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2415 case EM_KVARC
: return "KM211 KVARC processor";
2416 case EM_CDP
: return "Paneve CDP architecture family";
2417 case EM_COGE
: return "Cognitive Smart Memory Processor";
2418 case EM_COOL
: return "Bluechip Systems CoolEngine";
2419 case EM_NORC
: return "Nanoradio Optimized RISC";
2420 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2422 case EM_Z80
: return "Zilog Z80";
2423 case EM_VISIUM
: return "CDS VISIUMcore processor";
2424 case EM_FT32
: return "FTDI Chip FT32";
2425 case EM_MOXIE
: return "Moxie";
2426 case EM_AMDGPU
: return "AMD GPU";
2427 case EM_RISCV
: return "RISC-V";
2428 case EM_LANAI
: return "Lanai 32-bit processor";
2429 case EM_BPF
: return "Linux BPF";
2431 /* Large numbers... */
2432 case EM_MT
: return "Morpho Techologies MT processor";
2433 case EM_ALPHA
: return "Alpha";
2434 case EM_WEBASSEMBLY
: return "Web Assembly";
2435 case EM_DLX
: return "OpenDLX";
2436 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2437 case EM_IQ2000
: return "Vitesse IQ2000";
2439 case EM_NIOS32
: return "Altera Nios";
2440 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2441 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2442 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2445 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2451 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2453 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2454 other compilers don't a specific architecture type in the e_flags, and
2455 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2456 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2459 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2460 but also sets a specific architecture type in the e_flags field.
2462 However, when decoding the flags we don't worry if we see an
2463 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2464 ARCEM architecture type. */
2466 switch (e_flags
& EF_ARC_MACH_MSK
)
2468 /* We only expect these to occur for EM_ARC_COMPACT2. */
2469 case EF_ARC_CPU_ARCV2EM
:
2470 strcat (buf
, ", ARC EM");
2472 case EF_ARC_CPU_ARCV2HS
:
2473 strcat (buf
, ", ARC HS");
2476 /* We only expect these to occur for EM_ARC_COMPACT. */
2477 case E_ARC_MACH_ARC600
:
2478 strcat (buf
, ", ARC600");
2480 case E_ARC_MACH_ARC601
:
2481 strcat (buf
, ", ARC601");
2483 case E_ARC_MACH_ARC700
:
2484 strcat (buf
, ", ARC700");
2487 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2488 new ELF with new architecture being read by an old version of
2489 readelf, or (c) An ELF built with non-GNU compiler that does not
2490 set the architecture in the e_flags. */
2492 if (e_machine
== EM_ARC_COMPACT
)
2493 strcat (buf
, ", Unknown ARCompact");
2495 strcat (buf
, ", Unknown ARC");
2499 switch (e_flags
& EF_ARC_OSABI_MSK
)
2501 case E_ARC_OSABI_ORIG
:
2502 strcat (buf
, ", (ABI:legacy)");
2504 case E_ARC_OSABI_V2
:
2505 strcat (buf
, ", (ABI:v2)");
2507 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2508 case E_ARC_OSABI_V3
:
2509 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2512 strcat (buf
, ", unrecognised ARC OSABI flag");
2518 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2521 bfd_boolean unknown
= FALSE
;
2523 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2524 e_flags
&= ~ EF_ARM_EABIMASK
;
2526 /* Handle "generic" ARM flags. */
2527 if (e_flags
& EF_ARM_RELEXEC
)
2529 strcat (buf
, ", relocatable executable");
2530 e_flags
&= ~ EF_ARM_RELEXEC
;
2533 /* Now handle EABI specific flags. */
2537 strcat (buf
, ", <unrecognized EABI>");
2542 case EF_ARM_EABI_VER1
:
2543 strcat (buf
, ", Version1 EABI");
2548 /* Process flags one bit at a time. */
2549 flag
= e_flags
& - e_flags
;
2554 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2555 strcat (buf
, ", sorted symbol tables");
2565 case EF_ARM_EABI_VER2
:
2566 strcat (buf
, ", Version2 EABI");
2571 /* Process flags one bit at a time. */
2572 flag
= e_flags
& - e_flags
;
2577 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2578 strcat (buf
, ", sorted symbol tables");
2581 case EF_ARM_DYNSYMSUSESEGIDX
:
2582 strcat (buf
, ", dynamic symbols use segment index");
2585 case EF_ARM_MAPSYMSFIRST
:
2586 strcat (buf
, ", mapping symbols precede others");
2596 case EF_ARM_EABI_VER3
:
2597 strcat (buf
, ", Version3 EABI");
2600 case EF_ARM_EABI_VER4
:
2601 strcat (buf
, ", Version4 EABI");
2606 /* Process flags one bit at a time. */
2607 flag
= e_flags
& - e_flags
;
2613 strcat (buf
, ", BE8");
2617 strcat (buf
, ", LE8");
2627 case EF_ARM_EABI_VER5
:
2628 strcat (buf
, ", Version5 EABI");
2633 /* Process flags one bit at a time. */
2634 flag
= e_flags
& - e_flags
;
2640 strcat (buf
, ", BE8");
2644 strcat (buf
, ", LE8");
2647 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2648 strcat (buf
, ", soft-float ABI");
2651 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2652 strcat (buf
, ", hard-float ABI");
2662 case EF_ARM_EABI_UNKNOWN
:
2663 strcat (buf
, ", GNU EABI");
2668 /* Process flags one bit at a time. */
2669 flag
= e_flags
& - e_flags
;
2674 case EF_ARM_INTERWORK
:
2675 strcat (buf
, ", interworking enabled");
2678 case EF_ARM_APCS_26
:
2679 strcat (buf
, ", uses APCS/26");
2682 case EF_ARM_APCS_FLOAT
:
2683 strcat (buf
, ", uses APCS/float");
2687 strcat (buf
, ", position independent");
2691 strcat (buf
, ", 8 bit structure alignment");
2694 case EF_ARM_NEW_ABI
:
2695 strcat (buf
, ", uses new ABI");
2698 case EF_ARM_OLD_ABI
:
2699 strcat (buf
, ", uses old ABI");
2702 case EF_ARM_SOFT_FLOAT
:
2703 strcat (buf
, ", software FP");
2706 case EF_ARM_VFP_FLOAT
:
2707 strcat (buf
, ", VFP");
2710 case EF_ARM_MAVERICK_FLOAT
:
2711 strcat (buf
, ", Maverick FP");
2722 strcat (buf
,_(", <unknown>"));
2726 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2728 --size
; /* Leave space for null terminator. */
2730 switch (e_flags
& EF_AVR_MACH
)
2732 case E_AVR_MACH_AVR1
:
2733 strncat (buf
, ", avr:1", size
);
2735 case E_AVR_MACH_AVR2
:
2736 strncat (buf
, ", avr:2", size
);
2738 case E_AVR_MACH_AVR25
:
2739 strncat (buf
, ", avr:25", size
);
2741 case E_AVR_MACH_AVR3
:
2742 strncat (buf
, ", avr:3", size
);
2744 case E_AVR_MACH_AVR31
:
2745 strncat (buf
, ", avr:31", size
);
2747 case E_AVR_MACH_AVR35
:
2748 strncat (buf
, ", avr:35", size
);
2750 case E_AVR_MACH_AVR4
:
2751 strncat (buf
, ", avr:4", size
);
2753 case E_AVR_MACH_AVR5
:
2754 strncat (buf
, ", avr:5", size
);
2756 case E_AVR_MACH_AVR51
:
2757 strncat (buf
, ", avr:51", size
);
2759 case E_AVR_MACH_AVR6
:
2760 strncat (buf
, ", avr:6", size
);
2762 case E_AVR_MACH_AVRTINY
:
2763 strncat (buf
, ", avr:100", size
);
2765 case E_AVR_MACH_XMEGA1
:
2766 strncat (buf
, ", avr:101", size
);
2768 case E_AVR_MACH_XMEGA2
:
2769 strncat (buf
, ", avr:102", size
);
2771 case E_AVR_MACH_XMEGA3
:
2772 strncat (buf
, ", avr:103", size
);
2774 case E_AVR_MACH_XMEGA4
:
2775 strncat (buf
, ", avr:104", size
);
2777 case E_AVR_MACH_XMEGA5
:
2778 strncat (buf
, ", avr:105", size
);
2780 case E_AVR_MACH_XMEGA6
:
2781 strncat (buf
, ", avr:106", size
);
2783 case E_AVR_MACH_XMEGA7
:
2784 strncat (buf
, ", avr:107", size
);
2787 strncat (buf
, ", avr:<unknown>", size
);
2791 size
-= strlen (buf
);
2792 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2793 strncat (buf
, ", link-relax", size
);
2797 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2803 bfd_boolean has_fpu
= FALSE
;
2806 static const char *ABI_STRINGS
[] =
2808 "ABI v0", /* use r5 as return register; only used in N1213HC */
2809 "ABI v1", /* use r0 as return register */
2810 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2811 "ABI v2fp", /* for FPU */
2815 static const char *VER_STRINGS
[] =
2817 "Andes ELF V1.3 or older",
2821 static const char *ARCH_STRINGS
[] =
2830 abi
= EF_NDS_ABI
& e_flags
;
2831 arch
= EF_NDS_ARCH
& e_flags
;
2832 config
= EF_NDS_INST
& e_flags
;
2833 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2835 memset (buf
, 0, size
);
2842 case E_NDS_ABI_V2FP
:
2843 case E_NDS_ABI_AABI
:
2844 case E_NDS_ABI_V2FP_PLUS
:
2845 /* In case there are holes in the array. */
2846 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2850 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2856 case E_NDS32_ELF_VER_1_2
:
2857 case E_NDS32_ELF_VER_1_3
:
2858 case E_NDS32_ELF_VER_1_4
:
2859 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2863 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2867 if (E_NDS_ABI_V0
== abi
)
2869 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2870 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2871 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2872 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2878 case E_NDS_ARCH_STAR_V1_0
:
2879 case E_NDS_ARCH_STAR_V2_0
:
2880 case E_NDS_ARCH_STAR_V3_0
:
2881 case E_NDS_ARCH_STAR_V3_M
:
2882 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2886 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2887 /* ARCH version determines how the e_flags are interpreted.
2888 If it is unknown, we cannot proceed. */
2892 /* Newer ABI; Now handle architecture specific flags. */
2893 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2895 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2896 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2898 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2899 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2901 if (config
& E_NDS32_HAS_DIV_INST
)
2902 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2904 if (config
& E_NDS32_HAS_16BIT_INST
)
2905 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2909 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2911 if (version
<= E_NDS32_ELF_VER_1_3
)
2912 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2914 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2917 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2918 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2920 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2921 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2923 if (config
& E_NDS32_HAS_16BIT_INST
)
2925 if (version
<= E_NDS32_ELF_VER_1_3
)
2926 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2928 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2932 if (config
& E_NDS32_HAS_EXT_INST
)
2933 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2935 if (config
& E_NDS32_HAS_EXT2_INST
)
2936 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2938 if (config
& E_NDS32_HAS_FPU_INST
)
2941 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2944 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2947 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2950 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2953 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2958 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2960 case E_NDS32_FPU_REG_8SP_4DP
:
2961 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2963 case E_NDS32_FPU_REG_16SP_8DP
:
2964 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2966 case E_NDS32_FPU_REG_32SP_16DP
:
2967 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2969 case E_NDS32_FPU_REG_32SP_32DP
:
2970 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2975 if (config
& E_NDS32_HAS_AUDIO_INST
)
2976 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2978 if (config
& E_NDS32_HAS_STRING_INST
)
2979 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2981 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2982 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2984 if (config
& E_NDS32_HAS_VIDEO_INST
)
2986 if (version
<= E_NDS32_ELF_VER_1_3
)
2987 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2989 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2992 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2993 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2995 if (config
& E_NDS32_HAS_L2C_INST
)
2996 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3000 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
3002 static char buf
[1024];
3013 case EM_ARC_COMPACT2
:
3014 case EM_ARC_COMPACT
:
3015 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3019 decode_ARM_machine_flags (e_flags
, buf
);
3023 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3027 if (e_flags
& EF_BFIN_PIC
)
3028 strcat (buf
, ", PIC");
3030 if (e_flags
& EF_BFIN_FDPIC
)
3031 strcat (buf
, ", FDPIC");
3033 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3034 strcat (buf
, ", code in L1");
3036 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3037 strcat (buf
, ", data in L1");
3042 switch (e_flags
& EF_FRV_CPU_MASK
)
3044 case EF_FRV_CPU_GENERIC
:
3048 strcat (buf
, ", fr???");
3051 case EF_FRV_CPU_FR300
:
3052 strcat (buf
, ", fr300");
3055 case EF_FRV_CPU_FR400
:
3056 strcat (buf
, ", fr400");
3058 case EF_FRV_CPU_FR405
:
3059 strcat (buf
, ", fr405");
3062 case EF_FRV_CPU_FR450
:
3063 strcat (buf
, ", fr450");
3066 case EF_FRV_CPU_FR500
:
3067 strcat (buf
, ", fr500");
3069 case EF_FRV_CPU_FR550
:
3070 strcat (buf
, ", fr550");
3073 case EF_FRV_CPU_SIMPLE
:
3074 strcat (buf
, ", simple");
3076 case EF_FRV_CPU_TOMCAT
:
3077 strcat (buf
, ", tomcat");
3083 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3084 strcat (buf
, ", m68000");
3085 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3086 strcat (buf
, ", cpu32");
3087 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3088 strcat (buf
, ", fido_a");
3091 char const * isa
= _("unknown");
3092 char const * mac
= _("unknown mac");
3093 char const * additional
= NULL
;
3095 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3097 case EF_M68K_CF_ISA_A_NODIV
:
3099 additional
= ", nodiv";
3101 case EF_M68K_CF_ISA_A
:
3104 case EF_M68K_CF_ISA_A_PLUS
:
3107 case EF_M68K_CF_ISA_B_NOUSP
:
3109 additional
= ", nousp";
3111 case EF_M68K_CF_ISA_B
:
3114 case EF_M68K_CF_ISA_C
:
3117 case EF_M68K_CF_ISA_C_NODIV
:
3119 additional
= ", nodiv";
3122 strcat (buf
, ", cf, isa ");
3125 strcat (buf
, additional
);
3126 if (e_flags
& EF_M68K_CF_FLOAT
)
3127 strcat (buf
, ", float");
3128 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3133 case EF_M68K_CF_MAC
:
3136 case EF_M68K_CF_EMAC
:
3139 case EF_M68K_CF_EMAC_B
:
3152 switch (e_flags
& EF_MEP_CPU_MASK
)
3154 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3155 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3156 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3157 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3158 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3159 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3160 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3163 switch (e_flags
& EF_MEP_COP_MASK
)
3165 case EF_MEP_COP_NONE
: break;
3166 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3167 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3168 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3169 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3170 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3173 if (e_flags
& EF_MEP_LIBRARY
)
3174 strcat (buf
, ", Built for Library");
3176 if (e_flags
& EF_MEP_INDEX_MASK
)
3177 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3178 e_flags
& EF_MEP_INDEX_MASK
);
3180 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3181 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3182 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3186 if (e_flags
& EF_PPC_EMB
)
3187 strcat (buf
, ", emb");
3189 if (e_flags
& EF_PPC_RELOCATABLE
)
3190 strcat (buf
, _(", relocatable"));
3192 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3193 strcat (buf
, _(", relocatable-lib"));
3197 if (e_flags
& EF_PPC64_ABI
)
3199 char abi
[] = ", abiv0";
3201 abi
[6] += e_flags
& EF_PPC64_ABI
;
3207 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3208 strcat (buf
, ", RH850 ABI");
3210 if (e_flags
& EF_V800_850E3
)
3211 strcat (buf
, ", V3 architecture");
3213 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3214 strcat (buf
, ", FPU not used");
3216 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3217 strcat (buf
, ", regmode: COMMON");
3219 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3220 strcat (buf
, ", r4 not used");
3222 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3223 strcat (buf
, ", r30 not used");
3225 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3226 strcat (buf
, ", r5 not used");
3228 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3229 strcat (buf
, ", r2 not used");
3231 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3233 switch (e_flags
& - e_flags
)
3235 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3236 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3237 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3238 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3239 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3240 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3241 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3242 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3243 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3244 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3245 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3246 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3253 case EM_CYGNUS_V850
:
3254 switch (e_flags
& EF_V850_ARCH
)
3256 case E_V850E3V5_ARCH
:
3257 strcat (buf
, ", v850e3v5");
3259 case E_V850E2V3_ARCH
:
3260 strcat (buf
, ", v850e2v3");
3263 strcat (buf
, ", v850e2");
3266 strcat (buf
, ", v850e1");
3269 strcat (buf
, ", v850e");
3272 strcat (buf
, ", v850");
3275 strcat (buf
, _(", unknown v850 architecture variant"));
3281 case EM_CYGNUS_M32R
:
3282 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3283 strcat (buf
, ", m32r");
3287 case EM_MIPS_RS3_LE
:
3288 if (e_flags
& EF_MIPS_NOREORDER
)
3289 strcat (buf
, ", noreorder");
3291 if (e_flags
& EF_MIPS_PIC
)
3292 strcat (buf
, ", pic");
3294 if (e_flags
& EF_MIPS_CPIC
)
3295 strcat (buf
, ", cpic");
3297 if (e_flags
& EF_MIPS_UCODE
)
3298 strcat (buf
, ", ugen_reserved");
3300 if (e_flags
& EF_MIPS_ABI2
)
3301 strcat (buf
, ", abi2");
3303 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3304 strcat (buf
, ", odk first");
3306 if (e_flags
& EF_MIPS_32BITMODE
)
3307 strcat (buf
, ", 32bitmode");
3309 if (e_flags
& EF_MIPS_NAN2008
)
3310 strcat (buf
, ", nan2008");
3312 if (e_flags
& EF_MIPS_FP64
)
3313 strcat (buf
, ", fp64");
3315 switch ((e_flags
& EF_MIPS_MACH
))
3317 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3318 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3319 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3320 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3321 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3322 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3323 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3324 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3325 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3326 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3327 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3328 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3329 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3330 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3331 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3332 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3333 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3335 /* We simply ignore the field in this case to avoid confusion:
3336 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3339 default: strcat (buf
, _(", unknown CPU")); break;
3342 switch ((e_flags
& EF_MIPS_ABI
))
3344 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3345 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3346 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3347 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3349 /* We simply ignore the field in this case to avoid confusion:
3350 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3351 This means it is likely to be an o32 file, but not for
3354 default: strcat (buf
, _(", unknown ABI")); break;
3357 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3358 strcat (buf
, ", mdmx");
3360 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3361 strcat (buf
, ", mips16");
3363 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3364 strcat (buf
, ", micromips");
3366 switch ((e_flags
& EF_MIPS_ARCH
))
3368 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3369 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3370 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3371 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3372 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3373 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3374 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3375 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3376 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3377 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3378 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3379 default: strcat (buf
, _(", unknown ISA")); break;
3384 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3388 if (e_flags
& EF_RISCV_RVC
)
3389 strcat (buf
, ", RVC");
3391 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3393 case EF_RISCV_FLOAT_ABI_SOFT
:
3394 strcat (buf
, ", soft-float ABI");
3397 case EF_RISCV_FLOAT_ABI_SINGLE
:
3398 strcat (buf
, ", single-float ABI");
3401 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3402 strcat (buf
, ", double-float ABI");
3405 case EF_RISCV_FLOAT_ABI_QUAD
:
3406 strcat (buf
, ", quad-float ABI");
3412 switch ((e_flags
& EF_SH_MACH_MASK
))
3414 case EF_SH1
: strcat (buf
, ", sh1"); break;
3415 case EF_SH2
: strcat (buf
, ", sh2"); break;
3416 case EF_SH3
: strcat (buf
, ", sh3"); break;
3417 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3418 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3419 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3420 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3421 case EF_SH4
: strcat (buf
, ", sh4"); break;
3422 case EF_SH5
: strcat (buf
, ", sh5"); break;
3423 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3424 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3425 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3426 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3427 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3428 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3429 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3430 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3431 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3432 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3433 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3434 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3435 default: strcat (buf
, _(", unknown ISA")); break;
3438 if (e_flags
& EF_SH_PIC
)
3439 strcat (buf
, ", pic");
3441 if (e_flags
& EF_SH_FDPIC
)
3442 strcat (buf
, ", fdpic");
3446 if (e_flags
& EF_OR1K_NODELAY
)
3447 strcat (buf
, ", no delay");
3451 if (e_flags
& EF_SPARC_32PLUS
)
3452 strcat (buf
, ", v8+");
3454 if (e_flags
& EF_SPARC_SUN_US1
)
3455 strcat (buf
, ", ultrasparcI");
3457 if (e_flags
& EF_SPARC_SUN_US3
)
3458 strcat (buf
, ", ultrasparcIII");
3460 if (e_flags
& EF_SPARC_HAL_R1
)
3461 strcat (buf
, ", halr1");
3463 if (e_flags
& EF_SPARC_LEDATA
)
3464 strcat (buf
, ", ledata");
3466 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3467 strcat (buf
, ", tso");
3469 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3470 strcat (buf
, ", pso");
3472 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3473 strcat (buf
, ", rmo");
3477 switch (e_flags
& EF_PARISC_ARCH
)
3479 case EFA_PARISC_1_0
:
3480 strcpy (buf
, ", PA-RISC 1.0");
3482 case EFA_PARISC_1_1
:
3483 strcpy (buf
, ", PA-RISC 1.1");
3485 case EFA_PARISC_2_0
:
3486 strcpy (buf
, ", PA-RISC 2.0");
3491 if (e_flags
& EF_PARISC_TRAPNIL
)
3492 strcat (buf
, ", trapnil");
3493 if (e_flags
& EF_PARISC_EXT
)
3494 strcat (buf
, ", ext");
3495 if (e_flags
& EF_PARISC_LSB
)
3496 strcat (buf
, ", lsb");
3497 if (e_flags
& EF_PARISC_WIDE
)
3498 strcat (buf
, ", wide");
3499 if (e_flags
& EF_PARISC_NO_KABP
)
3500 strcat (buf
, ", no kabp");
3501 if (e_flags
& EF_PARISC_LAZYSWAP
)
3502 strcat (buf
, ", lazyswap");
3507 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3508 strcat (buf
, ", new calling convention");
3510 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3511 strcat (buf
, ", gnu calling convention");
3515 if ((e_flags
& EF_IA_64_ABI64
))
3516 strcat (buf
, ", 64-bit");
3518 strcat (buf
, ", 32-bit");
3519 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3520 strcat (buf
, ", reduced fp model");
3521 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3522 strcat (buf
, ", no function descriptors, constant gp");
3523 else if ((e_flags
& EF_IA_64_CONS_GP
))
3524 strcat (buf
, ", constant gp");
3525 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3526 strcat (buf
, ", absolute");
3527 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3529 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3530 strcat (buf
, ", vms_linkages");
3531 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3533 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3535 case EF_IA_64_VMS_COMCOD_WARNING
:
3536 strcat (buf
, ", warning");
3538 case EF_IA_64_VMS_COMCOD_ERROR
:
3539 strcat (buf
, ", error");
3541 case EF_IA_64_VMS_COMCOD_ABORT
:
3542 strcat (buf
, ", abort");
3545 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3546 e_flags
& EF_IA_64_VMS_COMCOD
);
3547 strcat (buf
, ", <unknown>");
3553 if ((e_flags
& EF_VAX_NONPIC
))
3554 strcat (buf
, ", non-PIC");
3555 if ((e_flags
& EF_VAX_DFLOAT
))
3556 strcat (buf
, ", D-Float");
3557 if ((e_flags
& EF_VAX_GFLOAT
))
3558 strcat (buf
, ", G-Float");
3562 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3563 strcat (buf
, ", mcm");
3564 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3565 strcat (buf
, ", mcm24");
3566 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3567 strcat (buf
, ", gr6");
3571 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3573 case E_FLAG_RL78_ANY_CPU
: break;
3574 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3575 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3576 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3578 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3579 strcat (buf
, ", 64-bit doubles");
3583 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3584 strcat (buf
, ", 64-bit doubles");
3585 if (e_flags
& E_FLAG_RX_DSP
)
3586 strcat (buf
, ", dsp");
3587 if (e_flags
& E_FLAG_RX_PID
)
3588 strcat (buf
, ", pid");
3589 if (e_flags
& E_FLAG_RX_ABI
)
3590 strcat (buf
, ", RX ABI");
3591 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3592 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3593 ? ", uses String instructions" : ", bans String instructions");
3594 if (e_flags
& E_FLAG_RX_V2
)
3595 strcat (buf
, ", V2");
3599 if (e_flags
& EF_S390_HIGH_GPRS
)
3600 strcat (buf
, ", highgprs");
3604 if ((e_flags
& EF_C6000_REL
))
3605 strcat (buf
, ", relocatable module");
3609 strcat (buf
, _(": architecture variant: "));
3610 switch (e_flags
& EF_MSP430_MACH
)
3612 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3613 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3614 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3615 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3616 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3617 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3618 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3619 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3620 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3621 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3622 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3623 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3624 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3625 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3626 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3628 strcat (buf
, _(": unknown")); break;
3631 if (e_flags
& ~ EF_MSP430_MACH
)
3632 strcat (buf
, _(": unknown extra flag bits also present"));
3640 get_osabi_name (unsigned int osabi
)
3642 static char buff
[32];
3646 case ELFOSABI_NONE
: return "UNIX - System V";
3647 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3648 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3649 case ELFOSABI_GNU
: return "UNIX - GNU";
3650 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3651 case ELFOSABI_AIX
: return "UNIX - AIX";
3652 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3653 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3654 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3655 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3656 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3657 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3658 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3659 case ELFOSABI_AROS
: return "AROS";
3660 case ELFOSABI_FENIXOS
: return "FenixOS";
3661 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3662 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3665 switch (elf_header
.e_machine
)
3670 case ELFOSABI_ARM
: return "ARM";
3681 case ELFOSABI_STANDALONE
: return _("Standalone App");
3690 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3691 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3700 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3706 get_aarch64_segment_type (unsigned long type
)
3710 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3711 default: return NULL
;
3716 get_arm_segment_type (unsigned long type
)
3720 case PT_ARM_EXIDX
: return "EXIDX";
3721 default: return NULL
;
3726 get_mips_segment_type (unsigned long type
)
3730 case PT_MIPS_REGINFO
: return "REGINFO";
3731 case PT_MIPS_RTPROC
: return "RTPROC";
3732 case PT_MIPS_OPTIONS
: return "OPTIONS";
3733 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3734 default: return NULL
;
3739 get_parisc_segment_type (unsigned long type
)
3743 case PT_HP_TLS
: return "HP_TLS";
3744 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3745 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3746 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3747 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3748 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3749 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3750 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3751 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3752 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3753 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3754 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3755 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3756 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3757 case PT_HP_STACK
: return "HP_STACK";
3758 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3759 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3760 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3761 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3762 default: return NULL
;
3767 get_ia64_segment_type (unsigned long type
)
3771 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3772 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3773 case PT_HP_TLS
: return "HP_TLS";
3774 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3775 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3776 case PT_IA_64_HP_STACK
: return "HP_STACK";
3777 default: return NULL
;
3782 get_tic6x_segment_type (unsigned long type
)
3786 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3787 default: return NULL
;
3792 get_solaris_segment_type (unsigned long type
)
3796 case 0x6464e550: return "PT_SUNW_UNWIND";
3797 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3798 case 0x6ffffff7: return "PT_LOSUNW";
3799 case 0x6ffffffa: return "PT_SUNWBSS";
3800 case 0x6ffffffb: return "PT_SUNWSTACK";
3801 case 0x6ffffffc: return "PT_SUNWDTRACE";
3802 case 0x6ffffffd: return "PT_SUNWCAP";
3803 case 0x6fffffff: return "PT_HISUNW";
3804 default: return NULL
;
3809 get_segment_type (unsigned long p_type
)
3811 static char buff
[32];
3815 case PT_NULL
: return "NULL";
3816 case PT_LOAD
: return "LOAD";
3817 case PT_DYNAMIC
: return "DYNAMIC";
3818 case PT_INTERP
: return "INTERP";
3819 case PT_NOTE
: return "NOTE";
3820 case PT_SHLIB
: return "SHLIB";
3821 case PT_PHDR
: return "PHDR";
3822 case PT_TLS
: return "TLS";
3823 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3824 case PT_GNU_STACK
: return "GNU_STACK";
3825 case PT_GNU_RELRO
: return "GNU_RELRO";
3828 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3830 sprintf (buff
, "GNU_MBIND+%#lx",
3831 p_type
- PT_GNU_MBIND_LO
);
3833 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3835 const char * result
;
3837 switch (elf_header
.e_machine
)
3840 result
= get_aarch64_segment_type (p_type
);
3843 result
= get_arm_segment_type (p_type
);
3846 case EM_MIPS_RS3_LE
:
3847 result
= get_mips_segment_type (p_type
);
3850 result
= get_parisc_segment_type (p_type
);
3853 result
= get_ia64_segment_type (p_type
);
3856 result
= get_tic6x_segment_type (p_type
);
3866 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3868 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3870 const char * result
;
3872 switch (elf_header
.e_machine
)
3875 result
= get_parisc_segment_type (p_type
);
3878 result
= get_ia64_segment_type (p_type
);
3881 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3882 result
= get_solaris_segment_type (p_type
);
3891 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3894 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3901 get_mips_section_type_name (unsigned int sh_type
)
3905 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3906 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3907 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3908 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3909 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3910 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3911 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3912 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3913 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3914 case SHT_MIPS_RELD
: return "MIPS_RELD";
3915 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3916 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3917 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3918 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3919 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3920 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3921 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3922 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3923 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3924 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3925 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3926 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3927 case SHT_MIPS_LINE
: return "MIPS_LINE";
3928 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3929 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3930 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3931 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3932 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3933 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3934 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3935 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3936 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3937 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3938 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3939 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3940 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3941 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3942 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3943 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3944 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3952 get_parisc_section_type_name (unsigned int sh_type
)
3956 case SHT_PARISC_EXT
: return "PARISC_EXT";
3957 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3958 case SHT_PARISC_DOC
: return "PARISC_DOC";
3959 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3960 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3961 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3962 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3963 default: return NULL
;
3968 get_ia64_section_type_name (unsigned int sh_type
)
3970 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3971 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3972 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3976 case SHT_IA_64_EXT
: return "IA_64_EXT";
3977 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3978 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3979 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3980 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3981 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3982 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3983 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3984 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3985 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3993 get_x86_64_section_type_name (unsigned int sh_type
)
3997 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3998 default: return NULL
;
4003 get_aarch64_section_type_name (unsigned int sh_type
)
4007 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4008 default: return NULL
;
4013 get_arm_section_type_name (unsigned int sh_type
)
4017 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4018 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4019 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4020 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4021 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4022 default: return NULL
;
4027 get_tic6x_section_type_name (unsigned int sh_type
)
4031 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4032 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4033 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4034 case SHT_TI_ICODE
: return "TI_ICODE";
4035 case SHT_TI_XREF
: return "TI_XREF";
4036 case SHT_TI_HANDLER
: return "TI_HANDLER";
4037 case SHT_TI_INITINFO
: return "TI_INITINFO";
4038 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4039 default: return NULL
;
4044 get_msp430x_section_type_name (unsigned int sh_type
)
4048 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4049 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4050 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4051 default: return NULL
;
4056 get_v850_section_type_name (unsigned int sh_type
)
4060 case SHT_V850_SCOMMON
: return "V850 Small Common";
4061 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4062 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4063 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4064 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4065 default: return NULL
;
4070 get_section_type_name (unsigned int sh_type
)
4072 static char buff
[32];
4073 const char * result
;
4077 case SHT_NULL
: return "NULL";
4078 case SHT_PROGBITS
: return "PROGBITS";
4079 case SHT_SYMTAB
: return "SYMTAB";
4080 case SHT_STRTAB
: return "STRTAB";
4081 case SHT_RELA
: return "RELA";
4082 case SHT_HASH
: return "HASH";
4083 case SHT_DYNAMIC
: return "DYNAMIC";
4084 case SHT_NOTE
: return "NOTE";
4085 case SHT_NOBITS
: return "NOBITS";
4086 case SHT_REL
: return "REL";
4087 case SHT_SHLIB
: return "SHLIB";
4088 case SHT_DYNSYM
: return "DYNSYM";
4089 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4090 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4091 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4092 case SHT_GNU_HASH
: return "GNU_HASH";
4093 case SHT_GROUP
: return "GROUP";
4094 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4095 case SHT_GNU_verdef
: return "VERDEF";
4096 case SHT_GNU_verneed
: return "VERNEED";
4097 case SHT_GNU_versym
: return "VERSYM";
4098 case 0x6ffffff0: return "VERSYM";
4099 case 0x6ffffffc: return "VERDEF";
4100 case 0x7ffffffd: return "AUXILIARY";
4101 case 0x7fffffff: return "FILTER";
4102 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4105 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4107 switch (elf_header
.e_machine
)
4110 case EM_MIPS_RS3_LE
:
4111 result
= get_mips_section_type_name (sh_type
);
4114 result
= get_parisc_section_type_name (sh_type
);
4117 result
= get_ia64_section_type_name (sh_type
);
4122 result
= get_x86_64_section_type_name (sh_type
);
4125 result
= get_aarch64_section_type_name (sh_type
);
4128 result
= get_arm_section_type_name (sh_type
);
4131 result
= get_tic6x_section_type_name (sh_type
);
4134 result
= get_msp430x_section_type_name (sh_type
);
4138 case EM_CYGNUS_V850
:
4139 result
= get_v850_section_type_name (sh_type
);
4149 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4151 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4153 switch (elf_header
.e_machine
)
4156 result
= get_ia64_section_type_name (sh_type
);
4159 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4160 result
= get_solaris_section_type (sh_type
);
4165 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4166 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4167 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4168 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4180 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4182 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4184 switch (elf_header
.e_machine
)
4188 case EM_CYGNUS_V850
:
4189 result
= get_v850_section_type_name (sh_type
);
4199 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4202 /* This message is probably going to be displayed in a 15
4203 character wide field, so put the hex value first. */
4204 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4210 #define OPTION_DEBUG_DUMP 512
4211 #define OPTION_DYN_SYMS 513
4212 #define OPTION_DWARF_DEPTH 514
4213 #define OPTION_DWARF_START 515
4214 #define OPTION_DWARF_CHECK 516
4216 static struct option options
[] =
4218 {"all", no_argument
, 0, 'a'},
4219 {"file-header", no_argument
, 0, 'h'},
4220 {"program-headers", no_argument
, 0, 'l'},
4221 {"headers", no_argument
, 0, 'e'},
4222 {"histogram", no_argument
, 0, 'I'},
4223 {"segments", no_argument
, 0, 'l'},
4224 {"sections", no_argument
, 0, 'S'},
4225 {"section-headers", no_argument
, 0, 'S'},
4226 {"section-groups", no_argument
, 0, 'g'},
4227 {"section-details", no_argument
, 0, 't'},
4228 {"full-section-name",no_argument
, 0, 'N'},
4229 {"symbols", no_argument
, 0, 's'},
4230 {"syms", no_argument
, 0, 's'},
4231 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4232 {"relocs", no_argument
, 0, 'r'},
4233 {"notes", no_argument
, 0, 'n'},
4234 {"dynamic", no_argument
, 0, 'd'},
4235 {"arch-specific", no_argument
, 0, 'A'},
4236 {"version-info", no_argument
, 0, 'V'},
4237 {"use-dynamic", no_argument
, 0, 'D'},
4238 {"unwind", no_argument
, 0, 'u'},
4239 {"archive-index", no_argument
, 0, 'c'},
4240 {"hex-dump", required_argument
, 0, 'x'},
4241 {"relocated-dump", required_argument
, 0, 'R'},
4242 {"string-dump", required_argument
, 0, 'p'},
4243 {"decompress", no_argument
, 0, 'z'},
4244 #ifdef SUPPORT_DISASSEMBLY
4245 {"instruction-dump", required_argument
, 0, 'i'},
4247 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4249 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4250 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4251 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4253 {"version", no_argument
, 0, 'v'},
4254 {"wide", no_argument
, 0, 'W'},
4255 {"help", no_argument
, 0, 'H'},
4256 {0, no_argument
, 0, 0}
4260 usage (FILE * stream
)
4262 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4263 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4264 fprintf (stream
, _(" Options are:\n\
4265 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4266 -h --file-header Display the ELF file header\n\
4267 -l --program-headers Display the program headers\n\
4268 --segments An alias for --program-headers\n\
4269 -S --section-headers Display the sections' header\n\
4270 --sections An alias for --section-headers\n\
4271 -g --section-groups Display the section groups\n\
4272 -t --section-details Display the section details\n\
4273 -e --headers Equivalent to: -h -l -S\n\
4274 -s --syms Display the symbol table\n\
4275 --symbols An alias for --syms\n\
4276 --dyn-syms Display the dynamic symbol table\n\
4277 -n --notes Display the core notes (if present)\n\
4278 -r --relocs Display the relocations (if present)\n\
4279 -u --unwind Display the unwind info (if present)\n\
4280 -d --dynamic Display the dynamic section (if present)\n\
4281 -V --version-info Display the version sections (if present)\n\
4282 -A --arch-specific Display architecture specific information (if any)\n\
4283 -c --archive-index Display the symbol/file index in an archive\n\
4284 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4285 -x --hex-dump=<number|name>\n\
4286 Dump the contents of section <number|name> as bytes\n\
4287 -p --string-dump=<number|name>\n\
4288 Dump the contents of section <number|name> as strings\n\
4289 -R --relocated-dump=<number|name>\n\
4290 Dump the contents of section <number|name> as relocated bytes\n\
4291 -z --decompress Decompress section before dumping it\n\
4292 -w[lLiaprmfFsoRt] or\n\
4293 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4294 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4295 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4297 Display the contents of DWARF2 debug sections\n"));
4298 fprintf (stream
, _("\
4299 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4300 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4302 #ifdef SUPPORT_DISASSEMBLY
4303 fprintf (stream
, _("\
4304 -i --instruction-dump=<number|name>\n\
4305 Disassemble the contents of section <number|name>\n"));
4307 fprintf (stream
, _("\
4308 -I --histogram Display histogram of bucket list lengths\n\
4309 -W --wide Allow output width to exceed 80 characters\n\
4310 @<file> Read options from <file>\n\
4311 -H --help Display this information\n\
4312 -v --version Display the version number of readelf\n"));
4314 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4315 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4317 exit (stream
== stdout
? 0 : 1);
4320 /* Record the fact that the user wants the contents of section number
4321 SECTION to be displayed using the method(s) encoded as flags bits
4322 in TYPE. Note, TYPE can be zero if we are creating the array for
4326 request_dump_bynumber (unsigned int section
, dump_type type
)
4328 if (section
>= num_dump_sects
)
4330 dump_type
* new_dump_sects
;
4332 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4333 sizeof (* dump_sects
));
4335 if (new_dump_sects
== NULL
)
4336 error (_("Out of memory allocating dump request table.\n"));
4341 /* Copy current flag settings. */
4342 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4347 dump_sects
= new_dump_sects
;
4348 num_dump_sects
= section
+ 1;
4353 dump_sects
[section
] |= type
;
4358 /* Request a dump by section name. */
4361 request_dump_byname (const char * section
, dump_type type
)
4363 struct dump_list_entry
* new_request
;
4365 new_request
= (struct dump_list_entry
*)
4366 malloc (sizeof (struct dump_list_entry
));
4368 error (_("Out of memory allocating dump request table.\n"));
4370 new_request
->name
= strdup (section
);
4371 if (!new_request
->name
)
4372 error (_("Out of memory allocating dump request table.\n"));
4374 new_request
->type
= type
;
4376 new_request
->next
= dump_sects_byname
;
4377 dump_sects_byname
= new_request
;
4381 request_dump (dump_type type
)
4387 section
= strtoul (optarg
, & cp
, 0);
4389 if (! *cp
&& section
>= 0)
4390 request_dump_bynumber (section
, type
);
4392 request_dump_byname (optarg
, type
);
4397 parse_args (int argc
, char ** argv
)
4404 while ((c
= getopt_long
4405 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4423 do_section_groups
= TRUE
;
4426 do_histogram
= TRUE
;
4431 do_section_groups
= TRUE
;
4436 do_section_details
= TRUE
;
4447 do_using_dynamic
= TRUE
;
4471 do_histogram
= TRUE
;
4477 do_archive_index
= TRUE
;
4480 request_dump (HEX_DUMP
);
4483 request_dump (STRING_DUMP
);
4486 request_dump (RELOC_DUMP
);
4489 decompress_dumps
= TRUE
;
4495 do_debugging
= TRUE
;
4496 dwarf_select_sections_all ();
4500 do_debugging
= FALSE
;
4501 dwarf_select_sections_by_letters (optarg
);
4504 case OPTION_DEBUG_DUMP
:
4507 do_debugging
= TRUE
;
4510 do_debugging
= FALSE
;
4511 dwarf_select_sections_by_names (optarg
);
4514 case OPTION_DWARF_DEPTH
:
4518 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4521 case OPTION_DWARF_START
:
4525 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4528 case OPTION_DWARF_CHECK
:
4531 case OPTION_DYN_SYMS
:
4534 #ifdef SUPPORT_DISASSEMBLY
4536 request_dump (DISASS_DUMP
);
4540 print_version (program_name
);
4549 /* xgettext:c-format */
4550 error (_("Invalid option '-%c'\n"), c
);
4557 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4558 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4559 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4560 && !do_section_groups
&& !do_archive_index
4566 get_elf_class (unsigned int elf_class
)
4568 static char buff
[32];
4572 case ELFCLASSNONE
: return _("none");
4573 case ELFCLASS32
: return "ELF32";
4574 case ELFCLASS64
: return "ELF64";
4576 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4582 get_data_encoding (unsigned int encoding
)
4584 static char buff
[32];
4588 case ELFDATANONE
: return _("none");
4589 case ELFDATA2LSB
: return _("2's complement, little endian");
4590 case ELFDATA2MSB
: return _("2's complement, big endian");
4592 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4597 /* Decode the data held in 'elf_header'. */
4600 process_file_header (void)
4602 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4603 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4604 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4605 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4608 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4612 init_dwarf_regnames (elf_header
.e_machine
);
4618 printf (_("ELF Header:\n"));
4619 printf (_(" Magic: "));
4620 for (i
= 0; i
< EI_NIDENT
; i
++)
4621 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4623 printf (_(" Class: %s\n"),
4624 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4625 printf (_(" Data: %s\n"),
4626 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4627 printf (_(" Version: %d %s\n"),
4628 elf_header
.e_ident
[EI_VERSION
],
4629 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4631 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4632 ? _("<unknown: %lx>")
4634 printf (_(" OS/ABI: %s\n"),
4635 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4636 printf (_(" ABI Version: %d\n"),
4637 elf_header
.e_ident
[EI_ABIVERSION
]);
4638 printf (_(" Type: %s\n"),
4639 get_file_type (elf_header
.e_type
));
4640 printf (_(" Machine: %s\n"),
4641 get_machine_name (elf_header
.e_machine
));
4642 printf (_(" Version: 0x%lx\n"),
4643 (unsigned long) elf_header
.e_version
);
4645 printf (_(" Entry point address: "));
4646 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4647 printf (_("\n Start of program headers: "));
4648 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4649 printf (_(" (bytes into file)\n Start of section headers: "));
4650 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4651 printf (_(" (bytes into file)\n"));
4653 printf (_(" Flags: 0x%lx%s\n"),
4654 (unsigned long) elf_header
.e_flags
,
4655 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4656 printf (_(" Size of this header: %ld (bytes)\n"),
4657 (long) elf_header
.e_ehsize
);
4658 printf (_(" Size of program headers: %ld (bytes)\n"),
4659 (long) elf_header
.e_phentsize
);
4660 printf (_(" Number of program headers: %ld"),
4661 (long) elf_header
.e_phnum
);
4662 if (section_headers
!= NULL
4663 && elf_header
.e_phnum
== PN_XNUM
4664 && section_headers
[0].sh_info
!= 0)
4665 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4666 putc ('\n', stdout
);
4667 printf (_(" Size of section headers: %ld (bytes)\n"),
4668 (long) elf_header
.e_shentsize
);
4669 printf (_(" Number of section headers: %ld"),
4670 (long) elf_header
.e_shnum
);
4671 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4672 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4673 putc ('\n', stdout
);
4674 printf (_(" Section header string table index: %ld"),
4675 (long) elf_header
.e_shstrndx
);
4676 if (section_headers
!= NULL
4677 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4678 printf (" (%u)", section_headers
[0].sh_link
);
4679 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4680 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4681 printf (_(" <corrupt: out of range>"));
4682 putc ('\n', stdout
);
4685 if (section_headers
!= NULL
)
4687 if (elf_header
.e_phnum
== PN_XNUM
4688 && section_headers
[0].sh_info
!= 0)
4689 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4690 if (elf_header
.e_shnum
== SHN_UNDEF
)
4691 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4692 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4693 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4694 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4695 elf_header
.e_shstrndx
= SHN_UNDEF
;
4696 free (section_headers
);
4697 section_headers
= NULL
;
4704 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4706 Elf32_External_Phdr
* phdrs
;
4707 Elf32_External_Phdr
* external
;
4708 Elf_Internal_Phdr
* internal
;
4710 unsigned int size
= elf_header
.e_phentsize
;
4711 unsigned int num
= elf_header
.e_phnum
;
4713 /* PR binutils/17531: Cope with unexpected section header sizes. */
4714 if (size
== 0 || num
== 0)
4716 if (size
< sizeof * phdrs
)
4718 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4721 if (size
> sizeof * phdrs
)
4722 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4724 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4725 size
, num
, _("program headers"));
4729 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4730 i
< elf_header
.e_phnum
;
4731 i
++, internal
++, external
++)
4733 internal
->p_type
= BYTE_GET (external
->p_type
);
4734 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4735 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4736 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4737 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4738 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4739 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4740 internal
->p_align
= BYTE_GET (external
->p_align
);
4748 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4750 Elf64_External_Phdr
* phdrs
;
4751 Elf64_External_Phdr
* external
;
4752 Elf_Internal_Phdr
* internal
;
4754 unsigned int size
= elf_header
.e_phentsize
;
4755 unsigned int num
= elf_header
.e_phnum
;
4757 /* PR binutils/17531: Cope with unexpected section header sizes. */
4758 if (size
== 0 || num
== 0)
4760 if (size
< sizeof * phdrs
)
4762 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4765 if (size
> sizeof * phdrs
)
4766 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4768 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4769 size
, num
, _("program headers"));
4773 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4774 i
< elf_header
.e_phnum
;
4775 i
++, internal
++, external
++)
4777 internal
->p_type
= BYTE_GET (external
->p_type
);
4778 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4779 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4780 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4781 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4782 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4783 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4784 internal
->p_align
= BYTE_GET (external
->p_align
);
4791 /* Returns TRUE if the program headers were read into `program_headers'. */
4794 get_program_headers (FILE * file
)
4796 Elf_Internal_Phdr
* phdrs
;
4798 /* Check cache of prior read. */
4799 if (program_headers
!= NULL
)
4802 /* Be kind to memory checkers by looking for
4803 e_phnum values which we know must be invalid. */
4804 if (elf_header
.e_phnum
4805 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4806 >= current_file_size
)
4808 error (_("Too many program headers - %#x - the file is not that big\n"),
4809 elf_header
.e_phnum
);
4813 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4814 sizeof (Elf_Internal_Phdr
));
4817 error (_("Out of memory reading %u program headers\n"),
4818 elf_header
.e_phnum
);
4823 ? get_32bit_program_headers (file
, phdrs
)
4824 : get_64bit_program_headers (file
, phdrs
))
4826 program_headers
= phdrs
;
4834 /* Returns TRUE if the program headers were loaded. */
4837 process_program_headers (FILE * file
)
4839 Elf_Internal_Phdr
* segment
;
4841 Elf_Internal_Phdr
* previous_load
= NULL
;
4843 if (elf_header
.e_phnum
== 0)
4845 /* PR binutils/12467. */
4846 if (elf_header
.e_phoff
!= 0)
4848 warn (_("possibly corrupt ELF header - it has a non-zero program"
4849 " header offset, but no program headers\n"));
4852 else if (do_segments
)
4853 printf (_("\nThere are no program headers in this file.\n"));
4857 if (do_segments
&& !do_header
)
4859 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4860 printf (_("Entry point "));
4861 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4862 printf (_("\nThere are %d program headers, starting at offset "),
4863 elf_header
.e_phnum
);
4864 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4868 if (! get_program_headers (file
))
4873 if (elf_header
.e_phnum
> 1)
4874 printf (_("\nProgram Headers:\n"));
4876 printf (_("\nProgram Headers:\n"));
4880 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4883 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4887 (_(" Type Offset VirtAddr PhysAddr\n"));
4889 (_(" FileSiz MemSiz Flags Align\n"));
4896 for (i
= 0, segment
= program_headers
;
4897 i
< elf_header
.e_phnum
;
4902 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4906 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4907 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4908 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4909 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4910 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4912 (segment
->p_flags
& PF_R
? 'R' : ' '),
4913 (segment
->p_flags
& PF_W
? 'W' : ' '),
4914 (segment
->p_flags
& PF_X
? 'E' : ' '));
4915 printf ("%#lx", (unsigned long) segment
->p_align
);
4919 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4920 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4923 print_vma (segment
->p_offset
, FULL_HEX
);
4927 print_vma (segment
->p_vaddr
, FULL_HEX
);
4929 print_vma (segment
->p_paddr
, FULL_HEX
);
4932 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4933 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4936 print_vma (segment
->p_filesz
, FULL_HEX
);
4940 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4941 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4944 print_vma (segment
->p_memsz
, FULL_HEX
);
4948 (segment
->p_flags
& PF_R
? 'R' : ' '),
4949 (segment
->p_flags
& PF_W
? 'W' : ' '),
4950 (segment
->p_flags
& PF_X
? 'E' : ' '));
4952 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4953 printf ("%#lx", (unsigned long) segment
->p_align
);
4956 print_vma (segment
->p_align
, PREFIX_HEX
);
4961 print_vma (segment
->p_offset
, FULL_HEX
);
4963 print_vma (segment
->p_vaddr
, FULL_HEX
);
4965 print_vma (segment
->p_paddr
, FULL_HEX
);
4967 print_vma (segment
->p_filesz
, FULL_HEX
);
4969 print_vma (segment
->p_memsz
, FULL_HEX
);
4971 (segment
->p_flags
& PF_R
? 'R' : ' '),
4972 (segment
->p_flags
& PF_W
? 'W' : ' '),
4973 (segment
->p_flags
& PF_X
? 'E' : ' '));
4974 print_vma (segment
->p_align
, PREFIX_HEX
);
4977 putc ('\n', stdout
);
4980 switch (segment
->p_type
)
4983 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4984 required by the ELF standard, several programs, including the Linux
4985 kernel, make use of non-ordered segments. */
4987 && previous_load
->p_vaddr
> segment
->p_vaddr
)
4988 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4990 if (segment
->p_memsz
< segment
->p_filesz
)
4991 error (_("the segment's file size is larger than its memory size\n"));
4992 previous_load
= segment
;
4996 /* PR 20815 - Verify that the program header is loaded into memory. */
4997 if (i
> 0 && previous_load
!= NULL
)
4998 error (_("the PHDR segment must occur before any LOAD segment\n"));
4999 if (elf_header
.e_machine
!= EM_PARISC
)
5003 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
5004 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5005 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
5006 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5008 if (j
== elf_header
.e_phnum
)
5009 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5015 error (_("more than one dynamic segment\n"));
5017 /* By default, assume that the .dynamic section is the first
5018 section in the DYNAMIC segment. */
5019 dynamic_addr
= segment
->p_offset
;
5020 dynamic_size
= segment
->p_filesz
;
5022 /* Try to locate the .dynamic section. If there is
5023 a section header table, we can easily locate it. */
5024 if (section_headers
!= NULL
)
5026 Elf_Internal_Shdr
* sec
;
5028 sec
= find_section (".dynamic");
5029 if (sec
== NULL
|| sec
->sh_size
== 0)
5031 /* A corresponding .dynamic section is expected, but on
5032 IA-64/OpenVMS it is OK for it to be missing. */
5033 if (!is_ia64_vms ())
5034 error (_("no .dynamic section in the dynamic segment\n"));
5038 if (sec
->sh_type
== SHT_NOBITS
)
5044 dynamic_addr
= sec
->sh_offset
;
5045 dynamic_size
= sec
->sh_size
;
5047 if (dynamic_addr
< segment
->p_offset
5048 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5049 warn (_("the .dynamic section is not contained"
5050 " within the dynamic segment\n"));
5051 else if (dynamic_addr
> segment
->p_offset
)
5052 warn (_("the .dynamic section is not the first section"
5053 " in the dynamic segment.\n"));
5056 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5057 segment. Check this after matching against the section headers
5058 so we don't warn on debuginfo file (which have NOBITS .dynamic
5060 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5062 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5063 dynamic_addr
= dynamic_size
= 0;
5068 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5070 error (_("Unable to find program interpreter name\n"));
5074 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5076 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5077 error (_("Internal error: failed to create format string to display program interpreter\n"));
5079 program_interpreter
[0] = 0;
5080 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5081 error (_("Unable to read program interpreter name\n"));
5084 printf (_(" [Requesting program interpreter: %s]\n"),
5085 program_interpreter
);
5091 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5093 printf (_("\n Section to Segment mapping:\n"));
5094 printf (_(" Segment Sections...\n"));
5096 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5099 Elf_Internal_Shdr
* section
;
5101 segment
= program_headers
+ i
;
5102 section
= section_headers
+ 1;
5104 printf (" %2.2d ", i
);
5106 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5108 if (!ELF_TBSS_SPECIAL (section
, segment
)
5109 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5110 printf ("%s ", printable_section_name (section
));
5121 /* Find the file offset corresponding to VMA by using the program headers. */
5124 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5126 Elf_Internal_Phdr
* seg
;
5128 if (! get_program_headers (file
))
5130 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5134 for (seg
= program_headers
;
5135 seg
< program_headers
+ elf_header
.e_phnum
;
5138 if (seg
->p_type
!= PT_LOAD
)
5141 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5142 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5143 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5146 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5147 (unsigned long) vma
);
5152 /* Allocate memory and load the sections headers into the global pointer
5153 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5154 generate any error messages if the load fails. */
5157 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5159 Elf32_External_Shdr
* shdrs
;
5160 Elf_Internal_Shdr
* internal
;
5162 unsigned int size
= elf_header
.e_shentsize
;
5163 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5165 /* PR binutils/17531: Cope with unexpected section header sizes. */
5166 if (size
== 0 || num
== 0)
5168 if (size
< sizeof * shdrs
)
5171 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5174 if (!probe
&& size
> sizeof * shdrs
)
5175 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5177 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5179 probe
? NULL
: _("section headers"));
5183 if (section_headers
!= NULL
)
5184 free (section_headers
);
5185 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5186 sizeof (Elf_Internal_Shdr
));
5187 if (section_headers
== NULL
)
5190 error (_("Out of memory reading %u section headers\n"), num
);
5194 for (i
= 0, internal
= section_headers
;
5198 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5199 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5200 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5201 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5202 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5203 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5204 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5205 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5206 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5207 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5208 if (!probe
&& internal
->sh_link
> num
)
5209 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5210 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5211 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5219 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5221 Elf64_External_Shdr
* shdrs
;
5222 Elf_Internal_Shdr
* internal
;
5224 unsigned int size
= elf_header
.e_shentsize
;
5225 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5227 /* PR binutils/17531: Cope with unexpected section header sizes. */
5228 if (size
== 0 || num
== 0)
5230 if (size
< sizeof * shdrs
)
5233 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5236 if (! probe
&& size
> sizeof * shdrs
)
5237 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5239 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5241 probe
? NULL
: _("section headers"));
5245 if (section_headers
!= NULL
)
5246 free (section_headers
);
5247 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5248 sizeof (Elf_Internal_Shdr
));
5249 if (section_headers
== NULL
)
5252 error (_("Out of memory reading %u section headers\n"), num
);
5256 for (i
= 0, internal
= section_headers
;
5260 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5261 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5262 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5263 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5264 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5265 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5266 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5267 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5268 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5269 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5270 if (!probe
&& internal
->sh_link
> num
)
5271 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5272 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5273 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5280 static Elf_Internal_Sym
*
5281 get_32bit_elf_symbols (FILE * file
,
5282 Elf_Internal_Shdr
* section
,
5283 unsigned long * num_syms_return
)
5285 unsigned long number
= 0;
5286 Elf32_External_Sym
* esyms
= NULL
;
5287 Elf_External_Sym_Shndx
* shndx
= NULL
;
5288 Elf_Internal_Sym
* isyms
= NULL
;
5289 Elf_Internal_Sym
* psym
;
5292 if (section
->sh_size
== 0)
5294 if (num_syms_return
!= NULL
)
5295 * num_syms_return
= 0;
5299 /* Run some sanity checks first. */
5300 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5302 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5303 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5307 if (section
->sh_size
> current_file_size
)
5309 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5310 printable_section_name (section
), (unsigned long) section
->sh_size
);
5314 number
= section
->sh_size
/ section
->sh_entsize
;
5316 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5318 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5319 (unsigned long) section
->sh_size
,
5320 printable_section_name (section
),
5321 (unsigned long) section
->sh_entsize
);
5325 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5326 section
->sh_size
, _("symbols"));
5331 elf_section_list
* entry
;
5334 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5335 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5337 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5338 entry
->hdr
->sh_offset
,
5339 1, entry
->hdr
->sh_size
,
5340 _("symbol table section indicies"));
5343 /* PR17531: file: heap-buffer-overflow */
5344 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5346 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5347 printable_section_name (entry
->hdr
),
5348 (unsigned long) entry
->hdr
->sh_size
,
5349 (unsigned long) section
->sh_size
);
5355 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5359 error (_("Out of memory reading %lu symbols\n"),
5360 (unsigned long) number
);
5364 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5366 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5367 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5368 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5369 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5370 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5372 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5373 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5374 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5375 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5376 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5385 if (num_syms_return
!= NULL
)
5386 * num_syms_return
= isyms
== NULL
? 0 : number
;
5391 static Elf_Internal_Sym
*
5392 get_64bit_elf_symbols (FILE * file
,
5393 Elf_Internal_Shdr
* section
,
5394 unsigned long * num_syms_return
)
5396 unsigned long number
= 0;
5397 Elf64_External_Sym
* esyms
= NULL
;
5398 Elf_External_Sym_Shndx
* shndx
= NULL
;
5399 Elf_Internal_Sym
* isyms
= NULL
;
5400 Elf_Internal_Sym
* psym
;
5403 if (section
->sh_size
== 0)
5405 if (num_syms_return
!= NULL
)
5406 * num_syms_return
= 0;
5410 /* Run some sanity checks first. */
5411 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5413 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5414 printable_section_name (section
),
5415 (unsigned long) section
->sh_entsize
);
5419 if (section
->sh_size
> current_file_size
)
5421 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5422 printable_section_name (section
),
5423 (unsigned long) section
->sh_size
);
5427 number
= section
->sh_size
/ section
->sh_entsize
;
5429 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5431 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5432 (unsigned long) section
->sh_size
,
5433 printable_section_name (section
),
5434 (unsigned long) section
->sh_entsize
);
5438 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5439 section
->sh_size
, _("symbols"));
5444 elf_section_list
* entry
;
5447 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5448 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5450 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5451 entry
->hdr
->sh_offset
,
5452 1, entry
->hdr
->sh_size
,
5453 _("symbol table section indicies"));
5456 /* PR17531: file: heap-buffer-overflow */
5457 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5459 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5460 printable_section_name (entry
->hdr
),
5461 (unsigned long) entry
->hdr
->sh_size
,
5462 (unsigned long) section
->sh_size
);
5468 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5472 error (_("Out of memory reading %lu symbols\n"),
5473 (unsigned long) number
);
5477 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5479 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5480 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5481 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5482 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5484 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5486 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5487 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5488 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5490 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5491 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5500 if (num_syms_return
!= NULL
)
5501 * num_syms_return
= isyms
== NULL
? 0 : number
;
5507 get_elf_section_flags (bfd_vma sh_flags
)
5509 static char buff
[1024];
5511 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5513 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5514 bfd_vma os_flags
= 0;
5515 bfd_vma proc_flags
= 0;
5516 bfd_vma unknown_flags
= 0;
5524 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5525 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5526 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5527 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5528 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5529 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5530 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5531 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5532 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5533 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5534 /* IA-64 specific. */
5535 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5536 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5537 /* IA-64 OpenVMS specific. */
5538 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5539 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5540 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5541 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5542 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5543 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5545 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5546 /* SPARC specific. */
5547 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5548 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5550 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5551 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5552 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5554 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5557 if (do_section_details
)
5559 sprintf (buff
, "[%*.*lx]: ",
5560 field_size
, field_size
, (unsigned long) sh_flags
);
5561 p
+= field_size
+ 4;
5568 flag
= sh_flags
& - sh_flags
;
5571 if (do_section_details
)
5575 case SHF_WRITE
: sindex
= 0; break;
5576 case SHF_ALLOC
: sindex
= 1; break;
5577 case SHF_EXECINSTR
: sindex
= 2; break;
5578 case SHF_MERGE
: sindex
= 3; break;
5579 case SHF_STRINGS
: sindex
= 4; break;
5580 case SHF_INFO_LINK
: sindex
= 5; break;
5581 case SHF_LINK_ORDER
: sindex
= 6; break;
5582 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5583 case SHF_GROUP
: sindex
= 8; break;
5584 case SHF_TLS
: sindex
= 9; break;
5585 case SHF_EXCLUDE
: sindex
= 18; break;
5586 case SHF_COMPRESSED
: sindex
= 20; break;
5587 case SHF_GNU_MBIND
: sindex
= 24; break;
5591 switch (elf_header
.e_machine
)
5594 if (flag
== SHF_IA_64_SHORT
)
5596 else if (flag
== SHF_IA_64_NORECOV
)
5599 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5602 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5603 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5604 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5605 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5606 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5607 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5618 case EM_OLD_SPARCV9
:
5619 case EM_SPARC32PLUS
:
5622 if (flag
== SHF_ORDERED
)
5629 case SHF_ENTRYSECT
: sindex
= 21; break;
5630 case SHF_ARM_PURECODE
: sindex
= 22; break;
5631 case SHF_COMDEF
: sindex
= 23; break;
5643 if (p
!= buff
+ field_size
+ 4)
5645 if (size
< (10 + 2))
5647 warn (_("Internal error: not enough buffer room for section flag info"));
5648 return _("<unknown>");
5655 size
-= flags
[sindex
].len
;
5656 p
= stpcpy (p
, flags
[sindex
].str
);
5658 else if (flag
& SHF_MASKOS
)
5660 else if (flag
& SHF_MASKPROC
)
5663 unknown_flags
|= flag
;
5669 case SHF_WRITE
: *p
= 'W'; break;
5670 case SHF_ALLOC
: *p
= 'A'; break;
5671 case SHF_EXECINSTR
: *p
= 'X'; break;
5672 case SHF_MERGE
: *p
= 'M'; break;
5673 case SHF_STRINGS
: *p
= 'S'; break;
5674 case SHF_INFO_LINK
: *p
= 'I'; break;
5675 case SHF_LINK_ORDER
: *p
= 'L'; break;
5676 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5677 case SHF_GROUP
: *p
= 'G'; break;
5678 case SHF_TLS
: *p
= 'T'; break;
5679 case SHF_EXCLUDE
: *p
= 'E'; break;
5680 case SHF_COMPRESSED
: *p
= 'C'; break;
5681 case SHF_GNU_MBIND
: *p
= 'D'; break;
5684 if ((elf_header
.e_machine
== EM_X86_64
5685 || elf_header
.e_machine
== EM_L1OM
5686 || elf_header
.e_machine
== EM_K1OM
)
5687 && flag
== SHF_X86_64_LARGE
)
5689 else if (elf_header
.e_machine
== EM_ARM
5690 && flag
== SHF_ARM_PURECODE
)
5692 else if (flag
& SHF_MASKOS
)
5695 sh_flags
&= ~ SHF_MASKOS
;
5697 else if (flag
& SHF_MASKPROC
)
5700 sh_flags
&= ~ SHF_MASKPROC
;
5710 if (do_section_details
)
5714 size
-= 5 + field_size
;
5715 if (p
!= buff
+ field_size
+ 4)
5719 warn (_("Internal error: not enough buffer room for section flag info"));
5720 return _("<unknown>");
5726 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5727 (unsigned long) os_flags
);
5728 p
+= 5 + field_size
;
5732 size
-= 7 + field_size
;
5733 if (p
!= buff
+ field_size
+ 4)
5737 warn (_("Internal error: not enough buffer room for section flag info"));
5738 return _("<unknown>");
5744 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5745 (unsigned long) proc_flags
);
5746 p
+= 7 + field_size
;
5750 size
-= 10 + field_size
;
5751 if (p
!= buff
+ field_size
+ 4)
5755 warn (_("Internal error: not enough buffer room for section flag info"));
5756 return _("<unknown>");
5762 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5763 (unsigned long) unknown_flags
);
5764 p
+= 10 + field_size
;
5773 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5777 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5779 if (size
< sizeof (* echdr
))
5781 error (_("Compressed section is too small even for a compression header\n"));
5785 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5786 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5787 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5788 return sizeof (*echdr
);
5792 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5794 if (size
< sizeof (* echdr
))
5796 error (_("Compressed section is too small even for a compression header\n"));
5800 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5801 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5802 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5803 return sizeof (*echdr
);
5808 process_section_headers (FILE * file
)
5810 Elf_Internal_Shdr
* section
;
5813 section_headers
= NULL
;
5815 if (elf_header
.e_shnum
== 0)
5817 /* PR binutils/12467. */
5818 if (elf_header
.e_shoff
!= 0)
5820 warn (_("possibly corrupt ELF file header - it has a non-zero"
5821 " section header offset, but no section headers\n"));
5824 else if (do_sections
)
5825 printf (_("\nThere are no sections in this file.\n"));
5830 if (do_sections
&& !do_header
)
5831 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5832 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5836 if (! get_32bit_section_headers (file
, FALSE
))
5841 if (! get_64bit_section_headers (file
, FALSE
))
5845 /* Read in the string table, so that we have names to display. */
5846 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5847 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5849 section
= section_headers
+ elf_header
.e_shstrndx
;
5851 if (section
->sh_size
!= 0)
5853 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5854 1, section
->sh_size
,
5857 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5861 /* Scan the sections for the dynamic symbol table
5862 and dynamic string table and debug sections. */
5863 dynamic_symbols
= NULL
;
5864 dynamic_strings
= NULL
;
5865 dynamic_syminfo
= NULL
;
5866 symtab_shndx_list
= NULL
;
5868 eh_addr_size
= is_32bit_elf
? 4 : 8;
5869 switch (elf_header
.e_machine
)
5872 case EM_MIPS_RS3_LE
:
5873 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5874 FDE addresses. However, the ABI also has a semi-official ILP32
5875 variant for which the normal FDE address size rules apply.
5877 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5878 section, where XX is the size of longs in bits. Unfortunately,
5879 earlier compilers provided no way of distinguishing ILP32 objects
5880 from LP64 objects, so if there's any doubt, we should assume that
5881 the official LP64 form is being used. */
5882 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5883 && find_section (".gcc_compiled_long32") == NULL
)
5889 switch (elf_header
.e_flags
& EF_H8_MACH
)
5891 case E_H8_MACH_H8300
:
5892 case E_H8_MACH_H8300HN
:
5893 case E_H8_MACH_H8300SN
:
5894 case E_H8_MACH_H8300SXN
:
5897 case E_H8_MACH_H8300H
:
5898 case E_H8_MACH_H8300S
:
5899 case E_H8_MACH_H8300SX
:
5907 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5909 case EF_M32C_CPU_M16C
:
5916 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5919 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5920 if (section->sh_entsize != expected_entsize) \
5923 sprintf_vma (buf, section->sh_entsize); \
5924 /* Note: coded this way so that there is a single string for \
5926 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5927 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5928 (unsigned) expected_entsize); \
5929 section->sh_entsize = expected_entsize; \
5934 #define CHECK_ENTSIZE(section, i, type) \
5935 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5936 sizeof (Elf64_External_##type))
5938 for (i
= 0, section
= section_headers
;
5939 i
< elf_header
.e_shnum
;
5942 char * name
= SECTION_NAME (section
);
5944 if (section
->sh_type
== SHT_DYNSYM
)
5946 if (dynamic_symbols
!= NULL
)
5948 error (_("File contains multiple dynamic symbol tables\n"));
5952 CHECK_ENTSIZE (section
, i
, Sym
);
5953 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5955 else if (section
->sh_type
== SHT_STRTAB
5956 && streq (name
, ".dynstr"))
5958 if (dynamic_strings
!= NULL
)
5960 error (_("File contains multiple dynamic string tables\n"));
5964 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5965 1, section
->sh_size
,
5966 _("dynamic strings"));
5967 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5969 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5971 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5972 entry
->hdr
= section
;
5973 entry
->next
= symtab_shndx_list
;
5974 symtab_shndx_list
= entry
;
5976 else if (section
->sh_type
== SHT_SYMTAB
)
5977 CHECK_ENTSIZE (section
, i
, Sym
);
5978 else if (section
->sh_type
== SHT_GROUP
)
5979 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5980 else if (section
->sh_type
== SHT_REL
)
5981 CHECK_ENTSIZE (section
, i
, Rel
);
5982 else if (section
->sh_type
== SHT_RELA
)
5983 CHECK_ENTSIZE (section
, i
, Rela
);
5984 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5985 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5986 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5987 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5988 || do_debug_addr
|| do_debug_cu_index
)
5989 && (const_strneq (name
, ".debug_")
5990 || const_strneq (name
, ".zdebug_")))
5993 name
+= sizeof (".zdebug_") - 1;
5995 name
+= sizeof (".debug_") - 1;
5998 || (do_debug_info
&& const_strneq (name
, "info"))
5999 || (do_debug_info
&& const_strneq (name
, "types"))
6000 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6001 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6002 || (do_debug_lines
&& const_strneq (name
, "line."))
6003 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6004 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6005 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6006 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6007 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6008 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6009 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6010 || (do_debug_frames
&& const_strneq (name
, "frame"))
6011 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6012 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6013 || (do_debug_str
&& const_strneq (name
, "str"))
6014 || (do_debug_loc
&& const_strneq (name
, "loc"))
6015 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6016 || (do_debug_addr
&& const_strneq (name
, "addr"))
6017 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6018 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6020 request_dump_bynumber (i
, DEBUG_DUMP
);
6022 /* Linkonce section to be combined with .debug_info at link time. */
6023 else if ((do_debugging
|| do_debug_info
)
6024 && const_strneq (name
, ".gnu.linkonce.wi."))
6025 request_dump_bynumber (i
, DEBUG_DUMP
);
6026 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6027 request_dump_bynumber (i
, DEBUG_DUMP
);
6028 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
6029 request_dump_bynumber (i
, DEBUG_DUMP
);
6030 /* Trace sections for Itanium VMS. */
6031 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6032 || do_trace_aranges
)
6033 && const_strneq (name
, ".trace_"))
6035 name
+= sizeof (".trace_") - 1;
6038 || (do_trace_info
&& streq (name
, "info"))
6039 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6040 || (do_trace_aranges
&& streq (name
, "aranges"))
6042 request_dump_bynumber (i
, DEBUG_DUMP
);
6049 if (elf_header
.e_shnum
> 1)
6050 printf (_("\nSection Headers:\n"));
6052 printf (_("\nSection Header:\n"));
6056 if (do_section_details
)
6058 printf (_(" [Nr] Name\n"));
6059 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6063 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6067 if (do_section_details
)
6069 printf (_(" [Nr] Name\n"));
6070 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6074 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6078 if (do_section_details
)
6080 printf (_(" [Nr] Name\n"));
6081 printf (_(" Type Address Offset Link\n"));
6082 printf (_(" Size EntSize Info Align\n"));
6086 printf (_(" [Nr] Name Type Address Offset\n"));
6087 printf (_(" Size EntSize Flags Link Info Align\n"));
6091 if (do_section_details
)
6092 printf (_(" Flags\n"));
6094 for (i
= 0, section
= section_headers
;
6095 i
< elf_header
.e_shnum
;
6098 /* Run some sanity checks on the section header. */
6100 /* Check the sh_link field. */
6101 switch (section
->sh_type
)
6103 case SHT_SYMTAB_SHNDX
:
6107 case SHT_GNU_versym
:
6110 if (section
->sh_link
< 1
6111 || section
->sh_link
>= elf_header
.e_shnum
6112 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6113 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6114 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6115 i
, section
->sh_link
);
6121 case SHT_GNU_verneed
:
6122 case SHT_GNU_verdef
:
6123 case SHT_GNU_LIBLIST
:
6124 if (section
->sh_link
< 1
6125 || section
->sh_link
>= elf_header
.e_shnum
6126 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6127 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6128 i
, section
->sh_link
);
6131 case SHT_INIT_ARRAY
:
6132 case SHT_FINI_ARRAY
:
6133 case SHT_PREINIT_ARRAY
:
6134 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6135 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6136 i
, section
->sh_link
);
6140 /* FIXME: Add support for target specific section types. */
6141 #if 0 /* Currently we do not check other section types as there are too
6142 many special cases. Stab sections for example have a type
6143 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6145 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6146 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6147 i
, section
->sh_link
);
6152 /* Check the sh_info field. */
6153 switch (section
->sh_type
)
6157 if (section
->sh_info
< 1
6158 || section
->sh_info
>= elf_header
.e_shnum
6159 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6160 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6161 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6162 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6163 /* FIXME: Are other section types valid ? */
6164 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6166 if (section
->sh_info
== 0
6167 && (streq (SECTION_NAME (section
), ".rel.dyn")
6168 || streq (SECTION_NAME (section
), ".rela.dyn")))
6169 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6170 of zero. The relocations in these sections may apply
6171 to many different sections. */
6174 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6175 i
, section
->sh_info
);
6181 case SHT_SYMTAB_SHNDX
:
6182 case SHT_INIT_ARRAY
:
6183 case SHT_FINI_ARRAY
:
6184 case SHT_PREINIT_ARRAY
:
6185 if (section
->sh_info
!= 0)
6186 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6187 i
, section
->sh_info
);
6193 /* A symbol index - we assume that it is valid. */
6197 /* FIXME: Add support for target specific section types. */
6198 if (section
->sh_type
== SHT_NOBITS
)
6199 /* NOBITS section headers with non-zero sh_info fields can be
6200 created when a binary is stripped of everything but its debug
6201 information. The stripped sections have their headers
6202 preserved but their types set to SHT_NOBITS. So do not check
6203 this type of section. */
6205 else if (section
->sh_flags
& SHF_INFO_LINK
)
6207 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6208 warn (_("[%2u]: Expected link to another section in info field"), i
);
6210 else if (section
->sh_type
< SHT_LOOS
6211 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6212 && section
->sh_info
!= 0)
6213 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6214 i
, section
->sh_info
);
6218 /* Check the sh_size field. */
6219 if (section
->sh_size
> current_file_size
6220 && section
->sh_type
!= SHT_NOBITS
6221 && section
->sh_type
!= SHT_NULL
6222 && section
->sh_type
< SHT_LOOS
)
6223 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6225 printf (" [%2u] ", i
);
6226 if (do_section_details
)
6227 printf ("%s\n ", printable_section_name (section
));
6229 print_symbol (-17, SECTION_NAME (section
));
6231 printf (do_wide
? " %-15s " : " %-15.15s ",
6232 get_section_type_name (section
->sh_type
));
6236 const char * link_too_big
= NULL
;
6238 print_vma (section
->sh_addr
, LONG_HEX
);
6240 printf ( " %6.6lx %6.6lx %2.2lx",
6241 (unsigned long) section
->sh_offset
,
6242 (unsigned long) section
->sh_size
,
6243 (unsigned long) section
->sh_entsize
);
6245 if (do_section_details
)
6246 fputs (" ", stdout
);
6248 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6250 if (section
->sh_link
>= elf_header
.e_shnum
)
6253 /* The sh_link value is out of range. Normally this indicates
6254 an error but it can have special values in Solaris binaries. */
6255 switch (elf_header
.e_machine
)
6262 case EM_OLD_SPARCV9
:
6263 case EM_SPARC32PLUS
:
6266 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6267 link_too_big
= "BEFORE";
6268 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6269 link_too_big
= "AFTER";
6276 if (do_section_details
)
6278 if (link_too_big
!= NULL
&& * link_too_big
)
6279 printf ("<%s> ", link_too_big
);
6281 printf ("%2u ", section
->sh_link
);
6282 printf ("%3u %2lu\n", section
->sh_info
,
6283 (unsigned long) section
->sh_addralign
);
6286 printf ("%2u %3u %2lu\n",
6289 (unsigned long) section
->sh_addralign
);
6291 if (link_too_big
&& ! * link_too_big
)
6292 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6293 i
, section
->sh_link
);
6297 print_vma (section
->sh_addr
, LONG_HEX
);
6299 if ((long) section
->sh_offset
== section
->sh_offset
)
6300 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6304 print_vma (section
->sh_offset
, LONG_HEX
);
6307 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6308 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6312 print_vma (section
->sh_size
, LONG_HEX
);
6315 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6316 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6320 print_vma (section
->sh_entsize
, LONG_HEX
);
6323 if (do_section_details
)
6324 fputs (" ", stdout
);
6326 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6328 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6330 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6331 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6334 print_vma (section
->sh_addralign
, DEC
);
6338 else if (do_section_details
)
6340 printf (" %-15.15s ",
6341 get_section_type_name (section
->sh_type
));
6342 print_vma (section
->sh_addr
, LONG_HEX
);
6343 if ((long) section
->sh_offset
== section
->sh_offset
)
6344 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6348 print_vma (section
->sh_offset
, LONG_HEX
);
6350 printf (" %u\n ", section
->sh_link
);
6351 print_vma (section
->sh_size
, LONG_HEX
);
6353 print_vma (section
->sh_entsize
, LONG_HEX
);
6355 printf (" %-16u %lu\n",
6357 (unsigned long) section
->sh_addralign
);
6362 print_vma (section
->sh_addr
, LONG_HEX
);
6363 if ((long) section
->sh_offset
== section
->sh_offset
)
6364 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6368 print_vma (section
->sh_offset
, LONG_HEX
);
6371 print_vma (section
->sh_size
, LONG_HEX
);
6373 print_vma (section
->sh_entsize
, LONG_HEX
);
6375 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6377 printf (" %2u %3u %lu\n",
6380 (unsigned long) section
->sh_addralign
);
6383 if (do_section_details
)
6385 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6386 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6388 /* Minimum section size is 12 bytes for 32-bit compression
6389 header + 12 bytes for compressed data header. */
6390 unsigned char buf
[24];
6392 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6393 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6394 sizeof (buf
), _("compression header")))
6396 Elf_Internal_Chdr chdr
;
6398 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6400 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6403 printf (_(" [<unknown>: 0x%x], "),
6405 print_vma (chdr
.ch_size
, LONG_HEX
);
6406 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6412 if (!do_section_details
)
6414 /* The ordering of the letters shown here matches the ordering of the
6415 corresponding SHF_xxx values, and hence the order in which these
6416 letters will be displayed to the user. */
6417 printf (_("Key to Flags:\n\
6418 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6419 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6420 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6421 if (elf_header
.e_machine
== EM_X86_64
6422 || elf_header
.e_machine
== EM_L1OM
6423 || elf_header
.e_machine
== EM_K1OM
)
6424 printf (_("l (large), "));
6425 else if (elf_header
.e_machine
== EM_ARM
)
6426 printf (_("y (purecode), "));
6427 printf ("p (processor specific)\n");
6434 get_group_flags (unsigned int flags
)
6436 static char buff
[128];
6440 else if (flags
== GRP_COMDAT
)
6443 snprintf (buff
, 14, _("[0x%x: "), flags
);
6445 flags
&= ~ GRP_COMDAT
;
6446 if (flags
& GRP_MASKOS
)
6448 strcat (buff
, "<OS specific>");
6449 flags
&= ~ GRP_MASKOS
;
6452 if (flags
& GRP_MASKPROC
)
6454 strcat (buff
, "<PROC specific>");
6455 flags
&= ~ GRP_MASKPROC
;
6459 strcat (buff
, "<unknown>");
6466 process_section_groups (FILE * file
)
6468 Elf_Internal_Shdr
* section
;
6470 struct group
* group
;
6471 Elf_Internal_Shdr
* symtab_sec
;
6472 Elf_Internal_Shdr
* strtab_sec
;
6473 Elf_Internal_Sym
* symtab
;
6474 unsigned long num_syms
;
6478 /* Don't process section groups unless needed. */
6479 if (!do_unwind
&& !do_section_groups
)
6482 if (elf_header
.e_shnum
== 0)
6484 if (do_section_groups
)
6485 printf (_("\nThere are no sections to group in this file.\n"));
6490 if (section_headers
== NULL
)
6492 error (_("Section headers are not available!\n"));
6493 /* PR 13622: This can happen with a corrupt ELF header. */
6497 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6498 sizeof (struct group
*));
6500 if (section_headers_groups
== NULL
)
6502 error (_("Out of memory reading %u section group headers\n"),
6503 elf_header
.e_shnum
);
6507 /* Scan the sections for the group section. */
6509 for (i
= 0, section
= section_headers
;
6510 i
< elf_header
.e_shnum
;
6512 if (section
->sh_type
== SHT_GROUP
)
6515 if (group_count
== 0)
6517 if (do_section_groups
)
6518 printf (_("\nThere are no section groups in this file.\n"));
6523 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6525 if (section_groups
== NULL
)
6527 error (_("Out of memory reading %lu groups\n"),
6528 (unsigned long) group_count
);
6538 for (i
= 0, section
= section_headers
, group
= section_groups
;
6539 i
< elf_header
.e_shnum
;
6542 if (section
->sh_type
== SHT_GROUP
)
6544 const char * name
= printable_section_name (section
);
6545 const char * group_name
;
6546 unsigned char * start
;
6547 unsigned char * indices
;
6548 unsigned int entry
, j
, size
;
6549 Elf_Internal_Shdr
* sec
;
6550 Elf_Internal_Sym
* sym
;
6552 /* Get the symbol table. */
6553 if (section
->sh_link
>= elf_header
.e_shnum
6554 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6557 error (_("Bad sh_link in group section `%s'\n"), name
);
6561 if (symtab_sec
!= sec
)
6566 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6571 error (_("Corrupt header in group section `%s'\n"), name
);
6575 if (section
->sh_info
>= num_syms
)
6577 error (_("Bad sh_info in group section `%s'\n"), name
);
6581 sym
= symtab
+ section
->sh_info
;
6583 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6585 if (sym
->st_shndx
== 0
6586 || sym
->st_shndx
>= elf_header
.e_shnum
)
6588 error (_("Bad sh_info in group section `%s'\n"), name
);
6592 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6601 /* Get the string table. */
6602 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6611 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6617 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6618 1, strtab_sec
->sh_size
,
6620 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6622 group_name
= sym
->st_name
< strtab_size
6623 ? strtab
+ sym
->st_name
: _("<corrupt>");
6626 /* PR 17531: file: loop. */
6627 if (section
->sh_entsize
> section
->sh_size
)
6629 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6630 printable_section_name (section
),
6631 (unsigned long) section
->sh_entsize
,
6632 (unsigned long) section
->sh_size
);
6636 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6637 1, section
->sh_size
,
6643 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6644 entry
= byte_get (indices
, 4);
6647 if (do_section_groups
)
6649 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6650 get_group_flags (entry
), i
, name
, group_name
, size
);
6652 printf (_(" [Index] Name\n"));
6655 group
->group_index
= i
;
6657 for (j
= 0; j
< size
; j
++)
6659 struct group_list
* g
;
6661 entry
= byte_get (indices
, 4);
6664 if (entry
>= elf_header
.e_shnum
)
6666 static unsigned num_group_errors
= 0;
6668 if (num_group_errors
++ < 10)
6670 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6671 entry
, i
, elf_header
.e_shnum
- 1);
6672 if (num_group_errors
== 10)
6673 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6678 if (section_headers_groups
[entry
] != NULL
)
6682 static unsigned num_errs
= 0;
6684 if (num_errs
++ < 10)
6686 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6688 section_headers_groups
[entry
]->group_index
);
6690 warn (_("Further error messages about already contained group sections suppressed\n"));
6696 /* Intel C/C++ compiler may put section 0 in a
6697 section group. We just warn it the first time
6698 and ignore it afterwards. */
6699 static bfd_boolean warned
= FALSE
;
6702 error (_("section 0 in group section [%5u]\n"),
6703 section_headers_groups
[entry
]->group_index
);
6709 section_headers_groups
[entry
] = group
;
6711 if (do_section_groups
)
6713 sec
= section_headers
+ entry
;
6714 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6717 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6718 g
->section_index
= entry
;
6719 g
->next
= group
->root
;
6737 /* Data used to display dynamic fixups. */
6739 struct ia64_vms_dynfixup
6741 bfd_vma needed_ident
; /* Library ident number. */
6742 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6743 bfd_vma fixup_needed
; /* Index of the library. */
6744 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6745 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6748 /* Data used to display dynamic relocations. */
6750 struct ia64_vms_dynimgrela
6752 bfd_vma img_rela_cnt
; /* Number of relocations. */
6753 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6756 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6760 dump_ia64_vms_dynamic_fixups (FILE * file
,
6761 struct ia64_vms_dynfixup
* fixup
,
6762 const char * strtab
,
6763 unsigned int strtab_sz
)
6765 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6767 const char * lib_name
;
6769 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6770 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6771 _("dynamic section image fixups"));
6775 if (fixup
->needed
< strtab_sz
)
6776 lib_name
= strtab
+ fixup
->needed
;
6779 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6780 (unsigned long) fixup
->needed
);
6783 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6784 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6786 (_("Seg Offset Type SymVec DataType\n"));
6788 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6793 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6794 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6795 type
= BYTE_GET (imfs
[i
].type
);
6796 rtype
= elf_ia64_reloc_type (type
);
6798 printf (" 0x%08x ", type
);
6800 printf (" %-32s ", rtype
);
6801 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6802 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6809 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6812 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6814 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6817 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6818 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6819 _("dynamic section image relocations"));
6823 printf (_("\nImage relocs\n"));
6825 (_("Seg Offset Type Addend Seg Sym Off\n"));
6827 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6832 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6833 printf ("%08" BFD_VMA_FMT
"x ",
6834 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6835 type
= BYTE_GET (imrs
[i
].type
);
6836 rtype
= elf_ia64_reloc_type (type
);
6838 printf ("0x%08x ", type
);
6840 printf ("%-31s ", rtype
);
6841 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6842 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6843 printf ("%08" BFD_VMA_FMT
"x\n",
6844 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6851 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6854 process_ia64_vms_dynamic_relocs (FILE *file
)
6856 struct ia64_vms_dynfixup fixup
;
6857 struct ia64_vms_dynimgrela imgrela
;
6858 Elf_Internal_Dyn
*entry
;
6859 bfd_vma strtab_off
= 0;
6860 bfd_vma strtab_sz
= 0;
6861 char *strtab
= NULL
;
6862 bfd_boolean res
= TRUE
;
6864 memset (&fixup
, 0, sizeof (fixup
));
6865 memset (&imgrela
, 0, sizeof (imgrela
));
6867 /* Note: the order of the entries is specified by the OpenVMS specs. */
6868 for (entry
= dynamic_section
;
6869 entry
< dynamic_section
+ dynamic_nent
;
6872 switch (entry
->d_tag
)
6874 case DT_IA_64_VMS_STRTAB_OFFSET
:
6875 strtab_off
= entry
->d_un
.d_val
;
6878 strtab_sz
= entry
->d_un
.d_val
;
6880 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6881 1, strtab_sz
, _("dynamic string section"));
6884 case DT_IA_64_VMS_NEEDED_IDENT
:
6885 fixup
.needed_ident
= entry
->d_un
.d_val
;
6888 fixup
.needed
= entry
->d_un
.d_val
;
6890 case DT_IA_64_VMS_FIXUP_NEEDED
:
6891 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6893 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6894 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6896 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6897 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6898 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6901 case DT_IA_64_VMS_IMG_RELA_CNT
:
6902 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6904 case DT_IA_64_VMS_IMG_RELA_OFF
:
6905 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6906 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6928 dynamic_relocations
[] =
6930 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6931 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6932 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6935 /* Process the reloc section. */
6938 process_relocs (FILE * file
)
6940 unsigned long rel_size
;
6941 unsigned long rel_offset
;
6946 if (do_using_dynamic
)
6950 bfd_boolean has_dynamic_reloc
;
6953 has_dynamic_reloc
= FALSE
;
6955 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6957 is_rela
= dynamic_relocations
[i
].rela
;
6958 name
= dynamic_relocations
[i
].name
;
6959 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6960 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6963 has_dynamic_reloc
= TRUE
;
6965 if (is_rela
== UNKNOWN
)
6967 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6968 switch (dynamic_info
[DT_PLTREL
])
6982 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6983 name
, rel_offset
, rel_size
);
6985 dump_relocations (file
,
6986 offset_from_vma (file
, rel_offset
, rel_size
),
6988 dynamic_symbols
, num_dynamic_syms
,
6989 dynamic_strings
, dynamic_strings_length
,
6990 is_rela
, TRUE
/* is_dynamic */);
6995 if (process_ia64_vms_dynamic_relocs (file
))
6996 has_dynamic_reloc
= TRUE
;
6998 if (! has_dynamic_reloc
)
6999 printf (_("\nThere are no dynamic relocations in this file.\n"));
7003 Elf_Internal_Shdr
* section
;
7005 bfd_boolean found
= FALSE
;
7007 for (i
= 0, section
= section_headers
;
7008 i
< elf_header
.e_shnum
;
7011 if ( section
->sh_type
!= SHT_RELA
7012 && section
->sh_type
!= SHT_REL
)
7015 rel_offset
= section
->sh_offset
;
7016 rel_size
= section
->sh_size
;
7020 Elf_Internal_Shdr
* strsec
;
7023 printf (_("\nRelocation section "));
7025 if (string_table
== NULL
)
7026 printf ("%d", section
->sh_name
);
7028 printf ("'%s'", printable_section_name (section
));
7030 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7031 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
7033 is_rela
= section
->sh_type
== SHT_RELA
;
7035 if (section
->sh_link
!= 0
7036 && section
->sh_link
< elf_header
.e_shnum
)
7038 Elf_Internal_Shdr
* symsec
;
7039 Elf_Internal_Sym
* symtab
;
7040 unsigned long nsyms
;
7041 unsigned long strtablen
= 0;
7042 char * strtab
= NULL
;
7044 symsec
= section_headers
+ section
->sh_link
;
7045 if (symsec
->sh_type
!= SHT_SYMTAB
7046 && symsec
->sh_type
!= SHT_DYNSYM
)
7049 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7054 if (symsec
->sh_link
!= 0
7055 && symsec
->sh_link
< elf_header
.e_shnum
)
7057 strsec
= section_headers
+ symsec
->sh_link
;
7059 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7062 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7065 dump_relocations (file
, rel_offset
, rel_size
,
7066 symtab
, nsyms
, strtab
, strtablen
,
7068 symsec
->sh_type
== SHT_DYNSYM
);
7074 dump_relocations (file
, rel_offset
, rel_size
,
7075 NULL
, 0, NULL
, 0, is_rela
,
7076 FALSE
/* is_dynamic */);
7083 printf (_("\nThere are no relocations in this file.\n"));
7089 /* An absolute address consists of a section and an offset. If the
7090 section is NULL, the offset itself is the address, otherwise, the
7091 address equals to LOAD_ADDRESS(section) + offset. */
7095 unsigned short section
;
7099 #define ABSADDR(a) \
7101 ? section_headers [(a).section].sh_addr + (a).offset \
7104 /* Find the nearest symbol at or below ADDR. Returns the symbol
7105 name, if found, and the offset from the symbol to ADDR. */
7108 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7109 unsigned long nsyms
,
7110 const char * strtab
,
7111 unsigned long strtab_size
,
7112 struct absaddr addr
,
7113 const char ** symname
,
7116 bfd_vma dist
= 0x100000;
7117 Elf_Internal_Sym
* sym
;
7118 Elf_Internal_Sym
* beg
;
7119 Elf_Internal_Sym
* end
;
7120 Elf_Internal_Sym
* best
= NULL
;
7122 REMOVE_ARCH_BITS (addr
.offset
);
7124 end
= symtab
+ nsyms
;
7130 sym
= beg
+ (end
- beg
) / 2;
7132 value
= sym
->st_value
;
7133 REMOVE_ARCH_BITS (value
);
7135 if (sym
->st_name
!= 0
7136 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7137 && addr
.offset
>= value
7138 && addr
.offset
- value
< dist
)
7141 dist
= addr
.offset
- value
;
7146 if (addr
.offset
< value
)
7154 *symname
= (best
->st_name
>= strtab_size
7155 ? _("<corrupt>") : strtab
+ best
->st_name
);
7161 *offset
= addr
.offset
;
7164 static /* signed */ int
7165 symcmp (const void *p
, const void *q
)
7167 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7168 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7170 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7173 /* Process the unwind section. */
7175 #include "unwind-ia64.h"
7177 struct ia64_unw_table_entry
7179 struct absaddr start
;
7181 struct absaddr info
;
7184 struct ia64_unw_aux_info
7186 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7187 unsigned long table_len
; /* Length of unwind table. */
7188 unsigned char * info
; /* Unwind info. */
7189 unsigned long info_size
; /* Size of unwind info. */
7190 bfd_vma info_addr
; /* Starting address of unwind info. */
7191 bfd_vma seg_base
; /* Starting address of segment. */
7192 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7193 unsigned long nsyms
; /* Number of symbols. */
7194 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7195 unsigned long nfuns
; /* Number of entries in funtab. */
7196 char * strtab
; /* The string table. */
7197 unsigned long strtab_size
; /* Size of string table. */
7201 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7203 struct ia64_unw_table_entry
* tp
;
7204 unsigned long j
, nfuns
;
7206 bfd_boolean res
= TRUE
;
7208 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7209 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7210 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7211 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7213 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7215 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7219 const unsigned char * dp
;
7220 const unsigned char * head
;
7221 const unsigned char * end
;
7222 const char * procname
;
7224 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7225 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7227 fputs ("\n<", stdout
);
7231 fputs (procname
, stdout
);
7234 printf ("+%lx", (unsigned long) offset
);
7237 fputs (">: [", stdout
);
7238 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7239 fputc ('-', stdout
);
7240 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7241 printf ("], info at +0x%lx\n",
7242 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7244 /* PR 17531: file: 86232b32. */
7245 if (aux
->info
== NULL
)
7248 /* PR 17531: file: 0997b4d1. */
7249 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7251 warn (_("Invalid offset %lx in table entry %ld\n"),
7252 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7257 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7258 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7260 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7261 (unsigned) UNW_VER (stamp
),
7262 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7263 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7264 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7265 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7267 if (UNW_VER (stamp
) != 1)
7269 printf (_("\tUnknown version.\n"));
7274 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7275 /* PR 17531: file: 16ceda89. */
7276 if (end
> aux
->info
+ aux
->info_size
)
7277 end
= aux
->info
+ aux
->info_size
;
7278 for (dp
= head
+ 8; dp
< end
;)
7279 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7288 slurp_ia64_unwind_table (FILE * file
,
7289 struct ia64_unw_aux_info
* aux
,
7290 Elf_Internal_Shdr
* sec
)
7292 unsigned long size
, nrelas
, i
;
7293 Elf_Internal_Phdr
* seg
;
7294 struct ia64_unw_table_entry
* tep
;
7295 Elf_Internal_Shdr
* relsec
;
7296 Elf_Internal_Rela
* rela
;
7297 Elf_Internal_Rela
* rp
;
7298 unsigned char * table
;
7300 Elf_Internal_Sym
* sym
;
7301 const char * relname
;
7305 /* First, find the starting address of the segment that includes
7308 if (elf_header
.e_phnum
)
7310 if (! get_program_headers (file
))
7313 for (seg
= program_headers
;
7314 seg
< program_headers
+ elf_header
.e_phnum
;
7317 if (seg
->p_type
!= PT_LOAD
)
7320 if (sec
->sh_addr
>= seg
->p_vaddr
7321 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7323 aux
->seg_base
= seg
->p_vaddr
;
7329 /* Second, build the unwind table from the contents of the unwind section: */
7330 size
= sec
->sh_size
;
7331 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7336 aux
->table_len
= size
/ (3 * eh_addr_size
);
7337 aux
->table
= (struct ia64_unw_table_entry
*)
7338 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7341 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7343 tep
->start
.section
= SHN_UNDEF
;
7344 tep
->end
.section
= SHN_UNDEF
;
7345 tep
->info
.section
= SHN_UNDEF
;
7346 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7347 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7348 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7349 tep
->start
.offset
+= aux
->seg_base
;
7350 tep
->end
.offset
+= aux
->seg_base
;
7351 tep
->info
.offset
+= aux
->seg_base
;
7355 /* Third, apply any relocations to the unwind table: */
7356 for (relsec
= section_headers
;
7357 relsec
< section_headers
+ elf_header
.e_shnum
;
7360 if (relsec
->sh_type
!= SHT_RELA
7361 || relsec
->sh_info
>= elf_header
.e_shnum
7362 || section_headers
+ relsec
->sh_info
!= sec
)
7365 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7374 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7376 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7377 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7379 /* PR 17531: file: 9fa67536. */
7380 if (relname
== NULL
)
7382 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7386 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7388 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7392 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7394 /* PR 17531: file: 5bc8d9bf. */
7395 if (i
>= aux
->table_len
)
7397 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7401 switch (rp
->r_offset
/ eh_addr_size
% 3)
7404 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7405 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7408 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7409 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7412 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7413 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7427 ia64_process_unwind (FILE * file
)
7429 Elf_Internal_Shdr
* sec
;
7430 Elf_Internal_Shdr
* unwsec
= NULL
;
7431 Elf_Internal_Shdr
* strsec
;
7432 unsigned long i
, unwcount
= 0, unwstart
= 0;
7433 struct ia64_unw_aux_info aux
;
7434 bfd_boolean res
= TRUE
;
7436 memset (& aux
, 0, sizeof (aux
));
7438 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7440 if (sec
->sh_type
== SHT_SYMTAB
7441 && sec
->sh_link
< elf_header
.e_shnum
)
7443 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7445 strsec
= section_headers
+ sec
->sh_link
;
7446 if (aux
.strtab
!= NULL
)
7448 error (_("Multiple auxillary string tables encountered\n"));
7452 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7455 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7457 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7462 printf (_("\nThere are no unwind sections in this file.\n"));
7464 while (unwcount
-- > 0)
7469 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7470 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7471 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7476 /* We have already counted the number of SHT_IA64_UNWIND
7477 sections so the loop above should never fail. */
7478 assert (unwsec
!= NULL
);
7481 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7483 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7485 /* We need to find which section group it is in. */
7486 struct group_list
* g
;
7488 if (section_headers_groups
== NULL
7489 || section_headers_groups
[i
] == NULL
)
7490 i
= elf_header
.e_shnum
;
7493 g
= section_headers_groups
[i
]->root
;
7495 for (; g
!= NULL
; g
= g
->next
)
7497 sec
= section_headers
+ g
->section_index
;
7499 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7504 i
= elf_header
.e_shnum
;
7507 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7509 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7510 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7511 suffix
= SECTION_NAME (unwsec
) + len
;
7512 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7514 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7515 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7520 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7521 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7522 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7523 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7525 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7526 suffix
= SECTION_NAME (unwsec
) + len
;
7527 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7529 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7530 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7534 if (i
== elf_header
.e_shnum
)
7536 printf (_("\nCould not find unwind info section for "));
7538 if (string_table
== NULL
)
7539 printf ("%d", unwsec
->sh_name
);
7541 printf ("'%s'", printable_section_name (unwsec
));
7545 aux
.info_addr
= sec
->sh_addr
;
7546 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7549 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7551 printf (_("\nUnwind section "));
7553 if (string_table
== NULL
)
7554 printf ("%d", unwsec
->sh_name
);
7556 printf ("'%s'", printable_section_name (unwsec
));
7558 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7559 (unsigned long) unwsec
->sh_offset
,
7560 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7562 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7563 && aux
.table_len
> 0)
7564 dump_ia64_unwind (& aux
);
7567 free ((char *) aux
.table
);
7569 free ((char *) aux
.info
);
7578 free ((char *) aux
.strtab
);
7583 struct hppa_unw_table_entry
7585 struct absaddr start
;
7587 unsigned int Cannot_unwind
:1; /* 0 */
7588 unsigned int Millicode
:1; /* 1 */
7589 unsigned int Millicode_save_sr0
:1; /* 2 */
7590 unsigned int Region_description
:2; /* 3..4 */
7591 unsigned int reserved1
:1; /* 5 */
7592 unsigned int Entry_SR
:1; /* 6 */
7593 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7594 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7595 unsigned int Args_stored
:1; /* 16 */
7596 unsigned int Variable_Frame
:1; /* 17 */
7597 unsigned int Separate_Package_Body
:1; /* 18 */
7598 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7599 unsigned int Stack_Overflow_Check
:1; /* 20 */
7600 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7601 unsigned int Ada_Region
:1; /* 22 */
7602 unsigned int cxx_info
:1; /* 23 */
7603 unsigned int cxx_try_catch
:1; /* 24 */
7604 unsigned int sched_entry_seq
:1; /* 25 */
7605 unsigned int reserved2
:1; /* 26 */
7606 unsigned int Save_SP
:1; /* 27 */
7607 unsigned int Save_RP
:1; /* 28 */
7608 unsigned int Save_MRP_in_frame
:1; /* 29 */
7609 unsigned int extn_ptr_defined
:1; /* 30 */
7610 unsigned int Cleanup_defined
:1; /* 31 */
7612 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7613 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7614 unsigned int Large_frame
:1; /* 2 */
7615 unsigned int Pseudo_SP_Set
:1; /* 3 */
7616 unsigned int reserved4
:1; /* 4 */
7617 unsigned int Total_frame_size
:27; /* 5..31 */
7620 struct hppa_unw_aux_info
7622 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7623 unsigned long table_len
; /* Length of unwind table. */
7624 bfd_vma seg_base
; /* Starting address of segment. */
7625 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7626 unsigned long nsyms
; /* Number of symbols. */
7627 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7628 unsigned long nfuns
; /* Number of entries in funtab. */
7629 char * strtab
; /* The string table. */
7630 unsigned long strtab_size
; /* Size of string table. */
7634 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7636 struct hppa_unw_table_entry
* tp
;
7637 unsigned long j
, nfuns
;
7638 bfd_boolean res
= TRUE
;
7640 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7641 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7642 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7643 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7645 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7647 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7650 const char * procname
;
7652 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7653 aux
->strtab_size
, tp
->start
, &procname
,
7656 fputs ("\n<", stdout
);
7660 fputs (procname
, stdout
);
7663 printf ("+%lx", (unsigned long) offset
);
7666 fputs (">: [", stdout
);
7667 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7668 fputc ('-', stdout
);
7669 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7672 #define PF(_m) if (tp->_m) printf (#_m " ");
7673 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7676 PF(Millicode_save_sr0
);
7677 /* PV(Region_description); */
7683 PF(Separate_Package_Body
);
7684 PF(Frame_Extension_Millicode
);
7685 PF(Stack_Overflow_Check
);
7686 PF(Two_Instruction_SP_Increment
);
7690 PF(sched_entry_seq
);
7693 PF(Save_MRP_in_frame
);
7694 PF(extn_ptr_defined
);
7695 PF(Cleanup_defined
);
7696 PF(MPE_XL_interrupt_marker
);
7697 PF(HP_UX_interrupt_marker
);
7700 PV(Total_frame_size
);
7713 slurp_hppa_unwind_table (FILE * file
,
7714 struct hppa_unw_aux_info
* aux
,
7715 Elf_Internal_Shdr
* sec
)
7717 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7718 Elf_Internal_Phdr
* seg
;
7719 struct hppa_unw_table_entry
* tep
;
7720 Elf_Internal_Shdr
* relsec
;
7721 Elf_Internal_Rela
* rela
;
7722 Elf_Internal_Rela
* rp
;
7723 unsigned char * table
;
7725 Elf_Internal_Sym
* sym
;
7726 const char * relname
;
7728 /* First, find the starting address of the segment that includes
7730 if (elf_header
.e_phnum
)
7732 if (! get_program_headers (file
))
7735 for (seg
= program_headers
;
7736 seg
< program_headers
+ elf_header
.e_phnum
;
7739 if (seg
->p_type
!= PT_LOAD
)
7742 if (sec
->sh_addr
>= seg
->p_vaddr
7743 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7745 aux
->seg_base
= seg
->p_vaddr
;
7751 /* Second, build the unwind table from the contents of the unwind
7753 size
= sec
->sh_size
;
7754 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7760 nentries
= size
/ unw_ent_size
;
7761 size
= unw_ent_size
* nentries
;
7763 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7764 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7766 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7768 unsigned int tmp1
, tmp2
;
7770 tep
->start
.section
= SHN_UNDEF
;
7771 tep
->end
.section
= SHN_UNDEF
;
7773 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7774 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7775 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7776 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7778 tep
->start
.offset
+= aux
->seg_base
;
7779 tep
->end
.offset
+= aux
->seg_base
;
7781 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7782 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7783 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7784 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7785 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7786 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7787 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7788 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7789 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7790 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7791 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7792 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7793 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7794 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7795 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7796 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7797 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7798 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7799 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7800 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7801 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7802 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7803 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7804 tep
->Cleanup_defined
= tmp1
& 0x1;
7806 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7807 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7808 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7809 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7810 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7811 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7815 /* Third, apply any relocations to the unwind table. */
7816 for (relsec
= section_headers
;
7817 relsec
< section_headers
+ elf_header
.e_shnum
;
7820 if (relsec
->sh_type
!= SHT_RELA
7821 || relsec
->sh_info
>= elf_header
.e_shnum
7822 || section_headers
+ relsec
->sh_info
!= sec
)
7825 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7829 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7831 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7832 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7834 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7835 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7837 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7841 i
= rp
->r_offset
/ unw_ent_size
;
7843 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7846 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7847 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7850 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7851 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7861 aux
->table_len
= nentries
;
7867 hppa_process_unwind (FILE * file
)
7869 struct hppa_unw_aux_info aux
;
7870 Elf_Internal_Shdr
* unwsec
= NULL
;
7871 Elf_Internal_Shdr
* strsec
;
7872 Elf_Internal_Shdr
* sec
;
7874 bfd_boolean res
= TRUE
;
7876 if (string_table
== NULL
)
7879 memset (& aux
, 0, sizeof (aux
));
7881 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7883 if (sec
->sh_type
== SHT_SYMTAB
7884 && sec
->sh_link
< elf_header
.e_shnum
)
7886 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7888 strsec
= section_headers
+ sec
->sh_link
;
7889 if (aux
.strtab
!= NULL
)
7891 error (_("Multiple auxillary string tables encountered\n"));
7895 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7898 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7900 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7905 printf (_("\nThere are no unwind sections in this file.\n"));
7907 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7909 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7911 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7912 printable_section_name (sec
),
7913 (unsigned long) sec
->sh_offset
,
7914 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7916 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7919 if (aux
.table_len
> 0)
7921 if (! dump_hppa_unwind (&aux
))
7926 free ((char *) aux
.table
);
7934 free ((char *) aux
.strtab
);
7941 unsigned char * data
; /* The unwind data. */
7942 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7943 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7944 unsigned long nrelas
; /* The number of relocations. */
7945 unsigned int rel_type
; /* REL or RELA ? */
7946 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7949 struct arm_unw_aux_info
7951 FILE * file
; /* The file containing the unwind sections. */
7952 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7953 unsigned long nsyms
; /* Number of symbols. */
7954 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7955 unsigned long nfuns
; /* Number of these symbols. */
7956 char * strtab
; /* The file's string table. */
7957 unsigned long strtab_size
; /* Size of string table. */
7961 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7962 bfd_vma fn
, struct absaddr addr
)
7964 const char *procname
;
7967 if (addr
.section
== SHN_UNDEF
)
7970 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7971 aux
->strtab_size
, addr
, &procname
,
7974 print_vma (fn
, PREFIX_HEX
);
7978 fputs (" <", stdout
);
7979 fputs (procname
, stdout
);
7982 printf ("+0x%lx", (unsigned long) sym_offset
);
7983 fputc ('>', stdout
);
7990 arm_free_section (struct arm_section
*arm_sec
)
7992 if (arm_sec
->data
!= NULL
)
7993 free (arm_sec
->data
);
7995 if (arm_sec
->rela
!= NULL
)
7996 free (arm_sec
->rela
);
7999 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8000 cached section and install SEC instead.
8001 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8002 and return its valued in * WORDP, relocating if necessary.
8003 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8004 relocation's offset in ADDR.
8005 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8006 into the string table of the symbol associated with the reloc. If no
8007 reloc was applied store -1 there.
8008 5) Return TRUE upon success, FALSE otherwise. */
8011 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
8012 struct arm_section
* arm_sec
,
8013 Elf_Internal_Shdr
* sec
,
8014 bfd_vma word_offset
,
8015 unsigned int * wordp
,
8016 struct absaddr
* addr
,
8019 Elf_Internal_Rela
*rp
;
8020 Elf_Internal_Sym
*sym
;
8021 const char * relname
;
8023 bfd_boolean wrapped
;
8025 if (sec
== NULL
|| arm_sec
== NULL
)
8028 addr
->section
= SHN_UNDEF
;
8031 if (sym_name
!= NULL
)
8032 *sym_name
= (bfd_vma
) -1;
8034 /* If necessary, update the section cache. */
8035 if (sec
!= arm_sec
->sec
)
8037 Elf_Internal_Shdr
*relsec
;
8039 arm_free_section (arm_sec
);
8042 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8043 sec
->sh_size
, _("unwind data"));
8044 arm_sec
->rela
= NULL
;
8045 arm_sec
->nrelas
= 0;
8047 for (relsec
= section_headers
;
8048 relsec
< section_headers
+ elf_header
.e_shnum
;
8051 if (relsec
->sh_info
>= elf_header
.e_shnum
8052 || section_headers
+ relsec
->sh_info
!= sec
8053 /* PR 15745: Check the section type as well. */
8054 || (relsec
->sh_type
!= SHT_REL
8055 && relsec
->sh_type
!= SHT_RELA
))
8058 arm_sec
->rel_type
= relsec
->sh_type
;
8059 if (relsec
->sh_type
== SHT_REL
)
8061 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8063 & arm_sec
->rela
, & arm_sec
->nrelas
))
8066 else /* relsec->sh_type == SHT_RELA */
8068 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8070 & arm_sec
->rela
, & arm_sec
->nrelas
))
8076 arm_sec
->next_rela
= arm_sec
->rela
;
8079 /* If there is no unwind data we can do nothing. */
8080 if (arm_sec
->data
== NULL
)
8083 /* If the offset is invalid then fail. */
8084 if (/* PR 21343 *//* PR 18879 */
8086 || word_offset
> (sec
->sh_size
- 4)
8087 || ((bfd_signed_vma
) word_offset
) < 0)
8090 /* Get the word at the required offset. */
8091 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8093 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8094 if (arm_sec
->rela
== NULL
)
8100 /* Look through the relocs to find the one that applies to the provided offset. */
8102 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8104 bfd_vma prelval
, offset
;
8106 if (rp
->r_offset
> word_offset
&& !wrapped
)
8111 if (rp
->r_offset
> word_offset
)
8114 if (rp
->r_offset
& 3)
8116 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8117 (unsigned long) rp
->r_offset
);
8121 if (rp
->r_offset
< word_offset
)
8124 /* PR 17531: file: 027-161405-0.004 */
8125 if (aux
->symtab
== NULL
)
8128 if (arm_sec
->rel_type
== SHT_REL
)
8130 offset
= word
& 0x7fffffff;
8131 if (offset
& 0x40000000)
8132 offset
|= ~ (bfd_vma
) 0x7fffffff;
8134 else if (arm_sec
->rel_type
== SHT_RELA
)
8135 offset
= rp
->r_addend
;
8138 error (_("Unknown section relocation type %d encountered\n"),
8143 /* PR 17531 file: 027-1241568-0.004. */
8144 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8146 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8147 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8151 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8152 offset
+= sym
->st_value
;
8153 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8155 /* Check that we are processing the expected reloc type. */
8156 if (elf_header
.e_machine
== EM_ARM
)
8158 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8159 if (relname
== NULL
)
8161 warn (_("Skipping unknown ARM relocation type: %d\n"),
8162 (int) ELF32_R_TYPE (rp
->r_info
));
8166 if (streq (relname
, "R_ARM_NONE"))
8169 if (! streq (relname
, "R_ARM_PREL31"))
8171 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8175 else if (elf_header
.e_machine
== EM_TI_C6000
)
8177 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8178 if (relname
== NULL
)
8180 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8181 (int) ELF32_R_TYPE (rp
->r_info
));
8185 if (streq (relname
, "R_C6000_NONE"))
8188 if (! streq (relname
, "R_C6000_PREL31"))
8190 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8198 /* This function currently only supports ARM and TI unwinders. */
8199 warn (_("Only TI and ARM unwinders are currently supported\n"));
8203 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8204 addr
->section
= sym
->st_shndx
;
8205 addr
->offset
= offset
;
8208 * sym_name
= sym
->st_name
;
8213 arm_sec
->next_rela
= rp
;
8218 static const char *tic6x_unwind_regnames
[16] =
8220 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8221 "A14", "A13", "A12", "A11", "A10",
8222 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8226 decode_tic6x_unwind_regmask (unsigned int mask
)
8230 for (i
= 12; mask
; mask
>>= 1, i
--)
8234 fputs (tic6x_unwind_regnames
[i
], stdout
);
8236 fputs (", ", stdout
);
8242 if (remaining == 0 && more_words) \
8245 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8246 data_offset, & word, & addr, NULL)) \
8252 #define GET_OP(OP) \
8257 (OP) = word >> 24; \
8262 printf (_("[Truncated opcode]\n")); \
8265 printf ("0x%02x ", OP)
8268 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8270 unsigned int remaining
,
8271 unsigned int more_words
,
8272 bfd_vma data_offset
,
8273 Elf_Internal_Shdr
* data_sec
,
8274 struct arm_section
* data_arm_sec
)
8276 struct absaddr addr
;
8277 bfd_boolean res
= TRUE
;
8279 /* Decode the unwinding instructions. */
8282 unsigned int op
, op2
;
8291 printf (" 0x%02x ", op
);
8293 if ((op
& 0xc0) == 0x00)
8295 int offset
= ((op
& 0x3f) << 2) + 4;
8297 printf (" vsp = vsp + %d", offset
);
8299 else if ((op
& 0xc0) == 0x40)
8301 int offset
= ((op
& 0x3f) << 2) + 4;
8303 printf (" vsp = vsp - %d", offset
);
8305 else if ((op
& 0xf0) == 0x80)
8308 if (op
== 0x80 && op2
== 0)
8309 printf (_("Refuse to unwind"));
8312 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8313 bfd_boolean first
= TRUE
;
8317 for (i
= 0; i
< 12; i
++)
8318 if (mask
& (1 << i
))
8324 printf ("r%d", 4 + i
);
8329 else if ((op
& 0xf0) == 0x90)
8331 if (op
== 0x9d || op
== 0x9f)
8332 printf (_(" [Reserved]"));
8334 printf (" vsp = r%d", op
& 0x0f);
8336 else if ((op
& 0xf0) == 0xa0)
8338 int end
= 4 + (op
& 0x07);
8339 bfd_boolean first
= TRUE
;
8343 for (i
= 4; i
<= end
; i
++)
8359 else if (op
== 0xb0)
8360 printf (_(" finish"));
8361 else if (op
== 0xb1)
8364 if (op2
== 0 || (op2
& 0xf0) != 0)
8365 printf (_("[Spare]"));
8368 unsigned int mask
= op2
& 0x0f;
8369 bfd_boolean first
= TRUE
;
8373 for (i
= 0; i
< 12; i
++)
8374 if (mask
& (1 << i
))
8385 else if (op
== 0xb2)
8387 unsigned char buf
[9];
8388 unsigned int i
, len
;
8389 unsigned long offset
;
8391 for (i
= 0; i
< sizeof (buf
); i
++)
8394 if ((buf
[i
] & 0x80) == 0)
8397 if (i
== sizeof (buf
))
8399 error (_("corrupt change to vsp"));
8404 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8405 assert (len
== i
+ 1);
8406 offset
= offset
* 4 + 0x204;
8407 printf ("vsp = vsp + %ld", offset
);
8410 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8412 unsigned int first
, last
;
8419 printf ("pop {D%d", first
);
8421 printf ("-D%d", first
+ last
);
8424 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8426 unsigned int count
= op
& 0x07;
8430 printf ("-D%d", 8 + count
);
8433 else if (op
>= 0xc0 && op
<= 0xc5)
8435 unsigned int count
= op
& 0x07;
8437 printf (" pop {wR10");
8439 printf ("-wR%d", 10 + count
);
8442 else if (op
== 0xc6)
8444 unsigned int first
, last
;
8449 printf ("pop {wR%d", first
);
8451 printf ("-wR%d", first
+ last
);
8454 else if (op
== 0xc7)
8457 if (op2
== 0 || (op2
& 0xf0) != 0)
8458 printf (_("[Spare]"));
8461 unsigned int mask
= op2
& 0x0f;
8462 bfd_boolean first
= TRUE
;
8466 for (i
= 0; i
< 4; i
++)
8467 if (mask
& (1 << i
))
8473 printf ("wCGR%d", i
);
8480 printf (_(" [unsupported opcode]"));
8491 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8493 unsigned int remaining
,
8494 unsigned int more_words
,
8495 bfd_vma data_offset
,
8496 Elf_Internal_Shdr
* data_sec
,
8497 struct arm_section
* data_arm_sec
)
8499 struct absaddr addr
;
8501 /* Decode the unwinding instructions. */
8504 unsigned int op
, op2
;
8513 printf (" 0x%02x ", op
);
8515 if ((op
& 0xc0) == 0x00)
8517 int offset
= ((op
& 0x3f) << 3) + 8;
8518 printf (" sp = sp + %d", offset
);
8520 else if ((op
& 0xc0) == 0x80)
8523 if (op
== 0x80 && op2
== 0)
8524 printf (_("Refuse to unwind"));
8527 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8529 printf ("pop compact {");
8533 decode_tic6x_unwind_regmask (mask
);
8537 else if ((op
& 0xf0) == 0xc0)
8545 unsigned int offset
;
8549 /* Scan entire instruction first so that GET_OP output is not
8550 interleaved with disassembly. */
8552 for (i
= 0; nregs
< (op
& 0xf); i
++)
8558 regpos
[nregs
].offset
= i
* 2;
8559 regpos
[nregs
].reg
= reg
;
8566 regpos
[nregs
].offset
= i
* 2 + 1;
8567 regpos
[nregs
].reg
= reg
;
8572 printf (_("pop frame {"));
8574 for (i
= i
* 2; i
> 0; i
--)
8576 if (regpos
[reg
].offset
== i
- 1)
8578 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8585 fputs (name
, stdout
);
8592 else if (op
== 0xd0)
8593 printf (" MOV FP, SP");
8594 else if (op
== 0xd1)
8595 printf (" __c6xabi_pop_rts");
8596 else if (op
== 0xd2)
8598 unsigned char buf
[9];
8599 unsigned int i
, len
;
8600 unsigned long offset
;
8602 for (i
= 0; i
< sizeof (buf
); i
++)
8605 if ((buf
[i
] & 0x80) == 0)
8608 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8609 if (i
== sizeof (buf
))
8611 warn (_("Corrupt stack pointer adjustment detected\n"));
8615 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8616 assert (len
== i
+ 1);
8617 offset
= offset
* 8 + 0x408;
8618 printf (_("sp = sp + %ld"), offset
);
8620 else if ((op
& 0xf0) == 0xe0)
8622 if ((op
& 0x0f) == 7)
8625 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8629 printf (_(" [unsupported opcode]"));
8638 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8642 offset
= word
& 0x7fffffff;
8643 if (offset
& 0x40000000)
8644 offset
|= ~ (bfd_vma
) 0x7fffffff;
8646 if (elf_header
.e_machine
== EM_TI_C6000
)
8649 return offset
+ where
;
8653 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8655 unsigned int remaining
,
8656 bfd_vma data_offset
,
8657 Elf_Internal_Shdr
* data_sec
,
8658 struct arm_section
* data_arm_sec
)
8661 unsigned int more_words
= 0;
8662 struct absaddr addr
;
8663 bfd_vma sym_name
= (bfd_vma
) -1;
8664 bfd_boolean res
= FALSE
;
8668 /* Fetch the first word.
8669 Note - when decoding an object file the address extracted
8670 here will always be 0. So we also pass in the sym_name
8671 parameter so that we can find the symbol associated with
8672 the personality routine. */
8673 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8674 & word
, & addr
, & sym_name
))
8680 if ((word
& 0x80000000) == 0)
8682 /* Expand prel31 for personality routine. */
8684 const char *procname
;
8686 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8687 printf (_(" Personality routine: "));
8689 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8690 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8692 procname
= aux
->strtab
+ sym_name
;
8693 print_vma (fn
, PREFIX_HEX
);
8696 fputs (" <", stdout
);
8697 fputs (procname
, stdout
);
8698 fputc ('>', stdout
);
8702 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8703 fputc ('\n', stdout
);
8705 /* The GCC personality routines use the standard compact
8706 encoding, starting with one byte giving the number of
8708 if (procname
!= NULL
8709 && (const_strneq (procname
, "__gcc_personality_v0")
8710 || const_strneq (procname
, "__gxx_personality_v0")
8711 || const_strneq (procname
, "__gcj_personality_v0")
8712 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8719 printf (_(" [Truncated data]\n"));
8722 more_words
= word
>> 24;
8732 /* ARM EHABI Section 6.3:
8734 An exception-handling table entry for the compact model looks like:
8738 1 0 index Data for personalityRoutine[index] */
8740 if (elf_header
.e_machine
== EM_ARM
8741 && (word
& 0x70000000))
8743 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8747 per_index
= (word
>> 24) & 0x7f;
8748 printf (_(" Compact model index: %d\n"), per_index
);
8755 else if (per_index
< 3)
8757 more_words
= (word
>> 16) & 0xff;
8763 switch (elf_header
.e_machine
)
8768 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8769 data_offset
, data_sec
, data_arm_sec
))
8774 warn (_("Unknown ARM compact model index encountered\n"));
8775 printf (_(" [reserved]\n"));
8783 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8784 data_offset
, data_sec
, data_arm_sec
))
8787 else if (per_index
< 5)
8789 if (((word
>> 17) & 0x7f) == 0x7f)
8790 printf (_(" Restore stack from frame pointer\n"));
8792 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8793 printf (_(" Registers restored: "));
8795 printf (" (compact) ");
8796 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8798 printf (_(" Return register: %s\n"),
8799 tic6x_unwind_regnames
[word
& 0xf]);
8802 printf (_(" [reserved (%d)]\n"), per_index
);
8806 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8807 elf_header
.e_machine
);
8811 /* Decode the descriptors. Not implemented. */
8817 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8819 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8820 unsigned int i
, exidx_len
;
8821 unsigned long j
, nfuns
;
8822 bfd_boolean res
= TRUE
;
8824 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8825 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8826 exidx_len
= exidx_sec
->sh_size
/ 8;
8828 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8829 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8830 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8831 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8833 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8835 for (i
= 0; i
< exidx_len
; i
++)
8837 unsigned int exidx_fn
, exidx_entry
;
8838 struct absaddr fn_addr
, entry_addr
;
8841 fputc ('\n', stdout
);
8843 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8844 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8845 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8846 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8849 arm_free_section (& exidx_arm_sec
);
8850 arm_free_section (& extab_arm_sec
);
8854 /* ARM EHABI, Section 5:
8855 An index table entry consists of 2 words.
8856 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8857 if (exidx_fn
& 0x80000000)
8859 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8863 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8865 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8866 fputs (": ", stdout
);
8868 if (exidx_entry
== 1)
8870 print_vma (exidx_entry
, PREFIX_HEX
);
8871 fputs (" [cantunwind]\n", stdout
);
8873 else if (exidx_entry
& 0x80000000)
8875 print_vma (exidx_entry
, PREFIX_HEX
);
8876 fputc ('\n', stdout
);
8877 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8881 bfd_vma table
, table_offset
= 0;
8882 Elf_Internal_Shdr
*table_sec
;
8884 fputs ("@", stdout
);
8885 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8886 print_vma (table
, PREFIX_HEX
);
8889 /* Locate the matching .ARM.extab. */
8890 if (entry_addr
.section
!= SHN_UNDEF
8891 && entry_addr
.section
< elf_header
.e_shnum
)
8893 table_sec
= section_headers
+ entry_addr
.section
;
8894 table_offset
= entry_addr
.offset
;
8896 if (table_offset
> table_sec
->sh_size
8897 || ((bfd_signed_vma
) table_offset
) < 0)
8899 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8900 (unsigned long) table_offset
,
8901 printable_section_name (table_sec
));
8908 table_sec
= find_section_by_address (table
);
8909 if (table_sec
!= NULL
)
8910 table_offset
= table
- table_sec
->sh_addr
;
8913 if (table_sec
== NULL
)
8915 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8916 (unsigned long) table
);
8921 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8930 arm_free_section (&exidx_arm_sec
);
8931 arm_free_section (&extab_arm_sec
);
8936 /* Used for both ARM and C6X unwinding tables. */
8939 arm_process_unwind (FILE *file
)
8941 struct arm_unw_aux_info aux
;
8942 Elf_Internal_Shdr
*unwsec
= NULL
;
8943 Elf_Internal_Shdr
*strsec
;
8944 Elf_Internal_Shdr
*sec
;
8946 unsigned int sec_type
;
8947 bfd_boolean res
= TRUE
;
8949 switch (elf_header
.e_machine
)
8952 sec_type
= SHT_ARM_EXIDX
;
8956 sec_type
= SHT_C6000_UNWIND
;
8960 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8961 elf_header
.e_machine
);
8965 if (string_table
== NULL
)
8968 memset (& aux
, 0, sizeof (aux
));
8971 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8973 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8975 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8977 strsec
= section_headers
+ sec
->sh_link
;
8979 /* PR binutils/17531 file: 011-12666-0.004. */
8980 if (aux
.strtab
!= NULL
)
8982 error (_("Multiple string tables found in file.\n"));
8986 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8987 1, strsec
->sh_size
, _("string table"));
8988 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8990 else if (sec
->sh_type
== sec_type
)
8995 printf (_("\nThere are no unwind sections in this file.\n"));
8997 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8999 if (sec
->sh_type
== sec_type
)
9001 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9002 printable_section_name (sec
),
9003 (unsigned long) sec
->sh_offset
,
9004 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
9006 if (! dump_arm_unwind (&aux
, sec
))
9014 free ((char *) aux
.strtab
);
9020 process_unwind (FILE * file
)
9022 struct unwind_handler
9024 unsigned int machtype
;
9025 bfd_boolean (* handler
)(FILE *);
9028 { EM_ARM
, arm_process_unwind
},
9029 { EM_IA_64
, ia64_process_unwind
},
9030 { EM_PARISC
, hppa_process_unwind
},
9031 { EM_TI_C6000
, arm_process_unwind
},
9039 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9040 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9041 return handlers
[i
].handler (file
);
9043 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9044 get_machine_name (elf_header
.e_machine
));
9049 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9051 switch (entry
->d_tag
)
9054 if (entry
->d_un
.d_val
== 0)
9058 static const char * opts
[] =
9060 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9061 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9062 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9063 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9067 bfd_boolean first
= TRUE
;
9069 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9070 if (entry
->d_un
.d_val
& (1 << cnt
))
9072 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9078 case DT_MIPS_IVERSION
:
9079 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9080 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9084 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9085 /* Note: coded this way so that there is a single string for translation. */
9086 printf (_("<corrupt: %s>"), buf
);
9090 case DT_MIPS_TIME_STAMP
:
9094 time_t atime
= entry
->d_un
.d_val
;
9096 tmp
= gmtime (&atime
);
9097 /* PR 17531: file: 6accc532. */
9099 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9101 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9102 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9103 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9104 printf (_("Time Stamp: %s"), timebuf
);
9108 case DT_MIPS_RLD_VERSION
:
9109 case DT_MIPS_LOCAL_GOTNO
:
9110 case DT_MIPS_CONFLICTNO
:
9111 case DT_MIPS_LIBLISTNO
:
9112 case DT_MIPS_SYMTABNO
:
9113 case DT_MIPS_UNREFEXTNO
:
9114 case DT_MIPS_HIPAGENO
:
9115 case DT_MIPS_DELTA_CLASS_NO
:
9116 case DT_MIPS_DELTA_INSTANCE_NO
:
9117 case DT_MIPS_DELTA_RELOC_NO
:
9118 case DT_MIPS_DELTA_SYM_NO
:
9119 case DT_MIPS_DELTA_CLASSSYM_NO
:
9120 case DT_MIPS_COMPACT_SIZE
:
9121 print_vma (entry
->d_un
.d_val
, DEC
);
9125 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9131 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9133 switch (entry
->d_tag
)
9135 case DT_HP_DLD_FLAGS
:
9144 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9145 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9146 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9147 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9148 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9149 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9150 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9151 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9152 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9153 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9154 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9155 { DT_HP_GST
, "HP_GST" },
9156 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9157 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9158 { DT_HP_NODELETE
, "HP_NODELETE" },
9159 { DT_HP_GROUP
, "HP_GROUP" },
9160 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9162 bfd_boolean first
= TRUE
;
9164 bfd_vma val
= entry
->d_un
.d_val
;
9166 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9167 if (val
& flags
[cnt
].bit
)
9171 fputs (flags
[cnt
].str
, stdout
);
9173 val
^= flags
[cnt
].bit
;
9176 if (val
!= 0 || first
)
9180 print_vma (val
, HEX
);
9186 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9194 /* VMS vs Unix time offset and factor. */
9196 #define VMS_EPOCH_OFFSET 35067168000000000LL
9197 #define VMS_GRANULARITY_FACTOR 10000000
9199 /* Display a VMS time in a human readable format. */
9202 print_vms_time (bfd_int64_t vmstime
)
9207 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9208 tm
= gmtime (&unxtime
);
9209 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9210 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9211 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9216 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9218 switch (entry
->d_tag
)
9220 case DT_IA_64_PLT_RESERVE
:
9221 /* First 3 slots reserved. */
9222 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9224 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9227 case DT_IA_64_VMS_LINKTIME
:
9229 print_vms_time (entry
->d_un
.d_val
);
9233 case DT_IA_64_VMS_LNKFLAGS
:
9234 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9235 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9236 printf (" CALL_DEBUG");
9237 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9238 printf (" NOP0BUFS");
9239 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9240 printf (" P0IMAGE");
9241 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9242 printf (" MKTHREADS");
9243 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9244 printf (" UPCALLS");
9245 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9247 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9248 printf (" INITIALIZE");
9249 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9251 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9252 printf (" EXE_INIT");
9253 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9254 printf (" TBK_IN_IMG");
9255 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9256 printf (" DBG_IN_IMG");
9257 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9258 printf (" TBK_IN_DSF");
9259 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9260 printf (" DBG_IN_DSF");
9261 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9262 printf (" SIGNATURES");
9263 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9264 printf (" REL_SEG_OFF");
9268 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9275 get_32bit_dynamic_section (FILE * file
)
9277 Elf32_External_Dyn
* edyn
;
9278 Elf32_External_Dyn
* ext
;
9279 Elf_Internal_Dyn
* entry
;
9281 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9282 dynamic_size
, _("dynamic section"));
9286 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9287 might not have the luxury of section headers. Look for the DT_NULL
9288 terminator to determine the number of entries. */
9289 for (ext
= edyn
, dynamic_nent
= 0;
9290 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9294 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9298 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9300 if (dynamic_section
== NULL
)
9302 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9303 (unsigned long) dynamic_nent
);
9308 for (ext
= edyn
, entry
= dynamic_section
;
9309 entry
< dynamic_section
+ dynamic_nent
;
9312 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9313 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9322 get_64bit_dynamic_section (FILE * file
)
9324 Elf64_External_Dyn
* edyn
;
9325 Elf64_External_Dyn
* ext
;
9326 Elf_Internal_Dyn
* entry
;
9328 /* Read in the data. */
9329 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9330 dynamic_size
, _("dynamic section"));
9334 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9335 might not have the luxury of section headers. Look for the DT_NULL
9336 terminator to determine the number of entries. */
9337 for (ext
= edyn
, dynamic_nent
= 0;
9338 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9339 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9343 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9347 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9349 if (dynamic_section
== NULL
)
9351 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9352 (unsigned long) dynamic_nent
);
9357 /* Convert from external to internal formats. */
9358 for (ext
= edyn
, entry
= dynamic_section
;
9359 entry
< dynamic_section
+ dynamic_nent
;
9362 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9363 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9372 print_dynamic_flags (bfd_vma flags
)
9374 bfd_boolean first
= TRUE
;
9380 flag
= flags
& - flags
;
9390 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9391 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9392 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9393 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9394 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9395 default: fputs (_("unknown"), stdout
); break;
9401 /* Parse and display the contents of the dynamic section. */
9404 process_dynamic_section (FILE * file
)
9406 Elf_Internal_Dyn
* entry
;
9408 if (dynamic_size
== 0)
9411 printf (_("\nThere is no dynamic section in this file.\n"));
9418 if (! get_32bit_dynamic_section (file
))
9423 if (! get_64bit_dynamic_section (file
))
9427 /* Find the appropriate symbol table. */
9428 if (dynamic_symbols
== NULL
)
9430 for (entry
= dynamic_section
;
9431 entry
< dynamic_section
+ dynamic_nent
;
9434 Elf_Internal_Shdr section
;
9436 if (entry
->d_tag
!= DT_SYMTAB
)
9439 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9441 /* Since we do not know how big the symbol table is,
9442 we default to reading in the entire file (!) and
9443 processing that. This is overkill, I know, but it
9445 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9446 if ((bfd_size_type
) section
.sh_offset
> current_file_size
)
9448 /* See PR 21379 for a reproducer. */
9449 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9453 if (archive_file_offset
!= 0)
9454 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9457 if (fseek (file
, 0, SEEK_END
))
9458 error (_("Unable to seek to end of file!\n"));
9460 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9464 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9466 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9467 section
.sh_name
= string_table_length
;
9469 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9470 if (num_dynamic_syms
< 1)
9472 error (_("Unable to determine the number of symbols to load\n"));
9478 /* Similarly find a string table. */
9479 if (dynamic_strings
== NULL
)
9481 for (entry
= dynamic_section
;
9482 entry
< dynamic_section
+ dynamic_nent
;
9485 unsigned long offset
;
9488 if (entry
->d_tag
!= DT_STRTAB
)
9491 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9493 /* Since we do not know how big the string table is,
9494 we default to reading in the entire file (!) and
9495 processing that. This is overkill, I know, but it
9498 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9500 if (archive_file_offset
!= 0)
9501 str_tab_len
= archive_file_size
- offset
;
9504 if (fseek (file
, 0, SEEK_END
))
9505 error (_("Unable to seek to end of file\n"));
9506 str_tab_len
= ftell (file
) - offset
;
9509 if (str_tab_len
< 1)
9512 (_("Unable to determine the length of the dynamic string table\n"));
9516 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9518 _("dynamic string table"));
9519 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9524 /* And find the syminfo section if available. */
9525 if (dynamic_syminfo
== NULL
)
9527 unsigned long syminsz
= 0;
9529 for (entry
= dynamic_section
;
9530 entry
< dynamic_section
+ dynamic_nent
;
9533 if (entry
->d_tag
== DT_SYMINENT
)
9535 /* Note: these braces are necessary to avoid a syntax
9536 error from the SunOS4 C compiler. */
9537 /* PR binutils/17531: A corrupt file can trigger this test.
9538 So do not use an assert, instead generate an error message. */
9539 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9540 error (_("Bad value (%d) for SYMINENT entry\n"),
9541 (int) entry
->d_un
.d_val
);
9543 else if (entry
->d_tag
== DT_SYMINSZ
)
9544 syminsz
= entry
->d_un
.d_val
;
9545 else if (entry
->d_tag
== DT_SYMINFO
)
9546 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9550 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9552 Elf_External_Syminfo
* extsyminfo
;
9553 Elf_External_Syminfo
* extsym
;
9554 Elf_Internal_Syminfo
* syminfo
;
9556 /* There is a syminfo section. Read the data. */
9557 extsyminfo
= (Elf_External_Syminfo
*)
9558 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9559 _("symbol information"));
9563 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9564 if (dynamic_syminfo
== NULL
)
9566 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9567 (unsigned long) syminsz
);
9571 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9572 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9573 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9574 ++syminfo
, ++extsym
)
9576 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9577 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9584 if (do_dynamic
&& dynamic_addr
)
9585 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9586 dynamic_addr
, (unsigned long) dynamic_nent
);
9588 printf (_(" Tag Type Name/Value\n"));
9590 for (entry
= dynamic_section
;
9591 entry
< dynamic_section
+ dynamic_nent
;
9599 print_vma (entry
->d_tag
, FULL_HEX
);
9600 dtype
= get_dynamic_type (entry
->d_tag
);
9601 printf (" (%s)%*s", dtype
,
9602 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9605 switch (entry
->d_tag
)
9609 print_dynamic_flags (entry
->d_un
.d_val
);
9619 switch (entry
->d_tag
)
9622 printf (_("Auxiliary library"));
9626 printf (_("Filter library"));
9630 printf (_("Configuration file"));
9634 printf (_("Dependency audit library"));
9638 printf (_("Audit library"));
9642 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9643 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9647 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9656 printf (_("Flags:"));
9658 if (entry
->d_un
.d_val
== 0)
9659 printf (_(" None\n"));
9662 unsigned long int val
= entry
->d_un
.d_val
;
9664 if (val
& DTF_1_PARINIT
)
9666 printf (" PARINIT");
9667 val
^= DTF_1_PARINIT
;
9669 if (val
& DTF_1_CONFEXP
)
9671 printf (" CONFEXP");
9672 val
^= DTF_1_CONFEXP
;
9675 printf (" %lx", val
);
9684 printf (_("Flags:"));
9686 if (entry
->d_un
.d_val
== 0)
9687 printf (_(" None\n"));
9690 unsigned long int val
= entry
->d_un
.d_val
;
9692 if (val
& DF_P1_LAZYLOAD
)
9694 printf (" LAZYLOAD");
9695 val
^= DF_P1_LAZYLOAD
;
9697 if (val
& DF_P1_GROUPPERM
)
9699 printf (" GROUPPERM");
9700 val
^= DF_P1_GROUPPERM
;
9703 printf (" %lx", val
);
9712 printf (_("Flags:"));
9713 if (entry
->d_un
.d_val
== 0)
9714 printf (_(" None\n"));
9717 unsigned long int val
= entry
->d_un
.d_val
;
9724 if (val
& DF_1_GLOBAL
)
9729 if (val
& DF_1_GROUP
)
9734 if (val
& DF_1_NODELETE
)
9736 printf (" NODELETE");
9737 val
^= DF_1_NODELETE
;
9739 if (val
& DF_1_LOADFLTR
)
9741 printf (" LOADFLTR");
9742 val
^= DF_1_LOADFLTR
;
9744 if (val
& DF_1_INITFIRST
)
9746 printf (" INITFIRST");
9747 val
^= DF_1_INITFIRST
;
9749 if (val
& DF_1_NOOPEN
)
9754 if (val
& DF_1_ORIGIN
)
9759 if (val
& DF_1_DIRECT
)
9764 if (val
& DF_1_TRANS
)
9769 if (val
& DF_1_INTERPOSE
)
9771 printf (" INTERPOSE");
9772 val
^= DF_1_INTERPOSE
;
9774 if (val
& DF_1_NODEFLIB
)
9776 printf (" NODEFLIB");
9777 val
^= DF_1_NODEFLIB
;
9779 if (val
& DF_1_NODUMP
)
9784 if (val
& DF_1_CONFALT
)
9786 printf (" CONFALT");
9787 val
^= DF_1_CONFALT
;
9789 if (val
& DF_1_ENDFILTEE
)
9791 printf (" ENDFILTEE");
9792 val
^= DF_1_ENDFILTEE
;
9794 if (val
& DF_1_DISPRELDNE
)
9796 printf (" DISPRELDNE");
9797 val
^= DF_1_DISPRELDNE
;
9799 if (val
& DF_1_DISPRELPND
)
9801 printf (" DISPRELPND");
9802 val
^= DF_1_DISPRELPND
;
9804 if (val
& DF_1_NODIRECT
)
9806 printf (" NODIRECT");
9807 val
^= DF_1_NODIRECT
;
9809 if (val
& DF_1_IGNMULDEF
)
9811 printf (" IGNMULDEF");
9812 val
^= DF_1_IGNMULDEF
;
9814 if (val
& DF_1_NOKSYMS
)
9816 printf (" NOKSYMS");
9817 val
^= DF_1_NOKSYMS
;
9819 if (val
& DF_1_NOHDR
)
9824 if (val
& DF_1_EDITED
)
9829 if (val
& DF_1_NORELOC
)
9831 printf (" NORELOC");
9832 val
^= DF_1_NORELOC
;
9834 if (val
& DF_1_SYMINTPOSE
)
9836 printf (" SYMINTPOSE");
9837 val
^= DF_1_SYMINTPOSE
;
9839 if (val
& DF_1_GLOBAUDIT
)
9841 printf (" GLOBAUDIT");
9842 val
^= DF_1_GLOBAUDIT
;
9844 if (val
& DF_1_SINGLETON
)
9846 printf (" SINGLETON");
9847 val
^= DF_1_SINGLETON
;
9849 if (val
& DF_1_STUB
)
9860 printf (" %lx", val
);
9867 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9869 puts (get_dynamic_type (entry
->d_un
.d_val
));
9889 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9895 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9896 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9902 switch (entry
->d_tag
)
9905 printf (_("Shared library: [%s]"), name
);
9907 if (streq (name
, program_interpreter
))
9908 printf (_(" program interpreter"));
9912 printf (_("Library soname: [%s]"), name
);
9916 printf (_("Library rpath: [%s]"), name
);
9920 printf (_("Library runpath: [%s]"), name
);
9924 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9929 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9942 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9947 case DT_INIT_ARRAYSZ
:
9948 case DT_FINI_ARRAYSZ
:
9949 case DT_GNU_CONFLICTSZ
:
9950 case DT_GNU_LIBLISTSZ
:
9953 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9954 printf (_(" (bytes)\n"));
9964 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9977 if (entry
->d_tag
== DT_USED
9978 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9980 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9984 printf (_("Not needed object: [%s]\n"), name
);
9989 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9995 /* The value of this entry is ignored. */
10000 case DT_GNU_PRELINKED
:
10004 time_t atime
= entry
->d_un
.d_val
;
10006 tmp
= gmtime (&atime
);
10007 /* PR 17533 file: 041-1244816-0.004. */
10009 printf (_("<corrupt time val: %lx"),
10010 (unsigned long) atime
);
10012 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10013 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10014 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10020 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10023 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10029 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10030 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10035 switch (elf_header
.e_machine
)
10038 case EM_MIPS_RS3_LE
:
10039 dynamic_section_mips_val (entry
);
10042 dynamic_section_parisc_val (entry
);
10045 dynamic_section_ia64_val (entry
);
10048 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10060 get_ver_flags (unsigned int flags
)
10062 static char buff
[32];
10069 if (flags
& VER_FLG_BASE
)
10070 strcat (buff
, "BASE");
10072 if (flags
& VER_FLG_WEAK
)
10074 if (flags
& VER_FLG_BASE
)
10075 strcat (buff
, " | ");
10077 strcat (buff
, "WEAK");
10080 if (flags
& VER_FLG_INFO
)
10082 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10083 strcat (buff
, " | ");
10085 strcat (buff
, "INFO");
10088 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10090 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10091 strcat (buff
, " | ");
10093 strcat (buff
, _("<unknown>"));
10099 /* Display the contents of the version sections. */
10102 process_version_sections (FILE * file
)
10104 Elf_Internal_Shdr
* section
;
10106 bfd_boolean found
= FALSE
;
10111 for (i
= 0, section
= section_headers
;
10112 i
< elf_header
.e_shnum
;
10115 switch (section
->sh_type
)
10117 case SHT_GNU_verdef
:
10119 Elf_External_Verdef
* edefs
;
10127 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10128 printable_section_name (section
),
10131 printf (_(" Addr: 0x"));
10132 printf_vma (section
->sh_addr
);
10133 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10134 (unsigned long) section
->sh_offset
, section
->sh_link
,
10135 printable_section_name_from_index (section
->sh_link
));
10137 edefs
= (Elf_External_Verdef
*)
10138 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10139 _("version definition section"));
10142 endbuf
= (char *) edefs
+ section
->sh_size
;
10144 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10145 end
= (section
->sh_info
< section
->sh_size
10146 ? section
->sh_info
: section
->sh_size
);
10147 for (idx
= cnt
= 0; cnt
< end
; ++cnt
)
10150 Elf_External_Verdef
* edef
;
10151 Elf_Internal_Verdef ent
;
10152 Elf_External_Verdaux
* eaux
;
10153 Elf_Internal_Verdaux aux
;
10157 /* Check for very large indices. */
10158 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10161 vstart
= ((char *) edefs
) + idx
;
10162 if (vstart
+ sizeof (*edef
) > endbuf
)
10165 edef
= (Elf_External_Verdef
*) vstart
;
10167 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10168 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10169 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10170 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10171 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10172 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10173 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10175 printf (_(" %#06x: Rev: %d Flags: %s"),
10176 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10178 printf (_(" Index: %d Cnt: %d "),
10179 ent
.vd_ndx
, ent
.vd_cnt
);
10181 /* Check for overflow and underflow. */
10182 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
)
10183 || (vstart
+ ent
.vd_aux
< vstart
))
10186 vstart
+= ent
.vd_aux
;
10188 eaux
= (Elf_External_Verdaux
*) vstart
;
10190 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10191 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10193 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10194 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10196 printf (_("Name index: %ld\n"), aux
.vda_name
);
10198 isum
= idx
+ ent
.vd_aux
;
10200 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10202 /* Check for overflow. */
10203 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10206 isum
+= aux
.vda_next
;
10207 vstart
+= aux
.vda_next
;
10209 eaux
= (Elf_External_Verdaux
*) vstart
;
10210 if (vstart
+ sizeof (*eaux
) > endbuf
)
10213 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10214 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10216 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10217 printf (_(" %#06x: Parent %d: %s\n"),
10218 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10220 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10221 isum
, j
, aux
.vda_name
);
10224 if (j
< ent
.vd_cnt
)
10225 printf (_(" Version def aux past end of section\n"));
10228 file: id:000001,src:000172+005151,op:splice,rep:2. */
10229 if (idx
+ ent
.vd_next
< idx
)
10232 idx
+= ent
.vd_next
;
10235 if (cnt
< section
->sh_info
)
10236 printf (_(" Version definition past end of section\n"));
10242 case SHT_GNU_verneed
:
10244 Elf_External_Verneed
* eneed
;
10251 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10252 printable_section_name (section
), section
->sh_info
);
10254 printf (_(" Addr: 0x"));
10255 printf_vma (section
->sh_addr
);
10256 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10257 (unsigned long) section
->sh_offset
, section
->sh_link
,
10258 printable_section_name_from_index (section
->sh_link
));
10260 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10261 section
->sh_offset
, 1,
10263 _("Version Needs section"));
10266 endbuf
= (char *) eneed
+ section
->sh_size
;
10268 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10270 Elf_External_Verneed
* entry
;
10271 Elf_Internal_Verneed ent
;
10276 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10279 vstart
= ((char *) eneed
) + idx
;
10280 if (vstart
+ sizeof (*entry
) > endbuf
)
10283 entry
= (Elf_External_Verneed
*) vstart
;
10285 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10286 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10287 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10288 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10289 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10291 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10293 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10294 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10296 printf (_(" File: %lx"), ent
.vn_file
);
10298 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10300 /* Check for overflow. */
10301 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10303 vstart
+= ent
.vn_aux
;
10305 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10307 Elf_External_Vernaux
* eaux
;
10308 Elf_Internal_Vernaux aux
;
10310 if (vstart
+ sizeof (*eaux
) > endbuf
)
10312 eaux
= (Elf_External_Vernaux
*) vstart
;
10314 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10315 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10316 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10317 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10318 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10320 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10321 printf (_(" %#06x: Name: %s"),
10322 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10324 printf (_(" %#06x: Name index: %lx"),
10325 isum
, aux
.vna_name
);
10327 printf (_(" Flags: %s Version: %d\n"),
10328 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10330 /* Check for overflow. */
10331 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10332 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10334 warn (_("Invalid vna_next field of %lx\n"),
10339 isum
+= aux
.vna_next
;
10340 vstart
+= aux
.vna_next
;
10343 if (j
< ent
.vn_cnt
)
10344 warn (_("Missing Version Needs auxillary information\n"));
10346 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10348 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10349 cnt
= section
->sh_info
;
10352 idx
+= ent
.vn_next
;
10355 if (cnt
< section
->sh_info
)
10356 warn (_("Missing Version Needs information\n"));
10362 case SHT_GNU_versym
:
10364 Elf_Internal_Shdr
* link_section
;
10367 unsigned char * edata
;
10368 unsigned short * data
;
10370 Elf_Internal_Sym
* symbols
;
10371 Elf_Internal_Shdr
* string_sec
;
10372 unsigned long num_syms
;
10375 if (section
->sh_link
>= elf_header
.e_shnum
)
10378 link_section
= section_headers
+ section
->sh_link
;
10379 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10381 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10386 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10387 if (symbols
== NULL
)
10390 string_sec
= section_headers
+ link_section
->sh_link
;
10392 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10393 string_sec
->sh_size
,
10394 _("version string table"));
10401 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10402 printable_section_name (section
), (unsigned long) total
);
10404 printf (_(" Addr: "));
10405 printf_vma (section
->sh_addr
);
10406 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10407 (unsigned long) section
->sh_offset
, section
->sh_link
,
10408 printable_section_name (link_section
));
10410 off
= offset_from_vma (file
,
10411 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10412 total
* sizeof (short));
10413 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10415 _("version symbol data"));
10423 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10425 for (cnt
= total
; cnt
--;)
10426 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10431 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10435 char *invalid
= _("*invalid*");
10437 printf (" %03x:", cnt
);
10439 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10440 switch (data
[cnt
+ j
])
10443 fputs (_(" 0 (*local*) "), stdout
);
10447 fputs (_(" 1 (*global*) "), stdout
);
10451 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10452 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10454 /* If this index value is greater than the size of the symbols
10455 array, break to avoid an out-of-bounds read. */
10456 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10458 warn (_("invalid index into symbol array\n"));
10463 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10465 Elf_Internal_Verneed ivn
;
10466 unsigned long offset
;
10468 offset
= offset_from_vma
10469 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10470 sizeof (Elf_External_Verneed
));
10474 Elf_Internal_Vernaux ivna
;
10475 Elf_External_Verneed evn
;
10476 Elf_External_Vernaux evna
;
10477 unsigned long a_off
;
10479 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10480 _("version need")) == NULL
)
10483 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10484 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10486 a_off
= offset
+ ivn
.vn_aux
;
10490 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10491 1, _("version need aux (2)")) == NULL
)
10494 ivna
.vna_other
= 0;
10498 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10499 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10502 a_off
+= ivna
.vna_next
;
10504 while (ivna
.vna_other
!= data
[cnt
+ j
]
10505 && ivna
.vna_next
!= 0);
10507 if (ivna
.vna_other
== data
[cnt
+ j
])
10509 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10511 if (ivna
.vna_name
>= string_sec
->sh_size
)
10514 name
= strtab
+ ivna
.vna_name
;
10518 offset
+= ivn
.vn_next
;
10520 while (ivn
.vn_next
);
10523 if (data
[cnt
+ j
] != 0x8001
10524 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10526 Elf_Internal_Verdef ivd
;
10527 Elf_External_Verdef evd
;
10528 unsigned long offset
;
10530 offset
= offset_from_vma
10531 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10536 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10537 _("version def")) == NULL
)
10540 /* PR 17531: file: 046-1082287-0.004. */
10541 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10546 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10547 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10550 offset
+= ivd
.vd_next
;
10552 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10553 && ivd
.vd_next
!= 0);
10555 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10557 Elf_External_Verdaux evda
;
10558 Elf_Internal_Verdaux ivda
;
10560 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10562 if (get_data (&evda
, file
,
10563 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10565 _("version def aux")) == NULL
)
10568 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10570 if (ivda
.vda_name
>= string_sec
->sh_size
)
10572 else if (name
!= NULL
&& name
!= invalid
)
10573 name
= _("*both*");
10575 name
= strtab
+ ivda
.vda_name
;
10579 nn
+= printf ("(%s%-*s",
10581 12 - (int) strlen (name
),
10585 printf ("%*c", 18 - nn
, ' ');
10603 printf (_("\nNo version information found in this file.\n"));
10608 static const char *
10609 get_symbol_binding (unsigned int binding
)
10611 static char buff
[32];
10615 case STB_LOCAL
: return "LOCAL";
10616 case STB_GLOBAL
: return "GLOBAL";
10617 case STB_WEAK
: return "WEAK";
10619 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10620 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10622 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10624 if (binding
== STB_GNU_UNIQUE
10625 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10626 /* GNU is still using the default value 0. */
10627 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10629 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10632 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10637 static const char *
10638 get_symbol_type (unsigned int type
)
10640 static char buff
[32];
10644 case STT_NOTYPE
: return "NOTYPE";
10645 case STT_OBJECT
: return "OBJECT";
10646 case STT_FUNC
: return "FUNC";
10647 case STT_SECTION
: return "SECTION";
10648 case STT_FILE
: return "FILE";
10649 case STT_COMMON
: return "COMMON";
10650 case STT_TLS
: return "TLS";
10651 case STT_RELC
: return "RELC";
10652 case STT_SRELC
: return "SRELC";
10654 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10656 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10657 return "THUMB_FUNC";
10659 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10662 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10663 return "PARISC_MILLI";
10665 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10667 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10669 if (elf_header
.e_machine
== EM_PARISC
)
10671 if (type
== STT_HP_OPAQUE
)
10672 return "HP_OPAQUE";
10673 if (type
== STT_HP_STUB
)
10677 if (type
== STT_GNU_IFUNC
10678 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10679 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10680 /* GNU is still using the default value 0. */
10681 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10684 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10687 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10692 static const char *
10693 get_symbol_visibility (unsigned int visibility
)
10695 switch (visibility
)
10697 case STV_DEFAULT
: return "DEFAULT";
10698 case STV_INTERNAL
: return "INTERNAL";
10699 case STV_HIDDEN
: return "HIDDEN";
10700 case STV_PROTECTED
: return "PROTECTED";
10702 error (_("Unrecognized visibility value: %u"), visibility
);
10703 return _("<unknown>");
10707 static const char *
10708 get_solaris_symbol_visibility (unsigned int visibility
)
10710 switch (visibility
)
10712 case 4: return "EXPORTED";
10713 case 5: return "SINGLETON";
10714 case 6: return "ELIMINATE";
10715 default: return get_symbol_visibility (visibility
);
10719 static const char *
10720 get_mips_symbol_other (unsigned int other
)
10724 case STO_OPTIONAL
: return "OPTIONAL";
10725 case STO_MIPS_PLT
: return "MIPS PLT";
10726 case STO_MIPS_PIC
: return "MIPS PIC";
10727 case STO_MICROMIPS
: return "MICROMIPS";
10728 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10729 case STO_MIPS16
: return "MIPS16";
10730 default: return NULL
;
10734 static const char *
10735 get_ia64_symbol_other (unsigned int other
)
10737 if (is_ia64_vms ())
10739 static char res
[32];
10743 /* Function types is for images and .STB files only. */
10744 switch (elf_header
.e_type
)
10748 switch (VMS_ST_FUNC_TYPE (other
))
10750 case VMS_SFT_CODE_ADDR
:
10751 strcat (res
, " CA");
10753 case VMS_SFT_SYMV_IDX
:
10754 strcat (res
, " VEC");
10757 strcat (res
, " FD");
10759 case VMS_SFT_RESERVE
:
10760 strcat (res
, " RSV");
10763 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10764 VMS_ST_FUNC_TYPE (other
));
10765 strcat (res
, " <unknown>");
10772 switch (VMS_ST_LINKAGE (other
))
10774 case VMS_STL_IGNORE
:
10775 strcat (res
, " IGN");
10777 case VMS_STL_RESERVE
:
10778 strcat (res
, " RSV");
10781 strcat (res
, " STD");
10784 strcat (res
, " LNK");
10787 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10788 VMS_ST_LINKAGE (other
));
10789 strcat (res
, " <unknown>");
10801 static const char *
10802 get_ppc64_symbol_other (unsigned int other
)
10804 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10806 static char buf
[32];
10807 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10808 PPC64_LOCAL_ENTRY_OFFSET (other
));
10814 static const char *
10815 get_symbol_other (unsigned int other
)
10817 const char * result
= NULL
;
10818 static char buff
[32];
10823 switch (elf_header
.e_machine
)
10826 result
= get_mips_symbol_other (other
);
10829 result
= get_ia64_symbol_other (other
);
10832 result
= get_ppc64_symbol_other (other
);
10842 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10846 static const char *
10847 get_symbol_index_type (unsigned int type
)
10849 static char buff
[32];
10853 case SHN_UNDEF
: return "UND";
10854 case SHN_ABS
: return "ABS";
10855 case SHN_COMMON
: return "COM";
10857 if (type
== SHN_IA_64_ANSI_COMMON
10858 && elf_header
.e_machine
== EM_IA_64
10859 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10861 else if ((elf_header
.e_machine
== EM_X86_64
10862 || elf_header
.e_machine
== EM_L1OM
10863 || elf_header
.e_machine
== EM_K1OM
)
10864 && type
== SHN_X86_64_LCOMMON
)
10865 return "LARGE_COM";
10866 else if ((type
== SHN_MIPS_SCOMMON
10867 && elf_header
.e_machine
== EM_MIPS
)
10868 || (type
== SHN_TIC6X_SCOMMON
10869 && elf_header
.e_machine
== EM_TI_C6000
))
10871 else if (type
== SHN_MIPS_SUNDEFINED
10872 && elf_header
.e_machine
== EM_MIPS
)
10874 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10875 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10876 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10877 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10878 else if (type
>= SHN_LORESERVE
)
10879 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10880 else if (type
>= elf_header
.e_shnum
)
10881 sprintf (buff
, _("bad section index[%3d]"), type
);
10883 sprintf (buff
, "%3d", type
);
10891 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10893 unsigned char * e_data
;
10896 /* If the size_t type is smaller than the bfd_size_type, eg because
10897 you are building a 32-bit tool on a 64-bit host, then make sure
10898 that when (number) is cast to (size_t) no information is lost. */
10899 if (sizeof (size_t) < sizeof (bfd_size_type
)
10900 && (bfd_size_type
) ((size_t) number
) != number
)
10902 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10903 " elements of size %u\n"),
10908 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10909 attempting to allocate memory when the read is bound to fail. */
10910 if (ent_size
* number
> current_file_size
)
10912 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10917 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10918 if (e_data
== NULL
)
10920 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10925 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10927 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10928 number
* ent_size
);
10933 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10934 if (i_data
== NULL
)
10936 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10937 " dynamic entries\n"),
10944 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10952 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10954 Elf_Internal_Sym
* psym
;
10957 n
= print_vma (si
, DEC_5
);
10959 fputs (&" "[n
], stdout
);
10960 printf (" %3lu: ", hn
);
10962 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10964 printf (_("<No info available for dynamic symbol number %lu>\n"),
10965 (unsigned long) si
);
10969 psym
= dynamic_symbols
+ si
;
10970 print_vma (psym
->st_value
, LONG_HEX
);
10972 print_vma (psym
->st_size
, DEC_5
);
10974 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10975 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10977 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10978 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10981 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10983 printf (" %-7s", get_symbol_visibility (vis
));
10984 /* Check to see if any other bits in the st_other field are set.
10985 Note - displaying this information disrupts the layout of the
10986 table being generated, but for the moment this case is very
10988 if (psym
->st_other
^ vis
)
10989 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10992 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10993 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10994 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10996 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11000 static const char *
11001 get_symbol_version_string (FILE * file
,
11002 bfd_boolean is_dynsym
,
11003 const char * strtab
,
11004 unsigned long int strtab_size
,
11006 Elf_Internal_Sym
* psym
,
11007 enum versioned_symbol_info
* sym_info
,
11008 unsigned short * vna_other
)
11010 unsigned char data
[2];
11011 unsigned short vers_data
;
11012 unsigned long offset
;
11015 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11018 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11019 sizeof data
+ si
* sizeof (vers_data
));
11021 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
11022 sizeof (data
), 1, _("version data")) == NULL
)
11025 vers_data
= byte_get (data
, 2);
11027 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11030 /* Usually we'd only see verdef for defined symbols, and verneed for
11031 undefined symbols. However, symbols defined by the linker in
11032 .dynbss for variables copied from a shared library in order to
11033 avoid text relocations are defined yet have verneed. We could
11034 use a heuristic to detect the special case, for example, check
11035 for verneed first on symbols defined in SHT_NOBITS sections, but
11036 it is simpler and more reliable to just look for both verdef and
11037 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11039 if (psym
->st_shndx
!= SHN_UNDEF
11040 && vers_data
!= 0x8001
11041 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11043 Elf_Internal_Verdef ivd
;
11044 Elf_Internal_Verdaux ivda
;
11045 Elf_External_Verdaux evda
;
11048 off
= offset_from_vma (file
,
11049 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11050 sizeof (Elf_External_Verdef
));
11054 Elf_External_Verdef evd
;
11056 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11057 _("version def")) == NULL
)
11065 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11066 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11067 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11070 off
+= ivd
.vd_next
;
11072 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11074 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11076 off
-= ivd
.vd_next
;
11079 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11080 _("version def aux")) != NULL
)
11082 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11084 if (psym
->st_name
!= ivda
.vda_name
)
11086 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11087 ? symbol_hidden
: symbol_public
);
11088 return (ivda
.vda_name
< strtab_size
11089 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11095 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11097 Elf_External_Verneed evn
;
11098 Elf_Internal_Verneed ivn
;
11099 Elf_Internal_Vernaux ivna
;
11101 offset
= offset_from_vma (file
,
11102 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11106 unsigned long vna_off
;
11108 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11109 _("version need")) == NULL
)
11112 ivna
.vna_other
= 0;
11117 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11118 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11120 vna_off
= offset
+ ivn
.vn_aux
;
11124 Elf_External_Vernaux evna
;
11126 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11127 _("version need aux (3)")) == NULL
)
11130 ivna
.vna_other
= 0;
11135 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11136 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11137 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11140 vna_off
+= ivna
.vna_next
;
11142 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11144 if (ivna
.vna_other
== vers_data
)
11147 offset
+= ivn
.vn_next
;
11149 while (ivn
.vn_next
!= 0);
11151 if (ivna
.vna_other
== vers_data
)
11153 *sym_info
= symbol_undefined
;
11154 *vna_other
= ivna
.vna_other
;
11155 return (ivna
.vna_name
< strtab_size
11156 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11162 /* Dump the symbol table. */
11164 process_symbol_table (FILE * file
)
11166 Elf_Internal_Shdr
* section
;
11167 bfd_size_type nbuckets
= 0;
11168 bfd_size_type nchains
= 0;
11169 bfd_vma
* buckets
= NULL
;
11170 bfd_vma
* chains
= NULL
;
11171 bfd_vma ngnubuckets
= 0;
11172 bfd_vma
* gnubuckets
= NULL
;
11173 bfd_vma
* gnuchains
= NULL
;
11174 bfd_vma gnusymidx
= 0;
11175 bfd_size_type ngnuchains
= 0;
11177 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11180 if (dynamic_info
[DT_HASH
]
11182 || (do_using_dynamic
11184 && dynamic_strings
!= NULL
)))
11186 unsigned char nb
[8];
11187 unsigned char nc
[8];
11188 unsigned int hash_ent_size
= 4;
11190 if ((elf_header
.e_machine
== EM_ALPHA
11191 || elf_header
.e_machine
== EM_S390
11192 || elf_header
.e_machine
== EM_S390_OLD
)
11193 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11197 (archive_file_offset
11198 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11199 sizeof nb
+ sizeof nc
)),
11202 error (_("Unable to seek to start of dynamic information\n"));
11206 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11208 error (_("Failed to read in number of buckets\n"));
11212 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11214 error (_("Failed to read in number of chains\n"));
11218 nbuckets
= byte_get (nb
, hash_ent_size
);
11219 nchains
= byte_get (nc
, hash_ent_size
);
11221 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11222 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11225 if (buckets
== NULL
|| chains
== NULL
)
11227 if (do_using_dynamic
)
11238 if (dynamic_info_DT_GNU_HASH
11240 || (do_using_dynamic
11242 && dynamic_strings
!= NULL
)))
11244 unsigned char nb
[16];
11245 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11246 bfd_vma buckets_vma
;
11249 (archive_file_offset
11250 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11254 error (_("Unable to seek to start of dynamic information\n"));
11258 if (fread (nb
, 16, 1, file
) != 1)
11260 error (_("Failed to read in number of buckets\n"));
11264 ngnubuckets
= byte_get (nb
, 4);
11265 gnusymidx
= byte_get (nb
+ 4, 4);
11266 bitmaskwords
= byte_get (nb
+ 8, 4);
11267 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11269 buckets_vma
+= bitmaskwords
* 4;
11271 buckets_vma
+= bitmaskwords
* 8;
11274 (archive_file_offset
11275 + offset_from_vma (file
, buckets_vma
, 4)),
11278 error (_("Unable to seek to start of dynamic information\n"));
11282 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11284 if (gnubuckets
== NULL
)
11287 for (i
= 0; i
< ngnubuckets
; i
++)
11288 if (gnubuckets
[i
] != 0)
11290 if (gnubuckets
[i
] < gnusymidx
)
11293 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11294 maxchain
= gnubuckets
[i
];
11297 if (maxchain
== 0xffffffff)
11300 maxchain
-= gnusymidx
;
11303 (archive_file_offset
11304 + offset_from_vma (file
, buckets_vma
11305 + 4 * (ngnubuckets
+ maxchain
), 4)),
11308 error (_("Unable to seek to start of dynamic information\n"));
11314 if (fread (nb
, 4, 1, file
) != 1)
11316 error (_("Failed to determine last chain length\n"));
11320 if (maxchain
+ 1 == 0)
11325 while ((byte_get (nb
, 4) & 1) == 0);
11328 (archive_file_offset
11329 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11332 error (_("Unable to seek to start of dynamic information\n"));
11336 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11337 ngnuchains
= maxchain
;
11340 if (gnuchains
== NULL
)
11345 if (do_using_dynamic
)
11350 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11352 && do_using_dynamic
11353 && dynamic_strings
!= NULL
11354 && dynamic_symbols
!= NULL
)
11358 if (dynamic_info
[DT_HASH
])
11362 printf (_("\nSymbol table for image:\n"));
11364 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11366 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11368 for (hn
= 0; hn
< nbuckets
; hn
++)
11373 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11374 print_dynamic_symbol (si
, hn
);
11378 if (dynamic_info_DT_GNU_HASH
)
11380 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11382 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11384 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11386 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11387 if (gnubuckets
[hn
] != 0)
11389 bfd_vma si
= gnubuckets
[hn
];
11390 bfd_vma off
= si
- gnusymidx
;
11394 print_dynamic_symbol (si
, hn
);
11397 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11401 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11402 && section_headers
!= NULL
)
11406 for (i
= 0, section
= section_headers
;
11407 i
< elf_header
.e_shnum
;
11411 char * strtab
= NULL
;
11412 unsigned long int strtab_size
= 0;
11413 Elf_Internal_Sym
* symtab
;
11414 Elf_Internal_Sym
* psym
;
11415 unsigned long num_syms
;
11417 if ((section
->sh_type
!= SHT_SYMTAB
11418 && section
->sh_type
!= SHT_DYNSYM
)
11420 && section
->sh_type
== SHT_SYMTAB
))
11423 if (section
->sh_entsize
== 0)
11425 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11426 printable_section_name (section
));
11430 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11431 printable_section_name (section
),
11432 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11435 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11437 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11439 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11440 if (symtab
== NULL
)
11443 if (section
->sh_link
== elf_header
.e_shstrndx
)
11445 strtab
= string_table
;
11446 strtab_size
= string_table_length
;
11448 else if (section
->sh_link
< elf_header
.e_shnum
)
11450 Elf_Internal_Shdr
* string_sec
;
11452 string_sec
= section_headers
+ section
->sh_link
;
11454 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11455 1, string_sec
->sh_size
,
11456 _("string table"));
11457 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11460 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11462 const char *version_string
;
11463 enum versioned_symbol_info sym_info
;
11464 unsigned short vna_other
;
11466 printf ("%6d: ", si
);
11467 print_vma (psym
->st_value
, LONG_HEX
);
11469 print_vma (psym
->st_size
, DEC_5
);
11470 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11471 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11472 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11473 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11476 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11478 printf (" %-7s", get_symbol_visibility (vis
));
11479 /* Check to see if any other bits in the st_other field are set.
11480 Note - displaying this information disrupts the layout of the
11481 table being generated, but for the moment this case is very rare. */
11482 if (psym
->st_other
^ vis
)
11483 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11485 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11486 print_symbol (25, psym
->st_name
< strtab_size
11487 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11490 = get_symbol_version_string (file
,
11491 section
->sh_type
== SHT_DYNSYM
,
11492 strtab
, strtab_size
, si
,
11493 psym
, &sym_info
, &vna_other
);
11494 if (version_string
)
11496 if (sym_info
== symbol_undefined
)
11497 printf ("@%s (%d)", version_string
, vna_other
);
11499 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11505 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11506 && si
>= section
->sh_info
11507 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11508 && elf_header
.e_machine
!= EM_MIPS
11509 /* Solaris binaries have been found to violate this requirement as
11510 well. Not sure if this is a bug or an ABI requirement. */
11511 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11512 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11513 si
, printable_section_name (section
), section
->sh_info
);
11517 if (strtab
!= string_table
)
11523 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11525 if (do_histogram
&& buckets
!= NULL
)
11527 unsigned long * lengths
;
11528 unsigned long * counts
;
11531 unsigned long maxlength
= 0;
11532 unsigned long nzero_counts
= 0;
11533 unsigned long nsyms
= 0;
11534 unsigned long chained
;
11536 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11537 (unsigned long) nbuckets
);
11539 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11540 if (lengths
== NULL
)
11542 error (_("Out of memory allocating space for histogram buckets\n"));
11546 printf (_(" Length Number %% of total Coverage\n"));
11547 for (hn
= 0; hn
< nbuckets
; ++hn
)
11549 for (si
= buckets
[hn
], chained
= 0;
11550 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11551 si
= chains
[si
], ++chained
)
11554 if (maxlength
< ++lengths
[hn
])
11558 /* PR binutils/17531: A corrupt binary could contain broken
11559 histogram data. Do not go into an infinite loop trying
11561 if (chained
> nchains
)
11563 error (_("histogram chain is corrupt\n"));
11568 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11569 if (counts
== NULL
)
11572 error (_("Out of memory allocating space for histogram counts\n"));
11576 for (hn
= 0; hn
< nbuckets
; ++hn
)
11577 ++counts
[lengths
[hn
]];
11582 printf (" 0 %-10lu (%5.1f%%)\n",
11583 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11584 for (i
= 1; i
<= maxlength
; ++i
)
11586 nzero_counts
+= counts
[i
] * i
;
11587 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11588 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11589 (nzero_counts
* 100.0) / nsyms
);
11597 if (buckets
!= NULL
)
11603 if (do_histogram
&& gnubuckets
!= NULL
)
11605 unsigned long * lengths
;
11606 unsigned long * counts
;
11608 unsigned long maxlength
= 0;
11609 unsigned long nzero_counts
= 0;
11610 unsigned long nsyms
= 0;
11612 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11613 (unsigned long) ngnubuckets
);
11615 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11616 if (lengths
== NULL
)
11618 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11622 printf (_(" Length Number %% of total Coverage\n"));
11624 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11625 if (gnubuckets
[hn
] != 0)
11627 bfd_vma off
, length
= 1;
11629 for (off
= gnubuckets
[hn
] - gnusymidx
;
11630 /* PR 17531 file: 010-77222-0.004. */
11631 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11634 lengths
[hn
] = length
;
11635 if (length
> maxlength
)
11636 maxlength
= length
;
11640 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11641 if (counts
== NULL
)
11644 error (_("Out of memory allocating space for gnu histogram counts\n"));
11648 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11649 ++counts
[lengths
[hn
]];
11651 if (ngnubuckets
> 0)
11654 printf (" 0 %-10lu (%5.1f%%)\n",
11655 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11656 for (j
= 1; j
<= maxlength
; ++j
)
11658 nzero_counts
+= counts
[j
] * j
;
11659 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11660 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11661 (nzero_counts
* 100.0) / nsyms
);
11675 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11679 if (dynamic_syminfo
== NULL
11681 /* No syminfo, this is ok. */
11684 /* There better should be a dynamic symbol section. */
11685 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11689 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11690 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11692 printf (_(" Num: Name BoundTo Flags\n"));
11693 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11695 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11697 printf ("%4d: ", i
);
11698 if (i
>= num_dynamic_syms
)
11699 printf (_("<corrupt index>"));
11700 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11701 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11703 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11706 switch (dynamic_syminfo
[i
].si_boundto
)
11708 case SYMINFO_BT_SELF
:
11709 fputs ("SELF ", stdout
);
11711 case SYMINFO_BT_PARENT
:
11712 fputs ("PARENT ", stdout
);
11715 if (dynamic_syminfo
[i
].si_boundto
> 0
11716 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11717 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11719 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11723 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11727 if (flags
& SYMINFO_FLG_DIRECT
)
11728 printf (" DIRECT");
11729 if (flags
& SYMINFO_FLG_PASSTHRU
)
11730 printf (" PASSTHRU");
11731 if (flags
& SYMINFO_FLG_COPY
)
11733 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11734 printf (" LAZYLOAD");
11742 #define IN_RANGE(START,END,ADDR,OFF) \
11743 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11745 /* Check to see if the given reloc needs to be handled in a target specific
11746 manner. If so then process the reloc and return TRUE otherwise return
11749 If called with reloc == NULL, then this is a signal that reloc processing
11750 for the current section has finished, and any saved state should be
11754 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11755 unsigned char * start
,
11756 unsigned char * end
,
11757 Elf_Internal_Sym
* symtab
,
11758 unsigned long num_syms
)
11760 unsigned int reloc_type
= 0;
11761 unsigned long sym_index
= 0;
11765 reloc_type
= get_reloc_type (reloc
->r_info
);
11766 sym_index
= get_reloc_symindex (reloc
->r_info
);
11769 switch (elf_header
.e_machine
)
11772 case EM_MSP430_OLD
:
11774 static Elf_Internal_Sym
* saved_sym
= NULL
;
11782 switch (reloc_type
)
11784 case 10: /* R_MSP430_SYM_DIFF */
11785 if (uses_msp430x_relocs ())
11787 /* Fall through. */
11788 case 21: /* R_MSP430X_SYM_DIFF */
11790 if (sym_index
>= num_syms
)
11791 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11794 saved_sym
= symtab
+ sym_index
;
11797 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11798 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11799 goto handle_sym_diff
;
11801 case 5: /* R_MSP430_16_BYTE */
11802 case 9: /* R_MSP430_8 */
11803 if (uses_msp430x_relocs ())
11805 goto handle_sym_diff
;
11807 case 2: /* R_MSP430_ABS16 */
11808 case 15: /* R_MSP430X_ABS16 */
11809 if (! uses_msp430x_relocs ())
11811 goto handle_sym_diff
;
11814 if (saved_sym
!= NULL
)
11816 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11819 if (sym_index
>= num_syms
)
11820 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11824 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11825 - saved_sym
->st_value
);
11827 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11828 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11831 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11832 (long) reloc
->r_offset
);
11841 if (saved_sym
!= NULL
)
11842 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11849 case EM_CYGNUS_MN10300
:
11851 static Elf_Internal_Sym
* saved_sym
= NULL
;
11859 switch (reloc_type
)
11861 case 34: /* R_MN10300_ALIGN */
11863 case 33: /* R_MN10300_SYM_DIFF */
11864 if (sym_index
>= num_syms
)
11865 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11868 saved_sym
= symtab
+ sym_index
;
11871 case 1: /* R_MN10300_32 */
11872 case 2: /* R_MN10300_16 */
11873 if (saved_sym
!= NULL
)
11875 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11878 if (sym_index
>= num_syms
)
11879 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11883 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11884 - saved_sym
->st_value
);
11886 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11887 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11889 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11890 (long) reloc
->r_offset
);
11898 if (saved_sym
!= NULL
)
11899 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11907 static bfd_vma saved_sym1
= 0;
11908 static bfd_vma saved_sym2
= 0;
11909 static bfd_vma value
;
11913 saved_sym1
= saved_sym2
= 0;
11917 switch (reloc_type
)
11919 case 0x80: /* R_RL78_SYM. */
11920 saved_sym1
= saved_sym2
;
11921 if (sym_index
>= num_syms
)
11922 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11926 saved_sym2
= symtab
[sym_index
].st_value
;
11927 saved_sym2
+= reloc
->r_addend
;
11931 case 0x83: /* R_RL78_OPsub. */
11932 value
= saved_sym1
- saved_sym2
;
11933 saved_sym2
= saved_sym1
= 0;
11937 case 0x41: /* R_RL78_ABS32. */
11938 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11939 byte_put (start
+ reloc
->r_offset
, value
, 4);
11941 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11942 (long) reloc
->r_offset
);
11946 case 0x43: /* R_RL78_ABS16. */
11947 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11948 byte_put (start
+ reloc
->r_offset
, value
, 2);
11950 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11951 (long) reloc
->r_offset
);
11965 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11966 DWARF debug sections. This is a target specific test. Note - we do not
11967 go through the whole including-target-headers-multiple-times route, (as
11968 we have already done with <elf/h8.h>) because this would become very
11969 messy and even then this function would have to contain target specific
11970 information (the names of the relocs instead of their numeric values).
11971 FIXME: This is not the correct way to solve this problem. The proper way
11972 is to have target specific reloc sizing and typing functions created by
11973 the reloc-macros.h header, in the same way that it already creates the
11974 reloc naming functions. */
11977 is_32bit_abs_reloc (unsigned int reloc_type
)
11979 /* Please keep this table alpha-sorted for ease of visual lookup. */
11980 switch (elf_header
.e_machine
)
11984 return reloc_type
== 1; /* R_386_32. */
11986 return reloc_type
== 1; /* R_68K_32. */
11988 return reloc_type
== 1; /* R_860_32. */
11990 return reloc_type
== 2; /* R_960_32. */
11992 return (reloc_type
== 258
11993 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11994 case EM_ADAPTEVA_EPIPHANY
:
11995 return reloc_type
== 3;
11997 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11999 return reloc_type
== 1; /* R_ARC_32. */
12000 case EM_ARC_COMPACT
:
12001 case EM_ARC_COMPACT2
:
12002 return reloc_type
== 4; /* R_ARC_32. */
12004 return reloc_type
== 2; /* R_ARM_ABS32 */
12007 return reloc_type
== 1;
12009 return reloc_type
== 0x12; /* R_byte4_data. */
12011 return reloc_type
== 3; /* R_CRIS_32. */
12013 return reloc_type
== 3; /* R_CR16_NUM32. */
12015 return reloc_type
== 15; /* R_CRX_NUM32. */
12016 case EM_CYGNUS_FRV
:
12017 return reloc_type
== 1;
12018 case EM_CYGNUS_D10V
:
12020 return reloc_type
== 6; /* R_D10V_32. */
12021 case EM_CYGNUS_D30V
:
12023 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12025 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12026 case EM_CYGNUS_FR30
:
12028 return reloc_type
== 3; /* R_FR30_32. */
12030 return reloc_type
== 1; /* R_FT32_32. */
12034 return reloc_type
== 1; /* R_H8_DIR32. */
12036 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12037 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
12040 return reloc_type
== 2; /* R_IP2K_32. */
12042 return reloc_type
== 2; /* R_IQ2000_32. */
12043 case EM_LATTICEMICO32
:
12044 return reloc_type
== 3; /* R_LM32_32. */
12047 return reloc_type
== 3; /* R_M32C_32. */
12049 return reloc_type
== 34; /* R_M32R_32_RELA. */
12052 return reloc_type
== 6; /* R_M68HC11_32. */
12054 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12055 case EM_CYGNUS_MEP
:
12056 return reloc_type
== 4; /* R_MEP_32. */
12058 return reloc_type
== 2; /* R_METAG_ADDR32. */
12059 case EM_MICROBLAZE
:
12060 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12062 return reloc_type
== 2; /* R_MIPS_32. */
12064 return reloc_type
== 4; /* R_MMIX_32. */
12065 case EM_CYGNUS_MN10200
:
12067 return reloc_type
== 1; /* R_MN10200_32. */
12068 case EM_CYGNUS_MN10300
:
12070 return reloc_type
== 1; /* R_MN10300_32. */
12072 return reloc_type
== 1; /* R_MOXIE_32. */
12073 case EM_MSP430_OLD
:
12075 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12077 return reloc_type
== 2; /* R_MT_32. */
12079 return reloc_type
== 20; /* R_NDS32_RELA. */
12080 case EM_ALTERA_NIOS2
:
12081 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12083 return reloc_type
== 1; /* R_NIOS_32. */
12085 return reloc_type
== 1; /* R_OR1K_32. */
12087 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12088 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12091 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12093 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12095 return reloc_type
== 1; /* R_PPC_ADDR32. */
12097 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12099 return reloc_type
== 1; /* R_RISCV_32. */
12101 return reloc_type
== 1; /* R_RL78_DIR32. */
12103 return reloc_type
== 1; /* R_RX_DIR32. */
12105 return reloc_type
== 1; /* R_I370_ADDR31. */
12108 return reloc_type
== 4; /* R_S390_32. */
12110 return reloc_type
== 8; /* R_SCORE_ABS32. */
12112 return reloc_type
== 1; /* R_SH_DIR32. */
12113 case EM_SPARC32PLUS
:
12116 return reloc_type
== 3 /* R_SPARC_32. */
12117 || reloc_type
== 23; /* R_SPARC_UA32. */
12119 return reloc_type
== 6; /* R_SPU_ADDR32 */
12121 return reloc_type
== 1; /* R_C6000_ABS32. */
12123 return reloc_type
== 2; /* R_TILEGX_32. */
12125 return reloc_type
== 1; /* R_TILEPRO_32. */
12126 case EM_CYGNUS_V850
:
12128 return reloc_type
== 6; /* R_V850_ABS32. */
12130 return reloc_type
== 0x33; /* R_V810_WORD. */
12132 return reloc_type
== 1; /* R_VAX_32. */
12134 return reloc_type
== 3; /* R_VISIUM_32. */
12135 case EM_WEBASSEMBLY
:
12136 return reloc_type
== 1; /* R_WASM32_32. */
12140 return reloc_type
== 10; /* R_X86_64_32. */
12143 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12145 return reloc_type
== 4; /* R_XGATE_32. */
12147 return reloc_type
== 1; /* R_XSTROMY16_32. */
12148 case EM_XTENSA_OLD
:
12150 return reloc_type
== 1; /* R_XTENSA_32. */
12153 static unsigned int prev_warn
= 0;
12155 /* Avoid repeating the same warning multiple times. */
12156 if (prev_warn
!= elf_header
.e_machine
)
12157 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12158 elf_header
.e_machine
);
12159 prev_warn
= elf_header
.e_machine
;
12165 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12166 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12169 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12171 switch (elf_header
.e_machine
)
12172 /* Please keep this table alpha-sorted for ease of visual lookup. */
12176 return reloc_type
== 2; /* R_386_PC32. */
12178 return reloc_type
== 4; /* R_68K_PC32. */
12180 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12181 case EM_ADAPTEVA_EPIPHANY
:
12182 return reloc_type
== 6;
12184 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12185 case EM_ARC_COMPACT
:
12186 case EM_ARC_COMPACT2
:
12187 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12189 return reloc_type
== 3; /* R_ARM_REL32 */
12192 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12193 case EM_MICROBLAZE
:
12194 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12196 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12198 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12200 return reloc_type
== 26; /* R_PPC_REL32. */
12202 return reloc_type
== 26; /* R_PPC64_REL32. */
12205 return reloc_type
== 5; /* R_390_PC32. */
12207 return reloc_type
== 2; /* R_SH_REL32. */
12208 case EM_SPARC32PLUS
:
12211 return reloc_type
== 6; /* R_SPARC_DISP32. */
12213 return reloc_type
== 13; /* R_SPU_REL32. */
12215 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12217 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12219 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12223 return reloc_type
== 2; /* R_X86_64_PC32. */
12224 case EM_XTENSA_OLD
:
12226 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12228 /* Do not abort or issue an error message here. Not all targets use
12229 pc-relative 32-bit relocs in their DWARF debug information and we
12230 have already tested for target coverage in is_32bit_abs_reloc. A
12231 more helpful warning message will be generated by apply_relocations
12232 anyway, so just return. */
12237 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12238 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12241 is_64bit_abs_reloc (unsigned int reloc_type
)
12243 switch (elf_header
.e_machine
)
12246 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12248 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12250 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12252 return reloc_type
== 80; /* R_PARISC_DIR64. */
12254 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12256 return reloc_type
== 2; /* R_RISCV_64. */
12257 case EM_SPARC32PLUS
:
12260 return reloc_type
== 54; /* R_SPARC_UA64. */
12264 return reloc_type
== 1; /* R_X86_64_64. */
12267 return reloc_type
== 22; /* R_S390_64. */
12269 return reloc_type
== 1; /* R_TILEGX_64. */
12271 return reloc_type
== 18; /* R_MIPS_64. */
12277 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12278 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12281 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12283 switch (elf_header
.e_machine
)
12286 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12288 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12290 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12292 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12294 return reloc_type
== 44; /* R_PPC64_REL64. */
12295 case EM_SPARC32PLUS
:
12298 return reloc_type
== 46; /* R_SPARC_DISP64. */
12302 return reloc_type
== 24; /* R_X86_64_PC64. */
12305 return reloc_type
== 23; /* R_S390_PC64. */
12307 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12313 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12314 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12317 is_24bit_abs_reloc (unsigned int reloc_type
)
12319 switch (elf_header
.e_machine
)
12321 case EM_CYGNUS_MN10200
:
12323 return reloc_type
== 4; /* R_MN10200_24. */
12325 return reloc_type
== 5; /* R_FT32_20. */
12331 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12332 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12335 is_16bit_abs_reloc (unsigned int reloc_type
)
12337 /* Please keep this table alpha-sorted for ease of visual lookup. */
12338 switch (elf_header
.e_machine
)
12341 case EM_ARC_COMPACT
:
12342 case EM_ARC_COMPACT2
:
12343 return reloc_type
== 2; /* R_ARC_16. */
12344 case EM_ADAPTEVA_EPIPHANY
:
12345 return reloc_type
== 5;
12348 return reloc_type
== 4; /* R_AVR_16. */
12349 case EM_CYGNUS_D10V
:
12351 return reloc_type
== 3; /* R_D10V_16. */
12355 return reloc_type
== R_H8_DIR16
;
12358 return reloc_type
== 1; /* R_IP2K_16. */
12361 return reloc_type
== 1; /* R_M32C_16 */
12362 case EM_CYGNUS_MN10200
:
12364 return reloc_type
== 2; /* R_MN10200_16. */
12365 case EM_CYGNUS_MN10300
:
12367 return reloc_type
== 2; /* R_MN10300_16. */
12369 if (uses_msp430x_relocs ())
12370 return reloc_type
== 2; /* R_MSP430_ABS16. */
12371 /* Fall through. */
12372 case EM_MSP430_OLD
:
12373 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12375 return reloc_type
== 19; /* R_NDS32_RELA. */
12376 case EM_ALTERA_NIOS2
:
12377 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12379 return reloc_type
== 9; /* R_NIOS_16. */
12381 return reloc_type
== 2; /* R_OR1K_16. */
12383 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12385 return reloc_type
== 2; /* R_C6000_ABS16. */
12387 return reloc_type
== 2; /* R_VISIUM_16. */
12390 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12392 return reloc_type
== 3; /* R_XGATE_16. */
12398 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12399 relocation entries (possibly formerly used for SHT_GROUP sections). */
12402 is_none_reloc (unsigned int reloc_type
)
12404 switch (elf_header
.e_machine
)
12406 case EM_386
: /* R_386_NONE. */
12407 case EM_68K
: /* R_68K_NONE. */
12408 case EM_ADAPTEVA_EPIPHANY
:
12409 case EM_ALPHA
: /* R_ALPHA_NONE. */
12410 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12411 case EM_ARC
: /* R_ARC_NONE. */
12412 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12413 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12414 case EM_ARM
: /* R_ARM_NONE. */
12415 case EM_C166
: /* R_XC16X_NONE. */
12416 case EM_CRIS
: /* R_CRIS_NONE. */
12417 case EM_FT32
: /* R_FT32_NONE. */
12418 case EM_IA_64
: /* R_IA64_NONE. */
12419 case EM_K1OM
: /* R_X86_64_NONE. */
12420 case EM_L1OM
: /* R_X86_64_NONE. */
12421 case EM_M32R
: /* R_M32R_NONE. */
12422 case EM_MIPS
: /* R_MIPS_NONE. */
12423 case EM_MN10300
: /* R_MN10300_NONE. */
12424 case EM_MOXIE
: /* R_MOXIE_NONE. */
12425 case EM_NIOS32
: /* R_NIOS_NONE. */
12426 case EM_OR1K
: /* R_OR1K_NONE. */
12427 case EM_PARISC
: /* R_PARISC_NONE. */
12428 case EM_PPC64
: /* R_PPC64_NONE. */
12429 case EM_PPC
: /* R_PPC_NONE. */
12430 case EM_RISCV
: /* R_RISCV_NONE. */
12431 case EM_S390
: /* R_390_NONE. */
12433 case EM_SH
: /* R_SH_NONE. */
12434 case EM_SPARC32PLUS
:
12435 case EM_SPARC
: /* R_SPARC_NONE. */
12437 case EM_TILEGX
: /* R_TILEGX_NONE. */
12438 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12439 case EM_TI_C6000
:/* R_C6000_NONE. */
12440 case EM_X86_64
: /* R_X86_64_NONE. */
12442 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12443 return reloc_type
== 0;
12446 return reloc_type
== 0 || reloc_type
== 256;
12449 return (reloc_type
== 0 /* R_AVR_NONE. */
12450 || reloc_type
== 30 /* R_AVR_DIFF8. */
12451 || reloc_type
== 31 /* R_AVR_DIFF16. */
12452 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12454 return reloc_type
== 3; /* R_METAG_NONE. */
12456 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12457 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12458 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12459 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12460 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12462 return (reloc_type
== 0 /* R_PRU_NONE. */
12463 || reloc_type
== 65 /* R_PRU_DIFF8. */
12464 || reloc_type
== 66 /* R_PRU_DIFF16. */
12465 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12466 case EM_XTENSA_OLD
:
12468 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12469 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12470 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12471 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12476 /* Returns TRUE if there is a relocation against
12477 section NAME at OFFSET bytes. */
12480 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12482 Elf_Internal_Rela
* relocs
;
12483 Elf_Internal_Rela
* rp
;
12485 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12488 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12490 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12491 if (rp
->r_offset
== offset
)
12497 /* Apply relocations to a section.
12498 Returns TRUE upon success, FALSE otherwise.
12499 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12500 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12501 will be set to the number of relocs loaded.
12503 Note: So far support has been added only for those relocations
12504 which can be found in debug sections. FIXME: Add support for
12505 more relocations ? */
12508 apply_relocations (void * file
,
12509 const Elf_Internal_Shdr
* section
,
12510 unsigned char * start
,
12511 bfd_size_type size
,
12512 void ** relocs_return
,
12513 unsigned long * num_relocs_return
)
12515 Elf_Internal_Shdr
* relsec
;
12516 unsigned char * end
= start
+ size
;
12517 bfd_boolean res
= TRUE
;
12519 if (relocs_return
!= NULL
)
12521 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12522 * num_relocs_return
= 0;
12525 if (elf_header
.e_type
!= ET_REL
)
12526 /* No relocs to apply. */
12529 /* Find the reloc section associated with the section. */
12530 for (relsec
= section_headers
;
12531 relsec
< section_headers
+ elf_header
.e_shnum
;
12534 bfd_boolean is_rela
;
12535 unsigned long num_relocs
;
12536 Elf_Internal_Rela
* relocs
;
12537 Elf_Internal_Rela
* rp
;
12538 Elf_Internal_Shdr
* symsec
;
12539 Elf_Internal_Sym
* symtab
;
12540 unsigned long num_syms
;
12541 Elf_Internal_Sym
* sym
;
12543 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12544 || relsec
->sh_info
>= elf_header
.e_shnum
12545 || section_headers
+ relsec
->sh_info
!= section
12546 || relsec
->sh_size
== 0
12547 || relsec
->sh_link
>= elf_header
.e_shnum
)
12550 is_rela
= relsec
->sh_type
== SHT_RELA
;
12554 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12555 relsec
->sh_size
, & relocs
, & num_relocs
))
12560 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12561 relsec
->sh_size
, & relocs
, & num_relocs
))
12565 /* SH uses RELA but uses in place value instead of the addend field. */
12566 if (elf_header
.e_machine
== EM_SH
)
12569 symsec
= section_headers
+ relsec
->sh_link
;
12570 if (symsec
->sh_type
!= SHT_SYMTAB
12571 && symsec
->sh_type
!= SHT_DYNSYM
)
12573 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12575 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12578 unsigned int reloc_type
;
12579 unsigned int reloc_size
;
12580 unsigned char * rloc
;
12581 unsigned long sym_index
;
12583 reloc_type
= get_reloc_type (rp
->r_info
);
12585 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12587 else if (is_none_reloc (reloc_type
))
12589 else if (is_32bit_abs_reloc (reloc_type
)
12590 || is_32bit_pcrel_reloc (reloc_type
))
12592 else if (is_64bit_abs_reloc (reloc_type
)
12593 || is_64bit_pcrel_reloc (reloc_type
))
12595 else if (is_24bit_abs_reloc (reloc_type
))
12597 else if (is_16bit_abs_reloc (reloc_type
))
12601 static unsigned int prev_reloc
= 0;
12602 if (reloc_type
!= prev_reloc
)
12603 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12604 reloc_type
, printable_section_name (section
));
12605 prev_reloc
= reloc_type
;
12610 rloc
= start
+ rp
->r_offset
;
12611 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12613 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12614 (unsigned long) rp
->r_offset
,
12615 printable_section_name (section
));
12620 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12621 if (sym_index
>= num_syms
)
12623 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12624 sym_index
, printable_section_name (section
));
12628 sym
= symtab
+ sym_index
;
12630 /* If the reloc has a symbol associated with it,
12631 make sure that it is of an appropriate type.
12633 Relocations against symbols without type can happen.
12634 Gcc -feliminate-dwarf2-dups may generate symbols
12635 without type for debug info.
12637 Icc generates relocations against function symbols
12638 instead of local labels.
12640 Relocations against object symbols can happen, eg when
12641 referencing a global array. For an example of this see
12642 the _clz.o binary in libgcc.a. */
12644 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12645 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12647 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12648 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12649 (long int)(rp
- relocs
),
12650 printable_section_name (relsec
));
12657 addend
+= rp
->r_addend
;
12658 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12659 partial_inplace. */
12661 || (elf_header
.e_machine
== EM_XTENSA
12662 && reloc_type
== 1)
12663 || ((elf_header
.e_machine
== EM_PJ
12664 || elf_header
.e_machine
== EM_PJ_OLD
)
12665 && reloc_type
== 1)
12666 || ((elf_header
.e_machine
== EM_D30V
12667 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12668 && reloc_type
== 12))
12669 addend
+= byte_get (rloc
, reloc_size
);
12671 if (is_32bit_pcrel_reloc (reloc_type
)
12672 || is_64bit_pcrel_reloc (reloc_type
))
12674 /* On HPPA, all pc-relative relocations are biased by 8. */
12675 if (elf_header
.e_machine
== EM_PARISC
)
12677 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12681 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12685 /* Let the target specific reloc processing code know that
12686 we have finished with these relocs. */
12687 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12691 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12692 * num_relocs_return
= num_relocs
;
12703 #ifdef SUPPORT_DISASSEMBLY
12705 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12707 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12709 /* FIXME: XXX -- to be done --- XXX */
12715 /* Reads in the contents of SECTION from FILE, returning a pointer
12716 to a malloc'ed buffer or NULL if something went wrong. */
12719 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12721 bfd_size_type num_bytes
;
12723 num_bytes
= section
->sh_size
;
12725 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12727 printf (_("\nSection '%s' has no data to dump.\n"),
12728 printable_section_name (section
));
12732 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12733 _("section contents"));
12736 /* Uncompresses a section that was compressed using zlib, in place. */
12739 uncompress_section_contents (unsigned char **buffer
,
12740 dwarf_size_type uncompressed_size
,
12741 dwarf_size_type
*size
)
12743 dwarf_size_type compressed_size
= *size
;
12744 unsigned char * compressed_buffer
= *buffer
;
12745 unsigned char * uncompressed_buffer
;
12749 /* It is possible the section consists of several compressed
12750 buffers concatenated together, so we uncompress in a loop. */
12751 /* PR 18313: The state field in the z_stream structure is supposed
12752 to be invisible to the user (ie us), but some compilers will
12753 still complain about it being used without initialisation. So
12754 we first zero the entire z_stream structure and then set the fields
12756 memset (& strm
, 0, sizeof strm
);
12757 strm
.avail_in
= compressed_size
;
12758 strm
.next_in
= (Bytef
*) compressed_buffer
;
12759 strm
.avail_out
= uncompressed_size
;
12760 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12762 rc
= inflateInit (& strm
);
12763 while (strm
.avail_in
> 0)
12767 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12768 + (uncompressed_size
- strm
.avail_out
));
12769 rc
= inflate (&strm
, Z_FINISH
);
12770 if (rc
!= Z_STREAM_END
)
12772 rc
= inflateReset (& strm
);
12774 rc
= inflateEnd (& strm
);
12776 || strm
.avail_out
!= 0)
12779 *buffer
= uncompressed_buffer
;
12780 *size
= uncompressed_size
;
12784 free (uncompressed_buffer
);
12785 /* Indicate decompression failure. */
12791 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12793 Elf_Internal_Shdr
* relsec
;
12794 bfd_size_type num_bytes
;
12795 unsigned char * data
;
12796 unsigned char * end
;
12797 unsigned char * real_start
;
12798 unsigned char * start
;
12799 bfd_boolean some_strings_shown
;
12801 real_start
= start
= (unsigned char *) get_section_contents (section
,
12805 num_bytes
= section
->sh_size
;
12807 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12809 if (decompress_dumps
)
12811 dwarf_size_type new_size
= num_bytes
;
12812 dwarf_size_type uncompressed_size
= 0;
12814 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12816 Elf_Internal_Chdr chdr
;
12817 unsigned int compression_header_size
12818 = get_compression_header (& chdr
, (unsigned char *) start
,
12821 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12823 warn (_("section '%s' has unsupported compress type: %d\n"),
12824 printable_section_name (section
), chdr
.ch_type
);
12827 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12829 warn (_("compressed section '%s' is corrupted\n"),
12830 printable_section_name (section
));
12833 uncompressed_size
= chdr
.ch_size
;
12834 start
+= compression_header_size
;
12835 new_size
-= compression_header_size
;
12837 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12839 /* Read the zlib header. In this case, it should be "ZLIB"
12840 followed by the uncompressed section size, 8 bytes in
12841 big-endian order. */
12842 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12843 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12844 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12845 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12846 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12847 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12848 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12849 uncompressed_size
+= start
[11];
12854 if (uncompressed_size
)
12856 if (uncompress_section_contents (& start
,
12857 uncompressed_size
, & new_size
))
12858 num_bytes
= new_size
;
12861 error (_("Unable to decompress section %s\n"),
12862 printable_section_name (section
));
12867 start
= real_start
;
12870 /* If the section being dumped has relocations against it the user might
12871 be expecting these relocations to have been applied. Check for this
12872 case and issue a warning message in order to avoid confusion.
12873 FIXME: Maybe we ought to have an option that dumps a section with
12874 relocs applied ? */
12875 for (relsec
= section_headers
;
12876 relsec
< section_headers
+ elf_header
.e_shnum
;
12879 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12880 || relsec
->sh_info
>= elf_header
.e_shnum
12881 || section_headers
+ relsec
->sh_info
!= section
12882 || relsec
->sh_size
== 0
12883 || relsec
->sh_link
>= elf_header
.e_shnum
)
12886 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12891 end
= start
+ num_bytes
;
12892 some_strings_shown
= FALSE
;
12896 while (!ISPRINT (* data
))
12897 if (++ data
>= end
)
12902 size_t maxlen
= end
- data
;
12905 /* PR 11128: Use two separate invocations in order to work
12906 around bugs in the Solaris 8 implementation of printf. */
12907 printf (" [%6tx] ", data
- start
);
12909 printf (" [%6Ix] ", (size_t) (data
- start
));
12913 print_symbol ((int) maxlen
, (const char *) data
);
12915 data
+= strnlen ((const char *) data
, maxlen
);
12919 printf (_("<corrupt>\n"));
12922 some_strings_shown
= TRUE
;
12926 if (! some_strings_shown
)
12927 printf (_(" No strings found in this section."));
12936 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12938 bfd_boolean relocate
)
12940 Elf_Internal_Shdr
* relsec
;
12941 bfd_size_type bytes
;
12942 bfd_size_type section_size
;
12944 unsigned char * data
;
12945 unsigned char * real_start
;
12946 unsigned char * start
;
12948 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12952 section_size
= section
->sh_size
;
12954 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12956 if (decompress_dumps
)
12958 dwarf_size_type new_size
= section_size
;
12959 dwarf_size_type uncompressed_size
= 0;
12961 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12963 Elf_Internal_Chdr chdr
;
12964 unsigned int compression_header_size
12965 = get_compression_header (& chdr
, start
, section_size
);
12967 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12969 warn (_("section '%s' has unsupported compress type: %d\n"),
12970 printable_section_name (section
), chdr
.ch_type
);
12973 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12975 warn (_("compressed section '%s' is corrupted\n"),
12976 printable_section_name (section
));
12979 uncompressed_size
= chdr
.ch_size
;
12980 start
+= compression_header_size
;
12981 new_size
-= compression_header_size
;
12983 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12985 /* Read the zlib header. In this case, it should be "ZLIB"
12986 followed by the uncompressed section size, 8 bytes in
12987 big-endian order. */
12988 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12989 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12990 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12991 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12992 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12993 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12994 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12995 uncompressed_size
+= start
[11];
13000 if (uncompressed_size
)
13002 if (uncompress_section_contents (& start
, uncompressed_size
,
13005 section_size
= new_size
;
13009 error (_("Unable to decompress section %s\n"),
13010 printable_section_name (section
));
13011 /* FIXME: Print the section anyway ? */
13016 start
= real_start
;
13021 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
13026 /* If the section being dumped has relocations against it the user might
13027 be expecting these relocations to have been applied. Check for this
13028 case and issue a warning message in order to avoid confusion.
13029 FIXME: Maybe we ought to have an option that dumps a section with
13030 relocs applied ? */
13031 for (relsec
= section_headers
;
13032 relsec
< section_headers
+ elf_header
.e_shnum
;
13035 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13036 || relsec
->sh_info
>= elf_header
.e_shnum
13037 || section_headers
+ relsec
->sh_info
!= section
13038 || relsec
->sh_size
== 0
13039 || relsec
->sh_link
>= elf_header
.e_shnum
)
13042 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13047 addr
= section
->sh_addr
;
13048 bytes
= section_size
;
13057 lbytes
= (bytes
> 16 ? 16 : bytes
);
13059 printf (" 0x%8.8lx ", (unsigned long) addr
);
13061 for (j
= 0; j
< 16; j
++)
13064 printf ("%2.2x", data
[j
]);
13072 for (j
= 0; j
< lbytes
; j
++)
13075 if (k
>= ' ' && k
< 0x7f)
13095 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13096 const Elf_Internal_Shdr
* sec
, void * file
)
13098 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13101 /* If it is already loaded, do nothing. */
13102 if (section
->start
!= NULL
)
13105 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13106 section
->address
= sec
->sh_addr
;
13107 section
->user_data
= NULL
;
13108 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13110 sec
->sh_size
, buf
);
13111 if (section
->start
== NULL
)
13115 unsigned char *start
= section
->start
;
13116 dwarf_size_type size
= sec
->sh_size
;
13117 dwarf_size_type uncompressed_size
= 0;
13119 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13121 Elf_Internal_Chdr chdr
;
13122 unsigned int compression_header_size
;
13124 if (size
< (is_32bit_elf
13125 ? sizeof (Elf32_External_Chdr
)
13126 : sizeof (Elf64_External_Chdr
)))
13128 warn (_("compressed section %s is too small to contain a compression header"),
13133 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13135 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13137 warn (_("section '%s' has unsupported compress type: %d\n"),
13138 section
->name
, chdr
.ch_type
);
13141 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13143 warn (_("compressed section '%s' is corrupted\n"),
13147 uncompressed_size
= chdr
.ch_size
;
13148 start
+= compression_header_size
;
13149 size
-= compression_header_size
;
13151 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13153 /* Read the zlib header. In this case, it should be "ZLIB"
13154 followed by the uncompressed section size, 8 bytes in
13155 big-endian order. */
13156 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13157 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13158 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13159 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13160 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13161 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13162 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13163 uncompressed_size
+= start
[11];
13168 if (uncompressed_size
)
13170 if (uncompress_section_contents (&start
, uncompressed_size
,
13173 /* Free the compressed buffer, update the section buffer
13174 and the section size if uncompress is successful. */
13175 free (section
->start
);
13176 section
->start
= start
;
13180 error (_("Unable to decompress section %s\n"),
13181 printable_section_name (sec
));
13186 section
->size
= size
;
13189 if (section
->start
== NULL
)
13192 if (debug_displays
[debug
].relocate
)
13194 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13195 & section
->reloc_info
, & section
->num_relocs
))
13200 section
->reloc_info
= NULL
;
13201 section
->num_relocs
= 0;
13207 /* If this is not NULL, load_debug_section will only look for sections
13208 within the list of sections given here. */
13209 static unsigned int * section_subset
= NULL
;
13212 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13214 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13215 Elf_Internal_Shdr
* sec
;
13217 /* Locate the debug section. */
13218 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13220 section
->name
= section
->uncompressed_name
;
13223 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13225 section
->name
= section
->compressed_name
;
13230 /* If we're loading from a subset of sections, and we've loaded
13231 a section matching this name before, it's likely that it's a
13233 if (section_subset
!= NULL
)
13234 free_debug_section (debug
);
13236 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13240 free_debug_section (enum dwarf_section_display_enum debug
)
13242 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13244 if (section
->start
== NULL
)
13247 free ((char *) section
->start
);
13248 section
->start
= NULL
;
13249 section
->address
= 0;
13254 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13256 char * name
= SECTION_NAME (section
);
13257 const char * print_name
= printable_section_name (section
);
13258 bfd_size_type length
;
13259 bfd_boolean result
= TRUE
;
13262 length
= section
->sh_size
;
13265 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13268 if (section
->sh_type
== SHT_NOBITS
)
13270 /* There is no point in dumping the contents of a debugging section
13271 which has the NOBITS type - the bits in the file will be random.
13272 This can happen when a file containing a .eh_frame section is
13273 stripped with the --only-keep-debug command line option. */
13274 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13279 if (const_strneq (name
, ".gnu.linkonce.wi."))
13280 name
= ".debug_info";
13282 /* See if we know how to display the contents of this section. */
13283 for (i
= 0; i
< max
; i
++)
13284 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13285 || (i
== line
&& const_strneq (name
, ".debug_line."))
13286 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13288 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13289 int secondary
= (section
!= find_section (name
));
13292 free_debug_section ((enum dwarf_section_display_enum
) i
);
13294 if (i
== line
&& const_strneq (name
, ".debug_line."))
13296 else if (streq (sec
->uncompressed_name
, name
))
13297 sec
->name
= sec
->uncompressed_name
;
13299 sec
->name
= sec
->compressed_name
;
13300 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13303 /* If this debug section is part of a CU/TU set in a .dwp file,
13304 restrict load_debug_section to the sections in that set. */
13305 section_subset
= find_cu_tu_set (file
, shndx
);
13307 result
&= debug_displays
[i
].display (sec
, file
);
13309 section_subset
= NULL
;
13311 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13312 free_debug_section ((enum dwarf_section_display_enum
) i
);
13320 printf (_("Unrecognized debug section: %s\n"), print_name
);
13327 /* Set DUMP_SECTS for all sections where dumps were requested
13328 based on section name. */
13331 initialise_dumps_byname (void)
13333 struct dump_list_entry
* cur
;
13335 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13338 bfd_boolean any
= FALSE
;
13340 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13341 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13343 request_dump_bynumber (i
, cur
->type
);
13348 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13354 process_section_contents (FILE * file
)
13356 Elf_Internal_Shdr
* section
;
13358 bfd_boolean res
= TRUE
;
13363 initialise_dumps_byname ();
13365 for (i
= 0, section
= section_headers
;
13366 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13369 #ifdef SUPPORT_DISASSEMBLY
13370 if (dump_sects
[i
] & DISASS_DUMP
)
13371 disassemble_section (section
, file
);
13373 if (dump_sects
[i
] & HEX_DUMP
)
13375 if (! dump_section_as_bytes (section
, file
, FALSE
))
13379 if (dump_sects
[i
] & RELOC_DUMP
)
13381 if (! dump_section_as_bytes (section
, file
, TRUE
))
13385 if (dump_sects
[i
] & STRING_DUMP
)
13387 if (! dump_section_as_strings (section
, file
))
13391 if (dump_sects
[i
] & DEBUG_DUMP
)
13393 if (! display_debug_section (i
, section
, file
))
13398 /* Check to see if the user requested a
13399 dump of a section that does not exist. */
13400 while (i
< num_dump_sects
)
13404 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13414 process_mips_fpe_exception (int mask
)
13418 bfd_boolean first
= TRUE
;
13420 if (mask
& OEX_FPU_INEX
)
13421 fputs ("INEX", stdout
), first
= FALSE
;
13422 if (mask
& OEX_FPU_UFLO
)
13423 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13424 if (mask
& OEX_FPU_OFLO
)
13425 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13426 if (mask
& OEX_FPU_DIV0
)
13427 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13428 if (mask
& OEX_FPU_INVAL
)
13429 printf ("%sINVAL", first
? "" : "|");
13432 fputs ("0", stdout
);
13435 /* Display's the value of TAG at location P. If TAG is
13436 greater than 0 it is assumed to be an unknown tag, and
13437 a message is printed to this effect. Otherwise it is
13438 assumed that a message has already been printed.
13440 If the bottom bit of TAG is set it assumed to have a
13441 string value, otherwise it is assumed to have an integer
13444 Returns an updated P pointing to the first unread byte
13445 beyond the end of TAG's value.
13447 Reads at or beyond END will not be made. */
13449 static unsigned char *
13450 display_tag_value (signed int tag
,
13452 const unsigned char * const end
)
13457 printf (" Tag_unknown_%d: ", tag
);
13461 warn (_("<corrupt tag>\n"));
13465 /* PR 17531 file: 027-19978-0.004. */
13466 size_t maxlen
= (end
- p
) - 1;
13471 print_symbol ((int) maxlen
, (const char *) p
);
13472 p
+= strnlen ((char *) p
, maxlen
) + 1;
13476 printf (_("<corrupt string tag>"));
13477 p
= (unsigned char *) end
;
13485 val
= read_uleb128 (p
, &len
, end
);
13487 printf ("%ld (0x%lx)\n", val
, val
);
13494 /* ARM EABI attributes section. */
13499 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13501 const char ** table
;
13502 } arm_attr_public_tag
;
13504 static const char * arm_attr_tag_CPU_arch
[] =
13505 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13506 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13508 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13509 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13510 {"No", "Thumb-1", "Thumb-2", "Yes"};
13511 static const char * arm_attr_tag_FP_arch
[] =
13512 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13513 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13514 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13515 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13516 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13517 "NEON for ARMv8.1"};
13518 static const char * arm_attr_tag_PCS_config
[] =
13519 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13520 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13521 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13522 {"V6", "SB", "TLS", "Unused"};
13523 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13524 {"Absolute", "PC-relative", "SB-relative", "None"};
13525 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13526 {"Absolute", "PC-relative", "None"};
13527 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13528 {"None", "direct", "GOT-indirect"};
13529 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13530 {"None", "??? 1", "2", "??? 3", "4"};
13531 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13532 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13533 {"Unused", "Needed", "Sign only"};
13534 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13535 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13536 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13537 {"Unused", "Finite", "RTABI", "IEEE 754"};
13538 static const char * arm_attr_tag_ABI_enum_size
[] =
13539 {"Unused", "small", "int", "forced to int"};
13540 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13541 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13542 static const char * arm_attr_tag_ABI_VFP_args
[] =
13543 {"AAPCS", "VFP registers", "custom", "compatible"};
13544 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13545 {"AAPCS", "WMMX registers", "custom"};
13546 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13547 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13548 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13549 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13550 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13551 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13552 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13553 static const char * arm_attr_tag_FP_HP_extension
[] =
13554 {"Not Allowed", "Allowed"};
13555 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13556 {"None", "IEEE 754", "Alternative Format"};
13557 static const char * arm_attr_tag_DSP_extension
[] =
13558 {"Follow architecture", "Allowed"};
13559 static const char * arm_attr_tag_MPextension_use
[] =
13560 {"Not Allowed", "Allowed"};
13561 static const char * arm_attr_tag_DIV_use
[] =
13562 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13563 "Allowed in v7-A with integer division extension"};
13564 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13565 static const char * arm_attr_tag_Virtualization_use
[] =
13566 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13567 "TrustZone and Virtualization Extensions"};
13568 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13569 {"Not Allowed", "Allowed"};
13571 #define LOOKUP(id, name) \
13572 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13573 static arm_attr_public_tag arm_attr_public_tags
[] =
13575 {4, "CPU_raw_name", 1, NULL
},
13576 {5, "CPU_name", 1, NULL
},
13577 LOOKUP(6, CPU_arch
),
13578 {7, "CPU_arch_profile", 0, NULL
},
13579 LOOKUP(8, ARM_ISA_use
),
13580 LOOKUP(9, THUMB_ISA_use
),
13581 LOOKUP(10, FP_arch
),
13582 LOOKUP(11, WMMX_arch
),
13583 LOOKUP(12, Advanced_SIMD_arch
),
13584 LOOKUP(13, PCS_config
),
13585 LOOKUP(14, ABI_PCS_R9_use
),
13586 LOOKUP(15, ABI_PCS_RW_data
),
13587 LOOKUP(16, ABI_PCS_RO_data
),
13588 LOOKUP(17, ABI_PCS_GOT_use
),
13589 LOOKUP(18, ABI_PCS_wchar_t
),
13590 LOOKUP(19, ABI_FP_rounding
),
13591 LOOKUP(20, ABI_FP_denormal
),
13592 LOOKUP(21, ABI_FP_exceptions
),
13593 LOOKUP(22, ABI_FP_user_exceptions
),
13594 LOOKUP(23, ABI_FP_number_model
),
13595 {24, "ABI_align_needed", 0, NULL
},
13596 {25, "ABI_align_preserved", 0, NULL
},
13597 LOOKUP(26, ABI_enum_size
),
13598 LOOKUP(27, ABI_HardFP_use
),
13599 LOOKUP(28, ABI_VFP_args
),
13600 LOOKUP(29, ABI_WMMX_args
),
13601 LOOKUP(30, ABI_optimization_goals
),
13602 LOOKUP(31, ABI_FP_optimization_goals
),
13603 {32, "compatibility", 0, NULL
},
13604 LOOKUP(34, CPU_unaligned_access
),
13605 LOOKUP(36, FP_HP_extension
),
13606 LOOKUP(38, ABI_FP_16bit_format
),
13607 LOOKUP(42, MPextension_use
),
13608 LOOKUP(44, DIV_use
),
13609 LOOKUP(46, DSP_extension
),
13610 {64, "nodefaults", 0, NULL
},
13611 {65, "also_compatible_with", 0, NULL
},
13612 LOOKUP(66, T2EE_use
),
13613 {67, "conformance", 1, NULL
},
13614 LOOKUP(68, Virtualization_use
),
13615 LOOKUP(70, MPextension_use_legacy
)
13619 static unsigned char *
13620 display_arm_attribute (unsigned char * p
,
13621 const unsigned char * const end
)
13626 arm_attr_public_tag
* attr
;
13630 tag
= read_uleb128 (p
, &len
, end
);
13633 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13635 if (arm_attr_public_tags
[i
].tag
== tag
)
13637 attr
= &arm_attr_public_tags
[i
];
13644 printf (" Tag_%s: ", attr
->name
);
13645 switch (attr
->type
)
13650 case 7: /* Tag_CPU_arch_profile. */
13651 val
= read_uleb128 (p
, &len
, end
);
13655 case 0: printf (_("None\n")); break;
13656 case 'A': printf (_("Application\n")); break;
13657 case 'R': printf (_("Realtime\n")); break;
13658 case 'M': printf (_("Microcontroller\n")); break;
13659 case 'S': printf (_("Application or Realtime\n")); break;
13660 default: printf ("??? (%d)\n", val
); break;
13664 case 24: /* Tag_align_needed. */
13665 val
= read_uleb128 (p
, &len
, end
);
13669 case 0: printf (_("None\n")); break;
13670 case 1: printf (_("8-byte\n")); break;
13671 case 2: printf (_("4-byte\n")); break;
13672 case 3: printf ("??? 3\n"); break;
13675 printf (_("8-byte and up to %d-byte extended\n"),
13678 printf ("??? (%d)\n", val
);
13683 case 25: /* Tag_align_preserved. */
13684 val
= read_uleb128 (p
, &len
, end
);
13688 case 0: printf (_("None\n")); break;
13689 case 1: printf (_("8-byte, except leaf SP\n")); break;
13690 case 2: printf (_("8-byte\n")); break;
13691 case 3: printf ("??? 3\n"); break;
13694 printf (_("8-byte and up to %d-byte extended\n"),
13697 printf ("??? (%d)\n", val
);
13702 case 32: /* Tag_compatibility. */
13704 val
= read_uleb128 (p
, &len
, end
);
13706 printf (_("flag = %d, vendor = "), val
);
13709 size_t maxlen
= (end
- p
) - 1;
13711 print_symbol ((int) maxlen
, (const char *) p
);
13712 p
+= strnlen ((char *) p
, maxlen
) + 1;
13716 printf (_("<corrupt>"));
13717 p
= (unsigned char *) end
;
13723 case 64: /* Tag_nodefaults. */
13724 /* PR 17531: file: 001-505008-0.01. */
13727 printf (_("True\n"));
13730 case 65: /* Tag_also_compatible_with. */
13731 val
= read_uleb128 (p
, &len
, end
);
13733 if (val
== 6 /* Tag_CPU_arch. */)
13735 val
= read_uleb128 (p
, &len
, end
);
13737 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13738 printf ("??? (%d)\n", val
);
13740 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13744 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13749 printf (_("<unknown: %d>\n"), tag
);
13755 return display_tag_value (-1, p
, end
);
13757 return display_tag_value (0, p
, end
);
13760 assert (attr
->type
& 0x80);
13761 val
= read_uleb128 (p
, &len
, end
);
13763 type
= attr
->type
& 0x7f;
13765 printf ("??? (%d)\n", val
);
13767 printf ("%s\n", attr
->table
[val
]);
13772 return display_tag_value (tag
, p
, end
);
13775 static unsigned char *
13776 display_gnu_attribute (unsigned char * p
,
13777 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13778 const unsigned char * const end
)
13784 tag
= read_uleb128 (p
, &len
, end
);
13787 /* Tag_compatibility is the only generic GNU attribute defined at
13791 val
= read_uleb128 (p
, &len
, end
);
13794 printf (_("flag = %d, vendor = "), val
);
13797 printf (_("<corrupt>\n"));
13798 warn (_("corrupt vendor attribute\n"));
13804 size_t maxlen
= (end
- p
) - 1;
13806 print_symbol ((int) maxlen
, (const char *) p
);
13807 p
+= strnlen ((char *) p
, maxlen
) + 1;
13811 printf (_("<corrupt>"));
13812 p
= (unsigned char *) end
;
13819 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13820 return display_proc_gnu_attribute (p
, tag
, end
);
13822 return display_tag_value (tag
, p
, end
);
13825 static unsigned char *
13826 display_power_gnu_attribute (unsigned char * p
,
13828 const unsigned char * const end
)
13833 if (tag
== Tag_GNU_Power_ABI_FP
)
13835 val
= read_uleb128 (p
, &len
, end
);
13837 printf (" Tag_GNU_Power_ABI_FP: ");
13840 printf (_("<corrupt>\n"));
13845 printf ("(%#x), ", val
);
13850 printf (_("unspecified hard/soft float, "));
13853 printf (_("hard float, "));
13856 printf (_("soft float, "));
13859 printf (_("single-precision hard float, "));
13866 printf (_("unspecified long double\n"));
13869 printf (_("128-bit IBM long double\n"));
13872 printf (_("64-bit long double\n"));
13875 printf (_("128-bit IEEE long double\n"));
13881 if (tag
== Tag_GNU_Power_ABI_Vector
)
13883 val
= read_uleb128 (p
, &len
, end
);
13885 printf (" Tag_GNU_Power_ABI_Vector: ");
13888 printf (_("<corrupt>\n"));
13893 printf ("(%#x), ", val
);
13898 printf (_("unspecified\n"));
13901 printf (_("generic\n"));
13904 printf ("AltiVec\n");
13913 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13915 val
= read_uleb128 (p
, &len
, end
);
13917 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13920 printf (_("<corrupt>\n"));
13925 printf ("(%#x), ", val
);
13930 printf (_("unspecified\n"));
13933 printf ("r3/r4\n");
13936 printf (_("memory\n"));
13945 return display_tag_value (tag
& 1, p
, end
);
13948 static unsigned char *
13949 display_s390_gnu_attribute (unsigned char * p
,
13951 const unsigned char * const end
)
13956 if (tag
== Tag_GNU_S390_ABI_Vector
)
13958 val
= read_uleb128 (p
, &len
, end
);
13960 printf (" Tag_GNU_S390_ABI_Vector: ");
13965 printf (_("any\n"));
13968 printf (_("software\n"));
13971 printf (_("hardware\n"));
13974 printf ("??? (%d)\n", val
);
13980 return display_tag_value (tag
& 1, p
, end
);
13984 display_sparc_hwcaps (unsigned int mask
)
13988 bfd_boolean first
= TRUE
;
13990 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13991 fputs ("mul32", stdout
), first
= FALSE
;
13992 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13993 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
13994 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13995 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
13996 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13997 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
13998 if (mask
& ELF_SPARC_HWCAP_POPC
)
13999 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14000 if (mask
& ELF_SPARC_HWCAP_VIS
)
14001 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14002 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14003 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14004 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14005 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14006 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14007 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14008 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14009 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14010 if (mask
& ELF_SPARC_HWCAP_HPC
)
14011 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14012 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14013 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14014 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14015 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14016 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14017 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14018 if (mask
& ELF_SPARC_HWCAP_IMA
)
14019 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14020 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14021 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14024 fputc ('0', stdout
);
14025 fputc ('\n', stdout
);
14029 display_sparc_hwcaps2 (unsigned int mask
)
14033 bfd_boolean first
= TRUE
;
14035 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14036 fputs ("fjathplus", stdout
), first
= FALSE
;
14037 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14038 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14039 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14040 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14041 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14042 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14043 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14044 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14045 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14046 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14047 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14048 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14049 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14050 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14051 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14052 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14053 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14054 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14055 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14056 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14059 fputc ('0', stdout
);
14060 fputc ('\n', stdout
);
14063 static unsigned char *
14064 display_sparc_gnu_attribute (unsigned char * p
,
14066 const unsigned char * const end
)
14071 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14073 val
= read_uleb128 (p
, &len
, end
);
14075 printf (" Tag_GNU_Sparc_HWCAPS: ");
14076 display_sparc_hwcaps (val
);
14079 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14081 val
= read_uleb128 (p
, &len
, end
);
14083 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14084 display_sparc_hwcaps2 (val
);
14088 return display_tag_value (tag
, p
, end
);
14092 print_mips_fp_abi_value (unsigned int val
)
14096 case Val_GNU_MIPS_ABI_FP_ANY
:
14097 printf (_("Hard or soft float\n"));
14099 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14100 printf (_("Hard float (double precision)\n"));
14102 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14103 printf (_("Hard float (single precision)\n"));
14105 case Val_GNU_MIPS_ABI_FP_SOFT
:
14106 printf (_("Soft float\n"));
14108 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14109 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14111 case Val_GNU_MIPS_ABI_FP_XX
:
14112 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14114 case Val_GNU_MIPS_ABI_FP_64
:
14115 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14117 case Val_GNU_MIPS_ABI_FP_64A
:
14118 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14120 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14121 printf (_("NaN 2008 compatibility\n"));
14124 printf ("??? (%d)\n", val
);
14129 static unsigned char *
14130 display_mips_gnu_attribute (unsigned char * p
,
14132 const unsigned char * const end
)
14134 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14139 val
= read_uleb128 (p
, &len
, end
);
14141 printf (" Tag_GNU_MIPS_ABI_FP: ");
14143 print_mips_fp_abi_value (val
);
14148 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14153 val
= read_uleb128 (p
, &len
, end
);
14155 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14159 case Val_GNU_MIPS_ABI_MSA_ANY
:
14160 printf (_("Any MSA or not\n"));
14162 case Val_GNU_MIPS_ABI_MSA_128
:
14163 printf (_("128-bit MSA\n"));
14166 printf ("??? (%d)\n", val
);
14172 return display_tag_value (tag
& 1, p
, end
);
14175 static unsigned char *
14176 display_tic6x_attribute (unsigned char * p
,
14177 const unsigned char * const end
)
14183 tag
= read_uleb128 (p
, &len
, end
);
14189 val
= read_uleb128 (p
, &len
, end
);
14191 printf (" Tag_ISA: ");
14195 case C6XABI_Tag_ISA_none
:
14196 printf (_("None\n"));
14198 case C6XABI_Tag_ISA_C62X
:
14201 case C6XABI_Tag_ISA_C67X
:
14204 case C6XABI_Tag_ISA_C67XP
:
14205 printf ("C67x+\n");
14207 case C6XABI_Tag_ISA_C64X
:
14210 case C6XABI_Tag_ISA_C64XP
:
14211 printf ("C64x+\n");
14213 case C6XABI_Tag_ISA_C674X
:
14214 printf ("C674x\n");
14217 printf ("??? (%d)\n", val
);
14222 case Tag_ABI_wchar_t
:
14223 val
= read_uleb128 (p
, &len
, end
);
14225 printf (" Tag_ABI_wchar_t: ");
14229 printf (_("Not used\n"));
14232 printf (_("2 bytes\n"));
14235 printf (_("4 bytes\n"));
14238 printf ("??? (%d)\n", val
);
14243 case Tag_ABI_stack_align_needed
:
14244 val
= read_uleb128 (p
, &len
, end
);
14246 printf (" Tag_ABI_stack_align_needed: ");
14250 printf (_("8-byte\n"));
14253 printf (_("16-byte\n"));
14256 printf ("??? (%d)\n", val
);
14261 case Tag_ABI_stack_align_preserved
:
14262 val
= read_uleb128 (p
, &len
, end
);
14264 printf (" Tag_ABI_stack_align_preserved: ");
14268 printf (_("8-byte\n"));
14271 printf (_("16-byte\n"));
14274 printf ("??? (%d)\n", val
);
14280 val
= read_uleb128 (p
, &len
, end
);
14282 printf (" Tag_ABI_DSBT: ");
14286 printf (_("DSBT addressing not used\n"));
14289 printf (_("DSBT addressing used\n"));
14292 printf ("??? (%d)\n", val
);
14298 val
= read_uleb128 (p
, &len
, end
);
14300 printf (" Tag_ABI_PID: ");
14304 printf (_("Data addressing position-dependent\n"));
14307 printf (_("Data addressing position-independent, GOT near DP\n"));
14310 printf (_("Data addressing position-independent, GOT far from DP\n"));
14313 printf ("??? (%d)\n", val
);
14319 val
= read_uleb128 (p
, &len
, end
);
14321 printf (" Tag_ABI_PIC: ");
14325 printf (_("Code addressing position-dependent\n"));
14328 printf (_("Code addressing position-independent\n"));
14331 printf ("??? (%d)\n", val
);
14336 case Tag_ABI_array_object_alignment
:
14337 val
= read_uleb128 (p
, &len
, end
);
14339 printf (" Tag_ABI_array_object_alignment: ");
14343 printf (_("8-byte\n"));
14346 printf (_("4-byte\n"));
14349 printf (_("16-byte\n"));
14352 printf ("??? (%d)\n", val
);
14357 case Tag_ABI_array_object_align_expected
:
14358 val
= read_uleb128 (p
, &len
, end
);
14360 printf (" Tag_ABI_array_object_align_expected: ");
14364 printf (_("8-byte\n"));
14367 printf (_("4-byte\n"));
14370 printf (_("16-byte\n"));
14373 printf ("??? (%d)\n", val
);
14378 case Tag_ABI_compatibility
:
14380 val
= read_uleb128 (p
, &len
, end
);
14382 printf (" Tag_ABI_compatibility: ");
14383 printf (_("flag = %d, vendor = "), val
);
14386 size_t maxlen
= (end
- p
) - 1;
14388 print_symbol ((int) maxlen
, (const char *) p
);
14389 p
+= strnlen ((char *) p
, maxlen
) + 1;
14393 printf (_("<corrupt>"));
14394 p
= (unsigned char *) end
;
14400 case Tag_ABI_conformance
:
14402 printf (" Tag_ABI_conformance: \"");
14405 size_t maxlen
= (end
- p
) - 1;
14407 print_symbol ((int) maxlen
, (const char *) p
);
14408 p
+= strnlen ((char *) p
, maxlen
) + 1;
14412 printf (_("<corrupt>"));
14413 p
= (unsigned char *) end
;
14420 return display_tag_value (tag
, p
, end
);
14424 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14426 unsigned long addr
= 0;
14427 size_t bytes
= end
- p
;
14434 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14436 printf (" 0x%8.8lx ", addr
);
14438 for (j
= 0; j
< 16; j
++)
14441 printf ("%2.2x", p
[j
]);
14449 for (j
= 0; j
< lbytes
; j
++)
14452 if (k
>= ' ' && k
< 0x7f)
14468 static unsigned char *
14469 display_msp430x_attribute (unsigned char * p
,
14470 const unsigned char * const end
)
14476 tag
= read_uleb128 (p
, & len
, end
);
14481 case OFBA_MSPABI_Tag_ISA
:
14482 val
= read_uleb128 (p
, &len
, end
);
14484 printf (" Tag_ISA: ");
14487 case 0: printf (_("None\n")); break;
14488 case 1: printf (_("MSP430\n")); break;
14489 case 2: printf (_("MSP430X\n")); break;
14490 default: printf ("??? (%d)\n", val
); break;
14494 case OFBA_MSPABI_Tag_Code_Model
:
14495 val
= read_uleb128 (p
, &len
, end
);
14497 printf (" Tag_Code_Model: ");
14500 case 0: printf (_("None\n")); break;
14501 case 1: printf (_("Small\n")); break;
14502 case 2: printf (_("Large\n")); break;
14503 default: printf ("??? (%d)\n", val
); break;
14507 case OFBA_MSPABI_Tag_Data_Model
:
14508 val
= read_uleb128 (p
, &len
, end
);
14510 printf (" Tag_Data_Model: ");
14513 case 0: printf (_("None\n")); break;
14514 case 1: printf (_("Small\n")); break;
14515 case 2: printf (_("Large\n")); break;
14516 case 3: printf (_("Restricted Large\n")); break;
14517 default: printf ("??? (%d)\n", val
); break;
14522 printf (_(" <unknown tag %d>: "), tag
);
14529 size_t maxlen
= (end
- p
) - 1;
14531 print_symbol ((int) maxlen
, (const char *) p
);
14532 p
+= strnlen ((char *) p
, maxlen
) + 1;
14536 printf (_("<corrupt>"));
14537 p
= (unsigned char *) end
;
14543 val
= read_uleb128 (p
, &len
, end
);
14545 printf ("%d (0x%x)\n", val
, val
);
14555 process_attributes (FILE * file
,
14556 const char * public_name
,
14557 unsigned int proc_type
,
14558 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14559 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14561 Elf_Internal_Shdr
* sect
;
14563 bfd_boolean res
= TRUE
;
14565 /* Find the section header so that we get the size. */
14566 for (i
= 0, sect
= section_headers
;
14567 i
< elf_header
.e_shnum
;
14570 unsigned char * contents
;
14573 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14576 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14577 sect
->sh_size
, _("attributes"));
14578 if (contents
== NULL
)
14585 /* The first character is the version of the attributes.
14586 Currently only version 1, (aka 'A') is recognised here. */
14589 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14594 bfd_vma section_len
;
14596 section_len
= sect
->sh_size
- 1;
14599 while (section_len
> 0)
14602 unsigned int namelen
;
14603 bfd_boolean public_section
;
14604 bfd_boolean gnu_section
;
14606 if (section_len
<= 4)
14608 error (_("Tag section ends prematurely\n"));
14612 attr_len
= byte_get (p
, 4);
14615 if (attr_len
> section_len
)
14617 error (_("Bad attribute length (%u > %u)\n"),
14618 (unsigned) attr_len
, (unsigned) section_len
);
14619 attr_len
= section_len
;
14622 /* PR 17531: file: 001-101425-0.004 */
14623 else if (attr_len
< 5)
14625 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14630 section_len
-= attr_len
;
14633 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14634 if (namelen
== 0 || namelen
>= attr_len
)
14636 error (_("Corrupt attribute section name\n"));
14641 printf (_("Attribute Section: "));
14642 print_symbol (INT_MAX
, (const char *) p
);
14645 if (public_name
&& streq ((char *) p
, public_name
))
14646 public_section
= TRUE
;
14648 public_section
= FALSE
;
14650 if (streq ((char *) p
, "gnu"))
14651 gnu_section
= TRUE
;
14653 gnu_section
= FALSE
;
14656 attr_len
-= namelen
;
14658 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14663 unsigned char * end
;
14665 /* PR binutils/17531: Safe handling of corrupt files. */
14668 error (_("Unused bytes at end of section\n"));
14675 size
= byte_get (p
, 4);
14676 if (size
> attr_len
)
14678 error (_("Bad subsection length (%u > %u)\n"),
14679 (unsigned) size
, (unsigned) attr_len
);
14683 /* PR binutils/17531: Safe handling of corrupt files. */
14686 error (_("Bad subsection length (%u < 6)\n"),
14694 end
= p
+ size
- 1;
14695 assert (end
<= contents
+ sect
->sh_size
);
14701 printf (_("File Attributes\n"));
14704 printf (_("Section Attributes:"));
14707 printf (_("Symbol Attributes:"));
14708 /* Fall through. */
14714 val
= read_uleb128 (p
, &j
, end
);
14718 printf (" %d", val
);
14723 printf (_("Unknown tag: %d\n"), tag
);
14724 public_section
= FALSE
;
14728 if (public_section
&& display_pub_attribute
!= NULL
)
14731 p
= display_pub_attribute (p
, end
);
14734 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14737 p
= display_gnu_attribute (p
,
14738 display_proc_gnu_attribute
,
14744 printf (_(" Unknown attribute:\n"));
14745 display_raw_attribute (p
, end
);
14760 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14761 Print the Address, Access and Initial fields of an entry at VMA ADDR
14762 and return the VMA of the next entry, or -1 if there was a problem.
14763 Does not read from DATA_END or beyond. */
14766 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14767 unsigned char * data_end
)
14770 print_vma (addr
, LONG_HEX
);
14772 if (addr
< pltgot
+ 0xfff0)
14773 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14775 printf ("%10s", "");
14778 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14782 unsigned char * from
= data
+ addr
- pltgot
;
14784 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14786 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14787 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14788 return (bfd_vma
) -1;
14792 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14793 print_vma (entry
, LONG_HEX
);
14796 return addr
+ (is_32bit_elf
? 4 : 8);
14799 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14800 PLTGOT. Print the Address and Initial fields of an entry at VMA
14801 ADDR and return the VMA of the next entry. */
14804 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14807 print_vma (addr
, LONG_HEX
);
14810 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14815 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14816 print_vma (entry
, LONG_HEX
);
14818 return addr
+ (is_32bit_elf
? 4 : 8);
14822 print_mips_ases (unsigned int mask
)
14824 if (mask
& AFL_ASE_DSP
)
14825 fputs ("\n\tDSP ASE", stdout
);
14826 if (mask
& AFL_ASE_DSPR2
)
14827 fputs ("\n\tDSP R2 ASE", stdout
);
14828 if (mask
& AFL_ASE_DSPR3
)
14829 fputs ("\n\tDSP R3 ASE", stdout
);
14830 if (mask
& AFL_ASE_EVA
)
14831 fputs ("\n\tEnhanced VA Scheme", stdout
);
14832 if (mask
& AFL_ASE_MCU
)
14833 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14834 if (mask
& AFL_ASE_MDMX
)
14835 fputs ("\n\tMDMX ASE", stdout
);
14836 if (mask
& AFL_ASE_MIPS3D
)
14837 fputs ("\n\tMIPS-3D ASE", stdout
);
14838 if (mask
& AFL_ASE_MT
)
14839 fputs ("\n\tMT ASE", stdout
);
14840 if (mask
& AFL_ASE_SMARTMIPS
)
14841 fputs ("\n\tSmartMIPS ASE", stdout
);
14842 if (mask
& AFL_ASE_VIRT
)
14843 fputs ("\n\tVZ ASE", stdout
);
14844 if (mask
& AFL_ASE_MSA
)
14845 fputs ("\n\tMSA ASE", stdout
);
14846 if (mask
& AFL_ASE_MIPS16
)
14847 fputs ("\n\tMIPS16 ASE", stdout
);
14848 if (mask
& AFL_ASE_MICROMIPS
)
14849 fputs ("\n\tMICROMIPS ASE", stdout
);
14850 if (mask
& AFL_ASE_XPA
)
14851 fputs ("\n\tXPA ASE", stdout
);
14853 fprintf (stdout
, "\n\t%s", _("None"));
14854 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14855 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14859 print_mips_isa_ext (unsigned int isa_ext
)
14864 fputs (_("None"), stdout
);
14867 fputs ("RMI XLR", stdout
);
14869 case AFL_EXT_OCTEON3
:
14870 fputs ("Cavium Networks Octeon3", stdout
);
14872 case AFL_EXT_OCTEON2
:
14873 fputs ("Cavium Networks Octeon2", stdout
);
14875 case AFL_EXT_OCTEONP
:
14876 fputs ("Cavium Networks OcteonP", stdout
);
14878 case AFL_EXT_LOONGSON_3A
:
14879 fputs ("Loongson 3A", stdout
);
14881 case AFL_EXT_OCTEON
:
14882 fputs ("Cavium Networks Octeon", stdout
);
14885 fputs ("Toshiba R5900", stdout
);
14888 fputs ("MIPS R4650", stdout
);
14891 fputs ("LSI R4010", stdout
);
14894 fputs ("NEC VR4100", stdout
);
14897 fputs ("Toshiba R3900", stdout
);
14899 case AFL_EXT_10000
:
14900 fputs ("MIPS R10000", stdout
);
14903 fputs ("Broadcom SB-1", stdout
);
14906 fputs ("NEC VR4111/VR4181", stdout
);
14909 fputs ("NEC VR4120", stdout
);
14912 fputs ("NEC VR5400", stdout
);
14915 fputs ("NEC VR5500", stdout
);
14917 case AFL_EXT_LOONGSON_2E
:
14918 fputs ("ST Microelectronics Loongson 2E", stdout
);
14920 case AFL_EXT_LOONGSON_2F
:
14921 fputs ("ST Microelectronics Loongson 2F", stdout
);
14924 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14929 get_mips_reg_size (int reg_size
)
14931 return (reg_size
== AFL_REG_NONE
) ? 0
14932 : (reg_size
== AFL_REG_32
) ? 32
14933 : (reg_size
== AFL_REG_64
) ? 64
14934 : (reg_size
== AFL_REG_128
) ? 128
14939 process_mips_specific (FILE * file
)
14941 Elf_Internal_Dyn
* entry
;
14942 Elf_Internal_Shdr
*sect
= NULL
;
14943 size_t liblist_offset
= 0;
14944 size_t liblistno
= 0;
14945 size_t conflictsno
= 0;
14946 size_t options_offset
= 0;
14947 size_t conflicts_offset
= 0;
14948 size_t pltrelsz
= 0;
14950 bfd_vma pltgot
= 0;
14951 bfd_vma mips_pltgot
= 0;
14952 bfd_vma jmprel
= 0;
14953 bfd_vma local_gotno
= 0;
14954 bfd_vma gotsym
= 0;
14955 bfd_vma symtabno
= 0;
14956 bfd_boolean res
= TRUE
;
14958 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14959 display_mips_gnu_attribute
))
14962 sect
= find_section (".MIPS.abiflags");
14966 Elf_External_ABIFlags_v0
*abiflags_ext
;
14967 Elf_Internal_ABIFlags_v0 abiflags_in
;
14969 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14971 error (_("Corrupt MIPS ABI Flags section.\n"));
14976 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14977 sect
->sh_size
, _("MIPS ABI Flags section"));
14980 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14981 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14982 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14983 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14984 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14985 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14986 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14987 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14988 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14989 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14990 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14992 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14993 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14994 if (abiflags_in
.isa_rev
> 1)
14995 printf ("r%d", abiflags_in
.isa_rev
);
14996 printf ("\nGPR size: %d",
14997 get_mips_reg_size (abiflags_in
.gpr_size
));
14998 printf ("\nCPR1 size: %d",
14999 get_mips_reg_size (abiflags_in
.cpr1_size
));
15000 printf ("\nCPR2 size: %d",
15001 get_mips_reg_size (abiflags_in
.cpr2_size
));
15002 fputs ("\nFP ABI: ", stdout
);
15003 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15004 fputs ("ISA Extension: ", stdout
);
15005 print_mips_isa_ext (abiflags_in
.isa_ext
);
15006 fputs ("\nASEs:", stdout
);
15007 print_mips_ases (abiflags_in
.ases
);
15008 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15009 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15010 fputc ('\n', stdout
);
15011 free (abiflags_ext
);
15016 /* We have a lot of special sections. Thanks SGI! */
15017 if (dynamic_section
== NULL
)
15019 /* No dynamic information available. See if there is static GOT. */
15020 sect
= find_section (".got");
15023 unsigned char *data_end
;
15024 unsigned char *data
;
15028 pltgot
= sect
->sh_addr
;
15031 addr_size
= (is_32bit_elf
? 4 : 8);
15032 end
= pltgot
+ sect
->sh_size
;
15034 data
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
,
15036 _("Global Offset Table data"));
15037 /* PR 12855: Null data is handled gracefully throughout. */
15038 data_end
= data
+ (end
- pltgot
);
15040 printf (_("\nStatic GOT:\n"));
15041 printf (_(" Canonical gp value: "));
15042 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15045 /* In a dynamic binary GOT[0] is reserved for the dynamic
15046 loader to store the lazy resolver pointer, however in
15047 a static binary it may well have been omitted and GOT
15048 reduced to a table of addresses.
15049 PR 21344: Check for the entry being fully available
15050 before fetching it. */
15052 && data
+ ent
- pltgot
+ addr_size
<= data_end
15053 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15055 printf (_(" Reserved entries:\n"));
15056 printf (_(" %*s %10s %*s\n"),
15057 addr_size
* 2, _("Address"), _("Access"),
15058 addr_size
* 2, _("Value"));
15059 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15061 if (ent
== (bfd_vma
) -1)
15062 goto sgot_print_fail
;
15064 /* Check for the MSB of GOT[1] being set, identifying a
15065 GNU object. This entry will be used by some runtime
15066 loaders, to store the module pointer. Otherwise this
15067 is an ordinary local entry.
15068 PR 21344: Check for the entry being fully available
15069 before fetching it. */
15071 && data
+ ent
- pltgot
+ addr_size
<= data_end
15072 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15073 >> (addr_size
* 8 - 1)) != 0)
15075 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15077 if (ent
== (bfd_vma
) -1)
15078 goto sgot_print_fail
;
15085 printf (_(" Local entries:\n"));
15086 printf (" %*s %10s %*s\n",
15087 addr_size
* 2, _("Address"), _("Access"),
15088 addr_size
* 2, _("Value"));
15091 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15093 if (ent
== (bfd_vma
) -1)
15094 goto sgot_print_fail
;
15106 for (entry
= dynamic_section
;
15107 /* PR 17531 file: 012-50589-0.004. */
15108 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15110 switch (entry
->d_tag
)
15112 case DT_MIPS_LIBLIST
:
15114 = offset_from_vma (file
, entry
->d_un
.d_val
,
15115 liblistno
* sizeof (Elf32_External_Lib
));
15117 case DT_MIPS_LIBLISTNO
:
15118 liblistno
= entry
->d_un
.d_val
;
15120 case DT_MIPS_OPTIONS
:
15121 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15123 case DT_MIPS_CONFLICT
:
15125 = offset_from_vma (file
, entry
->d_un
.d_val
,
15126 conflictsno
* sizeof (Elf32_External_Conflict
));
15128 case DT_MIPS_CONFLICTNO
:
15129 conflictsno
= entry
->d_un
.d_val
;
15132 pltgot
= entry
->d_un
.d_ptr
;
15134 case DT_MIPS_LOCAL_GOTNO
:
15135 local_gotno
= entry
->d_un
.d_val
;
15137 case DT_MIPS_GOTSYM
:
15138 gotsym
= entry
->d_un
.d_val
;
15140 case DT_MIPS_SYMTABNO
:
15141 symtabno
= entry
->d_un
.d_val
;
15143 case DT_MIPS_PLTGOT
:
15144 mips_pltgot
= entry
->d_un
.d_ptr
;
15147 pltrel
= entry
->d_un
.d_val
;
15150 pltrelsz
= entry
->d_un
.d_val
;
15153 jmprel
= entry
->d_un
.d_ptr
;
15159 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15161 Elf32_External_Lib
* elib
;
15164 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15166 sizeof (Elf32_External_Lib
),
15167 _("liblist section data"));
15170 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15171 (unsigned long) liblistno
);
15172 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15175 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15182 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15183 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15184 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15185 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15186 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15188 tmp
= gmtime (&atime
);
15189 snprintf (timebuf
, sizeof (timebuf
),
15190 "%04u-%02u-%02uT%02u:%02u:%02u",
15191 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15192 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15194 printf ("%3lu: ", (unsigned long) cnt
);
15195 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15196 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15198 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15199 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15200 liblist
.l_version
);
15202 if (liblist
.l_flags
== 0)
15206 static const struct
15213 { " EXACT_MATCH", LL_EXACT_MATCH
},
15214 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15215 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15216 { " EXPORTS", LL_EXPORTS
},
15217 { " DELAY_LOAD", LL_DELAY_LOAD
},
15218 { " DELTA", LL_DELTA
}
15220 int flags
= liblist
.l_flags
;
15223 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15224 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15226 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15227 flags
^= l_flags_vals
[fcnt
].bit
;
15230 printf (" %#x", (unsigned int) flags
);
15242 if (options_offset
!= 0)
15244 Elf_External_Options
* eopt
;
15245 Elf_Internal_Options
* iopt
;
15246 Elf_Internal_Options
* option
;
15249 sect
= section_headers
;
15251 /* Find the section header so that we get the size. */
15252 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15253 /* PR 17533 file: 012-277276-0.004. */
15256 error (_("No MIPS_OPTIONS header found\n"));
15260 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15261 sect
->sh_size
, _("options"));
15264 iopt
= (Elf_Internal_Options
*)
15265 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15268 error (_("Out of memory allocating space for MIPS options\n"));
15275 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15277 Elf_External_Options
* eoption
;
15279 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15281 option
->kind
= BYTE_GET (eoption
->kind
);
15282 option
->size
= BYTE_GET (eoption
->size
);
15283 option
->section
= BYTE_GET (eoption
->section
);
15284 option
->info
= BYTE_GET (eoption
->info
);
15286 /* PR 17531: file: ffa0fa3b. */
15287 if (option
->size
< sizeof (* eopt
)
15288 || offset
+ option
->size
> sect
->sh_size
)
15290 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15293 offset
+= option
->size
;
15299 printf (_("\nSection '%s' contains %d entries:\n"),
15300 printable_section_name (sect
), cnt
);
15309 switch (option
->kind
)
15312 /* This shouldn't happen. */
15313 printf (" NULL %d %lx", option
->section
, option
->info
);
15316 printf (" REGINFO ");
15317 if (elf_header
.e_machine
== EM_MIPS
)
15320 Elf32_External_RegInfo
* ereg
;
15321 Elf32_RegInfo reginfo
;
15323 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15324 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15325 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15326 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15327 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15328 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15329 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15331 printf ("GPR %08lx GP 0x%lx\n",
15332 reginfo
.ri_gprmask
,
15333 (unsigned long) reginfo
.ri_gp_value
);
15334 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15335 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15336 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15341 Elf64_External_RegInfo
* ereg
;
15342 Elf64_Internal_RegInfo reginfo
;
15344 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15345 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15346 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15347 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15348 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15349 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15350 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15352 printf ("GPR %08lx GP 0x",
15353 reginfo
.ri_gprmask
);
15354 printf_vma (reginfo
.ri_gp_value
);
15357 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15358 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15359 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15363 case ODK_EXCEPTIONS
:
15364 fputs (" EXCEPTIONS fpe_min(", stdout
);
15365 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15366 fputs (") fpe_max(", stdout
);
15367 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15368 fputs (")", stdout
);
15370 if (option
->info
& OEX_PAGE0
)
15371 fputs (" PAGE0", stdout
);
15372 if (option
->info
& OEX_SMM
)
15373 fputs (" SMM", stdout
);
15374 if (option
->info
& OEX_FPDBUG
)
15375 fputs (" FPDBUG", stdout
);
15376 if (option
->info
& OEX_DISMISS
)
15377 fputs (" DISMISS", stdout
);
15380 fputs (" PAD ", stdout
);
15381 if (option
->info
& OPAD_PREFIX
)
15382 fputs (" PREFIX", stdout
);
15383 if (option
->info
& OPAD_POSTFIX
)
15384 fputs (" POSTFIX", stdout
);
15385 if (option
->info
& OPAD_SYMBOL
)
15386 fputs (" SYMBOL", stdout
);
15389 fputs (" HWPATCH ", stdout
);
15390 if (option
->info
& OHW_R4KEOP
)
15391 fputs (" R4KEOP", stdout
);
15392 if (option
->info
& OHW_R8KPFETCH
)
15393 fputs (" R8KPFETCH", stdout
);
15394 if (option
->info
& OHW_R5KEOP
)
15395 fputs (" R5KEOP", stdout
);
15396 if (option
->info
& OHW_R5KCVTL
)
15397 fputs (" R5KCVTL", stdout
);
15400 fputs (" FILL ", stdout
);
15401 /* XXX Print content of info word? */
15404 fputs (" TAGS ", stdout
);
15405 /* XXX Print content of info word? */
15408 fputs (" HWAND ", stdout
);
15409 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15410 fputs (" R4KEOP_CHECKED", stdout
);
15411 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15412 fputs (" R4KEOP_CLEAN", stdout
);
15415 fputs (" HWOR ", stdout
);
15416 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15417 fputs (" R4KEOP_CHECKED", stdout
);
15418 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15419 fputs (" R4KEOP_CLEAN", stdout
);
15422 printf (" GP_GROUP %#06lx self-contained %#06lx",
15423 option
->info
& OGP_GROUP
,
15424 (option
->info
& OGP_SELF
) >> 16);
15427 printf (" IDENT %#06lx self-contained %#06lx",
15428 option
->info
& OGP_GROUP
,
15429 (option
->info
& OGP_SELF
) >> 16);
15432 /* This shouldn't happen. */
15433 printf (" %3d ??? %d %lx",
15434 option
->kind
, option
->section
, option
->info
);
15438 len
= sizeof (* eopt
);
15439 while (len
< option
->size
)
15441 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15443 if (ISPRINT (datum
))
15444 printf ("%c", datum
);
15446 printf ("\\%03o", datum
);
15449 fputs ("\n", stdout
);
15451 offset
+= option
->size
;
15461 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15463 Elf32_Conflict
* iconf
;
15466 if (dynamic_symbols
== NULL
)
15468 error (_("conflict list found without a dynamic symbol table\n"));
15472 /* PR 21345 - print a slightly more helpful error message
15473 if we are sure that the cmalloc will fail. */
15474 if (conflictsno
* sizeof (* iconf
) > current_file_size
)
15476 error (_("Overlarge number of conflicts detected: %lx\n"),
15477 (long) conflictsno
);
15481 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15484 error (_("Out of memory allocating space for dynamic conflicts\n"));
15490 Elf32_External_Conflict
* econf32
;
15492 econf32
= (Elf32_External_Conflict
*)
15493 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15494 sizeof (* econf32
), _("conflict"));
15498 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15499 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15505 Elf64_External_Conflict
* econf64
;
15507 econf64
= (Elf64_External_Conflict
*)
15508 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15509 sizeof (* econf64
), _("conflict"));
15513 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15514 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15519 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15520 (unsigned long) conflictsno
);
15521 puts (_(" Num: Index Value Name"));
15523 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15525 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15527 if (iconf
[cnt
] >= num_dynamic_syms
)
15528 printf (_("<corrupt symbol index>"));
15531 Elf_Internal_Sym
* psym
;
15533 psym
= & dynamic_symbols
[iconf
[cnt
]];
15534 print_vma (psym
->st_value
, FULL_HEX
);
15536 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15537 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15539 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15547 if (pltgot
!= 0 && local_gotno
!= 0)
15549 bfd_vma ent
, local_end
, global_end
;
15551 unsigned char * data
;
15552 unsigned char * data_end
;
15556 addr_size
= (is_32bit_elf
? 4 : 8);
15557 local_end
= pltgot
+ local_gotno
* addr_size
;
15559 /* PR binutils/17533 file: 012-111227-0.004 */
15560 if (symtabno
< gotsym
)
15562 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15563 (unsigned long) gotsym
, (unsigned long) symtabno
);
15567 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15568 /* PR 17531: file: 54c91a34. */
15569 if (global_end
< local_end
)
15571 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15575 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15576 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15577 global_end
- pltgot
, 1,
15578 _("Global Offset Table data"));
15579 /* PR 12855: Null data is handled gracefully throughout. */
15580 data_end
= data
+ (global_end
- pltgot
);
15582 printf (_("\nPrimary GOT:\n"));
15583 printf (_(" Canonical gp value: "));
15584 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15587 printf (_(" Reserved entries:\n"));
15588 printf (_(" %*s %10s %*s Purpose\n"),
15589 addr_size
* 2, _("Address"), _("Access"),
15590 addr_size
* 2, _("Initial"));
15591 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15592 printf (_(" Lazy resolver\n"));
15593 if (ent
== (bfd_vma
) -1)
15594 goto got_print_fail
;
15596 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15597 This entry will be used by some runtime loaders, to store the
15598 module pointer. Otherwise this is an ordinary local entry.
15599 PR 21344: Check for the entry being fully available before
15602 && data
+ ent
- pltgot
+ addr_size
<= data_end
15603 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15604 >> (addr_size
* 8 - 1)) != 0)
15606 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15607 printf (_(" Module pointer (GNU extension)\n"));
15608 if (ent
== (bfd_vma
) -1)
15609 goto got_print_fail
;
15613 if (ent
< local_end
)
15615 printf (_(" Local entries:\n"));
15616 printf (" %*s %10s %*s\n",
15617 addr_size
* 2, _("Address"), _("Access"),
15618 addr_size
* 2, _("Initial"));
15619 while (ent
< local_end
)
15621 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15623 if (ent
== (bfd_vma
) -1)
15624 goto got_print_fail
;
15629 if (gotsym
< symtabno
)
15633 printf (_(" Global entries:\n"));
15634 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15635 addr_size
* 2, _("Address"),
15637 addr_size
* 2, _("Initial"),
15638 addr_size
* 2, _("Sym.Val."),
15640 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15641 _("Ndx"), _("Name"));
15643 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15645 for (i
= gotsym
; i
< symtabno
; i
++)
15647 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15650 if (dynamic_symbols
== NULL
)
15651 printf (_("<no dynamic symbols>"));
15652 else if (i
< num_dynamic_syms
)
15654 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15656 print_vma (psym
->st_value
, LONG_HEX
);
15657 printf (" %-7s %3s ",
15658 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15659 get_symbol_index_type (psym
->st_shndx
));
15661 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15662 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15664 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15667 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15668 (unsigned long) i
);
15671 if (ent
== (bfd_vma
) -1)
15682 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15685 size_t offset
, rel_offset
;
15686 unsigned long count
, i
;
15687 unsigned char * data
;
15688 int addr_size
, sym_width
;
15689 Elf_Internal_Rela
* rels
;
15691 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15692 if (pltrel
== DT_RELA
)
15694 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15699 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15704 addr_size
= (is_32bit_elf
? 4 : 8);
15705 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15707 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15708 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15709 1, _("Procedure Linkage Table data"));
15713 printf ("\nPLT GOT:\n\n");
15714 printf (_(" Reserved entries:\n"));
15715 printf (_(" %*s %*s Purpose\n"),
15716 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15717 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15718 printf (_(" PLT lazy resolver\n"));
15719 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15720 printf (_(" Module pointer\n"));
15723 printf (_(" Entries:\n"));
15724 printf (" %*s %*s %*s %-7s %3s %s\n",
15725 addr_size
* 2, _("Address"),
15726 addr_size
* 2, _("Initial"),
15727 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15728 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15729 for (i
= 0; i
< count
; i
++)
15731 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15733 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15736 if (idx
>= num_dynamic_syms
)
15737 printf (_("<corrupt symbol index: %lu>"), idx
);
15740 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15742 print_vma (psym
->st_value
, LONG_HEX
);
15743 printf (" %-7s %3s ",
15744 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15745 get_symbol_index_type (psym
->st_shndx
));
15746 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15747 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15749 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15764 process_nds32_specific (FILE * file
)
15766 Elf_Internal_Shdr
*sect
= NULL
;
15768 sect
= find_section (".nds32_e_flags");
15771 unsigned int *flag
;
15773 printf ("\nNDS32 elf flags section:\n");
15774 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15775 sect
->sh_size
, _("NDS32 elf flags section"));
15780 switch ((*flag
) & 0x3)
15783 printf ("(VEC_SIZE):\tNo entry.\n");
15786 printf ("(VEC_SIZE):\t4 bytes\n");
15789 printf ("(VEC_SIZE):\t16 bytes\n");
15792 printf ("(VEC_SIZE):\treserved\n");
15801 process_gnu_liblist (FILE * file
)
15803 Elf_Internal_Shdr
* section
;
15804 Elf_Internal_Shdr
* string_sec
;
15805 Elf32_External_Lib
* elib
;
15807 size_t strtab_size
;
15810 bfd_boolean res
= TRUE
;
15815 for (i
= 0, section
= section_headers
;
15816 i
< elf_header
.e_shnum
;
15819 switch (section
->sh_type
)
15821 case SHT_GNU_LIBLIST
:
15822 if (section
->sh_link
>= elf_header
.e_shnum
)
15825 elib
= (Elf32_External_Lib
*)
15826 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15827 _("liblist section data"));
15835 string_sec
= section_headers
+ section
->sh_link
;
15836 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15837 string_sec
->sh_size
,
15838 _("liblist string table"));
15840 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15847 strtab_size
= string_sec
->sh_size
;
15849 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15850 printable_section_name (section
),
15851 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15853 puts (_(" Library Time Stamp Checksum Version Flags"));
15855 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15863 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15864 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15865 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15866 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15867 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15869 tmp
= gmtime (&atime
);
15870 snprintf (timebuf
, sizeof (timebuf
),
15871 "%04u-%02u-%02uT%02u:%02u:%02u",
15872 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15873 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15875 printf ("%3lu: ", (unsigned long) cnt
);
15877 printf ("%-20s", liblist
.l_name
< strtab_size
15878 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15880 printf ("%-20.20s", liblist
.l_name
< strtab_size
15881 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15882 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15883 liblist
.l_version
, liblist
.l_flags
);
15894 static const char *
15895 get_note_type (unsigned e_type
)
15897 static char buff
[64];
15899 if (elf_header
.e_type
== ET_CORE
)
15903 return _("NT_AUXV (auxiliary vector)");
15905 return _("NT_PRSTATUS (prstatus structure)");
15907 return _("NT_FPREGSET (floating point registers)");
15909 return _("NT_PRPSINFO (prpsinfo structure)");
15910 case NT_TASKSTRUCT
:
15911 return _("NT_TASKSTRUCT (task structure)");
15913 return _("NT_PRXFPREG (user_xfpregs structure)");
15915 return _("NT_PPC_VMX (ppc Altivec registers)");
15917 return _("NT_PPC_VSX (ppc VSX registers)");
15919 return _("NT_386_TLS (x86 TLS information)");
15920 case NT_386_IOPERM
:
15921 return _("NT_386_IOPERM (x86 I/O permissions)");
15922 case NT_X86_XSTATE
:
15923 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15924 case NT_S390_HIGH_GPRS
:
15925 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15926 case NT_S390_TIMER
:
15927 return _("NT_S390_TIMER (s390 timer register)");
15928 case NT_S390_TODCMP
:
15929 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15930 case NT_S390_TODPREG
:
15931 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15933 return _("NT_S390_CTRS (s390 control registers)");
15934 case NT_S390_PREFIX
:
15935 return _("NT_S390_PREFIX (s390 prefix register)");
15936 case NT_S390_LAST_BREAK
:
15937 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15938 case NT_S390_SYSTEM_CALL
:
15939 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15941 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15942 case NT_S390_VXRS_LOW
:
15943 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15944 case NT_S390_VXRS_HIGH
:
15945 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15947 return _("NT_ARM_VFP (arm VFP registers)");
15949 return _("NT_ARM_TLS (AArch TLS registers)");
15950 case NT_ARM_HW_BREAK
:
15951 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15952 case NT_ARM_HW_WATCH
:
15953 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15955 return _("NT_PSTATUS (pstatus structure)");
15957 return _("NT_FPREGS (floating point registers)");
15959 return _("NT_PSINFO (psinfo structure)");
15961 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15963 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15964 case NT_WIN32PSTATUS
:
15965 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15967 return _("NT_SIGINFO (siginfo_t data)");
15969 return _("NT_FILE (mapped files)");
15977 return _("NT_VERSION (version)");
15979 return _("NT_ARCH (architecture)");
15980 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
15981 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15982 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
15983 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15988 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15993 print_core_note (Elf_Internal_Note
*pnote
)
15995 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15996 bfd_vma count
, page_size
;
15997 unsigned char *descdata
, *filenames
, *descend
;
15999 if (pnote
->type
!= NT_FILE
)
16005 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16006 /* Still "successful". */
16011 if (pnote
->descsz
< 2 * addr_size
)
16013 error (_(" Malformed note - too short for header\n"));
16017 descdata
= (unsigned char *) pnote
->descdata
;
16018 descend
= descdata
+ pnote
->descsz
;
16020 if (descdata
[pnote
->descsz
- 1] != '\0')
16022 error (_(" Malformed note - does not end with \\0\n"));
16026 count
= byte_get (descdata
, addr_size
);
16027 descdata
+= addr_size
;
16029 page_size
= byte_get (descdata
, addr_size
);
16030 descdata
+= addr_size
;
16032 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16034 error (_(" Malformed note - too short for supplied file count\n"));
16038 printf (_(" Page size: "));
16039 print_vma (page_size
, DEC
);
16042 printf (_(" %*s%*s%*s\n"),
16043 (int) (2 + 2 * addr_size
), _("Start"),
16044 (int) (4 + 2 * addr_size
), _("End"),
16045 (int) (4 + 2 * addr_size
), _("Page Offset"));
16046 filenames
= descdata
+ count
* 3 * addr_size
;
16047 while (count
-- > 0)
16049 bfd_vma start
, end
, file_ofs
;
16051 if (filenames
== descend
)
16053 error (_(" Malformed note - filenames end too early\n"));
16057 start
= byte_get (descdata
, addr_size
);
16058 descdata
+= addr_size
;
16059 end
= byte_get (descdata
, addr_size
);
16060 descdata
+= addr_size
;
16061 file_ofs
= byte_get (descdata
, addr_size
);
16062 descdata
+= addr_size
;
16065 print_vma (start
, FULL_HEX
);
16067 print_vma (end
, FULL_HEX
);
16069 print_vma (file_ofs
, FULL_HEX
);
16070 printf ("\n %s\n", filenames
);
16072 filenames
+= 1 + strlen ((char *) filenames
);
16078 static const char *
16079 get_gnu_elf_note_type (unsigned e_type
)
16081 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16084 case NT_GNU_ABI_TAG
:
16085 return _("NT_GNU_ABI_TAG (ABI version tag)");
16087 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16088 case NT_GNU_BUILD_ID
:
16089 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16090 case NT_GNU_GOLD_VERSION
:
16091 return _("NT_GNU_GOLD_VERSION (gold version)");
16092 case NT_GNU_PROPERTY_TYPE_0
:
16093 return _("NT_GNU_PROPERTY_TYPE_0");
16094 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16095 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16096 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16097 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16100 static char buff
[64];
16102 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16109 decode_x86_isa (unsigned int bitmask
)
16113 unsigned int bit
= bitmask
& (- bitmask
);
16118 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16119 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16120 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16121 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16122 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16123 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16124 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16125 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16126 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16127 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16128 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16129 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16130 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16131 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16132 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16133 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16134 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16135 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16136 default: printf (_("<unknown: %x>"), bit
); break;
16144 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16146 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16147 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16148 unsigned int size
= is_32bit_elf
? 4 : 8;
16150 printf (_(" Properties: "));
16152 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16154 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16161 unsigned int type
= byte_get (ptr
, 4);
16162 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16166 if ((ptr
+ datasz
) > ptr_end
)
16168 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16173 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16175 if (elf_header
.e_machine
== EM_X86_64
16176 || elf_header
.e_machine
== EM_IAMCU
16177 || elf_header
.e_machine
== EM_386
)
16181 case GNU_PROPERTY_X86_ISA_1_USED
:
16182 printf ("x86 ISA used: ");
16184 printf (_("<corrupt length: %#x> "), datasz
);
16186 decode_x86_isa (byte_get (ptr
, 4));
16189 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16190 printf ("x86 ISA needed: ");
16192 printf (_("<corrupt length: %#x> "), datasz
);
16194 decode_x86_isa (byte_get (ptr
, 4));
16206 case GNU_PROPERTY_STACK_SIZE
:
16207 printf (_("stack size: "));
16208 if (datasz
!= size
)
16209 printf (_("<corrupt length: %#x> "), datasz
);
16211 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16214 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16215 printf ("no copy on protected ");
16217 printf (_("<corrupt length: %#x> "), datasz
);
16225 if (type
< GNU_PROPERTY_LOPROC
)
16226 printf (_("<unknown type %#x data: "), type
);
16227 else if (type
< GNU_PROPERTY_LOUSER
)
16228 printf (_("<procesor-specific type %#x data: "), type
);
16230 printf (_("<application-specific type %#x data: "), type
);
16231 for (j
= 0; j
< datasz
; ++j
)
16232 printf ("%02x ", ptr
[j
] & 0xff);
16236 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16237 if (ptr
== ptr_end
)
16247 if (ptr
> (ptr_end
- 8))
16249 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16258 print_gnu_note (Elf_Internal_Note
*pnote
)
16260 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16261 switch (pnote
->type
)
16263 case NT_GNU_BUILD_ID
:
16267 printf (_(" Build ID: "));
16268 for (i
= 0; i
< pnote
->descsz
; ++i
)
16269 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16274 case NT_GNU_ABI_TAG
:
16276 unsigned long os
, major
, minor
, subminor
;
16277 const char *osname
;
16279 /* PR 17531: file: 030-599401-0.004. */
16280 if (pnote
->descsz
< 16)
16282 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16286 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16287 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16288 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16289 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16293 case GNU_ABI_TAG_LINUX
:
16296 case GNU_ABI_TAG_HURD
:
16299 case GNU_ABI_TAG_SOLARIS
:
16300 osname
= "Solaris";
16302 case GNU_ABI_TAG_FREEBSD
:
16303 osname
= "FreeBSD";
16305 case GNU_ABI_TAG_NETBSD
:
16308 case GNU_ABI_TAG_SYLLABLE
:
16309 osname
= "Syllable";
16311 case GNU_ABI_TAG_NACL
:
16315 osname
= "Unknown";
16319 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16320 major
, minor
, subminor
);
16324 case NT_GNU_GOLD_VERSION
:
16328 printf (_(" Version: "));
16329 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16330 printf ("%c", pnote
->descdata
[i
]);
16337 unsigned long num_entries
, mask
;
16339 /* Hardware capabilities information. Word 0 is the number of entries.
16340 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16341 is a series of entries, where each entry is a single byte followed
16342 by a nul terminated string. The byte gives the bit number to test
16343 if enabled in the bitmask. */
16344 printf (_(" Hardware Capabilities: "));
16345 if (pnote
->descsz
< 8)
16347 error (_("<corrupt GNU_HWCAP>\n"));
16350 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16351 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16352 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16353 /* FIXME: Add code to display the entries... */
16357 case NT_GNU_PROPERTY_TYPE_0
:
16358 print_gnu_property_note (pnote
);
16362 /* Handle unrecognised types. An error message should have already been
16363 created by get_gnu_elf_note_type(), so all that we need to do is to
16364 display the data. */
16368 printf (_(" Description data: "));
16369 for (i
= 0; i
< pnote
->descsz
; ++i
)
16370 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16379 static const char *
16380 get_v850_elf_note_type (enum v850_notes n_type
)
16382 static char buff
[64];
16386 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16387 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16388 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16389 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16390 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16391 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16393 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16399 print_v850_note (Elf_Internal_Note
* pnote
)
16403 if (pnote
->descsz
!= 4)
16406 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16410 printf (_("not set\n"));
16414 switch (pnote
->type
)
16416 case V850_NOTE_ALIGNMENT
:
16419 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16420 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16424 case V850_NOTE_DATA_SIZE
:
16427 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16428 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16432 case V850_NOTE_FPU_INFO
:
16435 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16436 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16440 case V850_NOTE_MMU_INFO
:
16441 case V850_NOTE_CACHE_INFO
:
16442 case V850_NOTE_SIMD_INFO
:
16443 if (val
== EF_RH850_SIMD
)
16445 printf (_("yes\n"));
16451 /* An 'unknown note type' message will already have been displayed. */
16455 printf (_("unknown value: %x\n"), val
);
16460 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16462 unsigned int version
;
16464 switch (pnote
->type
)
16466 case NT_NETBSD_IDENT
:
16467 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16468 if ((version
/ 10000) % 100)
16469 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16470 version
, version
/ 100000000, (version
/ 1000000) % 100,
16471 (version
/ 10000) % 100 > 26 ? "Z" : "",
16472 'A' + (version
/ 10000) % 26);
16474 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16475 version
, version
/ 100000000, (version
/ 1000000) % 100,
16476 (version
/ 100) % 100);
16479 case NT_NETBSD_MARCH
:
16480 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16485 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16491 static const char *
16492 get_freebsd_elfcore_note_type (unsigned e_type
)
16496 case NT_FREEBSD_THRMISC
:
16497 return _("NT_THRMISC (thrmisc structure)");
16498 case NT_FREEBSD_PROCSTAT_PROC
:
16499 return _("NT_PROCSTAT_PROC (proc data)");
16500 case NT_FREEBSD_PROCSTAT_FILES
:
16501 return _("NT_PROCSTAT_FILES (files data)");
16502 case NT_FREEBSD_PROCSTAT_VMMAP
:
16503 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16504 case NT_FREEBSD_PROCSTAT_GROUPS
:
16505 return _("NT_PROCSTAT_GROUPS (groups data)");
16506 case NT_FREEBSD_PROCSTAT_UMASK
:
16507 return _("NT_PROCSTAT_UMASK (umask data)");
16508 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16509 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16510 case NT_FREEBSD_PROCSTAT_OSREL
:
16511 return _("NT_PROCSTAT_OSREL (osreldate data)");
16512 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16513 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16514 case NT_FREEBSD_PROCSTAT_AUXV
:
16515 return _("NT_PROCSTAT_AUXV (auxv data)");
16517 return get_note_type (e_type
);
16520 static const char *
16521 get_netbsd_elfcore_note_type (unsigned e_type
)
16523 static char buff
[64];
16525 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16527 /* NetBSD core "procinfo" structure. */
16528 return _("NetBSD procinfo structure");
16531 /* As of Jan 2002 there are no other machine-independent notes
16532 defined for NetBSD core files. If the note type is less
16533 than the start of the machine-dependent note types, we don't
16536 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16538 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16542 switch (elf_header
.e_machine
)
16544 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16545 and PT_GETFPREGS == mach+2. */
16550 case EM_SPARC32PLUS
:
16554 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16555 return _("PT_GETREGS (reg structure)");
16556 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16557 return _("PT_GETFPREGS (fpreg structure)");
16563 /* On all other arch's, PT_GETREGS == mach+1 and
16564 PT_GETFPREGS == mach+3. */
16568 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16569 return _("PT_GETREGS (reg structure)");
16570 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16571 return _("PT_GETFPREGS (fpreg structure)");
16577 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16578 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16582 static const char *
16583 get_stapsdt_note_type (unsigned e_type
)
16585 static char buff
[64];
16590 return _("NT_STAPSDT (SystemTap probe descriptors)");
16596 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16601 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16603 int addr_size
= is_32bit_elf
? 4 : 8;
16604 char *data
= pnote
->descdata
;
16605 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16606 bfd_vma pc
, base_addr
, semaphore
;
16607 char *provider
, *probe
, *arg_fmt
;
16609 pc
= byte_get ((unsigned char *) data
, addr_size
);
16611 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16613 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16617 data
+= strlen (data
) + 1;
16619 data
+= strlen (data
) + 1;
16621 data
+= strlen (data
) + 1;
16623 printf (_(" Provider: %s\n"), provider
);
16624 printf (_(" Name: %s\n"), probe
);
16625 printf (_(" Location: "));
16626 print_vma (pc
, FULL_HEX
);
16627 printf (_(", Base: "));
16628 print_vma (base_addr
, FULL_HEX
);
16629 printf (_(", Semaphore: "));
16630 print_vma (semaphore
, FULL_HEX
);
16632 printf (_(" Arguments: %s\n"), arg_fmt
);
16634 return data
== data_end
;
16637 static const char *
16638 get_ia64_vms_note_type (unsigned e_type
)
16640 static char buff
[64];
16645 return _("NT_VMS_MHD (module header)");
16647 return _("NT_VMS_LNM (language name)");
16649 return _("NT_VMS_SRC (source files)");
16651 return "NT_VMS_TITLE";
16653 return _("NT_VMS_EIDC (consistency check)");
16654 case NT_VMS_FPMODE
:
16655 return _("NT_VMS_FPMODE (FP mode)");
16656 case NT_VMS_LINKTIME
:
16657 return "NT_VMS_LINKTIME";
16658 case NT_VMS_IMGNAM
:
16659 return _("NT_VMS_IMGNAM (image name)");
16661 return _("NT_VMS_IMGID (image id)");
16662 case NT_VMS_LINKID
:
16663 return _("NT_VMS_LINKID (link id)");
16664 case NT_VMS_IMGBID
:
16665 return _("NT_VMS_IMGBID (build id)");
16666 case NT_VMS_GSTNAM
:
16667 return _("NT_VMS_GSTNAM (sym table name)");
16668 case NT_VMS_ORIG_DYN
:
16669 return "NT_VMS_ORIG_DYN";
16670 case NT_VMS_PATCHTIME
:
16671 return "NT_VMS_PATCHTIME";
16673 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16679 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16681 switch (pnote
->type
)
16684 if (pnote
->descsz
> 36)
16686 size_t l
= strlen (pnote
->descdata
+ 34);
16687 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16688 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16689 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16690 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16693 printf (_(" Invalid size\n"));
16696 printf (_(" Language: %s\n"), pnote
->descdata
);
16699 case NT_VMS_FPMODE
:
16700 printf (_(" Floating Point mode: "));
16701 printf ("0x%016" BFD_VMA_FMT
"x\n",
16702 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16704 case NT_VMS_LINKTIME
:
16705 printf (_(" Link time: "));
16707 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16710 case NT_VMS_PATCHTIME
:
16711 printf (_(" Patch time: "));
16713 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16716 case NT_VMS_ORIG_DYN
:
16717 printf (_(" Major id: %u, minor id: %u\n"),
16718 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16719 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16720 printf (_(" Last modified : "));
16722 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16723 printf (_("\n Link flags : "));
16724 printf ("0x%016" BFD_VMA_FMT
"x\n",
16725 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16726 printf (_(" Header flags: 0x%08x\n"),
16727 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16728 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16731 case NT_VMS_IMGNAM
:
16732 printf (_(" Image name: %s\n"), pnote
->descdata
);
16734 case NT_VMS_GSTNAM
:
16735 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16738 printf (_(" Image id: %s\n"), pnote
->descdata
);
16740 case NT_VMS_LINKID
:
16741 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16749 /* Print the name of the symbol associated with a build attribute
16750 that is attached to address OFFSET. */
16753 print_symbol_for_build_attribute (FILE * file
,
16754 unsigned long offset
,
16755 bfd_boolean is_open_attr
)
16757 static FILE * saved_file
= NULL
;
16758 static char * strtab
;
16759 static unsigned long strtablen
;
16760 static Elf_Internal_Sym
* symtab
;
16761 static unsigned long nsyms
;
16762 Elf_Internal_Sym
* saved_sym
= NULL
;
16763 Elf_Internal_Sym
* sym
;
16765 if (section_headers
!= NULL
16766 && (saved_file
== NULL
|| file
!= saved_file
))
16768 Elf_Internal_Shdr
* symsec
;
16770 /* Load the symbol and string sections. */
16771 for (symsec
= section_headers
;
16772 symsec
< section_headers
+ elf_header
.e_shnum
;
16775 if (symsec
->sh_type
== SHT_SYMTAB
)
16777 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
16779 if (symsec
->sh_link
< elf_header
.e_shnum
)
16781 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
16783 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
16784 1, strtab_sec
->sh_size
,
16785 _("string table"));
16786 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
16793 if (symtab
== NULL
|| strtab
== NULL
)
16799 /* Find a symbol whose value matches offset. */
16800 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
16801 if (sym
->st_value
== offset
)
16803 if (sym
->st_name
>= strtablen
)
16804 /* Huh ? This should not happen. */
16807 if (strtab
[sym
->st_name
] == 0)
16812 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
16813 and FILE or OBJECT symbols over NOTYPE symbols. We skip
16814 FUNC symbols entirely. */
16815 switch (ELF_ST_TYPE (sym
->st_info
))
16819 /* We can stop searching now. */
16820 sym
= symtab
+ nsyms
;
16828 /* Ignore function symbols. */
16835 switch (ELF_ST_BIND (sym
->st_info
))
16838 if (saved_sym
== NULL
16839 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
16844 if (saved_sym
== NULL
)
16854 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
16862 printf (" (%s: %s)\n",
16863 is_open_attr
? _("file") : _("func"),
16864 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
16869 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
16872 static unsigned long global_offset
= 0;
16873 unsigned long offset
;
16874 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
16875 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
16877 if (pnote
->descsz
== 0)
16881 printf (_(" Applies from offset %#lx\n"), global_offset
);
16886 printf (_(" Applies to func at %#lx"), global_offset
);
16887 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
16891 if (pnote
->descsz
!= desc_size
)
16893 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
16894 printf (_(" <invalid descsz>"));
16898 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
16902 printf (_(" Applies from offset %#lx"), offset
);
16903 global_offset
= offset
;
16907 printf (_(" Applies to func at %#lx"), offset
);
16910 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
16914 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
16916 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
16917 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
16918 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
16920 char name_attribute
;
16921 const char * expected_types
;
16922 const char * name
= pnote
->namedata
;
16926 if (name
== NULL
|| pnote
->namesz
< 2)
16928 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
16929 print_symbol (-20, _(" <corrupt name>"));
16933 switch ((name_type
= * name
))
16935 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
16936 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
16937 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
16938 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
16939 printf ("%c", * name
);
16942 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
16943 print_symbol (-20, _("<unknown name type>"));
16951 switch ((name_attribute
= * name
))
16953 case GNU_BUILD_ATTRIBUTE_VERSION
:
16954 text
= _("<version>");
16955 expected_types
= string_expected
;
16958 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
16959 text
= _("<stack prot>");
16960 expected_types
= "!+*";
16963 case GNU_BUILD_ATTRIBUTE_RELRO
:
16964 text
= _("<relro>");
16965 expected_types
= bool_expected
;
16968 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
16969 text
= _("<stack size>");
16970 expected_types
= number_expected
;
16973 case GNU_BUILD_ATTRIBUTE_TOOL
:
16974 text
= _("<tool>");
16975 expected_types
= string_expected
;
16978 case GNU_BUILD_ATTRIBUTE_ABI
:
16980 expected_types
= "$*";
16983 case GNU_BUILD_ATTRIBUTE_PIC
:
16985 expected_types
= number_expected
;
16988 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
16989 text
= _("<short enum>");
16990 expected_types
= bool_expected
;
16994 if (ISPRINT (* name
))
16996 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
16998 if (len
> left
&& ! do_wide
)
17000 printf ("%.*s:", len
, name
);
17006 static char tmpbuf
[128];
17007 error (_("unrecognised byte in name field: %d\n"), * name
);
17008 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17012 expected_types
= "*$!+";
17018 printf ("%s", text
);
17019 left
-= strlen (text
);
17022 if (strchr (expected_types
, name_type
) == NULL
)
17023 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17025 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17027 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17028 (unsigned long) pnote
->namesz
,
17029 (long) (name
- pnote
->namedata
));
17033 if (left
< 1 && ! do_wide
)
17038 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17040 unsigned int bytes
;
17041 unsigned long long val
= 0;
17042 unsigned int shift
= 0;
17043 char * decoded
= NULL
;
17045 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17047 /* The -1 is because the name field is always 0 terminated, and we
17048 want to be able to ensure that the shift in the while loop below
17049 will not overflow. */
17052 if (bytes
> sizeof (val
))
17054 fprintf (stderr
, "namesz %lx name %p namedata %p\n",
17055 pnote
->namesz
, name
, pnote
->namedata
);
17056 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17058 bytes
= sizeof (val
);
17060 /* We do not bother to warn if bytes == 0 as this can
17061 happen with some early versions of the gcc plugin. */
17065 unsigned long byte
= (* name
++) & 0xff;
17067 val
|= byte
<< shift
;
17071 switch (name_attribute
)
17073 case GNU_BUILD_ATTRIBUTE_PIC
:
17076 case 0: decoded
= "static"; break;
17077 case 1: decoded
= "pic"; break;
17078 case 2: decoded
= "PIC"; break;
17079 case 3: decoded
= "pie"; break;
17080 case 4: decoded
= "PIE"; break;
17084 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17087 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17088 case 0: decoded
= "off"; break;
17089 case 1: decoded
= "on"; break;
17090 case 2: decoded
= "all"; break;
17091 case 3: decoded
= "strong"; break;
17092 case 4: decoded
= "explicit"; break;
17100 if (decoded
!= NULL
)
17102 print_symbol (-left
, decoded
);
17113 left
-= printf ("0x%llx", val
);
17115 left
-= printf ("0x%-.*llx", left
, val
);
17119 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17120 left
-= print_symbol (- left
, name
);
17122 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17123 left
-= print_symbol (- left
, "true");
17125 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17126 left
-= print_symbol (- left
, "false");
17130 if (do_wide
&& left
> 0)
17131 printf ("%-*s", left
, " ");
17136 /* Note that by the ELF standard, the name field is already null byte
17137 terminated, and namesz includes the terminating null byte.
17138 I.E. the value of namesz for the name "FSF" is 4.
17140 If the value of namesz is zero, there is no name present. */
17143 process_note (Elf_Internal_Note
* pnote
,
17146 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17149 if (pnote
->namesz
== 0)
17150 /* If there is no note name, then use the default set of
17151 note type strings. */
17152 nt
= get_note_type (pnote
->type
);
17154 else if (const_strneq (pnote
->namedata
, "GNU"))
17155 /* GNU-specific object file notes. */
17156 nt
= get_gnu_elf_note_type (pnote
->type
);
17158 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17159 /* FreeBSD-specific core file notes. */
17160 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
17162 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17163 /* NetBSD-specific core file notes. */
17164 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17166 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17167 /* NetBSD-specific core file notes. */
17168 return process_netbsd_elf_note (pnote
);
17170 else if (strneq (pnote
->namedata
, "SPU/", 4))
17172 /* SPU-specific core file notes. */
17173 nt
= pnote
->namedata
+ 4;
17177 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17178 /* VMS/ia64-specific file notes. */
17179 nt
= get_ia64_vms_note_type (pnote
->type
);
17181 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17182 nt
= get_stapsdt_note_type (pnote
->type
);
17185 /* Don't recognize this note name; just use the default set of
17186 note type strings. */
17187 nt
= get_note_type (pnote
->type
);
17191 if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17192 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17193 print_gnu_build_attribute_name (pnote
);
17195 print_symbol (-20, name
);
17198 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17200 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17202 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17203 return print_ia64_vms_note (pnote
);
17204 else if (const_strneq (pnote
->namedata
, "GNU"))
17205 return print_gnu_note (pnote
);
17206 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17207 return print_stapsdt_note (pnote
);
17208 else if (const_strneq (pnote
->namedata
, "CORE"))
17209 return print_core_note (pnote
);
17210 else if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17211 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17212 return print_gnu_build_attribute_description (pnote
, file
);
17218 printf (_(" description data: "));
17219 for (i
= 0; i
< pnote
->descsz
; i
++)
17220 printf ("%02x ", pnote
->descdata
[i
]);
17230 process_notes_at (FILE * file
,
17231 Elf_Internal_Shdr
* section
,
17235 Elf_External_Note
* pnotes
;
17236 Elf_External_Note
* external
;
17238 bfd_boolean res
= TRUE
;
17245 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17248 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17253 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17255 if (pnotes
== NULL
)
17261 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17263 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17264 (unsigned long) offset
, (unsigned long) length
);
17266 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17268 end
= (char *) pnotes
+ length
;
17269 while ((char *) external
< end
)
17271 Elf_Internal_Note inote
;
17274 char * temp
= NULL
;
17275 size_t data_remaining
= end
- (char *) external
;
17277 if (!is_ia64_vms ())
17279 /* PR binutils/15191
17280 Make sure that there is enough data to read. */
17281 min_notesz
= offsetof (Elf_External_Note
, name
);
17282 if (data_remaining
< min_notesz
)
17284 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17285 (int) data_remaining
);
17288 inote
.type
= BYTE_GET (external
->type
);
17289 inote
.namesz
= BYTE_GET (external
->namesz
);
17290 inote
.namedata
= external
->name
;
17291 inote
.descsz
= BYTE_GET (external
->descsz
);
17292 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17293 /* PR 17531: file: 3443835e. */
17294 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17296 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17297 inote
.namesz
, (long)(end
- inote
.namedata
));
17298 inote
.descdata
= inote
.namedata
;
17302 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17303 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17307 Elf64_External_VMS_Note
*vms_external
;
17309 /* PR binutils/15191
17310 Make sure that there is enough data to read. */
17311 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17312 if (data_remaining
< min_notesz
)
17314 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17315 (int) data_remaining
);
17319 vms_external
= (Elf64_External_VMS_Note
*) external
;
17320 inote
.type
= BYTE_GET (vms_external
->type
);
17321 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17322 inote
.namedata
= vms_external
->name
;
17323 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17324 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17325 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17326 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17329 if (inote
.descdata
< (char *) external
+ min_notesz
17330 || next
< (char *) external
+ min_notesz
17331 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17332 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17333 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17334 || data_remaining
< (size_t)(next
- (char *) external
))
17336 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17337 (unsigned long) ((char *) external
- (char *) pnotes
));
17338 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17339 inote
.type
, inote
.namesz
, inote
.descsz
);
17343 external
= (Elf_External_Note
*) next
;
17345 /* Verify that name is null terminated. It appears that at least
17346 one version of Linux (RedHat 6.0) generates corefiles that don't
17347 comply with the ELF spec by failing to include the null byte in
17349 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17351 temp
= (char *) malloc (inote
.namesz
+ 1);
17354 error (_("Out of memory allocating space for inote name\n"));
17359 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17360 temp
[inote
.namesz
] = 0;
17362 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17363 inote
.namedata
= temp
;
17366 if (! process_note (& inote
, file
))
17382 process_corefile_note_segments (FILE * file
)
17384 Elf_Internal_Phdr
* segment
;
17386 bfd_boolean res
= TRUE
;
17388 if (! get_program_headers (file
))
17391 for (i
= 0, segment
= program_headers
;
17392 i
< elf_header
.e_phnum
;
17395 if (segment
->p_type
== PT_NOTE
)
17396 if (! process_notes_at (file
, NULL
,
17397 (bfd_vma
) segment
->p_offset
,
17398 (bfd_vma
) segment
->p_filesz
))
17406 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17408 Elf_External_Note
* pnotes
;
17409 Elf_External_Note
* external
;
17411 bfd_boolean res
= TRUE
;
17416 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17418 if (pnotes
== NULL
)
17422 end
= (char*) pnotes
+ length
;
17424 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17425 (unsigned long) offset
, (unsigned long) length
);
17427 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17429 Elf_External_Note
* next
;
17430 Elf_Internal_Note inote
;
17432 inote
.type
= BYTE_GET (external
->type
);
17433 inote
.namesz
= BYTE_GET (external
->namesz
);
17434 inote
.namedata
= external
->name
;
17435 inote
.descsz
= BYTE_GET (external
->descsz
);
17436 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17437 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17439 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17441 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17442 inote
.descdata
= inote
.namedata
;
17446 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17448 if ( ((char *) next
> end
)
17449 || ((char *) next
< (char *) pnotes
))
17451 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17452 (unsigned long) ((char *) external
- (char *) pnotes
));
17453 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17454 inote
.type
, inote
.namesz
, inote
.descsz
);
17460 /* Prevent out-of-bounds indexing. */
17461 if ( inote
.namedata
+ inote
.namesz
> end
17462 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17464 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17465 (unsigned long) ((char *) external
- (char *) pnotes
));
17466 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17467 inote
.type
, inote
.namesz
, inote
.descsz
);
17471 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17473 if (! print_v850_note (& inote
))
17476 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17477 inote
.namesz
, inote
.descsz
);
17487 process_note_sections (FILE * file
)
17489 Elf_Internal_Shdr
* section
;
17491 unsigned int n
= 0;
17492 bfd_boolean res
= TRUE
;
17494 for (i
= 0, section
= section_headers
;
17495 i
< elf_header
.e_shnum
&& section
!= NULL
;
17498 if (section
->sh_type
== SHT_NOTE
)
17500 if (! process_notes_at (file
, section
,
17501 (bfd_vma
) section
->sh_offset
,
17502 (bfd_vma
) section
->sh_size
))
17507 if (( elf_header
.e_machine
== EM_V800
17508 || elf_header
.e_machine
== EM_V850
17509 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17510 && section
->sh_type
== SHT_RENESAS_INFO
)
17512 if (! process_v850_notes (file
,
17513 (bfd_vma
) section
->sh_offset
,
17514 (bfd_vma
) section
->sh_size
))
17521 /* Try processing NOTE segments instead. */
17522 return process_corefile_note_segments (file
);
17528 process_notes (FILE * file
)
17530 /* If we have not been asked to display the notes then do nothing. */
17534 if (elf_header
.e_type
!= ET_CORE
)
17535 return process_note_sections (file
);
17537 /* No program headers means no NOTE segment. */
17538 if (elf_header
.e_phnum
> 0)
17539 return process_corefile_note_segments (file
);
17541 printf (_("No note segments present in the core file.\n"));
17545 static unsigned char *
17546 display_public_gnu_attributes (unsigned char * start
,
17547 const unsigned char * const end
)
17549 printf (_(" Unknown GNU attribute: %s\n"), start
);
17551 start
+= strnlen ((char *) start
, end
- start
);
17552 display_raw_attribute (start
, end
);
17554 return (unsigned char *) end
;
17557 static unsigned char *
17558 display_generic_attribute (unsigned char * start
,
17560 const unsigned char * const end
)
17563 return (unsigned char *) end
;
17565 return display_tag_value (tag
, start
, end
);
17569 process_arch_specific (FILE * file
)
17574 switch (elf_header
.e_machine
)
17577 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17578 display_arm_attribute
,
17579 display_generic_attribute
);
17582 case EM_MIPS_RS3_LE
:
17583 return process_mips_specific (file
);
17586 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17587 display_msp430x_attribute
,
17588 display_generic_attribute
);
17591 return process_nds32_specific (file
);
17595 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17596 display_power_gnu_attribute
);
17600 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17601 display_s390_gnu_attribute
);
17604 case EM_SPARC32PLUS
:
17606 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17607 display_sparc_gnu_attribute
);
17610 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17611 display_tic6x_attribute
,
17612 display_generic_attribute
);
17615 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17616 display_public_gnu_attributes
,
17617 display_generic_attribute
);
17622 get_file_header (FILE * file
)
17624 /* Read in the identity array. */
17625 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
17628 /* Determine how to read the rest of the header. */
17629 switch (elf_header
.e_ident
[EI_DATA
])
17634 byte_get
= byte_get_little_endian
;
17635 byte_put
= byte_put_little_endian
;
17638 byte_get
= byte_get_big_endian
;
17639 byte_put
= byte_put_big_endian
;
17643 /* For now we only support 32 bit and 64 bit ELF files. */
17644 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
17646 /* Read in the rest of the header. */
17649 Elf32_External_Ehdr ehdr32
;
17651 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
17654 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
17655 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
17656 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
17657 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
17658 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
17659 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
17660 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
17661 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
17662 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
17663 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
17664 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
17665 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
17666 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
17670 Elf64_External_Ehdr ehdr64
;
17672 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17673 we will not be able to cope with the 64bit data found in
17674 64 ELF files. Detect this now and abort before we start
17675 overwriting things. */
17676 if (sizeof (bfd_vma
) < 8)
17678 error (_("This instance of readelf has been built without support for a\n\
17679 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17683 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
17686 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
17687 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
17688 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
17689 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
17690 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
17691 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
17692 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
17693 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
17694 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
17695 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
17696 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
17697 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
17698 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
17701 if (elf_header
.e_shoff
)
17703 /* There may be some extensions in the first section header. Don't
17704 bomb if we can't read it. */
17706 get_32bit_section_headers (file
, TRUE
);
17708 get_64bit_section_headers (file
, TRUE
);
17714 /* Process one ELF object file according to the command line options.
17715 This file may actually be stored in an archive. The file is
17716 positioned at the start of the ELF object. Returns TRUE if no
17717 problems were encountered, FALSE otherwise. */
17720 process_object (char * file_name
, FILE * file
)
17723 bfd_boolean res
= TRUE
;
17725 if (! get_file_header (file
))
17727 error (_("%s: Failed to read file header\n"), file_name
);
17731 /* Initialise per file variables. */
17732 for (i
= ARRAY_SIZE (version_info
); i
--;)
17733 version_info
[i
] = 0;
17735 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
17736 dynamic_info
[i
] = 0;
17737 dynamic_info_DT_GNU_HASH
= 0;
17739 /* Process the file. */
17741 printf (_("\nFile: %s\n"), file_name
);
17743 /* Initialise the dump_sects array from the cmdline_dump_sects array.
17744 Note we do this even if cmdline_dump_sects is empty because we
17745 must make sure that the dump_sets array is zeroed out before each
17746 object file is processed. */
17747 if (num_dump_sects
> num_cmdline_dump_sects
)
17748 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
17750 if (num_cmdline_dump_sects
> 0)
17752 if (num_dump_sects
== 0)
17753 /* A sneaky way of allocating the dump_sects array. */
17754 request_dump_bynumber (num_cmdline_dump_sects
, 0);
17756 assert (num_dump_sects
>= num_cmdline_dump_sects
);
17757 memcpy (dump_sects
, cmdline_dump_sects
,
17758 num_cmdline_dump_sects
* sizeof (* dump_sects
));
17761 if (! process_file_header ())
17764 if (! process_section_headers (file
))
17766 /* Without loaded section headers we cannot process lots of things. */
17767 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
17769 if (! do_using_dynamic
)
17770 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
17773 if (! process_section_groups (file
))
17774 /* Without loaded section groups we cannot process unwind. */
17777 if (process_program_headers (file
))
17778 process_dynamic_section (file
);
17782 if (! process_relocs (file
))
17785 if (! process_unwind (file
))
17788 if (! process_symbol_table (file
))
17791 if (! process_syminfo (file
))
17794 if (! process_version_sections (file
))
17797 if (! process_section_contents (file
))
17800 if (! process_notes (file
))
17803 if (! process_gnu_liblist (file
))
17806 if (! process_arch_specific (file
))
17809 if (program_headers
)
17811 free (program_headers
);
17812 program_headers
= NULL
;
17815 if (section_headers
)
17817 free (section_headers
);
17818 section_headers
= NULL
;
17823 free (string_table
);
17824 string_table
= NULL
;
17825 string_table_length
= 0;
17828 if (dynamic_strings
)
17830 free (dynamic_strings
);
17831 dynamic_strings
= NULL
;
17832 dynamic_strings_length
= 0;
17835 if (dynamic_symbols
)
17837 free (dynamic_symbols
);
17838 dynamic_symbols
= NULL
;
17839 num_dynamic_syms
= 0;
17842 if (dynamic_syminfo
)
17844 free (dynamic_syminfo
);
17845 dynamic_syminfo
= NULL
;
17848 if (dynamic_section
)
17850 free (dynamic_section
);
17851 dynamic_section
= NULL
;
17854 if (section_headers_groups
)
17856 free (section_headers_groups
);
17857 section_headers_groups
= NULL
;
17860 if (section_groups
)
17862 struct group_list
* g
;
17863 struct group_list
* next
;
17865 for (i
= 0; i
< group_count
; i
++)
17867 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
17874 free (section_groups
);
17875 section_groups
= NULL
;
17878 free_debug_memory ();
17883 /* Process an ELF archive.
17884 On entry the file is positioned just after the ARMAG string.
17885 Returns TRUE upon success, FALSE otherwise. */
17888 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
17890 struct archive_info arch
;
17891 struct archive_info nested_arch
;
17893 bfd_boolean ret
= TRUE
;
17897 /* The ARCH structure is used to hold information about this archive. */
17898 arch
.file_name
= NULL
;
17900 arch
.index_array
= NULL
;
17901 arch
.sym_table
= NULL
;
17902 arch
.longnames
= NULL
;
17904 /* The NESTED_ARCH structure is used as a single-item cache of information
17905 about a nested archive (when members of a thin archive reside within
17906 another regular archive file). */
17907 nested_arch
.file_name
= NULL
;
17908 nested_arch
.file
= NULL
;
17909 nested_arch
.index_array
= NULL
;
17910 nested_arch
.sym_table
= NULL
;
17911 nested_arch
.longnames
= NULL
;
17913 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
17919 if (do_archive_index
)
17921 if (arch
.sym_table
== NULL
)
17922 error (_("%s: unable to dump the index as none was found\n"), file_name
);
17925 unsigned long i
, l
;
17926 unsigned long current_pos
;
17928 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17929 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
17930 current_pos
= ftell (file
);
17932 for (i
= l
= 0; i
< arch
.index_num
; i
++)
17934 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
17936 char * member_name
;
17938 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
17940 if (member_name
!= NULL
)
17942 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
17944 if (qualified_name
!= NULL
)
17946 printf (_("Contents of binary %s at offset "), qualified_name
);
17947 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
17949 free (qualified_name
);
17954 if (l
>= arch
.sym_size
)
17956 error (_("%s: end of the symbol table reached before the end of the index\n"),
17961 /* PR 17531: file: 0b6630b2. */
17962 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
17963 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
17966 if (arch
.uses_64bit_indicies
)
17971 if (l
< arch
.sym_size
)
17973 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17974 file_name
, arch
.sym_size
- l
);
17978 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
17980 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
17986 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
17987 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
17988 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
17989 && !do_section_groups
&& !do_dyn_syms
)
17991 ret
= TRUE
; /* Archive index only. */
18000 char * qualified_name
;
18002 /* Read the next archive header. */
18003 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18005 error (_("%s: failed to seek to next archive header\n"), file_name
);
18008 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
18009 if (got
!= sizeof arch
.arhdr
)
18013 error (_("%s: failed to read archive header\n"), file_name
);
18017 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18019 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18024 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18026 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18027 if (archive_file_size
& 01)
18028 ++archive_file_size
;
18030 name
= get_archive_member_name (&arch
, &nested_arch
);
18033 error (_("%s: bad archive file name\n"), file_name
);
18037 namelen
= strlen (name
);
18039 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18040 if (qualified_name
== NULL
)
18042 error (_("%s: bad archive file name\n"), file_name
);
18047 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18049 /* This is a proxy for an external member of a thin archive. */
18050 FILE * member_file
;
18051 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
18053 if (member_file_name
== NULL
)
18059 member_file
= fopen (member_file_name
, "rb");
18060 if (member_file
== NULL
)
18062 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18063 free (member_file_name
);
18068 archive_file_offset
= arch
.nested_member_origin
;
18070 if (! process_object (qualified_name
, member_file
))
18073 fclose (member_file
);
18074 free (member_file_name
);
18076 else if (is_thin_archive
)
18078 /* PR 15140: Allow for corrupt thin archives. */
18079 if (nested_arch
.file
== NULL
)
18081 error (_("%s: contains corrupt thin archive: %s\n"),
18087 /* This is a proxy for a member of a nested archive. */
18088 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18090 /* The nested archive file will have been opened and setup by
18091 get_archive_member_name. */
18092 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18094 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
18099 if (! process_object (qualified_name
, nested_arch
.file
))
18104 archive_file_offset
= arch
.next_arhdr_offset
;
18105 arch
.next_arhdr_offset
+= archive_file_size
;
18107 if (! process_object (qualified_name
, file
))
18111 if (dump_sects
!= NULL
)
18115 num_dump_sects
= 0;
18118 free (qualified_name
);
18122 if (nested_arch
.file
!= NULL
)
18123 fclose (nested_arch
.file
);
18124 release_archive (&nested_arch
);
18125 release_archive (&arch
);
18131 process_file (char * file_name
)
18134 struct stat statbuf
;
18135 char armag
[SARMAG
];
18136 bfd_boolean ret
= TRUE
;
18138 if (stat (file_name
, &statbuf
) < 0)
18140 if (errno
== ENOENT
)
18141 error (_("'%s': No such file\n"), file_name
);
18143 error (_("Could not locate '%s'. System error message: %s\n"),
18144 file_name
, strerror (errno
));
18148 if (! S_ISREG (statbuf
.st_mode
))
18150 error (_("'%s' is not an ordinary file\n"), file_name
);
18154 file
= fopen (file_name
, "rb");
18157 error (_("Input file '%s' is not readable.\n"), file_name
);
18161 if (fread (armag
, SARMAG
, 1, file
) != 1)
18163 error (_("%s: Failed to read file's magic number\n"), file_name
);
18168 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18170 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18172 if (! process_archive (file_name
, file
, FALSE
))
18175 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18177 if ( ! process_archive (file_name
, file
, TRUE
))
18182 if (do_archive_index
)
18183 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18187 archive_file_size
= archive_file_offset
= 0;
18189 if (! process_object (file_name
, file
))
18194 current_file_size
= 0;
18199 #ifdef SUPPORT_DISASSEMBLY
18200 /* Needed by the i386 disassembler. For extra credit, someone could
18201 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18205 print_address (unsigned int addr
, FILE * outfile
)
18207 fprintf (outfile
,"0x%8.8x", addr
);
18210 /* Needed by the i386 disassembler. */
18212 db_task_printsym (unsigned int addr
)
18214 print_address (addr
, stderr
);
18219 main (int argc
, char ** argv
)
18223 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18224 setlocale (LC_MESSAGES
, "");
18226 #if defined (HAVE_SETLOCALE)
18227 setlocale (LC_CTYPE
, "");
18229 bindtextdomain (PACKAGE
, LOCALEDIR
);
18230 textdomain (PACKAGE
);
18232 expandargv (&argc
, &argv
);
18234 parse_args (argc
, argv
);
18236 if (num_dump_sects
> 0)
18238 /* Make a copy of the dump_sects array. */
18239 cmdline_dump_sects
= (dump_type
*)
18240 malloc (num_dump_sects
* sizeof (* dump_sects
));
18241 if (cmdline_dump_sects
== NULL
)
18242 error (_("Out of memory allocating dump request table.\n"));
18245 memcpy (cmdline_dump_sects
, dump_sects
,
18246 num_dump_sects
* sizeof (* dump_sects
));
18247 num_cmdline_dump_sects
= num_dump_sects
;
18251 if (optind
< (argc
- 1))
18253 else if (optind
>= argc
)
18255 warn (_("Nothing to do.\n"));
18260 while (optind
< argc
)
18261 if (! process_file (argv
[optind
++]))
18264 if (dump_sects
!= NULL
)
18266 if (cmdline_dump_sects
!= NULL
)
18267 free (cmdline_dump_sects
);
18269 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;