1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/riscv.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/wasm32.h"
155 #include "elf/x86-64.h"
156 #include "elf/xc16x.h"
157 #include "elf/xgate.h"
158 #include "elf/xstormy16.h"
159 #include "elf/xtensa.h"
162 #include "libiberty.h"
163 #include "safe-ctype.h"
164 #include "filenames.h"
167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
170 typedef struct elf_section_list
172 Elf_Internal_Shdr
* hdr
;
173 struct elf_section_list
* next
;
176 char * program_name
= "readelf";
177 static unsigned long archive_file_offset
;
178 static unsigned long archive_file_size
;
179 static bfd_size_type current_file_size
;
180 static unsigned long dynamic_addr
;
181 static bfd_size_type dynamic_size
;
182 static size_t dynamic_nent
;
183 static char * dynamic_strings
;
184 static unsigned long dynamic_strings_length
;
185 static char * string_table
;
186 static unsigned long string_table_length
;
187 static unsigned long num_dynamic_syms
;
188 static Elf_Internal_Sym
* dynamic_symbols
;
189 static Elf_Internal_Syminfo
* dynamic_syminfo
;
190 static unsigned long dynamic_syminfo_offset
;
191 static unsigned int dynamic_syminfo_nent
;
192 static char program_interpreter
[PATH_MAX
];
193 static bfd_vma dynamic_info
[DT_ENCODING
];
194 static bfd_vma dynamic_info_DT_GNU_HASH
;
195 static bfd_vma version_info
[16];
196 static Elf_Internal_Ehdr elf_header
;
197 static Elf_Internal_Shdr
* section_headers
;
198 static Elf_Internal_Phdr
* program_headers
;
199 static Elf_Internal_Dyn
* dynamic_section
;
200 static elf_section_list
* symtab_shndx_list
;
201 static bfd_boolean show_name
= FALSE
;
202 static bfd_boolean do_dynamic
= FALSE
;
203 static bfd_boolean do_syms
= FALSE
;
204 static bfd_boolean do_dyn_syms
= FALSE
;
205 static bfd_boolean do_reloc
= FALSE
;
206 static bfd_boolean do_sections
= FALSE
;
207 static bfd_boolean do_section_groups
= FALSE
;
208 static bfd_boolean do_section_details
= FALSE
;
209 static bfd_boolean do_segments
= FALSE
;
210 static bfd_boolean do_unwind
= FALSE
;
211 static bfd_boolean do_using_dynamic
= FALSE
;
212 static bfd_boolean do_header
= FALSE
;
213 static bfd_boolean do_dump
= FALSE
;
214 static bfd_boolean do_version
= FALSE
;
215 static bfd_boolean do_histogram
= FALSE
;
216 static bfd_boolean do_debugging
= FALSE
;
217 static bfd_boolean do_arch
= FALSE
;
218 static bfd_boolean do_notes
= FALSE
;
219 static bfd_boolean do_archive_index
= FALSE
;
220 static bfd_boolean is_32bit_elf
= FALSE
;
221 static bfd_boolean decompress_dumps
= FALSE
;
225 struct group_list
* next
;
226 unsigned int section_index
;
231 struct group_list
* root
;
232 unsigned int group_index
;
235 static size_t group_count
;
236 static struct group
* section_groups
;
237 static struct group
** section_headers_groups
;
240 /* Flag bits indicating particular types of dump. */
241 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
242 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
243 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
244 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
245 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
247 typedef unsigned char dump_type
;
249 /* A linked list of the section names for which dumps were requested. */
250 struct dump_list_entry
254 struct dump_list_entry
* next
;
256 static struct dump_list_entry
* dump_sects_byname
;
258 /* A dynamic array of flags indicating for which sections a dump
259 has been requested via command line switches. */
260 static dump_type
* cmdline_dump_sects
= NULL
;
261 static unsigned int num_cmdline_dump_sects
= 0;
263 /* A dynamic array of flags indicating for which sections a dump of
264 some kind has been requested. It is reset on a per-object file
265 basis and then initialised from the cmdline_dump_sects array,
266 the results of interpreting the -w switch, and the
267 dump_sects_byname list. */
268 static dump_type
* dump_sects
= NULL
;
269 static unsigned int num_dump_sects
= 0;
272 /* How to print a vma value. */
273 typedef enum print_mode
285 /* Versioned symbol info. */
286 enum versioned_symbol_info
293 static const char * get_symbol_version_string
294 (FILE *, bfd_boolean
, const char *, unsigned long, unsigned,
295 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
299 #define SECTION_NAME(X) \
300 ((X) == NULL ? _("<none>") \
301 : string_table == NULL ? _("<no-name>") \
302 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
303 : string_table + (X)->sh_name))
305 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
307 #define GET_ELF_SYMBOLS(file, section, sym_count) \
308 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
309 : get_64bit_elf_symbols (file, section, sym_count))
311 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
313 already been called and verified that the string exists. */
314 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
316 #define REMOVE_ARCH_BITS(ADDR) \
319 if (elf_header.e_machine == EM_ARM) \
324 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
325 the offset of the current archive member, if we are examining an archive.
326 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
327 using malloc and fill that. In either case return the pointer to the start of
328 the retrieved data or NULL if something went wrong. If something does go wrong
329 and REASON is not NULL then emit an error message using REASON as part of the
333 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
334 bfd_size_type nmemb
, const char * reason
)
337 bfd_size_type amt
= size
* nmemb
;
339 if (size
== 0 || nmemb
== 0)
342 /* If the size_t type is smaller than the bfd_size_type, eg because
343 you are building a 32-bit tool on a 64-bit host, then make sure
344 that when the sizes are cast to (size_t) no information is lost. */
345 if (sizeof (size_t) < sizeof (bfd_size_type
)
346 && ( (bfd_size_type
) ((size_t) size
) != size
347 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
350 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT
"x"
351 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
352 nmemb
, size
, reason
);
356 /* Check for size overflow. */
360 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT
"x"
361 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
362 nmemb
, size
, reason
);
366 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
367 attempting to allocate memory when the read is bound to fail. */
368 if (amt
> current_file_size
369 || offset
+ archive_file_offset
+ amt
> current_file_size
)
372 error (_("Reading 0x%" BFD_VMA_FMT
"x"
373 " bytes extends past end of file for %s\n"),
378 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
381 error (_("Unable to seek to 0x%lx for %s\n"),
382 archive_file_offset
+ offset
, reason
);
389 /* Check for overflow. */
390 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
391 /* + 1 so that we can '\0' terminate invalid string table sections. */
392 mvar
= malloc ((size_t) amt
+ 1);
397 error (_("Out of memory allocating 0x%" BFD_VMA_FMT
"x"
403 ((char *) mvar
)[amt
] = '\0';
406 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
409 error (_("Unable to read in 0x%" BFD_VMA_FMT
"x bytes of %s\n"),
419 /* Print a VMA value in the MODE specified.
420 Returns the number of characters displayed. */
423 print_vma (bfd_vma vma
, print_mode mode
)
435 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
442 return printf ("%5" BFD_VMA_FMT
"d", vma
);
448 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
451 return printf ("%" BFD_VMA_FMT
"d", vma
);
454 return printf ("%" BFD_VMA_FMT
"u", vma
);
457 /* FIXME: Report unrecognised mode ? */
462 /* Display a symbol on stdout. Handles the display of control characters and
463 multibye characters (assuming the host environment supports them).
465 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
467 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
468 padding as necessary.
470 Returns the number of emitted characters. */
473 print_symbol (signed int width
, const char *symbol
)
475 bfd_boolean extra_padding
= FALSE
;
476 signed int num_printed
= 0;
477 #ifdef HAVE_MBSTATE_T
480 unsigned int width_remaining
;
484 /* Keep the width positive. This also helps. */
486 extra_padding
= TRUE
;
491 /* Set the remaining width to a very large value.
492 This simplifies the code below. */
493 width_remaining
= INT_MAX
;
495 width_remaining
= width
;
497 #ifdef HAVE_MBSTATE_T
498 /* Initialise the multibyte conversion state. */
499 memset (& state
, 0, sizeof (state
));
502 while (width_remaining
)
505 const char c
= *symbol
++;
510 /* Do not print control characters directly as they can affect terminal
511 settings. Such characters usually appear in the names generated
512 by the assembler for local labels. */
515 if (width_remaining
< 2)
518 printf ("^%c", c
+ 0x40);
519 width_remaining
-= 2;
522 else if (ISPRINT (c
))
530 #ifdef HAVE_MBSTATE_T
533 /* Let printf do the hard work of displaying multibyte characters. */
534 printf ("%.1s", symbol
- 1);
538 #ifdef HAVE_MBSTATE_T
539 /* Try to find out how many bytes made up the character that was
540 just printed. Advance the symbol pointer past the bytes that
542 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
546 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
551 if (extra_padding
&& num_printed
< width
)
553 /* Fill in the remaining spaces. */
554 printf ("%-*s", width
- num_printed
, " ");
561 /* Returns a pointer to a static buffer containing a printable version of
562 the given section's name. Like print_symbol, except that it does not try
563 to print multibyte characters, it just interprets them as hex values. */
566 printable_section_name (const Elf_Internal_Shdr
* sec
)
568 #define MAX_PRINT_SEC_NAME_LEN 128
569 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
570 const char * name
= SECTION_NAME (sec
);
571 char * buf
= sec_name_buf
;
573 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
575 while ((c
= * name
++) != 0)
586 else if (ISPRINT (c
))
593 static char hex
[17] = "0123456789ABCDEF";
598 * buf
++ = hex
[(c
& 0xf0) >> 4];
599 * buf
++ = hex
[c
& 0x0f];
613 printable_section_name_from_index (unsigned long ndx
)
615 if (ndx
>= elf_header
.e_shnum
)
616 return _("<corrupt>");
618 return printable_section_name (section_headers
+ ndx
);
621 /* Return a pointer to section NAME, or NULL if no such section exists. */
623 static Elf_Internal_Shdr
*
624 find_section (const char * name
)
628 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
629 if (streq (SECTION_NAME (section_headers
+ i
), name
))
630 return section_headers
+ i
;
635 /* Return a pointer to a section containing ADDR, or NULL if no such
638 static Elf_Internal_Shdr
*
639 find_section_by_address (bfd_vma addr
)
643 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
645 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
646 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
653 static Elf_Internal_Shdr
*
654 find_section_by_type (unsigned int type
)
658 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
660 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
661 if (sec
->sh_type
== type
)
668 /* Return a pointer to section NAME, or NULL if no such section exists,
669 restricted to the list of sections given in SET. */
671 static Elf_Internal_Shdr
*
672 find_section_in_set (const char * name
, unsigned int * set
)
678 while ((i
= *set
++) > 0)
680 /* See PR 21156 for a reproducer. */
681 if (i
>= elf_header
.e_shnum
)
682 continue; /* FIXME: Should we issue an error message ? */
684 if (streq (SECTION_NAME (section_headers
+ i
), name
))
685 return section_headers
+ i
;
689 return find_section (name
);
692 /* Read an unsigned LEB128 encoded value from DATA.
693 Set *LENGTH_RETURN to the number of bytes read. */
695 static inline unsigned long
696 read_uleb128 (unsigned char * data
,
697 unsigned int * length_return
,
698 const unsigned char * const end
)
700 return read_leb128 (data
, length_return
, FALSE
, end
);
703 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
704 This OS has so many departures from the ELF standard that we test it at
707 static inline bfd_boolean
710 return elf_header
.e_machine
== EM_IA_64
711 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
714 /* Guess the relocation size commonly used by the specific machines. */
717 guess_is_rela (unsigned int e_machine
)
721 /* Targets that use REL relocations. */
736 /* Targets that use RELA relocations. */
740 case EM_ADAPTEVA_EPIPHANY
:
742 case EM_ALTERA_NIOS2
:
745 case EM_ARC_COMPACT2
:
765 case EM_LATTICEMICO32
:
774 case EM_CYGNUS_MN10200
:
776 case EM_CYGNUS_MN10300
:
812 case EM_MICROBLAZE_OLD
:
834 warn (_("Don't know about relocations on this machine architecture\n"));
839 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
840 Returns TRUE upon success, FALSE otherwise. If successful then a
841 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
842 and the number of relocs loaded is placed in *NRELASP. It is the caller's
843 responsibility to free the allocated buffer. */
846 slurp_rela_relocs (FILE * file
,
847 unsigned long rel_offset
,
848 unsigned long rel_size
,
849 Elf_Internal_Rela
** relasp
,
850 unsigned long * nrelasp
)
852 Elf_Internal_Rela
* relas
;
858 Elf32_External_Rela
* erelas
;
860 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
861 rel_size
, _("32-bit relocation data"));
865 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
867 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
868 sizeof (Elf_Internal_Rela
));
873 error (_("out of memory parsing relocs\n"));
877 for (i
= 0; i
< nrelas
; i
++)
879 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
880 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
881 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
888 Elf64_External_Rela
* erelas
;
890 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
891 rel_size
, _("64-bit relocation data"));
895 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
897 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
898 sizeof (Elf_Internal_Rela
));
903 error (_("out of memory parsing relocs\n"));
907 for (i
= 0; i
< nrelas
; i
++)
909 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
910 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
911 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
913 /* The #ifdef BFD64 below is to prevent a compile time
914 warning. We know that if we do not have a 64 bit data
915 type that we will never execute this code anyway. */
917 if (elf_header
.e_machine
== EM_MIPS
918 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
920 /* In little-endian objects, r_info isn't really a
921 64-bit little-endian value: it has a 32-bit
922 little-endian symbol index followed by four
923 individual byte fields. Reorder INFO
925 bfd_vma inf
= relas
[i
].r_info
;
926 inf
= (((inf
& 0xffffffff) << 32)
927 | ((inf
>> 56) & 0xff)
928 | ((inf
>> 40) & 0xff00)
929 | ((inf
>> 24) & 0xff0000)
930 | ((inf
>> 8) & 0xff000000));
931 relas
[i
].r_info
= inf
;
944 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
945 Returns TRUE upon success, FALSE otherwise. If successful then a
946 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
947 and the number of relocs loaded is placed in *NRELSP. It is the caller's
948 responsibility to free the allocated buffer. */
951 slurp_rel_relocs (FILE * file
,
952 unsigned long rel_offset
,
953 unsigned long rel_size
,
954 Elf_Internal_Rela
** relsp
,
955 unsigned long * nrelsp
)
957 Elf_Internal_Rela
* rels
;
963 Elf32_External_Rel
* erels
;
965 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
966 rel_size
, _("32-bit relocation data"));
970 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
972 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
977 error (_("out of memory parsing relocs\n"));
981 for (i
= 0; i
< nrels
; i
++)
983 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
984 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
985 rels
[i
].r_addend
= 0;
992 Elf64_External_Rel
* erels
;
994 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
995 rel_size
, _("64-bit relocation data"));
999 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1001 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1006 error (_("out of memory parsing relocs\n"));
1010 for (i
= 0; i
< nrels
; i
++)
1012 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1013 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1014 rels
[i
].r_addend
= 0;
1016 /* The #ifdef BFD64 below is to prevent a compile time
1017 warning. We know that if we do not have a 64 bit data
1018 type that we will never execute this code anyway. */
1020 if (elf_header
.e_machine
== EM_MIPS
1021 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1023 /* In little-endian objects, r_info isn't really a
1024 64-bit little-endian value: it has a 32-bit
1025 little-endian symbol index followed by four
1026 individual byte fields. Reorder INFO
1028 bfd_vma inf
= rels
[i
].r_info
;
1029 inf
= (((inf
& 0xffffffff) << 32)
1030 | ((inf
>> 56) & 0xff)
1031 | ((inf
>> 40) & 0xff00)
1032 | ((inf
>> 24) & 0xff0000)
1033 | ((inf
>> 8) & 0xff000000));
1034 rels
[i
].r_info
= inf
;
1047 /* Returns the reloc type extracted from the reloc info field. */
1050 get_reloc_type (bfd_vma reloc_info
)
1053 return ELF32_R_TYPE (reloc_info
);
1055 switch (elf_header
.e_machine
)
1058 /* Note: We assume that reloc_info has already been adjusted for us. */
1059 return ELF64_MIPS_R_TYPE (reloc_info
);
1062 return ELF64_R_TYPE_ID (reloc_info
);
1065 return ELF64_R_TYPE (reloc_info
);
1069 /* Return the symbol index extracted from the reloc info field. */
1072 get_reloc_symindex (bfd_vma reloc_info
)
1074 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1077 static inline bfd_boolean
1078 uses_msp430x_relocs (void)
1081 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1082 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1083 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1084 /* TI compiler uses ELFOSABI_NONE. */
1085 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1088 /* Display the contents of the relocation data found at the specified
1092 dump_relocations (FILE * file
,
1093 unsigned long rel_offset
,
1094 unsigned long rel_size
,
1095 Elf_Internal_Sym
* symtab
,
1096 unsigned long nsyms
,
1098 unsigned long strtablen
,
1100 bfd_boolean is_dynsym
)
1103 Elf_Internal_Rela
* rels
;
1104 bfd_boolean res
= TRUE
;
1106 if (is_rela
== UNKNOWN
)
1107 is_rela
= guess_is_rela (elf_header
.e_machine
);
1111 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1116 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1125 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1127 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1132 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1134 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1142 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1144 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1149 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1151 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1155 for (i
= 0; i
< rel_size
; i
++)
1160 bfd_vma symtab_index
;
1163 offset
= rels
[i
].r_offset
;
1164 inf
= rels
[i
].r_info
;
1166 type
= get_reloc_type (inf
);
1167 symtab_index
= get_reloc_symindex (inf
);
1171 printf ("%8.8lx %8.8lx ",
1172 (unsigned long) offset
& 0xffffffff,
1173 (unsigned long) inf
& 0xffffffff);
1177 #if BFD_HOST_64BIT_LONG
1179 ? "%16.16lx %16.16lx "
1180 : "%12.12lx %12.12lx ",
1182 #elif BFD_HOST_64BIT_LONG_LONG
1185 ? "%16.16llx %16.16llx "
1186 : "%12.12llx %12.12llx ",
1190 ? "%16.16I64x %16.16I64x "
1191 : "%12.12I64x %12.12I64x ",
1196 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1197 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1198 _bfd_int64_high (offset
),
1199 _bfd_int64_low (offset
),
1200 _bfd_int64_high (inf
),
1201 _bfd_int64_low (inf
));
1205 switch (elf_header
.e_machine
)
1212 rtype
= elf_aarch64_reloc_type (type
);
1216 case EM_CYGNUS_M32R
:
1217 rtype
= elf_m32r_reloc_type (type
);
1222 rtype
= elf_i386_reloc_type (type
);
1227 rtype
= elf_m68hc11_reloc_type (type
);
1231 rtype
= elf_m68k_reloc_type (type
);
1235 rtype
= elf_i960_reloc_type (type
);
1240 rtype
= elf_avr_reloc_type (type
);
1243 case EM_OLD_SPARCV9
:
1244 case EM_SPARC32PLUS
:
1247 rtype
= elf_sparc_reloc_type (type
);
1251 rtype
= elf_spu_reloc_type (type
);
1255 rtype
= v800_reloc_type (type
);
1258 case EM_CYGNUS_V850
:
1259 rtype
= v850_reloc_type (type
);
1263 case EM_CYGNUS_D10V
:
1264 rtype
= elf_d10v_reloc_type (type
);
1268 case EM_CYGNUS_D30V
:
1269 rtype
= elf_d30v_reloc_type (type
);
1273 rtype
= elf_dlx_reloc_type (type
);
1277 rtype
= elf_sh_reloc_type (type
);
1281 case EM_CYGNUS_MN10300
:
1282 rtype
= elf_mn10300_reloc_type (type
);
1286 case EM_CYGNUS_MN10200
:
1287 rtype
= elf_mn10200_reloc_type (type
);
1291 case EM_CYGNUS_FR30
:
1292 rtype
= elf_fr30_reloc_type (type
);
1296 rtype
= elf_frv_reloc_type (type
);
1300 rtype
= elf_ft32_reloc_type (type
);
1304 rtype
= elf_mcore_reloc_type (type
);
1308 rtype
= elf_mmix_reloc_type (type
);
1312 rtype
= elf_moxie_reloc_type (type
);
1316 if (uses_msp430x_relocs ())
1318 rtype
= elf_msp430x_reloc_type (type
);
1323 rtype
= elf_msp430_reloc_type (type
);
1327 rtype
= elf_nds32_reloc_type (type
);
1331 rtype
= elf_ppc_reloc_type (type
);
1335 rtype
= elf_ppc64_reloc_type (type
);
1339 case EM_MIPS_RS3_LE
:
1340 rtype
= elf_mips_reloc_type (type
);
1344 rtype
= elf_riscv_reloc_type (type
);
1348 rtype
= elf_alpha_reloc_type (type
);
1352 rtype
= elf_arm_reloc_type (type
);
1356 case EM_ARC_COMPACT
:
1357 case EM_ARC_COMPACT2
:
1358 rtype
= elf_arc_reloc_type (type
);
1362 rtype
= elf_hppa_reloc_type (type
);
1368 rtype
= elf_h8_reloc_type (type
);
1372 rtype
= elf_or1k_reloc_type (type
);
1377 rtype
= elf_pj_reloc_type (type
);
1380 rtype
= elf_ia64_reloc_type (type
);
1384 rtype
= elf_cris_reloc_type (type
);
1388 rtype
= elf_i860_reloc_type (type
);
1394 rtype
= elf_x86_64_reloc_type (type
);
1398 rtype
= i370_reloc_type (type
);
1403 rtype
= elf_s390_reloc_type (type
);
1407 rtype
= elf_score_reloc_type (type
);
1411 rtype
= elf_xstormy16_reloc_type (type
);
1415 rtype
= elf_crx_reloc_type (type
);
1419 rtype
= elf_vax_reloc_type (type
);
1423 rtype
= elf_visium_reloc_type (type
);
1426 case EM_ADAPTEVA_EPIPHANY
:
1427 rtype
= elf_epiphany_reloc_type (type
);
1432 rtype
= elf_ip2k_reloc_type (type
);
1436 rtype
= elf_iq2000_reloc_type (type
);
1441 rtype
= elf_xtensa_reloc_type (type
);
1444 case EM_LATTICEMICO32
:
1445 rtype
= elf_lm32_reloc_type (type
);
1450 rtype
= elf_m32c_reloc_type (type
);
1454 rtype
= elf_mt_reloc_type (type
);
1458 rtype
= elf_bfin_reloc_type (type
);
1462 rtype
= elf_mep_reloc_type (type
);
1466 rtype
= elf_cr16_reloc_type (type
);
1470 case EM_MICROBLAZE_OLD
:
1471 rtype
= elf_microblaze_reloc_type (type
);
1475 rtype
= elf_rl78_reloc_type (type
);
1479 rtype
= elf_rx_reloc_type (type
);
1483 rtype
= elf_metag_reloc_type (type
);
1488 rtype
= elf_xc16x_reloc_type (type
);
1492 rtype
= elf_tic6x_reloc_type (type
);
1496 rtype
= elf_tilegx_reloc_type (type
);
1500 rtype
= elf_tilepro_reloc_type (type
);
1503 case EM_WEBASSEMBLY
:
1504 rtype
= elf_wasm32_reloc_type (type
);
1508 rtype
= elf_xgate_reloc_type (type
);
1511 case EM_ALTERA_NIOS2
:
1512 rtype
= elf_nios2_reloc_type (type
);
1516 rtype
= elf_pru_reloc_type (type
);
1521 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1523 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1525 if (elf_header
.e_machine
== EM_ALPHA
1527 && streq (rtype
, "R_ALPHA_LITUSE")
1530 switch (rels
[i
].r_addend
)
1532 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1533 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1534 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1535 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1536 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1537 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1538 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1539 default: rtype
= NULL
;
1543 printf (" (%s)", rtype
);
1547 printf (_("<unknown addend: %lx>"),
1548 (unsigned long) rels
[i
].r_addend
);
1552 else if (symtab_index
)
1554 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1556 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1561 Elf_Internal_Sym
* psym
;
1562 const char * version_string
;
1563 enum versioned_symbol_info sym_info
;
1564 unsigned short vna_other
;
1566 psym
= symtab
+ symtab_index
;
1569 = get_symbol_version_string (file
, is_dynsym
,
1578 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1582 unsigned int width
= is_32bit_elf
? 8 : 14;
1584 /* Relocations against GNU_IFUNC symbols do not use the value
1585 of the symbol as the address to relocate against. Instead
1586 they invoke the function named by the symbol and use its
1587 result as the address for relocation.
1589 To indicate this to the user, do not display the value of
1590 the symbol in the "Symbols's Value" field. Instead show
1591 its name followed by () as a hint that the symbol is
1595 || psym
->st_name
== 0
1596 || psym
->st_name
>= strtablen
)
1599 name
= strtab
+ psym
->st_name
;
1601 len
= print_symbol (width
, name
);
1603 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1605 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1609 print_vma (psym
->st_value
, LONG_HEX
);
1611 printf (is_32bit_elf
? " " : " ");
1614 if (psym
->st_name
== 0)
1616 const char * sec_name
= "<null>";
1619 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1621 if (psym
->st_shndx
< elf_header
.e_shnum
)
1622 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1623 else if (psym
->st_shndx
== SHN_ABS
)
1625 else if (psym
->st_shndx
== SHN_COMMON
)
1626 sec_name
= "COMMON";
1627 else if ((elf_header
.e_machine
== EM_MIPS
1628 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1629 || (elf_header
.e_machine
== EM_TI_C6000
1630 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1631 sec_name
= "SCOMMON";
1632 else if (elf_header
.e_machine
== EM_MIPS
1633 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1634 sec_name
= "SUNDEF";
1635 else if ((elf_header
.e_machine
== EM_X86_64
1636 || elf_header
.e_machine
== EM_L1OM
1637 || elf_header
.e_machine
== EM_K1OM
)
1638 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1639 sec_name
= "LARGE_COMMON";
1640 else if (elf_header
.e_machine
== EM_IA_64
1641 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1642 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1643 sec_name
= "ANSI_COM";
1644 else if (is_ia64_vms ()
1645 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1646 sec_name
= "VMS_SYMVEC";
1649 sprintf (name_buf
, "<section 0x%x>",
1650 (unsigned int) psym
->st_shndx
);
1651 sec_name
= name_buf
;
1654 print_symbol (22, sec_name
);
1656 else if (strtab
== NULL
)
1657 printf (_("<string table index: %3ld>"), psym
->st_name
);
1658 else if (psym
->st_name
>= strtablen
)
1660 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1665 print_symbol (22, strtab
+ psym
->st_name
);
1667 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1673 bfd_vma off
= rels
[i
].r_addend
;
1675 if ((bfd_signed_vma
) off
< 0)
1676 printf (" - %" BFD_VMA_FMT
"x", - off
);
1678 printf (" + %" BFD_VMA_FMT
"x", off
);
1684 bfd_vma off
= rels
[i
].r_addend
;
1686 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1687 if ((bfd_signed_vma
) off
< 0)
1688 printf ("-%" BFD_VMA_FMT
"x", - off
);
1690 printf ("%" BFD_VMA_FMT
"x", off
);
1693 if (elf_header
.e_machine
== EM_SPARCV9
1695 && streq (rtype
, "R_SPARC_OLO10"))
1696 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1701 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1703 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1704 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1705 const char * rtype2
= elf_mips_reloc_type (type2
);
1706 const char * rtype3
= elf_mips_reloc_type (type3
);
1708 printf (" Type2: ");
1711 printf (_("unrecognized: %-7lx"),
1712 (unsigned long) type2
& 0xffffffff);
1714 printf ("%-17.17s", rtype2
);
1716 printf ("\n Type3: ");
1719 printf (_("unrecognized: %-7lx"),
1720 (unsigned long) type3
& 0xffffffff);
1722 printf ("%-17.17s", rtype3
);
1735 get_mips_dynamic_type (unsigned long type
)
1739 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1740 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1741 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1742 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1743 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1744 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1745 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1746 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1747 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1748 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1749 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1750 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1751 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1752 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1753 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1754 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1755 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1756 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1757 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1758 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1759 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1760 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1761 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1762 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1763 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1764 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1765 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1766 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1767 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1768 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1769 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1770 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1771 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1772 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1773 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1774 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1775 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1776 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1777 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1778 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1779 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1780 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1781 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1782 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1783 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1784 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1791 get_sparc64_dynamic_type (unsigned long type
)
1795 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1802 get_ppc_dynamic_type (unsigned long type
)
1806 case DT_PPC_GOT
: return "PPC_GOT";
1807 case DT_PPC_OPT
: return "PPC_OPT";
1814 get_ppc64_dynamic_type (unsigned long type
)
1818 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1819 case DT_PPC64_OPD
: return "PPC64_OPD";
1820 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1821 case DT_PPC64_OPT
: return "PPC64_OPT";
1828 get_parisc_dynamic_type (unsigned long type
)
1832 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1833 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1834 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1835 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1836 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1837 case DT_HP_PREINIT
: return "HP_PREINIT";
1838 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1839 case DT_HP_NEEDED
: return "HP_NEEDED";
1840 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1841 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1842 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1843 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1844 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1845 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1846 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1847 case DT_HP_FILTERED
: return "HP_FILTERED";
1848 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1849 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1850 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1851 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1852 case DT_PLT
: return "PLT";
1853 case DT_PLT_SIZE
: return "PLT_SIZE";
1854 case DT_DLT
: return "DLT";
1855 case DT_DLT_SIZE
: return "DLT_SIZE";
1862 get_ia64_dynamic_type (unsigned long type
)
1866 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1867 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1868 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1869 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1870 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1871 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1872 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1873 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1874 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1875 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1876 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1877 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1878 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1879 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1880 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1881 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1882 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1883 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1884 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1885 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1886 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1887 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1888 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1889 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1890 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1891 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1892 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1893 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1894 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1895 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1896 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1903 get_solaris_section_type (unsigned long type
)
1907 case 0x6fffffee: return "SUNW_ancillary";
1908 case 0x6fffffef: return "SUNW_capchain";
1909 case 0x6ffffff0: return "SUNW_capinfo";
1910 case 0x6ffffff1: return "SUNW_symsort";
1911 case 0x6ffffff2: return "SUNW_tlssort";
1912 case 0x6ffffff3: return "SUNW_LDYNSYM";
1913 case 0x6ffffff4: return "SUNW_dof";
1914 case 0x6ffffff5: return "SUNW_cap";
1915 case 0x6ffffff6: return "SUNW_SIGNATURE";
1916 case 0x6ffffff7: return "SUNW_ANNOTATE";
1917 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1918 case 0x6ffffff9: return "SUNW_DEBUG";
1919 case 0x6ffffffa: return "SUNW_move";
1920 case 0x6ffffffb: return "SUNW_COMDAT";
1921 case 0x6ffffffc: return "SUNW_syminfo";
1922 case 0x6ffffffd: return "SUNW_verdef";
1923 case 0x6ffffffe: return "SUNW_verneed";
1924 case 0x6fffffff: return "SUNW_versym";
1925 case 0x70000000: return "SPARC_GOTDATA";
1926 default: return NULL
;
1931 get_alpha_dynamic_type (unsigned long type
)
1935 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1936 default: return NULL
;
1941 get_score_dynamic_type (unsigned long type
)
1945 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1946 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1947 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1948 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1949 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1950 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1951 default: return NULL
;
1956 get_tic6x_dynamic_type (unsigned long type
)
1960 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1961 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1962 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1963 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1964 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1965 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1966 default: return NULL
;
1971 get_nios2_dynamic_type (unsigned long type
)
1975 case DT_NIOS2_GP
: return "NIOS2_GP";
1976 default: return NULL
;
1981 get_solaris_dynamic_type (unsigned long type
)
1985 case 0x6000000d: return "SUNW_AUXILIARY";
1986 case 0x6000000e: return "SUNW_RTLDINF";
1987 case 0x6000000f: return "SUNW_FILTER";
1988 case 0x60000010: return "SUNW_CAP";
1989 case 0x60000011: return "SUNW_SYMTAB";
1990 case 0x60000012: return "SUNW_SYMSZ";
1991 case 0x60000013: return "SUNW_SORTENT";
1992 case 0x60000014: return "SUNW_SYMSORT";
1993 case 0x60000015: return "SUNW_SYMSORTSZ";
1994 case 0x60000016: return "SUNW_TLSSORT";
1995 case 0x60000017: return "SUNW_TLSSORTSZ";
1996 case 0x60000018: return "SUNW_CAPINFO";
1997 case 0x60000019: return "SUNW_STRPAD";
1998 case 0x6000001a: return "SUNW_CAPCHAIN";
1999 case 0x6000001b: return "SUNW_LDMACH";
2000 case 0x6000001d: return "SUNW_CAPCHAINENT";
2001 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2002 case 0x60000021: return "SUNW_PARENT";
2003 case 0x60000023: return "SUNW_ASLR";
2004 case 0x60000025: return "SUNW_RELAX";
2005 case 0x60000029: return "SUNW_NXHEAP";
2006 case 0x6000002b: return "SUNW_NXSTACK";
2008 case 0x70000001: return "SPARC_REGISTER";
2009 case 0x7ffffffd: return "AUXILIARY";
2010 case 0x7ffffffe: return "USED";
2011 case 0x7fffffff: return "FILTER";
2013 default: return NULL
;
2018 get_dynamic_type (unsigned long type
)
2020 static char buff
[64];
2024 case DT_NULL
: return "NULL";
2025 case DT_NEEDED
: return "NEEDED";
2026 case DT_PLTRELSZ
: return "PLTRELSZ";
2027 case DT_PLTGOT
: return "PLTGOT";
2028 case DT_HASH
: return "HASH";
2029 case DT_STRTAB
: return "STRTAB";
2030 case DT_SYMTAB
: return "SYMTAB";
2031 case DT_RELA
: return "RELA";
2032 case DT_RELASZ
: return "RELASZ";
2033 case DT_RELAENT
: return "RELAENT";
2034 case DT_STRSZ
: return "STRSZ";
2035 case DT_SYMENT
: return "SYMENT";
2036 case DT_INIT
: return "INIT";
2037 case DT_FINI
: return "FINI";
2038 case DT_SONAME
: return "SONAME";
2039 case DT_RPATH
: return "RPATH";
2040 case DT_SYMBOLIC
: return "SYMBOLIC";
2041 case DT_REL
: return "REL";
2042 case DT_RELSZ
: return "RELSZ";
2043 case DT_RELENT
: return "RELENT";
2044 case DT_PLTREL
: return "PLTREL";
2045 case DT_DEBUG
: return "DEBUG";
2046 case DT_TEXTREL
: return "TEXTREL";
2047 case DT_JMPREL
: return "JMPREL";
2048 case DT_BIND_NOW
: return "BIND_NOW";
2049 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2050 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2051 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2052 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2053 case DT_RUNPATH
: return "RUNPATH";
2054 case DT_FLAGS
: return "FLAGS";
2056 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2057 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2058 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2060 case DT_CHECKSUM
: return "CHECKSUM";
2061 case DT_PLTPADSZ
: return "PLTPADSZ";
2062 case DT_MOVEENT
: return "MOVEENT";
2063 case DT_MOVESZ
: return "MOVESZ";
2064 case DT_FEATURE
: return "FEATURE";
2065 case DT_POSFLAG_1
: return "POSFLAG_1";
2066 case DT_SYMINSZ
: return "SYMINSZ";
2067 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2069 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2070 case DT_CONFIG
: return "CONFIG";
2071 case DT_DEPAUDIT
: return "DEPAUDIT";
2072 case DT_AUDIT
: return "AUDIT";
2073 case DT_PLTPAD
: return "PLTPAD";
2074 case DT_MOVETAB
: return "MOVETAB";
2075 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2077 case DT_VERSYM
: return "VERSYM";
2079 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2080 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2081 case DT_RELACOUNT
: return "RELACOUNT";
2082 case DT_RELCOUNT
: return "RELCOUNT";
2083 case DT_FLAGS_1
: return "FLAGS_1";
2084 case DT_VERDEF
: return "VERDEF";
2085 case DT_VERDEFNUM
: return "VERDEFNUM";
2086 case DT_VERNEED
: return "VERNEED";
2087 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2089 case DT_AUXILIARY
: return "AUXILIARY";
2090 case DT_USED
: return "USED";
2091 case DT_FILTER
: return "FILTER";
2093 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2094 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2095 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2096 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2097 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2098 case DT_GNU_HASH
: return "GNU_HASH";
2101 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2103 const char * result
;
2105 switch (elf_header
.e_machine
)
2108 case EM_MIPS_RS3_LE
:
2109 result
= get_mips_dynamic_type (type
);
2112 result
= get_sparc64_dynamic_type (type
);
2115 result
= get_ppc_dynamic_type (type
);
2118 result
= get_ppc64_dynamic_type (type
);
2121 result
= get_ia64_dynamic_type (type
);
2124 result
= get_alpha_dynamic_type (type
);
2127 result
= get_score_dynamic_type (type
);
2130 result
= get_tic6x_dynamic_type (type
);
2132 case EM_ALTERA_NIOS2
:
2133 result
= get_nios2_dynamic_type (type
);
2136 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2137 result
= get_solaris_dynamic_type (type
);
2146 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2148 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2149 || (elf_header
.e_machine
== EM_PARISC
2150 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2152 const char * result
;
2154 switch (elf_header
.e_machine
)
2157 result
= get_parisc_dynamic_type (type
);
2160 result
= get_ia64_dynamic_type (type
);
2163 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2164 result
= get_solaris_dynamic_type (type
);
2173 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2177 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2184 get_file_type (unsigned e_type
)
2186 static char buff
[32];
2190 case ET_NONE
: return _("NONE (None)");
2191 case ET_REL
: return _("REL (Relocatable file)");
2192 case ET_EXEC
: return _("EXEC (Executable file)");
2193 case ET_DYN
: return _("DYN (Shared object file)");
2194 case ET_CORE
: return _("CORE (Core file)");
2197 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2198 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2199 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2200 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2202 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2208 get_machine_name (unsigned e_machine
)
2210 static char buff
[64]; /* XXX */
2214 /* Please keep this switch table sorted by increasing EM_ value. */
2216 case EM_NONE
: return _("None");
2217 case EM_M32
: return "WE32100";
2218 case EM_SPARC
: return "Sparc";
2219 case EM_386
: return "Intel 80386";
2220 case EM_68K
: return "MC68000";
2221 case EM_88K
: return "MC88000";
2222 case EM_IAMCU
: return "Intel MCU";
2223 case EM_860
: return "Intel 80860";
2224 case EM_MIPS
: return "MIPS R3000";
2225 case EM_S370
: return "IBM System/370";
2227 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2228 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2229 case EM_PARISC
: return "HPPA";
2230 case EM_VPP550
: return "Fujitsu VPP500";
2231 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2232 case EM_960
: return "Intel 90860";
2233 case EM_PPC
: return "PowerPC";
2235 case EM_PPC64
: return "PowerPC64";
2237 case EM_S390
: return "IBM S/390";
2238 case EM_SPU
: return "SPU";
2240 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2241 case EM_FR20
: return "Fujitsu FR20";
2242 case EM_RH32
: return "TRW RH32";
2243 case EM_MCORE
: return "MCORE";
2245 case EM_ARM
: return "ARM";
2246 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2247 case EM_SH
: return "Renesas / SuperH SH";
2248 case EM_SPARCV9
: return "Sparc v9";
2249 case EM_TRICORE
: return "Siemens Tricore";
2250 case EM_ARC
: return "ARC";
2251 case EM_H8_300
: return "Renesas H8/300";
2252 case EM_H8_300H
: return "Renesas H8/300H";
2253 case EM_H8S
: return "Renesas H8S";
2254 case EM_H8_500
: return "Renesas H8/500";
2256 case EM_IA_64
: return "Intel IA-64";
2257 case EM_MIPS_X
: return "Stanford MIPS-X";
2258 case EM_COLDFIRE
: return "Motorola Coldfire";
2259 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2260 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2261 case EM_PCP
: return "Siemens PCP";
2262 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2263 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2264 case EM_STARCORE
: return "Motorola Star*Core processor";
2265 case EM_ME16
: return "Toyota ME16 processor";
2267 case EM_ST100
: return "STMicroelectronics ST100 processor";
2268 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2269 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2270 case EM_PDSP
: return "Sony DSP processor";
2271 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2272 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2273 case EM_FX66
: return "Siemens FX66 microcontroller";
2274 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2275 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2276 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2278 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2279 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2280 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2281 case EM_SVX
: return "Silicon Graphics SVx";
2282 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2283 case EM_VAX
: return "Digital VAX";
2284 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2285 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2286 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2287 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2289 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2290 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2291 case EM_PRISM
: return "Vitesse Prism";
2293 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2294 case EM_CYGNUS_FR30
:
2295 case EM_FR30
: return "Fujitsu FR30";
2296 case EM_CYGNUS_D10V
:
2297 case EM_D10V
: return "d10v";
2298 case EM_CYGNUS_D30V
:
2299 case EM_D30V
: return "d30v";
2300 case EM_CYGNUS_V850
:
2301 case EM_V850
: return "Renesas V850";
2302 case EM_CYGNUS_M32R
:
2303 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2304 case EM_CYGNUS_MN10300
:
2305 case EM_MN10300
: return "mn10300";
2307 case EM_CYGNUS_MN10200
:
2308 case EM_MN10200
: return "mn10200";
2309 case EM_PJ
: return "picoJava";
2310 case EM_OR1K
: return "OpenRISC 1000";
2311 case EM_ARC_COMPACT
: return "ARCompact";
2313 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2314 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2315 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2316 case EM_NS32K
: return "National Semiconductor 32000 series";
2317 case EM_TPC
: return "Tenor Network TPC processor";
2318 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2320 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2322 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2323 case EM_MAX
: return "MAX Processor";
2324 case EM_CR
: return "National Semiconductor CompactRISC";
2325 case EM_F2MC16
: return "Fujitsu F2MC16";
2326 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2327 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2328 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2329 case EM_SEP
: return "Sharp embedded microprocessor";
2330 case EM_ARCA
: return "Arca RISC microprocessor";
2332 case EM_UNICORE
: return "Unicore";
2333 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2334 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2335 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2336 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2337 case EM_XGATE
: return "Motorola XGATE embedded processor";
2339 case EM_XC16X
: return "Infineon Technologies xc16x";
2340 case EM_M16C
: return "Renesas M16C series microprocessors";
2341 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2342 case EM_CE
: return "Freescale Communication Engine RISC core";
2344 case EM_M32C
: return "Renesas M32c";
2346 case EM_TSK3000
: return "Altium TSK3000 core";
2347 case EM_RS08
: return "Freescale RS08 embedded processor";
2348 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2349 case EM_SCORE
: return "SUNPLUS S+Core";
2350 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2351 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2352 case EM_LATTICEMICO32
: return "Lattice Mico32";
2353 case EM_SE_C17
: return "Seiko Epson C17 family";
2355 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2356 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2357 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2358 case EM_TI_PRU
: return "TI PRU I/O processor";
2360 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2361 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2362 case EM_R32C
: return "Renesas R32C series microprocessors";
2363 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2364 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2365 case EM_8051
: return "Intel 8051 and variants";
2366 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2367 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2368 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2369 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2371 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2372 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2373 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2374 case EM_RX
: return "Renesas RX";
2375 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2376 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2377 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2380 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2381 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2382 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2384 case EM_L1OM
: return "Intel L1OM";
2385 case EM_K1OM
: return "Intel K1OM";
2386 case EM_INTEL182
: return "Intel (reserved)";
2387 case EM_AARCH64
: return "AArch64";
2388 case EM_ARM184
: return "ARM (reserved)";
2389 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2390 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2391 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2392 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2394 case EM_CUDA
: return "NVIDIA CUDA architecture";
2395 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2396 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2397 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2398 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2399 case EM_ARC_COMPACT2
: return "ARCv2";
2400 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2401 case EM_RL78
: return "Renesas RL78";
2402 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2403 case EM_78K0R
: return "Renesas 78K0R";
2405 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2406 case EM_BA1
: return "Beyond BA1 CPU architecture";
2407 case EM_BA2
: return "Beyond BA2 CPU architecture";
2408 case EM_XCORE
: return "XMOS xCORE processor family";
2409 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2411 case EM_KM32
: return "KM211 KM32 32-bit processor";
2412 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2413 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2414 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2415 case EM_KVARC
: return "KM211 KVARC processor";
2416 case EM_CDP
: return "Paneve CDP architecture family";
2417 case EM_COGE
: return "Cognitive Smart Memory Processor";
2418 case EM_COOL
: return "Bluechip Systems CoolEngine";
2419 case EM_NORC
: return "Nanoradio Optimized RISC";
2420 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2422 case EM_Z80
: return "Zilog Z80";
2423 case EM_VISIUM
: return "CDS VISIUMcore processor";
2424 case EM_FT32
: return "FTDI Chip FT32";
2425 case EM_MOXIE
: return "Moxie";
2426 case EM_AMDGPU
: return "AMD GPU";
2427 case EM_RISCV
: return "RISC-V";
2428 case EM_LANAI
: return "Lanai 32-bit processor";
2429 case EM_BPF
: return "Linux BPF";
2431 /* Large numbers... */
2432 case EM_MT
: return "Morpho Techologies MT processor";
2433 case EM_ALPHA
: return "Alpha";
2434 case EM_WEBASSEMBLY
: return "Web Assembly";
2435 case EM_DLX
: return "OpenDLX";
2436 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2437 case EM_IQ2000
: return "Vitesse IQ2000";
2439 case EM_NIOS32
: return "Altera Nios";
2440 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2441 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2442 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2445 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2451 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2453 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2454 other compilers don't a specific architecture type in the e_flags, and
2455 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2456 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2459 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2460 but also sets a specific architecture type in the e_flags field.
2462 However, when decoding the flags we don't worry if we see an
2463 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2464 ARCEM architecture type. */
2466 switch (e_flags
& EF_ARC_MACH_MSK
)
2468 /* We only expect these to occur for EM_ARC_COMPACT2. */
2469 case EF_ARC_CPU_ARCV2EM
:
2470 strcat (buf
, ", ARC EM");
2472 case EF_ARC_CPU_ARCV2HS
:
2473 strcat (buf
, ", ARC HS");
2476 /* We only expect these to occur for EM_ARC_COMPACT. */
2477 case E_ARC_MACH_ARC600
:
2478 strcat (buf
, ", ARC600");
2480 case E_ARC_MACH_ARC601
:
2481 strcat (buf
, ", ARC601");
2483 case E_ARC_MACH_ARC700
:
2484 strcat (buf
, ", ARC700");
2487 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2488 new ELF with new architecture being read by an old version of
2489 readelf, or (c) An ELF built with non-GNU compiler that does not
2490 set the architecture in the e_flags. */
2492 if (e_machine
== EM_ARC_COMPACT
)
2493 strcat (buf
, ", Unknown ARCompact");
2495 strcat (buf
, ", Unknown ARC");
2499 switch (e_flags
& EF_ARC_OSABI_MSK
)
2501 case E_ARC_OSABI_ORIG
:
2502 strcat (buf
, ", (ABI:legacy)");
2504 case E_ARC_OSABI_V2
:
2505 strcat (buf
, ", (ABI:v2)");
2507 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2508 case E_ARC_OSABI_V3
:
2509 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2511 case E_ARC_OSABI_V4
:
2512 strcat (buf
, ", v4 ABI");
2515 strcat (buf
, ", unrecognised ARC OSABI flag");
2521 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2524 bfd_boolean unknown
= FALSE
;
2526 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2527 e_flags
&= ~ EF_ARM_EABIMASK
;
2529 /* Handle "generic" ARM flags. */
2530 if (e_flags
& EF_ARM_RELEXEC
)
2532 strcat (buf
, ", relocatable executable");
2533 e_flags
&= ~ EF_ARM_RELEXEC
;
2536 /* Now handle EABI specific flags. */
2540 strcat (buf
, ", <unrecognized EABI>");
2545 case EF_ARM_EABI_VER1
:
2546 strcat (buf
, ", Version1 EABI");
2551 /* Process flags one bit at a time. */
2552 flag
= e_flags
& - e_flags
;
2557 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2558 strcat (buf
, ", sorted symbol tables");
2568 case EF_ARM_EABI_VER2
:
2569 strcat (buf
, ", Version2 EABI");
2574 /* Process flags one bit at a time. */
2575 flag
= e_flags
& - e_flags
;
2580 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2581 strcat (buf
, ", sorted symbol tables");
2584 case EF_ARM_DYNSYMSUSESEGIDX
:
2585 strcat (buf
, ", dynamic symbols use segment index");
2588 case EF_ARM_MAPSYMSFIRST
:
2589 strcat (buf
, ", mapping symbols precede others");
2599 case EF_ARM_EABI_VER3
:
2600 strcat (buf
, ", Version3 EABI");
2603 case EF_ARM_EABI_VER4
:
2604 strcat (buf
, ", Version4 EABI");
2609 /* Process flags one bit at a time. */
2610 flag
= e_flags
& - e_flags
;
2616 strcat (buf
, ", BE8");
2620 strcat (buf
, ", LE8");
2630 case EF_ARM_EABI_VER5
:
2631 strcat (buf
, ", Version5 EABI");
2636 /* Process flags one bit at a time. */
2637 flag
= e_flags
& - e_flags
;
2643 strcat (buf
, ", BE8");
2647 strcat (buf
, ", LE8");
2650 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2651 strcat (buf
, ", soft-float ABI");
2654 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2655 strcat (buf
, ", hard-float ABI");
2665 case EF_ARM_EABI_UNKNOWN
:
2666 strcat (buf
, ", GNU EABI");
2671 /* Process flags one bit at a time. */
2672 flag
= e_flags
& - e_flags
;
2677 case EF_ARM_INTERWORK
:
2678 strcat (buf
, ", interworking enabled");
2681 case EF_ARM_APCS_26
:
2682 strcat (buf
, ", uses APCS/26");
2685 case EF_ARM_APCS_FLOAT
:
2686 strcat (buf
, ", uses APCS/float");
2690 strcat (buf
, ", position independent");
2694 strcat (buf
, ", 8 bit structure alignment");
2697 case EF_ARM_NEW_ABI
:
2698 strcat (buf
, ", uses new ABI");
2701 case EF_ARM_OLD_ABI
:
2702 strcat (buf
, ", uses old ABI");
2705 case EF_ARM_SOFT_FLOAT
:
2706 strcat (buf
, ", software FP");
2709 case EF_ARM_VFP_FLOAT
:
2710 strcat (buf
, ", VFP");
2713 case EF_ARM_MAVERICK_FLOAT
:
2714 strcat (buf
, ", Maverick FP");
2725 strcat (buf
,_(", <unknown>"));
2729 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2731 --size
; /* Leave space for null terminator. */
2733 switch (e_flags
& EF_AVR_MACH
)
2735 case E_AVR_MACH_AVR1
:
2736 strncat (buf
, ", avr:1", size
);
2738 case E_AVR_MACH_AVR2
:
2739 strncat (buf
, ", avr:2", size
);
2741 case E_AVR_MACH_AVR25
:
2742 strncat (buf
, ", avr:25", size
);
2744 case E_AVR_MACH_AVR3
:
2745 strncat (buf
, ", avr:3", size
);
2747 case E_AVR_MACH_AVR31
:
2748 strncat (buf
, ", avr:31", size
);
2750 case E_AVR_MACH_AVR35
:
2751 strncat (buf
, ", avr:35", size
);
2753 case E_AVR_MACH_AVR4
:
2754 strncat (buf
, ", avr:4", size
);
2756 case E_AVR_MACH_AVR5
:
2757 strncat (buf
, ", avr:5", size
);
2759 case E_AVR_MACH_AVR51
:
2760 strncat (buf
, ", avr:51", size
);
2762 case E_AVR_MACH_AVR6
:
2763 strncat (buf
, ", avr:6", size
);
2765 case E_AVR_MACH_AVRTINY
:
2766 strncat (buf
, ", avr:100", size
);
2768 case E_AVR_MACH_XMEGA1
:
2769 strncat (buf
, ", avr:101", size
);
2771 case E_AVR_MACH_XMEGA2
:
2772 strncat (buf
, ", avr:102", size
);
2774 case E_AVR_MACH_XMEGA3
:
2775 strncat (buf
, ", avr:103", size
);
2777 case E_AVR_MACH_XMEGA4
:
2778 strncat (buf
, ", avr:104", size
);
2780 case E_AVR_MACH_XMEGA5
:
2781 strncat (buf
, ", avr:105", size
);
2783 case E_AVR_MACH_XMEGA6
:
2784 strncat (buf
, ", avr:106", size
);
2786 case E_AVR_MACH_XMEGA7
:
2787 strncat (buf
, ", avr:107", size
);
2790 strncat (buf
, ", avr:<unknown>", size
);
2794 size
-= strlen (buf
);
2795 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2796 strncat (buf
, ", link-relax", size
);
2800 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2806 bfd_boolean has_fpu
= FALSE
;
2809 static const char *ABI_STRINGS
[] =
2811 "ABI v0", /* use r5 as return register; only used in N1213HC */
2812 "ABI v1", /* use r0 as return register */
2813 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2814 "ABI v2fp", /* for FPU */
2818 static const char *VER_STRINGS
[] =
2820 "Andes ELF V1.3 or older",
2824 static const char *ARCH_STRINGS
[] =
2833 abi
= EF_NDS_ABI
& e_flags
;
2834 arch
= EF_NDS_ARCH
& e_flags
;
2835 config
= EF_NDS_INST
& e_flags
;
2836 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2838 memset (buf
, 0, size
);
2845 case E_NDS_ABI_V2FP
:
2846 case E_NDS_ABI_AABI
:
2847 case E_NDS_ABI_V2FP_PLUS
:
2848 /* In case there are holes in the array. */
2849 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2853 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2859 case E_NDS32_ELF_VER_1_2
:
2860 case E_NDS32_ELF_VER_1_3
:
2861 case E_NDS32_ELF_VER_1_4
:
2862 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2866 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2870 if (E_NDS_ABI_V0
== abi
)
2872 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2873 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2874 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2875 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2881 case E_NDS_ARCH_STAR_V1_0
:
2882 case E_NDS_ARCH_STAR_V2_0
:
2883 case E_NDS_ARCH_STAR_V3_0
:
2884 case E_NDS_ARCH_STAR_V3_M
:
2885 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2889 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2890 /* ARCH version determines how the e_flags are interpreted.
2891 If it is unknown, we cannot proceed. */
2895 /* Newer ABI; Now handle architecture specific flags. */
2896 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2898 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2899 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2901 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2902 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2904 if (config
& E_NDS32_HAS_DIV_INST
)
2905 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2907 if (config
& E_NDS32_HAS_16BIT_INST
)
2908 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2912 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2914 if (version
<= E_NDS32_ELF_VER_1_3
)
2915 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2917 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2920 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2921 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2923 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2924 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2926 if (config
& E_NDS32_HAS_16BIT_INST
)
2928 if (version
<= E_NDS32_ELF_VER_1_3
)
2929 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2931 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2935 if (config
& E_NDS32_HAS_EXT_INST
)
2936 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2938 if (config
& E_NDS32_HAS_EXT2_INST
)
2939 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2941 if (config
& E_NDS32_HAS_FPU_INST
)
2944 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2947 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2950 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2953 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2956 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2961 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2963 case E_NDS32_FPU_REG_8SP_4DP
:
2964 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2966 case E_NDS32_FPU_REG_16SP_8DP
:
2967 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2969 case E_NDS32_FPU_REG_32SP_16DP
:
2970 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2972 case E_NDS32_FPU_REG_32SP_32DP
:
2973 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2978 if (config
& E_NDS32_HAS_AUDIO_INST
)
2979 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2981 if (config
& E_NDS32_HAS_STRING_INST
)
2982 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2984 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2985 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2987 if (config
& E_NDS32_HAS_VIDEO_INST
)
2989 if (version
<= E_NDS32_ELF_VER_1_3
)
2990 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2992 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2995 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2996 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2998 if (config
& E_NDS32_HAS_L2C_INST
)
2999 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3003 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
3005 static char buf
[1024];
3016 case EM_ARC_COMPACT2
:
3017 case EM_ARC_COMPACT
:
3018 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3022 decode_ARM_machine_flags (e_flags
, buf
);
3026 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3030 if (e_flags
& EF_BFIN_PIC
)
3031 strcat (buf
, ", PIC");
3033 if (e_flags
& EF_BFIN_FDPIC
)
3034 strcat (buf
, ", FDPIC");
3036 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3037 strcat (buf
, ", code in L1");
3039 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3040 strcat (buf
, ", data in L1");
3045 switch (e_flags
& EF_FRV_CPU_MASK
)
3047 case EF_FRV_CPU_GENERIC
:
3051 strcat (buf
, ", fr???");
3054 case EF_FRV_CPU_FR300
:
3055 strcat (buf
, ", fr300");
3058 case EF_FRV_CPU_FR400
:
3059 strcat (buf
, ", fr400");
3061 case EF_FRV_CPU_FR405
:
3062 strcat (buf
, ", fr405");
3065 case EF_FRV_CPU_FR450
:
3066 strcat (buf
, ", fr450");
3069 case EF_FRV_CPU_FR500
:
3070 strcat (buf
, ", fr500");
3072 case EF_FRV_CPU_FR550
:
3073 strcat (buf
, ", fr550");
3076 case EF_FRV_CPU_SIMPLE
:
3077 strcat (buf
, ", simple");
3079 case EF_FRV_CPU_TOMCAT
:
3080 strcat (buf
, ", tomcat");
3086 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3087 strcat (buf
, ", m68000");
3088 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3089 strcat (buf
, ", cpu32");
3090 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3091 strcat (buf
, ", fido_a");
3094 char const * isa
= _("unknown");
3095 char const * mac
= _("unknown mac");
3096 char const * additional
= NULL
;
3098 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3100 case EF_M68K_CF_ISA_A_NODIV
:
3102 additional
= ", nodiv";
3104 case EF_M68K_CF_ISA_A
:
3107 case EF_M68K_CF_ISA_A_PLUS
:
3110 case EF_M68K_CF_ISA_B_NOUSP
:
3112 additional
= ", nousp";
3114 case EF_M68K_CF_ISA_B
:
3117 case EF_M68K_CF_ISA_C
:
3120 case EF_M68K_CF_ISA_C_NODIV
:
3122 additional
= ", nodiv";
3125 strcat (buf
, ", cf, isa ");
3128 strcat (buf
, additional
);
3129 if (e_flags
& EF_M68K_CF_FLOAT
)
3130 strcat (buf
, ", float");
3131 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3136 case EF_M68K_CF_MAC
:
3139 case EF_M68K_CF_EMAC
:
3142 case EF_M68K_CF_EMAC_B
:
3155 switch (e_flags
& EF_MEP_CPU_MASK
)
3157 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3158 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3159 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3160 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3161 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3162 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3163 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3166 switch (e_flags
& EF_MEP_COP_MASK
)
3168 case EF_MEP_COP_NONE
: break;
3169 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3170 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3171 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3172 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3173 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3176 if (e_flags
& EF_MEP_LIBRARY
)
3177 strcat (buf
, ", Built for Library");
3179 if (e_flags
& EF_MEP_INDEX_MASK
)
3180 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3181 e_flags
& EF_MEP_INDEX_MASK
);
3183 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3184 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3185 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3189 if (e_flags
& EF_PPC_EMB
)
3190 strcat (buf
, ", emb");
3192 if (e_flags
& EF_PPC_RELOCATABLE
)
3193 strcat (buf
, _(", relocatable"));
3195 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3196 strcat (buf
, _(", relocatable-lib"));
3200 if (e_flags
& EF_PPC64_ABI
)
3202 char abi
[] = ", abiv0";
3204 abi
[6] += e_flags
& EF_PPC64_ABI
;
3210 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3211 strcat (buf
, ", RH850 ABI");
3213 if (e_flags
& EF_V800_850E3
)
3214 strcat (buf
, ", V3 architecture");
3216 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3217 strcat (buf
, ", FPU not used");
3219 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3220 strcat (buf
, ", regmode: COMMON");
3222 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3223 strcat (buf
, ", r4 not used");
3225 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3226 strcat (buf
, ", r30 not used");
3228 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3229 strcat (buf
, ", r5 not used");
3231 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3232 strcat (buf
, ", r2 not used");
3234 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3236 switch (e_flags
& - e_flags
)
3238 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3239 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3240 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3241 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3242 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3243 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3244 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3245 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3246 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3247 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3248 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3249 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3256 case EM_CYGNUS_V850
:
3257 switch (e_flags
& EF_V850_ARCH
)
3259 case E_V850E3V5_ARCH
:
3260 strcat (buf
, ", v850e3v5");
3262 case E_V850E2V3_ARCH
:
3263 strcat (buf
, ", v850e2v3");
3266 strcat (buf
, ", v850e2");
3269 strcat (buf
, ", v850e1");
3272 strcat (buf
, ", v850e");
3275 strcat (buf
, ", v850");
3278 strcat (buf
, _(", unknown v850 architecture variant"));
3284 case EM_CYGNUS_M32R
:
3285 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3286 strcat (buf
, ", m32r");
3290 case EM_MIPS_RS3_LE
:
3291 if (e_flags
& EF_MIPS_NOREORDER
)
3292 strcat (buf
, ", noreorder");
3294 if (e_flags
& EF_MIPS_PIC
)
3295 strcat (buf
, ", pic");
3297 if (e_flags
& EF_MIPS_CPIC
)
3298 strcat (buf
, ", cpic");
3300 if (e_flags
& EF_MIPS_UCODE
)
3301 strcat (buf
, ", ugen_reserved");
3303 if (e_flags
& EF_MIPS_ABI2
)
3304 strcat (buf
, ", abi2");
3306 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3307 strcat (buf
, ", odk first");
3309 if (e_flags
& EF_MIPS_32BITMODE
)
3310 strcat (buf
, ", 32bitmode");
3312 if (e_flags
& EF_MIPS_NAN2008
)
3313 strcat (buf
, ", nan2008");
3315 if (e_flags
& EF_MIPS_FP64
)
3316 strcat (buf
, ", fp64");
3318 switch ((e_flags
& EF_MIPS_MACH
))
3320 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3321 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3322 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3323 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3324 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3325 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3326 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3327 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3328 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3329 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3330 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3331 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3332 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3333 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3334 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3335 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3336 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3338 /* We simply ignore the field in this case to avoid confusion:
3339 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3342 default: strcat (buf
, _(", unknown CPU")); break;
3345 switch ((e_flags
& EF_MIPS_ABI
))
3347 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3348 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3349 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3350 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3352 /* We simply ignore the field in this case to avoid confusion:
3353 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3354 This means it is likely to be an o32 file, but not for
3357 default: strcat (buf
, _(", unknown ABI")); break;
3360 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3361 strcat (buf
, ", mdmx");
3363 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3364 strcat (buf
, ", mips16");
3366 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3367 strcat (buf
, ", micromips");
3369 switch ((e_flags
& EF_MIPS_ARCH
))
3371 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3372 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3373 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3374 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3375 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3376 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3377 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3378 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3379 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3380 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3381 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3382 default: strcat (buf
, _(", unknown ISA")); break;
3387 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3391 if (e_flags
& EF_RISCV_RVC
)
3392 strcat (buf
, ", RVC");
3394 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3396 case EF_RISCV_FLOAT_ABI_SOFT
:
3397 strcat (buf
, ", soft-float ABI");
3400 case EF_RISCV_FLOAT_ABI_SINGLE
:
3401 strcat (buf
, ", single-float ABI");
3404 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3405 strcat (buf
, ", double-float ABI");
3408 case EF_RISCV_FLOAT_ABI_QUAD
:
3409 strcat (buf
, ", quad-float ABI");
3415 switch ((e_flags
& EF_SH_MACH_MASK
))
3417 case EF_SH1
: strcat (buf
, ", sh1"); break;
3418 case EF_SH2
: strcat (buf
, ", sh2"); break;
3419 case EF_SH3
: strcat (buf
, ", sh3"); break;
3420 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3421 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3422 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3423 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3424 case EF_SH4
: strcat (buf
, ", sh4"); break;
3425 case EF_SH5
: strcat (buf
, ", sh5"); break;
3426 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3427 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3428 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3429 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3430 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3431 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3432 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3433 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3434 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3435 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3436 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3437 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3438 default: strcat (buf
, _(", unknown ISA")); break;
3441 if (e_flags
& EF_SH_PIC
)
3442 strcat (buf
, ", pic");
3444 if (e_flags
& EF_SH_FDPIC
)
3445 strcat (buf
, ", fdpic");
3449 if (e_flags
& EF_OR1K_NODELAY
)
3450 strcat (buf
, ", no delay");
3454 if (e_flags
& EF_SPARC_32PLUS
)
3455 strcat (buf
, ", v8+");
3457 if (e_flags
& EF_SPARC_SUN_US1
)
3458 strcat (buf
, ", ultrasparcI");
3460 if (e_flags
& EF_SPARC_SUN_US3
)
3461 strcat (buf
, ", ultrasparcIII");
3463 if (e_flags
& EF_SPARC_HAL_R1
)
3464 strcat (buf
, ", halr1");
3466 if (e_flags
& EF_SPARC_LEDATA
)
3467 strcat (buf
, ", ledata");
3469 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3470 strcat (buf
, ", tso");
3472 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3473 strcat (buf
, ", pso");
3475 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3476 strcat (buf
, ", rmo");
3480 switch (e_flags
& EF_PARISC_ARCH
)
3482 case EFA_PARISC_1_0
:
3483 strcpy (buf
, ", PA-RISC 1.0");
3485 case EFA_PARISC_1_1
:
3486 strcpy (buf
, ", PA-RISC 1.1");
3488 case EFA_PARISC_2_0
:
3489 strcpy (buf
, ", PA-RISC 2.0");
3494 if (e_flags
& EF_PARISC_TRAPNIL
)
3495 strcat (buf
, ", trapnil");
3496 if (e_flags
& EF_PARISC_EXT
)
3497 strcat (buf
, ", ext");
3498 if (e_flags
& EF_PARISC_LSB
)
3499 strcat (buf
, ", lsb");
3500 if (e_flags
& EF_PARISC_WIDE
)
3501 strcat (buf
, ", wide");
3502 if (e_flags
& EF_PARISC_NO_KABP
)
3503 strcat (buf
, ", no kabp");
3504 if (e_flags
& EF_PARISC_LAZYSWAP
)
3505 strcat (buf
, ", lazyswap");
3510 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3511 strcat (buf
, ", new calling convention");
3513 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3514 strcat (buf
, ", gnu calling convention");
3518 if ((e_flags
& EF_IA_64_ABI64
))
3519 strcat (buf
, ", 64-bit");
3521 strcat (buf
, ", 32-bit");
3522 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3523 strcat (buf
, ", reduced fp model");
3524 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3525 strcat (buf
, ", no function descriptors, constant gp");
3526 else if ((e_flags
& EF_IA_64_CONS_GP
))
3527 strcat (buf
, ", constant gp");
3528 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3529 strcat (buf
, ", absolute");
3530 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3532 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3533 strcat (buf
, ", vms_linkages");
3534 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3536 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3538 case EF_IA_64_VMS_COMCOD_WARNING
:
3539 strcat (buf
, ", warning");
3541 case EF_IA_64_VMS_COMCOD_ERROR
:
3542 strcat (buf
, ", error");
3544 case EF_IA_64_VMS_COMCOD_ABORT
:
3545 strcat (buf
, ", abort");
3548 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3549 e_flags
& EF_IA_64_VMS_COMCOD
);
3550 strcat (buf
, ", <unknown>");
3556 if ((e_flags
& EF_VAX_NONPIC
))
3557 strcat (buf
, ", non-PIC");
3558 if ((e_flags
& EF_VAX_DFLOAT
))
3559 strcat (buf
, ", D-Float");
3560 if ((e_flags
& EF_VAX_GFLOAT
))
3561 strcat (buf
, ", G-Float");
3565 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3566 strcat (buf
, ", mcm");
3567 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3568 strcat (buf
, ", mcm24");
3569 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3570 strcat (buf
, ", gr6");
3574 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3576 case E_FLAG_RL78_ANY_CPU
: break;
3577 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3578 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3579 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3581 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3582 strcat (buf
, ", 64-bit doubles");
3586 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3587 strcat (buf
, ", 64-bit doubles");
3588 if (e_flags
& E_FLAG_RX_DSP
)
3589 strcat (buf
, ", dsp");
3590 if (e_flags
& E_FLAG_RX_PID
)
3591 strcat (buf
, ", pid");
3592 if (e_flags
& E_FLAG_RX_ABI
)
3593 strcat (buf
, ", RX ABI");
3594 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3595 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3596 ? ", uses String instructions" : ", bans String instructions");
3597 if (e_flags
& E_FLAG_RX_V2
)
3598 strcat (buf
, ", V2");
3602 if (e_flags
& EF_S390_HIGH_GPRS
)
3603 strcat (buf
, ", highgprs");
3607 if ((e_flags
& EF_C6000_REL
))
3608 strcat (buf
, ", relocatable module");
3612 strcat (buf
, _(": architecture variant: "));
3613 switch (e_flags
& EF_MSP430_MACH
)
3615 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3616 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3617 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3618 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3619 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3620 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3621 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3622 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3623 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3624 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3625 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3626 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3627 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3628 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3629 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3631 strcat (buf
, _(": unknown")); break;
3634 if (e_flags
& ~ EF_MSP430_MACH
)
3635 strcat (buf
, _(": unknown extra flag bits also present"));
3643 get_osabi_name (unsigned int osabi
)
3645 static char buff
[32];
3649 case ELFOSABI_NONE
: return "UNIX - System V";
3650 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3651 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3652 case ELFOSABI_GNU
: return "UNIX - GNU";
3653 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3654 case ELFOSABI_AIX
: return "UNIX - AIX";
3655 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3656 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3657 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3658 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3659 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3660 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3661 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3662 case ELFOSABI_AROS
: return "AROS";
3663 case ELFOSABI_FENIXOS
: return "FenixOS";
3664 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3665 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3668 switch (elf_header
.e_machine
)
3673 case ELFOSABI_ARM
: return "ARM";
3684 case ELFOSABI_STANDALONE
: return _("Standalone App");
3693 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3694 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3703 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3709 get_aarch64_segment_type (unsigned long type
)
3713 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3714 default: return NULL
;
3719 get_arm_segment_type (unsigned long type
)
3723 case PT_ARM_EXIDX
: return "EXIDX";
3724 default: return NULL
;
3729 get_s390_segment_type (unsigned long type
)
3733 case PT_S390_PGSTE
: return "S390_PGSTE";
3734 default: return NULL
;
3739 get_mips_segment_type (unsigned long type
)
3743 case PT_MIPS_REGINFO
: return "REGINFO";
3744 case PT_MIPS_RTPROC
: return "RTPROC";
3745 case PT_MIPS_OPTIONS
: return "OPTIONS";
3746 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3747 default: return NULL
;
3752 get_parisc_segment_type (unsigned long type
)
3756 case PT_HP_TLS
: return "HP_TLS";
3757 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3758 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3759 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3760 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3761 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3762 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3763 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3764 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3765 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3766 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3767 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3768 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3769 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3770 case PT_HP_STACK
: return "HP_STACK";
3771 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3772 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3773 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3774 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3775 default: return NULL
;
3780 get_ia64_segment_type (unsigned long type
)
3784 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3785 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3786 case PT_HP_TLS
: return "HP_TLS";
3787 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3788 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3789 case PT_IA_64_HP_STACK
: return "HP_STACK";
3790 default: return NULL
;
3795 get_tic6x_segment_type (unsigned long type
)
3799 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3800 default: return NULL
;
3805 get_solaris_segment_type (unsigned long type
)
3809 case 0x6464e550: return "PT_SUNW_UNWIND";
3810 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3811 case 0x6ffffff7: return "PT_LOSUNW";
3812 case 0x6ffffffa: return "PT_SUNWBSS";
3813 case 0x6ffffffb: return "PT_SUNWSTACK";
3814 case 0x6ffffffc: return "PT_SUNWDTRACE";
3815 case 0x6ffffffd: return "PT_SUNWCAP";
3816 case 0x6fffffff: return "PT_HISUNW";
3817 default: return NULL
;
3822 get_segment_type (unsigned long p_type
)
3824 static char buff
[32];
3828 case PT_NULL
: return "NULL";
3829 case PT_LOAD
: return "LOAD";
3830 case PT_DYNAMIC
: return "DYNAMIC";
3831 case PT_INTERP
: return "INTERP";
3832 case PT_NOTE
: return "NOTE";
3833 case PT_SHLIB
: return "SHLIB";
3834 case PT_PHDR
: return "PHDR";
3835 case PT_TLS
: return "TLS";
3836 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3837 case PT_GNU_STACK
: return "GNU_STACK";
3838 case PT_GNU_RELRO
: return "GNU_RELRO";
3841 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3843 sprintf (buff
, "GNU_MBIND+%#lx",
3844 p_type
- PT_GNU_MBIND_LO
);
3846 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3848 const char * result
;
3850 switch (elf_header
.e_machine
)
3853 result
= get_aarch64_segment_type (p_type
);
3856 result
= get_arm_segment_type (p_type
);
3859 case EM_MIPS_RS3_LE
:
3860 result
= get_mips_segment_type (p_type
);
3863 result
= get_parisc_segment_type (p_type
);
3866 result
= get_ia64_segment_type (p_type
);
3869 result
= get_tic6x_segment_type (p_type
);
3873 result
= get_s390_segment_type (p_type
);
3883 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3885 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3887 const char * result
;
3889 switch (elf_header
.e_machine
)
3892 result
= get_parisc_segment_type (p_type
);
3895 result
= get_ia64_segment_type (p_type
);
3898 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3899 result
= get_solaris_segment_type (p_type
);
3908 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3911 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3918 get_arc_section_type_name (unsigned int sh_type
)
3922 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3930 get_mips_section_type_name (unsigned int sh_type
)
3934 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3935 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3936 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3937 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3938 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3939 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3940 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3941 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3942 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3943 case SHT_MIPS_RELD
: return "MIPS_RELD";
3944 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3945 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3946 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3947 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3948 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3949 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3950 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3951 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3952 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3953 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3954 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3955 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3956 case SHT_MIPS_LINE
: return "MIPS_LINE";
3957 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3958 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3959 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3960 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3961 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3962 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3963 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3964 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3965 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3966 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3967 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3968 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3969 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3970 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3971 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3972 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3973 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3981 get_parisc_section_type_name (unsigned int sh_type
)
3985 case SHT_PARISC_EXT
: return "PARISC_EXT";
3986 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3987 case SHT_PARISC_DOC
: return "PARISC_DOC";
3988 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3989 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3990 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3991 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3992 default: return NULL
;
3997 get_ia64_section_type_name (unsigned int sh_type
)
3999 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4000 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4001 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
4005 case SHT_IA_64_EXT
: return "IA_64_EXT";
4006 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4007 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4008 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4009 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4010 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4011 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4012 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4013 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4014 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4022 get_x86_64_section_type_name (unsigned int sh_type
)
4026 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4027 default: return NULL
;
4032 get_aarch64_section_type_name (unsigned int sh_type
)
4036 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4037 default: return NULL
;
4042 get_arm_section_type_name (unsigned int sh_type
)
4046 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4047 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4048 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4049 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4050 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4051 default: return NULL
;
4056 get_tic6x_section_type_name (unsigned int sh_type
)
4060 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4061 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4062 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4063 case SHT_TI_ICODE
: return "TI_ICODE";
4064 case SHT_TI_XREF
: return "TI_XREF";
4065 case SHT_TI_HANDLER
: return "TI_HANDLER";
4066 case SHT_TI_INITINFO
: return "TI_INITINFO";
4067 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4068 default: return NULL
;
4073 get_msp430x_section_type_name (unsigned int sh_type
)
4077 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4078 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4079 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4080 default: return NULL
;
4085 get_v850_section_type_name (unsigned int sh_type
)
4089 case SHT_V850_SCOMMON
: return "V850 Small Common";
4090 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4091 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4092 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4093 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4094 default: return NULL
;
4099 get_section_type_name (unsigned int sh_type
)
4101 static char buff
[32];
4102 const char * result
;
4106 case SHT_NULL
: return "NULL";
4107 case SHT_PROGBITS
: return "PROGBITS";
4108 case SHT_SYMTAB
: return "SYMTAB";
4109 case SHT_STRTAB
: return "STRTAB";
4110 case SHT_RELA
: return "RELA";
4111 case SHT_HASH
: return "HASH";
4112 case SHT_DYNAMIC
: return "DYNAMIC";
4113 case SHT_NOTE
: return "NOTE";
4114 case SHT_NOBITS
: return "NOBITS";
4115 case SHT_REL
: return "REL";
4116 case SHT_SHLIB
: return "SHLIB";
4117 case SHT_DYNSYM
: return "DYNSYM";
4118 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4119 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4120 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4121 case SHT_GNU_HASH
: return "GNU_HASH";
4122 case SHT_GROUP
: return "GROUP";
4123 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4124 case SHT_GNU_verdef
: return "VERDEF";
4125 case SHT_GNU_verneed
: return "VERNEED";
4126 case SHT_GNU_versym
: return "VERSYM";
4127 case 0x6ffffff0: return "VERSYM";
4128 case 0x6ffffffc: return "VERDEF";
4129 case 0x7ffffffd: return "AUXILIARY";
4130 case 0x7fffffff: return "FILTER";
4131 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4134 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4136 switch (elf_header
.e_machine
)
4139 case EM_ARC_COMPACT
:
4140 case EM_ARC_COMPACT2
:
4141 result
= get_arc_section_type_name (sh_type
);
4144 case EM_MIPS_RS3_LE
:
4145 result
= get_mips_section_type_name (sh_type
);
4148 result
= get_parisc_section_type_name (sh_type
);
4151 result
= get_ia64_section_type_name (sh_type
);
4156 result
= get_x86_64_section_type_name (sh_type
);
4159 result
= get_aarch64_section_type_name (sh_type
);
4162 result
= get_arm_section_type_name (sh_type
);
4165 result
= get_tic6x_section_type_name (sh_type
);
4168 result
= get_msp430x_section_type_name (sh_type
);
4172 case EM_CYGNUS_V850
:
4173 result
= get_v850_section_type_name (sh_type
);
4183 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4185 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4187 switch (elf_header
.e_machine
)
4190 result
= get_ia64_section_type_name (sh_type
);
4193 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4194 result
= get_solaris_section_type (sh_type
);
4199 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4200 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4201 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4202 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4214 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4216 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4218 switch (elf_header
.e_machine
)
4222 case EM_CYGNUS_V850
:
4223 result
= get_v850_section_type_name (sh_type
);
4233 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4236 /* This message is probably going to be displayed in a 15
4237 character wide field, so put the hex value first. */
4238 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4244 #define OPTION_DEBUG_DUMP 512
4245 #define OPTION_DYN_SYMS 513
4246 #define OPTION_DWARF_DEPTH 514
4247 #define OPTION_DWARF_START 515
4248 #define OPTION_DWARF_CHECK 516
4250 static struct option options
[] =
4252 {"all", no_argument
, 0, 'a'},
4253 {"file-header", no_argument
, 0, 'h'},
4254 {"program-headers", no_argument
, 0, 'l'},
4255 {"headers", no_argument
, 0, 'e'},
4256 {"histogram", no_argument
, 0, 'I'},
4257 {"segments", no_argument
, 0, 'l'},
4258 {"sections", no_argument
, 0, 'S'},
4259 {"section-headers", no_argument
, 0, 'S'},
4260 {"section-groups", no_argument
, 0, 'g'},
4261 {"section-details", no_argument
, 0, 't'},
4262 {"full-section-name",no_argument
, 0, 'N'},
4263 {"symbols", no_argument
, 0, 's'},
4264 {"syms", no_argument
, 0, 's'},
4265 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4266 {"relocs", no_argument
, 0, 'r'},
4267 {"notes", no_argument
, 0, 'n'},
4268 {"dynamic", no_argument
, 0, 'd'},
4269 {"arch-specific", no_argument
, 0, 'A'},
4270 {"version-info", no_argument
, 0, 'V'},
4271 {"use-dynamic", no_argument
, 0, 'D'},
4272 {"unwind", no_argument
, 0, 'u'},
4273 {"archive-index", no_argument
, 0, 'c'},
4274 {"hex-dump", required_argument
, 0, 'x'},
4275 {"relocated-dump", required_argument
, 0, 'R'},
4276 {"string-dump", required_argument
, 0, 'p'},
4277 {"decompress", no_argument
, 0, 'z'},
4278 #ifdef SUPPORT_DISASSEMBLY
4279 {"instruction-dump", required_argument
, 0, 'i'},
4281 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4283 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4284 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4285 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4287 {"version", no_argument
, 0, 'v'},
4288 {"wide", no_argument
, 0, 'W'},
4289 {"help", no_argument
, 0, 'H'},
4290 {0, no_argument
, 0, 0}
4294 usage (FILE * stream
)
4296 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4297 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4298 fprintf (stream
, _(" Options are:\n\
4299 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4300 -h --file-header Display the ELF file header\n\
4301 -l --program-headers Display the program headers\n\
4302 --segments An alias for --program-headers\n\
4303 -S --section-headers Display the sections' header\n\
4304 --sections An alias for --section-headers\n\
4305 -g --section-groups Display the section groups\n\
4306 -t --section-details Display the section details\n\
4307 -e --headers Equivalent to: -h -l -S\n\
4308 -s --syms Display the symbol table\n\
4309 --symbols An alias for --syms\n\
4310 --dyn-syms Display the dynamic symbol table\n\
4311 -n --notes Display the core notes (if present)\n\
4312 -r --relocs Display the relocations (if present)\n\
4313 -u --unwind Display the unwind info (if present)\n\
4314 -d --dynamic Display the dynamic section (if present)\n\
4315 -V --version-info Display the version sections (if present)\n\
4316 -A --arch-specific Display architecture specific information (if any)\n\
4317 -c --archive-index Display the symbol/file index in an archive\n\
4318 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4319 -x --hex-dump=<number|name>\n\
4320 Dump the contents of section <number|name> as bytes\n\
4321 -p --string-dump=<number|name>\n\
4322 Dump the contents of section <number|name> as strings\n\
4323 -R --relocated-dump=<number|name>\n\
4324 Dump the contents of section <number|name> as relocated bytes\n\
4325 -z --decompress Decompress section before dumping it\n\
4326 -w[lLiaprmfFsoRt] or\n\
4327 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4328 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4329 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4331 Display the contents of DWARF2 debug sections\n"));
4332 fprintf (stream
, _("\
4333 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4334 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4336 #ifdef SUPPORT_DISASSEMBLY
4337 fprintf (stream
, _("\
4338 -i --instruction-dump=<number|name>\n\
4339 Disassemble the contents of section <number|name>\n"));
4341 fprintf (stream
, _("\
4342 -I --histogram Display histogram of bucket list lengths\n\
4343 -W --wide Allow output width to exceed 80 characters\n\
4344 @<file> Read options from <file>\n\
4345 -H --help Display this information\n\
4346 -v --version Display the version number of readelf\n"));
4348 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4349 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4351 exit (stream
== stdout
? 0 : 1);
4354 /* Record the fact that the user wants the contents of section number
4355 SECTION to be displayed using the method(s) encoded as flags bits
4356 in TYPE. Note, TYPE can be zero if we are creating the array for
4360 request_dump_bynumber (unsigned int section
, dump_type type
)
4362 if (section
>= num_dump_sects
)
4364 dump_type
* new_dump_sects
;
4366 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4367 sizeof (* dump_sects
));
4369 if (new_dump_sects
== NULL
)
4370 error (_("Out of memory allocating dump request table.\n"));
4375 /* Copy current flag settings. */
4376 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4381 dump_sects
= new_dump_sects
;
4382 num_dump_sects
= section
+ 1;
4387 dump_sects
[section
] |= type
;
4392 /* Request a dump by section name. */
4395 request_dump_byname (const char * section
, dump_type type
)
4397 struct dump_list_entry
* new_request
;
4399 new_request
= (struct dump_list_entry
*)
4400 malloc (sizeof (struct dump_list_entry
));
4402 error (_("Out of memory allocating dump request table.\n"));
4404 new_request
->name
= strdup (section
);
4405 if (!new_request
->name
)
4406 error (_("Out of memory allocating dump request table.\n"));
4408 new_request
->type
= type
;
4410 new_request
->next
= dump_sects_byname
;
4411 dump_sects_byname
= new_request
;
4415 request_dump (dump_type type
)
4421 section
= strtoul (optarg
, & cp
, 0);
4423 if (! *cp
&& section
>= 0)
4424 request_dump_bynumber (section
, type
);
4426 request_dump_byname (optarg
, type
);
4431 parse_args (int argc
, char ** argv
)
4438 while ((c
= getopt_long
4439 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4457 do_section_groups
= TRUE
;
4460 do_histogram
= TRUE
;
4465 do_section_groups
= TRUE
;
4470 do_section_details
= TRUE
;
4481 do_using_dynamic
= TRUE
;
4505 do_histogram
= TRUE
;
4511 do_archive_index
= TRUE
;
4514 request_dump (HEX_DUMP
);
4517 request_dump (STRING_DUMP
);
4520 request_dump (RELOC_DUMP
);
4523 decompress_dumps
= TRUE
;
4529 do_debugging
= TRUE
;
4530 dwarf_select_sections_all ();
4534 do_debugging
= FALSE
;
4535 dwarf_select_sections_by_letters (optarg
);
4538 case OPTION_DEBUG_DUMP
:
4541 do_debugging
= TRUE
;
4544 do_debugging
= FALSE
;
4545 dwarf_select_sections_by_names (optarg
);
4548 case OPTION_DWARF_DEPTH
:
4552 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4555 case OPTION_DWARF_START
:
4559 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4562 case OPTION_DWARF_CHECK
:
4565 case OPTION_DYN_SYMS
:
4568 #ifdef SUPPORT_DISASSEMBLY
4570 request_dump (DISASS_DUMP
);
4574 print_version (program_name
);
4583 /* xgettext:c-format */
4584 error (_("Invalid option '-%c'\n"), c
);
4591 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4592 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4593 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4594 && !do_section_groups
&& !do_archive_index
4600 get_elf_class (unsigned int elf_class
)
4602 static char buff
[32];
4606 case ELFCLASSNONE
: return _("none");
4607 case ELFCLASS32
: return "ELF32";
4608 case ELFCLASS64
: return "ELF64";
4610 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4616 get_data_encoding (unsigned int encoding
)
4618 static char buff
[32];
4622 case ELFDATANONE
: return _("none");
4623 case ELFDATA2LSB
: return _("2's complement, little endian");
4624 case ELFDATA2MSB
: return _("2's complement, big endian");
4626 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4631 /* Decode the data held in 'elf_header'. */
4634 process_file_header (void)
4636 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4637 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4638 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4639 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4642 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4646 init_dwarf_regnames (elf_header
.e_machine
);
4652 printf (_("ELF Header:\n"));
4653 printf (_(" Magic: "));
4654 for (i
= 0; i
< EI_NIDENT
; i
++)
4655 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4657 printf (_(" Class: %s\n"),
4658 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4659 printf (_(" Data: %s\n"),
4660 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4661 printf (_(" Version: %d %s\n"),
4662 elf_header
.e_ident
[EI_VERSION
],
4663 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4665 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4666 ? _("<unknown: %lx>")
4668 printf (_(" OS/ABI: %s\n"),
4669 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4670 printf (_(" ABI Version: %d\n"),
4671 elf_header
.e_ident
[EI_ABIVERSION
]);
4672 printf (_(" Type: %s\n"),
4673 get_file_type (elf_header
.e_type
));
4674 printf (_(" Machine: %s\n"),
4675 get_machine_name (elf_header
.e_machine
));
4676 printf (_(" Version: 0x%lx\n"),
4677 (unsigned long) elf_header
.e_version
);
4679 printf (_(" Entry point address: "));
4680 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4681 printf (_("\n Start of program headers: "));
4682 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4683 printf (_(" (bytes into file)\n Start of section headers: "));
4684 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4685 printf (_(" (bytes into file)\n"));
4687 printf (_(" Flags: 0x%lx%s\n"),
4688 (unsigned long) elf_header
.e_flags
,
4689 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4690 printf (_(" Size of this header: %ld (bytes)\n"),
4691 (long) elf_header
.e_ehsize
);
4692 printf (_(" Size of program headers: %ld (bytes)\n"),
4693 (long) elf_header
.e_phentsize
);
4694 printf (_(" Number of program headers: %ld"),
4695 (long) elf_header
.e_phnum
);
4696 if (section_headers
!= NULL
4697 && elf_header
.e_phnum
== PN_XNUM
4698 && section_headers
[0].sh_info
!= 0)
4699 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4700 putc ('\n', stdout
);
4701 printf (_(" Size of section headers: %ld (bytes)\n"),
4702 (long) elf_header
.e_shentsize
);
4703 printf (_(" Number of section headers: %ld"),
4704 (long) elf_header
.e_shnum
);
4705 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4706 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4707 putc ('\n', stdout
);
4708 printf (_(" Section header string table index: %ld"),
4709 (long) elf_header
.e_shstrndx
);
4710 if (section_headers
!= NULL
4711 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4712 printf (" (%u)", section_headers
[0].sh_link
);
4713 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4714 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4715 printf (_(" <corrupt: out of range>"));
4716 putc ('\n', stdout
);
4719 if (section_headers
!= NULL
)
4721 if (elf_header
.e_phnum
== PN_XNUM
4722 && section_headers
[0].sh_info
!= 0)
4723 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4724 if (elf_header
.e_shnum
== SHN_UNDEF
)
4725 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4726 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4727 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4728 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4729 elf_header
.e_shstrndx
= SHN_UNDEF
;
4730 free (section_headers
);
4731 section_headers
= NULL
;
4738 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4740 Elf32_External_Phdr
* phdrs
;
4741 Elf32_External_Phdr
* external
;
4742 Elf_Internal_Phdr
* internal
;
4744 unsigned int size
= elf_header
.e_phentsize
;
4745 unsigned int num
= elf_header
.e_phnum
;
4747 /* PR binutils/17531: Cope with unexpected section header sizes. */
4748 if (size
== 0 || num
== 0)
4750 if (size
< sizeof * phdrs
)
4752 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4755 if (size
> sizeof * phdrs
)
4756 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4758 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4759 size
, num
, _("program headers"));
4763 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4764 i
< elf_header
.e_phnum
;
4765 i
++, internal
++, external
++)
4767 internal
->p_type
= BYTE_GET (external
->p_type
);
4768 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4769 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4770 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4771 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4772 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4773 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4774 internal
->p_align
= BYTE_GET (external
->p_align
);
4782 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4784 Elf64_External_Phdr
* phdrs
;
4785 Elf64_External_Phdr
* external
;
4786 Elf_Internal_Phdr
* internal
;
4788 unsigned int size
= elf_header
.e_phentsize
;
4789 unsigned int num
= elf_header
.e_phnum
;
4791 /* PR binutils/17531: Cope with unexpected section header sizes. */
4792 if (size
== 0 || num
== 0)
4794 if (size
< sizeof * phdrs
)
4796 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4799 if (size
> sizeof * phdrs
)
4800 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4802 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4803 size
, num
, _("program headers"));
4807 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4808 i
< elf_header
.e_phnum
;
4809 i
++, internal
++, external
++)
4811 internal
->p_type
= BYTE_GET (external
->p_type
);
4812 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4813 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4814 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4815 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4816 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4817 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4818 internal
->p_align
= BYTE_GET (external
->p_align
);
4825 /* Returns TRUE if the program headers were read into `program_headers'. */
4828 get_program_headers (FILE * file
)
4830 Elf_Internal_Phdr
* phdrs
;
4832 /* Check cache of prior read. */
4833 if (program_headers
!= NULL
)
4836 /* Be kind to memory checkers by looking for
4837 e_phnum values which we know must be invalid. */
4838 if (elf_header
.e_phnum
4839 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4840 >= current_file_size
)
4842 error (_("Too many program headers - %#x - the file is not that big\n"),
4843 elf_header
.e_phnum
);
4847 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4848 sizeof (Elf_Internal_Phdr
));
4851 error (_("Out of memory reading %u program headers\n"),
4852 elf_header
.e_phnum
);
4857 ? get_32bit_program_headers (file
, phdrs
)
4858 : get_64bit_program_headers (file
, phdrs
))
4860 program_headers
= phdrs
;
4868 /* Returns TRUE if the program headers were loaded. */
4871 process_program_headers (FILE * file
)
4873 Elf_Internal_Phdr
* segment
;
4875 Elf_Internal_Phdr
* previous_load
= NULL
;
4877 if (elf_header
.e_phnum
== 0)
4879 /* PR binutils/12467. */
4880 if (elf_header
.e_phoff
!= 0)
4882 warn (_("possibly corrupt ELF header - it has a non-zero program"
4883 " header offset, but no program headers\n"));
4886 else if (do_segments
)
4887 printf (_("\nThere are no program headers in this file.\n"));
4891 if (do_segments
&& !do_header
)
4893 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4894 printf (_("Entry point "));
4895 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4896 printf (_("\nThere are %d program headers, starting at offset "),
4897 elf_header
.e_phnum
);
4898 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4902 if (! get_program_headers (file
))
4907 if (elf_header
.e_phnum
> 1)
4908 printf (_("\nProgram Headers:\n"));
4910 printf (_("\nProgram Headers:\n"));
4914 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4917 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4921 (_(" Type Offset VirtAddr PhysAddr\n"));
4923 (_(" FileSiz MemSiz Flags Align\n"));
4930 for (i
= 0, segment
= program_headers
;
4931 i
< elf_header
.e_phnum
;
4936 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4940 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4941 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4942 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4943 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4944 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4946 (segment
->p_flags
& PF_R
? 'R' : ' '),
4947 (segment
->p_flags
& PF_W
? 'W' : ' '),
4948 (segment
->p_flags
& PF_X
? 'E' : ' '));
4949 printf ("%#lx", (unsigned long) segment
->p_align
);
4953 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4954 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4957 print_vma (segment
->p_offset
, FULL_HEX
);
4961 print_vma (segment
->p_vaddr
, FULL_HEX
);
4963 print_vma (segment
->p_paddr
, FULL_HEX
);
4966 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4967 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4970 print_vma (segment
->p_filesz
, FULL_HEX
);
4974 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4975 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4978 print_vma (segment
->p_memsz
, FULL_HEX
);
4982 (segment
->p_flags
& PF_R
? 'R' : ' '),
4983 (segment
->p_flags
& PF_W
? 'W' : ' '),
4984 (segment
->p_flags
& PF_X
? 'E' : ' '));
4986 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4987 printf ("%#lx", (unsigned long) segment
->p_align
);
4990 print_vma (segment
->p_align
, PREFIX_HEX
);
4995 print_vma (segment
->p_offset
, FULL_HEX
);
4997 print_vma (segment
->p_vaddr
, FULL_HEX
);
4999 print_vma (segment
->p_paddr
, FULL_HEX
);
5001 print_vma (segment
->p_filesz
, FULL_HEX
);
5003 print_vma (segment
->p_memsz
, FULL_HEX
);
5005 (segment
->p_flags
& PF_R
? 'R' : ' '),
5006 (segment
->p_flags
& PF_W
? 'W' : ' '),
5007 (segment
->p_flags
& PF_X
? 'E' : ' '));
5008 print_vma (segment
->p_align
, PREFIX_HEX
);
5011 putc ('\n', stdout
);
5014 switch (segment
->p_type
)
5017 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5018 required by the ELF standard, several programs, including the Linux
5019 kernel, make use of non-ordered segments. */
5021 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5022 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5024 if (segment
->p_memsz
< segment
->p_filesz
)
5025 error (_("the segment's file size is larger than its memory size\n"));
5026 previous_load
= segment
;
5030 /* PR 20815 - Verify that the program header is loaded into memory. */
5031 if (i
> 0 && previous_load
!= NULL
)
5032 error (_("the PHDR segment must occur before any LOAD segment\n"));
5033 if (elf_header
.e_machine
!= EM_PARISC
)
5037 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
5038 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5039 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
5040 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5042 if (j
== elf_header
.e_phnum
)
5043 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5049 error (_("more than one dynamic segment\n"));
5051 /* By default, assume that the .dynamic section is the first
5052 section in the DYNAMIC segment. */
5053 dynamic_addr
= segment
->p_offset
;
5054 dynamic_size
= segment
->p_filesz
;
5056 /* Try to locate the .dynamic section. If there is
5057 a section header table, we can easily locate it. */
5058 if (section_headers
!= NULL
)
5060 Elf_Internal_Shdr
* sec
;
5062 sec
= find_section (".dynamic");
5063 if (sec
== NULL
|| sec
->sh_size
== 0)
5065 /* A corresponding .dynamic section is expected, but on
5066 IA-64/OpenVMS it is OK for it to be missing. */
5067 if (!is_ia64_vms ())
5068 error (_("no .dynamic section in the dynamic segment\n"));
5072 if (sec
->sh_type
== SHT_NOBITS
)
5078 dynamic_addr
= sec
->sh_offset
;
5079 dynamic_size
= sec
->sh_size
;
5081 if (dynamic_addr
< segment
->p_offset
5082 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5083 warn (_("the .dynamic section is not contained"
5084 " within the dynamic segment\n"));
5085 else if (dynamic_addr
> segment
->p_offset
)
5086 warn (_("the .dynamic section is not the first section"
5087 " in the dynamic segment.\n"));
5090 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5091 segment. Check this after matching against the section headers
5092 so we don't warn on debuginfo file (which have NOBITS .dynamic
5094 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5096 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5097 dynamic_addr
= dynamic_size
= 0;
5102 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5104 error (_("Unable to find program interpreter name\n"));
5108 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5110 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5111 error (_("Internal error: failed to create format string to display program interpreter\n"));
5113 program_interpreter
[0] = 0;
5114 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5115 error (_("Unable to read program interpreter name\n"));
5118 printf (_(" [Requesting program interpreter: %s]\n"),
5119 program_interpreter
);
5125 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5127 printf (_("\n Section to Segment mapping:\n"));
5128 printf (_(" Segment Sections...\n"));
5130 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5133 Elf_Internal_Shdr
* section
;
5135 segment
= program_headers
+ i
;
5136 section
= section_headers
+ 1;
5138 printf (" %2.2d ", i
);
5140 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5142 if (!ELF_TBSS_SPECIAL (section
, segment
)
5143 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5144 printf ("%s ", printable_section_name (section
));
5155 /* Find the file offset corresponding to VMA by using the program headers. */
5158 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5160 Elf_Internal_Phdr
* seg
;
5162 if (! get_program_headers (file
))
5164 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5168 for (seg
= program_headers
;
5169 seg
< program_headers
+ elf_header
.e_phnum
;
5172 if (seg
->p_type
!= PT_LOAD
)
5175 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5176 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5177 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5180 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5181 (unsigned long) vma
);
5186 /* Allocate memory and load the sections headers into the global pointer
5187 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5188 generate any error messages if the load fails. */
5191 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5193 Elf32_External_Shdr
* shdrs
;
5194 Elf_Internal_Shdr
* internal
;
5196 unsigned int size
= elf_header
.e_shentsize
;
5197 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5199 /* PR binutils/17531: Cope with unexpected section header sizes. */
5200 if (size
== 0 || num
== 0)
5202 if (size
< sizeof * shdrs
)
5205 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5208 if (!probe
&& size
> sizeof * shdrs
)
5209 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5211 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5213 probe
? NULL
: _("section headers"));
5217 if (section_headers
!= NULL
)
5218 free (section_headers
);
5219 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5220 sizeof (Elf_Internal_Shdr
));
5221 if (section_headers
== NULL
)
5224 error (_("Out of memory reading %u section headers\n"), num
);
5228 for (i
= 0, internal
= section_headers
;
5232 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5233 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5234 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5235 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5236 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5237 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5238 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5239 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5240 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5241 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5242 if (!probe
&& internal
->sh_link
> num
)
5243 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5244 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5245 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5253 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5255 Elf64_External_Shdr
* shdrs
;
5256 Elf_Internal_Shdr
* internal
;
5258 unsigned int size
= elf_header
.e_shentsize
;
5259 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5261 /* PR binutils/17531: Cope with unexpected section header sizes. */
5262 if (size
== 0 || num
== 0)
5264 if (size
< sizeof * shdrs
)
5267 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5270 if (! probe
&& size
> sizeof * shdrs
)
5271 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5273 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5275 probe
? NULL
: _("section headers"));
5279 if (section_headers
!= NULL
)
5280 free (section_headers
);
5281 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5282 sizeof (Elf_Internal_Shdr
));
5283 if (section_headers
== NULL
)
5286 error (_("Out of memory reading %u section headers\n"), num
);
5290 for (i
= 0, internal
= section_headers
;
5294 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5295 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5296 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5297 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5298 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5299 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5300 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5301 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5302 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5303 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5304 if (!probe
&& internal
->sh_link
> num
)
5305 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5306 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5307 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5314 static Elf_Internal_Sym
*
5315 get_32bit_elf_symbols (FILE * file
,
5316 Elf_Internal_Shdr
* section
,
5317 unsigned long * num_syms_return
)
5319 unsigned long number
= 0;
5320 Elf32_External_Sym
* esyms
= NULL
;
5321 Elf_External_Sym_Shndx
* shndx
= NULL
;
5322 Elf_Internal_Sym
* isyms
= NULL
;
5323 Elf_Internal_Sym
* psym
;
5326 if (section
->sh_size
== 0)
5328 if (num_syms_return
!= NULL
)
5329 * num_syms_return
= 0;
5333 /* Run some sanity checks first. */
5334 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5336 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5337 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5341 if (section
->sh_size
> current_file_size
)
5343 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5344 printable_section_name (section
), (unsigned long) section
->sh_size
);
5348 number
= section
->sh_size
/ section
->sh_entsize
;
5350 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5352 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5353 (unsigned long) section
->sh_size
,
5354 printable_section_name (section
),
5355 (unsigned long) section
->sh_entsize
);
5359 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5360 section
->sh_size
, _("symbols"));
5365 elf_section_list
* entry
;
5368 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5369 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5371 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5372 entry
->hdr
->sh_offset
,
5373 1, entry
->hdr
->sh_size
,
5374 _("symbol table section indicies"));
5377 /* PR17531: file: heap-buffer-overflow */
5378 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5380 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5381 printable_section_name (entry
->hdr
),
5382 (unsigned long) entry
->hdr
->sh_size
,
5383 (unsigned long) section
->sh_size
);
5389 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5393 error (_("Out of memory reading %lu symbols\n"),
5394 (unsigned long) number
);
5398 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5400 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5401 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5402 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5403 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5404 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5406 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5407 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5408 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5409 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5410 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5419 if (num_syms_return
!= NULL
)
5420 * num_syms_return
= isyms
== NULL
? 0 : number
;
5425 static Elf_Internal_Sym
*
5426 get_64bit_elf_symbols (FILE * file
,
5427 Elf_Internal_Shdr
* section
,
5428 unsigned long * num_syms_return
)
5430 unsigned long number
= 0;
5431 Elf64_External_Sym
* esyms
= NULL
;
5432 Elf_External_Sym_Shndx
* shndx
= NULL
;
5433 Elf_Internal_Sym
* isyms
= NULL
;
5434 Elf_Internal_Sym
* psym
;
5437 if (section
->sh_size
== 0)
5439 if (num_syms_return
!= NULL
)
5440 * num_syms_return
= 0;
5444 /* Run some sanity checks first. */
5445 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5447 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5448 printable_section_name (section
),
5449 (unsigned long) section
->sh_entsize
);
5453 if (section
->sh_size
> current_file_size
)
5455 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5456 printable_section_name (section
),
5457 (unsigned long) section
->sh_size
);
5461 number
= section
->sh_size
/ section
->sh_entsize
;
5463 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5465 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5466 (unsigned long) section
->sh_size
,
5467 printable_section_name (section
),
5468 (unsigned long) section
->sh_entsize
);
5472 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5473 section
->sh_size
, _("symbols"));
5478 elf_section_list
* entry
;
5481 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5482 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5484 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5485 entry
->hdr
->sh_offset
,
5486 1, entry
->hdr
->sh_size
,
5487 _("symbol table section indicies"));
5490 /* PR17531: file: heap-buffer-overflow */
5491 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5493 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5494 printable_section_name (entry
->hdr
),
5495 (unsigned long) entry
->hdr
->sh_size
,
5496 (unsigned long) section
->sh_size
);
5502 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5506 error (_("Out of memory reading %lu symbols\n"),
5507 (unsigned long) number
);
5511 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5513 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5514 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5515 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5516 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5518 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5520 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5521 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5522 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5524 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5525 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5534 if (num_syms_return
!= NULL
)
5535 * num_syms_return
= isyms
== NULL
? 0 : number
;
5541 get_elf_section_flags (bfd_vma sh_flags
)
5543 static char buff
[1024];
5545 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5547 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5548 bfd_vma os_flags
= 0;
5549 bfd_vma proc_flags
= 0;
5550 bfd_vma unknown_flags
= 0;
5558 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5559 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5560 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5561 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5562 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5563 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5564 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5565 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5566 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5567 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5568 /* IA-64 specific. */
5569 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5570 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5571 /* IA-64 OpenVMS specific. */
5572 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5573 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5574 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5575 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5576 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5577 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5579 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5580 /* SPARC specific. */
5581 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5582 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5584 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5585 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5586 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5588 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5591 if (do_section_details
)
5593 sprintf (buff
, "[%*.*lx]: ",
5594 field_size
, field_size
, (unsigned long) sh_flags
);
5595 p
+= field_size
+ 4;
5602 flag
= sh_flags
& - sh_flags
;
5605 if (do_section_details
)
5609 case SHF_WRITE
: sindex
= 0; break;
5610 case SHF_ALLOC
: sindex
= 1; break;
5611 case SHF_EXECINSTR
: sindex
= 2; break;
5612 case SHF_MERGE
: sindex
= 3; break;
5613 case SHF_STRINGS
: sindex
= 4; break;
5614 case SHF_INFO_LINK
: sindex
= 5; break;
5615 case SHF_LINK_ORDER
: sindex
= 6; break;
5616 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5617 case SHF_GROUP
: sindex
= 8; break;
5618 case SHF_TLS
: sindex
= 9; break;
5619 case SHF_EXCLUDE
: sindex
= 18; break;
5620 case SHF_COMPRESSED
: sindex
= 20; break;
5621 case SHF_GNU_MBIND
: sindex
= 24; break;
5625 switch (elf_header
.e_machine
)
5628 if (flag
== SHF_IA_64_SHORT
)
5630 else if (flag
== SHF_IA_64_NORECOV
)
5633 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5636 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5637 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5638 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5639 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5640 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5641 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5652 case EM_OLD_SPARCV9
:
5653 case EM_SPARC32PLUS
:
5656 if (flag
== SHF_ORDERED
)
5663 case SHF_ENTRYSECT
: sindex
= 21; break;
5664 case SHF_ARM_PURECODE
: sindex
= 22; break;
5665 case SHF_COMDEF
: sindex
= 23; break;
5677 if (p
!= buff
+ field_size
+ 4)
5679 if (size
< (10 + 2))
5681 warn (_("Internal error: not enough buffer room for section flag info"));
5682 return _("<unknown>");
5689 size
-= flags
[sindex
].len
;
5690 p
= stpcpy (p
, flags
[sindex
].str
);
5692 else if (flag
& SHF_MASKOS
)
5694 else if (flag
& SHF_MASKPROC
)
5697 unknown_flags
|= flag
;
5703 case SHF_WRITE
: *p
= 'W'; break;
5704 case SHF_ALLOC
: *p
= 'A'; break;
5705 case SHF_EXECINSTR
: *p
= 'X'; break;
5706 case SHF_MERGE
: *p
= 'M'; break;
5707 case SHF_STRINGS
: *p
= 'S'; break;
5708 case SHF_INFO_LINK
: *p
= 'I'; break;
5709 case SHF_LINK_ORDER
: *p
= 'L'; break;
5710 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5711 case SHF_GROUP
: *p
= 'G'; break;
5712 case SHF_TLS
: *p
= 'T'; break;
5713 case SHF_EXCLUDE
: *p
= 'E'; break;
5714 case SHF_COMPRESSED
: *p
= 'C'; break;
5715 case SHF_GNU_MBIND
: *p
= 'D'; break;
5718 if ((elf_header
.e_machine
== EM_X86_64
5719 || elf_header
.e_machine
== EM_L1OM
5720 || elf_header
.e_machine
== EM_K1OM
)
5721 && flag
== SHF_X86_64_LARGE
)
5723 else if (elf_header
.e_machine
== EM_ARM
5724 && flag
== SHF_ARM_PURECODE
)
5726 else if (flag
& SHF_MASKOS
)
5729 sh_flags
&= ~ SHF_MASKOS
;
5731 else if (flag
& SHF_MASKPROC
)
5734 sh_flags
&= ~ SHF_MASKPROC
;
5744 if (do_section_details
)
5748 size
-= 5 + field_size
;
5749 if (p
!= buff
+ field_size
+ 4)
5753 warn (_("Internal error: not enough buffer room for section flag info"));
5754 return _("<unknown>");
5760 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5761 (unsigned long) os_flags
);
5762 p
+= 5 + field_size
;
5766 size
-= 7 + field_size
;
5767 if (p
!= buff
+ field_size
+ 4)
5771 warn (_("Internal error: not enough buffer room for section flag info"));
5772 return _("<unknown>");
5778 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5779 (unsigned long) proc_flags
);
5780 p
+= 7 + field_size
;
5784 size
-= 10 + field_size
;
5785 if (p
!= buff
+ field_size
+ 4)
5789 warn (_("Internal error: not enough buffer room for section flag info"));
5790 return _("<unknown>");
5796 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5797 (unsigned long) unknown_flags
);
5798 p
+= 10 + field_size
;
5807 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5811 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5813 if (size
< sizeof (* echdr
))
5815 error (_("Compressed section is too small even for a compression header\n"));
5819 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5820 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5821 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5822 return sizeof (*echdr
);
5826 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5828 if (size
< sizeof (* echdr
))
5830 error (_("Compressed section is too small even for a compression header\n"));
5834 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5835 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5836 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5837 return sizeof (*echdr
);
5842 process_section_headers (FILE * file
)
5844 Elf_Internal_Shdr
* section
;
5847 section_headers
= NULL
;
5849 if (elf_header
.e_shnum
== 0)
5851 /* PR binutils/12467. */
5852 if (elf_header
.e_shoff
!= 0)
5854 warn (_("possibly corrupt ELF file header - it has a non-zero"
5855 " section header offset, but no section headers\n"));
5858 else if (do_sections
)
5859 printf (_("\nThere are no sections in this file.\n"));
5864 if (do_sections
&& !do_header
)
5865 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5866 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5870 if (! get_32bit_section_headers (file
, FALSE
))
5875 if (! get_64bit_section_headers (file
, FALSE
))
5879 /* Read in the string table, so that we have names to display. */
5880 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5881 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5883 section
= section_headers
+ elf_header
.e_shstrndx
;
5885 if (section
->sh_size
!= 0)
5887 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5888 1, section
->sh_size
,
5891 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5895 /* Scan the sections for the dynamic symbol table
5896 and dynamic string table and debug sections. */
5897 dynamic_symbols
= NULL
;
5898 dynamic_strings
= NULL
;
5899 dynamic_syminfo
= NULL
;
5900 symtab_shndx_list
= NULL
;
5902 eh_addr_size
= is_32bit_elf
? 4 : 8;
5903 switch (elf_header
.e_machine
)
5906 case EM_MIPS_RS3_LE
:
5907 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5908 FDE addresses. However, the ABI also has a semi-official ILP32
5909 variant for which the normal FDE address size rules apply.
5911 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5912 section, where XX is the size of longs in bits. Unfortunately,
5913 earlier compilers provided no way of distinguishing ILP32 objects
5914 from LP64 objects, so if there's any doubt, we should assume that
5915 the official LP64 form is being used. */
5916 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5917 && find_section (".gcc_compiled_long32") == NULL
)
5923 switch (elf_header
.e_flags
& EF_H8_MACH
)
5925 case E_H8_MACH_H8300
:
5926 case E_H8_MACH_H8300HN
:
5927 case E_H8_MACH_H8300SN
:
5928 case E_H8_MACH_H8300SXN
:
5931 case E_H8_MACH_H8300H
:
5932 case E_H8_MACH_H8300S
:
5933 case E_H8_MACH_H8300SX
:
5941 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5943 case EF_M32C_CPU_M16C
:
5950 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5953 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5954 if (section->sh_entsize != expected_entsize) \
5957 sprintf_vma (buf, section->sh_entsize); \
5958 /* Note: coded this way so that there is a single string for \
5960 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5961 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5962 (unsigned) expected_entsize); \
5963 section->sh_entsize = expected_entsize; \
5968 #define CHECK_ENTSIZE(section, i, type) \
5969 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5970 sizeof (Elf64_External_##type))
5972 for (i
= 0, section
= section_headers
;
5973 i
< elf_header
.e_shnum
;
5976 char * name
= SECTION_NAME (section
);
5978 if (section
->sh_type
== SHT_DYNSYM
)
5980 if (dynamic_symbols
!= NULL
)
5982 error (_("File contains multiple dynamic symbol tables\n"));
5986 CHECK_ENTSIZE (section
, i
, Sym
);
5987 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5989 else if (section
->sh_type
== SHT_STRTAB
5990 && streq (name
, ".dynstr"))
5992 if (dynamic_strings
!= NULL
)
5994 error (_("File contains multiple dynamic string tables\n"));
5998 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5999 1, section
->sh_size
,
6000 _("dynamic strings"));
6001 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6003 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6005 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6006 entry
->hdr
= section
;
6007 entry
->next
= symtab_shndx_list
;
6008 symtab_shndx_list
= entry
;
6010 else if (section
->sh_type
== SHT_SYMTAB
)
6011 CHECK_ENTSIZE (section
, i
, Sym
);
6012 else if (section
->sh_type
== SHT_GROUP
)
6013 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6014 else if (section
->sh_type
== SHT_REL
)
6015 CHECK_ENTSIZE (section
, i
, Rel
);
6016 else if (section
->sh_type
== SHT_RELA
)
6017 CHECK_ENTSIZE (section
, i
, Rela
);
6018 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6019 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6020 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6021 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6022 || do_debug_addr
|| do_debug_cu_index
)
6023 && (const_strneq (name
, ".debug_")
6024 || const_strneq (name
, ".zdebug_")))
6027 name
+= sizeof (".zdebug_") - 1;
6029 name
+= sizeof (".debug_") - 1;
6032 || (do_debug_info
&& const_strneq (name
, "info"))
6033 || (do_debug_info
&& const_strneq (name
, "types"))
6034 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6035 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6036 || (do_debug_lines
&& const_strneq (name
, "line."))
6037 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6038 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6039 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6040 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6041 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6042 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6043 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6044 || (do_debug_frames
&& const_strneq (name
, "frame"))
6045 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6046 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6047 || (do_debug_str
&& const_strneq (name
, "str"))
6048 || (do_debug_loc
&& const_strneq (name
, "loc"))
6049 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6050 || (do_debug_addr
&& const_strneq (name
, "addr"))
6051 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6052 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6054 request_dump_bynumber (i
, DEBUG_DUMP
);
6056 /* Linkonce section to be combined with .debug_info at link time. */
6057 else if ((do_debugging
|| do_debug_info
)
6058 && const_strneq (name
, ".gnu.linkonce.wi."))
6059 request_dump_bynumber (i
, DEBUG_DUMP
);
6060 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6061 request_dump_bynumber (i
, DEBUG_DUMP
);
6062 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
6063 request_dump_bynumber (i
, DEBUG_DUMP
);
6064 /* Trace sections for Itanium VMS. */
6065 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6066 || do_trace_aranges
)
6067 && const_strneq (name
, ".trace_"))
6069 name
+= sizeof (".trace_") - 1;
6072 || (do_trace_info
&& streq (name
, "info"))
6073 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6074 || (do_trace_aranges
&& streq (name
, "aranges"))
6076 request_dump_bynumber (i
, DEBUG_DUMP
);
6083 if (elf_header
.e_shnum
> 1)
6084 printf (_("\nSection Headers:\n"));
6086 printf (_("\nSection Header:\n"));
6090 if (do_section_details
)
6092 printf (_(" [Nr] Name\n"));
6093 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6097 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6101 if (do_section_details
)
6103 printf (_(" [Nr] Name\n"));
6104 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6108 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6112 if (do_section_details
)
6114 printf (_(" [Nr] Name\n"));
6115 printf (_(" Type Address Offset Link\n"));
6116 printf (_(" Size EntSize Info Align\n"));
6120 printf (_(" [Nr] Name Type Address Offset\n"));
6121 printf (_(" Size EntSize Flags Link Info Align\n"));
6125 if (do_section_details
)
6126 printf (_(" Flags\n"));
6128 for (i
= 0, section
= section_headers
;
6129 i
< elf_header
.e_shnum
;
6132 /* Run some sanity checks on the section header. */
6134 /* Check the sh_link field. */
6135 switch (section
->sh_type
)
6137 case SHT_SYMTAB_SHNDX
:
6141 case SHT_GNU_versym
:
6144 if (section
->sh_link
< 1
6145 || section
->sh_link
>= elf_header
.e_shnum
6146 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6147 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6148 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6149 i
, section
->sh_link
);
6155 case SHT_GNU_verneed
:
6156 case SHT_GNU_verdef
:
6157 case SHT_GNU_LIBLIST
:
6158 if (section
->sh_link
< 1
6159 || section
->sh_link
>= elf_header
.e_shnum
6160 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6161 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6162 i
, section
->sh_link
);
6165 case SHT_INIT_ARRAY
:
6166 case SHT_FINI_ARRAY
:
6167 case SHT_PREINIT_ARRAY
:
6168 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6169 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6170 i
, section
->sh_link
);
6174 /* FIXME: Add support for target specific section types. */
6175 #if 0 /* Currently we do not check other section types as there are too
6176 many special cases. Stab sections for example have a type
6177 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6179 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6180 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6181 i
, section
->sh_link
);
6186 /* Check the sh_info field. */
6187 switch (section
->sh_type
)
6191 if (section
->sh_info
< 1
6192 || section
->sh_info
>= elf_header
.e_shnum
6193 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6194 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6195 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6196 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6197 /* FIXME: Are other section types valid ? */
6198 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6200 if (section
->sh_info
== 0
6201 && (streq (SECTION_NAME (section
), ".rel.dyn")
6202 || streq (SECTION_NAME (section
), ".rela.dyn")))
6203 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6204 of zero. The relocations in these sections may apply
6205 to many different sections. */
6208 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6209 i
, section
->sh_info
);
6215 case SHT_SYMTAB_SHNDX
:
6216 case SHT_INIT_ARRAY
:
6217 case SHT_FINI_ARRAY
:
6218 case SHT_PREINIT_ARRAY
:
6219 if (section
->sh_info
!= 0)
6220 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6221 i
, section
->sh_info
);
6227 /* A symbol index - we assume that it is valid. */
6231 /* FIXME: Add support for target specific section types. */
6232 if (section
->sh_type
== SHT_NOBITS
)
6233 /* NOBITS section headers with non-zero sh_info fields can be
6234 created when a binary is stripped of everything but its debug
6235 information. The stripped sections have their headers
6236 preserved but their types set to SHT_NOBITS. So do not check
6237 this type of section. */
6239 else if (section
->sh_flags
& SHF_INFO_LINK
)
6241 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6242 warn (_("[%2u]: Expected link to another section in info field"), i
);
6244 else if (section
->sh_type
< SHT_LOOS
6245 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6246 && section
->sh_info
!= 0)
6247 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6248 i
, section
->sh_info
);
6252 /* Check the sh_size field. */
6253 if (section
->sh_size
> current_file_size
6254 && section
->sh_type
!= SHT_NOBITS
6255 && section
->sh_type
!= SHT_NULL
6256 && section
->sh_type
< SHT_LOOS
)
6257 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6259 printf (" [%2u] ", i
);
6260 if (do_section_details
)
6261 printf ("%s\n ", printable_section_name (section
));
6263 print_symbol (-17, SECTION_NAME (section
));
6265 printf (do_wide
? " %-15s " : " %-15.15s ",
6266 get_section_type_name (section
->sh_type
));
6270 const char * link_too_big
= NULL
;
6272 print_vma (section
->sh_addr
, LONG_HEX
);
6274 printf ( " %6.6lx %6.6lx %2.2lx",
6275 (unsigned long) section
->sh_offset
,
6276 (unsigned long) section
->sh_size
,
6277 (unsigned long) section
->sh_entsize
);
6279 if (do_section_details
)
6280 fputs (" ", stdout
);
6282 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6284 if (section
->sh_link
>= elf_header
.e_shnum
)
6287 /* The sh_link value is out of range. Normally this indicates
6288 an error but it can have special values in Solaris binaries. */
6289 switch (elf_header
.e_machine
)
6296 case EM_OLD_SPARCV9
:
6297 case EM_SPARC32PLUS
:
6300 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6301 link_too_big
= "BEFORE";
6302 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6303 link_too_big
= "AFTER";
6310 if (do_section_details
)
6312 if (link_too_big
!= NULL
&& * link_too_big
)
6313 printf ("<%s> ", link_too_big
);
6315 printf ("%2u ", section
->sh_link
);
6316 printf ("%3u %2lu\n", section
->sh_info
,
6317 (unsigned long) section
->sh_addralign
);
6320 printf ("%2u %3u %2lu\n",
6323 (unsigned long) section
->sh_addralign
);
6325 if (link_too_big
&& ! * link_too_big
)
6326 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6327 i
, section
->sh_link
);
6331 print_vma (section
->sh_addr
, LONG_HEX
);
6333 if ((long) section
->sh_offset
== section
->sh_offset
)
6334 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6338 print_vma (section
->sh_offset
, LONG_HEX
);
6341 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6342 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6346 print_vma (section
->sh_size
, LONG_HEX
);
6349 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6350 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6354 print_vma (section
->sh_entsize
, LONG_HEX
);
6357 if (do_section_details
)
6358 fputs (" ", stdout
);
6360 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6362 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6364 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6365 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6368 print_vma (section
->sh_addralign
, DEC
);
6372 else if (do_section_details
)
6374 printf (" %-15.15s ",
6375 get_section_type_name (section
->sh_type
));
6376 print_vma (section
->sh_addr
, LONG_HEX
);
6377 if ((long) section
->sh_offset
== section
->sh_offset
)
6378 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6382 print_vma (section
->sh_offset
, LONG_HEX
);
6384 printf (" %u\n ", section
->sh_link
);
6385 print_vma (section
->sh_size
, LONG_HEX
);
6387 print_vma (section
->sh_entsize
, LONG_HEX
);
6389 printf (" %-16u %lu\n",
6391 (unsigned long) section
->sh_addralign
);
6396 print_vma (section
->sh_addr
, LONG_HEX
);
6397 if ((long) section
->sh_offset
== section
->sh_offset
)
6398 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6402 print_vma (section
->sh_offset
, LONG_HEX
);
6405 print_vma (section
->sh_size
, LONG_HEX
);
6407 print_vma (section
->sh_entsize
, LONG_HEX
);
6409 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6411 printf (" %2u %3u %lu\n",
6414 (unsigned long) section
->sh_addralign
);
6417 if (do_section_details
)
6419 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6420 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6422 /* Minimum section size is 12 bytes for 32-bit compression
6423 header + 12 bytes for compressed data header. */
6424 unsigned char buf
[24];
6426 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6427 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6428 sizeof (buf
), _("compression header")))
6430 Elf_Internal_Chdr chdr
;
6432 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6434 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6437 printf (_(" [<unknown>: 0x%x], "),
6439 print_vma (chdr
.ch_size
, LONG_HEX
);
6440 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6446 if (!do_section_details
)
6448 /* The ordering of the letters shown here matches the ordering of the
6449 corresponding SHF_xxx values, and hence the order in which these
6450 letters will be displayed to the user. */
6451 printf (_("Key to Flags:\n\
6452 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6453 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6454 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6455 if (elf_header
.e_machine
== EM_X86_64
6456 || elf_header
.e_machine
== EM_L1OM
6457 || elf_header
.e_machine
== EM_K1OM
)
6458 printf (_("l (large), "));
6459 else if (elf_header
.e_machine
== EM_ARM
)
6460 printf (_("y (purecode), "));
6461 printf ("p (processor specific)\n");
6468 get_group_flags (unsigned int flags
)
6470 static char buff
[128];
6474 else if (flags
== GRP_COMDAT
)
6477 snprintf (buff
, 14, _("[0x%x: "), flags
);
6479 flags
&= ~ GRP_COMDAT
;
6480 if (flags
& GRP_MASKOS
)
6482 strcat (buff
, "<OS specific>");
6483 flags
&= ~ GRP_MASKOS
;
6486 if (flags
& GRP_MASKPROC
)
6488 strcat (buff
, "<PROC specific>");
6489 flags
&= ~ GRP_MASKPROC
;
6493 strcat (buff
, "<unknown>");
6500 process_section_groups (FILE * file
)
6502 Elf_Internal_Shdr
* section
;
6504 struct group
* group
;
6505 Elf_Internal_Shdr
* symtab_sec
;
6506 Elf_Internal_Shdr
* strtab_sec
;
6507 Elf_Internal_Sym
* symtab
;
6508 unsigned long num_syms
;
6512 /* Don't process section groups unless needed. */
6513 if (!do_unwind
&& !do_section_groups
)
6516 if (elf_header
.e_shnum
== 0)
6518 if (do_section_groups
)
6519 printf (_("\nThere are no sections to group in this file.\n"));
6524 if (section_headers
== NULL
)
6526 error (_("Section headers are not available!\n"));
6527 /* PR 13622: This can happen with a corrupt ELF header. */
6531 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6532 sizeof (struct group
*));
6534 if (section_headers_groups
== NULL
)
6536 error (_("Out of memory reading %u section group headers\n"),
6537 elf_header
.e_shnum
);
6541 /* Scan the sections for the group section. */
6543 for (i
= 0, section
= section_headers
;
6544 i
< elf_header
.e_shnum
;
6546 if (section
->sh_type
== SHT_GROUP
)
6549 if (group_count
== 0)
6551 if (do_section_groups
)
6552 printf (_("\nThere are no section groups in this file.\n"));
6557 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6559 if (section_groups
== NULL
)
6561 error (_("Out of memory reading %lu groups\n"),
6562 (unsigned long) group_count
);
6572 for (i
= 0, section
= section_headers
, group
= section_groups
;
6573 i
< elf_header
.e_shnum
;
6576 if (section
->sh_type
== SHT_GROUP
)
6578 const char * name
= printable_section_name (section
);
6579 const char * group_name
;
6580 unsigned char * start
;
6581 unsigned char * indices
;
6582 unsigned int entry
, j
, size
;
6583 Elf_Internal_Shdr
* sec
;
6584 Elf_Internal_Sym
* sym
;
6586 /* Get the symbol table. */
6587 if (section
->sh_link
>= elf_header
.e_shnum
6588 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6591 error (_("Bad sh_link in group section `%s'\n"), name
);
6595 if (symtab_sec
!= sec
)
6600 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6605 error (_("Corrupt header in group section `%s'\n"), name
);
6609 if (section
->sh_info
>= num_syms
)
6611 error (_("Bad sh_info in group section `%s'\n"), name
);
6615 sym
= symtab
+ section
->sh_info
;
6617 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6619 if (sym
->st_shndx
== 0
6620 || sym
->st_shndx
>= elf_header
.e_shnum
)
6622 error (_("Bad sh_info in group section `%s'\n"), name
);
6626 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6635 /* Get the string table. */
6636 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6645 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6651 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6652 1, strtab_sec
->sh_size
,
6654 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6656 group_name
= sym
->st_name
< strtab_size
6657 ? strtab
+ sym
->st_name
: _("<corrupt>");
6660 /* PR 17531: file: loop. */
6661 if (section
->sh_entsize
> section
->sh_size
)
6663 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6664 printable_section_name (section
),
6665 (unsigned long) section
->sh_entsize
,
6666 (unsigned long) section
->sh_size
);
6670 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6671 1, section
->sh_size
,
6677 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6678 entry
= byte_get (indices
, 4);
6681 if (do_section_groups
)
6683 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6684 get_group_flags (entry
), i
, name
, group_name
, size
);
6686 printf (_(" [Index] Name\n"));
6689 group
->group_index
= i
;
6691 for (j
= 0; j
< size
; j
++)
6693 struct group_list
* g
;
6695 entry
= byte_get (indices
, 4);
6698 if (entry
>= elf_header
.e_shnum
)
6700 static unsigned num_group_errors
= 0;
6702 if (num_group_errors
++ < 10)
6704 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6705 entry
, i
, elf_header
.e_shnum
- 1);
6706 if (num_group_errors
== 10)
6707 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6712 if (section_headers_groups
[entry
] != NULL
)
6716 static unsigned num_errs
= 0;
6718 if (num_errs
++ < 10)
6720 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6722 section_headers_groups
[entry
]->group_index
);
6724 warn (_("Further error messages about already contained group sections suppressed\n"));
6730 /* Intel C/C++ compiler may put section 0 in a
6731 section group. We just warn it the first time
6732 and ignore it afterwards. */
6733 static bfd_boolean warned
= FALSE
;
6736 error (_("section 0 in group section [%5u]\n"),
6737 section_headers_groups
[entry
]->group_index
);
6743 section_headers_groups
[entry
] = group
;
6745 if (do_section_groups
)
6747 sec
= section_headers
+ entry
;
6748 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6751 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6752 g
->section_index
= entry
;
6753 g
->next
= group
->root
;
6771 /* Data used to display dynamic fixups. */
6773 struct ia64_vms_dynfixup
6775 bfd_vma needed_ident
; /* Library ident number. */
6776 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6777 bfd_vma fixup_needed
; /* Index of the library. */
6778 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6779 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6782 /* Data used to display dynamic relocations. */
6784 struct ia64_vms_dynimgrela
6786 bfd_vma img_rela_cnt
; /* Number of relocations. */
6787 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6790 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6794 dump_ia64_vms_dynamic_fixups (FILE * file
,
6795 struct ia64_vms_dynfixup
* fixup
,
6796 const char * strtab
,
6797 unsigned int strtab_sz
)
6799 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6801 const char * lib_name
;
6803 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6804 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6805 _("dynamic section image fixups"));
6809 if (fixup
->needed
< strtab_sz
)
6810 lib_name
= strtab
+ fixup
->needed
;
6813 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6814 (unsigned long) fixup
->needed
);
6817 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6818 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6820 (_("Seg Offset Type SymVec DataType\n"));
6822 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6827 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6828 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6829 type
= BYTE_GET (imfs
[i
].type
);
6830 rtype
= elf_ia64_reloc_type (type
);
6832 printf (" 0x%08x ", type
);
6834 printf (" %-32s ", rtype
);
6835 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6836 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6843 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6846 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6848 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6851 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6852 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6853 _("dynamic section image relocations"));
6857 printf (_("\nImage relocs\n"));
6859 (_("Seg Offset Type Addend Seg Sym Off\n"));
6861 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6866 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6867 printf ("%08" BFD_VMA_FMT
"x ",
6868 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6869 type
= BYTE_GET (imrs
[i
].type
);
6870 rtype
= elf_ia64_reloc_type (type
);
6872 printf ("0x%08x ", type
);
6874 printf ("%-31s ", rtype
);
6875 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6876 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6877 printf ("%08" BFD_VMA_FMT
"x\n",
6878 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6885 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6888 process_ia64_vms_dynamic_relocs (FILE *file
)
6890 struct ia64_vms_dynfixup fixup
;
6891 struct ia64_vms_dynimgrela imgrela
;
6892 Elf_Internal_Dyn
*entry
;
6893 bfd_vma strtab_off
= 0;
6894 bfd_vma strtab_sz
= 0;
6895 char *strtab
= NULL
;
6896 bfd_boolean res
= TRUE
;
6898 memset (&fixup
, 0, sizeof (fixup
));
6899 memset (&imgrela
, 0, sizeof (imgrela
));
6901 /* Note: the order of the entries is specified by the OpenVMS specs. */
6902 for (entry
= dynamic_section
;
6903 entry
< dynamic_section
+ dynamic_nent
;
6906 switch (entry
->d_tag
)
6908 case DT_IA_64_VMS_STRTAB_OFFSET
:
6909 strtab_off
= entry
->d_un
.d_val
;
6912 strtab_sz
= entry
->d_un
.d_val
;
6914 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6915 1, strtab_sz
, _("dynamic string section"));
6918 case DT_IA_64_VMS_NEEDED_IDENT
:
6919 fixup
.needed_ident
= entry
->d_un
.d_val
;
6922 fixup
.needed
= entry
->d_un
.d_val
;
6924 case DT_IA_64_VMS_FIXUP_NEEDED
:
6925 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6927 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6928 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6930 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6931 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6932 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6935 case DT_IA_64_VMS_IMG_RELA_CNT
:
6936 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6938 case DT_IA_64_VMS_IMG_RELA_OFF
:
6939 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6940 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6962 dynamic_relocations
[] =
6964 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6965 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6966 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6969 /* Process the reloc section. */
6972 process_relocs (FILE * file
)
6974 unsigned long rel_size
;
6975 unsigned long rel_offset
;
6980 if (do_using_dynamic
)
6984 bfd_boolean has_dynamic_reloc
;
6987 has_dynamic_reloc
= FALSE
;
6989 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6991 is_rela
= dynamic_relocations
[i
].rela
;
6992 name
= dynamic_relocations
[i
].name
;
6993 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6994 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6997 has_dynamic_reloc
= TRUE
;
6999 if (is_rela
== UNKNOWN
)
7001 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7002 switch (dynamic_info
[DT_PLTREL
])
7016 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7017 name
, rel_offset
, rel_size
);
7019 dump_relocations (file
,
7020 offset_from_vma (file
, rel_offset
, rel_size
),
7022 dynamic_symbols
, num_dynamic_syms
,
7023 dynamic_strings
, dynamic_strings_length
,
7024 is_rela
, TRUE
/* is_dynamic */);
7029 if (process_ia64_vms_dynamic_relocs (file
))
7030 has_dynamic_reloc
= TRUE
;
7032 if (! has_dynamic_reloc
)
7033 printf (_("\nThere are no dynamic relocations in this file.\n"));
7037 Elf_Internal_Shdr
* section
;
7039 bfd_boolean found
= FALSE
;
7041 for (i
= 0, section
= section_headers
;
7042 i
< elf_header
.e_shnum
;
7045 if ( section
->sh_type
!= SHT_RELA
7046 && section
->sh_type
!= SHT_REL
)
7049 rel_offset
= section
->sh_offset
;
7050 rel_size
= section
->sh_size
;
7054 Elf_Internal_Shdr
* strsec
;
7057 printf (_("\nRelocation section "));
7059 if (string_table
== NULL
)
7060 printf ("%d", section
->sh_name
);
7062 printf ("'%s'", printable_section_name (section
));
7064 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7065 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
7067 is_rela
= section
->sh_type
== SHT_RELA
;
7069 if (section
->sh_link
!= 0
7070 && section
->sh_link
< elf_header
.e_shnum
)
7072 Elf_Internal_Shdr
* symsec
;
7073 Elf_Internal_Sym
* symtab
;
7074 unsigned long nsyms
;
7075 unsigned long strtablen
= 0;
7076 char * strtab
= NULL
;
7078 symsec
= section_headers
+ section
->sh_link
;
7079 if (symsec
->sh_type
!= SHT_SYMTAB
7080 && symsec
->sh_type
!= SHT_DYNSYM
)
7083 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7088 if (symsec
->sh_link
!= 0
7089 && symsec
->sh_link
< elf_header
.e_shnum
)
7091 strsec
= section_headers
+ symsec
->sh_link
;
7093 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7096 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7099 dump_relocations (file
, rel_offset
, rel_size
,
7100 symtab
, nsyms
, strtab
, strtablen
,
7102 symsec
->sh_type
== SHT_DYNSYM
);
7108 dump_relocations (file
, rel_offset
, rel_size
,
7109 NULL
, 0, NULL
, 0, is_rela
,
7110 FALSE
/* is_dynamic */);
7117 printf (_("\nThere are no relocations in this file.\n"));
7123 /* An absolute address consists of a section and an offset. If the
7124 section is NULL, the offset itself is the address, otherwise, the
7125 address equals to LOAD_ADDRESS(section) + offset. */
7129 unsigned short section
;
7133 #define ABSADDR(a) \
7135 ? section_headers [(a).section].sh_addr + (a).offset \
7138 /* Find the nearest symbol at or below ADDR. Returns the symbol
7139 name, if found, and the offset from the symbol to ADDR. */
7142 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7143 unsigned long nsyms
,
7144 const char * strtab
,
7145 unsigned long strtab_size
,
7146 struct absaddr addr
,
7147 const char ** symname
,
7150 bfd_vma dist
= 0x100000;
7151 Elf_Internal_Sym
* sym
;
7152 Elf_Internal_Sym
* beg
;
7153 Elf_Internal_Sym
* end
;
7154 Elf_Internal_Sym
* best
= NULL
;
7156 REMOVE_ARCH_BITS (addr
.offset
);
7158 end
= symtab
+ nsyms
;
7164 sym
= beg
+ (end
- beg
) / 2;
7166 value
= sym
->st_value
;
7167 REMOVE_ARCH_BITS (value
);
7169 if (sym
->st_name
!= 0
7170 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7171 && addr
.offset
>= value
7172 && addr
.offset
- value
< dist
)
7175 dist
= addr
.offset
- value
;
7180 if (addr
.offset
< value
)
7188 *symname
= (best
->st_name
>= strtab_size
7189 ? _("<corrupt>") : strtab
+ best
->st_name
);
7195 *offset
= addr
.offset
;
7198 static /* signed */ int
7199 symcmp (const void *p
, const void *q
)
7201 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7202 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7204 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7207 /* Process the unwind section. */
7209 #include "unwind-ia64.h"
7211 struct ia64_unw_table_entry
7213 struct absaddr start
;
7215 struct absaddr info
;
7218 struct ia64_unw_aux_info
7220 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7221 unsigned long table_len
; /* Length of unwind table. */
7222 unsigned char * info
; /* Unwind info. */
7223 unsigned long info_size
; /* Size of unwind info. */
7224 bfd_vma info_addr
; /* Starting address of unwind info. */
7225 bfd_vma seg_base
; /* Starting address of segment. */
7226 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7227 unsigned long nsyms
; /* Number of symbols. */
7228 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7229 unsigned long nfuns
; /* Number of entries in funtab. */
7230 char * strtab
; /* The string table. */
7231 unsigned long strtab_size
; /* Size of string table. */
7235 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7237 struct ia64_unw_table_entry
* tp
;
7238 unsigned long j
, nfuns
;
7240 bfd_boolean res
= TRUE
;
7242 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7243 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7244 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7245 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7247 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7249 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7253 const unsigned char * dp
;
7254 const unsigned char * head
;
7255 const unsigned char * end
;
7256 const char * procname
;
7258 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7259 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7261 fputs ("\n<", stdout
);
7265 fputs (procname
, stdout
);
7268 printf ("+%lx", (unsigned long) offset
);
7271 fputs (">: [", stdout
);
7272 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7273 fputc ('-', stdout
);
7274 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7275 printf ("], info at +0x%lx\n",
7276 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7278 /* PR 17531: file: 86232b32. */
7279 if (aux
->info
== NULL
)
7282 /* PR 17531: file: 0997b4d1. */
7283 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7285 warn (_("Invalid offset %lx in table entry %ld\n"),
7286 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7291 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7292 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7294 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7295 (unsigned) UNW_VER (stamp
),
7296 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7297 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7298 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7299 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7301 if (UNW_VER (stamp
) != 1)
7303 printf (_("\tUnknown version.\n"));
7308 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7309 /* PR 17531: file: 16ceda89. */
7310 if (end
> aux
->info
+ aux
->info_size
)
7311 end
= aux
->info
+ aux
->info_size
;
7312 for (dp
= head
+ 8; dp
< end
;)
7313 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7322 slurp_ia64_unwind_table (FILE * file
,
7323 struct ia64_unw_aux_info
* aux
,
7324 Elf_Internal_Shdr
* sec
)
7326 unsigned long size
, nrelas
, i
;
7327 Elf_Internal_Phdr
* seg
;
7328 struct ia64_unw_table_entry
* tep
;
7329 Elf_Internal_Shdr
* relsec
;
7330 Elf_Internal_Rela
* rela
;
7331 Elf_Internal_Rela
* rp
;
7332 unsigned char * table
;
7334 Elf_Internal_Sym
* sym
;
7335 const char * relname
;
7339 /* First, find the starting address of the segment that includes
7342 if (elf_header
.e_phnum
)
7344 if (! get_program_headers (file
))
7347 for (seg
= program_headers
;
7348 seg
< program_headers
+ elf_header
.e_phnum
;
7351 if (seg
->p_type
!= PT_LOAD
)
7354 if (sec
->sh_addr
>= seg
->p_vaddr
7355 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7357 aux
->seg_base
= seg
->p_vaddr
;
7363 /* Second, build the unwind table from the contents of the unwind section: */
7364 size
= sec
->sh_size
;
7365 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7370 aux
->table_len
= size
/ (3 * eh_addr_size
);
7371 aux
->table
= (struct ia64_unw_table_entry
*)
7372 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7375 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7377 tep
->start
.section
= SHN_UNDEF
;
7378 tep
->end
.section
= SHN_UNDEF
;
7379 tep
->info
.section
= SHN_UNDEF
;
7380 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7381 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7382 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7383 tep
->start
.offset
+= aux
->seg_base
;
7384 tep
->end
.offset
+= aux
->seg_base
;
7385 tep
->info
.offset
+= aux
->seg_base
;
7389 /* Third, apply any relocations to the unwind table: */
7390 for (relsec
= section_headers
;
7391 relsec
< section_headers
+ elf_header
.e_shnum
;
7394 if (relsec
->sh_type
!= SHT_RELA
7395 || relsec
->sh_info
>= elf_header
.e_shnum
7396 || section_headers
+ relsec
->sh_info
!= sec
)
7399 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7408 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7410 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7411 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7413 /* PR 17531: file: 9fa67536. */
7414 if (relname
== NULL
)
7416 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7420 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7422 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7426 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7428 /* PR 17531: file: 5bc8d9bf. */
7429 if (i
>= aux
->table_len
)
7431 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7435 switch (rp
->r_offset
/ eh_addr_size
% 3)
7438 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7439 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7442 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7443 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7446 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7447 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7461 ia64_process_unwind (FILE * file
)
7463 Elf_Internal_Shdr
* sec
;
7464 Elf_Internal_Shdr
* unwsec
= NULL
;
7465 Elf_Internal_Shdr
* strsec
;
7466 unsigned long i
, unwcount
= 0, unwstart
= 0;
7467 struct ia64_unw_aux_info aux
;
7468 bfd_boolean res
= TRUE
;
7470 memset (& aux
, 0, sizeof (aux
));
7472 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7474 if (sec
->sh_type
== SHT_SYMTAB
7475 && sec
->sh_link
< elf_header
.e_shnum
)
7477 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7479 strsec
= section_headers
+ sec
->sh_link
;
7480 if (aux
.strtab
!= NULL
)
7482 error (_("Multiple auxillary string tables encountered\n"));
7486 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7489 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7491 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7496 printf (_("\nThere are no unwind sections in this file.\n"));
7498 while (unwcount
-- > 0)
7503 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7504 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7505 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7510 /* We have already counted the number of SHT_IA64_UNWIND
7511 sections so the loop above should never fail. */
7512 assert (unwsec
!= NULL
);
7515 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7517 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7519 /* We need to find which section group it is in. */
7520 struct group_list
* g
;
7522 if (section_headers_groups
== NULL
7523 || section_headers_groups
[i
] == NULL
)
7524 i
= elf_header
.e_shnum
;
7527 g
= section_headers_groups
[i
]->root
;
7529 for (; g
!= NULL
; g
= g
->next
)
7531 sec
= section_headers
+ g
->section_index
;
7533 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7538 i
= elf_header
.e_shnum
;
7541 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7543 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7544 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7545 suffix
= SECTION_NAME (unwsec
) + len
;
7546 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7548 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7549 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7554 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7555 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7556 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7557 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7559 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7560 suffix
= SECTION_NAME (unwsec
) + len
;
7561 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7563 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7564 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7568 if (i
== elf_header
.e_shnum
)
7570 printf (_("\nCould not find unwind info section for "));
7572 if (string_table
== NULL
)
7573 printf ("%d", unwsec
->sh_name
);
7575 printf ("'%s'", printable_section_name (unwsec
));
7579 aux
.info_addr
= sec
->sh_addr
;
7580 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7583 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7585 printf (_("\nUnwind section "));
7587 if (string_table
== NULL
)
7588 printf ("%d", unwsec
->sh_name
);
7590 printf ("'%s'", printable_section_name (unwsec
));
7592 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7593 (unsigned long) unwsec
->sh_offset
,
7594 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7596 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7597 && aux
.table_len
> 0)
7598 dump_ia64_unwind (& aux
);
7601 free ((char *) aux
.table
);
7603 free ((char *) aux
.info
);
7612 free ((char *) aux
.strtab
);
7617 struct hppa_unw_table_entry
7619 struct absaddr start
;
7621 unsigned int Cannot_unwind
:1; /* 0 */
7622 unsigned int Millicode
:1; /* 1 */
7623 unsigned int Millicode_save_sr0
:1; /* 2 */
7624 unsigned int Region_description
:2; /* 3..4 */
7625 unsigned int reserved1
:1; /* 5 */
7626 unsigned int Entry_SR
:1; /* 6 */
7627 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7628 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7629 unsigned int Args_stored
:1; /* 16 */
7630 unsigned int Variable_Frame
:1; /* 17 */
7631 unsigned int Separate_Package_Body
:1; /* 18 */
7632 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7633 unsigned int Stack_Overflow_Check
:1; /* 20 */
7634 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7635 unsigned int Ada_Region
:1; /* 22 */
7636 unsigned int cxx_info
:1; /* 23 */
7637 unsigned int cxx_try_catch
:1; /* 24 */
7638 unsigned int sched_entry_seq
:1; /* 25 */
7639 unsigned int reserved2
:1; /* 26 */
7640 unsigned int Save_SP
:1; /* 27 */
7641 unsigned int Save_RP
:1; /* 28 */
7642 unsigned int Save_MRP_in_frame
:1; /* 29 */
7643 unsigned int extn_ptr_defined
:1; /* 30 */
7644 unsigned int Cleanup_defined
:1; /* 31 */
7646 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7647 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7648 unsigned int Large_frame
:1; /* 2 */
7649 unsigned int Pseudo_SP_Set
:1; /* 3 */
7650 unsigned int reserved4
:1; /* 4 */
7651 unsigned int Total_frame_size
:27; /* 5..31 */
7654 struct hppa_unw_aux_info
7656 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7657 unsigned long table_len
; /* Length of unwind table. */
7658 bfd_vma seg_base
; /* Starting address of segment. */
7659 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7660 unsigned long nsyms
; /* Number of symbols. */
7661 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7662 unsigned long nfuns
; /* Number of entries in funtab. */
7663 char * strtab
; /* The string table. */
7664 unsigned long strtab_size
; /* Size of string table. */
7668 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7670 struct hppa_unw_table_entry
* tp
;
7671 unsigned long j
, nfuns
;
7672 bfd_boolean res
= TRUE
;
7674 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7675 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7676 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7677 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7679 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7681 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7684 const char * procname
;
7686 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7687 aux
->strtab_size
, tp
->start
, &procname
,
7690 fputs ("\n<", stdout
);
7694 fputs (procname
, stdout
);
7697 printf ("+%lx", (unsigned long) offset
);
7700 fputs (">: [", stdout
);
7701 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7702 fputc ('-', stdout
);
7703 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7706 #define PF(_m) if (tp->_m) printf (#_m " ");
7707 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7710 PF(Millicode_save_sr0
);
7711 /* PV(Region_description); */
7717 PF(Separate_Package_Body
);
7718 PF(Frame_Extension_Millicode
);
7719 PF(Stack_Overflow_Check
);
7720 PF(Two_Instruction_SP_Increment
);
7724 PF(sched_entry_seq
);
7727 PF(Save_MRP_in_frame
);
7728 PF(extn_ptr_defined
);
7729 PF(Cleanup_defined
);
7730 PF(MPE_XL_interrupt_marker
);
7731 PF(HP_UX_interrupt_marker
);
7734 PV(Total_frame_size
);
7747 slurp_hppa_unwind_table (FILE * file
,
7748 struct hppa_unw_aux_info
* aux
,
7749 Elf_Internal_Shdr
* sec
)
7751 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7752 Elf_Internal_Phdr
* seg
;
7753 struct hppa_unw_table_entry
* tep
;
7754 Elf_Internal_Shdr
* relsec
;
7755 Elf_Internal_Rela
* rela
;
7756 Elf_Internal_Rela
* rp
;
7757 unsigned char * table
;
7759 Elf_Internal_Sym
* sym
;
7760 const char * relname
;
7762 /* First, find the starting address of the segment that includes
7764 if (elf_header
.e_phnum
)
7766 if (! get_program_headers (file
))
7769 for (seg
= program_headers
;
7770 seg
< program_headers
+ elf_header
.e_phnum
;
7773 if (seg
->p_type
!= PT_LOAD
)
7776 if (sec
->sh_addr
>= seg
->p_vaddr
7777 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7779 aux
->seg_base
= seg
->p_vaddr
;
7785 /* Second, build the unwind table from the contents of the unwind
7787 size
= sec
->sh_size
;
7788 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7794 nentries
= size
/ unw_ent_size
;
7795 size
= unw_ent_size
* nentries
;
7797 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7798 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7800 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7802 unsigned int tmp1
, tmp2
;
7804 tep
->start
.section
= SHN_UNDEF
;
7805 tep
->end
.section
= SHN_UNDEF
;
7807 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7808 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7809 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7810 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7812 tep
->start
.offset
+= aux
->seg_base
;
7813 tep
->end
.offset
+= aux
->seg_base
;
7815 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7816 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7817 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7818 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7819 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7820 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7821 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7822 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7823 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7824 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7825 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7826 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7827 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7828 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7829 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7830 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7831 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7832 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7833 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7834 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7835 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7836 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7837 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7838 tep
->Cleanup_defined
= tmp1
& 0x1;
7840 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7841 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7842 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7843 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7844 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7845 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7849 /* Third, apply any relocations to the unwind table. */
7850 for (relsec
= section_headers
;
7851 relsec
< section_headers
+ elf_header
.e_shnum
;
7854 if (relsec
->sh_type
!= SHT_RELA
7855 || relsec
->sh_info
>= elf_header
.e_shnum
7856 || section_headers
+ relsec
->sh_info
!= sec
)
7859 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7863 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7865 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7866 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7868 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7869 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7871 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7875 i
= rp
->r_offset
/ unw_ent_size
;
7877 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7880 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7881 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7884 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7885 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7895 aux
->table_len
= nentries
;
7901 hppa_process_unwind (FILE * file
)
7903 struct hppa_unw_aux_info aux
;
7904 Elf_Internal_Shdr
* unwsec
= NULL
;
7905 Elf_Internal_Shdr
* strsec
;
7906 Elf_Internal_Shdr
* sec
;
7908 bfd_boolean res
= TRUE
;
7910 if (string_table
== NULL
)
7913 memset (& aux
, 0, sizeof (aux
));
7915 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7917 if (sec
->sh_type
== SHT_SYMTAB
7918 && sec
->sh_link
< elf_header
.e_shnum
)
7920 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7922 strsec
= section_headers
+ sec
->sh_link
;
7923 if (aux
.strtab
!= NULL
)
7925 error (_("Multiple auxillary string tables encountered\n"));
7929 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7932 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7934 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7939 printf (_("\nThere are no unwind sections in this file.\n"));
7941 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7943 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7945 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7946 printable_section_name (sec
),
7947 (unsigned long) sec
->sh_offset
,
7948 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7950 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7953 if (aux
.table_len
> 0)
7955 if (! dump_hppa_unwind (&aux
))
7960 free ((char *) aux
.table
);
7968 free ((char *) aux
.strtab
);
7975 unsigned char * data
; /* The unwind data. */
7976 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7977 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7978 unsigned long nrelas
; /* The number of relocations. */
7979 unsigned int rel_type
; /* REL or RELA ? */
7980 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7983 struct arm_unw_aux_info
7985 FILE * file
; /* The file containing the unwind sections. */
7986 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7987 unsigned long nsyms
; /* Number of symbols. */
7988 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7989 unsigned long nfuns
; /* Number of these symbols. */
7990 char * strtab
; /* The file's string table. */
7991 unsigned long strtab_size
; /* Size of string table. */
7995 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7996 bfd_vma fn
, struct absaddr addr
)
7998 const char *procname
;
8001 if (addr
.section
== SHN_UNDEF
)
8004 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8005 aux
->strtab_size
, addr
, &procname
,
8008 print_vma (fn
, PREFIX_HEX
);
8012 fputs (" <", stdout
);
8013 fputs (procname
, stdout
);
8016 printf ("+0x%lx", (unsigned long) sym_offset
);
8017 fputc ('>', stdout
);
8024 arm_free_section (struct arm_section
*arm_sec
)
8026 if (arm_sec
->data
!= NULL
)
8027 free (arm_sec
->data
);
8029 if (arm_sec
->rela
!= NULL
)
8030 free (arm_sec
->rela
);
8033 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8034 cached section and install SEC instead.
8035 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8036 and return its valued in * WORDP, relocating if necessary.
8037 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8038 relocation's offset in ADDR.
8039 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8040 into the string table of the symbol associated with the reloc. If no
8041 reloc was applied store -1 there.
8042 5) Return TRUE upon success, FALSE otherwise. */
8045 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
8046 struct arm_section
* arm_sec
,
8047 Elf_Internal_Shdr
* sec
,
8048 bfd_vma word_offset
,
8049 unsigned int * wordp
,
8050 struct absaddr
* addr
,
8053 Elf_Internal_Rela
*rp
;
8054 Elf_Internal_Sym
*sym
;
8055 const char * relname
;
8057 bfd_boolean wrapped
;
8059 if (sec
== NULL
|| arm_sec
== NULL
)
8062 addr
->section
= SHN_UNDEF
;
8065 if (sym_name
!= NULL
)
8066 *sym_name
= (bfd_vma
) -1;
8068 /* If necessary, update the section cache. */
8069 if (sec
!= arm_sec
->sec
)
8071 Elf_Internal_Shdr
*relsec
;
8073 arm_free_section (arm_sec
);
8076 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8077 sec
->sh_size
, _("unwind data"));
8078 arm_sec
->rela
= NULL
;
8079 arm_sec
->nrelas
= 0;
8081 for (relsec
= section_headers
;
8082 relsec
< section_headers
+ elf_header
.e_shnum
;
8085 if (relsec
->sh_info
>= elf_header
.e_shnum
8086 || section_headers
+ relsec
->sh_info
!= sec
8087 /* PR 15745: Check the section type as well. */
8088 || (relsec
->sh_type
!= SHT_REL
8089 && relsec
->sh_type
!= SHT_RELA
))
8092 arm_sec
->rel_type
= relsec
->sh_type
;
8093 if (relsec
->sh_type
== SHT_REL
)
8095 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8097 & arm_sec
->rela
, & arm_sec
->nrelas
))
8100 else /* relsec->sh_type == SHT_RELA */
8102 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8104 & arm_sec
->rela
, & arm_sec
->nrelas
))
8110 arm_sec
->next_rela
= arm_sec
->rela
;
8113 /* If there is no unwind data we can do nothing. */
8114 if (arm_sec
->data
== NULL
)
8117 /* If the offset is invalid then fail. */
8118 if (/* PR 21343 *//* PR 18879 */
8120 || word_offset
> (sec
->sh_size
- 4)
8121 || ((bfd_signed_vma
) word_offset
) < 0)
8124 /* Get the word at the required offset. */
8125 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8127 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8128 if (arm_sec
->rela
== NULL
)
8134 /* Look through the relocs to find the one that applies to the provided offset. */
8136 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8138 bfd_vma prelval
, offset
;
8140 if (rp
->r_offset
> word_offset
&& !wrapped
)
8145 if (rp
->r_offset
> word_offset
)
8148 if (rp
->r_offset
& 3)
8150 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8151 (unsigned long) rp
->r_offset
);
8155 if (rp
->r_offset
< word_offset
)
8158 /* PR 17531: file: 027-161405-0.004 */
8159 if (aux
->symtab
== NULL
)
8162 if (arm_sec
->rel_type
== SHT_REL
)
8164 offset
= word
& 0x7fffffff;
8165 if (offset
& 0x40000000)
8166 offset
|= ~ (bfd_vma
) 0x7fffffff;
8168 else if (arm_sec
->rel_type
== SHT_RELA
)
8169 offset
= rp
->r_addend
;
8172 error (_("Unknown section relocation type %d encountered\n"),
8177 /* PR 17531 file: 027-1241568-0.004. */
8178 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8180 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8181 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8185 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8186 offset
+= sym
->st_value
;
8187 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8189 /* Check that we are processing the expected reloc type. */
8190 if (elf_header
.e_machine
== EM_ARM
)
8192 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8193 if (relname
== NULL
)
8195 warn (_("Skipping unknown ARM relocation type: %d\n"),
8196 (int) ELF32_R_TYPE (rp
->r_info
));
8200 if (streq (relname
, "R_ARM_NONE"))
8203 if (! streq (relname
, "R_ARM_PREL31"))
8205 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8209 else if (elf_header
.e_machine
== EM_TI_C6000
)
8211 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8212 if (relname
== NULL
)
8214 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8215 (int) ELF32_R_TYPE (rp
->r_info
));
8219 if (streq (relname
, "R_C6000_NONE"))
8222 if (! streq (relname
, "R_C6000_PREL31"))
8224 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8232 /* This function currently only supports ARM and TI unwinders. */
8233 warn (_("Only TI and ARM unwinders are currently supported\n"));
8237 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8238 addr
->section
= sym
->st_shndx
;
8239 addr
->offset
= offset
;
8242 * sym_name
= sym
->st_name
;
8247 arm_sec
->next_rela
= rp
;
8252 static const char *tic6x_unwind_regnames
[16] =
8254 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8255 "A14", "A13", "A12", "A11", "A10",
8256 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8260 decode_tic6x_unwind_regmask (unsigned int mask
)
8264 for (i
= 12; mask
; mask
>>= 1, i
--)
8268 fputs (tic6x_unwind_regnames
[i
], stdout
);
8270 fputs (", ", stdout
);
8276 if (remaining == 0 && more_words) \
8279 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8280 data_offset, & word, & addr, NULL)) \
8286 #define GET_OP(OP) \
8291 (OP) = word >> 24; \
8296 printf (_("[Truncated opcode]\n")); \
8299 printf ("0x%02x ", OP)
8302 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8304 unsigned int remaining
,
8305 unsigned int more_words
,
8306 bfd_vma data_offset
,
8307 Elf_Internal_Shdr
* data_sec
,
8308 struct arm_section
* data_arm_sec
)
8310 struct absaddr addr
;
8311 bfd_boolean res
= TRUE
;
8313 /* Decode the unwinding instructions. */
8316 unsigned int op
, op2
;
8325 printf (" 0x%02x ", op
);
8327 if ((op
& 0xc0) == 0x00)
8329 int offset
= ((op
& 0x3f) << 2) + 4;
8331 printf (" vsp = vsp + %d", offset
);
8333 else if ((op
& 0xc0) == 0x40)
8335 int offset
= ((op
& 0x3f) << 2) + 4;
8337 printf (" vsp = vsp - %d", offset
);
8339 else if ((op
& 0xf0) == 0x80)
8342 if (op
== 0x80 && op2
== 0)
8343 printf (_("Refuse to unwind"));
8346 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8347 bfd_boolean first
= TRUE
;
8351 for (i
= 0; i
< 12; i
++)
8352 if (mask
& (1 << i
))
8358 printf ("r%d", 4 + i
);
8363 else if ((op
& 0xf0) == 0x90)
8365 if (op
== 0x9d || op
== 0x9f)
8366 printf (_(" [Reserved]"));
8368 printf (" vsp = r%d", op
& 0x0f);
8370 else if ((op
& 0xf0) == 0xa0)
8372 int end
= 4 + (op
& 0x07);
8373 bfd_boolean first
= TRUE
;
8377 for (i
= 4; i
<= end
; i
++)
8393 else if (op
== 0xb0)
8394 printf (_(" finish"));
8395 else if (op
== 0xb1)
8398 if (op2
== 0 || (op2
& 0xf0) != 0)
8399 printf (_("[Spare]"));
8402 unsigned int mask
= op2
& 0x0f;
8403 bfd_boolean first
= TRUE
;
8407 for (i
= 0; i
< 12; i
++)
8408 if (mask
& (1 << i
))
8419 else if (op
== 0xb2)
8421 unsigned char buf
[9];
8422 unsigned int i
, len
;
8423 unsigned long offset
;
8425 for (i
= 0; i
< sizeof (buf
); i
++)
8428 if ((buf
[i
] & 0x80) == 0)
8431 if (i
== sizeof (buf
))
8433 error (_("corrupt change to vsp"));
8438 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8439 assert (len
== i
+ 1);
8440 offset
= offset
* 4 + 0x204;
8441 printf ("vsp = vsp + %ld", offset
);
8444 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8446 unsigned int first
, last
;
8453 printf ("pop {D%d", first
);
8455 printf ("-D%d", first
+ last
);
8458 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8460 unsigned int count
= op
& 0x07;
8464 printf ("-D%d", 8 + count
);
8467 else if (op
>= 0xc0 && op
<= 0xc5)
8469 unsigned int count
= op
& 0x07;
8471 printf (" pop {wR10");
8473 printf ("-wR%d", 10 + count
);
8476 else if (op
== 0xc6)
8478 unsigned int first
, last
;
8483 printf ("pop {wR%d", first
);
8485 printf ("-wR%d", first
+ last
);
8488 else if (op
== 0xc7)
8491 if (op2
== 0 || (op2
& 0xf0) != 0)
8492 printf (_("[Spare]"));
8495 unsigned int mask
= op2
& 0x0f;
8496 bfd_boolean first
= TRUE
;
8500 for (i
= 0; i
< 4; i
++)
8501 if (mask
& (1 << i
))
8507 printf ("wCGR%d", i
);
8514 printf (_(" [unsupported opcode]"));
8525 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8527 unsigned int remaining
,
8528 unsigned int more_words
,
8529 bfd_vma data_offset
,
8530 Elf_Internal_Shdr
* data_sec
,
8531 struct arm_section
* data_arm_sec
)
8533 struct absaddr addr
;
8535 /* Decode the unwinding instructions. */
8538 unsigned int op
, op2
;
8547 printf (" 0x%02x ", op
);
8549 if ((op
& 0xc0) == 0x00)
8551 int offset
= ((op
& 0x3f) << 3) + 8;
8552 printf (" sp = sp + %d", offset
);
8554 else if ((op
& 0xc0) == 0x80)
8557 if (op
== 0x80 && op2
== 0)
8558 printf (_("Refuse to unwind"));
8561 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8563 printf ("pop compact {");
8567 decode_tic6x_unwind_regmask (mask
);
8571 else if ((op
& 0xf0) == 0xc0)
8579 unsigned int offset
;
8583 /* Scan entire instruction first so that GET_OP output is not
8584 interleaved with disassembly. */
8586 for (i
= 0; nregs
< (op
& 0xf); i
++)
8592 regpos
[nregs
].offset
= i
* 2;
8593 regpos
[nregs
].reg
= reg
;
8600 regpos
[nregs
].offset
= i
* 2 + 1;
8601 regpos
[nregs
].reg
= reg
;
8606 printf (_("pop frame {"));
8608 for (i
= i
* 2; i
> 0; i
--)
8610 if (regpos
[reg
].offset
== i
- 1)
8612 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8619 fputs (name
, stdout
);
8626 else if (op
== 0xd0)
8627 printf (" MOV FP, SP");
8628 else if (op
== 0xd1)
8629 printf (" __c6xabi_pop_rts");
8630 else if (op
== 0xd2)
8632 unsigned char buf
[9];
8633 unsigned int i
, len
;
8634 unsigned long offset
;
8636 for (i
= 0; i
< sizeof (buf
); i
++)
8639 if ((buf
[i
] & 0x80) == 0)
8642 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8643 if (i
== sizeof (buf
))
8645 warn (_("Corrupt stack pointer adjustment detected\n"));
8649 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8650 assert (len
== i
+ 1);
8651 offset
= offset
* 8 + 0x408;
8652 printf (_("sp = sp + %ld"), offset
);
8654 else if ((op
& 0xf0) == 0xe0)
8656 if ((op
& 0x0f) == 7)
8659 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8663 printf (_(" [unsupported opcode]"));
8672 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8676 offset
= word
& 0x7fffffff;
8677 if (offset
& 0x40000000)
8678 offset
|= ~ (bfd_vma
) 0x7fffffff;
8680 if (elf_header
.e_machine
== EM_TI_C6000
)
8683 return offset
+ where
;
8687 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8689 unsigned int remaining
,
8690 bfd_vma data_offset
,
8691 Elf_Internal_Shdr
* data_sec
,
8692 struct arm_section
* data_arm_sec
)
8695 unsigned int more_words
= 0;
8696 struct absaddr addr
;
8697 bfd_vma sym_name
= (bfd_vma
) -1;
8698 bfd_boolean res
= FALSE
;
8702 /* Fetch the first word.
8703 Note - when decoding an object file the address extracted
8704 here will always be 0. So we also pass in the sym_name
8705 parameter so that we can find the symbol associated with
8706 the personality routine. */
8707 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8708 & word
, & addr
, & sym_name
))
8714 if ((word
& 0x80000000) == 0)
8716 /* Expand prel31 for personality routine. */
8718 const char *procname
;
8720 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8721 printf (_(" Personality routine: "));
8723 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8724 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8726 procname
= aux
->strtab
+ sym_name
;
8727 print_vma (fn
, PREFIX_HEX
);
8730 fputs (" <", stdout
);
8731 fputs (procname
, stdout
);
8732 fputc ('>', stdout
);
8736 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8737 fputc ('\n', stdout
);
8739 /* The GCC personality routines use the standard compact
8740 encoding, starting with one byte giving the number of
8742 if (procname
!= NULL
8743 && (const_strneq (procname
, "__gcc_personality_v0")
8744 || const_strneq (procname
, "__gxx_personality_v0")
8745 || const_strneq (procname
, "__gcj_personality_v0")
8746 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8753 printf (_(" [Truncated data]\n"));
8756 more_words
= word
>> 24;
8766 /* ARM EHABI Section 6.3:
8768 An exception-handling table entry for the compact model looks like:
8772 1 0 index Data for personalityRoutine[index] */
8774 if (elf_header
.e_machine
== EM_ARM
8775 && (word
& 0x70000000))
8777 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8781 per_index
= (word
>> 24) & 0x7f;
8782 printf (_(" Compact model index: %d\n"), per_index
);
8789 else if (per_index
< 3)
8791 more_words
= (word
>> 16) & 0xff;
8797 switch (elf_header
.e_machine
)
8802 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8803 data_offset
, data_sec
, data_arm_sec
))
8808 warn (_("Unknown ARM compact model index encountered\n"));
8809 printf (_(" [reserved]\n"));
8817 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8818 data_offset
, data_sec
, data_arm_sec
))
8821 else if (per_index
< 5)
8823 if (((word
>> 17) & 0x7f) == 0x7f)
8824 printf (_(" Restore stack from frame pointer\n"));
8826 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8827 printf (_(" Registers restored: "));
8829 printf (" (compact) ");
8830 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8832 printf (_(" Return register: %s\n"),
8833 tic6x_unwind_regnames
[word
& 0xf]);
8836 printf (_(" [reserved (%d)]\n"), per_index
);
8840 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8841 elf_header
.e_machine
);
8845 /* Decode the descriptors. Not implemented. */
8851 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8853 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8854 unsigned int i
, exidx_len
;
8855 unsigned long j
, nfuns
;
8856 bfd_boolean res
= TRUE
;
8858 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8859 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8860 exidx_len
= exidx_sec
->sh_size
/ 8;
8862 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8863 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8864 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8865 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8867 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8869 for (i
= 0; i
< exidx_len
; i
++)
8871 unsigned int exidx_fn
, exidx_entry
;
8872 struct absaddr fn_addr
, entry_addr
;
8875 fputc ('\n', stdout
);
8877 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8878 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8879 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8880 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8883 arm_free_section (& exidx_arm_sec
);
8884 arm_free_section (& extab_arm_sec
);
8888 /* ARM EHABI, Section 5:
8889 An index table entry consists of 2 words.
8890 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8891 if (exidx_fn
& 0x80000000)
8893 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8897 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8899 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8900 fputs (": ", stdout
);
8902 if (exidx_entry
== 1)
8904 print_vma (exidx_entry
, PREFIX_HEX
);
8905 fputs (" [cantunwind]\n", stdout
);
8907 else if (exidx_entry
& 0x80000000)
8909 print_vma (exidx_entry
, PREFIX_HEX
);
8910 fputc ('\n', stdout
);
8911 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8915 bfd_vma table
, table_offset
= 0;
8916 Elf_Internal_Shdr
*table_sec
;
8918 fputs ("@", stdout
);
8919 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8920 print_vma (table
, PREFIX_HEX
);
8923 /* Locate the matching .ARM.extab. */
8924 if (entry_addr
.section
!= SHN_UNDEF
8925 && entry_addr
.section
< elf_header
.e_shnum
)
8927 table_sec
= section_headers
+ entry_addr
.section
;
8928 table_offset
= entry_addr
.offset
;
8930 if (table_offset
> table_sec
->sh_size
8931 || ((bfd_signed_vma
) table_offset
) < 0)
8933 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8934 (unsigned long) table_offset
,
8935 printable_section_name (table_sec
));
8942 table_sec
= find_section_by_address (table
);
8943 if (table_sec
!= NULL
)
8944 table_offset
= table
- table_sec
->sh_addr
;
8947 if (table_sec
== NULL
)
8949 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8950 (unsigned long) table
);
8955 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8964 arm_free_section (&exidx_arm_sec
);
8965 arm_free_section (&extab_arm_sec
);
8970 /* Used for both ARM and C6X unwinding tables. */
8973 arm_process_unwind (FILE *file
)
8975 struct arm_unw_aux_info aux
;
8976 Elf_Internal_Shdr
*unwsec
= NULL
;
8977 Elf_Internal_Shdr
*strsec
;
8978 Elf_Internal_Shdr
*sec
;
8980 unsigned int sec_type
;
8981 bfd_boolean res
= TRUE
;
8983 switch (elf_header
.e_machine
)
8986 sec_type
= SHT_ARM_EXIDX
;
8990 sec_type
= SHT_C6000_UNWIND
;
8994 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8995 elf_header
.e_machine
);
8999 if (string_table
== NULL
)
9002 memset (& aux
, 0, sizeof (aux
));
9005 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9007 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
9009 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
9011 strsec
= section_headers
+ sec
->sh_link
;
9013 /* PR binutils/17531 file: 011-12666-0.004. */
9014 if (aux
.strtab
!= NULL
)
9016 error (_("Multiple string tables found in file.\n"));
9020 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
9021 1, strsec
->sh_size
, _("string table"));
9022 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9024 else if (sec
->sh_type
== sec_type
)
9029 printf (_("\nThere are no unwind sections in this file.\n"));
9031 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9033 if (sec
->sh_type
== sec_type
)
9035 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9036 printable_section_name (sec
),
9037 (unsigned long) sec
->sh_offset
,
9038 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
9040 if (! dump_arm_unwind (&aux
, sec
))
9048 free ((char *) aux
.strtab
);
9054 process_unwind (FILE * file
)
9056 struct unwind_handler
9058 unsigned int machtype
;
9059 bfd_boolean (* handler
)(FILE *);
9062 { EM_ARM
, arm_process_unwind
},
9063 { EM_IA_64
, ia64_process_unwind
},
9064 { EM_PARISC
, hppa_process_unwind
},
9065 { EM_TI_C6000
, arm_process_unwind
},
9073 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9074 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9075 return handlers
[i
].handler (file
);
9077 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9078 get_machine_name (elf_header
.e_machine
));
9083 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9085 switch (entry
->d_tag
)
9088 if (entry
->d_un
.d_val
== 0)
9092 static const char * opts
[] =
9094 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9095 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9096 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9097 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9101 bfd_boolean first
= TRUE
;
9103 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9104 if (entry
->d_un
.d_val
& (1 << cnt
))
9106 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9112 case DT_MIPS_IVERSION
:
9113 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9114 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9118 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9119 /* Note: coded this way so that there is a single string for translation. */
9120 printf (_("<corrupt: %s>"), buf
);
9124 case DT_MIPS_TIME_STAMP
:
9128 time_t atime
= entry
->d_un
.d_val
;
9130 tmp
= gmtime (&atime
);
9131 /* PR 17531: file: 6accc532. */
9133 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9135 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9136 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9137 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9138 printf (_("Time Stamp: %s"), timebuf
);
9142 case DT_MIPS_RLD_VERSION
:
9143 case DT_MIPS_LOCAL_GOTNO
:
9144 case DT_MIPS_CONFLICTNO
:
9145 case DT_MIPS_LIBLISTNO
:
9146 case DT_MIPS_SYMTABNO
:
9147 case DT_MIPS_UNREFEXTNO
:
9148 case DT_MIPS_HIPAGENO
:
9149 case DT_MIPS_DELTA_CLASS_NO
:
9150 case DT_MIPS_DELTA_INSTANCE_NO
:
9151 case DT_MIPS_DELTA_RELOC_NO
:
9152 case DT_MIPS_DELTA_SYM_NO
:
9153 case DT_MIPS_DELTA_CLASSSYM_NO
:
9154 case DT_MIPS_COMPACT_SIZE
:
9155 print_vma (entry
->d_un
.d_val
, DEC
);
9159 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9165 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9167 switch (entry
->d_tag
)
9169 case DT_HP_DLD_FLAGS
:
9178 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9179 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9180 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9181 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9182 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9183 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9184 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9185 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9186 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9187 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9188 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9189 { DT_HP_GST
, "HP_GST" },
9190 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9191 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9192 { DT_HP_NODELETE
, "HP_NODELETE" },
9193 { DT_HP_GROUP
, "HP_GROUP" },
9194 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9196 bfd_boolean first
= TRUE
;
9198 bfd_vma val
= entry
->d_un
.d_val
;
9200 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9201 if (val
& flags
[cnt
].bit
)
9205 fputs (flags
[cnt
].str
, stdout
);
9207 val
^= flags
[cnt
].bit
;
9210 if (val
!= 0 || first
)
9214 print_vma (val
, HEX
);
9220 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9228 /* VMS vs Unix time offset and factor. */
9230 #define VMS_EPOCH_OFFSET 35067168000000000LL
9231 #define VMS_GRANULARITY_FACTOR 10000000
9233 /* Display a VMS time in a human readable format. */
9236 print_vms_time (bfd_int64_t vmstime
)
9241 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9242 tm
= gmtime (&unxtime
);
9243 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9244 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9245 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9250 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9252 switch (entry
->d_tag
)
9254 case DT_IA_64_PLT_RESERVE
:
9255 /* First 3 slots reserved. */
9256 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9258 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9261 case DT_IA_64_VMS_LINKTIME
:
9263 print_vms_time (entry
->d_un
.d_val
);
9267 case DT_IA_64_VMS_LNKFLAGS
:
9268 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9269 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9270 printf (" CALL_DEBUG");
9271 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9272 printf (" NOP0BUFS");
9273 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9274 printf (" P0IMAGE");
9275 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9276 printf (" MKTHREADS");
9277 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9278 printf (" UPCALLS");
9279 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9281 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9282 printf (" INITIALIZE");
9283 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9285 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9286 printf (" EXE_INIT");
9287 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9288 printf (" TBK_IN_IMG");
9289 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9290 printf (" DBG_IN_IMG");
9291 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9292 printf (" TBK_IN_DSF");
9293 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9294 printf (" DBG_IN_DSF");
9295 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9296 printf (" SIGNATURES");
9297 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9298 printf (" REL_SEG_OFF");
9302 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9309 get_32bit_dynamic_section (FILE * file
)
9311 Elf32_External_Dyn
* edyn
;
9312 Elf32_External_Dyn
* ext
;
9313 Elf_Internal_Dyn
* entry
;
9315 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9316 dynamic_size
, _("dynamic section"));
9320 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9321 might not have the luxury of section headers. Look for the DT_NULL
9322 terminator to determine the number of entries. */
9323 for (ext
= edyn
, dynamic_nent
= 0;
9324 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9328 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9332 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9334 if (dynamic_section
== NULL
)
9336 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9337 (unsigned long) dynamic_nent
);
9342 for (ext
= edyn
, entry
= dynamic_section
;
9343 entry
< dynamic_section
+ dynamic_nent
;
9346 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9347 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9356 get_64bit_dynamic_section (FILE * file
)
9358 Elf64_External_Dyn
* edyn
;
9359 Elf64_External_Dyn
* ext
;
9360 Elf_Internal_Dyn
* entry
;
9362 /* Read in the data. */
9363 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9364 dynamic_size
, _("dynamic section"));
9368 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9369 might not have the luxury of section headers. Look for the DT_NULL
9370 terminator to determine the number of entries. */
9371 for (ext
= edyn
, dynamic_nent
= 0;
9372 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9373 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9377 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9381 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9383 if (dynamic_section
== NULL
)
9385 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9386 (unsigned long) dynamic_nent
);
9391 /* Convert from external to internal formats. */
9392 for (ext
= edyn
, entry
= dynamic_section
;
9393 entry
< dynamic_section
+ dynamic_nent
;
9396 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9397 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9406 print_dynamic_flags (bfd_vma flags
)
9408 bfd_boolean first
= TRUE
;
9414 flag
= flags
& - flags
;
9424 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9425 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9426 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9427 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9428 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9429 default: fputs (_("unknown"), stdout
); break;
9435 /* Parse and display the contents of the dynamic section. */
9438 process_dynamic_section (FILE * file
)
9440 Elf_Internal_Dyn
* entry
;
9442 if (dynamic_size
== 0)
9445 printf (_("\nThere is no dynamic section in this file.\n"));
9452 if (! get_32bit_dynamic_section (file
))
9457 if (! get_64bit_dynamic_section (file
))
9461 /* Find the appropriate symbol table. */
9462 if (dynamic_symbols
== NULL
)
9464 for (entry
= dynamic_section
;
9465 entry
< dynamic_section
+ dynamic_nent
;
9468 Elf_Internal_Shdr section
;
9470 if (entry
->d_tag
!= DT_SYMTAB
)
9473 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9475 /* Since we do not know how big the symbol table is,
9476 we default to reading in the entire file (!) and
9477 processing that. This is overkill, I know, but it
9479 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9480 if ((bfd_size_type
) section
.sh_offset
> current_file_size
)
9482 /* See PR 21379 for a reproducer. */
9483 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9487 if (archive_file_offset
!= 0)
9488 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9491 if (fseek (file
, 0, SEEK_END
))
9492 error (_("Unable to seek to end of file!\n"));
9494 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9498 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9500 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9501 section
.sh_name
= string_table_length
;
9503 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9504 if (num_dynamic_syms
< 1)
9506 error (_("Unable to determine the number of symbols to load\n"));
9512 /* Similarly find a string table. */
9513 if (dynamic_strings
== NULL
)
9515 for (entry
= dynamic_section
;
9516 entry
< dynamic_section
+ dynamic_nent
;
9519 unsigned long offset
;
9522 if (entry
->d_tag
!= DT_STRTAB
)
9525 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9527 /* Since we do not know how big the string table is,
9528 we default to reading in the entire file (!) and
9529 processing that. This is overkill, I know, but it
9532 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9534 if (archive_file_offset
!= 0)
9535 str_tab_len
= archive_file_size
- offset
;
9538 if (fseek (file
, 0, SEEK_END
))
9539 error (_("Unable to seek to end of file\n"));
9540 str_tab_len
= ftell (file
) - offset
;
9543 if (str_tab_len
< 1)
9546 (_("Unable to determine the length of the dynamic string table\n"));
9550 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9552 _("dynamic string table"));
9553 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9558 /* And find the syminfo section if available. */
9559 if (dynamic_syminfo
== NULL
)
9561 unsigned long syminsz
= 0;
9563 for (entry
= dynamic_section
;
9564 entry
< dynamic_section
+ dynamic_nent
;
9567 if (entry
->d_tag
== DT_SYMINENT
)
9569 /* Note: these braces are necessary to avoid a syntax
9570 error from the SunOS4 C compiler. */
9571 /* PR binutils/17531: A corrupt file can trigger this test.
9572 So do not use an assert, instead generate an error message. */
9573 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9574 error (_("Bad value (%d) for SYMINENT entry\n"),
9575 (int) entry
->d_un
.d_val
);
9577 else if (entry
->d_tag
== DT_SYMINSZ
)
9578 syminsz
= entry
->d_un
.d_val
;
9579 else if (entry
->d_tag
== DT_SYMINFO
)
9580 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9584 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9586 Elf_External_Syminfo
* extsyminfo
;
9587 Elf_External_Syminfo
* extsym
;
9588 Elf_Internal_Syminfo
* syminfo
;
9590 /* There is a syminfo section. Read the data. */
9591 extsyminfo
= (Elf_External_Syminfo
*)
9592 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9593 _("symbol information"));
9597 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9598 if (dynamic_syminfo
== NULL
)
9600 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9601 (unsigned long) syminsz
);
9605 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9606 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9607 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9608 ++syminfo
, ++extsym
)
9610 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9611 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9618 if (do_dynamic
&& dynamic_addr
)
9619 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9620 dynamic_addr
, (unsigned long) dynamic_nent
);
9622 printf (_(" Tag Type Name/Value\n"));
9624 for (entry
= dynamic_section
;
9625 entry
< dynamic_section
+ dynamic_nent
;
9633 print_vma (entry
->d_tag
, FULL_HEX
);
9634 dtype
= get_dynamic_type (entry
->d_tag
);
9635 printf (" (%s)%*s", dtype
,
9636 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9639 switch (entry
->d_tag
)
9643 print_dynamic_flags (entry
->d_un
.d_val
);
9653 switch (entry
->d_tag
)
9656 printf (_("Auxiliary library"));
9660 printf (_("Filter library"));
9664 printf (_("Configuration file"));
9668 printf (_("Dependency audit library"));
9672 printf (_("Audit library"));
9676 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9677 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9681 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9690 printf (_("Flags:"));
9692 if (entry
->d_un
.d_val
== 0)
9693 printf (_(" None\n"));
9696 unsigned long int val
= entry
->d_un
.d_val
;
9698 if (val
& DTF_1_PARINIT
)
9700 printf (" PARINIT");
9701 val
^= DTF_1_PARINIT
;
9703 if (val
& DTF_1_CONFEXP
)
9705 printf (" CONFEXP");
9706 val
^= DTF_1_CONFEXP
;
9709 printf (" %lx", val
);
9718 printf (_("Flags:"));
9720 if (entry
->d_un
.d_val
== 0)
9721 printf (_(" None\n"));
9724 unsigned long int val
= entry
->d_un
.d_val
;
9726 if (val
& DF_P1_LAZYLOAD
)
9728 printf (" LAZYLOAD");
9729 val
^= DF_P1_LAZYLOAD
;
9731 if (val
& DF_P1_GROUPPERM
)
9733 printf (" GROUPPERM");
9734 val
^= DF_P1_GROUPPERM
;
9737 printf (" %lx", val
);
9746 printf (_("Flags:"));
9747 if (entry
->d_un
.d_val
== 0)
9748 printf (_(" None\n"));
9751 unsigned long int val
= entry
->d_un
.d_val
;
9758 if (val
& DF_1_GLOBAL
)
9763 if (val
& DF_1_GROUP
)
9768 if (val
& DF_1_NODELETE
)
9770 printf (" NODELETE");
9771 val
^= DF_1_NODELETE
;
9773 if (val
& DF_1_LOADFLTR
)
9775 printf (" LOADFLTR");
9776 val
^= DF_1_LOADFLTR
;
9778 if (val
& DF_1_INITFIRST
)
9780 printf (" INITFIRST");
9781 val
^= DF_1_INITFIRST
;
9783 if (val
& DF_1_NOOPEN
)
9788 if (val
& DF_1_ORIGIN
)
9793 if (val
& DF_1_DIRECT
)
9798 if (val
& DF_1_TRANS
)
9803 if (val
& DF_1_INTERPOSE
)
9805 printf (" INTERPOSE");
9806 val
^= DF_1_INTERPOSE
;
9808 if (val
& DF_1_NODEFLIB
)
9810 printf (" NODEFLIB");
9811 val
^= DF_1_NODEFLIB
;
9813 if (val
& DF_1_NODUMP
)
9818 if (val
& DF_1_CONFALT
)
9820 printf (" CONFALT");
9821 val
^= DF_1_CONFALT
;
9823 if (val
& DF_1_ENDFILTEE
)
9825 printf (" ENDFILTEE");
9826 val
^= DF_1_ENDFILTEE
;
9828 if (val
& DF_1_DISPRELDNE
)
9830 printf (" DISPRELDNE");
9831 val
^= DF_1_DISPRELDNE
;
9833 if (val
& DF_1_DISPRELPND
)
9835 printf (" DISPRELPND");
9836 val
^= DF_1_DISPRELPND
;
9838 if (val
& DF_1_NODIRECT
)
9840 printf (" NODIRECT");
9841 val
^= DF_1_NODIRECT
;
9843 if (val
& DF_1_IGNMULDEF
)
9845 printf (" IGNMULDEF");
9846 val
^= DF_1_IGNMULDEF
;
9848 if (val
& DF_1_NOKSYMS
)
9850 printf (" NOKSYMS");
9851 val
^= DF_1_NOKSYMS
;
9853 if (val
& DF_1_NOHDR
)
9858 if (val
& DF_1_EDITED
)
9863 if (val
& DF_1_NORELOC
)
9865 printf (" NORELOC");
9866 val
^= DF_1_NORELOC
;
9868 if (val
& DF_1_SYMINTPOSE
)
9870 printf (" SYMINTPOSE");
9871 val
^= DF_1_SYMINTPOSE
;
9873 if (val
& DF_1_GLOBAUDIT
)
9875 printf (" GLOBAUDIT");
9876 val
^= DF_1_GLOBAUDIT
;
9878 if (val
& DF_1_SINGLETON
)
9880 printf (" SINGLETON");
9881 val
^= DF_1_SINGLETON
;
9883 if (val
& DF_1_STUB
)
9894 printf (" %lx", val
);
9901 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9903 puts (get_dynamic_type (entry
->d_un
.d_val
));
9923 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9929 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9930 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9936 switch (entry
->d_tag
)
9939 printf (_("Shared library: [%s]"), name
);
9941 if (streq (name
, program_interpreter
))
9942 printf (_(" program interpreter"));
9946 printf (_("Library soname: [%s]"), name
);
9950 printf (_("Library rpath: [%s]"), name
);
9954 printf (_("Library runpath: [%s]"), name
);
9958 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9963 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9976 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9981 case DT_INIT_ARRAYSZ
:
9982 case DT_FINI_ARRAYSZ
:
9983 case DT_GNU_CONFLICTSZ
:
9984 case DT_GNU_LIBLISTSZ
:
9987 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9988 printf (_(" (bytes)\n"));
9998 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10007 case DT_INIT_ARRAY
:
10008 case DT_FINI_ARRAY
:
10011 if (entry
->d_tag
== DT_USED
10012 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10014 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10018 printf (_("Not needed object: [%s]\n"), name
);
10023 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10029 /* The value of this entry is ignored. */
10034 case DT_GNU_PRELINKED
:
10038 time_t atime
= entry
->d_un
.d_val
;
10040 tmp
= gmtime (&atime
);
10041 /* PR 17533 file: 041-1244816-0.004. */
10043 printf (_("<corrupt time val: %lx"),
10044 (unsigned long) atime
);
10046 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10047 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10048 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10054 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10057 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10063 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10064 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10069 switch (elf_header
.e_machine
)
10072 case EM_MIPS_RS3_LE
:
10073 dynamic_section_mips_val (entry
);
10076 dynamic_section_parisc_val (entry
);
10079 dynamic_section_ia64_val (entry
);
10082 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10094 get_ver_flags (unsigned int flags
)
10096 static char buff
[32];
10103 if (flags
& VER_FLG_BASE
)
10104 strcat (buff
, "BASE");
10106 if (flags
& VER_FLG_WEAK
)
10108 if (flags
& VER_FLG_BASE
)
10109 strcat (buff
, " | ");
10111 strcat (buff
, "WEAK");
10114 if (flags
& VER_FLG_INFO
)
10116 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10117 strcat (buff
, " | ");
10119 strcat (buff
, "INFO");
10122 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10124 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10125 strcat (buff
, " | ");
10127 strcat (buff
, _("<unknown>"));
10133 /* Display the contents of the version sections. */
10136 process_version_sections (FILE * file
)
10138 Elf_Internal_Shdr
* section
;
10140 bfd_boolean found
= FALSE
;
10145 for (i
= 0, section
= section_headers
;
10146 i
< elf_header
.e_shnum
;
10149 switch (section
->sh_type
)
10151 case SHT_GNU_verdef
:
10153 Elf_External_Verdef
* edefs
;
10161 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10162 printable_section_name (section
),
10165 printf (_(" Addr: 0x"));
10166 printf_vma (section
->sh_addr
);
10167 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10168 (unsigned long) section
->sh_offset
, section
->sh_link
,
10169 printable_section_name_from_index (section
->sh_link
));
10171 edefs
= (Elf_External_Verdef
*)
10172 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10173 _("version definition section"));
10176 endbuf
= (char *) edefs
+ section
->sh_size
;
10178 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10179 end
= (section
->sh_info
< section
->sh_size
10180 ? section
->sh_info
: section
->sh_size
);
10181 for (idx
= cnt
= 0; cnt
< end
; ++cnt
)
10184 Elf_External_Verdef
* edef
;
10185 Elf_Internal_Verdef ent
;
10186 Elf_External_Verdaux
* eaux
;
10187 Elf_Internal_Verdaux aux
;
10191 /* Check for very large indices. */
10192 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10195 vstart
= ((char *) edefs
) + idx
;
10196 if (vstart
+ sizeof (*edef
) > endbuf
)
10199 edef
= (Elf_External_Verdef
*) vstart
;
10201 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10202 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10203 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10204 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10205 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10206 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10207 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10209 printf (_(" %#06x: Rev: %d Flags: %s"),
10210 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10212 printf (_(" Index: %d Cnt: %d "),
10213 ent
.vd_ndx
, ent
.vd_cnt
);
10215 /* Check for overflow and underflow. */
10216 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
)
10217 || (vstart
+ ent
.vd_aux
< vstart
))
10220 vstart
+= ent
.vd_aux
;
10222 eaux
= (Elf_External_Verdaux
*) vstart
;
10224 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10225 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10227 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10228 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10230 printf (_("Name index: %ld\n"), aux
.vda_name
);
10232 isum
= idx
+ ent
.vd_aux
;
10234 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10236 /* Check for overflow. */
10237 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10240 isum
+= aux
.vda_next
;
10241 vstart
+= aux
.vda_next
;
10243 eaux
= (Elf_External_Verdaux
*) vstart
;
10244 if (vstart
+ sizeof (*eaux
) > endbuf
)
10247 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10248 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10250 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10251 printf (_(" %#06x: Parent %d: %s\n"),
10252 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10254 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10255 isum
, j
, aux
.vda_name
);
10258 if (j
< ent
.vd_cnt
)
10259 printf (_(" Version def aux past end of section\n"));
10262 file: id:000001,src:000172+005151,op:splice,rep:2. */
10263 if (idx
+ ent
.vd_next
< idx
)
10266 idx
+= ent
.vd_next
;
10269 if (cnt
< section
->sh_info
)
10270 printf (_(" Version definition past end of section\n"));
10276 case SHT_GNU_verneed
:
10278 Elf_External_Verneed
* eneed
;
10285 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10286 printable_section_name (section
), section
->sh_info
);
10288 printf (_(" Addr: 0x"));
10289 printf_vma (section
->sh_addr
);
10290 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10291 (unsigned long) section
->sh_offset
, section
->sh_link
,
10292 printable_section_name_from_index (section
->sh_link
));
10294 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10295 section
->sh_offset
, 1,
10297 _("Version Needs section"));
10300 endbuf
= (char *) eneed
+ section
->sh_size
;
10302 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10304 Elf_External_Verneed
* entry
;
10305 Elf_Internal_Verneed ent
;
10310 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10313 vstart
= ((char *) eneed
) + idx
;
10314 if (vstart
+ sizeof (*entry
) > endbuf
)
10317 entry
= (Elf_External_Verneed
*) vstart
;
10319 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10320 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10321 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10322 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10323 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10325 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10327 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10328 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10330 printf (_(" File: %lx"), ent
.vn_file
);
10332 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10334 /* Check for overflow. */
10335 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10337 vstart
+= ent
.vn_aux
;
10339 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10341 Elf_External_Vernaux
* eaux
;
10342 Elf_Internal_Vernaux aux
;
10344 if (vstart
+ sizeof (*eaux
) > endbuf
)
10346 eaux
= (Elf_External_Vernaux
*) vstart
;
10348 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10349 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10350 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10351 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10352 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10354 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10355 printf (_(" %#06x: Name: %s"),
10356 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10358 printf (_(" %#06x: Name index: %lx"),
10359 isum
, aux
.vna_name
);
10361 printf (_(" Flags: %s Version: %d\n"),
10362 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10364 /* Check for overflow. */
10365 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10366 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10368 warn (_("Invalid vna_next field of %lx\n"),
10373 isum
+= aux
.vna_next
;
10374 vstart
+= aux
.vna_next
;
10377 if (j
< ent
.vn_cnt
)
10378 warn (_("Missing Version Needs auxillary information\n"));
10380 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10382 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10383 cnt
= section
->sh_info
;
10386 idx
+= ent
.vn_next
;
10389 if (cnt
< section
->sh_info
)
10390 warn (_("Missing Version Needs information\n"));
10396 case SHT_GNU_versym
:
10398 Elf_Internal_Shdr
* link_section
;
10401 unsigned char * edata
;
10402 unsigned short * data
;
10404 Elf_Internal_Sym
* symbols
;
10405 Elf_Internal_Shdr
* string_sec
;
10406 unsigned long num_syms
;
10409 if (section
->sh_link
>= elf_header
.e_shnum
)
10412 link_section
= section_headers
+ section
->sh_link
;
10413 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10415 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10420 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10421 if (symbols
== NULL
)
10424 string_sec
= section_headers
+ link_section
->sh_link
;
10426 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10427 string_sec
->sh_size
,
10428 _("version string table"));
10435 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10436 printable_section_name (section
), (unsigned long) total
);
10438 printf (_(" Addr: "));
10439 printf_vma (section
->sh_addr
);
10440 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10441 (unsigned long) section
->sh_offset
, section
->sh_link
,
10442 printable_section_name (link_section
));
10444 off
= offset_from_vma (file
,
10445 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10446 total
* sizeof (short));
10447 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10449 _("version symbol data"));
10457 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10459 for (cnt
= total
; cnt
--;)
10460 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10465 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10469 char *invalid
= _("*invalid*");
10471 printf (" %03x:", cnt
);
10473 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10474 switch (data
[cnt
+ j
])
10477 fputs (_(" 0 (*local*) "), stdout
);
10481 fputs (_(" 1 (*global*) "), stdout
);
10485 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10486 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10488 /* If this index value is greater than the size of the symbols
10489 array, break to avoid an out-of-bounds read. */
10490 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10492 warn (_("invalid index into symbol array\n"));
10497 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10499 Elf_Internal_Verneed ivn
;
10500 unsigned long offset
;
10502 offset
= offset_from_vma
10503 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10504 sizeof (Elf_External_Verneed
));
10508 Elf_Internal_Vernaux ivna
;
10509 Elf_External_Verneed evn
;
10510 Elf_External_Vernaux evna
;
10511 unsigned long a_off
;
10513 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10514 _("version need")) == NULL
)
10517 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10518 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10520 a_off
= offset
+ ivn
.vn_aux
;
10524 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10525 1, _("version need aux (2)")) == NULL
)
10528 ivna
.vna_other
= 0;
10532 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10533 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10536 a_off
+= ivna
.vna_next
;
10538 while (ivna
.vna_other
!= data
[cnt
+ j
]
10539 && ivna
.vna_next
!= 0);
10541 if (ivna
.vna_other
== data
[cnt
+ j
])
10543 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10545 if (ivna
.vna_name
>= string_sec
->sh_size
)
10548 name
= strtab
+ ivna
.vna_name
;
10552 offset
+= ivn
.vn_next
;
10554 while (ivn
.vn_next
);
10557 if (data
[cnt
+ j
] != 0x8001
10558 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10560 Elf_Internal_Verdef ivd
;
10561 Elf_External_Verdef evd
;
10562 unsigned long offset
;
10564 offset
= offset_from_vma
10565 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10570 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10571 _("version def")) == NULL
)
10574 /* PR 17531: file: 046-1082287-0.004. */
10575 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10580 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10581 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10584 offset
+= ivd
.vd_next
;
10586 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10587 && ivd
.vd_next
!= 0);
10589 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10591 Elf_External_Verdaux evda
;
10592 Elf_Internal_Verdaux ivda
;
10594 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10596 if (get_data (&evda
, file
,
10597 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10599 _("version def aux")) == NULL
)
10602 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10604 if (ivda
.vda_name
>= string_sec
->sh_size
)
10606 else if (name
!= NULL
&& name
!= invalid
)
10607 name
= _("*both*");
10609 name
= strtab
+ ivda
.vda_name
;
10613 nn
+= printf ("(%s%-*s",
10615 12 - (int) strlen (name
),
10619 printf ("%*c", 18 - nn
, ' ');
10637 printf (_("\nNo version information found in this file.\n"));
10642 static const char *
10643 get_symbol_binding (unsigned int binding
)
10645 static char buff
[32];
10649 case STB_LOCAL
: return "LOCAL";
10650 case STB_GLOBAL
: return "GLOBAL";
10651 case STB_WEAK
: return "WEAK";
10653 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10654 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10656 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10658 if (binding
== STB_GNU_UNIQUE
10659 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10660 /* GNU is still using the default value 0. */
10661 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10663 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10666 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10671 static const char *
10672 get_symbol_type (unsigned int type
)
10674 static char buff
[32];
10678 case STT_NOTYPE
: return "NOTYPE";
10679 case STT_OBJECT
: return "OBJECT";
10680 case STT_FUNC
: return "FUNC";
10681 case STT_SECTION
: return "SECTION";
10682 case STT_FILE
: return "FILE";
10683 case STT_COMMON
: return "COMMON";
10684 case STT_TLS
: return "TLS";
10685 case STT_RELC
: return "RELC";
10686 case STT_SRELC
: return "SRELC";
10688 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10690 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10691 return "THUMB_FUNC";
10693 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10696 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10697 return "PARISC_MILLI";
10699 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10701 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10703 if (elf_header
.e_machine
== EM_PARISC
)
10705 if (type
== STT_HP_OPAQUE
)
10706 return "HP_OPAQUE";
10707 if (type
== STT_HP_STUB
)
10711 if (type
== STT_GNU_IFUNC
10712 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10713 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10714 /* GNU is still using the default value 0. */
10715 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10718 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10721 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10726 static const char *
10727 get_symbol_visibility (unsigned int visibility
)
10729 switch (visibility
)
10731 case STV_DEFAULT
: return "DEFAULT";
10732 case STV_INTERNAL
: return "INTERNAL";
10733 case STV_HIDDEN
: return "HIDDEN";
10734 case STV_PROTECTED
: return "PROTECTED";
10736 error (_("Unrecognized visibility value: %u"), visibility
);
10737 return _("<unknown>");
10741 static const char *
10742 get_solaris_symbol_visibility (unsigned int visibility
)
10744 switch (visibility
)
10746 case 4: return "EXPORTED";
10747 case 5: return "SINGLETON";
10748 case 6: return "ELIMINATE";
10749 default: return get_symbol_visibility (visibility
);
10753 static const char *
10754 get_mips_symbol_other (unsigned int other
)
10758 case STO_OPTIONAL
: return "OPTIONAL";
10759 case STO_MIPS_PLT
: return "MIPS PLT";
10760 case STO_MIPS_PIC
: return "MIPS PIC";
10761 case STO_MICROMIPS
: return "MICROMIPS";
10762 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10763 case STO_MIPS16
: return "MIPS16";
10764 default: return NULL
;
10768 static const char *
10769 get_ia64_symbol_other (unsigned int other
)
10771 if (is_ia64_vms ())
10773 static char res
[32];
10777 /* Function types is for images and .STB files only. */
10778 switch (elf_header
.e_type
)
10782 switch (VMS_ST_FUNC_TYPE (other
))
10784 case VMS_SFT_CODE_ADDR
:
10785 strcat (res
, " CA");
10787 case VMS_SFT_SYMV_IDX
:
10788 strcat (res
, " VEC");
10791 strcat (res
, " FD");
10793 case VMS_SFT_RESERVE
:
10794 strcat (res
, " RSV");
10797 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10798 VMS_ST_FUNC_TYPE (other
));
10799 strcat (res
, " <unknown>");
10806 switch (VMS_ST_LINKAGE (other
))
10808 case VMS_STL_IGNORE
:
10809 strcat (res
, " IGN");
10811 case VMS_STL_RESERVE
:
10812 strcat (res
, " RSV");
10815 strcat (res
, " STD");
10818 strcat (res
, " LNK");
10821 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10822 VMS_ST_LINKAGE (other
));
10823 strcat (res
, " <unknown>");
10835 static const char *
10836 get_ppc64_symbol_other (unsigned int other
)
10838 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10840 static char buf
[32];
10841 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10842 PPC64_LOCAL_ENTRY_OFFSET (other
));
10848 static const char *
10849 get_symbol_other (unsigned int other
)
10851 const char * result
= NULL
;
10852 static char buff
[32];
10857 switch (elf_header
.e_machine
)
10860 result
= get_mips_symbol_other (other
);
10863 result
= get_ia64_symbol_other (other
);
10866 result
= get_ppc64_symbol_other (other
);
10876 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10880 static const char *
10881 get_symbol_index_type (unsigned int type
)
10883 static char buff
[32];
10887 case SHN_UNDEF
: return "UND";
10888 case SHN_ABS
: return "ABS";
10889 case SHN_COMMON
: return "COM";
10891 if (type
== SHN_IA_64_ANSI_COMMON
10892 && elf_header
.e_machine
== EM_IA_64
10893 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10895 else if ((elf_header
.e_machine
== EM_X86_64
10896 || elf_header
.e_machine
== EM_L1OM
10897 || elf_header
.e_machine
== EM_K1OM
)
10898 && type
== SHN_X86_64_LCOMMON
)
10899 return "LARGE_COM";
10900 else if ((type
== SHN_MIPS_SCOMMON
10901 && elf_header
.e_machine
== EM_MIPS
)
10902 || (type
== SHN_TIC6X_SCOMMON
10903 && elf_header
.e_machine
== EM_TI_C6000
))
10905 else if (type
== SHN_MIPS_SUNDEFINED
10906 && elf_header
.e_machine
== EM_MIPS
)
10908 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10909 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10910 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10911 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10912 else if (type
>= SHN_LORESERVE
)
10913 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10914 else if (type
>= elf_header
.e_shnum
)
10915 sprintf (buff
, _("bad section index[%3d]"), type
);
10917 sprintf (buff
, "%3d", type
);
10925 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10927 unsigned char * e_data
;
10930 /* If the size_t type is smaller than the bfd_size_type, eg because
10931 you are building a 32-bit tool on a 64-bit host, then make sure
10932 that when (number) is cast to (size_t) no information is lost. */
10933 if (sizeof (size_t) < sizeof (bfd_size_type
)
10934 && (bfd_size_type
) ((size_t) number
) != number
)
10936 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10937 " elements of size %u\n"),
10942 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10943 attempting to allocate memory when the read is bound to fail. */
10944 if (ent_size
* number
> current_file_size
)
10946 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10951 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10952 if (e_data
== NULL
)
10954 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10959 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10961 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10962 number
* ent_size
);
10967 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10968 if (i_data
== NULL
)
10970 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10971 " dynamic entries\n"),
10978 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10986 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10988 Elf_Internal_Sym
* psym
;
10991 n
= print_vma (si
, DEC_5
);
10993 fputs (&" "[n
], stdout
);
10994 printf (" %3lu: ", hn
);
10996 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10998 printf (_("<No info available for dynamic symbol number %lu>\n"),
10999 (unsigned long) si
);
11003 psym
= dynamic_symbols
+ si
;
11004 print_vma (psym
->st_value
, LONG_HEX
);
11006 print_vma (psym
->st_size
, DEC_5
);
11008 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11009 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11011 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11012 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11015 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11017 printf (" %-7s", get_symbol_visibility (vis
));
11018 /* Check to see if any other bits in the st_other field are set.
11019 Note - displaying this information disrupts the layout of the
11020 table being generated, but for the moment this case is very
11022 if (psym
->st_other
^ vis
)
11023 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11026 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
11027 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11028 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11030 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11034 static const char *
11035 get_symbol_version_string (FILE * file
,
11036 bfd_boolean is_dynsym
,
11037 const char * strtab
,
11038 unsigned long int strtab_size
,
11040 Elf_Internal_Sym
* psym
,
11041 enum versioned_symbol_info
* sym_info
,
11042 unsigned short * vna_other
)
11044 unsigned char data
[2];
11045 unsigned short vers_data
;
11046 unsigned long offset
;
11049 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11052 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11053 sizeof data
+ si
* sizeof (vers_data
));
11055 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
11056 sizeof (data
), 1, _("version data")) == NULL
)
11059 vers_data
= byte_get (data
, 2);
11061 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11064 /* Usually we'd only see verdef for defined symbols, and verneed for
11065 undefined symbols. However, symbols defined by the linker in
11066 .dynbss for variables copied from a shared library in order to
11067 avoid text relocations are defined yet have verneed. We could
11068 use a heuristic to detect the special case, for example, check
11069 for verneed first on symbols defined in SHT_NOBITS sections, but
11070 it is simpler and more reliable to just look for both verdef and
11071 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11073 if (psym
->st_shndx
!= SHN_UNDEF
11074 && vers_data
!= 0x8001
11075 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11077 Elf_Internal_Verdef ivd
;
11078 Elf_Internal_Verdaux ivda
;
11079 Elf_External_Verdaux evda
;
11082 off
= offset_from_vma (file
,
11083 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11084 sizeof (Elf_External_Verdef
));
11088 Elf_External_Verdef evd
;
11090 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11091 _("version def")) == NULL
)
11099 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11100 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11101 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11104 off
+= ivd
.vd_next
;
11106 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11108 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11110 off
-= ivd
.vd_next
;
11113 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11114 _("version def aux")) != NULL
)
11116 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11118 if (psym
->st_name
!= ivda
.vda_name
)
11120 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11121 ? symbol_hidden
: symbol_public
);
11122 return (ivda
.vda_name
< strtab_size
11123 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11129 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11131 Elf_External_Verneed evn
;
11132 Elf_Internal_Verneed ivn
;
11133 Elf_Internal_Vernaux ivna
;
11135 offset
= offset_from_vma (file
,
11136 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11140 unsigned long vna_off
;
11142 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11143 _("version need")) == NULL
)
11146 ivna
.vna_other
= 0;
11151 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11152 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11154 vna_off
= offset
+ ivn
.vn_aux
;
11158 Elf_External_Vernaux evna
;
11160 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11161 _("version need aux (3)")) == NULL
)
11164 ivna
.vna_other
= 0;
11169 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11170 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11171 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11174 vna_off
+= ivna
.vna_next
;
11176 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11178 if (ivna
.vna_other
== vers_data
)
11181 offset
+= ivn
.vn_next
;
11183 while (ivn
.vn_next
!= 0);
11185 if (ivna
.vna_other
== vers_data
)
11187 *sym_info
= symbol_undefined
;
11188 *vna_other
= ivna
.vna_other
;
11189 return (ivna
.vna_name
< strtab_size
11190 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11196 /* Dump the symbol table. */
11198 process_symbol_table (FILE * file
)
11200 Elf_Internal_Shdr
* section
;
11201 bfd_size_type nbuckets
= 0;
11202 bfd_size_type nchains
= 0;
11203 bfd_vma
* buckets
= NULL
;
11204 bfd_vma
* chains
= NULL
;
11205 bfd_vma ngnubuckets
= 0;
11206 bfd_vma
* gnubuckets
= NULL
;
11207 bfd_vma
* gnuchains
= NULL
;
11208 bfd_vma gnusymidx
= 0;
11209 bfd_size_type ngnuchains
= 0;
11211 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11214 if (dynamic_info
[DT_HASH
]
11216 || (do_using_dynamic
11218 && dynamic_strings
!= NULL
)))
11220 unsigned char nb
[8];
11221 unsigned char nc
[8];
11222 unsigned int hash_ent_size
= 4;
11224 if ((elf_header
.e_machine
== EM_ALPHA
11225 || elf_header
.e_machine
== EM_S390
11226 || elf_header
.e_machine
== EM_S390_OLD
)
11227 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11231 (archive_file_offset
11232 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11233 sizeof nb
+ sizeof nc
)),
11236 error (_("Unable to seek to start of dynamic information\n"));
11240 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11242 error (_("Failed to read in number of buckets\n"));
11246 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11248 error (_("Failed to read in number of chains\n"));
11252 nbuckets
= byte_get (nb
, hash_ent_size
);
11253 nchains
= byte_get (nc
, hash_ent_size
);
11255 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11256 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11259 if (buckets
== NULL
|| chains
== NULL
)
11261 if (do_using_dynamic
)
11272 if (dynamic_info_DT_GNU_HASH
11274 || (do_using_dynamic
11276 && dynamic_strings
!= NULL
)))
11278 unsigned char nb
[16];
11279 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11280 bfd_vma buckets_vma
;
11283 (archive_file_offset
11284 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11288 error (_("Unable to seek to start of dynamic information\n"));
11292 if (fread (nb
, 16, 1, file
) != 1)
11294 error (_("Failed to read in number of buckets\n"));
11298 ngnubuckets
= byte_get (nb
, 4);
11299 gnusymidx
= byte_get (nb
+ 4, 4);
11300 bitmaskwords
= byte_get (nb
+ 8, 4);
11301 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11303 buckets_vma
+= bitmaskwords
* 4;
11305 buckets_vma
+= bitmaskwords
* 8;
11308 (archive_file_offset
11309 + offset_from_vma (file
, buckets_vma
, 4)),
11312 error (_("Unable to seek to start of dynamic information\n"));
11316 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11318 if (gnubuckets
== NULL
)
11321 for (i
= 0; i
< ngnubuckets
; i
++)
11322 if (gnubuckets
[i
] != 0)
11324 if (gnubuckets
[i
] < gnusymidx
)
11327 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11328 maxchain
= gnubuckets
[i
];
11331 if (maxchain
== 0xffffffff)
11334 maxchain
-= gnusymidx
;
11337 (archive_file_offset
11338 + offset_from_vma (file
, buckets_vma
11339 + 4 * (ngnubuckets
+ maxchain
), 4)),
11342 error (_("Unable to seek to start of dynamic information\n"));
11348 if (fread (nb
, 4, 1, file
) != 1)
11350 error (_("Failed to determine last chain length\n"));
11354 if (maxchain
+ 1 == 0)
11359 while ((byte_get (nb
, 4) & 1) == 0);
11362 (archive_file_offset
11363 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11366 error (_("Unable to seek to start of dynamic information\n"));
11370 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11371 ngnuchains
= maxchain
;
11374 if (gnuchains
== NULL
)
11379 if (do_using_dynamic
)
11384 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11386 && do_using_dynamic
11387 && dynamic_strings
!= NULL
11388 && dynamic_symbols
!= NULL
)
11392 if (dynamic_info
[DT_HASH
])
11396 printf (_("\nSymbol table for image:\n"));
11398 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11400 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11402 for (hn
= 0; hn
< nbuckets
; hn
++)
11407 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11408 print_dynamic_symbol (si
, hn
);
11412 if (dynamic_info_DT_GNU_HASH
)
11414 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11416 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11418 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11420 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11421 if (gnubuckets
[hn
] != 0)
11423 bfd_vma si
= gnubuckets
[hn
];
11424 bfd_vma off
= si
- gnusymidx
;
11428 print_dynamic_symbol (si
, hn
);
11431 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11435 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11436 && section_headers
!= NULL
)
11440 for (i
= 0, section
= section_headers
;
11441 i
< elf_header
.e_shnum
;
11445 char * strtab
= NULL
;
11446 unsigned long int strtab_size
= 0;
11447 Elf_Internal_Sym
* symtab
;
11448 Elf_Internal_Sym
* psym
;
11449 unsigned long num_syms
;
11451 if ((section
->sh_type
!= SHT_SYMTAB
11452 && section
->sh_type
!= SHT_DYNSYM
)
11454 && section
->sh_type
== SHT_SYMTAB
))
11457 if (section
->sh_entsize
== 0)
11459 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11460 printable_section_name (section
));
11464 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11465 printable_section_name (section
),
11466 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11469 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11471 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11473 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11474 if (symtab
== NULL
)
11477 if (section
->sh_link
== elf_header
.e_shstrndx
)
11479 strtab
= string_table
;
11480 strtab_size
= string_table_length
;
11482 else if (section
->sh_link
< elf_header
.e_shnum
)
11484 Elf_Internal_Shdr
* string_sec
;
11486 string_sec
= section_headers
+ section
->sh_link
;
11488 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11489 1, string_sec
->sh_size
,
11490 _("string table"));
11491 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11494 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11496 const char *version_string
;
11497 enum versioned_symbol_info sym_info
;
11498 unsigned short vna_other
;
11500 printf ("%6d: ", si
);
11501 print_vma (psym
->st_value
, LONG_HEX
);
11503 print_vma (psym
->st_size
, DEC_5
);
11504 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11505 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11506 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11507 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11510 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11512 printf (" %-7s", get_symbol_visibility (vis
));
11513 /* Check to see if any other bits in the st_other field are set.
11514 Note - displaying this information disrupts the layout of the
11515 table being generated, but for the moment this case is very rare. */
11516 if (psym
->st_other
^ vis
)
11517 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11519 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11520 print_symbol (25, psym
->st_name
< strtab_size
11521 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11524 = get_symbol_version_string (file
,
11525 section
->sh_type
== SHT_DYNSYM
,
11526 strtab
, strtab_size
, si
,
11527 psym
, &sym_info
, &vna_other
);
11528 if (version_string
)
11530 if (sym_info
== symbol_undefined
)
11531 printf ("@%s (%d)", version_string
, vna_other
);
11533 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11539 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11540 && si
>= section
->sh_info
11541 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11542 && elf_header
.e_machine
!= EM_MIPS
11543 /* Solaris binaries have been found to violate this requirement as
11544 well. Not sure if this is a bug or an ABI requirement. */
11545 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11546 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11547 si
, printable_section_name (section
), section
->sh_info
);
11551 if (strtab
!= string_table
)
11557 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11559 if (do_histogram
&& buckets
!= NULL
)
11561 unsigned long * lengths
;
11562 unsigned long * counts
;
11565 unsigned long maxlength
= 0;
11566 unsigned long nzero_counts
= 0;
11567 unsigned long nsyms
= 0;
11568 unsigned long chained
;
11570 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11571 (unsigned long) nbuckets
);
11573 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11574 if (lengths
== NULL
)
11576 error (_("Out of memory allocating space for histogram buckets\n"));
11580 printf (_(" Length Number %% of total Coverage\n"));
11581 for (hn
= 0; hn
< nbuckets
; ++hn
)
11583 for (si
= buckets
[hn
], chained
= 0;
11584 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11585 si
= chains
[si
], ++chained
)
11588 if (maxlength
< ++lengths
[hn
])
11592 /* PR binutils/17531: A corrupt binary could contain broken
11593 histogram data. Do not go into an infinite loop trying
11595 if (chained
> nchains
)
11597 error (_("histogram chain is corrupt\n"));
11602 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11603 if (counts
== NULL
)
11606 error (_("Out of memory allocating space for histogram counts\n"));
11610 for (hn
= 0; hn
< nbuckets
; ++hn
)
11611 ++counts
[lengths
[hn
]];
11616 printf (" 0 %-10lu (%5.1f%%)\n",
11617 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11618 for (i
= 1; i
<= maxlength
; ++i
)
11620 nzero_counts
+= counts
[i
] * i
;
11621 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11622 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11623 (nzero_counts
* 100.0) / nsyms
);
11631 if (buckets
!= NULL
)
11637 if (do_histogram
&& gnubuckets
!= NULL
)
11639 unsigned long * lengths
;
11640 unsigned long * counts
;
11642 unsigned long maxlength
= 0;
11643 unsigned long nzero_counts
= 0;
11644 unsigned long nsyms
= 0;
11646 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11647 (unsigned long) ngnubuckets
);
11649 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11650 if (lengths
== NULL
)
11652 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11656 printf (_(" Length Number %% of total Coverage\n"));
11658 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11659 if (gnubuckets
[hn
] != 0)
11661 bfd_vma off
, length
= 1;
11663 for (off
= gnubuckets
[hn
] - gnusymidx
;
11664 /* PR 17531 file: 010-77222-0.004. */
11665 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11668 lengths
[hn
] = length
;
11669 if (length
> maxlength
)
11670 maxlength
= length
;
11674 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11675 if (counts
== NULL
)
11678 error (_("Out of memory allocating space for gnu histogram counts\n"));
11682 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11683 ++counts
[lengths
[hn
]];
11685 if (ngnubuckets
> 0)
11688 printf (" 0 %-10lu (%5.1f%%)\n",
11689 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11690 for (j
= 1; j
<= maxlength
; ++j
)
11692 nzero_counts
+= counts
[j
] * j
;
11693 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11694 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11695 (nzero_counts
* 100.0) / nsyms
);
11709 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11713 if (dynamic_syminfo
== NULL
11715 /* No syminfo, this is ok. */
11718 /* There better should be a dynamic symbol section. */
11719 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11723 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11724 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11726 printf (_(" Num: Name BoundTo Flags\n"));
11727 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11729 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11731 printf ("%4d: ", i
);
11732 if (i
>= num_dynamic_syms
)
11733 printf (_("<corrupt index>"));
11734 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11735 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11737 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11740 switch (dynamic_syminfo
[i
].si_boundto
)
11742 case SYMINFO_BT_SELF
:
11743 fputs ("SELF ", stdout
);
11745 case SYMINFO_BT_PARENT
:
11746 fputs ("PARENT ", stdout
);
11749 if (dynamic_syminfo
[i
].si_boundto
> 0
11750 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11751 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11753 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11757 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11761 if (flags
& SYMINFO_FLG_DIRECT
)
11762 printf (" DIRECT");
11763 if (flags
& SYMINFO_FLG_PASSTHRU
)
11764 printf (" PASSTHRU");
11765 if (flags
& SYMINFO_FLG_COPY
)
11767 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11768 printf (" LAZYLOAD");
11776 #define IN_RANGE(START,END,ADDR,OFF) \
11777 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11779 /* Check to see if the given reloc needs to be handled in a target specific
11780 manner. If so then process the reloc and return TRUE otherwise return
11783 If called with reloc == NULL, then this is a signal that reloc processing
11784 for the current section has finished, and any saved state should be
11788 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11789 unsigned char * start
,
11790 unsigned char * end
,
11791 Elf_Internal_Sym
* symtab
,
11792 unsigned long num_syms
)
11794 unsigned int reloc_type
= 0;
11795 unsigned long sym_index
= 0;
11799 reloc_type
= get_reloc_type (reloc
->r_info
);
11800 sym_index
= get_reloc_symindex (reloc
->r_info
);
11803 switch (elf_header
.e_machine
)
11806 case EM_MSP430_OLD
:
11808 static Elf_Internal_Sym
* saved_sym
= NULL
;
11816 switch (reloc_type
)
11818 case 10: /* R_MSP430_SYM_DIFF */
11819 if (uses_msp430x_relocs ())
11821 /* Fall through. */
11822 case 21: /* R_MSP430X_SYM_DIFF */
11824 if (sym_index
>= num_syms
)
11825 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11828 saved_sym
= symtab
+ sym_index
;
11831 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11832 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11833 goto handle_sym_diff
;
11835 case 5: /* R_MSP430_16_BYTE */
11836 case 9: /* R_MSP430_8 */
11837 if (uses_msp430x_relocs ())
11839 goto handle_sym_diff
;
11841 case 2: /* R_MSP430_ABS16 */
11842 case 15: /* R_MSP430X_ABS16 */
11843 if (! uses_msp430x_relocs ())
11845 goto handle_sym_diff
;
11848 if (saved_sym
!= NULL
)
11850 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11853 if (sym_index
>= num_syms
)
11854 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11858 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11859 - saved_sym
->st_value
);
11861 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11862 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11865 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11866 (long) reloc
->r_offset
);
11875 if (saved_sym
!= NULL
)
11876 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11883 case EM_CYGNUS_MN10300
:
11885 static Elf_Internal_Sym
* saved_sym
= NULL
;
11893 switch (reloc_type
)
11895 case 34: /* R_MN10300_ALIGN */
11897 case 33: /* R_MN10300_SYM_DIFF */
11898 if (sym_index
>= num_syms
)
11899 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11902 saved_sym
= symtab
+ sym_index
;
11905 case 1: /* R_MN10300_32 */
11906 case 2: /* R_MN10300_16 */
11907 if (saved_sym
!= NULL
)
11909 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11912 if (sym_index
>= num_syms
)
11913 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11917 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11918 - saved_sym
->st_value
);
11920 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11921 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11923 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11924 (long) reloc
->r_offset
);
11932 if (saved_sym
!= NULL
)
11933 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11941 static bfd_vma saved_sym1
= 0;
11942 static bfd_vma saved_sym2
= 0;
11943 static bfd_vma value
;
11947 saved_sym1
= saved_sym2
= 0;
11951 switch (reloc_type
)
11953 case 0x80: /* R_RL78_SYM. */
11954 saved_sym1
= saved_sym2
;
11955 if (sym_index
>= num_syms
)
11956 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11960 saved_sym2
= symtab
[sym_index
].st_value
;
11961 saved_sym2
+= reloc
->r_addend
;
11965 case 0x83: /* R_RL78_OPsub. */
11966 value
= saved_sym1
- saved_sym2
;
11967 saved_sym2
= saved_sym1
= 0;
11971 case 0x41: /* R_RL78_ABS32. */
11972 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11973 byte_put (start
+ reloc
->r_offset
, value
, 4);
11975 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11976 (long) reloc
->r_offset
);
11980 case 0x43: /* R_RL78_ABS16. */
11981 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11982 byte_put (start
+ reloc
->r_offset
, value
, 2);
11984 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11985 (long) reloc
->r_offset
);
11999 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12000 DWARF debug sections. This is a target specific test. Note - we do not
12001 go through the whole including-target-headers-multiple-times route, (as
12002 we have already done with <elf/h8.h>) because this would become very
12003 messy and even then this function would have to contain target specific
12004 information (the names of the relocs instead of their numeric values).
12005 FIXME: This is not the correct way to solve this problem. The proper way
12006 is to have target specific reloc sizing and typing functions created by
12007 the reloc-macros.h header, in the same way that it already creates the
12008 reloc naming functions. */
12011 is_32bit_abs_reloc (unsigned int reloc_type
)
12013 /* Please keep this table alpha-sorted for ease of visual lookup. */
12014 switch (elf_header
.e_machine
)
12018 return reloc_type
== 1; /* R_386_32. */
12020 return reloc_type
== 1; /* R_68K_32. */
12022 return reloc_type
== 1; /* R_860_32. */
12024 return reloc_type
== 2; /* R_960_32. */
12026 return (reloc_type
== 258
12027 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12028 case EM_ADAPTEVA_EPIPHANY
:
12029 return reloc_type
== 3;
12031 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12033 return reloc_type
== 1; /* R_ARC_32. */
12034 case EM_ARC_COMPACT
:
12035 case EM_ARC_COMPACT2
:
12036 return reloc_type
== 4; /* R_ARC_32. */
12038 return reloc_type
== 2; /* R_ARM_ABS32 */
12041 return reloc_type
== 1;
12043 return reloc_type
== 0x12; /* R_byte4_data. */
12045 return reloc_type
== 3; /* R_CRIS_32. */
12047 return reloc_type
== 3; /* R_CR16_NUM32. */
12049 return reloc_type
== 15; /* R_CRX_NUM32. */
12050 case EM_CYGNUS_FRV
:
12051 return reloc_type
== 1;
12052 case EM_CYGNUS_D10V
:
12054 return reloc_type
== 6; /* R_D10V_32. */
12055 case EM_CYGNUS_D30V
:
12057 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12059 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12060 case EM_CYGNUS_FR30
:
12062 return reloc_type
== 3; /* R_FR30_32. */
12064 return reloc_type
== 1; /* R_FT32_32. */
12068 return reloc_type
== 1; /* R_H8_DIR32. */
12070 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12071 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
12074 return reloc_type
== 2; /* R_IP2K_32. */
12076 return reloc_type
== 2; /* R_IQ2000_32. */
12077 case EM_LATTICEMICO32
:
12078 return reloc_type
== 3; /* R_LM32_32. */
12081 return reloc_type
== 3; /* R_M32C_32. */
12083 return reloc_type
== 34; /* R_M32R_32_RELA. */
12086 return reloc_type
== 6; /* R_M68HC11_32. */
12088 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12089 case EM_CYGNUS_MEP
:
12090 return reloc_type
== 4; /* R_MEP_32. */
12092 return reloc_type
== 2; /* R_METAG_ADDR32. */
12093 case EM_MICROBLAZE
:
12094 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12096 return reloc_type
== 2; /* R_MIPS_32. */
12098 return reloc_type
== 4; /* R_MMIX_32. */
12099 case EM_CYGNUS_MN10200
:
12101 return reloc_type
== 1; /* R_MN10200_32. */
12102 case EM_CYGNUS_MN10300
:
12104 return reloc_type
== 1; /* R_MN10300_32. */
12106 return reloc_type
== 1; /* R_MOXIE_32. */
12107 case EM_MSP430_OLD
:
12109 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12111 return reloc_type
== 2; /* R_MT_32. */
12113 return reloc_type
== 20; /* R_NDS32_RELA. */
12114 case EM_ALTERA_NIOS2
:
12115 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12117 return reloc_type
== 1; /* R_NIOS_32. */
12119 return reloc_type
== 1; /* R_OR1K_32. */
12121 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12122 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12125 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12127 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12129 return reloc_type
== 1; /* R_PPC_ADDR32. */
12131 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12133 return reloc_type
== 1; /* R_RISCV_32. */
12135 return reloc_type
== 1; /* R_RL78_DIR32. */
12137 return reloc_type
== 1; /* R_RX_DIR32. */
12139 return reloc_type
== 1; /* R_I370_ADDR31. */
12142 return reloc_type
== 4; /* R_S390_32. */
12144 return reloc_type
== 8; /* R_SCORE_ABS32. */
12146 return reloc_type
== 1; /* R_SH_DIR32. */
12147 case EM_SPARC32PLUS
:
12150 return reloc_type
== 3 /* R_SPARC_32. */
12151 || reloc_type
== 23; /* R_SPARC_UA32. */
12153 return reloc_type
== 6; /* R_SPU_ADDR32 */
12155 return reloc_type
== 1; /* R_C6000_ABS32. */
12157 return reloc_type
== 2; /* R_TILEGX_32. */
12159 return reloc_type
== 1; /* R_TILEPRO_32. */
12160 case EM_CYGNUS_V850
:
12162 return reloc_type
== 6; /* R_V850_ABS32. */
12164 return reloc_type
== 0x33; /* R_V810_WORD. */
12166 return reloc_type
== 1; /* R_VAX_32. */
12168 return reloc_type
== 3; /* R_VISIUM_32. */
12169 case EM_WEBASSEMBLY
:
12170 return reloc_type
== 1; /* R_WASM32_32. */
12174 return reloc_type
== 10; /* R_X86_64_32. */
12177 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12179 return reloc_type
== 4; /* R_XGATE_32. */
12181 return reloc_type
== 1; /* R_XSTROMY16_32. */
12182 case EM_XTENSA_OLD
:
12184 return reloc_type
== 1; /* R_XTENSA_32. */
12187 static unsigned int prev_warn
= 0;
12189 /* Avoid repeating the same warning multiple times. */
12190 if (prev_warn
!= elf_header
.e_machine
)
12191 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12192 elf_header
.e_machine
);
12193 prev_warn
= elf_header
.e_machine
;
12199 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12200 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12203 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12205 switch (elf_header
.e_machine
)
12206 /* Please keep this table alpha-sorted for ease of visual lookup. */
12210 return reloc_type
== 2; /* R_386_PC32. */
12212 return reloc_type
== 4; /* R_68K_PC32. */
12214 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12215 case EM_ADAPTEVA_EPIPHANY
:
12216 return reloc_type
== 6;
12218 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12219 case EM_ARC_COMPACT
:
12220 case EM_ARC_COMPACT2
:
12221 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12223 return reloc_type
== 3; /* R_ARM_REL32 */
12226 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12227 case EM_MICROBLAZE
:
12228 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12230 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12232 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12234 return reloc_type
== 26; /* R_PPC_REL32. */
12236 return reloc_type
== 26; /* R_PPC64_REL32. */
12239 return reloc_type
== 5; /* R_390_PC32. */
12241 return reloc_type
== 2; /* R_SH_REL32. */
12242 case EM_SPARC32PLUS
:
12245 return reloc_type
== 6; /* R_SPARC_DISP32. */
12247 return reloc_type
== 13; /* R_SPU_REL32. */
12249 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12251 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12253 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12257 return reloc_type
== 2; /* R_X86_64_PC32. */
12258 case EM_XTENSA_OLD
:
12260 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12262 /* Do not abort or issue an error message here. Not all targets use
12263 pc-relative 32-bit relocs in their DWARF debug information and we
12264 have already tested for target coverage in is_32bit_abs_reloc. A
12265 more helpful warning message will be generated by apply_relocations
12266 anyway, so just return. */
12271 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12272 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12275 is_64bit_abs_reloc (unsigned int reloc_type
)
12277 switch (elf_header
.e_machine
)
12280 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12282 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12284 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12286 return reloc_type
== 80; /* R_PARISC_DIR64. */
12288 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12290 return reloc_type
== 2; /* R_RISCV_64. */
12291 case EM_SPARC32PLUS
:
12294 return reloc_type
== 54; /* R_SPARC_UA64. */
12298 return reloc_type
== 1; /* R_X86_64_64. */
12301 return reloc_type
== 22; /* R_S390_64. */
12303 return reloc_type
== 1; /* R_TILEGX_64. */
12305 return reloc_type
== 18; /* R_MIPS_64. */
12311 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12312 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12315 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12317 switch (elf_header
.e_machine
)
12320 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12322 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12324 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12326 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12328 return reloc_type
== 44; /* R_PPC64_REL64. */
12329 case EM_SPARC32PLUS
:
12332 return reloc_type
== 46; /* R_SPARC_DISP64. */
12336 return reloc_type
== 24; /* R_X86_64_PC64. */
12339 return reloc_type
== 23; /* R_S390_PC64. */
12341 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12347 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12348 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12351 is_24bit_abs_reloc (unsigned int reloc_type
)
12353 switch (elf_header
.e_machine
)
12355 case EM_CYGNUS_MN10200
:
12357 return reloc_type
== 4; /* R_MN10200_24. */
12359 return reloc_type
== 5; /* R_FT32_20. */
12365 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12366 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12369 is_16bit_abs_reloc (unsigned int reloc_type
)
12371 /* Please keep this table alpha-sorted for ease of visual lookup. */
12372 switch (elf_header
.e_machine
)
12375 case EM_ARC_COMPACT
:
12376 case EM_ARC_COMPACT2
:
12377 return reloc_type
== 2; /* R_ARC_16. */
12378 case EM_ADAPTEVA_EPIPHANY
:
12379 return reloc_type
== 5;
12382 return reloc_type
== 4; /* R_AVR_16. */
12383 case EM_CYGNUS_D10V
:
12385 return reloc_type
== 3; /* R_D10V_16. */
12389 return reloc_type
== R_H8_DIR16
;
12392 return reloc_type
== 1; /* R_IP2K_16. */
12395 return reloc_type
== 1; /* R_M32C_16 */
12396 case EM_CYGNUS_MN10200
:
12398 return reloc_type
== 2; /* R_MN10200_16. */
12399 case EM_CYGNUS_MN10300
:
12401 return reloc_type
== 2; /* R_MN10300_16. */
12403 if (uses_msp430x_relocs ())
12404 return reloc_type
== 2; /* R_MSP430_ABS16. */
12405 /* Fall through. */
12406 case EM_MSP430_OLD
:
12407 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12409 return reloc_type
== 19; /* R_NDS32_RELA. */
12410 case EM_ALTERA_NIOS2
:
12411 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12413 return reloc_type
== 9; /* R_NIOS_16. */
12415 return reloc_type
== 2; /* R_OR1K_16. */
12417 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12419 return reloc_type
== 2; /* R_C6000_ABS16. */
12421 return reloc_type
== 2; /* R_VISIUM_16. */
12424 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12426 return reloc_type
== 3; /* R_XGATE_16. */
12432 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12433 relocation entries (possibly formerly used for SHT_GROUP sections). */
12436 is_none_reloc (unsigned int reloc_type
)
12438 switch (elf_header
.e_machine
)
12440 case EM_386
: /* R_386_NONE. */
12441 case EM_68K
: /* R_68K_NONE. */
12442 case EM_ADAPTEVA_EPIPHANY
:
12443 case EM_ALPHA
: /* R_ALPHA_NONE. */
12444 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12445 case EM_ARC
: /* R_ARC_NONE. */
12446 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12447 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12448 case EM_ARM
: /* R_ARM_NONE. */
12449 case EM_C166
: /* R_XC16X_NONE. */
12450 case EM_CRIS
: /* R_CRIS_NONE. */
12451 case EM_FT32
: /* R_FT32_NONE. */
12452 case EM_IA_64
: /* R_IA64_NONE. */
12453 case EM_K1OM
: /* R_X86_64_NONE. */
12454 case EM_L1OM
: /* R_X86_64_NONE. */
12455 case EM_M32R
: /* R_M32R_NONE. */
12456 case EM_MIPS
: /* R_MIPS_NONE. */
12457 case EM_MN10300
: /* R_MN10300_NONE. */
12458 case EM_MOXIE
: /* R_MOXIE_NONE. */
12459 case EM_NIOS32
: /* R_NIOS_NONE. */
12460 case EM_OR1K
: /* R_OR1K_NONE. */
12461 case EM_PARISC
: /* R_PARISC_NONE. */
12462 case EM_PPC64
: /* R_PPC64_NONE. */
12463 case EM_PPC
: /* R_PPC_NONE. */
12464 case EM_RISCV
: /* R_RISCV_NONE. */
12465 case EM_S390
: /* R_390_NONE. */
12467 case EM_SH
: /* R_SH_NONE. */
12468 case EM_SPARC32PLUS
:
12469 case EM_SPARC
: /* R_SPARC_NONE. */
12471 case EM_TILEGX
: /* R_TILEGX_NONE. */
12472 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12473 case EM_TI_C6000
:/* R_C6000_NONE. */
12474 case EM_X86_64
: /* R_X86_64_NONE. */
12476 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12477 return reloc_type
== 0;
12480 return reloc_type
== 0 || reloc_type
== 256;
12483 return (reloc_type
== 0 /* R_AVR_NONE. */
12484 || reloc_type
== 30 /* R_AVR_DIFF8. */
12485 || reloc_type
== 31 /* R_AVR_DIFF16. */
12486 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12488 return reloc_type
== 3; /* R_METAG_NONE. */
12490 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12491 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12492 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12493 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12494 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12496 return (reloc_type
== 0 /* R_PRU_NONE. */
12497 || reloc_type
== 65 /* R_PRU_DIFF8. */
12498 || reloc_type
== 66 /* R_PRU_DIFF16. */
12499 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12500 case EM_XTENSA_OLD
:
12502 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12503 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12504 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12505 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12510 /* Returns TRUE if there is a relocation against
12511 section NAME at OFFSET bytes. */
12514 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12516 Elf_Internal_Rela
* relocs
;
12517 Elf_Internal_Rela
* rp
;
12519 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12522 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12524 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12525 if (rp
->r_offset
== offset
)
12531 /* Apply relocations to a section.
12532 Returns TRUE upon success, FALSE otherwise.
12533 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12534 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12535 will be set to the number of relocs loaded.
12537 Note: So far support has been added only for those relocations
12538 which can be found in debug sections. FIXME: Add support for
12539 more relocations ? */
12542 apply_relocations (void * file
,
12543 const Elf_Internal_Shdr
* section
,
12544 unsigned char * start
,
12545 bfd_size_type size
,
12546 void ** relocs_return
,
12547 unsigned long * num_relocs_return
)
12549 Elf_Internal_Shdr
* relsec
;
12550 unsigned char * end
= start
+ size
;
12551 bfd_boolean res
= TRUE
;
12553 if (relocs_return
!= NULL
)
12555 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12556 * num_relocs_return
= 0;
12559 if (elf_header
.e_type
!= ET_REL
)
12560 /* No relocs to apply. */
12563 /* Find the reloc section associated with the section. */
12564 for (relsec
= section_headers
;
12565 relsec
< section_headers
+ elf_header
.e_shnum
;
12568 bfd_boolean is_rela
;
12569 unsigned long num_relocs
;
12570 Elf_Internal_Rela
* relocs
;
12571 Elf_Internal_Rela
* rp
;
12572 Elf_Internal_Shdr
* symsec
;
12573 Elf_Internal_Sym
* symtab
;
12574 unsigned long num_syms
;
12575 Elf_Internal_Sym
* sym
;
12577 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12578 || relsec
->sh_info
>= elf_header
.e_shnum
12579 || section_headers
+ relsec
->sh_info
!= section
12580 || relsec
->sh_size
== 0
12581 || relsec
->sh_link
>= elf_header
.e_shnum
)
12584 is_rela
= relsec
->sh_type
== SHT_RELA
;
12588 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12589 relsec
->sh_size
, & relocs
, & num_relocs
))
12594 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12595 relsec
->sh_size
, & relocs
, & num_relocs
))
12599 /* SH uses RELA but uses in place value instead of the addend field. */
12600 if (elf_header
.e_machine
== EM_SH
)
12603 symsec
= section_headers
+ relsec
->sh_link
;
12604 if (symsec
->sh_type
!= SHT_SYMTAB
12605 && symsec
->sh_type
!= SHT_DYNSYM
)
12607 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12609 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12612 unsigned int reloc_type
;
12613 unsigned int reloc_size
;
12614 unsigned char * rloc
;
12615 unsigned long sym_index
;
12617 reloc_type
= get_reloc_type (rp
->r_info
);
12619 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12621 else if (is_none_reloc (reloc_type
))
12623 else if (is_32bit_abs_reloc (reloc_type
)
12624 || is_32bit_pcrel_reloc (reloc_type
))
12626 else if (is_64bit_abs_reloc (reloc_type
)
12627 || is_64bit_pcrel_reloc (reloc_type
))
12629 else if (is_24bit_abs_reloc (reloc_type
))
12631 else if (is_16bit_abs_reloc (reloc_type
))
12635 static unsigned int prev_reloc
= 0;
12636 if (reloc_type
!= prev_reloc
)
12637 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12638 reloc_type
, printable_section_name (section
));
12639 prev_reloc
= reloc_type
;
12644 rloc
= start
+ rp
->r_offset
;
12645 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12647 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12648 (unsigned long) rp
->r_offset
,
12649 printable_section_name (section
));
12654 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12655 if (sym_index
>= num_syms
)
12657 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12658 sym_index
, printable_section_name (section
));
12662 sym
= symtab
+ sym_index
;
12664 /* If the reloc has a symbol associated with it,
12665 make sure that it is of an appropriate type.
12667 Relocations against symbols without type can happen.
12668 Gcc -feliminate-dwarf2-dups may generate symbols
12669 without type for debug info.
12671 Icc generates relocations against function symbols
12672 instead of local labels.
12674 Relocations against object symbols can happen, eg when
12675 referencing a global array. For an example of this see
12676 the _clz.o binary in libgcc.a. */
12678 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12679 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12681 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12682 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12683 (long int)(rp
- relocs
),
12684 printable_section_name (relsec
));
12691 addend
+= rp
->r_addend
;
12692 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12693 partial_inplace. */
12695 || (elf_header
.e_machine
== EM_XTENSA
12696 && reloc_type
== 1)
12697 || ((elf_header
.e_machine
== EM_PJ
12698 || elf_header
.e_machine
== EM_PJ_OLD
)
12699 && reloc_type
== 1)
12700 || ((elf_header
.e_machine
== EM_D30V
12701 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12702 && reloc_type
== 12))
12703 addend
+= byte_get (rloc
, reloc_size
);
12705 if (is_32bit_pcrel_reloc (reloc_type
)
12706 || is_64bit_pcrel_reloc (reloc_type
))
12708 /* On HPPA, all pc-relative relocations are biased by 8. */
12709 if (elf_header
.e_machine
== EM_PARISC
)
12711 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12715 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12719 /* Let the target specific reloc processing code know that
12720 we have finished with these relocs. */
12721 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12725 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12726 * num_relocs_return
= num_relocs
;
12737 #ifdef SUPPORT_DISASSEMBLY
12739 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12741 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12743 /* FIXME: XXX -- to be done --- XXX */
12749 /* Reads in the contents of SECTION from FILE, returning a pointer
12750 to a malloc'ed buffer or NULL if something went wrong. */
12753 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12755 bfd_size_type num_bytes
;
12757 num_bytes
= section
->sh_size
;
12759 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12761 printf (_("\nSection '%s' has no data to dump.\n"),
12762 printable_section_name (section
));
12766 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12767 _("section contents"));
12770 /* Uncompresses a section that was compressed using zlib, in place. */
12773 uncompress_section_contents (unsigned char **buffer
,
12774 dwarf_size_type uncompressed_size
,
12775 dwarf_size_type
*size
)
12777 dwarf_size_type compressed_size
= *size
;
12778 unsigned char * compressed_buffer
= *buffer
;
12779 unsigned char * uncompressed_buffer
;
12783 /* It is possible the section consists of several compressed
12784 buffers concatenated together, so we uncompress in a loop. */
12785 /* PR 18313: The state field in the z_stream structure is supposed
12786 to be invisible to the user (ie us), but some compilers will
12787 still complain about it being used without initialisation. So
12788 we first zero the entire z_stream structure and then set the fields
12790 memset (& strm
, 0, sizeof strm
);
12791 strm
.avail_in
= compressed_size
;
12792 strm
.next_in
= (Bytef
*) compressed_buffer
;
12793 strm
.avail_out
= uncompressed_size
;
12794 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12796 rc
= inflateInit (& strm
);
12797 while (strm
.avail_in
> 0)
12801 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12802 + (uncompressed_size
- strm
.avail_out
));
12803 rc
= inflate (&strm
, Z_FINISH
);
12804 if (rc
!= Z_STREAM_END
)
12806 rc
= inflateReset (& strm
);
12808 rc
= inflateEnd (& strm
);
12810 || strm
.avail_out
!= 0)
12813 *buffer
= uncompressed_buffer
;
12814 *size
= uncompressed_size
;
12818 free (uncompressed_buffer
);
12819 /* Indicate decompression failure. */
12825 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12827 Elf_Internal_Shdr
* relsec
;
12828 bfd_size_type num_bytes
;
12829 unsigned char * data
;
12830 unsigned char * end
;
12831 unsigned char * real_start
;
12832 unsigned char * start
;
12833 bfd_boolean some_strings_shown
;
12835 real_start
= start
= (unsigned char *) get_section_contents (section
,
12839 num_bytes
= section
->sh_size
;
12841 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12843 if (decompress_dumps
)
12845 dwarf_size_type new_size
= num_bytes
;
12846 dwarf_size_type uncompressed_size
= 0;
12848 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12850 Elf_Internal_Chdr chdr
;
12851 unsigned int compression_header_size
12852 = get_compression_header (& chdr
, (unsigned char *) start
,
12855 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12857 warn (_("section '%s' has unsupported compress type: %d\n"),
12858 printable_section_name (section
), chdr
.ch_type
);
12861 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12863 warn (_("compressed section '%s' is corrupted\n"),
12864 printable_section_name (section
));
12867 uncompressed_size
= chdr
.ch_size
;
12868 start
+= compression_header_size
;
12869 new_size
-= compression_header_size
;
12871 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12873 /* Read the zlib header. In this case, it should be "ZLIB"
12874 followed by the uncompressed section size, 8 bytes in
12875 big-endian order. */
12876 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12877 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12878 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12879 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12880 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12881 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12882 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12883 uncompressed_size
+= start
[11];
12888 if (uncompressed_size
)
12890 if (uncompress_section_contents (& start
,
12891 uncompressed_size
, & new_size
))
12892 num_bytes
= new_size
;
12895 error (_("Unable to decompress section %s\n"),
12896 printable_section_name (section
));
12901 start
= real_start
;
12904 /* If the section being dumped has relocations against it the user might
12905 be expecting these relocations to have been applied. Check for this
12906 case and issue a warning message in order to avoid confusion.
12907 FIXME: Maybe we ought to have an option that dumps a section with
12908 relocs applied ? */
12909 for (relsec
= section_headers
;
12910 relsec
< section_headers
+ elf_header
.e_shnum
;
12913 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12914 || relsec
->sh_info
>= elf_header
.e_shnum
12915 || section_headers
+ relsec
->sh_info
!= section
12916 || relsec
->sh_size
== 0
12917 || relsec
->sh_link
>= elf_header
.e_shnum
)
12920 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12925 end
= start
+ num_bytes
;
12926 some_strings_shown
= FALSE
;
12930 while (!ISPRINT (* data
))
12931 if (++ data
>= end
)
12936 size_t maxlen
= end
- data
;
12939 /* PR 11128: Use two separate invocations in order to work
12940 around bugs in the Solaris 8 implementation of printf. */
12941 printf (" [%6tx] ", data
- start
);
12943 printf (" [%6Ix] ", (size_t) (data
- start
));
12947 print_symbol ((int) maxlen
, (const char *) data
);
12949 data
+= strnlen ((const char *) data
, maxlen
);
12953 printf (_("<corrupt>\n"));
12956 some_strings_shown
= TRUE
;
12960 if (! some_strings_shown
)
12961 printf (_(" No strings found in this section."));
12970 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12972 bfd_boolean relocate
)
12974 Elf_Internal_Shdr
* relsec
;
12975 bfd_size_type bytes
;
12976 bfd_size_type section_size
;
12978 unsigned char * data
;
12979 unsigned char * real_start
;
12980 unsigned char * start
;
12982 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12986 section_size
= section
->sh_size
;
12988 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12990 if (decompress_dumps
)
12992 dwarf_size_type new_size
= section_size
;
12993 dwarf_size_type uncompressed_size
= 0;
12995 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12997 Elf_Internal_Chdr chdr
;
12998 unsigned int compression_header_size
12999 = get_compression_header (& chdr
, start
, section_size
);
13001 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13003 warn (_("section '%s' has unsupported compress type: %d\n"),
13004 printable_section_name (section
), chdr
.ch_type
);
13007 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13009 warn (_("compressed section '%s' is corrupted\n"),
13010 printable_section_name (section
));
13013 uncompressed_size
= chdr
.ch_size
;
13014 start
+= compression_header_size
;
13015 new_size
-= compression_header_size
;
13017 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13019 /* Read the zlib header. In this case, it should be "ZLIB"
13020 followed by the uncompressed section size, 8 bytes in
13021 big-endian order. */
13022 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13023 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13024 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13025 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13026 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13027 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13028 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13029 uncompressed_size
+= start
[11];
13034 if (uncompressed_size
)
13036 if (uncompress_section_contents (& start
, uncompressed_size
,
13039 section_size
= new_size
;
13043 error (_("Unable to decompress section %s\n"),
13044 printable_section_name (section
));
13045 /* FIXME: Print the section anyway ? */
13050 start
= real_start
;
13055 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
13060 /* If the section being dumped has relocations against it the user might
13061 be expecting these relocations to have been applied. Check for this
13062 case and issue a warning message in order to avoid confusion.
13063 FIXME: Maybe we ought to have an option that dumps a section with
13064 relocs applied ? */
13065 for (relsec
= section_headers
;
13066 relsec
< section_headers
+ elf_header
.e_shnum
;
13069 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13070 || relsec
->sh_info
>= elf_header
.e_shnum
13071 || section_headers
+ relsec
->sh_info
!= section
13072 || relsec
->sh_size
== 0
13073 || relsec
->sh_link
>= elf_header
.e_shnum
)
13076 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13081 addr
= section
->sh_addr
;
13082 bytes
= section_size
;
13091 lbytes
= (bytes
> 16 ? 16 : bytes
);
13093 printf (" 0x%8.8lx ", (unsigned long) addr
);
13095 for (j
= 0; j
< 16; j
++)
13098 printf ("%2.2x", data
[j
]);
13106 for (j
= 0; j
< lbytes
; j
++)
13109 if (k
>= ' ' && k
< 0x7f)
13129 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13130 const Elf_Internal_Shdr
* sec
, void * file
)
13132 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13135 /* If it is already loaded, do nothing. */
13136 if (section
->start
!= NULL
)
13139 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13140 section
->address
= sec
->sh_addr
;
13141 section
->user_data
= NULL
;
13142 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13144 sec
->sh_size
, buf
);
13145 if (section
->start
== NULL
)
13149 unsigned char *start
= section
->start
;
13150 dwarf_size_type size
= sec
->sh_size
;
13151 dwarf_size_type uncompressed_size
= 0;
13153 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13155 Elf_Internal_Chdr chdr
;
13156 unsigned int compression_header_size
;
13158 if (size
< (is_32bit_elf
13159 ? sizeof (Elf32_External_Chdr
)
13160 : sizeof (Elf64_External_Chdr
)))
13162 warn (_("compressed section %s is too small to contain a compression header"),
13167 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13169 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13171 warn (_("section '%s' has unsupported compress type: %d\n"),
13172 section
->name
, chdr
.ch_type
);
13175 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13177 warn (_("compressed section '%s' is corrupted\n"),
13181 uncompressed_size
= chdr
.ch_size
;
13182 start
+= compression_header_size
;
13183 size
-= compression_header_size
;
13185 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13187 /* Read the zlib header. In this case, it should be "ZLIB"
13188 followed by the uncompressed section size, 8 bytes in
13189 big-endian order. */
13190 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13191 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13192 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13193 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13194 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13195 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13196 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13197 uncompressed_size
+= start
[11];
13202 if (uncompressed_size
)
13204 if (uncompress_section_contents (&start
, uncompressed_size
,
13207 /* Free the compressed buffer, update the section buffer
13208 and the section size if uncompress is successful. */
13209 free (section
->start
);
13210 section
->start
= start
;
13214 error (_("Unable to decompress section %s\n"),
13215 printable_section_name (sec
));
13220 section
->size
= size
;
13223 if (section
->start
== NULL
)
13226 if (debug_displays
[debug
].relocate
)
13228 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13229 & section
->reloc_info
, & section
->num_relocs
))
13234 section
->reloc_info
= NULL
;
13235 section
->num_relocs
= 0;
13241 /* If this is not NULL, load_debug_section will only look for sections
13242 within the list of sections given here. */
13243 static unsigned int * section_subset
= NULL
;
13246 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13248 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13249 Elf_Internal_Shdr
* sec
;
13251 /* Locate the debug section. */
13252 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13254 section
->name
= section
->uncompressed_name
;
13257 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13259 section
->name
= section
->compressed_name
;
13264 /* If we're loading from a subset of sections, and we've loaded
13265 a section matching this name before, it's likely that it's a
13267 if (section_subset
!= NULL
)
13268 free_debug_section (debug
);
13270 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13274 free_debug_section (enum dwarf_section_display_enum debug
)
13276 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13278 if (section
->start
== NULL
)
13281 free ((char *) section
->start
);
13282 section
->start
= NULL
;
13283 section
->address
= 0;
13288 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13290 char * name
= SECTION_NAME (section
);
13291 const char * print_name
= printable_section_name (section
);
13292 bfd_size_type length
;
13293 bfd_boolean result
= TRUE
;
13296 length
= section
->sh_size
;
13299 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13302 if (section
->sh_type
== SHT_NOBITS
)
13304 /* There is no point in dumping the contents of a debugging section
13305 which has the NOBITS type - the bits in the file will be random.
13306 This can happen when a file containing a .eh_frame section is
13307 stripped with the --only-keep-debug command line option. */
13308 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13313 if (const_strneq (name
, ".gnu.linkonce.wi."))
13314 name
= ".debug_info";
13316 /* See if we know how to display the contents of this section. */
13317 for (i
= 0; i
< max
; i
++)
13318 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13319 || (i
== line
&& const_strneq (name
, ".debug_line."))
13320 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13322 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13323 int secondary
= (section
!= find_section (name
));
13326 free_debug_section ((enum dwarf_section_display_enum
) i
);
13328 if (i
== line
&& const_strneq (name
, ".debug_line."))
13330 else if (streq (sec
->uncompressed_name
, name
))
13331 sec
->name
= sec
->uncompressed_name
;
13333 sec
->name
= sec
->compressed_name
;
13334 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13337 /* If this debug section is part of a CU/TU set in a .dwp file,
13338 restrict load_debug_section to the sections in that set. */
13339 section_subset
= find_cu_tu_set (file
, shndx
);
13341 result
&= debug_displays
[i
].display (sec
, file
);
13343 section_subset
= NULL
;
13345 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13346 free_debug_section ((enum dwarf_section_display_enum
) i
);
13354 printf (_("Unrecognized debug section: %s\n"), print_name
);
13361 /* Set DUMP_SECTS for all sections where dumps were requested
13362 based on section name. */
13365 initialise_dumps_byname (void)
13367 struct dump_list_entry
* cur
;
13369 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13372 bfd_boolean any
= FALSE
;
13374 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13375 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13377 request_dump_bynumber (i
, cur
->type
);
13382 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13388 process_section_contents (FILE * file
)
13390 Elf_Internal_Shdr
* section
;
13392 bfd_boolean res
= TRUE
;
13397 initialise_dumps_byname ();
13399 for (i
= 0, section
= section_headers
;
13400 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13403 #ifdef SUPPORT_DISASSEMBLY
13404 if (dump_sects
[i
] & DISASS_DUMP
)
13405 disassemble_section (section
, file
);
13407 if (dump_sects
[i
] & HEX_DUMP
)
13409 if (! dump_section_as_bytes (section
, file
, FALSE
))
13413 if (dump_sects
[i
] & RELOC_DUMP
)
13415 if (! dump_section_as_bytes (section
, file
, TRUE
))
13419 if (dump_sects
[i
] & STRING_DUMP
)
13421 if (! dump_section_as_strings (section
, file
))
13425 if (dump_sects
[i
] & DEBUG_DUMP
)
13427 if (! display_debug_section (i
, section
, file
))
13432 /* Check to see if the user requested a
13433 dump of a section that does not exist. */
13434 while (i
< num_dump_sects
)
13438 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13448 process_mips_fpe_exception (int mask
)
13452 bfd_boolean first
= TRUE
;
13454 if (mask
& OEX_FPU_INEX
)
13455 fputs ("INEX", stdout
), first
= FALSE
;
13456 if (mask
& OEX_FPU_UFLO
)
13457 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13458 if (mask
& OEX_FPU_OFLO
)
13459 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13460 if (mask
& OEX_FPU_DIV0
)
13461 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13462 if (mask
& OEX_FPU_INVAL
)
13463 printf ("%sINVAL", first
? "" : "|");
13466 fputs ("0", stdout
);
13469 /* Display's the value of TAG at location P. If TAG is
13470 greater than 0 it is assumed to be an unknown tag, and
13471 a message is printed to this effect. Otherwise it is
13472 assumed that a message has already been printed.
13474 If the bottom bit of TAG is set it assumed to have a
13475 string value, otherwise it is assumed to have an integer
13478 Returns an updated P pointing to the first unread byte
13479 beyond the end of TAG's value.
13481 Reads at or beyond END will not be made. */
13483 static unsigned char *
13484 display_tag_value (signed int tag
,
13486 const unsigned char * const end
)
13491 printf (" Tag_unknown_%d: ", tag
);
13495 warn (_("<corrupt tag>\n"));
13499 /* PR 17531 file: 027-19978-0.004. */
13500 size_t maxlen
= (end
- p
) - 1;
13505 print_symbol ((int) maxlen
, (const char *) p
);
13506 p
+= strnlen ((char *) p
, maxlen
) + 1;
13510 printf (_("<corrupt string tag>"));
13511 p
= (unsigned char *) end
;
13519 val
= read_uleb128 (p
, &len
, end
);
13521 printf ("%ld (0x%lx)\n", val
, val
);
13528 /* ARC ABI attributes section. */
13530 static unsigned char *
13531 display_arc_attribute (unsigned char * p
,
13532 const unsigned char * const end
)
13538 tag
= read_uleb128 (p
, &len
, end
);
13543 case Tag_ARC_PCS_config
:
13544 val
= read_uleb128 (p
, &len
, end
);
13546 printf (" Tag_ARC_PCS_config: ");
13550 printf (_("Absent/Non standard\n"));
13553 printf (_("Bare metal/mwdt\n"));
13556 printf (_("Bare metal/newlib\n"));
13559 printf (_("Linux/uclibc\n"));
13562 printf (_("Linux/glibc\n"));
13565 printf (_("Unknown\n"));
13570 case Tag_ARC_CPU_base
:
13571 val
= read_uleb128 (p
, &len
, end
);
13573 printf (" Tag_ARC_CPU_base: ");
13578 printf (_("Absent\n"));
13580 case TAG_CPU_ARC6xx
:
13581 printf ("ARC6xx\n");
13583 case TAG_CPU_ARC7xx
:
13584 printf ("ARC7xx\n");
13586 case TAG_CPU_ARCEM
:
13587 printf ("ARCEM\n");
13589 case TAG_CPU_ARCHS
:
13590 printf ("ARCHS\n");
13595 case Tag_ARC_CPU_variation
:
13596 val
= read_uleb128 (p
, &len
, end
);
13598 printf (" Tag_ARC_CPU_variation: ");
13602 if (val
> 0 && val
< 16)
13603 printf ("Core%d\n", val
);
13605 printf ("Unknown\n");
13609 printf (_("Absent\n"));
13614 case Tag_ARC_CPU_name
:
13615 printf (" Tag_ARC_CPU_name: ");
13616 p
= display_tag_value (-1, p
, end
);
13619 case Tag_ARC_ABI_rf16
:
13620 val
= read_uleb128 (p
, &len
, end
);
13622 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
13625 case Tag_ARC_ABI_osver
:
13626 val
= read_uleb128 (p
, &len
, end
);
13628 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
13631 case Tag_ARC_ABI_pic
:
13632 case Tag_ARC_ABI_sda
:
13633 val
= read_uleb128 (p
, &len
, end
);
13635 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
13636 : " Tag_ARC_ABI_pic: ");
13640 printf (_("Absent\n"));
13649 printf (_("Unknown\n"));
13654 case Tag_ARC_ABI_tls
:
13655 val
= read_uleb128 (p
, &len
, end
);
13657 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
13660 case Tag_ARC_ABI_enumsize
:
13661 val
= read_uleb128 (p
, &len
, end
);
13663 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
13667 case Tag_ARC_ABI_exceptions
:
13668 val
= read_uleb128 (p
, &len
, end
);
13670 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
13674 case Tag_ARC_ABI_double_size
:
13675 val
= read_uleb128 (p
, &len
, end
);
13677 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
13680 case Tag_ARC_ISA_config
:
13681 printf (" Tag_ARC_ISA_config: ");
13682 p
= display_tag_value (-1, p
, end
);
13685 case Tag_ARC_ISA_apex
:
13686 printf (" Tag_ARC_ISA_apex: ");
13687 p
= display_tag_value (-1, p
, end
);
13690 case Tag_ARC_ISA_mpy_option
:
13691 val
= read_uleb128 (p
, &len
, end
);
13693 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
13697 return display_tag_value (tag
& 1, p
, end
);
13703 /* ARM EABI attributes section. */
13708 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13710 const char ** table
;
13711 } arm_attr_public_tag
;
13713 static const char * arm_attr_tag_CPU_arch
[] =
13714 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13715 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13717 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13718 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13719 {"No", "Thumb-1", "Thumb-2", "Yes"};
13720 static const char * arm_attr_tag_FP_arch
[] =
13721 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13722 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13723 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13724 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13725 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13726 "NEON for ARMv8.1"};
13727 static const char * arm_attr_tag_PCS_config
[] =
13728 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13729 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13730 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13731 {"V6", "SB", "TLS", "Unused"};
13732 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13733 {"Absolute", "PC-relative", "SB-relative", "None"};
13734 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13735 {"Absolute", "PC-relative", "None"};
13736 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13737 {"None", "direct", "GOT-indirect"};
13738 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13739 {"None", "??? 1", "2", "??? 3", "4"};
13740 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13741 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13742 {"Unused", "Needed", "Sign only"};
13743 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13744 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13745 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13746 {"Unused", "Finite", "RTABI", "IEEE 754"};
13747 static const char * arm_attr_tag_ABI_enum_size
[] =
13748 {"Unused", "small", "int", "forced to int"};
13749 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13750 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13751 static const char * arm_attr_tag_ABI_VFP_args
[] =
13752 {"AAPCS", "VFP registers", "custom", "compatible"};
13753 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13754 {"AAPCS", "WMMX registers", "custom"};
13755 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13756 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13757 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13758 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13759 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13760 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13761 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13762 static const char * arm_attr_tag_FP_HP_extension
[] =
13763 {"Not Allowed", "Allowed"};
13764 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13765 {"None", "IEEE 754", "Alternative Format"};
13766 static const char * arm_attr_tag_DSP_extension
[] =
13767 {"Follow architecture", "Allowed"};
13768 static const char * arm_attr_tag_MPextension_use
[] =
13769 {"Not Allowed", "Allowed"};
13770 static const char * arm_attr_tag_DIV_use
[] =
13771 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13772 "Allowed in v7-A with integer division extension"};
13773 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13774 static const char * arm_attr_tag_Virtualization_use
[] =
13775 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13776 "TrustZone and Virtualization Extensions"};
13777 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13778 {"Not Allowed", "Allowed"};
13780 #define LOOKUP(id, name) \
13781 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13782 static arm_attr_public_tag arm_attr_public_tags
[] =
13784 {4, "CPU_raw_name", 1, NULL
},
13785 {5, "CPU_name", 1, NULL
},
13786 LOOKUP(6, CPU_arch
),
13787 {7, "CPU_arch_profile", 0, NULL
},
13788 LOOKUP(8, ARM_ISA_use
),
13789 LOOKUP(9, THUMB_ISA_use
),
13790 LOOKUP(10, FP_arch
),
13791 LOOKUP(11, WMMX_arch
),
13792 LOOKUP(12, Advanced_SIMD_arch
),
13793 LOOKUP(13, PCS_config
),
13794 LOOKUP(14, ABI_PCS_R9_use
),
13795 LOOKUP(15, ABI_PCS_RW_data
),
13796 LOOKUP(16, ABI_PCS_RO_data
),
13797 LOOKUP(17, ABI_PCS_GOT_use
),
13798 LOOKUP(18, ABI_PCS_wchar_t
),
13799 LOOKUP(19, ABI_FP_rounding
),
13800 LOOKUP(20, ABI_FP_denormal
),
13801 LOOKUP(21, ABI_FP_exceptions
),
13802 LOOKUP(22, ABI_FP_user_exceptions
),
13803 LOOKUP(23, ABI_FP_number_model
),
13804 {24, "ABI_align_needed", 0, NULL
},
13805 {25, "ABI_align_preserved", 0, NULL
},
13806 LOOKUP(26, ABI_enum_size
),
13807 LOOKUP(27, ABI_HardFP_use
),
13808 LOOKUP(28, ABI_VFP_args
),
13809 LOOKUP(29, ABI_WMMX_args
),
13810 LOOKUP(30, ABI_optimization_goals
),
13811 LOOKUP(31, ABI_FP_optimization_goals
),
13812 {32, "compatibility", 0, NULL
},
13813 LOOKUP(34, CPU_unaligned_access
),
13814 LOOKUP(36, FP_HP_extension
),
13815 LOOKUP(38, ABI_FP_16bit_format
),
13816 LOOKUP(42, MPextension_use
),
13817 LOOKUP(44, DIV_use
),
13818 LOOKUP(46, DSP_extension
),
13819 {64, "nodefaults", 0, NULL
},
13820 {65, "also_compatible_with", 0, NULL
},
13821 LOOKUP(66, T2EE_use
),
13822 {67, "conformance", 1, NULL
},
13823 LOOKUP(68, Virtualization_use
),
13824 LOOKUP(70, MPextension_use_legacy
)
13828 static unsigned char *
13829 display_arm_attribute (unsigned char * p
,
13830 const unsigned char * const end
)
13835 arm_attr_public_tag
* attr
;
13839 tag
= read_uleb128 (p
, &len
, end
);
13842 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13844 if (arm_attr_public_tags
[i
].tag
== tag
)
13846 attr
= &arm_attr_public_tags
[i
];
13853 printf (" Tag_%s: ", attr
->name
);
13854 switch (attr
->type
)
13859 case 7: /* Tag_CPU_arch_profile. */
13860 val
= read_uleb128 (p
, &len
, end
);
13864 case 0: printf (_("None\n")); break;
13865 case 'A': printf (_("Application\n")); break;
13866 case 'R': printf (_("Realtime\n")); break;
13867 case 'M': printf (_("Microcontroller\n")); break;
13868 case 'S': printf (_("Application or Realtime\n")); break;
13869 default: printf ("??? (%d)\n", val
); break;
13873 case 24: /* Tag_align_needed. */
13874 val
= read_uleb128 (p
, &len
, end
);
13878 case 0: printf (_("None\n")); break;
13879 case 1: printf (_("8-byte\n")); break;
13880 case 2: printf (_("4-byte\n")); break;
13881 case 3: printf ("??? 3\n"); break;
13884 printf (_("8-byte and up to %d-byte extended\n"),
13887 printf ("??? (%d)\n", val
);
13892 case 25: /* Tag_align_preserved. */
13893 val
= read_uleb128 (p
, &len
, end
);
13897 case 0: printf (_("None\n")); break;
13898 case 1: printf (_("8-byte, except leaf SP\n")); break;
13899 case 2: printf (_("8-byte\n")); break;
13900 case 3: printf ("??? 3\n"); break;
13903 printf (_("8-byte and up to %d-byte extended\n"),
13906 printf ("??? (%d)\n", val
);
13911 case 32: /* Tag_compatibility. */
13913 val
= read_uleb128 (p
, &len
, end
);
13915 printf (_("flag = %d, vendor = "), val
);
13918 size_t maxlen
= (end
- p
) - 1;
13920 print_symbol ((int) maxlen
, (const char *) p
);
13921 p
+= strnlen ((char *) p
, maxlen
) + 1;
13925 printf (_("<corrupt>"));
13926 p
= (unsigned char *) end
;
13932 case 64: /* Tag_nodefaults. */
13933 /* PR 17531: file: 001-505008-0.01. */
13936 printf (_("True\n"));
13939 case 65: /* Tag_also_compatible_with. */
13940 val
= read_uleb128 (p
, &len
, end
);
13942 if (val
== 6 /* Tag_CPU_arch. */)
13944 val
= read_uleb128 (p
, &len
, end
);
13946 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13947 printf ("??? (%d)\n", val
);
13949 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13953 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13958 printf (_("<unknown: %d>\n"), tag
);
13964 return display_tag_value (-1, p
, end
);
13966 return display_tag_value (0, p
, end
);
13969 assert (attr
->type
& 0x80);
13970 val
= read_uleb128 (p
, &len
, end
);
13972 type
= attr
->type
& 0x7f;
13974 printf ("??? (%d)\n", val
);
13976 printf ("%s\n", attr
->table
[val
]);
13981 return display_tag_value (tag
, p
, end
);
13984 static unsigned char *
13985 display_gnu_attribute (unsigned char * p
,
13986 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13987 const unsigned char * const end
)
13993 tag
= read_uleb128 (p
, &len
, end
);
13996 /* Tag_compatibility is the only generic GNU attribute defined at
14000 val
= read_uleb128 (p
, &len
, end
);
14003 printf (_("flag = %d, vendor = "), val
);
14006 printf (_("<corrupt>\n"));
14007 warn (_("corrupt vendor attribute\n"));
14013 size_t maxlen
= (end
- p
) - 1;
14015 print_symbol ((int) maxlen
, (const char *) p
);
14016 p
+= strnlen ((char *) p
, maxlen
) + 1;
14020 printf (_("<corrupt>"));
14021 p
= (unsigned char *) end
;
14028 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14029 return display_proc_gnu_attribute (p
, tag
, end
);
14031 return display_tag_value (tag
, p
, end
);
14034 static unsigned char *
14035 display_power_gnu_attribute (unsigned char * p
,
14037 const unsigned char * const end
)
14042 if (tag
== Tag_GNU_Power_ABI_FP
)
14044 val
= read_uleb128 (p
, &len
, end
);
14046 printf (" Tag_GNU_Power_ABI_FP: ");
14049 printf (_("<corrupt>\n"));
14054 printf ("(%#x), ", val
);
14059 printf (_("unspecified hard/soft float, "));
14062 printf (_("hard float, "));
14065 printf (_("soft float, "));
14068 printf (_("single-precision hard float, "));
14075 printf (_("unspecified long double\n"));
14078 printf (_("128-bit IBM long double\n"));
14081 printf (_("64-bit long double\n"));
14084 printf (_("128-bit IEEE long double\n"));
14090 if (tag
== Tag_GNU_Power_ABI_Vector
)
14092 val
= read_uleb128 (p
, &len
, end
);
14094 printf (" Tag_GNU_Power_ABI_Vector: ");
14097 printf (_("<corrupt>\n"));
14102 printf ("(%#x), ", val
);
14107 printf (_("unspecified\n"));
14110 printf (_("generic\n"));
14113 printf ("AltiVec\n");
14122 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14124 val
= read_uleb128 (p
, &len
, end
);
14126 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14129 printf (_("<corrupt>\n"));
14134 printf ("(%#x), ", val
);
14139 printf (_("unspecified\n"));
14142 printf ("r3/r4\n");
14145 printf (_("memory\n"));
14154 return display_tag_value (tag
& 1, p
, end
);
14157 static unsigned char *
14158 display_s390_gnu_attribute (unsigned char * p
,
14160 const unsigned char * const end
)
14165 if (tag
== Tag_GNU_S390_ABI_Vector
)
14167 val
= read_uleb128 (p
, &len
, end
);
14169 printf (" Tag_GNU_S390_ABI_Vector: ");
14174 printf (_("any\n"));
14177 printf (_("software\n"));
14180 printf (_("hardware\n"));
14183 printf ("??? (%d)\n", val
);
14189 return display_tag_value (tag
& 1, p
, end
);
14193 display_sparc_hwcaps (unsigned int mask
)
14197 bfd_boolean first
= TRUE
;
14199 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14200 fputs ("mul32", stdout
), first
= FALSE
;
14201 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14202 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14203 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14204 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14205 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14206 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14207 if (mask
& ELF_SPARC_HWCAP_POPC
)
14208 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14209 if (mask
& ELF_SPARC_HWCAP_VIS
)
14210 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14211 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14212 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14213 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14214 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14215 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14216 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14217 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14218 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14219 if (mask
& ELF_SPARC_HWCAP_HPC
)
14220 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14221 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14222 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14223 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14224 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14225 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14226 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14227 if (mask
& ELF_SPARC_HWCAP_IMA
)
14228 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14229 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14230 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14233 fputc ('0', stdout
);
14234 fputc ('\n', stdout
);
14238 display_sparc_hwcaps2 (unsigned int mask
)
14242 bfd_boolean first
= TRUE
;
14244 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14245 fputs ("fjathplus", stdout
), first
= FALSE
;
14246 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14247 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14248 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14249 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14250 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14251 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14252 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14253 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14254 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14255 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14256 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14257 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14258 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14259 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14260 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14261 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14262 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14263 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14264 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14265 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14268 fputc ('0', stdout
);
14269 fputc ('\n', stdout
);
14272 static unsigned char *
14273 display_sparc_gnu_attribute (unsigned char * p
,
14275 const unsigned char * const end
)
14280 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14282 val
= read_uleb128 (p
, &len
, end
);
14284 printf (" Tag_GNU_Sparc_HWCAPS: ");
14285 display_sparc_hwcaps (val
);
14288 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14290 val
= read_uleb128 (p
, &len
, end
);
14292 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14293 display_sparc_hwcaps2 (val
);
14297 return display_tag_value (tag
, p
, end
);
14301 print_mips_fp_abi_value (unsigned int val
)
14305 case Val_GNU_MIPS_ABI_FP_ANY
:
14306 printf (_("Hard or soft float\n"));
14308 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14309 printf (_("Hard float (double precision)\n"));
14311 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14312 printf (_("Hard float (single precision)\n"));
14314 case Val_GNU_MIPS_ABI_FP_SOFT
:
14315 printf (_("Soft float\n"));
14317 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14318 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14320 case Val_GNU_MIPS_ABI_FP_XX
:
14321 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14323 case Val_GNU_MIPS_ABI_FP_64
:
14324 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14326 case Val_GNU_MIPS_ABI_FP_64A
:
14327 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14329 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14330 printf (_("NaN 2008 compatibility\n"));
14333 printf ("??? (%d)\n", val
);
14338 static unsigned char *
14339 display_mips_gnu_attribute (unsigned char * p
,
14341 const unsigned char * const end
)
14343 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14348 val
= read_uleb128 (p
, &len
, end
);
14350 printf (" Tag_GNU_MIPS_ABI_FP: ");
14352 print_mips_fp_abi_value (val
);
14357 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14362 val
= read_uleb128 (p
, &len
, end
);
14364 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14368 case Val_GNU_MIPS_ABI_MSA_ANY
:
14369 printf (_("Any MSA or not\n"));
14371 case Val_GNU_MIPS_ABI_MSA_128
:
14372 printf (_("128-bit MSA\n"));
14375 printf ("??? (%d)\n", val
);
14381 return display_tag_value (tag
& 1, p
, end
);
14384 static unsigned char *
14385 display_tic6x_attribute (unsigned char * p
,
14386 const unsigned char * const end
)
14392 tag
= read_uleb128 (p
, &len
, end
);
14398 val
= read_uleb128 (p
, &len
, end
);
14400 printf (" Tag_ISA: ");
14404 case C6XABI_Tag_ISA_none
:
14405 printf (_("None\n"));
14407 case C6XABI_Tag_ISA_C62X
:
14410 case C6XABI_Tag_ISA_C67X
:
14413 case C6XABI_Tag_ISA_C67XP
:
14414 printf ("C67x+\n");
14416 case C6XABI_Tag_ISA_C64X
:
14419 case C6XABI_Tag_ISA_C64XP
:
14420 printf ("C64x+\n");
14422 case C6XABI_Tag_ISA_C674X
:
14423 printf ("C674x\n");
14426 printf ("??? (%d)\n", val
);
14431 case Tag_ABI_wchar_t
:
14432 val
= read_uleb128 (p
, &len
, end
);
14434 printf (" Tag_ABI_wchar_t: ");
14438 printf (_("Not used\n"));
14441 printf (_("2 bytes\n"));
14444 printf (_("4 bytes\n"));
14447 printf ("??? (%d)\n", val
);
14452 case Tag_ABI_stack_align_needed
:
14453 val
= read_uleb128 (p
, &len
, end
);
14455 printf (" Tag_ABI_stack_align_needed: ");
14459 printf (_("8-byte\n"));
14462 printf (_("16-byte\n"));
14465 printf ("??? (%d)\n", val
);
14470 case Tag_ABI_stack_align_preserved
:
14471 val
= read_uleb128 (p
, &len
, end
);
14473 printf (" Tag_ABI_stack_align_preserved: ");
14477 printf (_("8-byte\n"));
14480 printf (_("16-byte\n"));
14483 printf ("??? (%d)\n", val
);
14489 val
= read_uleb128 (p
, &len
, end
);
14491 printf (" Tag_ABI_DSBT: ");
14495 printf (_("DSBT addressing not used\n"));
14498 printf (_("DSBT addressing used\n"));
14501 printf ("??? (%d)\n", val
);
14507 val
= read_uleb128 (p
, &len
, end
);
14509 printf (" Tag_ABI_PID: ");
14513 printf (_("Data addressing position-dependent\n"));
14516 printf (_("Data addressing position-independent, GOT near DP\n"));
14519 printf (_("Data addressing position-independent, GOT far from DP\n"));
14522 printf ("??? (%d)\n", val
);
14528 val
= read_uleb128 (p
, &len
, end
);
14530 printf (" Tag_ABI_PIC: ");
14534 printf (_("Code addressing position-dependent\n"));
14537 printf (_("Code addressing position-independent\n"));
14540 printf ("??? (%d)\n", val
);
14545 case Tag_ABI_array_object_alignment
:
14546 val
= read_uleb128 (p
, &len
, end
);
14548 printf (" Tag_ABI_array_object_alignment: ");
14552 printf (_("8-byte\n"));
14555 printf (_("4-byte\n"));
14558 printf (_("16-byte\n"));
14561 printf ("??? (%d)\n", val
);
14566 case Tag_ABI_array_object_align_expected
:
14567 val
= read_uleb128 (p
, &len
, end
);
14569 printf (" Tag_ABI_array_object_align_expected: ");
14573 printf (_("8-byte\n"));
14576 printf (_("4-byte\n"));
14579 printf (_("16-byte\n"));
14582 printf ("??? (%d)\n", val
);
14587 case Tag_ABI_compatibility
:
14589 val
= read_uleb128 (p
, &len
, end
);
14591 printf (" Tag_ABI_compatibility: ");
14592 printf (_("flag = %d, vendor = "), val
);
14595 size_t maxlen
= (end
- p
) - 1;
14597 print_symbol ((int) maxlen
, (const char *) p
);
14598 p
+= strnlen ((char *) p
, maxlen
) + 1;
14602 printf (_("<corrupt>"));
14603 p
= (unsigned char *) end
;
14609 case Tag_ABI_conformance
:
14611 printf (" Tag_ABI_conformance: \"");
14614 size_t maxlen
= (end
- p
) - 1;
14616 print_symbol ((int) maxlen
, (const char *) p
);
14617 p
+= strnlen ((char *) p
, maxlen
) + 1;
14621 printf (_("<corrupt>"));
14622 p
= (unsigned char *) end
;
14629 return display_tag_value (tag
, p
, end
);
14633 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14635 unsigned long addr
= 0;
14636 size_t bytes
= end
- p
;
14643 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14645 printf (" 0x%8.8lx ", addr
);
14647 for (j
= 0; j
< 16; j
++)
14650 printf ("%2.2x", p
[j
]);
14658 for (j
= 0; j
< lbytes
; j
++)
14661 if (k
>= ' ' && k
< 0x7f)
14677 static unsigned char *
14678 display_msp430x_attribute (unsigned char * p
,
14679 const unsigned char * const end
)
14685 tag
= read_uleb128 (p
, & len
, end
);
14690 case OFBA_MSPABI_Tag_ISA
:
14691 val
= read_uleb128 (p
, &len
, end
);
14693 printf (" Tag_ISA: ");
14696 case 0: printf (_("None\n")); break;
14697 case 1: printf (_("MSP430\n")); break;
14698 case 2: printf (_("MSP430X\n")); break;
14699 default: printf ("??? (%d)\n", val
); break;
14703 case OFBA_MSPABI_Tag_Code_Model
:
14704 val
= read_uleb128 (p
, &len
, end
);
14706 printf (" Tag_Code_Model: ");
14709 case 0: printf (_("None\n")); break;
14710 case 1: printf (_("Small\n")); break;
14711 case 2: printf (_("Large\n")); break;
14712 default: printf ("??? (%d)\n", val
); break;
14716 case OFBA_MSPABI_Tag_Data_Model
:
14717 val
= read_uleb128 (p
, &len
, end
);
14719 printf (" Tag_Data_Model: ");
14722 case 0: printf (_("None\n")); break;
14723 case 1: printf (_("Small\n")); break;
14724 case 2: printf (_("Large\n")); break;
14725 case 3: printf (_("Restricted Large\n")); break;
14726 default: printf ("??? (%d)\n", val
); break;
14731 printf (_(" <unknown tag %d>: "), tag
);
14738 size_t maxlen
= (end
- p
) - 1;
14740 print_symbol ((int) maxlen
, (const char *) p
);
14741 p
+= strnlen ((char *) p
, maxlen
) + 1;
14745 printf (_("<corrupt>"));
14746 p
= (unsigned char *) end
;
14752 val
= read_uleb128 (p
, &len
, end
);
14754 printf ("%d (0x%x)\n", val
, val
);
14764 process_attributes (FILE * file
,
14765 const char * public_name
,
14766 unsigned int proc_type
,
14767 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14768 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14770 Elf_Internal_Shdr
* sect
;
14772 bfd_boolean res
= TRUE
;
14774 /* Find the section header so that we get the size. */
14775 for (i
= 0, sect
= section_headers
;
14776 i
< elf_header
.e_shnum
;
14779 unsigned char * contents
;
14782 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14785 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14786 sect
->sh_size
, _("attributes"));
14787 if (contents
== NULL
)
14794 /* The first character is the version of the attributes.
14795 Currently only version 1, (aka 'A') is recognised here. */
14798 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14803 bfd_vma section_len
;
14805 section_len
= sect
->sh_size
- 1;
14808 while (section_len
> 0)
14811 unsigned int namelen
;
14812 bfd_boolean public_section
;
14813 bfd_boolean gnu_section
;
14815 if (section_len
<= 4)
14817 error (_("Tag section ends prematurely\n"));
14821 attr_len
= byte_get (p
, 4);
14824 if (attr_len
> section_len
)
14826 error (_("Bad attribute length (%u > %u)\n"),
14827 (unsigned) attr_len
, (unsigned) section_len
);
14828 attr_len
= section_len
;
14831 /* PR 17531: file: 001-101425-0.004 */
14832 else if (attr_len
< 5)
14834 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14839 section_len
-= attr_len
;
14842 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14843 if (namelen
== 0 || namelen
>= attr_len
)
14845 error (_("Corrupt attribute section name\n"));
14850 printf (_("Attribute Section: "));
14851 print_symbol (INT_MAX
, (const char *) p
);
14854 if (public_name
&& streq ((char *) p
, public_name
))
14855 public_section
= TRUE
;
14857 public_section
= FALSE
;
14859 if (streq ((char *) p
, "gnu"))
14860 gnu_section
= TRUE
;
14862 gnu_section
= FALSE
;
14865 attr_len
-= namelen
;
14867 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14872 unsigned char * end
;
14874 /* PR binutils/17531: Safe handling of corrupt files. */
14877 error (_("Unused bytes at end of section\n"));
14884 size
= byte_get (p
, 4);
14885 if (size
> attr_len
)
14887 error (_("Bad subsection length (%u > %u)\n"),
14888 (unsigned) size
, (unsigned) attr_len
);
14892 /* PR binutils/17531: Safe handling of corrupt files. */
14895 error (_("Bad subsection length (%u < 6)\n"),
14903 end
= p
+ size
- 1;
14904 assert (end
<= contents
+ sect
->sh_size
);
14910 printf (_("File Attributes\n"));
14913 printf (_("Section Attributes:"));
14916 printf (_("Symbol Attributes:"));
14917 /* Fall through. */
14923 val
= read_uleb128 (p
, &j
, end
);
14927 printf (" %d", val
);
14932 printf (_("Unknown tag: %d\n"), tag
);
14933 public_section
= FALSE
;
14937 if (public_section
&& display_pub_attribute
!= NULL
)
14940 p
= display_pub_attribute (p
, end
);
14943 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14946 p
= display_gnu_attribute (p
,
14947 display_proc_gnu_attribute
,
14953 printf (_(" Unknown attribute:\n"));
14954 display_raw_attribute (p
, end
);
14969 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14970 Print the Address, Access and Initial fields of an entry at VMA ADDR
14971 and return the VMA of the next entry, or -1 if there was a problem.
14972 Does not read from DATA_END or beyond. */
14975 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14976 unsigned char * data_end
)
14979 print_vma (addr
, LONG_HEX
);
14981 if (addr
< pltgot
+ 0xfff0)
14982 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14984 printf ("%10s", "");
14987 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14991 unsigned char * from
= data
+ addr
- pltgot
;
14993 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14995 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14996 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14997 return (bfd_vma
) -1;
15001 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15002 print_vma (entry
, LONG_HEX
);
15005 return addr
+ (is_32bit_elf
? 4 : 8);
15008 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15009 PLTGOT. Print the Address and Initial fields of an entry at VMA
15010 ADDR and return the VMA of the next entry. */
15013 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15016 print_vma (addr
, LONG_HEX
);
15019 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15024 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15025 print_vma (entry
, LONG_HEX
);
15027 return addr
+ (is_32bit_elf
? 4 : 8);
15031 print_mips_ases (unsigned int mask
)
15033 if (mask
& AFL_ASE_DSP
)
15034 fputs ("\n\tDSP ASE", stdout
);
15035 if (mask
& AFL_ASE_DSPR2
)
15036 fputs ("\n\tDSP R2 ASE", stdout
);
15037 if (mask
& AFL_ASE_DSPR3
)
15038 fputs ("\n\tDSP R3 ASE", stdout
);
15039 if (mask
& AFL_ASE_EVA
)
15040 fputs ("\n\tEnhanced VA Scheme", stdout
);
15041 if (mask
& AFL_ASE_MCU
)
15042 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15043 if (mask
& AFL_ASE_MDMX
)
15044 fputs ("\n\tMDMX ASE", stdout
);
15045 if (mask
& AFL_ASE_MIPS3D
)
15046 fputs ("\n\tMIPS-3D ASE", stdout
);
15047 if (mask
& AFL_ASE_MT
)
15048 fputs ("\n\tMT ASE", stdout
);
15049 if (mask
& AFL_ASE_SMARTMIPS
)
15050 fputs ("\n\tSmartMIPS ASE", stdout
);
15051 if (mask
& AFL_ASE_VIRT
)
15052 fputs ("\n\tVZ ASE", stdout
);
15053 if (mask
& AFL_ASE_MSA
)
15054 fputs ("\n\tMSA ASE", stdout
);
15055 if (mask
& AFL_ASE_MIPS16
)
15056 fputs ("\n\tMIPS16 ASE", stdout
);
15057 if (mask
& AFL_ASE_MICROMIPS
)
15058 fputs ("\n\tMICROMIPS ASE", stdout
);
15059 if (mask
& AFL_ASE_XPA
)
15060 fputs ("\n\tXPA ASE", stdout
);
15061 if (mask
& AFL_ASE_MIPS16E2
)
15062 fputs ("\n\tMIPS16e2 ASE", stdout
);
15064 fprintf (stdout
, "\n\t%s", _("None"));
15065 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15066 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15070 print_mips_isa_ext (unsigned int isa_ext
)
15075 fputs (_("None"), stdout
);
15078 fputs ("RMI XLR", stdout
);
15080 case AFL_EXT_OCTEON3
:
15081 fputs ("Cavium Networks Octeon3", stdout
);
15083 case AFL_EXT_OCTEON2
:
15084 fputs ("Cavium Networks Octeon2", stdout
);
15086 case AFL_EXT_OCTEONP
:
15087 fputs ("Cavium Networks OcteonP", stdout
);
15089 case AFL_EXT_LOONGSON_3A
:
15090 fputs ("Loongson 3A", stdout
);
15092 case AFL_EXT_OCTEON
:
15093 fputs ("Cavium Networks Octeon", stdout
);
15096 fputs ("Toshiba R5900", stdout
);
15099 fputs ("MIPS R4650", stdout
);
15102 fputs ("LSI R4010", stdout
);
15105 fputs ("NEC VR4100", stdout
);
15108 fputs ("Toshiba R3900", stdout
);
15110 case AFL_EXT_10000
:
15111 fputs ("MIPS R10000", stdout
);
15114 fputs ("Broadcom SB-1", stdout
);
15117 fputs ("NEC VR4111/VR4181", stdout
);
15120 fputs ("NEC VR4120", stdout
);
15123 fputs ("NEC VR5400", stdout
);
15126 fputs ("NEC VR5500", stdout
);
15128 case AFL_EXT_LOONGSON_2E
:
15129 fputs ("ST Microelectronics Loongson 2E", stdout
);
15131 case AFL_EXT_LOONGSON_2F
:
15132 fputs ("ST Microelectronics Loongson 2F", stdout
);
15135 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15140 get_mips_reg_size (int reg_size
)
15142 return (reg_size
== AFL_REG_NONE
) ? 0
15143 : (reg_size
== AFL_REG_32
) ? 32
15144 : (reg_size
== AFL_REG_64
) ? 64
15145 : (reg_size
== AFL_REG_128
) ? 128
15150 process_mips_specific (FILE * file
)
15152 Elf_Internal_Dyn
* entry
;
15153 Elf_Internal_Shdr
*sect
= NULL
;
15154 size_t liblist_offset
= 0;
15155 size_t liblistno
= 0;
15156 size_t conflictsno
= 0;
15157 size_t options_offset
= 0;
15158 size_t conflicts_offset
= 0;
15159 size_t pltrelsz
= 0;
15161 bfd_vma pltgot
= 0;
15162 bfd_vma mips_pltgot
= 0;
15163 bfd_vma jmprel
= 0;
15164 bfd_vma local_gotno
= 0;
15165 bfd_vma gotsym
= 0;
15166 bfd_vma symtabno
= 0;
15167 bfd_boolean res
= TRUE
;
15169 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15170 display_mips_gnu_attribute
))
15173 sect
= find_section (".MIPS.abiflags");
15177 Elf_External_ABIFlags_v0
*abiflags_ext
;
15178 Elf_Internal_ABIFlags_v0 abiflags_in
;
15180 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15182 error (_("Corrupt MIPS ABI Flags section.\n"));
15187 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15188 sect
->sh_size
, _("MIPS ABI Flags section"));
15191 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15192 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15193 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15194 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15195 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15196 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15197 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15198 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15199 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15200 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15201 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15203 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15204 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15205 if (abiflags_in
.isa_rev
> 1)
15206 printf ("r%d", abiflags_in
.isa_rev
);
15207 printf ("\nGPR size: %d",
15208 get_mips_reg_size (abiflags_in
.gpr_size
));
15209 printf ("\nCPR1 size: %d",
15210 get_mips_reg_size (abiflags_in
.cpr1_size
));
15211 printf ("\nCPR2 size: %d",
15212 get_mips_reg_size (abiflags_in
.cpr2_size
));
15213 fputs ("\nFP ABI: ", stdout
);
15214 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15215 fputs ("ISA Extension: ", stdout
);
15216 print_mips_isa_ext (abiflags_in
.isa_ext
);
15217 fputs ("\nASEs:", stdout
);
15218 print_mips_ases (abiflags_in
.ases
);
15219 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15220 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15221 fputc ('\n', stdout
);
15222 free (abiflags_ext
);
15227 /* We have a lot of special sections. Thanks SGI! */
15228 if (dynamic_section
== NULL
)
15230 /* No dynamic information available. See if there is static GOT. */
15231 sect
= find_section (".got");
15234 unsigned char *data_end
;
15235 unsigned char *data
;
15239 pltgot
= sect
->sh_addr
;
15242 addr_size
= (is_32bit_elf
? 4 : 8);
15243 end
= pltgot
+ sect
->sh_size
;
15245 data
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
,
15247 _("Global Offset Table data"));
15248 /* PR 12855: Null data is handled gracefully throughout. */
15249 data_end
= data
+ (end
- pltgot
);
15251 printf (_("\nStatic GOT:\n"));
15252 printf (_(" Canonical gp value: "));
15253 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15256 /* In a dynamic binary GOT[0] is reserved for the dynamic
15257 loader to store the lazy resolver pointer, however in
15258 a static binary it may well have been omitted and GOT
15259 reduced to a table of addresses.
15260 PR 21344: Check for the entry being fully available
15261 before fetching it. */
15263 && data
+ ent
- pltgot
+ addr_size
<= data_end
15264 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15266 printf (_(" Reserved entries:\n"));
15267 printf (_(" %*s %10s %*s\n"),
15268 addr_size
* 2, _("Address"), _("Access"),
15269 addr_size
* 2, _("Value"));
15270 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15272 if (ent
== (bfd_vma
) -1)
15273 goto sgot_print_fail
;
15275 /* Check for the MSB of GOT[1] being set, identifying a
15276 GNU object. This entry will be used by some runtime
15277 loaders, to store the module pointer. Otherwise this
15278 is an ordinary local entry.
15279 PR 21344: Check for the entry being fully available
15280 before fetching it. */
15282 && data
+ ent
- pltgot
+ addr_size
<= data_end
15283 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15284 >> (addr_size
* 8 - 1)) != 0)
15286 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15288 if (ent
== (bfd_vma
) -1)
15289 goto sgot_print_fail
;
15296 printf (_(" Local entries:\n"));
15297 printf (" %*s %10s %*s\n",
15298 addr_size
* 2, _("Address"), _("Access"),
15299 addr_size
* 2, _("Value"));
15302 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15304 if (ent
== (bfd_vma
) -1)
15305 goto sgot_print_fail
;
15317 for (entry
= dynamic_section
;
15318 /* PR 17531 file: 012-50589-0.004. */
15319 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15321 switch (entry
->d_tag
)
15323 case DT_MIPS_LIBLIST
:
15325 = offset_from_vma (file
, entry
->d_un
.d_val
,
15326 liblistno
* sizeof (Elf32_External_Lib
));
15328 case DT_MIPS_LIBLISTNO
:
15329 liblistno
= entry
->d_un
.d_val
;
15331 case DT_MIPS_OPTIONS
:
15332 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15334 case DT_MIPS_CONFLICT
:
15336 = offset_from_vma (file
, entry
->d_un
.d_val
,
15337 conflictsno
* sizeof (Elf32_External_Conflict
));
15339 case DT_MIPS_CONFLICTNO
:
15340 conflictsno
= entry
->d_un
.d_val
;
15343 pltgot
= entry
->d_un
.d_ptr
;
15345 case DT_MIPS_LOCAL_GOTNO
:
15346 local_gotno
= entry
->d_un
.d_val
;
15348 case DT_MIPS_GOTSYM
:
15349 gotsym
= entry
->d_un
.d_val
;
15351 case DT_MIPS_SYMTABNO
:
15352 symtabno
= entry
->d_un
.d_val
;
15354 case DT_MIPS_PLTGOT
:
15355 mips_pltgot
= entry
->d_un
.d_ptr
;
15358 pltrel
= entry
->d_un
.d_val
;
15361 pltrelsz
= entry
->d_un
.d_val
;
15364 jmprel
= entry
->d_un
.d_ptr
;
15370 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15372 Elf32_External_Lib
* elib
;
15375 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15377 sizeof (Elf32_External_Lib
),
15378 _("liblist section data"));
15381 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15382 (unsigned long) liblistno
);
15383 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15386 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15393 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15394 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15395 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15396 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15397 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15399 tmp
= gmtime (&atime
);
15400 snprintf (timebuf
, sizeof (timebuf
),
15401 "%04u-%02u-%02uT%02u:%02u:%02u",
15402 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15403 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15405 printf ("%3lu: ", (unsigned long) cnt
);
15406 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15407 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15409 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15410 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15411 liblist
.l_version
);
15413 if (liblist
.l_flags
== 0)
15417 static const struct
15424 { " EXACT_MATCH", LL_EXACT_MATCH
},
15425 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15426 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15427 { " EXPORTS", LL_EXPORTS
},
15428 { " DELAY_LOAD", LL_DELAY_LOAD
},
15429 { " DELTA", LL_DELTA
}
15431 int flags
= liblist
.l_flags
;
15434 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15435 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15437 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15438 flags
^= l_flags_vals
[fcnt
].bit
;
15441 printf (" %#x", (unsigned int) flags
);
15453 if (options_offset
!= 0)
15455 Elf_External_Options
* eopt
;
15456 Elf_Internal_Options
* iopt
;
15457 Elf_Internal_Options
* option
;
15460 sect
= section_headers
;
15462 /* Find the section header so that we get the size. */
15463 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15464 /* PR 17533 file: 012-277276-0.004. */
15467 error (_("No MIPS_OPTIONS header found\n"));
15471 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15472 sect
->sh_size
, _("options"));
15475 iopt
= (Elf_Internal_Options
*)
15476 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15479 error (_("Out of memory allocating space for MIPS options\n"));
15486 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15488 Elf_External_Options
* eoption
;
15490 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15492 option
->kind
= BYTE_GET (eoption
->kind
);
15493 option
->size
= BYTE_GET (eoption
->size
);
15494 option
->section
= BYTE_GET (eoption
->section
);
15495 option
->info
= BYTE_GET (eoption
->info
);
15497 /* PR 17531: file: ffa0fa3b. */
15498 if (option
->size
< sizeof (* eopt
)
15499 || offset
+ option
->size
> sect
->sh_size
)
15501 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15504 offset
+= option
->size
;
15510 printf (_("\nSection '%s' contains %d entries:\n"),
15511 printable_section_name (sect
), cnt
);
15520 switch (option
->kind
)
15523 /* This shouldn't happen. */
15524 printf (" NULL %d %lx", option
->section
, option
->info
);
15527 printf (" REGINFO ");
15528 if (elf_header
.e_machine
== EM_MIPS
)
15531 Elf32_External_RegInfo
* ereg
;
15532 Elf32_RegInfo reginfo
;
15534 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15535 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15536 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15537 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15538 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15539 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15540 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15542 printf ("GPR %08lx GP 0x%lx\n",
15543 reginfo
.ri_gprmask
,
15544 (unsigned long) reginfo
.ri_gp_value
);
15545 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15546 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15547 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15552 Elf64_External_RegInfo
* ereg
;
15553 Elf64_Internal_RegInfo reginfo
;
15555 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15556 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15557 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15558 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15559 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15560 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15561 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15563 printf ("GPR %08lx GP 0x",
15564 reginfo
.ri_gprmask
);
15565 printf_vma (reginfo
.ri_gp_value
);
15568 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15569 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15570 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15574 case ODK_EXCEPTIONS
:
15575 fputs (" EXCEPTIONS fpe_min(", stdout
);
15576 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15577 fputs (") fpe_max(", stdout
);
15578 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15579 fputs (")", stdout
);
15581 if (option
->info
& OEX_PAGE0
)
15582 fputs (" PAGE0", stdout
);
15583 if (option
->info
& OEX_SMM
)
15584 fputs (" SMM", stdout
);
15585 if (option
->info
& OEX_FPDBUG
)
15586 fputs (" FPDBUG", stdout
);
15587 if (option
->info
& OEX_DISMISS
)
15588 fputs (" DISMISS", stdout
);
15591 fputs (" PAD ", stdout
);
15592 if (option
->info
& OPAD_PREFIX
)
15593 fputs (" PREFIX", stdout
);
15594 if (option
->info
& OPAD_POSTFIX
)
15595 fputs (" POSTFIX", stdout
);
15596 if (option
->info
& OPAD_SYMBOL
)
15597 fputs (" SYMBOL", stdout
);
15600 fputs (" HWPATCH ", stdout
);
15601 if (option
->info
& OHW_R4KEOP
)
15602 fputs (" R4KEOP", stdout
);
15603 if (option
->info
& OHW_R8KPFETCH
)
15604 fputs (" R8KPFETCH", stdout
);
15605 if (option
->info
& OHW_R5KEOP
)
15606 fputs (" R5KEOP", stdout
);
15607 if (option
->info
& OHW_R5KCVTL
)
15608 fputs (" R5KCVTL", stdout
);
15611 fputs (" FILL ", stdout
);
15612 /* XXX Print content of info word? */
15615 fputs (" TAGS ", stdout
);
15616 /* XXX Print content of info word? */
15619 fputs (" HWAND ", stdout
);
15620 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15621 fputs (" R4KEOP_CHECKED", stdout
);
15622 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15623 fputs (" R4KEOP_CLEAN", stdout
);
15626 fputs (" HWOR ", stdout
);
15627 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15628 fputs (" R4KEOP_CHECKED", stdout
);
15629 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15630 fputs (" R4KEOP_CLEAN", stdout
);
15633 printf (" GP_GROUP %#06lx self-contained %#06lx",
15634 option
->info
& OGP_GROUP
,
15635 (option
->info
& OGP_SELF
) >> 16);
15638 printf (" IDENT %#06lx self-contained %#06lx",
15639 option
->info
& OGP_GROUP
,
15640 (option
->info
& OGP_SELF
) >> 16);
15643 /* This shouldn't happen. */
15644 printf (" %3d ??? %d %lx",
15645 option
->kind
, option
->section
, option
->info
);
15649 len
= sizeof (* eopt
);
15650 while (len
< option
->size
)
15652 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15654 if (ISPRINT (datum
))
15655 printf ("%c", datum
);
15657 printf ("\\%03o", datum
);
15660 fputs ("\n", stdout
);
15662 offset
+= option
->size
;
15672 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15674 Elf32_Conflict
* iconf
;
15677 if (dynamic_symbols
== NULL
)
15679 error (_("conflict list found without a dynamic symbol table\n"));
15683 /* PR 21345 - print a slightly more helpful error message
15684 if we are sure that the cmalloc will fail. */
15685 if (conflictsno
* sizeof (* iconf
) > current_file_size
)
15687 error (_("Overlarge number of conflicts detected: %lx\n"),
15688 (long) conflictsno
);
15692 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15695 error (_("Out of memory allocating space for dynamic conflicts\n"));
15701 Elf32_External_Conflict
* econf32
;
15703 econf32
= (Elf32_External_Conflict
*)
15704 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15705 sizeof (* econf32
), _("conflict"));
15709 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15710 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15716 Elf64_External_Conflict
* econf64
;
15718 econf64
= (Elf64_External_Conflict
*)
15719 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15720 sizeof (* econf64
), _("conflict"));
15724 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15725 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15730 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15731 (unsigned long) conflictsno
);
15732 puts (_(" Num: Index Value Name"));
15734 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15736 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15738 if (iconf
[cnt
] >= num_dynamic_syms
)
15739 printf (_("<corrupt symbol index>"));
15742 Elf_Internal_Sym
* psym
;
15744 psym
= & dynamic_symbols
[iconf
[cnt
]];
15745 print_vma (psym
->st_value
, FULL_HEX
);
15747 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15748 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15750 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15758 if (pltgot
!= 0 && local_gotno
!= 0)
15760 bfd_vma ent
, local_end
, global_end
;
15762 unsigned char * data
;
15763 unsigned char * data_end
;
15767 addr_size
= (is_32bit_elf
? 4 : 8);
15768 local_end
= pltgot
+ local_gotno
* addr_size
;
15770 /* PR binutils/17533 file: 012-111227-0.004 */
15771 if (symtabno
< gotsym
)
15773 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15774 (unsigned long) gotsym
, (unsigned long) symtabno
);
15778 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15779 /* PR 17531: file: 54c91a34. */
15780 if (global_end
< local_end
)
15782 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15786 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15787 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15788 global_end
- pltgot
, 1,
15789 _("Global Offset Table data"));
15790 /* PR 12855: Null data is handled gracefully throughout. */
15791 data_end
= data
+ (global_end
- pltgot
);
15793 printf (_("\nPrimary GOT:\n"));
15794 printf (_(" Canonical gp value: "));
15795 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15798 printf (_(" Reserved entries:\n"));
15799 printf (_(" %*s %10s %*s Purpose\n"),
15800 addr_size
* 2, _("Address"), _("Access"),
15801 addr_size
* 2, _("Initial"));
15802 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15803 printf (_(" Lazy resolver\n"));
15804 if (ent
== (bfd_vma
) -1)
15805 goto got_print_fail
;
15807 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15808 This entry will be used by some runtime loaders, to store the
15809 module pointer. Otherwise this is an ordinary local entry.
15810 PR 21344: Check for the entry being fully available before
15813 && data
+ ent
- pltgot
+ addr_size
<= data_end
15814 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15815 >> (addr_size
* 8 - 1)) != 0)
15817 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15818 printf (_(" Module pointer (GNU extension)\n"));
15819 if (ent
== (bfd_vma
) -1)
15820 goto got_print_fail
;
15824 if (ent
< local_end
)
15826 printf (_(" Local entries:\n"));
15827 printf (" %*s %10s %*s\n",
15828 addr_size
* 2, _("Address"), _("Access"),
15829 addr_size
* 2, _("Initial"));
15830 while (ent
< local_end
)
15832 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15834 if (ent
== (bfd_vma
) -1)
15835 goto got_print_fail
;
15840 if (gotsym
< symtabno
)
15844 printf (_(" Global entries:\n"));
15845 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15846 addr_size
* 2, _("Address"),
15848 addr_size
* 2, _("Initial"),
15849 addr_size
* 2, _("Sym.Val."),
15851 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15852 _("Ndx"), _("Name"));
15854 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15856 for (i
= gotsym
; i
< symtabno
; i
++)
15858 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15861 if (dynamic_symbols
== NULL
)
15862 printf (_("<no dynamic symbols>"));
15863 else if (i
< num_dynamic_syms
)
15865 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15867 print_vma (psym
->st_value
, LONG_HEX
);
15868 printf (" %-7s %3s ",
15869 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15870 get_symbol_index_type (psym
->st_shndx
));
15872 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15873 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15875 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15878 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15879 (unsigned long) i
);
15882 if (ent
== (bfd_vma
) -1)
15893 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15896 size_t offset
, rel_offset
;
15897 unsigned long count
, i
;
15898 unsigned char * data
;
15899 int addr_size
, sym_width
;
15900 Elf_Internal_Rela
* rels
;
15902 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15903 if (pltrel
== DT_RELA
)
15905 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15910 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15915 addr_size
= (is_32bit_elf
? 4 : 8);
15916 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15918 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15919 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15920 1, _("Procedure Linkage Table data"));
15924 printf ("\nPLT GOT:\n\n");
15925 printf (_(" Reserved entries:\n"));
15926 printf (_(" %*s %*s Purpose\n"),
15927 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15928 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15929 printf (_(" PLT lazy resolver\n"));
15930 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15931 printf (_(" Module pointer\n"));
15934 printf (_(" Entries:\n"));
15935 printf (" %*s %*s %*s %-7s %3s %s\n",
15936 addr_size
* 2, _("Address"),
15937 addr_size
* 2, _("Initial"),
15938 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15939 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15940 for (i
= 0; i
< count
; i
++)
15942 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15944 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15947 if (idx
>= num_dynamic_syms
)
15948 printf (_("<corrupt symbol index: %lu>"), idx
);
15951 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15953 print_vma (psym
->st_value
, LONG_HEX
);
15954 printf (" %-7s %3s ",
15955 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15956 get_symbol_index_type (psym
->st_shndx
));
15957 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15958 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15960 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15975 process_nds32_specific (FILE * file
)
15977 Elf_Internal_Shdr
*sect
= NULL
;
15979 sect
= find_section (".nds32_e_flags");
15982 unsigned int *flag
;
15984 printf ("\nNDS32 elf flags section:\n");
15985 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15986 sect
->sh_size
, _("NDS32 elf flags section"));
15991 switch ((*flag
) & 0x3)
15994 printf ("(VEC_SIZE):\tNo entry.\n");
15997 printf ("(VEC_SIZE):\t4 bytes\n");
16000 printf ("(VEC_SIZE):\t16 bytes\n");
16003 printf ("(VEC_SIZE):\treserved\n");
16012 process_gnu_liblist (FILE * file
)
16014 Elf_Internal_Shdr
* section
;
16015 Elf_Internal_Shdr
* string_sec
;
16016 Elf32_External_Lib
* elib
;
16018 size_t strtab_size
;
16021 bfd_boolean res
= TRUE
;
16026 for (i
= 0, section
= section_headers
;
16027 i
< elf_header
.e_shnum
;
16030 switch (section
->sh_type
)
16032 case SHT_GNU_LIBLIST
:
16033 if (section
->sh_link
>= elf_header
.e_shnum
)
16036 elib
= (Elf32_External_Lib
*)
16037 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
16038 _("liblist section data"));
16046 string_sec
= section_headers
+ section
->sh_link
;
16047 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
16048 string_sec
->sh_size
,
16049 _("liblist string table"));
16051 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16058 strtab_size
= string_sec
->sh_size
;
16060 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16061 printable_section_name (section
),
16062 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
16064 puts (_(" Library Time Stamp Checksum Version Flags"));
16066 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16074 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16075 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16076 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16077 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16078 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16080 tmp
= gmtime (&atime
);
16081 snprintf (timebuf
, sizeof (timebuf
),
16082 "%04u-%02u-%02uT%02u:%02u:%02u",
16083 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16084 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16086 printf ("%3lu: ", (unsigned long) cnt
);
16088 printf ("%-20s", liblist
.l_name
< strtab_size
16089 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16091 printf ("%-20.20s", liblist
.l_name
< strtab_size
16092 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16093 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16094 liblist
.l_version
, liblist
.l_flags
);
16105 static const char *
16106 get_note_type (unsigned e_type
)
16108 static char buff
[64];
16110 if (elf_header
.e_type
== ET_CORE
)
16114 return _("NT_AUXV (auxiliary vector)");
16116 return _("NT_PRSTATUS (prstatus structure)");
16118 return _("NT_FPREGSET (floating point registers)");
16120 return _("NT_PRPSINFO (prpsinfo structure)");
16121 case NT_TASKSTRUCT
:
16122 return _("NT_TASKSTRUCT (task structure)");
16124 return _("NT_PRXFPREG (user_xfpregs structure)");
16126 return _("NT_PPC_VMX (ppc Altivec registers)");
16128 return _("NT_PPC_VSX (ppc VSX registers)");
16130 return _("NT_386_TLS (x86 TLS information)");
16131 case NT_386_IOPERM
:
16132 return _("NT_386_IOPERM (x86 I/O permissions)");
16133 case NT_X86_XSTATE
:
16134 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16135 case NT_S390_HIGH_GPRS
:
16136 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16137 case NT_S390_TIMER
:
16138 return _("NT_S390_TIMER (s390 timer register)");
16139 case NT_S390_TODCMP
:
16140 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16141 case NT_S390_TODPREG
:
16142 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16144 return _("NT_S390_CTRS (s390 control registers)");
16145 case NT_S390_PREFIX
:
16146 return _("NT_S390_PREFIX (s390 prefix register)");
16147 case NT_S390_LAST_BREAK
:
16148 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16149 case NT_S390_SYSTEM_CALL
:
16150 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16152 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16153 case NT_S390_VXRS_LOW
:
16154 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16155 case NT_S390_VXRS_HIGH
:
16156 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16158 return _("NT_ARM_VFP (arm VFP registers)");
16160 return _("NT_ARM_TLS (AArch TLS registers)");
16161 case NT_ARM_HW_BREAK
:
16162 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16163 case NT_ARM_HW_WATCH
:
16164 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16166 return _("NT_PSTATUS (pstatus structure)");
16168 return _("NT_FPREGS (floating point registers)");
16170 return _("NT_PSINFO (psinfo structure)");
16172 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16174 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16175 case NT_WIN32PSTATUS
:
16176 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16178 return _("NT_SIGINFO (siginfo_t data)");
16180 return _("NT_FILE (mapped files)");
16188 return _("NT_VERSION (version)");
16190 return _("NT_ARCH (architecture)");
16191 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16192 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16193 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16194 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16199 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16204 print_core_note (Elf_Internal_Note
*pnote
)
16206 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16207 bfd_vma count
, page_size
;
16208 unsigned char *descdata
, *filenames
, *descend
;
16210 if (pnote
->type
!= NT_FILE
)
16216 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16217 /* Still "successful". */
16222 if (pnote
->descsz
< 2 * addr_size
)
16224 error (_(" Malformed note - too short for header\n"));
16228 descdata
= (unsigned char *) pnote
->descdata
;
16229 descend
= descdata
+ pnote
->descsz
;
16231 if (descdata
[pnote
->descsz
- 1] != '\0')
16233 error (_(" Malformed note - does not end with \\0\n"));
16237 count
= byte_get (descdata
, addr_size
);
16238 descdata
+= addr_size
;
16240 page_size
= byte_get (descdata
, addr_size
);
16241 descdata
+= addr_size
;
16243 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16245 error (_(" Malformed note - too short for supplied file count\n"));
16249 printf (_(" Page size: "));
16250 print_vma (page_size
, DEC
);
16253 printf (_(" %*s%*s%*s\n"),
16254 (int) (2 + 2 * addr_size
), _("Start"),
16255 (int) (4 + 2 * addr_size
), _("End"),
16256 (int) (4 + 2 * addr_size
), _("Page Offset"));
16257 filenames
= descdata
+ count
* 3 * addr_size
;
16258 while (count
-- > 0)
16260 bfd_vma start
, end
, file_ofs
;
16262 if (filenames
== descend
)
16264 error (_(" Malformed note - filenames end too early\n"));
16268 start
= byte_get (descdata
, addr_size
);
16269 descdata
+= addr_size
;
16270 end
= byte_get (descdata
, addr_size
);
16271 descdata
+= addr_size
;
16272 file_ofs
= byte_get (descdata
, addr_size
);
16273 descdata
+= addr_size
;
16276 print_vma (start
, FULL_HEX
);
16278 print_vma (end
, FULL_HEX
);
16280 print_vma (file_ofs
, FULL_HEX
);
16281 printf ("\n %s\n", filenames
);
16283 filenames
+= 1 + strlen ((char *) filenames
);
16289 static const char *
16290 get_gnu_elf_note_type (unsigned e_type
)
16292 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16295 case NT_GNU_ABI_TAG
:
16296 return _("NT_GNU_ABI_TAG (ABI version tag)");
16298 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16299 case NT_GNU_BUILD_ID
:
16300 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16301 case NT_GNU_GOLD_VERSION
:
16302 return _("NT_GNU_GOLD_VERSION (gold version)");
16303 case NT_GNU_PROPERTY_TYPE_0
:
16304 return _("NT_GNU_PROPERTY_TYPE_0");
16305 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16306 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16307 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16308 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16311 static char buff
[64];
16313 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16320 decode_x86_isa (unsigned int bitmask
)
16324 unsigned int bit
= bitmask
& (- bitmask
);
16329 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16330 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16331 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16332 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16333 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16334 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16335 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16336 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16337 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16338 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16339 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16340 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16341 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16342 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16343 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16344 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16345 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16346 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16347 default: printf (_("<unknown: %x>"), bit
); break;
16355 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16359 unsigned int bit
= bitmask
& (- bitmask
);
16364 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16367 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16371 /* This should never happen. */
16375 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16378 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16382 /* This should never happen. */
16387 printf (_("<unknown: %x>"), bit
);
16396 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16398 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16399 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16400 unsigned int size
= is_32bit_elf
? 4 : 8;
16402 printf (_(" Properties: "));
16404 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16406 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16413 unsigned int type
= byte_get (ptr
, 4);
16414 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16418 if ((ptr
+ datasz
) > ptr_end
)
16420 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16425 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16427 if (elf_header
.e_machine
== EM_X86_64
16428 || elf_header
.e_machine
== EM_IAMCU
16429 || elf_header
.e_machine
== EM_386
)
16433 case GNU_PROPERTY_X86_ISA_1_USED
:
16434 printf ("x86 ISA used: ");
16436 printf (_("<corrupt length: %#x> "), datasz
);
16438 decode_x86_isa (byte_get (ptr
, 4));
16441 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16442 printf ("x86 ISA needed: ");
16444 printf (_("<corrupt length: %#x> "), datasz
);
16446 decode_x86_isa (byte_get (ptr
, 4));
16449 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16450 printf ("x86 feature: ");
16452 printf (_("<corrupt length: %#x> "), datasz
);
16454 decode_x86_feature (type
, byte_get (ptr
, 4));
16466 case GNU_PROPERTY_STACK_SIZE
:
16467 printf (_("stack size: "));
16468 if (datasz
!= size
)
16469 printf (_("<corrupt length: %#x> "), datasz
);
16471 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16474 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16475 printf ("no copy on protected ");
16477 printf (_("<corrupt length: %#x> "), datasz
);
16485 if (type
< GNU_PROPERTY_LOPROC
)
16486 printf (_("<unknown type %#x data: "), type
);
16487 else if (type
< GNU_PROPERTY_LOUSER
)
16488 printf (_("<procesor-specific type %#x data: "), type
);
16490 printf (_("<application-specific type %#x data: "), type
);
16491 for (j
= 0; j
< datasz
; ++j
)
16492 printf ("%02x ", ptr
[j
] & 0xff);
16496 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16497 if (ptr
== ptr_end
)
16507 if (ptr
> (ptr_end
- 8))
16509 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16518 print_gnu_note (Elf_Internal_Note
*pnote
)
16520 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16521 switch (pnote
->type
)
16523 case NT_GNU_BUILD_ID
:
16527 printf (_(" Build ID: "));
16528 for (i
= 0; i
< pnote
->descsz
; ++i
)
16529 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16534 case NT_GNU_ABI_TAG
:
16536 unsigned long os
, major
, minor
, subminor
;
16537 const char *osname
;
16539 /* PR 17531: file: 030-599401-0.004. */
16540 if (pnote
->descsz
< 16)
16542 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16546 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16547 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16548 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16549 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16553 case GNU_ABI_TAG_LINUX
:
16556 case GNU_ABI_TAG_HURD
:
16559 case GNU_ABI_TAG_SOLARIS
:
16560 osname
= "Solaris";
16562 case GNU_ABI_TAG_FREEBSD
:
16563 osname
= "FreeBSD";
16565 case GNU_ABI_TAG_NETBSD
:
16568 case GNU_ABI_TAG_SYLLABLE
:
16569 osname
= "Syllable";
16571 case GNU_ABI_TAG_NACL
:
16575 osname
= "Unknown";
16579 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16580 major
, minor
, subminor
);
16584 case NT_GNU_GOLD_VERSION
:
16588 printf (_(" Version: "));
16589 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16590 printf ("%c", pnote
->descdata
[i
]);
16597 unsigned long num_entries
, mask
;
16599 /* Hardware capabilities information. Word 0 is the number of entries.
16600 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16601 is a series of entries, where each entry is a single byte followed
16602 by a nul terminated string. The byte gives the bit number to test
16603 if enabled in the bitmask. */
16604 printf (_(" Hardware Capabilities: "));
16605 if (pnote
->descsz
< 8)
16607 error (_("<corrupt GNU_HWCAP>\n"));
16610 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16611 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16612 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16613 /* FIXME: Add code to display the entries... */
16617 case NT_GNU_PROPERTY_TYPE_0
:
16618 print_gnu_property_note (pnote
);
16622 /* Handle unrecognised types. An error message should have already been
16623 created by get_gnu_elf_note_type(), so all that we need to do is to
16624 display the data. */
16628 printf (_(" Description data: "));
16629 for (i
= 0; i
< pnote
->descsz
; ++i
)
16630 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16639 static const char *
16640 get_v850_elf_note_type (enum v850_notes n_type
)
16642 static char buff
[64];
16646 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16647 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16648 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16649 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16650 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16651 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16653 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16659 print_v850_note (Elf_Internal_Note
* pnote
)
16663 if (pnote
->descsz
!= 4)
16666 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16670 printf (_("not set\n"));
16674 switch (pnote
->type
)
16676 case V850_NOTE_ALIGNMENT
:
16679 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16680 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16684 case V850_NOTE_DATA_SIZE
:
16687 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16688 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16692 case V850_NOTE_FPU_INFO
:
16695 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16696 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16700 case V850_NOTE_MMU_INFO
:
16701 case V850_NOTE_CACHE_INFO
:
16702 case V850_NOTE_SIMD_INFO
:
16703 if (val
== EF_RH850_SIMD
)
16705 printf (_("yes\n"));
16711 /* An 'unknown note type' message will already have been displayed. */
16715 printf (_("unknown value: %x\n"), val
);
16720 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16722 unsigned int version
;
16724 switch (pnote
->type
)
16726 case NT_NETBSD_IDENT
:
16727 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16728 if ((version
/ 10000) % 100)
16729 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16730 version
, version
/ 100000000, (version
/ 1000000) % 100,
16731 (version
/ 10000) % 100 > 26 ? "Z" : "",
16732 'A' + (version
/ 10000) % 26);
16734 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16735 version
, version
/ 100000000, (version
/ 1000000) % 100,
16736 (version
/ 100) % 100);
16739 case NT_NETBSD_MARCH
:
16740 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16745 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16751 static const char *
16752 get_freebsd_elfcore_note_type (unsigned e_type
)
16756 case NT_FREEBSD_THRMISC
:
16757 return _("NT_THRMISC (thrmisc structure)");
16758 case NT_FREEBSD_PROCSTAT_PROC
:
16759 return _("NT_PROCSTAT_PROC (proc data)");
16760 case NT_FREEBSD_PROCSTAT_FILES
:
16761 return _("NT_PROCSTAT_FILES (files data)");
16762 case NT_FREEBSD_PROCSTAT_VMMAP
:
16763 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16764 case NT_FREEBSD_PROCSTAT_GROUPS
:
16765 return _("NT_PROCSTAT_GROUPS (groups data)");
16766 case NT_FREEBSD_PROCSTAT_UMASK
:
16767 return _("NT_PROCSTAT_UMASK (umask data)");
16768 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16769 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16770 case NT_FREEBSD_PROCSTAT_OSREL
:
16771 return _("NT_PROCSTAT_OSREL (osreldate data)");
16772 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16773 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16774 case NT_FREEBSD_PROCSTAT_AUXV
:
16775 return _("NT_PROCSTAT_AUXV (auxv data)");
16777 return get_note_type (e_type
);
16780 static const char *
16781 get_netbsd_elfcore_note_type (unsigned e_type
)
16783 static char buff
[64];
16785 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16787 /* NetBSD core "procinfo" structure. */
16788 return _("NetBSD procinfo structure");
16791 /* As of Jan 2002 there are no other machine-independent notes
16792 defined for NetBSD core files. If the note type is less
16793 than the start of the machine-dependent note types, we don't
16796 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16798 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16802 switch (elf_header
.e_machine
)
16804 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16805 and PT_GETFPREGS == mach+2. */
16810 case EM_SPARC32PLUS
:
16814 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16815 return _("PT_GETREGS (reg structure)");
16816 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16817 return _("PT_GETFPREGS (fpreg structure)");
16823 /* On all other arch's, PT_GETREGS == mach+1 and
16824 PT_GETFPREGS == mach+3. */
16828 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16829 return _("PT_GETREGS (reg structure)");
16830 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16831 return _("PT_GETFPREGS (fpreg structure)");
16837 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16838 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16842 static const char *
16843 get_stapsdt_note_type (unsigned e_type
)
16845 static char buff
[64];
16850 return _("NT_STAPSDT (SystemTap probe descriptors)");
16856 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16861 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16863 int addr_size
= is_32bit_elf
? 4 : 8;
16864 char *data
= pnote
->descdata
;
16865 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16866 bfd_vma pc
, base_addr
, semaphore
;
16867 char *provider
, *probe
, *arg_fmt
;
16869 pc
= byte_get ((unsigned char *) data
, addr_size
);
16871 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16873 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16877 data
+= strlen (data
) + 1;
16879 data
+= strlen (data
) + 1;
16881 data
+= strlen (data
) + 1;
16883 printf (_(" Provider: %s\n"), provider
);
16884 printf (_(" Name: %s\n"), probe
);
16885 printf (_(" Location: "));
16886 print_vma (pc
, FULL_HEX
);
16887 printf (_(", Base: "));
16888 print_vma (base_addr
, FULL_HEX
);
16889 printf (_(", Semaphore: "));
16890 print_vma (semaphore
, FULL_HEX
);
16892 printf (_(" Arguments: %s\n"), arg_fmt
);
16894 return data
== data_end
;
16897 static const char *
16898 get_ia64_vms_note_type (unsigned e_type
)
16900 static char buff
[64];
16905 return _("NT_VMS_MHD (module header)");
16907 return _("NT_VMS_LNM (language name)");
16909 return _("NT_VMS_SRC (source files)");
16911 return "NT_VMS_TITLE";
16913 return _("NT_VMS_EIDC (consistency check)");
16914 case NT_VMS_FPMODE
:
16915 return _("NT_VMS_FPMODE (FP mode)");
16916 case NT_VMS_LINKTIME
:
16917 return "NT_VMS_LINKTIME";
16918 case NT_VMS_IMGNAM
:
16919 return _("NT_VMS_IMGNAM (image name)");
16921 return _("NT_VMS_IMGID (image id)");
16922 case NT_VMS_LINKID
:
16923 return _("NT_VMS_LINKID (link id)");
16924 case NT_VMS_IMGBID
:
16925 return _("NT_VMS_IMGBID (build id)");
16926 case NT_VMS_GSTNAM
:
16927 return _("NT_VMS_GSTNAM (sym table name)");
16928 case NT_VMS_ORIG_DYN
:
16929 return "NT_VMS_ORIG_DYN";
16930 case NT_VMS_PATCHTIME
:
16931 return "NT_VMS_PATCHTIME";
16933 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16939 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16941 switch (pnote
->type
)
16944 if (pnote
->descsz
> 36)
16946 size_t l
= strlen (pnote
->descdata
+ 34);
16947 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16948 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16949 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16950 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16953 printf (_(" Invalid size\n"));
16956 printf (_(" Language: %s\n"), pnote
->descdata
);
16959 case NT_VMS_FPMODE
:
16960 printf (_(" Floating Point mode: "));
16961 printf ("0x%016" BFD_VMA_FMT
"x\n",
16962 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16964 case NT_VMS_LINKTIME
:
16965 printf (_(" Link time: "));
16967 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16970 case NT_VMS_PATCHTIME
:
16971 printf (_(" Patch time: "));
16973 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16976 case NT_VMS_ORIG_DYN
:
16977 printf (_(" Major id: %u, minor id: %u\n"),
16978 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16979 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16980 printf (_(" Last modified : "));
16982 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16983 printf (_("\n Link flags : "));
16984 printf ("0x%016" BFD_VMA_FMT
"x\n",
16985 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16986 printf (_(" Header flags: 0x%08x\n"),
16987 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16988 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16991 case NT_VMS_IMGNAM
:
16992 printf (_(" Image name: %s\n"), pnote
->descdata
);
16994 case NT_VMS_GSTNAM
:
16995 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16998 printf (_(" Image id: %s\n"), pnote
->descdata
);
17000 case NT_VMS_LINKID
:
17001 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17009 /* Print the name of the symbol associated with a build attribute
17010 that is attached to address OFFSET. */
17013 print_symbol_for_build_attribute (FILE * file
,
17014 unsigned long offset
,
17015 bfd_boolean is_open_attr
)
17017 static FILE * saved_file
= NULL
;
17018 static char * strtab
;
17019 static unsigned long strtablen
;
17020 static Elf_Internal_Sym
* symtab
;
17021 static unsigned long nsyms
;
17022 Elf_Internal_Sym
* saved_sym
= NULL
;
17023 Elf_Internal_Sym
* sym
;
17025 if (section_headers
!= NULL
17026 && (saved_file
== NULL
|| file
!= saved_file
))
17028 Elf_Internal_Shdr
* symsec
;
17030 /* Load the symbol and string sections. */
17031 for (symsec
= section_headers
;
17032 symsec
< section_headers
+ elf_header
.e_shnum
;
17035 if (symsec
->sh_type
== SHT_SYMTAB
)
17037 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
17039 if (symsec
->sh_link
< elf_header
.e_shnum
)
17041 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
17043 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
17044 1, strtab_sec
->sh_size
,
17045 _("string table"));
17046 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17053 if (symtab
== NULL
|| strtab
== NULL
)
17059 /* Find a symbol whose value matches offset. */
17060 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17061 if (sym
->st_value
== offset
)
17063 if (sym
->st_name
>= strtablen
)
17064 /* Huh ? This should not happen. */
17067 if (strtab
[sym
->st_name
] == 0)
17072 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17073 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17074 FUNC symbols entirely. */
17075 switch (ELF_ST_TYPE (sym
->st_info
))
17079 /* We can stop searching now. */
17080 sym
= symtab
+ nsyms
;
17088 /* Ignore function symbols. */
17095 switch (ELF_ST_BIND (sym
->st_info
))
17098 if (saved_sym
== NULL
17099 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17104 if (saved_sym
== NULL
)
17114 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17122 printf (" (%s: %s)\n",
17123 is_open_attr
? _("file") : _("func"),
17124 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
17129 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17132 static unsigned long global_offset
= 0;
17133 unsigned long offset
;
17134 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
17135 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17137 if (pnote
->descsz
== 0)
17141 printf (_(" Applies from offset %#lx\n"), global_offset
);
17146 printf (_(" Applies to func at %#lx"), global_offset
);
17147 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
17151 if (pnote
->descsz
!= desc_size
)
17153 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17154 printf (_(" <invalid descsz>"));
17158 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
17162 printf (_(" Applies from offset %#lx"), offset
);
17163 global_offset
= offset
;
17167 printf (_(" Applies to func at %#lx"), offset
);
17170 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
17174 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17176 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17177 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17178 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17180 char name_attribute
;
17181 const char * expected_types
;
17182 const char * name
= pnote
->namedata
;
17186 if (name
== NULL
|| pnote
->namesz
< 2)
17188 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17189 print_symbol (-20, _(" <corrupt name>"));
17193 switch ((name_type
= * name
))
17195 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17196 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17197 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17198 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17199 printf ("%c", * name
);
17202 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17203 print_symbol (-20, _("<unknown name type>"));
17211 switch ((name_attribute
= * name
))
17213 case GNU_BUILD_ATTRIBUTE_VERSION
:
17214 text
= _("<version>");
17215 expected_types
= string_expected
;
17218 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17219 text
= _("<stack prot>");
17220 expected_types
= "!+*";
17223 case GNU_BUILD_ATTRIBUTE_RELRO
:
17224 text
= _("<relro>");
17225 expected_types
= bool_expected
;
17228 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17229 text
= _("<stack size>");
17230 expected_types
= number_expected
;
17233 case GNU_BUILD_ATTRIBUTE_TOOL
:
17234 text
= _("<tool>");
17235 expected_types
= string_expected
;
17238 case GNU_BUILD_ATTRIBUTE_ABI
:
17240 expected_types
= "$*";
17243 case GNU_BUILD_ATTRIBUTE_PIC
:
17245 expected_types
= number_expected
;
17248 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17249 text
= _("<short enum>");
17250 expected_types
= bool_expected
;
17254 if (ISPRINT (* name
))
17256 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17258 if (len
> left
&& ! do_wide
)
17260 printf ("%.*s:", len
, name
);
17266 static char tmpbuf
[128];
17267 error (_("unrecognised byte in name field: %d\n"), * name
);
17268 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17272 expected_types
= "*$!+";
17278 printf ("%s", text
);
17279 left
-= strlen (text
);
17282 if (strchr (expected_types
, name_type
) == NULL
)
17283 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17285 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17287 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17288 (unsigned long) pnote
->namesz
,
17289 (long) (name
- pnote
->namedata
));
17293 if (left
< 1 && ! do_wide
)
17298 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17300 unsigned int bytes
;
17301 unsigned long long val
= 0;
17302 unsigned int shift
= 0;
17303 char * decoded
= NULL
;
17305 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17307 /* The -1 is because the name field is always 0 terminated, and we
17308 want to be able to ensure that the shift in the while loop below
17309 will not overflow. */
17312 if (bytes
> sizeof (val
))
17314 fprintf (stderr
, "namesz %lx name %p namedata %p\n",
17315 pnote
->namesz
, name
, pnote
->namedata
);
17316 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17318 bytes
= sizeof (val
);
17320 /* We do not bother to warn if bytes == 0 as this can
17321 happen with some early versions of the gcc plugin. */
17325 unsigned long byte
= (* name
++) & 0xff;
17327 val
|= byte
<< shift
;
17331 switch (name_attribute
)
17333 case GNU_BUILD_ATTRIBUTE_PIC
:
17336 case 0: decoded
= "static"; break;
17337 case 1: decoded
= "pic"; break;
17338 case 2: decoded
= "PIC"; break;
17339 case 3: decoded
= "pie"; break;
17340 case 4: decoded
= "PIE"; break;
17344 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17347 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17348 case 0: decoded
= "off"; break;
17349 case 1: decoded
= "on"; break;
17350 case 2: decoded
= "all"; break;
17351 case 3: decoded
= "strong"; break;
17352 case 4: decoded
= "explicit"; break;
17360 if (decoded
!= NULL
)
17362 print_symbol (-left
, decoded
);
17373 left
-= printf ("0x%llx", val
);
17375 left
-= printf ("0x%-.*llx", left
, val
);
17379 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17380 left
-= print_symbol (- left
, name
);
17382 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17383 left
-= print_symbol (- left
, "true");
17385 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17386 left
-= print_symbol (- left
, "false");
17390 if (do_wide
&& left
> 0)
17391 printf ("%-*s", left
, " ");
17396 /* Note that by the ELF standard, the name field is already null byte
17397 terminated, and namesz includes the terminating null byte.
17398 I.E. the value of namesz for the name "FSF" is 4.
17400 If the value of namesz is zero, there is no name present. */
17403 process_note (Elf_Internal_Note
* pnote
,
17406 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17409 if (pnote
->namesz
== 0)
17410 /* If there is no note name, then use the default set of
17411 note type strings. */
17412 nt
= get_note_type (pnote
->type
);
17414 else if (const_strneq (pnote
->namedata
, "GNU"))
17415 /* GNU-specific object file notes. */
17416 nt
= get_gnu_elf_note_type (pnote
->type
);
17418 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17419 /* FreeBSD-specific core file notes. */
17420 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
17422 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17423 /* NetBSD-specific core file notes. */
17424 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17426 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17427 /* NetBSD-specific core file notes. */
17428 return process_netbsd_elf_note (pnote
);
17430 else if (strneq (pnote
->namedata
, "SPU/", 4))
17432 /* SPU-specific core file notes. */
17433 nt
= pnote
->namedata
+ 4;
17437 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17438 /* VMS/ia64-specific file notes. */
17439 nt
= get_ia64_vms_note_type (pnote
->type
);
17441 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17442 nt
= get_stapsdt_note_type (pnote
->type
);
17445 /* Don't recognize this note name; just use the default set of
17446 note type strings. */
17447 nt
= get_note_type (pnote
->type
);
17451 if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17452 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17453 print_gnu_build_attribute_name (pnote
);
17455 print_symbol (-20, name
);
17458 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17460 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17462 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17463 return print_ia64_vms_note (pnote
);
17464 else if (const_strneq (pnote
->namedata
, "GNU"))
17465 return print_gnu_note (pnote
);
17466 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17467 return print_stapsdt_note (pnote
);
17468 else if (const_strneq (pnote
->namedata
, "CORE"))
17469 return print_core_note (pnote
);
17470 else if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17471 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17472 return print_gnu_build_attribute_description (pnote
, file
);
17478 printf (_(" description data: "));
17479 for (i
= 0; i
< pnote
->descsz
; i
++)
17480 printf ("%02x ", pnote
->descdata
[i
]);
17490 process_notes_at (FILE * file
,
17491 Elf_Internal_Shdr
* section
,
17495 Elf_External_Note
* pnotes
;
17496 Elf_External_Note
* external
;
17498 bfd_boolean res
= TRUE
;
17505 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17508 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17513 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17515 if (pnotes
== NULL
)
17521 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17523 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17524 (unsigned long) offset
, (unsigned long) length
);
17526 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17528 end
= (char *) pnotes
+ length
;
17529 while ((char *) external
< end
)
17531 Elf_Internal_Note inote
;
17534 char * temp
= NULL
;
17535 size_t data_remaining
= end
- (char *) external
;
17537 if (!is_ia64_vms ())
17539 /* PR binutils/15191
17540 Make sure that there is enough data to read. */
17541 min_notesz
= offsetof (Elf_External_Note
, name
);
17542 if (data_remaining
< min_notesz
)
17544 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17545 (int) data_remaining
);
17548 inote
.type
= BYTE_GET (external
->type
);
17549 inote
.namesz
= BYTE_GET (external
->namesz
);
17550 inote
.namedata
= external
->name
;
17551 inote
.descsz
= BYTE_GET (external
->descsz
);
17552 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17553 /* PR 17531: file: 3443835e. */
17554 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17556 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17557 inote
.namesz
, (long)(end
- inote
.namedata
));
17558 inote
.descdata
= inote
.namedata
;
17562 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17563 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17567 Elf64_External_VMS_Note
*vms_external
;
17569 /* PR binutils/15191
17570 Make sure that there is enough data to read. */
17571 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17572 if (data_remaining
< min_notesz
)
17574 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17575 (int) data_remaining
);
17579 vms_external
= (Elf64_External_VMS_Note
*) external
;
17580 inote
.type
= BYTE_GET (vms_external
->type
);
17581 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17582 inote
.namedata
= vms_external
->name
;
17583 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17584 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17585 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17586 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17589 if (inote
.descdata
< (char *) external
+ min_notesz
17590 || next
< (char *) external
+ min_notesz
17591 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17592 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17593 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17594 || data_remaining
< (size_t)(next
- (char *) external
))
17596 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17597 (unsigned long) ((char *) external
- (char *) pnotes
));
17598 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17599 inote
.type
, inote
.namesz
, inote
.descsz
);
17603 external
= (Elf_External_Note
*) next
;
17605 /* Verify that name is null terminated. It appears that at least
17606 one version of Linux (RedHat 6.0) generates corefiles that don't
17607 comply with the ELF spec by failing to include the null byte in
17609 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17611 temp
= (char *) malloc (inote
.namesz
+ 1);
17614 error (_("Out of memory allocating space for inote name\n"));
17619 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17620 temp
[inote
.namesz
] = 0;
17622 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17623 inote
.namedata
= temp
;
17626 if (! process_note (& inote
, file
))
17642 process_corefile_note_segments (FILE * file
)
17644 Elf_Internal_Phdr
* segment
;
17646 bfd_boolean res
= TRUE
;
17648 if (! get_program_headers (file
))
17651 for (i
= 0, segment
= program_headers
;
17652 i
< elf_header
.e_phnum
;
17655 if (segment
->p_type
== PT_NOTE
)
17656 if (! process_notes_at (file
, NULL
,
17657 (bfd_vma
) segment
->p_offset
,
17658 (bfd_vma
) segment
->p_filesz
))
17666 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17668 Elf_External_Note
* pnotes
;
17669 Elf_External_Note
* external
;
17671 bfd_boolean res
= TRUE
;
17676 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17678 if (pnotes
== NULL
)
17682 end
= (char*) pnotes
+ length
;
17684 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17685 (unsigned long) offset
, (unsigned long) length
);
17687 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17689 Elf_External_Note
* next
;
17690 Elf_Internal_Note inote
;
17692 inote
.type
= BYTE_GET (external
->type
);
17693 inote
.namesz
= BYTE_GET (external
->namesz
);
17694 inote
.namedata
= external
->name
;
17695 inote
.descsz
= BYTE_GET (external
->descsz
);
17696 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17697 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17699 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17701 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17702 inote
.descdata
= inote
.namedata
;
17706 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17708 if ( ((char *) next
> end
)
17709 || ((char *) next
< (char *) pnotes
))
17711 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17712 (unsigned long) ((char *) external
- (char *) pnotes
));
17713 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17714 inote
.type
, inote
.namesz
, inote
.descsz
);
17720 /* Prevent out-of-bounds indexing. */
17721 if ( inote
.namedata
+ inote
.namesz
> end
17722 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17724 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17725 (unsigned long) ((char *) external
- (char *) pnotes
));
17726 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17727 inote
.type
, inote
.namesz
, inote
.descsz
);
17731 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17733 if (! print_v850_note (& inote
))
17736 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17737 inote
.namesz
, inote
.descsz
);
17747 process_note_sections (FILE * file
)
17749 Elf_Internal_Shdr
* section
;
17751 unsigned int n
= 0;
17752 bfd_boolean res
= TRUE
;
17754 for (i
= 0, section
= section_headers
;
17755 i
< elf_header
.e_shnum
&& section
!= NULL
;
17758 if (section
->sh_type
== SHT_NOTE
)
17760 if (! process_notes_at (file
, section
,
17761 (bfd_vma
) section
->sh_offset
,
17762 (bfd_vma
) section
->sh_size
))
17767 if (( elf_header
.e_machine
== EM_V800
17768 || elf_header
.e_machine
== EM_V850
17769 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17770 && section
->sh_type
== SHT_RENESAS_INFO
)
17772 if (! process_v850_notes (file
,
17773 (bfd_vma
) section
->sh_offset
,
17774 (bfd_vma
) section
->sh_size
))
17781 /* Try processing NOTE segments instead. */
17782 return process_corefile_note_segments (file
);
17788 process_notes (FILE * file
)
17790 /* If we have not been asked to display the notes then do nothing. */
17794 if (elf_header
.e_type
!= ET_CORE
)
17795 return process_note_sections (file
);
17797 /* No program headers means no NOTE segment. */
17798 if (elf_header
.e_phnum
> 0)
17799 return process_corefile_note_segments (file
);
17801 printf (_("No note segments present in the core file.\n"));
17805 static unsigned char *
17806 display_public_gnu_attributes (unsigned char * start
,
17807 const unsigned char * const end
)
17809 printf (_(" Unknown GNU attribute: %s\n"), start
);
17811 start
+= strnlen ((char *) start
, end
- start
);
17812 display_raw_attribute (start
, end
);
17814 return (unsigned char *) end
;
17817 static unsigned char *
17818 display_generic_attribute (unsigned char * start
,
17820 const unsigned char * const end
)
17823 return (unsigned char *) end
;
17825 return display_tag_value (tag
, start
, end
);
17829 process_arch_specific (FILE * file
)
17834 switch (elf_header
.e_machine
)
17837 case EM_ARC_COMPACT
:
17838 case EM_ARC_COMPACT2
:
17839 return process_attributes (file
, "ARC", SHT_ARC_ATTRIBUTES
,
17840 display_arc_attribute
,
17841 display_generic_attribute
);
17843 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17844 display_arm_attribute
,
17845 display_generic_attribute
);
17848 case EM_MIPS_RS3_LE
:
17849 return process_mips_specific (file
);
17852 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17853 display_msp430x_attribute
,
17854 display_generic_attribute
);
17857 return process_nds32_specific (file
);
17861 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17862 display_power_gnu_attribute
);
17866 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17867 display_s390_gnu_attribute
);
17870 case EM_SPARC32PLUS
:
17872 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17873 display_sparc_gnu_attribute
);
17876 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17877 display_tic6x_attribute
,
17878 display_generic_attribute
);
17881 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17882 display_public_gnu_attributes
,
17883 display_generic_attribute
);
17888 get_file_header (FILE * file
)
17890 /* Read in the identity array. */
17891 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
17894 /* Determine how to read the rest of the header. */
17895 switch (elf_header
.e_ident
[EI_DATA
])
17900 byte_get
= byte_get_little_endian
;
17901 byte_put
= byte_put_little_endian
;
17904 byte_get
= byte_get_big_endian
;
17905 byte_put
= byte_put_big_endian
;
17909 /* For now we only support 32 bit and 64 bit ELF files. */
17910 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
17912 /* Read in the rest of the header. */
17915 Elf32_External_Ehdr ehdr32
;
17917 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
17920 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
17921 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
17922 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
17923 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
17924 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
17925 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
17926 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
17927 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
17928 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
17929 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
17930 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
17931 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
17932 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
17936 Elf64_External_Ehdr ehdr64
;
17938 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17939 we will not be able to cope with the 64bit data found in
17940 64 ELF files. Detect this now and abort before we start
17941 overwriting things. */
17942 if (sizeof (bfd_vma
) < 8)
17944 error (_("This instance of readelf has been built without support for a\n\
17945 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17949 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
17952 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
17953 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
17954 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
17955 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
17956 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
17957 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
17958 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
17959 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
17960 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
17961 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
17962 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
17963 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
17964 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
17967 if (elf_header
.e_shoff
)
17969 /* There may be some extensions in the first section header. Don't
17970 bomb if we can't read it. */
17972 get_32bit_section_headers (file
, TRUE
);
17974 get_64bit_section_headers (file
, TRUE
);
17980 /* Process one ELF object file according to the command line options.
17981 This file may actually be stored in an archive. The file is
17982 positioned at the start of the ELF object. Returns TRUE if no
17983 problems were encountered, FALSE otherwise. */
17986 process_object (char * file_name
, FILE * file
)
17989 bfd_boolean res
= TRUE
;
17991 if (! get_file_header (file
))
17993 error (_("%s: Failed to read file header\n"), file_name
);
17997 /* Initialise per file variables. */
17998 for (i
= ARRAY_SIZE (version_info
); i
--;)
17999 version_info
[i
] = 0;
18001 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18002 dynamic_info
[i
] = 0;
18003 dynamic_info_DT_GNU_HASH
= 0;
18005 /* Process the file. */
18007 printf (_("\nFile: %s\n"), file_name
);
18009 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18010 Note we do this even if cmdline_dump_sects is empty because we
18011 must make sure that the dump_sets array is zeroed out before each
18012 object file is processed. */
18013 if (num_dump_sects
> num_cmdline_dump_sects
)
18014 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
18016 if (num_cmdline_dump_sects
> 0)
18018 if (num_dump_sects
== 0)
18019 /* A sneaky way of allocating the dump_sects array. */
18020 request_dump_bynumber (num_cmdline_dump_sects
, 0);
18022 assert (num_dump_sects
>= num_cmdline_dump_sects
);
18023 memcpy (dump_sects
, cmdline_dump_sects
,
18024 num_cmdline_dump_sects
* sizeof (* dump_sects
));
18027 if (! process_file_header ())
18030 if (! process_section_headers (file
))
18032 /* Without loaded section headers we cannot process lots of things. */
18033 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18035 if (! do_using_dynamic
)
18036 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18039 if (! process_section_groups (file
))
18040 /* Without loaded section groups we cannot process unwind. */
18043 if (process_program_headers (file
))
18044 process_dynamic_section (file
);
18048 if (! process_relocs (file
))
18051 if (! process_unwind (file
))
18054 if (! process_symbol_table (file
))
18057 if (! process_syminfo (file
))
18060 if (! process_version_sections (file
))
18063 if (! process_section_contents (file
))
18066 if (! process_notes (file
))
18069 if (! process_gnu_liblist (file
))
18072 if (! process_arch_specific (file
))
18075 if (program_headers
)
18077 free (program_headers
);
18078 program_headers
= NULL
;
18081 if (section_headers
)
18083 free (section_headers
);
18084 section_headers
= NULL
;
18089 free (string_table
);
18090 string_table
= NULL
;
18091 string_table_length
= 0;
18094 if (dynamic_strings
)
18096 free (dynamic_strings
);
18097 dynamic_strings
= NULL
;
18098 dynamic_strings_length
= 0;
18101 if (dynamic_symbols
)
18103 free (dynamic_symbols
);
18104 dynamic_symbols
= NULL
;
18105 num_dynamic_syms
= 0;
18108 if (dynamic_syminfo
)
18110 free (dynamic_syminfo
);
18111 dynamic_syminfo
= NULL
;
18114 if (dynamic_section
)
18116 free (dynamic_section
);
18117 dynamic_section
= NULL
;
18120 if (section_headers_groups
)
18122 free (section_headers_groups
);
18123 section_headers_groups
= NULL
;
18126 if (section_groups
)
18128 struct group_list
* g
;
18129 struct group_list
* next
;
18131 for (i
= 0; i
< group_count
; i
++)
18133 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18140 free (section_groups
);
18141 section_groups
= NULL
;
18144 free_debug_memory ();
18149 /* Process an ELF archive.
18150 On entry the file is positioned just after the ARMAG string.
18151 Returns TRUE upon success, FALSE otherwise. */
18154 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
18156 struct archive_info arch
;
18157 struct archive_info nested_arch
;
18159 bfd_boolean ret
= TRUE
;
18163 /* The ARCH structure is used to hold information about this archive. */
18164 arch
.file_name
= NULL
;
18166 arch
.index_array
= NULL
;
18167 arch
.sym_table
= NULL
;
18168 arch
.longnames
= NULL
;
18170 /* The NESTED_ARCH structure is used as a single-item cache of information
18171 about a nested archive (when members of a thin archive reside within
18172 another regular archive file). */
18173 nested_arch
.file_name
= NULL
;
18174 nested_arch
.file
= NULL
;
18175 nested_arch
.index_array
= NULL
;
18176 nested_arch
.sym_table
= NULL
;
18177 nested_arch
.longnames
= NULL
;
18179 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
18185 if (do_archive_index
)
18187 if (arch
.sym_table
== NULL
)
18188 error (_("%s: unable to dump the index as none was found\n"), file_name
);
18191 unsigned long i
, l
;
18192 unsigned long current_pos
;
18194 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18195 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18196 current_pos
= ftell (file
);
18198 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18200 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18202 char * member_name
;
18204 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18206 if (member_name
!= NULL
)
18208 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18210 if (qualified_name
!= NULL
)
18212 printf (_("Contents of binary %s at offset "), qualified_name
);
18213 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18215 free (qualified_name
);
18220 if (l
>= arch
.sym_size
)
18222 error (_("%s: end of the symbol table reached before the end of the index\n"),
18227 /* PR 17531: file: 0b6630b2. */
18228 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18229 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18232 if (arch
.uses_64bit_indicies
)
18237 if (l
< arch
.sym_size
)
18239 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18240 file_name
, arch
.sym_size
- l
);
18244 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
18246 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
18252 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18253 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18254 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18255 && !do_section_groups
&& !do_dyn_syms
)
18257 ret
= TRUE
; /* Archive index only. */
18266 char * qualified_name
;
18268 /* Read the next archive header. */
18269 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18271 error (_("%s: failed to seek to next archive header\n"), file_name
);
18274 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
18275 if (got
!= sizeof arch
.arhdr
)
18279 error (_("%s: failed to read archive header\n"), file_name
);
18283 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18285 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18290 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18292 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18293 if (archive_file_size
& 01)
18294 ++archive_file_size
;
18296 name
= get_archive_member_name (&arch
, &nested_arch
);
18299 error (_("%s: bad archive file name\n"), file_name
);
18303 namelen
= strlen (name
);
18305 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18306 if (qualified_name
== NULL
)
18308 error (_("%s: bad archive file name\n"), file_name
);
18313 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18315 /* This is a proxy for an external member of a thin archive. */
18316 FILE * member_file
;
18317 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
18319 if (member_file_name
== NULL
)
18325 member_file
= fopen (member_file_name
, "rb");
18326 if (member_file
== NULL
)
18328 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18329 free (member_file_name
);
18334 archive_file_offset
= arch
.nested_member_origin
;
18336 if (! process_object (qualified_name
, member_file
))
18339 fclose (member_file
);
18340 free (member_file_name
);
18342 else if (is_thin_archive
)
18344 /* PR 15140: Allow for corrupt thin archives. */
18345 if (nested_arch
.file
== NULL
)
18347 error (_("%s: contains corrupt thin archive: %s\n"),
18353 /* This is a proxy for a member of a nested archive. */
18354 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18356 /* The nested archive file will have been opened and setup by
18357 get_archive_member_name. */
18358 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18360 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
18365 if (! process_object (qualified_name
, nested_arch
.file
))
18370 archive_file_offset
= arch
.next_arhdr_offset
;
18371 arch
.next_arhdr_offset
+= archive_file_size
;
18373 if (! process_object (qualified_name
, file
))
18377 if (dump_sects
!= NULL
)
18381 num_dump_sects
= 0;
18384 free (qualified_name
);
18388 if (nested_arch
.file
!= NULL
)
18389 fclose (nested_arch
.file
);
18390 release_archive (&nested_arch
);
18391 release_archive (&arch
);
18397 process_file (char * file_name
)
18400 struct stat statbuf
;
18401 char armag
[SARMAG
];
18402 bfd_boolean ret
= TRUE
;
18404 if (stat (file_name
, &statbuf
) < 0)
18406 if (errno
== ENOENT
)
18407 error (_("'%s': No such file\n"), file_name
);
18409 error (_("Could not locate '%s'. System error message: %s\n"),
18410 file_name
, strerror (errno
));
18414 if (! S_ISREG (statbuf
.st_mode
))
18416 error (_("'%s' is not an ordinary file\n"), file_name
);
18420 file
= fopen (file_name
, "rb");
18423 error (_("Input file '%s' is not readable.\n"), file_name
);
18427 if (fread (armag
, SARMAG
, 1, file
) != 1)
18429 error (_("%s: Failed to read file's magic number\n"), file_name
);
18434 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18436 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18438 if (! process_archive (file_name
, file
, FALSE
))
18441 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18443 if ( ! process_archive (file_name
, file
, TRUE
))
18448 if (do_archive_index
)
18449 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18453 archive_file_size
= archive_file_offset
= 0;
18455 if (! process_object (file_name
, file
))
18460 current_file_size
= 0;
18465 #ifdef SUPPORT_DISASSEMBLY
18466 /* Needed by the i386 disassembler. For extra credit, someone could
18467 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18471 print_address (unsigned int addr
, FILE * outfile
)
18473 fprintf (outfile
,"0x%8.8x", addr
);
18476 /* Needed by the i386 disassembler. */
18478 db_task_printsym (unsigned int addr
)
18480 print_address (addr
, stderr
);
18485 main (int argc
, char ** argv
)
18489 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18490 setlocale (LC_MESSAGES
, "");
18492 #if defined (HAVE_SETLOCALE)
18493 setlocale (LC_CTYPE
, "");
18495 bindtextdomain (PACKAGE
, LOCALEDIR
);
18496 textdomain (PACKAGE
);
18498 expandargv (&argc
, &argv
);
18500 parse_args (argc
, argv
);
18502 if (num_dump_sects
> 0)
18504 /* Make a copy of the dump_sects array. */
18505 cmdline_dump_sects
= (dump_type
*)
18506 malloc (num_dump_sects
* sizeof (* dump_sects
));
18507 if (cmdline_dump_sects
== NULL
)
18508 error (_("Out of memory allocating dump request table.\n"));
18511 memcpy (cmdline_dump_sects
, dump_sects
,
18512 num_dump_sects
* sizeof (* dump_sects
));
18513 num_cmdline_dump_sects
= num_dump_sects
;
18517 if (optind
< (argc
- 1))
18519 else if (optind
>= argc
)
18521 warn (_("Nothing to do.\n"));
18526 while (optind
< argc
)
18527 if (! process_file (argv
[optind
++]))
18530 if (dump_sects
!= NULL
)
18532 if (cmdline_dump_sects
!= NULL
)
18533 free (cmdline_dump_sects
);
18535 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;