1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/riscv.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/wasm32.h"
155 #include "elf/x86-64.h"
156 #include "elf/xc16x.h"
157 #include "elf/xgate.h"
158 #include "elf/xstormy16.h"
159 #include "elf/xtensa.h"
162 #include "libiberty.h"
163 #include "safe-ctype.h"
164 #include "filenames.h"
167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
170 typedef struct elf_section_list
172 Elf_Internal_Shdr
* hdr
;
173 struct elf_section_list
* next
;
176 char * program_name
= "readelf";
177 static unsigned long archive_file_offset
;
178 static unsigned long archive_file_size
;
179 static bfd_size_type current_file_size
;
180 static unsigned long dynamic_addr
;
181 static bfd_size_type dynamic_size
;
182 static size_t dynamic_nent
;
183 static char * dynamic_strings
;
184 static unsigned long dynamic_strings_length
;
185 static char * string_table
;
186 static unsigned long string_table_length
;
187 static unsigned long num_dynamic_syms
;
188 static Elf_Internal_Sym
* dynamic_symbols
;
189 static Elf_Internal_Syminfo
* dynamic_syminfo
;
190 static unsigned long dynamic_syminfo_offset
;
191 static unsigned int dynamic_syminfo_nent
;
192 static char program_interpreter
[PATH_MAX
];
193 static bfd_vma dynamic_info
[DT_ENCODING
];
194 static bfd_vma dynamic_info_DT_GNU_HASH
;
195 static bfd_vma version_info
[16];
196 static Elf_Internal_Ehdr elf_header
;
197 static Elf_Internal_Shdr
* section_headers
;
198 static Elf_Internal_Phdr
* program_headers
;
199 static Elf_Internal_Dyn
* dynamic_section
;
200 static elf_section_list
* symtab_shndx_list
;
201 static bfd_boolean show_name
= FALSE
;
202 static bfd_boolean do_dynamic
= FALSE
;
203 static bfd_boolean do_syms
= FALSE
;
204 static bfd_boolean do_dyn_syms
= FALSE
;
205 static bfd_boolean do_reloc
= FALSE
;
206 static bfd_boolean do_sections
= FALSE
;
207 static bfd_boolean do_section_groups
= FALSE
;
208 static bfd_boolean do_section_details
= FALSE
;
209 static bfd_boolean do_segments
= FALSE
;
210 static bfd_boolean do_unwind
= FALSE
;
211 static bfd_boolean do_using_dynamic
= FALSE
;
212 static bfd_boolean do_header
= FALSE
;
213 static bfd_boolean do_dump
= FALSE
;
214 static bfd_boolean do_version
= FALSE
;
215 static bfd_boolean do_histogram
= FALSE
;
216 static bfd_boolean do_debugging
= FALSE
;
217 static bfd_boolean do_arch
= FALSE
;
218 static bfd_boolean do_notes
= FALSE
;
219 static bfd_boolean do_archive_index
= FALSE
;
220 static bfd_boolean is_32bit_elf
= FALSE
;
221 static bfd_boolean decompress_dumps
= FALSE
;
225 struct group_list
* next
;
226 unsigned int section_index
;
231 struct group_list
* root
;
232 unsigned int group_index
;
235 static size_t group_count
;
236 static struct group
* section_groups
;
237 static struct group
** section_headers_groups
;
240 /* Flag bits indicating particular types of dump. */
241 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
242 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
243 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
244 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
245 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
247 typedef unsigned char dump_type
;
249 /* A linked list of the section names for which dumps were requested. */
250 struct dump_list_entry
254 struct dump_list_entry
* next
;
256 static struct dump_list_entry
* dump_sects_byname
;
258 /* A dynamic array of flags indicating for which sections a dump
259 has been requested via command line switches. */
260 static dump_type
* cmdline_dump_sects
= NULL
;
261 static unsigned int num_cmdline_dump_sects
= 0;
263 /* A dynamic array of flags indicating for which sections a dump of
264 some kind has been requested. It is reset on a per-object file
265 basis and then initialised from the cmdline_dump_sects array,
266 the results of interpreting the -w switch, and the
267 dump_sects_byname list. */
268 static dump_type
* dump_sects
= NULL
;
269 static unsigned int num_dump_sects
= 0;
272 /* How to print a vma value. */
273 typedef enum print_mode
285 /* Versioned symbol info. */
286 enum versioned_symbol_info
293 static const char * get_symbol_version_string
294 (FILE *, bfd_boolean
, const char *, unsigned long, unsigned,
295 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
299 #define SECTION_NAME(X) \
300 ((X) == NULL ? _("<none>") \
301 : string_table == NULL ? _("<no-name>") \
302 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
303 : string_table + (X)->sh_name))
305 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
307 #define GET_ELF_SYMBOLS(file, section, sym_count) \
308 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
309 : get_64bit_elf_symbols (file, section, sym_count))
311 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
313 already been called and verified that the string exists. */
314 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
316 #define REMOVE_ARCH_BITS(ADDR) \
319 if (elf_header.e_machine == EM_ARM) \
324 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
325 the offset of the current archive member, if we are examining an archive.
326 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
327 using malloc and fill that. In either case return the pointer to the start of
328 the retrieved data or NULL if something went wrong. If something does go wrong
329 and REASON is not NULL then emit an error message using REASON as part of the
333 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
334 bfd_size_type nmemb
, const char * reason
)
337 bfd_size_type amt
= size
* nmemb
;
339 if (size
== 0 || nmemb
== 0)
342 /* If the size_t type is smaller than the bfd_size_type, eg because
343 you are building a 32-bit tool on a 64-bit host, then make sure
344 that when the sizes are cast to (size_t) no information is lost. */
345 if (sizeof (size_t) < sizeof (bfd_size_type
)
346 && ( (bfd_size_type
) ((size_t) size
) != size
347 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
350 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT
"x"
351 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
352 nmemb
, size
, reason
);
356 /* Check for size overflow. */
360 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT
"x"
361 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
362 nmemb
, size
, reason
);
366 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
367 attempting to allocate memory when the read is bound to fail. */
368 if (amt
> current_file_size
369 || offset
+ archive_file_offset
+ amt
> current_file_size
)
372 error (_("Reading 0x%" BFD_VMA_FMT
"x"
373 " bytes extends past end of file for %s\n"),
378 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
381 error (_("Unable to seek to 0x%lx for %s\n"),
382 archive_file_offset
+ offset
, reason
);
389 /* Check for overflow. */
390 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
391 /* + 1 so that we can '\0' terminate invalid string table sections. */
392 mvar
= malloc ((size_t) amt
+ 1);
397 error (_("Out of memory allocating 0x%" BFD_VMA_FMT
"x"
403 ((char *) mvar
)[amt
] = '\0';
406 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
409 error (_("Unable to read in 0x%" BFD_VMA_FMT
"x bytes of %s\n"),
419 /* Print a VMA value in the MODE specified.
420 Returns the number of characters displayed. */
423 print_vma (bfd_vma vma
, print_mode mode
)
435 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
442 return printf ("%5" BFD_VMA_FMT
"d", vma
);
448 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
451 return printf ("%" BFD_VMA_FMT
"d", vma
);
454 return printf ("%" BFD_VMA_FMT
"u", vma
);
457 /* FIXME: Report unrecognised mode ? */
462 /* Display a symbol on stdout. Handles the display of control characters and
463 multibye characters (assuming the host environment supports them).
465 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
467 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
468 padding as necessary.
470 Returns the number of emitted characters. */
473 print_symbol (signed int width
, const char *symbol
)
475 bfd_boolean extra_padding
= FALSE
;
476 signed int num_printed
= 0;
477 #ifdef HAVE_MBSTATE_T
480 unsigned int width_remaining
;
484 /* Keep the width positive. This also helps. */
486 extra_padding
= TRUE
;
491 /* Set the remaining width to a very large value.
492 This simplifies the code below. */
493 width_remaining
= INT_MAX
;
495 width_remaining
= width
;
497 #ifdef HAVE_MBSTATE_T
498 /* Initialise the multibyte conversion state. */
499 memset (& state
, 0, sizeof (state
));
502 while (width_remaining
)
505 const char c
= *symbol
++;
510 /* Do not print control characters directly as they can affect terminal
511 settings. Such characters usually appear in the names generated
512 by the assembler for local labels. */
515 if (width_remaining
< 2)
518 printf ("^%c", c
+ 0x40);
519 width_remaining
-= 2;
522 else if (ISPRINT (c
))
530 #ifdef HAVE_MBSTATE_T
533 /* Let printf do the hard work of displaying multibyte characters. */
534 printf ("%.1s", symbol
- 1);
538 #ifdef HAVE_MBSTATE_T
539 /* Try to find out how many bytes made up the character that was
540 just printed. Advance the symbol pointer past the bytes that
542 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
546 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
551 if (extra_padding
&& num_printed
< width
)
553 /* Fill in the remaining spaces. */
554 printf ("%-*s", width
- num_printed
, " ");
561 /* Returns a pointer to a static buffer containing a printable version of
562 the given section's name. Like print_symbol, except that it does not try
563 to print multibyte characters, it just interprets them as hex values. */
566 printable_section_name (const Elf_Internal_Shdr
* sec
)
568 #define MAX_PRINT_SEC_NAME_LEN 128
569 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
570 const char * name
= SECTION_NAME (sec
);
571 char * buf
= sec_name_buf
;
573 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
575 while ((c
= * name
++) != 0)
586 else if (ISPRINT (c
))
593 static char hex
[17] = "0123456789ABCDEF";
598 * buf
++ = hex
[(c
& 0xf0) >> 4];
599 * buf
++ = hex
[c
& 0x0f];
613 printable_section_name_from_index (unsigned long ndx
)
615 if (ndx
>= elf_header
.e_shnum
)
616 return _("<corrupt>");
618 return printable_section_name (section_headers
+ ndx
);
621 /* Return a pointer to section NAME, or NULL if no such section exists. */
623 static Elf_Internal_Shdr
*
624 find_section (const char * name
)
628 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
629 if (streq (SECTION_NAME (section_headers
+ i
), name
))
630 return section_headers
+ i
;
635 /* Return a pointer to a section containing ADDR, or NULL if no such
638 static Elf_Internal_Shdr
*
639 find_section_by_address (bfd_vma addr
)
643 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
645 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
646 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
653 static Elf_Internal_Shdr
*
654 find_section_by_type (unsigned int type
)
658 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
660 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
661 if (sec
->sh_type
== type
)
668 /* Return a pointer to section NAME, or NULL if no such section exists,
669 restricted to the list of sections given in SET. */
671 static Elf_Internal_Shdr
*
672 find_section_in_set (const char * name
, unsigned int * set
)
678 while ((i
= *set
++) > 0)
680 /* See PR 21156 for a reproducer. */
681 if (i
>= elf_header
.e_shnum
)
682 continue; /* FIXME: Should we issue an error message ? */
684 if (streq (SECTION_NAME (section_headers
+ i
), name
))
685 return section_headers
+ i
;
689 return find_section (name
);
692 /* Read an unsigned LEB128 encoded value from DATA.
693 Set *LENGTH_RETURN to the number of bytes read. */
695 static inline unsigned long
696 read_uleb128 (unsigned char * data
,
697 unsigned int * length_return
,
698 const unsigned char * const end
)
700 return read_leb128 (data
, length_return
, FALSE
, end
);
703 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
704 This OS has so many departures from the ELF standard that we test it at
707 static inline bfd_boolean
710 return elf_header
.e_machine
== EM_IA_64
711 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
714 /* Guess the relocation size commonly used by the specific machines. */
717 guess_is_rela (unsigned int e_machine
)
721 /* Targets that use REL relocations. */
736 /* Targets that use RELA relocations. */
740 case EM_ADAPTEVA_EPIPHANY
:
742 case EM_ALTERA_NIOS2
:
745 case EM_ARC_COMPACT2
:
765 case EM_LATTICEMICO32
:
774 case EM_CYGNUS_MN10200
:
776 case EM_CYGNUS_MN10300
:
812 case EM_MICROBLAZE_OLD
:
834 warn (_("Don't know about relocations on this machine architecture\n"));
839 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
840 Returns TRUE upon success, FALSE otherwise. If successful then a
841 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
842 and the number of relocs loaded is placed in *NRELASP. It is the caller's
843 responsibility to free the allocated buffer. */
846 slurp_rela_relocs (FILE * file
,
847 unsigned long rel_offset
,
848 unsigned long rel_size
,
849 Elf_Internal_Rela
** relasp
,
850 unsigned long * nrelasp
)
852 Elf_Internal_Rela
* relas
;
858 Elf32_External_Rela
* erelas
;
860 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
861 rel_size
, _("32-bit relocation data"));
865 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
867 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
868 sizeof (Elf_Internal_Rela
));
873 error (_("out of memory parsing relocs\n"));
877 for (i
= 0; i
< nrelas
; i
++)
879 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
880 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
881 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
888 Elf64_External_Rela
* erelas
;
890 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
891 rel_size
, _("64-bit relocation data"));
895 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
897 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
898 sizeof (Elf_Internal_Rela
));
903 error (_("out of memory parsing relocs\n"));
907 for (i
= 0; i
< nrelas
; i
++)
909 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
910 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
911 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
913 /* The #ifdef BFD64 below is to prevent a compile time
914 warning. We know that if we do not have a 64 bit data
915 type that we will never execute this code anyway. */
917 if (elf_header
.e_machine
== EM_MIPS
918 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
920 /* In little-endian objects, r_info isn't really a
921 64-bit little-endian value: it has a 32-bit
922 little-endian symbol index followed by four
923 individual byte fields. Reorder INFO
925 bfd_vma inf
= relas
[i
].r_info
;
926 inf
= (((inf
& 0xffffffff) << 32)
927 | ((inf
>> 56) & 0xff)
928 | ((inf
>> 40) & 0xff00)
929 | ((inf
>> 24) & 0xff0000)
930 | ((inf
>> 8) & 0xff000000));
931 relas
[i
].r_info
= inf
;
944 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
945 Returns TRUE upon success, FALSE otherwise. If successful then a
946 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
947 and the number of relocs loaded is placed in *NRELSP. It is the caller's
948 responsibility to free the allocated buffer. */
951 slurp_rel_relocs (FILE * file
,
952 unsigned long rel_offset
,
953 unsigned long rel_size
,
954 Elf_Internal_Rela
** relsp
,
955 unsigned long * nrelsp
)
957 Elf_Internal_Rela
* rels
;
963 Elf32_External_Rel
* erels
;
965 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
966 rel_size
, _("32-bit relocation data"));
970 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
972 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
977 error (_("out of memory parsing relocs\n"));
981 for (i
= 0; i
< nrels
; i
++)
983 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
984 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
985 rels
[i
].r_addend
= 0;
992 Elf64_External_Rel
* erels
;
994 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
995 rel_size
, _("64-bit relocation data"));
999 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1001 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1006 error (_("out of memory parsing relocs\n"));
1010 for (i
= 0; i
< nrels
; i
++)
1012 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1013 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1014 rels
[i
].r_addend
= 0;
1016 /* The #ifdef BFD64 below is to prevent a compile time
1017 warning. We know that if we do not have a 64 bit data
1018 type that we will never execute this code anyway. */
1020 if (elf_header
.e_machine
== EM_MIPS
1021 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1023 /* In little-endian objects, r_info isn't really a
1024 64-bit little-endian value: it has a 32-bit
1025 little-endian symbol index followed by four
1026 individual byte fields. Reorder INFO
1028 bfd_vma inf
= rels
[i
].r_info
;
1029 inf
= (((inf
& 0xffffffff) << 32)
1030 | ((inf
>> 56) & 0xff)
1031 | ((inf
>> 40) & 0xff00)
1032 | ((inf
>> 24) & 0xff0000)
1033 | ((inf
>> 8) & 0xff000000));
1034 rels
[i
].r_info
= inf
;
1047 /* Returns the reloc type extracted from the reloc info field. */
1050 get_reloc_type (bfd_vma reloc_info
)
1053 return ELF32_R_TYPE (reloc_info
);
1055 switch (elf_header
.e_machine
)
1058 /* Note: We assume that reloc_info has already been adjusted for us. */
1059 return ELF64_MIPS_R_TYPE (reloc_info
);
1062 return ELF64_R_TYPE_ID (reloc_info
);
1065 return ELF64_R_TYPE (reloc_info
);
1069 /* Return the symbol index extracted from the reloc info field. */
1072 get_reloc_symindex (bfd_vma reloc_info
)
1074 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1077 static inline bfd_boolean
1078 uses_msp430x_relocs (void)
1081 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1082 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1083 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1084 /* TI compiler uses ELFOSABI_NONE. */
1085 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1088 /* Display the contents of the relocation data found at the specified
1092 dump_relocations (FILE * file
,
1093 unsigned long rel_offset
,
1094 unsigned long rel_size
,
1095 Elf_Internal_Sym
* symtab
,
1096 unsigned long nsyms
,
1098 unsigned long strtablen
,
1100 bfd_boolean is_dynsym
)
1103 Elf_Internal_Rela
* rels
;
1104 bfd_boolean res
= TRUE
;
1106 if (is_rela
== UNKNOWN
)
1107 is_rela
= guess_is_rela (elf_header
.e_machine
);
1111 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1116 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1125 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1127 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1132 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1134 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1142 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1144 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1149 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1151 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1155 for (i
= 0; i
< rel_size
; i
++)
1160 bfd_vma symtab_index
;
1163 offset
= rels
[i
].r_offset
;
1164 inf
= rels
[i
].r_info
;
1166 type
= get_reloc_type (inf
);
1167 symtab_index
= get_reloc_symindex (inf
);
1171 printf ("%8.8lx %8.8lx ",
1172 (unsigned long) offset
& 0xffffffff,
1173 (unsigned long) inf
& 0xffffffff);
1177 #if BFD_HOST_64BIT_LONG
1179 ? "%16.16lx %16.16lx "
1180 : "%12.12lx %12.12lx ",
1182 #elif BFD_HOST_64BIT_LONG_LONG
1185 ? "%16.16llx %16.16llx "
1186 : "%12.12llx %12.12llx ",
1190 ? "%16.16I64x %16.16I64x "
1191 : "%12.12I64x %12.12I64x ",
1196 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1197 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1198 _bfd_int64_high (offset
),
1199 _bfd_int64_low (offset
),
1200 _bfd_int64_high (inf
),
1201 _bfd_int64_low (inf
));
1205 switch (elf_header
.e_machine
)
1212 rtype
= elf_aarch64_reloc_type (type
);
1216 case EM_CYGNUS_M32R
:
1217 rtype
= elf_m32r_reloc_type (type
);
1222 rtype
= elf_i386_reloc_type (type
);
1227 rtype
= elf_m68hc11_reloc_type (type
);
1231 rtype
= elf_m68k_reloc_type (type
);
1235 rtype
= elf_i960_reloc_type (type
);
1240 rtype
= elf_avr_reloc_type (type
);
1243 case EM_OLD_SPARCV9
:
1244 case EM_SPARC32PLUS
:
1247 rtype
= elf_sparc_reloc_type (type
);
1251 rtype
= elf_spu_reloc_type (type
);
1255 rtype
= v800_reloc_type (type
);
1258 case EM_CYGNUS_V850
:
1259 rtype
= v850_reloc_type (type
);
1263 case EM_CYGNUS_D10V
:
1264 rtype
= elf_d10v_reloc_type (type
);
1268 case EM_CYGNUS_D30V
:
1269 rtype
= elf_d30v_reloc_type (type
);
1273 rtype
= elf_dlx_reloc_type (type
);
1277 rtype
= elf_sh_reloc_type (type
);
1281 case EM_CYGNUS_MN10300
:
1282 rtype
= elf_mn10300_reloc_type (type
);
1286 case EM_CYGNUS_MN10200
:
1287 rtype
= elf_mn10200_reloc_type (type
);
1291 case EM_CYGNUS_FR30
:
1292 rtype
= elf_fr30_reloc_type (type
);
1296 rtype
= elf_frv_reloc_type (type
);
1300 rtype
= elf_ft32_reloc_type (type
);
1304 rtype
= elf_mcore_reloc_type (type
);
1308 rtype
= elf_mmix_reloc_type (type
);
1312 rtype
= elf_moxie_reloc_type (type
);
1316 if (uses_msp430x_relocs ())
1318 rtype
= elf_msp430x_reloc_type (type
);
1323 rtype
= elf_msp430_reloc_type (type
);
1327 rtype
= elf_nds32_reloc_type (type
);
1331 rtype
= elf_ppc_reloc_type (type
);
1335 rtype
= elf_ppc64_reloc_type (type
);
1339 case EM_MIPS_RS3_LE
:
1340 rtype
= elf_mips_reloc_type (type
);
1344 rtype
= elf_riscv_reloc_type (type
);
1348 rtype
= elf_alpha_reloc_type (type
);
1352 rtype
= elf_arm_reloc_type (type
);
1356 case EM_ARC_COMPACT
:
1357 case EM_ARC_COMPACT2
:
1358 rtype
= elf_arc_reloc_type (type
);
1362 rtype
= elf_hppa_reloc_type (type
);
1368 rtype
= elf_h8_reloc_type (type
);
1372 rtype
= elf_or1k_reloc_type (type
);
1377 rtype
= elf_pj_reloc_type (type
);
1380 rtype
= elf_ia64_reloc_type (type
);
1384 rtype
= elf_cris_reloc_type (type
);
1388 rtype
= elf_i860_reloc_type (type
);
1394 rtype
= elf_x86_64_reloc_type (type
);
1398 rtype
= i370_reloc_type (type
);
1403 rtype
= elf_s390_reloc_type (type
);
1407 rtype
= elf_score_reloc_type (type
);
1411 rtype
= elf_xstormy16_reloc_type (type
);
1415 rtype
= elf_crx_reloc_type (type
);
1419 rtype
= elf_vax_reloc_type (type
);
1423 rtype
= elf_visium_reloc_type (type
);
1426 case EM_ADAPTEVA_EPIPHANY
:
1427 rtype
= elf_epiphany_reloc_type (type
);
1432 rtype
= elf_ip2k_reloc_type (type
);
1436 rtype
= elf_iq2000_reloc_type (type
);
1441 rtype
= elf_xtensa_reloc_type (type
);
1444 case EM_LATTICEMICO32
:
1445 rtype
= elf_lm32_reloc_type (type
);
1450 rtype
= elf_m32c_reloc_type (type
);
1454 rtype
= elf_mt_reloc_type (type
);
1458 rtype
= elf_bfin_reloc_type (type
);
1462 rtype
= elf_mep_reloc_type (type
);
1466 rtype
= elf_cr16_reloc_type (type
);
1470 case EM_MICROBLAZE_OLD
:
1471 rtype
= elf_microblaze_reloc_type (type
);
1475 rtype
= elf_rl78_reloc_type (type
);
1479 rtype
= elf_rx_reloc_type (type
);
1483 rtype
= elf_metag_reloc_type (type
);
1488 rtype
= elf_xc16x_reloc_type (type
);
1492 rtype
= elf_tic6x_reloc_type (type
);
1496 rtype
= elf_tilegx_reloc_type (type
);
1500 rtype
= elf_tilepro_reloc_type (type
);
1503 case EM_WEBASSEMBLY
:
1504 rtype
= elf_wasm32_reloc_type (type
);
1508 rtype
= elf_xgate_reloc_type (type
);
1511 case EM_ALTERA_NIOS2
:
1512 rtype
= elf_nios2_reloc_type (type
);
1516 rtype
= elf_pru_reloc_type (type
);
1521 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1523 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1525 if (elf_header
.e_machine
== EM_ALPHA
1527 && streq (rtype
, "R_ALPHA_LITUSE")
1530 switch (rels
[i
].r_addend
)
1532 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1533 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1534 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1535 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1536 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1537 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1538 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1539 default: rtype
= NULL
;
1543 printf (" (%s)", rtype
);
1547 printf (_("<unknown addend: %lx>"),
1548 (unsigned long) rels
[i
].r_addend
);
1552 else if (symtab_index
)
1554 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1556 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1561 Elf_Internal_Sym
* psym
;
1562 const char * version_string
;
1563 enum versioned_symbol_info sym_info
;
1564 unsigned short vna_other
;
1566 psym
= symtab
+ symtab_index
;
1569 = get_symbol_version_string (file
, is_dynsym
,
1578 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1582 unsigned int width
= is_32bit_elf
? 8 : 14;
1584 /* Relocations against GNU_IFUNC symbols do not use the value
1585 of the symbol as the address to relocate against. Instead
1586 they invoke the function named by the symbol and use its
1587 result as the address for relocation.
1589 To indicate this to the user, do not display the value of
1590 the symbol in the "Symbols's Value" field. Instead show
1591 its name followed by () as a hint that the symbol is
1595 || psym
->st_name
== 0
1596 || psym
->st_name
>= strtablen
)
1599 name
= strtab
+ psym
->st_name
;
1601 len
= print_symbol (width
, name
);
1603 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1605 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1609 print_vma (psym
->st_value
, LONG_HEX
);
1611 printf (is_32bit_elf
? " " : " ");
1614 if (psym
->st_name
== 0)
1616 const char * sec_name
= "<null>";
1619 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1621 if (psym
->st_shndx
< elf_header
.e_shnum
)
1622 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1623 else if (psym
->st_shndx
== SHN_ABS
)
1625 else if (psym
->st_shndx
== SHN_COMMON
)
1626 sec_name
= "COMMON";
1627 else if ((elf_header
.e_machine
== EM_MIPS
1628 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1629 || (elf_header
.e_machine
== EM_TI_C6000
1630 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1631 sec_name
= "SCOMMON";
1632 else if (elf_header
.e_machine
== EM_MIPS
1633 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1634 sec_name
= "SUNDEF";
1635 else if ((elf_header
.e_machine
== EM_X86_64
1636 || elf_header
.e_machine
== EM_L1OM
1637 || elf_header
.e_machine
== EM_K1OM
)
1638 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1639 sec_name
= "LARGE_COMMON";
1640 else if (elf_header
.e_machine
== EM_IA_64
1641 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1642 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1643 sec_name
= "ANSI_COM";
1644 else if (is_ia64_vms ()
1645 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1646 sec_name
= "VMS_SYMVEC";
1649 sprintf (name_buf
, "<section 0x%x>",
1650 (unsigned int) psym
->st_shndx
);
1651 sec_name
= name_buf
;
1654 print_symbol (22, sec_name
);
1656 else if (strtab
== NULL
)
1657 printf (_("<string table index: %3ld>"), psym
->st_name
);
1658 else if (psym
->st_name
>= strtablen
)
1660 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1665 print_symbol (22, strtab
+ psym
->st_name
);
1667 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1673 bfd_vma off
= rels
[i
].r_addend
;
1675 if ((bfd_signed_vma
) off
< 0)
1676 printf (" - %" BFD_VMA_FMT
"x", - off
);
1678 printf (" + %" BFD_VMA_FMT
"x", off
);
1684 bfd_vma off
= rels
[i
].r_addend
;
1686 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1687 if ((bfd_signed_vma
) off
< 0)
1688 printf ("-%" BFD_VMA_FMT
"x", - off
);
1690 printf ("%" BFD_VMA_FMT
"x", off
);
1693 if (elf_header
.e_machine
== EM_SPARCV9
1695 && streq (rtype
, "R_SPARC_OLO10"))
1696 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1701 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1703 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1704 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1705 const char * rtype2
= elf_mips_reloc_type (type2
);
1706 const char * rtype3
= elf_mips_reloc_type (type3
);
1708 printf (" Type2: ");
1711 printf (_("unrecognized: %-7lx"),
1712 (unsigned long) type2
& 0xffffffff);
1714 printf ("%-17.17s", rtype2
);
1716 printf ("\n Type3: ");
1719 printf (_("unrecognized: %-7lx"),
1720 (unsigned long) type3
& 0xffffffff);
1722 printf ("%-17.17s", rtype3
);
1735 get_mips_dynamic_type (unsigned long type
)
1739 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1740 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1741 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1742 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1743 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1744 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1745 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1746 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1747 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1748 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1749 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1750 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1751 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1752 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1753 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1754 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1755 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1756 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1757 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1758 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1759 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1760 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1761 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1762 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1763 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1764 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1765 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1766 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1767 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1768 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1769 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1770 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1771 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1772 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1773 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1774 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1775 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1776 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1777 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1778 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1779 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1780 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1781 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1782 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1783 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1784 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1791 get_sparc64_dynamic_type (unsigned long type
)
1795 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1802 get_ppc_dynamic_type (unsigned long type
)
1806 case DT_PPC_GOT
: return "PPC_GOT";
1807 case DT_PPC_OPT
: return "PPC_OPT";
1814 get_ppc64_dynamic_type (unsigned long type
)
1818 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1819 case DT_PPC64_OPD
: return "PPC64_OPD";
1820 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1821 case DT_PPC64_OPT
: return "PPC64_OPT";
1828 get_parisc_dynamic_type (unsigned long type
)
1832 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1833 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1834 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1835 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1836 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1837 case DT_HP_PREINIT
: return "HP_PREINIT";
1838 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1839 case DT_HP_NEEDED
: return "HP_NEEDED";
1840 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1841 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1842 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1843 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1844 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1845 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1846 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1847 case DT_HP_FILTERED
: return "HP_FILTERED";
1848 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1849 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1850 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1851 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1852 case DT_PLT
: return "PLT";
1853 case DT_PLT_SIZE
: return "PLT_SIZE";
1854 case DT_DLT
: return "DLT";
1855 case DT_DLT_SIZE
: return "DLT_SIZE";
1862 get_ia64_dynamic_type (unsigned long type
)
1866 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1867 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1868 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1869 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1870 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1871 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1872 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1873 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1874 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1875 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1876 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1877 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1878 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1879 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1880 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1881 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1882 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1883 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1884 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1885 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1886 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1887 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1888 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1889 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1890 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1891 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1892 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1893 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1894 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1895 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1896 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1903 get_solaris_section_type (unsigned long type
)
1907 case 0x6fffffee: return "SUNW_ancillary";
1908 case 0x6fffffef: return "SUNW_capchain";
1909 case 0x6ffffff0: return "SUNW_capinfo";
1910 case 0x6ffffff1: return "SUNW_symsort";
1911 case 0x6ffffff2: return "SUNW_tlssort";
1912 case 0x6ffffff3: return "SUNW_LDYNSYM";
1913 case 0x6ffffff4: return "SUNW_dof";
1914 case 0x6ffffff5: return "SUNW_cap";
1915 case 0x6ffffff6: return "SUNW_SIGNATURE";
1916 case 0x6ffffff7: return "SUNW_ANNOTATE";
1917 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1918 case 0x6ffffff9: return "SUNW_DEBUG";
1919 case 0x6ffffffa: return "SUNW_move";
1920 case 0x6ffffffb: return "SUNW_COMDAT";
1921 case 0x6ffffffc: return "SUNW_syminfo";
1922 case 0x6ffffffd: return "SUNW_verdef";
1923 case 0x6ffffffe: return "SUNW_verneed";
1924 case 0x6fffffff: return "SUNW_versym";
1925 case 0x70000000: return "SPARC_GOTDATA";
1926 default: return NULL
;
1931 get_alpha_dynamic_type (unsigned long type
)
1935 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1936 default: return NULL
;
1941 get_score_dynamic_type (unsigned long type
)
1945 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1946 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1947 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1948 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1949 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1950 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1951 default: return NULL
;
1956 get_tic6x_dynamic_type (unsigned long type
)
1960 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1961 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1962 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1963 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1964 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1965 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1966 default: return NULL
;
1971 get_nios2_dynamic_type (unsigned long type
)
1975 case DT_NIOS2_GP
: return "NIOS2_GP";
1976 default: return NULL
;
1981 get_solaris_dynamic_type (unsigned long type
)
1985 case 0x6000000d: return "SUNW_AUXILIARY";
1986 case 0x6000000e: return "SUNW_RTLDINF";
1987 case 0x6000000f: return "SUNW_FILTER";
1988 case 0x60000010: return "SUNW_CAP";
1989 case 0x60000011: return "SUNW_SYMTAB";
1990 case 0x60000012: return "SUNW_SYMSZ";
1991 case 0x60000013: return "SUNW_SORTENT";
1992 case 0x60000014: return "SUNW_SYMSORT";
1993 case 0x60000015: return "SUNW_SYMSORTSZ";
1994 case 0x60000016: return "SUNW_TLSSORT";
1995 case 0x60000017: return "SUNW_TLSSORTSZ";
1996 case 0x60000018: return "SUNW_CAPINFO";
1997 case 0x60000019: return "SUNW_STRPAD";
1998 case 0x6000001a: return "SUNW_CAPCHAIN";
1999 case 0x6000001b: return "SUNW_LDMACH";
2000 case 0x6000001d: return "SUNW_CAPCHAINENT";
2001 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2002 case 0x60000021: return "SUNW_PARENT";
2003 case 0x60000023: return "SUNW_ASLR";
2004 case 0x60000025: return "SUNW_RELAX";
2005 case 0x60000029: return "SUNW_NXHEAP";
2006 case 0x6000002b: return "SUNW_NXSTACK";
2008 case 0x70000001: return "SPARC_REGISTER";
2009 case 0x7ffffffd: return "AUXILIARY";
2010 case 0x7ffffffe: return "USED";
2011 case 0x7fffffff: return "FILTER";
2013 default: return NULL
;
2018 get_dynamic_type (unsigned long type
)
2020 static char buff
[64];
2024 case DT_NULL
: return "NULL";
2025 case DT_NEEDED
: return "NEEDED";
2026 case DT_PLTRELSZ
: return "PLTRELSZ";
2027 case DT_PLTGOT
: return "PLTGOT";
2028 case DT_HASH
: return "HASH";
2029 case DT_STRTAB
: return "STRTAB";
2030 case DT_SYMTAB
: return "SYMTAB";
2031 case DT_RELA
: return "RELA";
2032 case DT_RELASZ
: return "RELASZ";
2033 case DT_RELAENT
: return "RELAENT";
2034 case DT_STRSZ
: return "STRSZ";
2035 case DT_SYMENT
: return "SYMENT";
2036 case DT_INIT
: return "INIT";
2037 case DT_FINI
: return "FINI";
2038 case DT_SONAME
: return "SONAME";
2039 case DT_RPATH
: return "RPATH";
2040 case DT_SYMBOLIC
: return "SYMBOLIC";
2041 case DT_REL
: return "REL";
2042 case DT_RELSZ
: return "RELSZ";
2043 case DT_RELENT
: return "RELENT";
2044 case DT_PLTREL
: return "PLTREL";
2045 case DT_DEBUG
: return "DEBUG";
2046 case DT_TEXTREL
: return "TEXTREL";
2047 case DT_JMPREL
: return "JMPREL";
2048 case DT_BIND_NOW
: return "BIND_NOW";
2049 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2050 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2051 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2052 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2053 case DT_RUNPATH
: return "RUNPATH";
2054 case DT_FLAGS
: return "FLAGS";
2056 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2057 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2058 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2060 case DT_CHECKSUM
: return "CHECKSUM";
2061 case DT_PLTPADSZ
: return "PLTPADSZ";
2062 case DT_MOVEENT
: return "MOVEENT";
2063 case DT_MOVESZ
: return "MOVESZ";
2064 case DT_FEATURE
: return "FEATURE";
2065 case DT_POSFLAG_1
: return "POSFLAG_1";
2066 case DT_SYMINSZ
: return "SYMINSZ";
2067 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2069 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2070 case DT_CONFIG
: return "CONFIG";
2071 case DT_DEPAUDIT
: return "DEPAUDIT";
2072 case DT_AUDIT
: return "AUDIT";
2073 case DT_PLTPAD
: return "PLTPAD";
2074 case DT_MOVETAB
: return "MOVETAB";
2075 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2077 case DT_VERSYM
: return "VERSYM";
2079 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2080 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2081 case DT_RELACOUNT
: return "RELACOUNT";
2082 case DT_RELCOUNT
: return "RELCOUNT";
2083 case DT_FLAGS_1
: return "FLAGS_1";
2084 case DT_VERDEF
: return "VERDEF";
2085 case DT_VERDEFNUM
: return "VERDEFNUM";
2086 case DT_VERNEED
: return "VERNEED";
2087 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2089 case DT_AUXILIARY
: return "AUXILIARY";
2090 case DT_USED
: return "USED";
2091 case DT_FILTER
: return "FILTER";
2093 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2094 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2095 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2096 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2097 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2098 case DT_GNU_HASH
: return "GNU_HASH";
2101 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2103 const char * result
;
2105 switch (elf_header
.e_machine
)
2108 case EM_MIPS_RS3_LE
:
2109 result
= get_mips_dynamic_type (type
);
2112 result
= get_sparc64_dynamic_type (type
);
2115 result
= get_ppc_dynamic_type (type
);
2118 result
= get_ppc64_dynamic_type (type
);
2121 result
= get_ia64_dynamic_type (type
);
2124 result
= get_alpha_dynamic_type (type
);
2127 result
= get_score_dynamic_type (type
);
2130 result
= get_tic6x_dynamic_type (type
);
2132 case EM_ALTERA_NIOS2
:
2133 result
= get_nios2_dynamic_type (type
);
2136 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2137 result
= get_solaris_dynamic_type (type
);
2146 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2148 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2149 || (elf_header
.e_machine
== EM_PARISC
2150 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2152 const char * result
;
2154 switch (elf_header
.e_machine
)
2157 result
= get_parisc_dynamic_type (type
);
2160 result
= get_ia64_dynamic_type (type
);
2163 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2164 result
= get_solaris_dynamic_type (type
);
2173 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2177 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2184 get_file_type (unsigned e_type
)
2186 static char buff
[32];
2190 case ET_NONE
: return _("NONE (None)");
2191 case ET_REL
: return _("REL (Relocatable file)");
2192 case ET_EXEC
: return _("EXEC (Executable file)");
2193 case ET_DYN
: return _("DYN (Shared object file)");
2194 case ET_CORE
: return _("CORE (Core file)");
2197 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2198 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2199 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2200 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2202 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2208 get_machine_name (unsigned e_machine
)
2210 static char buff
[64]; /* XXX */
2214 /* Please keep this switch table sorted by increasing EM_ value. */
2216 case EM_NONE
: return _("None");
2217 case EM_M32
: return "WE32100";
2218 case EM_SPARC
: return "Sparc";
2219 case EM_386
: return "Intel 80386";
2220 case EM_68K
: return "MC68000";
2221 case EM_88K
: return "MC88000";
2222 case EM_IAMCU
: return "Intel MCU";
2223 case EM_860
: return "Intel 80860";
2224 case EM_MIPS
: return "MIPS R3000";
2225 case EM_S370
: return "IBM System/370";
2227 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2228 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2229 case EM_PARISC
: return "HPPA";
2230 case EM_VPP550
: return "Fujitsu VPP500";
2231 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2232 case EM_960
: return "Intel 90860";
2233 case EM_PPC
: return "PowerPC";
2235 case EM_PPC64
: return "PowerPC64";
2237 case EM_S390
: return "IBM S/390";
2238 case EM_SPU
: return "SPU";
2240 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2241 case EM_FR20
: return "Fujitsu FR20";
2242 case EM_RH32
: return "TRW RH32";
2243 case EM_MCORE
: return "MCORE";
2245 case EM_ARM
: return "ARM";
2246 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2247 case EM_SH
: return "Renesas / SuperH SH";
2248 case EM_SPARCV9
: return "Sparc v9";
2249 case EM_TRICORE
: return "Siemens Tricore";
2250 case EM_ARC
: return "ARC";
2251 case EM_H8_300
: return "Renesas H8/300";
2252 case EM_H8_300H
: return "Renesas H8/300H";
2253 case EM_H8S
: return "Renesas H8S";
2254 case EM_H8_500
: return "Renesas H8/500";
2256 case EM_IA_64
: return "Intel IA-64";
2257 case EM_MIPS_X
: return "Stanford MIPS-X";
2258 case EM_COLDFIRE
: return "Motorola Coldfire";
2259 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2260 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2261 case EM_PCP
: return "Siemens PCP";
2262 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2263 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2264 case EM_STARCORE
: return "Motorola Star*Core processor";
2265 case EM_ME16
: return "Toyota ME16 processor";
2267 case EM_ST100
: return "STMicroelectronics ST100 processor";
2268 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2269 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2270 case EM_PDSP
: return "Sony DSP processor";
2271 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2272 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2273 case EM_FX66
: return "Siemens FX66 microcontroller";
2274 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2275 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2276 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2278 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2279 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2280 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2281 case EM_SVX
: return "Silicon Graphics SVx";
2282 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2283 case EM_VAX
: return "Digital VAX";
2284 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2285 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2286 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2287 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2289 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2290 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2291 case EM_PRISM
: return "Vitesse Prism";
2293 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2294 case EM_CYGNUS_FR30
:
2295 case EM_FR30
: return "Fujitsu FR30";
2296 case EM_CYGNUS_D10V
:
2297 case EM_D10V
: return "d10v";
2298 case EM_CYGNUS_D30V
:
2299 case EM_D30V
: return "d30v";
2300 case EM_CYGNUS_V850
:
2301 case EM_V850
: return "Renesas V850";
2302 case EM_CYGNUS_M32R
:
2303 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2304 case EM_CYGNUS_MN10300
:
2305 case EM_MN10300
: return "mn10300";
2307 case EM_CYGNUS_MN10200
:
2308 case EM_MN10200
: return "mn10200";
2309 case EM_PJ
: return "picoJava";
2310 case EM_OR1K
: return "OpenRISC 1000";
2311 case EM_ARC_COMPACT
: return "ARCompact";
2313 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2314 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2315 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2316 case EM_NS32K
: return "National Semiconductor 32000 series";
2317 case EM_TPC
: return "Tenor Network TPC processor";
2318 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2320 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2322 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2323 case EM_MAX
: return "MAX Processor";
2324 case EM_CR
: return "National Semiconductor CompactRISC";
2325 case EM_F2MC16
: return "Fujitsu F2MC16";
2326 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2327 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2328 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2329 case EM_SEP
: return "Sharp embedded microprocessor";
2330 case EM_ARCA
: return "Arca RISC microprocessor";
2332 case EM_UNICORE
: return "Unicore";
2333 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2334 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2335 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2336 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2337 case EM_XGATE
: return "Motorola XGATE embedded processor";
2339 case EM_XC16X
: return "Infineon Technologies xc16x";
2340 case EM_M16C
: return "Renesas M16C series microprocessors";
2341 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2342 case EM_CE
: return "Freescale Communication Engine RISC core";
2344 case EM_M32C
: return "Renesas M32c";
2346 case EM_TSK3000
: return "Altium TSK3000 core";
2347 case EM_RS08
: return "Freescale RS08 embedded processor";
2348 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2349 case EM_SCORE
: return "SUNPLUS S+Core";
2350 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2351 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2352 case EM_LATTICEMICO32
: return "Lattice Mico32";
2353 case EM_SE_C17
: return "Seiko Epson C17 family";
2355 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2356 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2357 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2358 case EM_TI_PRU
: return "TI PRU I/O processor";
2360 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2361 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2362 case EM_R32C
: return "Renesas R32C series microprocessors";
2363 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2364 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2365 case EM_8051
: return "Intel 8051 and variants";
2366 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2367 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2368 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2369 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2371 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2372 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2373 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2374 case EM_RX
: return "Renesas RX";
2375 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2376 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2377 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2380 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2381 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2382 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2384 case EM_L1OM
: return "Intel L1OM";
2385 case EM_K1OM
: return "Intel K1OM";
2386 case EM_INTEL182
: return "Intel (reserved)";
2387 case EM_AARCH64
: return "AArch64";
2388 case EM_ARM184
: return "ARM (reserved)";
2389 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2390 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2391 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2392 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2394 case EM_CUDA
: return "NVIDIA CUDA architecture";
2395 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2396 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2397 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2398 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2399 case EM_ARC_COMPACT2
: return "ARCv2";
2400 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2401 case EM_RL78
: return "Renesas RL78";
2402 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2403 case EM_78K0R
: return "Renesas 78K0R";
2405 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2406 case EM_BA1
: return "Beyond BA1 CPU architecture";
2407 case EM_BA2
: return "Beyond BA2 CPU architecture";
2408 case EM_XCORE
: return "XMOS xCORE processor family";
2409 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2411 case EM_KM32
: return "KM211 KM32 32-bit processor";
2412 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2413 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2414 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2415 case EM_KVARC
: return "KM211 KVARC processor";
2416 case EM_CDP
: return "Paneve CDP architecture family";
2417 case EM_COGE
: return "Cognitive Smart Memory Processor";
2418 case EM_COOL
: return "Bluechip Systems CoolEngine";
2419 case EM_NORC
: return "Nanoradio Optimized RISC";
2420 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2422 case EM_Z80
: return "Zilog Z80";
2423 case EM_VISIUM
: return "CDS VISIUMcore processor";
2424 case EM_FT32
: return "FTDI Chip FT32";
2425 case EM_MOXIE
: return "Moxie";
2426 case EM_AMDGPU
: return "AMD GPU";
2427 case EM_RISCV
: return "RISC-V";
2428 case EM_LANAI
: return "Lanai 32-bit processor";
2429 case EM_BPF
: return "Linux BPF";
2431 /* Large numbers... */
2432 case EM_MT
: return "Morpho Techologies MT processor";
2433 case EM_ALPHA
: return "Alpha";
2434 case EM_WEBASSEMBLY
: return "Web Assembly";
2435 case EM_DLX
: return "OpenDLX";
2436 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2437 case EM_IQ2000
: return "Vitesse IQ2000";
2439 case EM_NIOS32
: return "Altera Nios";
2440 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2441 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2442 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2445 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2451 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2453 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2454 other compilers don't a specific architecture type in the e_flags, and
2455 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2456 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2459 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2460 but also sets a specific architecture type in the e_flags field.
2462 However, when decoding the flags we don't worry if we see an
2463 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2464 ARCEM architecture type. */
2466 switch (e_flags
& EF_ARC_MACH_MSK
)
2468 /* We only expect these to occur for EM_ARC_COMPACT2. */
2469 case EF_ARC_CPU_ARCV2EM
:
2470 strcat (buf
, ", ARC EM");
2472 case EF_ARC_CPU_ARCV2HS
:
2473 strcat (buf
, ", ARC HS");
2476 /* We only expect these to occur for EM_ARC_COMPACT. */
2477 case E_ARC_MACH_ARC600
:
2478 strcat (buf
, ", ARC600");
2480 case E_ARC_MACH_ARC601
:
2481 strcat (buf
, ", ARC601");
2483 case E_ARC_MACH_ARC700
:
2484 strcat (buf
, ", ARC700");
2487 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2488 new ELF with new architecture being read by an old version of
2489 readelf, or (c) An ELF built with non-GNU compiler that does not
2490 set the architecture in the e_flags. */
2492 if (e_machine
== EM_ARC_COMPACT
)
2493 strcat (buf
, ", Unknown ARCompact");
2495 strcat (buf
, ", Unknown ARC");
2499 switch (e_flags
& EF_ARC_OSABI_MSK
)
2501 case E_ARC_OSABI_ORIG
:
2502 strcat (buf
, ", (ABI:legacy)");
2504 case E_ARC_OSABI_V2
:
2505 strcat (buf
, ", (ABI:v2)");
2507 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2508 case E_ARC_OSABI_V3
:
2509 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2512 strcat (buf
, ", unrecognised ARC OSABI flag");
2518 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2521 bfd_boolean unknown
= FALSE
;
2523 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2524 e_flags
&= ~ EF_ARM_EABIMASK
;
2526 /* Handle "generic" ARM flags. */
2527 if (e_flags
& EF_ARM_RELEXEC
)
2529 strcat (buf
, ", relocatable executable");
2530 e_flags
&= ~ EF_ARM_RELEXEC
;
2533 /* Now handle EABI specific flags. */
2537 strcat (buf
, ", <unrecognized EABI>");
2542 case EF_ARM_EABI_VER1
:
2543 strcat (buf
, ", Version1 EABI");
2548 /* Process flags one bit at a time. */
2549 flag
= e_flags
& - e_flags
;
2554 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2555 strcat (buf
, ", sorted symbol tables");
2565 case EF_ARM_EABI_VER2
:
2566 strcat (buf
, ", Version2 EABI");
2571 /* Process flags one bit at a time. */
2572 flag
= e_flags
& - e_flags
;
2577 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2578 strcat (buf
, ", sorted symbol tables");
2581 case EF_ARM_DYNSYMSUSESEGIDX
:
2582 strcat (buf
, ", dynamic symbols use segment index");
2585 case EF_ARM_MAPSYMSFIRST
:
2586 strcat (buf
, ", mapping symbols precede others");
2596 case EF_ARM_EABI_VER3
:
2597 strcat (buf
, ", Version3 EABI");
2600 case EF_ARM_EABI_VER4
:
2601 strcat (buf
, ", Version4 EABI");
2606 /* Process flags one bit at a time. */
2607 flag
= e_flags
& - e_flags
;
2613 strcat (buf
, ", BE8");
2617 strcat (buf
, ", LE8");
2627 case EF_ARM_EABI_VER5
:
2628 strcat (buf
, ", Version5 EABI");
2633 /* Process flags one bit at a time. */
2634 flag
= e_flags
& - e_flags
;
2640 strcat (buf
, ", BE8");
2644 strcat (buf
, ", LE8");
2647 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2648 strcat (buf
, ", soft-float ABI");
2651 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2652 strcat (buf
, ", hard-float ABI");
2662 case EF_ARM_EABI_UNKNOWN
:
2663 strcat (buf
, ", GNU EABI");
2668 /* Process flags one bit at a time. */
2669 flag
= e_flags
& - e_flags
;
2674 case EF_ARM_INTERWORK
:
2675 strcat (buf
, ", interworking enabled");
2678 case EF_ARM_APCS_26
:
2679 strcat (buf
, ", uses APCS/26");
2682 case EF_ARM_APCS_FLOAT
:
2683 strcat (buf
, ", uses APCS/float");
2687 strcat (buf
, ", position independent");
2691 strcat (buf
, ", 8 bit structure alignment");
2694 case EF_ARM_NEW_ABI
:
2695 strcat (buf
, ", uses new ABI");
2698 case EF_ARM_OLD_ABI
:
2699 strcat (buf
, ", uses old ABI");
2702 case EF_ARM_SOFT_FLOAT
:
2703 strcat (buf
, ", software FP");
2706 case EF_ARM_VFP_FLOAT
:
2707 strcat (buf
, ", VFP");
2710 case EF_ARM_MAVERICK_FLOAT
:
2711 strcat (buf
, ", Maverick FP");
2722 strcat (buf
,_(", <unknown>"));
2726 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2728 --size
; /* Leave space for null terminator. */
2730 switch (e_flags
& EF_AVR_MACH
)
2732 case E_AVR_MACH_AVR1
:
2733 strncat (buf
, ", avr:1", size
);
2735 case E_AVR_MACH_AVR2
:
2736 strncat (buf
, ", avr:2", size
);
2738 case E_AVR_MACH_AVR25
:
2739 strncat (buf
, ", avr:25", size
);
2741 case E_AVR_MACH_AVR3
:
2742 strncat (buf
, ", avr:3", size
);
2744 case E_AVR_MACH_AVR31
:
2745 strncat (buf
, ", avr:31", size
);
2747 case E_AVR_MACH_AVR35
:
2748 strncat (buf
, ", avr:35", size
);
2750 case E_AVR_MACH_AVR4
:
2751 strncat (buf
, ", avr:4", size
);
2753 case E_AVR_MACH_AVR5
:
2754 strncat (buf
, ", avr:5", size
);
2756 case E_AVR_MACH_AVR51
:
2757 strncat (buf
, ", avr:51", size
);
2759 case E_AVR_MACH_AVR6
:
2760 strncat (buf
, ", avr:6", size
);
2762 case E_AVR_MACH_AVRTINY
:
2763 strncat (buf
, ", avr:100", size
);
2765 case E_AVR_MACH_XMEGA1
:
2766 strncat (buf
, ", avr:101", size
);
2768 case E_AVR_MACH_XMEGA2
:
2769 strncat (buf
, ", avr:102", size
);
2771 case E_AVR_MACH_XMEGA3
:
2772 strncat (buf
, ", avr:103", size
);
2774 case E_AVR_MACH_XMEGA4
:
2775 strncat (buf
, ", avr:104", size
);
2777 case E_AVR_MACH_XMEGA5
:
2778 strncat (buf
, ", avr:105", size
);
2780 case E_AVR_MACH_XMEGA6
:
2781 strncat (buf
, ", avr:106", size
);
2783 case E_AVR_MACH_XMEGA7
:
2784 strncat (buf
, ", avr:107", size
);
2787 strncat (buf
, ", avr:<unknown>", size
);
2791 size
-= strlen (buf
);
2792 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2793 strncat (buf
, ", link-relax", size
);
2797 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2803 bfd_boolean has_fpu
= FALSE
;
2806 static const char *ABI_STRINGS
[] =
2808 "ABI v0", /* use r5 as return register; only used in N1213HC */
2809 "ABI v1", /* use r0 as return register */
2810 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2811 "ABI v2fp", /* for FPU */
2815 static const char *VER_STRINGS
[] =
2817 "Andes ELF V1.3 or older",
2821 static const char *ARCH_STRINGS
[] =
2830 abi
= EF_NDS_ABI
& e_flags
;
2831 arch
= EF_NDS_ARCH
& e_flags
;
2832 config
= EF_NDS_INST
& e_flags
;
2833 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2835 memset (buf
, 0, size
);
2842 case E_NDS_ABI_V2FP
:
2843 case E_NDS_ABI_AABI
:
2844 case E_NDS_ABI_V2FP_PLUS
:
2845 /* In case there are holes in the array. */
2846 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2850 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2856 case E_NDS32_ELF_VER_1_2
:
2857 case E_NDS32_ELF_VER_1_3
:
2858 case E_NDS32_ELF_VER_1_4
:
2859 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2863 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2867 if (E_NDS_ABI_V0
== abi
)
2869 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2870 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2871 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2872 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2878 case E_NDS_ARCH_STAR_V1_0
:
2879 case E_NDS_ARCH_STAR_V2_0
:
2880 case E_NDS_ARCH_STAR_V3_0
:
2881 case E_NDS_ARCH_STAR_V3_M
:
2882 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2886 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2887 /* ARCH version determines how the e_flags are interpreted.
2888 If it is unknown, we cannot proceed. */
2892 /* Newer ABI; Now handle architecture specific flags. */
2893 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2895 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2896 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2898 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2899 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2901 if (config
& E_NDS32_HAS_DIV_INST
)
2902 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2904 if (config
& E_NDS32_HAS_16BIT_INST
)
2905 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2909 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2911 if (version
<= E_NDS32_ELF_VER_1_3
)
2912 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2914 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2917 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2918 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2920 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2921 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2923 if (config
& E_NDS32_HAS_16BIT_INST
)
2925 if (version
<= E_NDS32_ELF_VER_1_3
)
2926 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2928 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2932 if (config
& E_NDS32_HAS_EXT_INST
)
2933 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2935 if (config
& E_NDS32_HAS_EXT2_INST
)
2936 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2938 if (config
& E_NDS32_HAS_FPU_INST
)
2941 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2944 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2947 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2950 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2953 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2958 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2960 case E_NDS32_FPU_REG_8SP_4DP
:
2961 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2963 case E_NDS32_FPU_REG_16SP_8DP
:
2964 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2966 case E_NDS32_FPU_REG_32SP_16DP
:
2967 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2969 case E_NDS32_FPU_REG_32SP_32DP
:
2970 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2975 if (config
& E_NDS32_HAS_AUDIO_INST
)
2976 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2978 if (config
& E_NDS32_HAS_STRING_INST
)
2979 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2981 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2982 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2984 if (config
& E_NDS32_HAS_VIDEO_INST
)
2986 if (version
<= E_NDS32_ELF_VER_1_3
)
2987 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2989 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2992 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2993 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2995 if (config
& E_NDS32_HAS_L2C_INST
)
2996 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3000 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
3002 static char buf
[1024];
3013 case EM_ARC_COMPACT2
:
3014 case EM_ARC_COMPACT
:
3015 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3019 decode_ARM_machine_flags (e_flags
, buf
);
3023 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3027 if (e_flags
& EF_BFIN_PIC
)
3028 strcat (buf
, ", PIC");
3030 if (e_flags
& EF_BFIN_FDPIC
)
3031 strcat (buf
, ", FDPIC");
3033 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3034 strcat (buf
, ", code in L1");
3036 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3037 strcat (buf
, ", data in L1");
3042 switch (e_flags
& EF_FRV_CPU_MASK
)
3044 case EF_FRV_CPU_GENERIC
:
3048 strcat (buf
, ", fr???");
3051 case EF_FRV_CPU_FR300
:
3052 strcat (buf
, ", fr300");
3055 case EF_FRV_CPU_FR400
:
3056 strcat (buf
, ", fr400");
3058 case EF_FRV_CPU_FR405
:
3059 strcat (buf
, ", fr405");
3062 case EF_FRV_CPU_FR450
:
3063 strcat (buf
, ", fr450");
3066 case EF_FRV_CPU_FR500
:
3067 strcat (buf
, ", fr500");
3069 case EF_FRV_CPU_FR550
:
3070 strcat (buf
, ", fr550");
3073 case EF_FRV_CPU_SIMPLE
:
3074 strcat (buf
, ", simple");
3076 case EF_FRV_CPU_TOMCAT
:
3077 strcat (buf
, ", tomcat");
3083 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3084 strcat (buf
, ", m68000");
3085 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3086 strcat (buf
, ", cpu32");
3087 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3088 strcat (buf
, ", fido_a");
3091 char const * isa
= _("unknown");
3092 char const * mac
= _("unknown mac");
3093 char const * additional
= NULL
;
3095 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3097 case EF_M68K_CF_ISA_A_NODIV
:
3099 additional
= ", nodiv";
3101 case EF_M68K_CF_ISA_A
:
3104 case EF_M68K_CF_ISA_A_PLUS
:
3107 case EF_M68K_CF_ISA_B_NOUSP
:
3109 additional
= ", nousp";
3111 case EF_M68K_CF_ISA_B
:
3114 case EF_M68K_CF_ISA_C
:
3117 case EF_M68K_CF_ISA_C_NODIV
:
3119 additional
= ", nodiv";
3122 strcat (buf
, ", cf, isa ");
3125 strcat (buf
, additional
);
3126 if (e_flags
& EF_M68K_CF_FLOAT
)
3127 strcat (buf
, ", float");
3128 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3133 case EF_M68K_CF_MAC
:
3136 case EF_M68K_CF_EMAC
:
3139 case EF_M68K_CF_EMAC_B
:
3152 switch (e_flags
& EF_MEP_CPU_MASK
)
3154 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3155 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3156 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3157 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3158 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3159 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3160 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3163 switch (e_flags
& EF_MEP_COP_MASK
)
3165 case EF_MEP_COP_NONE
: break;
3166 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3167 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3168 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3169 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3170 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3173 if (e_flags
& EF_MEP_LIBRARY
)
3174 strcat (buf
, ", Built for Library");
3176 if (e_flags
& EF_MEP_INDEX_MASK
)
3177 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3178 e_flags
& EF_MEP_INDEX_MASK
);
3180 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3181 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3182 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3186 if (e_flags
& EF_PPC_EMB
)
3187 strcat (buf
, ", emb");
3189 if (e_flags
& EF_PPC_RELOCATABLE
)
3190 strcat (buf
, _(", relocatable"));
3192 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3193 strcat (buf
, _(", relocatable-lib"));
3197 if (e_flags
& EF_PPC64_ABI
)
3199 char abi
[] = ", abiv0";
3201 abi
[6] += e_flags
& EF_PPC64_ABI
;
3207 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3208 strcat (buf
, ", RH850 ABI");
3210 if (e_flags
& EF_V800_850E3
)
3211 strcat (buf
, ", V3 architecture");
3213 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3214 strcat (buf
, ", FPU not used");
3216 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3217 strcat (buf
, ", regmode: COMMON");
3219 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3220 strcat (buf
, ", r4 not used");
3222 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3223 strcat (buf
, ", r30 not used");
3225 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3226 strcat (buf
, ", r5 not used");
3228 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3229 strcat (buf
, ", r2 not used");
3231 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3233 switch (e_flags
& - e_flags
)
3235 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3236 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3237 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3238 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3239 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3240 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3241 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3242 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3243 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3244 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3245 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3246 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3253 case EM_CYGNUS_V850
:
3254 switch (e_flags
& EF_V850_ARCH
)
3256 case E_V850E3V5_ARCH
:
3257 strcat (buf
, ", v850e3v5");
3259 case E_V850E2V3_ARCH
:
3260 strcat (buf
, ", v850e2v3");
3263 strcat (buf
, ", v850e2");
3266 strcat (buf
, ", v850e1");
3269 strcat (buf
, ", v850e");
3272 strcat (buf
, ", v850");
3275 strcat (buf
, _(", unknown v850 architecture variant"));
3281 case EM_CYGNUS_M32R
:
3282 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3283 strcat (buf
, ", m32r");
3287 case EM_MIPS_RS3_LE
:
3288 if (e_flags
& EF_MIPS_NOREORDER
)
3289 strcat (buf
, ", noreorder");
3291 if (e_flags
& EF_MIPS_PIC
)
3292 strcat (buf
, ", pic");
3294 if (e_flags
& EF_MIPS_CPIC
)
3295 strcat (buf
, ", cpic");
3297 if (e_flags
& EF_MIPS_UCODE
)
3298 strcat (buf
, ", ugen_reserved");
3300 if (e_flags
& EF_MIPS_ABI2
)
3301 strcat (buf
, ", abi2");
3303 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3304 strcat (buf
, ", odk first");
3306 if (e_flags
& EF_MIPS_32BITMODE
)
3307 strcat (buf
, ", 32bitmode");
3309 if (e_flags
& EF_MIPS_NAN2008
)
3310 strcat (buf
, ", nan2008");
3312 if (e_flags
& EF_MIPS_FP64
)
3313 strcat (buf
, ", fp64");
3315 switch ((e_flags
& EF_MIPS_MACH
))
3317 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3318 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3319 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3320 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3321 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3322 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3323 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3324 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3325 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3326 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3327 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3328 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3329 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3330 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3331 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3332 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3333 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3335 /* We simply ignore the field in this case to avoid confusion:
3336 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3339 default: strcat (buf
, _(", unknown CPU")); break;
3342 switch ((e_flags
& EF_MIPS_ABI
))
3344 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3345 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3346 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3347 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3349 /* We simply ignore the field in this case to avoid confusion:
3350 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3351 This means it is likely to be an o32 file, but not for
3354 default: strcat (buf
, _(", unknown ABI")); break;
3357 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3358 strcat (buf
, ", mdmx");
3360 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3361 strcat (buf
, ", mips16");
3363 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3364 strcat (buf
, ", micromips");
3366 switch ((e_flags
& EF_MIPS_ARCH
))
3368 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3369 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3370 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3371 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3372 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3373 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3374 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3375 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3376 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3377 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3378 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3379 default: strcat (buf
, _(", unknown ISA")); break;
3384 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3388 if (e_flags
& EF_RISCV_RVC
)
3389 strcat (buf
, ", RVC");
3391 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3393 case EF_RISCV_FLOAT_ABI_SOFT
:
3394 strcat (buf
, ", soft-float ABI");
3397 case EF_RISCV_FLOAT_ABI_SINGLE
:
3398 strcat (buf
, ", single-float ABI");
3401 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3402 strcat (buf
, ", double-float ABI");
3405 case EF_RISCV_FLOAT_ABI_QUAD
:
3406 strcat (buf
, ", quad-float ABI");
3412 switch ((e_flags
& EF_SH_MACH_MASK
))
3414 case EF_SH1
: strcat (buf
, ", sh1"); break;
3415 case EF_SH2
: strcat (buf
, ", sh2"); break;
3416 case EF_SH3
: strcat (buf
, ", sh3"); break;
3417 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3418 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3419 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3420 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3421 case EF_SH4
: strcat (buf
, ", sh4"); break;
3422 case EF_SH5
: strcat (buf
, ", sh5"); break;
3423 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3424 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3425 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3426 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3427 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3428 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3429 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3430 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3431 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3432 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3433 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3434 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3435 default: strcat (buf
, _(", unknown ISA")); break;
3438 if (e_flags
& EF_SH_PIC
)
3439 strcat (buf
, ", pic");
3441 if (e_flags
& EF_SH_FDPIC
)
3442 strcat (buf
, ", fdpic");
3446 if (e_flags
& EF_OR1K_NODELAY
)
3447 strcat (buf
, ", no delay");
3451 if (e_flags
& EF_SPARC_32PLUS
)
3452 strcat (buf
, ", v8+");
3454 if (e_flags
& EF_SPARC_SUN_US1
)
3455 strcat (buf
, ", ultrasparcI");
3457 if (e_flags
& EF_SPARC_SUN_US3
)
3458 strcat (buf
, ", ultrasparcIII");
3460 if (e_flags
& EF_SPARC_HAL_R1
)
3461 strcat (buf
, ", halr1");
3463 if (e_flags
& EF_SPARC_LEDATA
)
3464 strcat (buf
, ", ledata");
3466 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3467 strcat (buf
, ", tso");
3469 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3470 strcat (buf
, ", pso");
3472 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3473 strcat (buf
, ", rmo");
3477 switch (e_flags
& EF_PARISC_ARCH
)
3479 case EFA_PARISC_1_0
:
3480 strcpy (buf
, ", PA-RISC 1.0");
3482 case EFA_PARISC_1_1
:
3483 strcpy (buf
, ", PA-RISC 1.1");
3485 case EFA_PARISC_2_0
:
3486 strcpy (buf
, ", PA-RISC 2.0");
3491 if (e_flags
& EF_PARISC_TRAPNIL
)
3492 strcat (buf
, ", trapnil");
3493 if (e_flags
& EF_PARISC_EXT
)
3494 strcat (buf
, ", ext");
3495 if (e_flags
& EF_PARISC_LSB
)
3496 strcat (buf
, ", lsb");
3497 if (e_flags
& EF_PARISC_WIDE
)
3498 strcat (buf
, ", wide");
3499 if (e_flags
& EF_PARISC_NO_KABP
)
3500 strcat (buf
, ", no kabp");
3501 if (e_flags
& EF_PARISC_LAZYSWAP
)
3502 strcat (buf
, ", lazyswap");
3507 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3508 strcat (buf
, ", new calling convention");
3510 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3511 strcat (buf
, ", gnu calling convention");
3515 if ((e_flags
& EF_IA_64_ABI64
))
3516 strcat (buf
, ", 64-bit");
3518 strcat (buf
, ", 32-bit");
3519 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3520 strcat (buf
, ", reduced fp model");
3521 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3522 strcat (buf
, ", no function descriptors, constant gp");
3523 else if ((e_flags
& EF_IA_64_CONS_GP
))
3524 strcat (buf
, ", constant gp");
3525 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3526 strcat (buf
, ", absolute");
3527 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3529 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3530 strcat (buf
, ", vms_linkages");
3531 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3533 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3535 case EF_IA_64_VMS_COMCOD_WARNING
:
3536 strcat (buf
, ", warning");
3538 case EF_IA_64_VMS_COMCOD_ERROR
:
3539 strcat (buf
, ", error");
3541 case EF_IA_64_VMS_COMCOD_ABORT
:
3542 strcat (buf
, ", abort");
3545 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3546 e_flags
& EF_IA_64_VMS_COMCOD
);
3547 strcat (buf
, ", <unknown>");
3553 if ((e_flags
& EF_VAX_NONPIC
))
3554 strcat (buf
, ", non-PIC");
3555 if ((e_flags
& EF_VAX_DFLOAT
))
3556 strcat (buf
, ", D-Float");
3557 if ((e_flags
& EF_VAX_GFLOAT
))
3558 strcat (buf
, ", G-Float");
3562 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3563 strcat (buf
, ", mcm");
3564 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3565 strcat (buf
, ", mcm24");
3566 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3567 strcat (buf
, ", gr6");
3571 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3573 case E_FLAG_RL78_ANY_CPU
: break;
3574 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3575 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3576 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3578 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3579 strcat (buf
, ", 64-bit doubles");
3583 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3584 strcat (buf
, ", 64-bit doubles");
3585 if (e_flags
& E_FLAG_RX_DSP
)
3586 strcat (buf
, ", dsp");
3587 if (e_flags
& E_FLAG_RX_PID
)
3588 strcat (buf
, ", pid");
3589 if (e_flags
& E_FLAG_RX_ABI
)
3590 strcat (buf
, ", RX ABI");
3591 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3592 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3593 ? ", uses String instructions" : ", bans String instructions");
3594 if (e_flags
& E_FLAG_RX_V2
)
3595 strcat (buf
, ", V2");
3599 if (e_flags
& EF_S390_HIGH_GPRS
)
3600 strcat (buf
, ", highgprs");
3604 if ((e_flags
& EF_C6000_REL
))
3605 strcat (buf
, ", relocatable module");
3609 strcat (buf
, _(": architecture variant: "));
3610 switch (e_flags
& EF_MSP430_MACH
)
3612 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3613 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3614 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3615 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3616 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3617 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3618 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3619 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3620 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3621 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3622 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3623 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3624 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3625 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3626 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3628 strcat (buf
, _(": unknown")); break;
3631 if (e_flags
& ~ EF_MSP430_MACH
)
3632 strcat (buf
, _(": unknown extra flag bits also present"));
3640 get_osabi_name (unsigned int osabi
)
3642 static char buff
[32];
3646 case ELFOSABI_NONE
: return "UNIX - System V";
3647 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3648 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3649 case ELFOSABI_GNU
: return "UNIX - GNU";
3650 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3651 case ELFOSABI_AIX
: return "UNIX - AIX";
3652 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3653 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3654 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3655 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3656 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3657 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3658 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3659 case ELFOSABI_AROS
: return "AROS";
3660 case ELFOSABI_FENIXOS
: return "FenixOS";
3661 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3662 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3665 switch (elf_header
.e_machine
)
3670 case ELFOSABI_ARM
: return "ARM";
3681 case ELFOSABI_STANDALONE
: return _("Standalone App");
3690 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3691 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3700 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3706 get_aarch64_segment_type (unsigned long type
)
3710 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3711 default: return NULL
;
3716 get_arm_segment_type (unsigned long type
)
3720 case PT_ARM_EXIDX
: return "EXIDX";
3721 default: return NULL
;
3726 get_mips_segment_type (unsigned long type
)
3730 case PT_MIPS_REGINFO
: return "REGINFO";
3731 case PT_MIPS_RTPROC
: return "RTPROC";
3732 case PT_MIPS_OPTIONS
: return "OPTIONS";
3733 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3734 default: return NULL
;
3739 get_parisc_segment_type (unsigned long type
)
3743 case PT_HP_TLS
: return "HP_TLS";
3744 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3745 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3746 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3747 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3748 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3749 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3750 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3751 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3752 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3753 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3754 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3755 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3756 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3757 case PT_HP_STACK
: return "HP_STACK";
3758 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3759 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3760 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3761 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3762 default: return NULL
;
3767 get_ia64_segment_type (unsigned long type
)
3771 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3772 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3773 case PT_HP_TLS
: return "HP_TLS";
3774 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3775 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3776 case PT_IA_64_HP_STACK
: return "HP_STACK";
3777 default: return NULL
;
3782 get_tic6x_segment_type (unsigned long type
)
3786 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3787 default: return NULL
;
3792 get_solaris_segment_type (unsigned long type
)
3796 case 0x6464e550: return "PT_SUNW_UNWIND";
3797 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3798 case 0x6ffffff7: return "PT_LOSUNW";
3799 case 0x6ffffffa: return "PT_SUNWBSS";
3800 case 0x6ffffffb: return "PT_SUNWSTACK";
3801 case 0x6ffffffc: return "PT_SUNWDTRACE";
3802 case 0x6ffffffd: return "PT_SUNWCAP";
3803 case 0x6fffffff: return "PT_HISUNW";
3804 default: return NULL
;
3809 get_segment_type (unsigned long p_type
)
3811 static char buff
[32];
3815 case PT_NULL
: return "NULL";
3816 case PT_LOAD
: return "LOAD";
3817 case PT_DYNAMIC
: return "DYNAMIC";
3818 case PT_INTERP
: return "INTERP";
3819 case PT_NOTE
: return "NOTE";
3820 case PT_SHLIB
: return "SHLIB";
3821 case PT_PHDR
: return "PHDR";
3822 case PT_TLS
: return "TLS";
3823 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3824 case PT_GNU_STACK
: return "GNU_STACK";
3825 case PT_GNU_RELRO
: return "GNU_RELRO";
3828 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3830 const char * result
;
3832 switch (elf_header
.e_machine
)
3835 result
= get_aarch64_segment_type (p_type
);
3838 result
= get_arm_segment_type (p_type
);
3841 case EM_MIPS_RS3_LE
:
3842 result
= get_mips_segment_type (p_type
);
3845 result
= get_parisc_segment_type (p_type
);
3848 result
= get_ia64_segment_type (p_type
);
3851 result
= get_tic6x_segment_type (p_type
);
3861 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3863 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3865 const char * result
;
3867 switch (elf_header
.e_machine
)
3870 result
= get_parisc_segment_type (p_type
);
3873 result
= get_ia64_segment_type (p_type
);
3876 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3877 result
= get_solaris_segment_type (p_type
);
3886 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3889 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3896 get_mips_section_type_name (unsigned int sh_type
)
3900 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3901 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3902 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3903 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3904 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3905 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3906 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3907 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3908 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3909 case SHT_MIPS_RELD
: return "MIPS_RELD";
3910 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3911 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3912 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3913 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3914 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3915 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3916 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3917 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3918 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3919 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3920 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3921 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3922 case SHT_MIPS_LINE
: return "MIPS_LINE";
3923 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3924 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3925 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3926 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3927 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3928 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3929 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3930 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3931 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3932 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3933 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3934 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3935 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3936 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3937 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3938 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3939 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3947 get_parisc_section_type_name (unsigned int sh_type
)
3951 case SHT_PARISC_EXT
: return "PARISC_EXT";
3952 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3953 case SHT_PARISC_DOC
: return "PARISC_DOC";
3954 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3955 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3956 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3957 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3958 default: return NULL
;
3963 get_ia64_section_type_name (unsigned int sh_type
)
3965 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3966 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3967 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3971 case SHT_IA_64_EXT
: return "IA_64_EXT";
3972 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3973 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3974 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3975 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3976 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3977 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3978 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3979 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3980 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3988 get_x86_64_section_type_name (unsigned int sh_type
)
3992 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3993 default: return NULL
;
3998 get_aarch64_section_type_name (unsigned int sh_type
)
4002 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4003 default: return NULL
;
4008 get_arm_section_type_name (unsigned int sh_type
)
4012 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4013 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4014 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4015 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4016 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4017 default: return NULL
;
4022 get_tic6x_section_type_name (unsigned int sh_type
)
4026 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4027 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4028 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4029 case SHT_TI_ICODE
: return "TI_ICODE";
4030 case SHT_TI_XREF
: return "TI_XREF";
4031 case SHT_TI_HANDLER
: return "TI_HANDLER";
4032 case SHT_TI_INITINFO
: return "TI_INITINFO";
4033 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4034 default: return NULL
;
4039 get_msp430x_section_type_name (unsigned int sh_type
)
4043 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4044 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4045 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4046 default: return NULL
;
4051 get_v850_section_type_name (unsigned int sh_type
)
4055 case SHT_V850_SCOMMON
: return "V850 Small Common";
4056 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4057 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4058 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4059 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4060 default: return NULL
;
4065 get_section_type_name (unsigned int sh_type
)
4067 static char buff
[32];
4068 const char * result
;
4072 case SHT_NULL
: return "NULL";
4073 case SHT_PROGBITS
: return "PROGBITS";
4074 case SHT_SYMTAB
: return "SYMTAB";
4075 case SHT_STRTAB
: return "STRTAB";
4076 case SHT_RELA
: return "RELA";
4077 case SHT_HASH
: return "HASH";
4078 case SHT_DYNAMIC
: return "DYNAMIC";
4079 case SHT_NOTE
: return "NOTE";
4080 case SHT_NOBITS
: return "NOBITS";
4081 case SHT_REL
: return "REL";
4082 case SHT_SHLIB
: return "SHLIB";
4083 case SHT_DYNSYM
: return "DYNSYM";
4084 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4085 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4086 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4087 case SHT_GNU_HASH
: return "GNU_HASH";
4088 case SHT_GROUP
: return "GROUP";
4089 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4090 case SHT_GNU_verdef
: return "VERDEF";
4091 case SHT_GNU_verneed
: return "VERNEED";
4092 case SHT_GNU_versym
: return "VERSYM";
4093 case 0x6ffffff0: return "VERSYM";
4094 case 0x6ffffffc: return "VERDEF";
4095 case 0x7ffffffd: return "AUXILIARY";
4096 case 0x7fffffff: return "FILTER";
4097 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4100 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4102 switch (elf_header
.e_machine
)
4105 case EM_MIPS_RS3_LE
:
4106 result
= get_mips_section_type_name (sh_type
);
4109 result
= get_parisc_section_type_name (sh_type
);
4112 result
= get_ia64_section_type_name (sh_type
);
4117 result
= get_x86_64_section_type_name (sh_type
);
4120 result
= get_aarch64_section_type_name (sh_type
);
4123 result
= get_arm_section_type_name (sh_type
);
4126 result
= get_tic6x_section_type_name (sh_type
);
4129 result
= get_msp430x_section_type_name (sh_type
);
4133 case EM_CYGNUS_V850
:
4134 result
= get_v850_section_type_name (sh_type
);
4144 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4146 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4148 switch (elf_header
.e_machine
)
4151 result
= get_ia64_section_type_name (sh_type
);
4154 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4155 result
= get_solaris_section_type (sh_type
);
4160 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4161 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4162 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4163 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4175 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4177 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4179 switch (elf_header
.e_machine
)
4183 case EM_CYGNUS_V850
:
4184 result
= get_v850_section_type_name (sh_type
);
4194 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4197 /* This message is probably going to be displayed in a 15
4198 character wide field, so put the hex value first. */
4199 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4205 #define OPTION_DEBUG_DUMP 512
4206 #define OPTION_DYN_SYMS 513
4207 #define OPTION_DWARF_DEPTH 514
4208 #define OPTION_DWARF_START 515
4209 #define OPTION_DWARF_CHECK 516
4211 static struct option options
[] =
4213 {"all", no_argument
, 0, 'a'},
4214 {"file-header", no_argument
, 0, 'h'},
4215 {"program-headers", no_argument
, 0, 'l'},
4216 {"headers", no_argument
, 0, 'e'},
4217 {"histogram", no_argument
, 0, 'I'},
4218 {"segments", no_argument
, 0, 'l'},
4219 {"sections", no_argument
, 0, 'S'},
4220 {"section-headers", no_argument
, 0, 'S'},
4221 {"section-groups", no_argument
, 0, 'g'},
4222 {"section-details", no_argument
, 0, 't'},
4223 {"full-section-name",no_argument
, 0, 'N'},
4224 {"symbols", no_argument
, 0, 's'},
4225 {"syms", no_argument
, 0, 's'},
4226 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4227 {"relocs", no_argument
, 0, 'r'},
4228 {"notes", no_argument
, 0, 'n'},
4229 {"dynamic", no_argument
, 0, 'd'},
4230 {"arch-specific", no_argument
, 0, 'A'},
4231 {"version-info", no_argument
, 0, 'V'},
4232 {"use-dynamic", no_argument
, 0, 'D'},
4233 {"unwind", no_argument
, 0, 'u'},
4234 {"archive-index", no_argument
, 0, 'c'},
4235 {"hex-dump", required_argument
, 0, 'x'},
4236 {"relocated-dump", required_argument
, 0, 'R'},
4237 {"string-dump", required_argument
, 0, 'p'},
4238 {"decompress", no_argument
, 0, 'z'},
4239 #ifdef SUPPORT_DISASSEMBLY
4240 {"instruction-dump", required_argument
, 0, 'i'},
4242 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4244 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4245 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4246 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4248 {"version", no_argument
, 0, 'v'},
4249 {"wide", no_argument
, 0, 'W'},
4250 {"help", no_argument
, 0, 'H'},
4251 {0, no_argument
, 0, 0}
4255 usage (FILE * stream
)
4257 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4258 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4259 fprintf (stream
, _(" Options are:\n\
4260 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4261 -h --file-header Display the ELF file header\n\
4262 -l --program-headers Display the program headers\n\
4263 --segments An alias for --program-headers\n\
4264 -S --section-headers Display the sections' header\n\
4265 --sections An alias for --section-headers\n\
4266 -g --section-groups Display the section groups\n\
4267 -t --section-details Display the section details\n\
4268 -e --headers Equivalent to: -h -l -S\n\
4269 -s --syms Display the symbol table\n\
4270 --symbols An alias for --syms\n\
4271 --dyn-syms Display the dynamic symbol table\n\
4272 -n --notes Display the core notes (if present)\n\
4273 -r --relocs Display the relocations (if present)\n\
4274 -u --unwind Display the unwind info (if present)\n\
4275 -d --dynamic Display the dynamic section (if present)\n\
4276 -V --version-info Display the version sections (if present)\n\
4277 -A --arch-specific Display architecture specific information (if any)\n\
4278 -c --archive-index Display the symbol/file index in an archive\n\
4279 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4280 -x --hex-dump=<number|name>\n\
4281 Dump the contents of section <number|name> as bytes\n\
4282 -p --string-dump=<number|name>\n\
4283 Dump the contents of section <number|name> as strings\n\
4284 -R --relocated-dump=<number|name>\n\
4285 Dump the contents of section <number|name> as relocated bytes\n\
4286 -z --decompress Decompress section before dumping it\n\
4287 -w[lLiaprmfFsoRt] or\n\
4288 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4289 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4290 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4292 Display the contents of DWARF2 debug sections\n"));
4293 fprintf (stream
, _("\
4294 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4295 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4297 #ifdef SUPPORT_DISASSEMBLY
4298 fprintf (stream
, _("\
4299 -i --instruction-dump=<number|name>\n\
4300 Disassemble the contents of section <number|name>\n"));
4302 fprintf (stream
, _("\
4303 -I --histogram Display histogram of bucket list lengths\n\
4304 -W --wide Allow output width to exceed 80 characters\n\
4305 @<file> Read options from <file>\n\
4306 -H --help Display this information\n\
4307 -v --version Display the version number of readelf\n"));
4309 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4310 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4312 exit (stream
== stdout
? 0 : 1);
4315 /* Record the fact that the user wants the contents of section number
4316 SECTION to be displayed using the method(s) encoded as flags bits
4317 in TYPE. Note, TYPE can be zero if we are creating the array for
4321 request_dump_bynumber (unsigned int section
, dump_type type
)
4323 if (section
>= num_dump_sects
)
4325 dump_type
* new_dump_sects
;
4327 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4328 sizeof (* dump_sects
));
4330 if (new_dump_sects
== NULL
)
4331 error (_("Out of memory allocating dump request table.\n"));
4336 /* Copy current flag settings. */
4337 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4342 dump_sects
= new_dump_sects
;
4343 num_dump_sects
= section
+ 1;
4348 dump_sects
[section
] |= type
;
4353 /* Request a dump by section name. */
4356 request_dump_byname (const char * section
, dump_type type
)
4358 struct dump_list_entry
* new_request
;
4360 new_request
= (struct dump_list_entry
*)
4361 malloc (sizeof (struct dump_list_entry
));
4363 error (_("Out of memory allocating dump request table.\n"));
4365 new_request
->name
= strdup (section
);
4366 if (!new_request
->name
)
4367 error (_("Out of memory allocating dump request table.\n"));
4369 new_request
->type
= type
;
4371 new_request
->next
= dump_sects_byname
;
4372 dump_sects_byname
= new_request
;
4376 request_dump (dump_type type
)
4382 section
= strtoul (optarg
, & cp
, 0);
4384 if (! *cp
&& section
>= 0)
4385 request_dump_bynumber (section
, type
);
4387 request_dump_byname (optarg
, type
);
4392 parse_args (int argc
, char ** argv
)
4399 while ((c
= getopt_long
4400 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4418 do_section_groups
= TRUE
;
4421 do_histogram
= TRUE
;
4426 do_section_groups
= TRUE
;
4431 do_section_details
= TRUE
;
4442 do_using_dynamic
= TRUE
;
4466 do_histogram
= TRUE
;
4472 do_archive_index
= TRUE
;
4475 request_dump (HEX_DUMP
);
4478 request_dump (STRING_DUMP
);
4481 request_dump (RELOC_DUMP
);
4484 decompress_dumps
= TRUE
;
4490 do_debugging
= TRUE
;
4491 dwarf_select_sections_all ();
4495 do_debugging
= FALSE
;
4496 dwarf_select_sections_by_letters (optarg
);
4499 case OPTION_DEBUG_DUMP
:
4502 do_debugging
= TRUE
;
4505 do_debugging
= FALSE
;
4506 dwarf_select_sections_by_names (optarg
);
4509 case OPTION_DWARF_DEPTH
:
4513 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4516 case OPTION_DWARF_START
:
4520 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4523 case OPTION_DWARF_CHECK
:
4526 case OPTION_DYN_SYMS
:
4529 #ifdef SUPPORT_DISASSEMBLY
4531 request_dump (DISASS_DUMP
);
4535 print_version (program_name
);
4544 /* xgettext:c-format */
4545 error (_("Invalid option '-%c'\n"), c
);
4552 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4553 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4554 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4555 && !do_section_groups
&& !do_archive_index
4561 get_elf_class (unsigned int elf_class
)
4563 static char buff
[32];
4567 case ELFCLASSNONE
: return _("none");
4568 case ELFCLASS32
: return "ELF32";
4569 case ELFCLASS64
: return "ELF64";
4571 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4577 get_data_encoding (unsigned int encoding
)
4579 static char buff
[32];
4583 case ELFDATANONE
: return _("none");
4584 case ELFDATA2LSB
: return _("2's complement, little endian");
4585 case ELFDATA2MSB
: return _("2's complement, big endian");
4587 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4592 /* Decode the data held in 'elf_header'. */
4595 process_file_header (void)
4597 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4598 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4599 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4600 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4603 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4607 init_dwarf_regnames (elf_header
.e_machine
);
4613 printf (_("ELF Header:\n"));
4614 printf (_(" Magic: "));
4615 for (i
= 0; i
< EI_NIDENT
; i
++)
4616 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4618 printf (_(" Class: %s\n"),
4619 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4620 printf (_(" Data: %s\n"),
4621 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4622 printf (_(" Version: %d %s\n"),
4623 elf_header
.e_ident
[EI_VERSION
],
4624 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4626 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4627 ? _("<unknown: %lx>")
4629 printf (_(" OS/ABI: %s\n"),
4630 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4631 printf (_(" ABI Version: %d\n"),
4632 elf_header
.e_ident
[EI_ABIVERSION
]);
4633 printf (_(" Type: %s\n"),
4634 get_file_type (elf_header
.e_type
));
4635 printf (_(" Machine: %s\n"),
4636 get_machine_name (elf_header
.e_machine
));
4637 printf (_(" Version: 0x%lx\n"),
4638 (unsigned long) elf_header
.e_version
);
4640 printf (_(" Entry point address: "));
4641 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4642 printf (_("\n Start of program headers: "));
4643 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4644 printf (_(" (bytes into file)\n Start of section headers: "));
4645 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4646 printf (_(" (bytes into file)\n"));
4648 printf (_(" Flags: 0x%lx%s\n"),
4649 (unsigned long) elf_header
.e_flags
,
4650 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4651 printf (_(" Size of this header: %ld (bytes)\n"),
4652 (long) elf_header
.e_ehsize
);
4653 printf (_(" Size of program headers: %ld (bytes)\n"),
4654 (long) elf_header
.e_phentsize
);
4655 printf (_(" Number of program headers: %ld"),
4656 (long) elf_header
.e_phnum
);
4657 if (section_headers
!= NULL
4658 && elf_header
.e_phnum
== PN_XNUM
4659 && section_headers
[0].sh_info
!= 0)
4660 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4661 putc ('\n', stdout
);
4662 printf (_(" Size of section headers: %ld (bytes)\n"),
4663 (long) elf_header
.e_shentsize
);
4664 printf (_(" Number of section headers: %ld"),
4665 (long) elf_header
.e_shnum
);
4666 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4667 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4668 putc ('\n', stdout
);
4669 printf (_(" Section header string table index: %ld"),
4670 (long) elf_header
.e_shstrndx
);
4671 if (section_headers
!= NULL
4672 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4673 printf (" (%u)", section_headers
[0].sh_link
);
4674 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4675 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4676 printf (_(" <corrupt: out of range>"));
4677 putc ('\n', stdout
);
4680 if (section_headers
!= NULL
)
4682 if (elf_header
.e_phnum
== PN_XNUM
4683 && section_headers
[0].sh_info
!= 0)
4684 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4685 if (elf_header
.e_shnum
== SHN_UNDEF
)
4686 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4687 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4688 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4689 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4690 elf_header
.e_shstrndx
= SHN_UNDEF
;
4691 free (section_headers
);
4692 section_headers
= NULL
;
4699 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4701 Elf32_External_Phdr
* phdrs
;
4702 Elf32_External_Phdr
* external
;
4703 Elf_Internal_Phdr
* internal
;
4705 unsigned int size
= elf_header
.e_phentsize
;
4706 unsigned int num
= elf_header
.e_phnum
;
4708 /* PR binutils/17531: Cope with unexpected section header sizes. */
4709 if (size
== 0 || num
== 0)
4711 if (size
< sizeof * phdrs
)
4713 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4716 if (size
> sizeof * phdrs
)
4717 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4719 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4720 size
, num
, _("program headers"));
4724 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4725 i
< elf_header
.e_phnum
;
4726 i
++, internal
++, external
++)
4728 internal
->p_type
= BYTE_GET (external
->p_type
);
4729 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4730 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4731 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4732 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4733 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4734 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4735 internal
->p_align
= BYTE_GET (external
->p_align
);
4743 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4745 Elf64_External_Phdr
* phdrs
;
4746 Elf64_External_Phdr
* external
;
4747 Elf_Internal_Phdr
* internal
;
4749 unsigned int size
= elf_header
.e_phentsize
;
4750 unsigned int num
= elf_header
.e_phnum
;
4752 /* PR binutils/17531: Cope with unexpected section header sizes. */
4753 if (size
== 0 || num
== 0)
4755 if (size
< sizeof * phdrs
)
4757 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4760 if (size
> sizeof * phdrs
)
4761 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4763 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4764 size
, num
, _("program headers"));
4768 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4769 i
< elf_header
.e_phnum
;
4770 i
++, internal
++, external
++)
4772 internal
->p_type
= BYTE_GET (external
->p_type
);
4773 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4774 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4775 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4776 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4777 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4778 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4779 internal
->p_align
= BYTE_GET (external
->p_align
);
4786 /* Returns TRUE if the program headers were read into `program_headers'. */
4789 get_program_headers (FILE * file
)
4791 Elf_Internal_Phdr
* phdrs
;
4793 /* Check cache of prior read. */
4794 if (program_headers
!= NULL
)
4797 /* Be kind to memory checkers by looking for
4798 e_phnum values which we know must be invalid. */
4799 if (elf_header
.e_phnum
4800 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4801 >= current_file_size
)
4803 error (_("Too many program headers - %#x - the file is not that big\n"),
4804 elf_header
.e_phnum
);
4808 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4809 sizeof (Elf_Internal_Phdr
));
4812 error (_("Out of memory reading %u program headers\n"),
4813 elf_header
.e_phnum
);
4818 ? get_32bit_program_headers (file
, phdrs
)
4819 : get_64bit_program_headers (file
, phdrs
))
4821 program_headers
= phdrs
;
4829 /* Returns TRUE if the program headers were loaded. */
4832 process_program_headers (FILE * file
)
4834 Elf_Internal_Phdr
* segment
;
4836 Elf_Internal_Phdr
* previous_load
= NULL
;
4838 if (elf_header
.e_phnum
== 0)
4840 /* PR binutils/12467. */
4841 if (elf_header
.e_phoff
!= 0)
4843 warn (_("possibly corrupt ELF header - it has a non-zero program"
4844 " header offset, but no program headers\n"));
4847 else if (do_segments
)
4848 printf (_("\nThere are no program headers in this file.\n"));
4852 if (do_segments
&& !do_header
)
4854 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4855 printf (_("Entry point "));
4856 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4857 printf (_("\nThere are %d program headers, starting at offset "),
4858 elf_header
.e_phnum
);
4859 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4863 if (! get_program_headers (file
))
4868 if (elf_header
.e_phnum
> 1)
4869 printf (_("\nProgram Headers:\n"));
4871 printf (_("\nProgram Headers:\n"));
4875 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4878 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4882 (_(" Type Offset VirtAddr PhysAddr\n"));
4884 (_(" FileSiz MemSiz Flags Align\n"));
4891 for (i
= 0, segment
= program_headers
;
4892 i
< elf_header
.e_phnum
;
4897 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4901 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4902 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4903 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4904 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4905 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4907 (segment
->p_flags
& PF_R
? 'R' : ' '),
4908 (segment
->p_flags
& PF_W
? 'W' : ' '),
4909 (segment
->p_flags
& PF_X
? 'E' : ' '));
4910 printf ("%#lx", (unsigned long) segment
->p_align
);
4914 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4915 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4918 print_vma (segment
->p_offset
, FULL_HEX
);
4922 print_vma (segment
->p_vaddr
, FULL_HEX
);
4924 print_vma (segment
->p_paddr
, FULL_HEX
);
4927 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4928 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4931 print_vma (segment
->p_filesz
, FULL_HEX
);
4935 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4936 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4939 print_vma (segment
->p_memsz
, FULL_HEX
);
4943 (segment
->p_flags
& PF_R
? 'R' : ' '),
4944 (segment
->p_flags
& PF_W
? 'W' : ' '),
4945 (segment
->p_flags
& PF_X
? 'E' : ' '));
4947 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4948 printf ("%#lx", (unsigned long) segment
->p_align
);
4951 print_vma (segment
->p_align
, PREFIX_HEX
);
4956 print_vma (segment
->p_offset
, FULL_HEX
);
4958 print_vma (segment
->p_vaddr
, FULL_HEX
);
4960 print_vma (segment
->p_paddr
, FULL_HEX
);
4962 print_vma (segment
->p_filesz
, FULL_HEX
);
4964 print_vma (segment
->p_memsz
, FULL_HEX
);
4966 (segment
->p_flags
& PF_R
? 'R' : ' '),
4967 (segment
->p_flags
& PF_W
? 'W' : ' '),
4968 (segment
->p_flags
& PF_X
? 'E' : ' '));
4969 print_vma (segment
->p_align
, PREFIX_HEX
);
4972 putc ('\n', stdout
);
4975 switch (segment
->p_type
)
4978 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4979 required by the ELF standard, several programs, including the Linux
4980 kernel, make use of non-ordered segments. */
4982 && previous_load
->p_vaddr
> segment
->p_vaddr
)
4983 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4985 if (segment
->p_memsz
< segment
->p_filesz
)
4986 error (_("the segment's file size is larger than its memory size\n"));
4987 previous_load
= segment
;
4991 /* PR 20815 - Verify that the program header is loaded into memory. */
4992 if (i
> 0 && previous_load
!= NULL
)
4993 error (_("the PHDR segment must occur before any LOAD segment\n"));
4994 if (elf_header
.e_machine
!= EM_PARISC
)
4998 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
4999 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5000 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
5001 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5003 if (j
== elf_header
.e_phnum
)
5004 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5010 error (_("more than one dynamic segment\n"));
5012 /* By default, assume that the .dynamic section is the first
5013 section in the DYNAMIC segment. */
5014 dynamic_addr
= segment
->p_offset
;
5015 dynamic_size
= segment
->p_filesz
;
5017 /* Try to locate the .dynamic section. If there is
5018 a section header table, we can easily locate it. */
5019 if (section_headers
!= NULL
)
5021 Elf_Internal_Shdr
* sec
;
5023 sec
= find_section (".dynamic");
5024 if (sec
== NULL
|| sec
->sh_size
== 0)
5026 /* A corresponding .dynamic section is expected, but on
5027 IA-64/OpenVMS it is OK for it to be missing. */
5028 if (!is_ia64_vms ())
5029 error (_("no .dynamic section in the dynamic segment\n"));
5033 if (sec
->sh_type
== SHT_NOBITS
)
5039 dynamic_addr
= sec
->sh_offset
;
5040 dynamic_size
= sec
->sh_size
;
5042 if (dynamic_addr
< segment
->p_offset
5043 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5044 warn (_("the .dynamic section is not contained"
5045 " within the dynamic segment\n"));
5046 else if (dynamic_addr
> segment
->p_offset
)
5047 warn (_("the .dynamic section is not the first section"
5048 " in the dynamic segment.\n"));
5051 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5052 segment. Check this after matching against the section headers
5053 so we don't warn on debuginfo file (which have NOBITS .dynamic
5055 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5057 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5058 dynamic_addr
= dynamic_size
= 0;
5063 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5065 error (_("Unable to find program interpreter name\n"));
5069 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5071 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5072 error (_("Internal error: failed to create format string to display program interpreter\n"));
5074 program_interpreter
[0] = 0;
5075 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5076 error (_("Unable to read program interpreter name\n"));
5079 printf (_(" [Requesting program interpreter: %s]\n"),
5080 program_interpreter
);
5086 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5088 printf (_("\n Section to Segment mapping:\n"));
5089 printf (_(" Segment Sections...\n"));
5091 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5094 Elf_Internal_Shdr
* section
;
5096 segment
= program_headers
+ i
;
5097 section
= section_headers
+ 1;
5099 printf (" %2.2d ", i
);
5101 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5103 if (!ELF_TBSS_SPECIAL (section
, segment
)
5104 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5105 printf ("%s ", printable_section_name (section
));
5116 /* Find the file offset corresponding to VMA by using the program headers. */
5119 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5121 Elf_Internal_Phdr
* seg
;
5123 if (! get_program_headers (file
))
5125 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5129 for (seg
= program_headers
;
5130 seg
< program_headers
+ elf_header
.e_phnum
;
5133 if (seg
->p_type
!= PT_LOAD
)
5136 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5137 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5138 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5141 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5142 (unsigned long) vma
);
5147 /* Allocate memory and load the sections headers into the global pointer
5148 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5149 generate any error messages if the load fails. */
5152 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5154 Elf32_External_Shdr
* shdrs
;
5155 Elf_Internal_Shdr
* internal
;
5157 unsigned int size
= elf_header
.e_shentsize
;
5158 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5160 /* PR binutils/17531: Cope with unexpected section header sizes. */
5161 if (size
== 0 || num
== 0)
5163 if (size
< sizeof * shdrs
)
5166 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5169 if (!probe
&& size
> sizeof * shdrs
)
5170 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5172 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5174 probe
? NULL
: _("section headers"));
5178 if (section_headers
!= NULL
)
5179 free (section_headers
);
5180 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5181 sizeof (Elf_Internal_Shdr
));
5182 if (section_headers
== NULL
)
5185 error (_("Out of memory reading %u section headers\n"), num
);
5189 for (i
= 0, internal
= section_headers
;
5193 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5194 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5195 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5196 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5197 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5198 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5199 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5200 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5201 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5202 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5203 if (!probe
&& internal
->sh_link
> num
)
5204 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5205 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5206 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5214 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5216 Elf64_External_Shdr
* shdrs
;
5217 Elf_Internal_Shdr
* internal
;
5219 unsigned int size
= elf_header
.e_shentsize
;
5220 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5222 /* PR binutils/17531: Cope with unexpected section header sizes. */
5223 if (size
== 0 || num
== 0)
5225 if (size
< sizeof * shdrs
)
5228 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5231 if (! probe
&& size
> sizeof * shdrs
)
5232 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5234 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5236 probe
? NULL
: _("section headers"));
5240 if (section_headers
!= NULL
)
5241 free (section_headers
);
5242 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5243 sizeof (Elf_Internal_Shdr
));
5244 if (section_headers
== NULL
)
5247 error (_("Out of memory reading %u section headers\n"), num
);
5251 for (i
= 0, internal
= section_headers
;
5255 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5256 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5257 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5258 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5259 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5260 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5261 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5262 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5263 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5264 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5265 if (!probe
&& internal
->sh_link
> num
)
5266 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5267 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5268 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5275 static Elf_Internal_Sym
*
5276 get_32bit_elf_symbols (FILE * file
,
5277 Elf_Internal_Shdr
* section
,
5278 unsigned long * num_syms_return
)
5280 unsigned long number
= 0;
5281 Elf32_External_Sym
* esyms
= NULL
;
5282 Elf_External_Sym_Shndx
* shndx
= NULL
;
5283 Elf_Internal_Sym
* isyms
= NULL
;
5284 Elf_Internal_Sym
* psym
;
5287 if (section
->sh_size
== 0)
5289 if (num_syms_return
!= NULL
)
5290 * num_syms_return
= 0;
5294 /* Run some sanity checks first. */
5295 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5297 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5298 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5302 if (section
->sh_size
> current_file_size
)
5304 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5305 printable_section_name (section
), (unsigned long) section
->sh_size
);
5309 number
= section
->sh_size
/ section
->sh_entsize
;
5311 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5313 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5314 (unsigned long) section
->sh_size
,
5315 printable_section_name (section
),
5316 (unsigned long) section
->sh_entsize
);
5320 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5321 section
->sh_size
, _("symbols"));
5326 elf_section_list
* entry
;
5329 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5330 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5332 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5333 entry
->hdr
->sh_offset
,
5334 1, entry
->hdr
->sh_size
,
5335 _("symbol table section indicies"));
5338 /* PR17531: file: heap-buffer-overflow */
5339 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5341 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5342 printable_section_name (entry
->hdr
),
5343 (unsigned long) entry
->hdr
->sh_size
,
5344 (unsigned long) section
->sh_size
);
5350 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5354 error (_("Out of memory reading %lu symbols\n"),
5355 (unsigned long) number
);
5359 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5361 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5362 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5363 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5364 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5365 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5367 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5368 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5369 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5370 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5371 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5380 if (num_syms_return
!= NULL
)
5381 * num_syms_return
= isyms
== NULL
? 0 : number
;
5386 static Elf_Internal_Sym
*
5387 get_64bit_elf_symbols (FILE * file
,
5388 Elf_Internal_Shdr
* section
,
5389 unsigned long * num_syms_return
)
5391 unsigned long number
= 0;
5392 Elf64_External_Sym
* esyms
= NULL
;
5393 Elf_External_Sym_Shndx
* shndx
= NULL
;
5394 Elf_Internal_Sym
* isyms
= NULL
;
5395 Elf_Internal_Sym
* psym
;
5398 if (section
->sh_size
== 0)
5400 if (num_syms_return
!= NULL
)
5401 * num_syms_return
= 0;
5405 /* Run some sanity checks first. */
5406 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5408 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5409 printable_section_name (section
),
5410 (unsigned long) section
->sh_entsize
);
5414 if (section
->sh_size
> current_file_size
)
5416 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5417 printable_section_name (section
),
5418 (unsigned long) section
->sh_size
);
5422 number
= section
->sh_size
/ section
->sh_entsize
;
5424 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5426 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5427 (unsigned long) section
->sh_size
,
5428 printable_section_name (section
),
5429 (unsigned long) section
->sh_entsize
);
5433 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5434 section
->sh_size
, _("symbols"));
5439 elf_section_list
* entry
;
5442 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5443 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5445 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5446 entry
->hdr
->sh_offset
,
5447 1, entry
->hdr
->sh_size
,
5448 _("symbol table section indicies"));
5451 /* PR17531: file: heap-buffer-overflow */
5452 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5454 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5455 printable_section_name (entry
->hdr
),
5456 (unsigned long) entry
->hdr
->sh_size
,
5457 (unsigned long) section
->sh_size
);
5463 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5467 error (_("Out of memory reading %lu symbols\n"),
5468 (unsigned long) number
);
5472 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5474 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5475 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5476 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5477 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5479 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5481 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5482 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5483 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5485 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5486 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5495 if (num_syms_return
!= NULL
)
5496 * num_syms_return
= isyms
== NULL
? 0 : number
;
5502 get_elf_section_flags (bfd_vma sh_flags
)
5504 static char buff
[1024];
5506 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5508 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5509 bfd_vma os_flags
= 0;
5510 bfd_vma proc_flags
= 0;
5511 bfd_vma unknown_flags
= 0;
5519 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5520 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5521 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5522 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5523 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5524 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5525 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5526 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5527 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5528 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5529 /* IA-64 specific. */
5530 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5531 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5532 /* IA-64 OpenVMS specific. */
5533 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5534 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5535 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5536 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5537 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5538 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5540 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5541 /* SPARC specific. */
5542 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5543 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5545 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5546 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5547 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5550 if (do_section_details
)
5552 sprintf (buff
, "[%*.*lx]: ",
5553 field_size
, field_size
, (unsigned long) sh_flags
);
5554 p
+= field_size
+ 4;
5561 flag
= sh_flags
& - sh_flags
;
5564 if (do_section_details
)
5568 case SHF_WRITE
: sindex
= 0; break;
5569 case SHF_ALLOC
: sindex
= 1; break;
5570 case SHF_EXECINSTR
: sindex
= 2; break;
5571 case SHF_MERGE
: sindex
= 3; break;
5572 case SHF_STRINGS
: sindex
= 4; break;
5573 case SHF_INFO_LINK
: sindex
= 5; break;
5574 case SHF_LINK_ORDER
: sindex
= 6; break;
5575 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5576 case SHF_GROUP
: sindex
= 8; break;
5577 case SHF_TLS
: sindex
= 9; break;
5578 case SHF_EXCLUDE
: sindex
= 18; break;
5579 case SHF_COMPRESSED
: sindex
= 20; break;
5583 switch (elf_header
.e_machine
)
5586 if (flag
== SHF_IA_64_SHORT
)
5588 else if (flag
== SHF_IA_64_NORECOV
)
5591 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5594 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5595 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5596 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5597 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5598 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5599 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5610 case EM_OLD_SPARCV9
:
5611 case EM_SPARC32PLUS
:
5614 if (flag
== SHF_ORDERED
)
5621 case SHF_ENTRYSECT
: sindex
= 21; break;
5622 case SHF_ARM_PURECODE
: sindex
= 22; break;
5623 case SHF_COMDEF
: sindex
= 23; break;
5635 if (p
!= buff
+ field_size
+ 4)
5637 if (size
< (10 + 2))
5639 warn (_("Internal error: not enough buffer room for section flag info"));
5640 return _("<unknown>");
5647 size
-= flags
[sindex
].len
;
5648 p
= stpcpy (p
, flags
[sindex
].str
);
5650 else if (flag
& SHF_MASKOS
)
5652 else if (flag
& SHF_MASKPROC
)
5655 unknown_flags
|= flag
;
5661 case SHF_WRITE
: *p
= 'W'; break;
5662 case SHF_ALLOC
: *p
= 'A'; break;
5663 case SHF_EXECINSTR
: *p
= 'X'; break;
5664 case SHF_MERGE
: *p
= 'M'; break;
5665 case SHF_STRINGS
: *p
= 'S'; break;
5666 case SHF_INFO_LINK
: *p
= 'I'; break;
5667 case SHF_LINK_ORDER
: *p
= 'L'; break;
5668 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5669 case SHF_GROUP
: *p
= 'G'; break;
5670 case SHF_TLS
: *p
= 'T'; break;
5671 case SHF_EXCLUDE
: *p
= 'E'; break;
5672 case SHF_COMPRESSED
: *p
= 'C'; break;
5675 if ((elf_header
.e_machine
== EM_X86_64
5676 || elf_header
.e_machine
== EM_L1OM
5677 || elf_header
.e_machine
== EM_K1OM
)
5678 && flag
== SHF_X86_64_LARGE
)
5680 else if (elf_header
.e_machine
== EM_ARM
5681 && flag
== SHF_ARM_PURECODE
)
5683 else if (flag
& SHF_MASKOS
)
5686 sh_flags
&= ~ SHF_MASKOS
;
5688 else if (flag
& SHF_MASKPROC
)
5691 sh_flags
&= ~ SHF_MASKPROC
;
5701 if (do_section_details
)
5705 size
-= 5 + field_size
;
5706 if (p
!= buff
+ field_size
+ 4)
5710 warn (_("Internal error: not enough buffer room for section flag info"));
5711 return _("<unknown>");
5717 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5718 (unsigned long) os_flags
);
5719 p
+= 5 + field_size
;
5723 size
-= 7 + field_size
;
5724 if (p
!= buff
+ field_size
+ 4)
5728 warn (_("Internal error: not enough buffer room for section flag info"));
5729 return _("<unknown>");
5735 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5736 (unsigned long) proc_flags
);
5737 p
+= 7 + field_size
;
5741 size
-= 10 + field_size
;
5742 if (p
!= buff
+ field_size
+ 4)
5746 warn (_("Internal error: not enough buffer room for section flag info"));
5747 return _("<unknown>");
5753 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5754 (unsigned long) unknown_flags
);
5755 p
+= 10 + field_size
;
5764 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5768 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5770 if (size
< sizeof (* echdr
))
5772 error (_("Compressed section is too small even for a compression header\n"));
5776 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5777 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5778 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5779 return sizeof (*echdr
);
5783 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5785 if (size
< sizeof (* echdr
))
5787 error (_("Compressed section is too small even for a compression header\n"));
5791 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5792 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5793 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5794 return sizeof (*echdr
);
5799 process_section_headers (FILE * file
)
5801 Elf_Internal_Shdr
* section
;
5804 section_headers
= NULL
;
5806 if (elf_header
.e_shnum
== 0)
5808 /* PR binutils/12467. */
5809 if (elf_header
.e_shoff
!= 0)
5811 warn (_("possibly corrupt ELF file header - it has a non-zero"
5812 " section header offset, but no section headers\n"));
5815 else if (do_sections
)
5816 printf (_("\nThere are no sections in this file.\n"));
5821 if (do_sections
&& !do_header
)
5822 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5823 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5827 if (! get_32bit_section_headers (file
, FALSE
))
5832 if (! get_64bit_section_headers (file
, FALSE
))
5836 /* Read in the string table, so that we have names to display. */
5837 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5838 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5840 section
= section_headers
+ elf_header
.e_shstrndx
;
5842 if (section
->sh_size
!= 0)
5844 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5845 1, section
->sh_size
,
5848 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5852 /* Scan the sections for the dynamic symbol table
5853 and dynamic string table and debug sections. */
5854 dynamic_symbols
= NULL
;
5855 dynamic_strings
= NULL
;
5856 dynamic_syminfo
= NULL
;
5857 symtab_shndx_list
= NULL
;
5859 eh_addr_size
= is_32bit_elf
? 4 : 8;
5860 switch (elf_header
.e_machine
)
5863 case EM_MIPS_RS3_LE
:
5864 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5865 FDE addresses. However, the ABI also has a semi-official ILP32
5866 variant for which the normal FDE address size rules apply.
5868 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5869 section, where XX is the size of longs in bits. Unfortunately,
5870 earlier compilers provided no way of distinguishing ILP32 objects
5871 from LP64 objects, so if there's any doubt, we should assume that
5872 the official LP64 form is being used. */
5873 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5874 && find_section (".gcc_compiled_long32") == NULL
)
5880 switch (elf_header
.e_flags
& EF_H8_MACH
)
5882 case E_H8_MACH_H8300
:
5883 case E_H8_MACH_H8300HN
:
5884 case E_H8_MACH_H8300SN
:
5885 case E_H8_MACH_H8300SXN
:
5888 case E_H8_MACH_H8300H
:
5889 case E_H8_MACH_H8300S
:
5890 case E_H8_MACH_H8300SX
:
5898 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5900 case EF_M32C_CPU_M16C
:
5907 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5910 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5911 if (section->sh_entsize != expected_entsize) \
5914 sprintf_vma (buf, section->sh_entsize); \
5915 /* Note: coded this way so that there is a single string for \
5917 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5918 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5919 (unsigned) expected_entsize); \
5920 section->sh_entsize = expected_entsize; \
5925 #define CHECK_ENTSIZE(section, i, type) \
5926 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5927 sizeof (Elf64_External_##type))
5929 for (i
= 0, section
= section_headers
;
5930 i
< elf_header
.e_shnum
;
5933 char * name
= SECTION_NAME (section
);
5935 if (section
->sh_type
== SHT_DYNSYM
)
5937 if (dynamic_symbols
!= NULL
)
5939 error (_("File contains multiple dynamic symbol tables\n"));
5943 CHECK_ENTSIZE (section
, i
, Sym
);
5944 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5946 else if (section
->sh_type
== SHT_STRTAB
5947 && streq (name
, ".dynstr"))
5949 if (dynamic_strings
!= NULL
)
5951 error (_("File contains multiple dynamic string tables\n"));
5955 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5956 1, section
->sh_size
,
5957 _("dynamic strings"));
5958 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5960 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5962 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5963 entry
->hdr
= section
;
5964 entry
->next
= symtab_shndx_list
;
5965 symtab_shndx_list
= entry
;
5967 else if (section
->sh_type
== SHT_SYMTAB
)
5968 CHECK_ENTSIZE (section
, i
, Sym
);
5969 else if (section
->sh_type
== SHT_GROUP
)
5970 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5971 else if (section
->sh_type
== SHT_REL
)
5972 CHECK_ENTSIZE (section
, i
, Rel
);
5973 else if (section
->sh_type
== SHT_RELA
)
5974 CHECK_ENTSIZE (section
, i
, Rela
);
5975 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5976 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5977 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5978 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5979 || do_debug_addr
|| do_debug_cu_index
)
5980 && (const_strneq (name
, ".debug_")
5981 || const_strneq (name
, ".zdebug_")))
5984 name
+= sizeof (".zdebug_") - 1;
5986 name
+= sizeof (".debug_") - 1;
5989 || (do_debug_info
&& const_strneq (name
, "info"))
5990 || (do_debug_info
&& const_strneq (name
, "types"))
5991 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5992 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5993 || (do_debug_lines
&& const_strneq (name
, "line."))
5994 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5995 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5996 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5997 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5998 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5999 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6000 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6001 || (do_debug_frames
&& const_strneq (name
, "frame"))
6002 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6003 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6004 || (do_debug_str
&& const_strneq (name
, "str"))
6005 || (do_debug_loc
&& const_strneq (name
, "loc"))
6006 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6007 || (do_debug_addr
&& const_strneq (name
, "addr"))
6008 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6009 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6011 request_dump_bynumber (i
, DEBUG_DUMP
);
6013 /* Linkonce section to be combined with .debug_info at link time. */
6014 else if ((do_debugging
|| do_debug_info
)
6015 && const_strneq (name
, ".gnu.linkonce.wi."))
6016 request_dump_bynumber (i
, DEBUG_DUMP
);
6017 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6018 request_dump_bynumber (i
, DEBUG_DUMP
);
6019 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
6020 request_dump_bynumber (i
, DEBUG_DUMP
);
6021 /* Trace sections for Itanium VMS. */
6022 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6023 || do_trace_aranges
)
6024 && const_strneq (name
, ".trace_"))
6026 name
+= sizeof (".trace_") - 1;
6029 || (do_trace_info
&& streq (name
, "info"))
6030 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6031 || (do_trace_aranges
&& streq (name
, "aranges"))
6033 request_dump_bynumber (i
, DEBUG_DUMP
);
6040 if (elf_header
.e_shnum
> 1)
6041 printf (_("\nSection Headers:\n"));
6043 printf (_("\nSection Header:\n"));
6047 if (do_section_details
)
6049 printf (_(" [Nr] Name\n"));
6050 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6054 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6058 if (do_section_details
)
6060 printf (_(" [Nr] Name\n"));
6061 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6065 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6069 if (do_section_details
)
6071 printf (_(" [Nr] Name\n"));
6072 printf (_(" Type Address Offset Link\n"));
6073 printf (_(" Size EntSize Info Align\n"));
6077 printf (_(" [Nr] Name Type Address Offset\n"));
6078 printf (_(" Size EntSize Flags Link Info Align\n"));
6082 if (do_section_details
)
6083 printf (_(" Flags\n"));
6085 for (i
= 0, section
= section_headers
;
6086 i
< elf_header
.e_shnum
;
6089 /* Run some sanity checks on the section header. */
6091 /* Check the sh_link field. */
6092 switch (section
->sh_type
)
6094 case SHT_SYMTAB_SHNDX
:
6098 case SHT_GNU_versym
:
6101 if (section
->sh_link
< 1
6102 || section
->sh_link
>= elf_header
.e_shnum
6103 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6104 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6105 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6106 i
, section
->sh_link
);
6112 case SHT_GNU_verneed
:
6113 case SHT_GNU_verdef
:
6114 case SHT_GNU_LIBLIST
:
6115 if (section
->sh_link
< 1
6116 || section
->sh_link
>= elf_header
.e_shnum
6117 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6118 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6119 i
, section
->sh_link
);
6122 case SHT_INIT_ARRAY
:
6123 case SHT_FINI_ARRAY
:
6124 case SHT_PREINIT_ARRAY
:
6125 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6126 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6127 i
, section
->sh_link
);
6131 /* FIXME: Add support for target specific section types. */
6132 #if 0 /* Currently we do not check other section types as there are too
6133 many special cases. Stab sections for example have a type
6134 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6136 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6137 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6138 i
, section
->sh_link
);
6143 /* Check the sh_info field. */
6144 switch (section
->sh_type
)
6148 if (section
->sh_info
< 1
6149 || section
->sh_info
>= elf_header
.e_shnum
6150 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6151 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6152 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6153 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6154 /* FIXME: Are other section types valid ? */
6155 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6157 if (section
->sh_info
== 0
6158 && (streq (SECTION_NAME (section
), ".rel.dyn")
6159 || streq (SECTION_NAME (section
), ".rela.dyn")))
6160 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6161 of zero. The relocations in these sections may apply
6162 to many different sections. */
6165 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6166 i
, section
->sh_info
);
6172 case SHT_SYMTAB_SHNDX
:
6173 case SHT_INIT_ARRAY
:
6174 case SHT_FINI_ARRAY
:
6175 case SHT_PREINIT_ARRAY
:
6176 if (section
->sh_info
!= 0)
6177 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6178 i
, section
->sh_info
);
6184 /* A symbol index - we assume that it is valid. */
6188 /* FIXME: Add support for target specific section types. */
6189 if (section
->sh_type
== SHT_NOBITS
)
6190 /* NOBITS section headers with non-zero sh_info fields can be
6191 created when a binary is stripped of everything but its debug
6192 information. The stripped sections have their headers
6193 preserved but their types set to SHT_NOBITS. So do not check
6194 this type of section. */
6196 else if (section
->sh_flags
& SHF_INFO_LINK
)
6198 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6199 warn (_("[%2u]: Expected link to another section in info field"), i
);
6201 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6202 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6203 i
, section
->sh_info
);
6207 printf (" [%2u] ", i
);
6208 if (do_section_details
)
6209 printf ("%s\n ", printable_section_name (section
));
6211 print_symbol (-17, SECTION_NAME (section
));
6213 printf (do_wide
? " %-15s " : " %-15.15s ",
6214 get_section_type_name (section
->sh_type
));
6218 const char * link_too_big
= NULL
;
6220 print_vma (section
->sh_addr
, LONG_HEX
);
6222 printf ( " %6.6lx %6.6lx %2.2lx",
6223 (unsigned long) section
->sh_offset
,
6224 (unsigned long) section
->sh_size
,
6225 (unsigned long) section
->sh_entsize
);
6227 if (do_section_details
)
6228 fputs (" ", stdout
);
6230 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6232 if (section
->sh_link
>= elf_header
.e_shnum
)
6235 /* The sh_link value is out of range. Normally this indicates
6236 an error but it can have special values in Solaris binaries. */
6237 switch (elf_header
.e_machine
)
6244 case EM_OLD_SPARCV9
:
6245 case EM_SPARC32PLUS
:
6248 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6249 link_too_big
= "BEFORE";
6250 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6251 link_too_big
= "AFTER";
6258 if (do_section_details
)
6260 if (link_too_big
!= NULL
&& * link_too_big
)
6261 printf ("<%s> ", link_too_big
);
6263 printf ("%2u ", section
->sh_link
);
6264 printf ("%3u %2lu\n", section
->sh_info
,
6265 (unsigned long) section
->sh_addralign
);
6268 printf ("%2u %3u %2lu\n",
6271 (unsigned long) section
->sh_addralign
);
6273 if (link_too_big
&& ! * link_too_big
)
6274 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6275 i
, section
->sh_link
);
6279 print_vma (section
->sh_addr
, LONG_HEX
);
6281 if ((long) section
->sh_offset
== section
->sh_offset
)
6282 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6286 print_vma (section
->sh_offset
, LONG_HEX
);
6289 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6290 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6294 print_vma (section
->sh_size
, LONG_HEX
);
6297 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6298 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6302 print_vma (section
->sh_entsize
, LONG_HEX
);
6305 if (do_section_details
)
6306 fputs (" ", stdout
);
6308 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6310 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6312 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6313 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6316 print_vma (section
->sh_addralign
, DEC
);
6320 else if (do_section_details
)
6322 printf (" %-15.15s ",
6323 get_section_type_name (section
->sh_type
));
6324 print_vma (section
->sh_addr
, LONG_HEX
);
6325 if ((long) section
->sh_offset
== section
->sh_offset
)
6326 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6330 print_vma (section
->sh_offset
, LONG_HEX
);
6332 printf (" %u\n ", section
->sh_link
);
6333 print_vma (section
->sh_size
, LONG_HEX
);
6335 print_vma (section
->sh_entsize
, LONG_HEX
);
6337 printf (" %-16u %lu\n",
6339 (unsigned long) section
->sh_addralign
);
6344 print_vma (section
->sh_addr
, LONG_HEX
);
6345 if ((long) section
->sh_offset
== section
->sh_offset
)
6346 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6350 print_vma (section
->sh_offset
, LONG_HEX
);
6353 print_vma (section
->sh_size
, LONG_HEX
);
6355 print_vma (section
->sh_entsize
, LONG_HEX
);
6357 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6359 printf (" %2u %3u %lu\n",
6362 (unsigned long) section
->sh_addralign
);
6365 if (do_section_details
)
6367 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6368 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6370 /* Minimum section size is 12 bytes for 32-bit compression
6371 header + 12 bytes for compressed data header. */
6372 unsigned char buf
[24];
6374 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6375 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6376 sizeof (buf
), _("compression header")))
6378 Elf_Internal_Chdr chdr
;
6380 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6382 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6385 printf (_(" [<unknown>: 0x%x], "),
6387 print_vma (chdr
.ch_size
, LONG_HEX
);
6388 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6394 if (!do_section_details
)
6396 /* The ordering of the letters shown here matches the ordering of the
6397 corresponding SHF_xxx values, and hence the order in which these
6398 letters will be displayed to the user. */
6399 printf (_("Key to Flags:\n\
6400 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6401 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6402 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6403 if (elf_header
.e_machine
== EM_X86_64
6404 || elf_header
.e_machine
== EM_L1OM
6405 || elf_header
.e_machine
== EM_K1OM
)
6406 printf (_("l (large), "));
6407 else if (elf_header
.e_machine
== EM_ARM
)
6408 printf (_("y (purecode), "));
6409 printf ("p (processor specific)\n");
6416 get_group_flags (unsigned int flags
)
6418 static char buff
[128];
6422 else if (flags
== GRP_COMDAT
)
6425 snprintf (buff
, 14, _("[0x%x: "), flags
);
6427 flags
&= ~ GRP_COMDAT
;
6428 if (flags
& GRP_MASKOS
)
6430 strcat (buff
, "<OS specific>");
6431 flags
&= ~ GRP_MASKOS
;
6434 if (flags
& GRP_MASKPROC
)
6436 strcat (buff
, "<PROC specific>");
6437 flags
&= ~ GRP_MASKPROC
;
6441 strcat (buff
, "<unknown>");
6448 process_section_groups (FILE * file
)
6450 Elf_Internal_Shdr
* section
;
6452 struct group
* group
;
6453 Elf_Internal_Shdr
* symtab_sec
;
6454 Elf_Internal_Shdr
* strtab_sec
;
6455 Elf_Internal_Sym
* symtab
;
6456 unsigned long num_syms
;
6460 /* Don't process section groups unless needed. */
6461 if (!do_unwind
&& !do_section_groups
)
6464 if (elf_header
.e_shnum
== 0)
6466 if (do_section_groups
)
6467 printf (_("\nThere are no sections to group in this file.\n"));
6472 if (section_headers
== NULL
)
6474 error (_("Section headers are not available!\n"));
6475 /* PR 13622: This can happen with a corrupt ELF header. */
6479 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6480 sizeof (struct group
*));
6482 if (section_headers_groups
== NULL
)
6484 error (_("Out of memory reading %u section group headers\n"),
6485 elf_header
.e_shnum
);
6489 /* Scan the sections for the group section. */
6491 for (i
= 0, section
= section_headers
;
6492 i
< elf_header
.e_shnum
;
6494 if (section
->sh_type
== SHT_GROUP
)
6497 if (group_count
== 0)
6499 if (do_section_groups
)
6500 printf (_("\nThere are no section groups in this file.\n"));
6505 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6507 if (section_groups
== NULL
)
6509 error (_("Out of memory reading %lu groups\n"),
6510 (unsigned long) group_count
);
6520 for (i
= 0, section
= section_headers
, group
= section_groups
;
6521 i
< elf_header
.e_shnum
;
6524 if (section
->sh_type
== SHT_GROUP
)
6526 const char * name
= printable_section_name (section
);
6527 const char * group_name
;
6528 unsigned char * start
;
6529 unsigned char * indices
;
6530 unsigned int entry
, j
, size
;
6531 Elf_Internal_Shdr
* sec
;
6532 Elf_Internal_Sym
* sym
;
6534 /* Get the symbol table. */
6535 if (section
->sh_link
>= elf_header
.e_shnum
6536 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6539 error (_("Bad sh_link in group section `%s'\n"), name
);
6543 if (symtab_sec
!= sec
)
6548 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6553 error (_("Corrupt header in group section `%s'\n"), name
);
6557 if (section
->sh_info
>= num_syms
)
6559 error (_("Bad sh_info in group section `%s'\n"), name
);
6563 sym
= symtab
+ section
->sh_info
;
6565 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6567 if (sym
->st_shndx
== 0
6568 || sym
->st_shndx
>= elf_header
.e_shnum
)
6570 error (_("Bad sh_info in group section `%s'\n"), name
);
6574 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6583 /* Get the string table. */
6584 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6593 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6599 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6600 1, strtab_sec
->sh_size
,
6602 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6604 group_name
= sym
->st_name
< strtab_size
6605 ? strtab
+ sym
->st_name
: _("<corrupt>");
6608 /* PR 17531: file: loop. */
6609 if (section
->sh_entsize
> section
->sh_size
)
6611 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6612 printable_section_name (section
),
6613 (unsigned long) section
->sh_entsize
,
6614 (unsigned long) section
->sh_size
);
6618 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6619 1, section
->sh_size
,
6625 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6626 entry
= byte_get (indices
, 4);
6629 if (do_section_groups
)
6631 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6632 get_group_flags (entry
), i
, name
, group_name
, size
);
6634 printf (_(" [Index] Name\n"));
6637 group
->group_index
= i
;
6639 for (j
= 0; j
< size
; j
++)
6641 struct group_list
* g
;
6643 entry
= byte_get (indices
, 4);
6646 if (entry
>= elf_header
.e_shnum
)
6648 static unsigned num_group_errors
= 0;
6650 if (num_group_errors
++ < 10)
6652 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6653 entry
, i
, elf_header
.e_shnum
- 1);
6654 if (num_group_errors
== 10)
6655 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6660 if (section_headers_groups
[entry
] != NULL
)
6664 static unsigned num_errs
= 0;
6666 if (num_errs
++ < 10)
6668 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6670 section_headers_groups
[entry
]->group_index
);
6672 warn (_("Further error messages about already contained group sections suppressed\n"));
6678 /* Intel C/C++ compiler may put section 0 in a
6679 section group. We just warn it the first time
6680 and ignore it afterwards. */
6681 static bfd_boolean warned
= FALSE
;
6684 error (_("section 0 in group section [%5u]\n"),
6685 section_headers_groups
[entry
]->group_index
);
6691 section_headers_groups
[entry
] = group
;
6693 if (do_section_groups
)
6695 sec
= section_headers
+ entry
;
6696 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6699 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6700 g
->section_index
= entry
;
6701 g
->next
= group
->root
;
6719 /* Data used to display dynamic fixups. */
6721 struct ia64_vms_dynfixup
6723 bfd_vma needed_ident
; /* Library ident number. */
6724 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6725 bfd_vma fixup_needed
; /* Index of the library. */
6726 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6727 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6730 /* Data used to display dynamic relocations. */
6732 struct ia64_vms_dynimgrela
6734 bfd_vma img_rela_cnt
; /* Number of relocations. */
6735 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6738 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6742 dump_ia64_vms_dynamic_fixups (FILE * file
,
6743 struct ia64_vms_dynfixup
* fixup
,
6744 const char * strtab
,
6745 unsigned int strtab_sz
)
6747 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6749 const char * lib_name
;
6751 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6752 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6753 _("dynamic section image fixups"));
6757 if (fixup
->needed
< strtab_sz
)
6758 lib_name
= strtab
+ fixup
->needed
;
6761 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6762 (unsigned long) fixup
->needed
);
6765 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6766 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6768 (_("Seg Offset Type SymVec DataType\n"));
6770 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6775 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6776 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6777 type
= BYTE_GET (imfs
[i
].type
);
6778 rtype
= elf_ia64_reloc_type (type
);
6780 printf (" 0x%08x ", type
);
6782 printf (" %-32s ", rtype
);
6783 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6784 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6791 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6794 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6796 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6799 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6800 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6801 _("dynamic section image relocations"));
6805 printf (_("\nImage relocs\n"));
6807 (_("Seg Offset Type Addend Seg Sym Off\n"));
6809 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6814 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6815 printf ("%08" BFD_VMA_FMT
"x ",
6816 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6817 type
= BYTE_GET (imrs
[i
].type
);
6818 rtype
= elf_ia64_reloc_type (type
);
6820 printf ("0x%08x ", type
);
6822 printf ("%-31s ", rtype
);
6823 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6824 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6825 printf ("%08" BFD_VMA_FMT
"x\n",
6826 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6833 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6836 process_ia64_vms_dynamic_relocs (FILE *file
)
6838 struct ia64_vms_dynfixup fixup
;
6839 struct ia64_vms_dynimgrela imgrela
;
6840 Elf_Internal_Dyn
*entry
;
6841 bfd_vma strtab_off
= 0;
6842 bfd_vma strtab_sz
= 0;
6843 char *strtab
= NULL
;
6844 bfd_boolean res
= TRUE
;
6846 memset (&fixup
, 0, sizeof (fixup
));
6847 memset (&imgrela
, 0, sizeof (imgrela
));
6849 /* Note: the order of the entries is specified by the OpenVMS specs. */
6850 for (entry
= dynamic_section
;
6851 entry
< dynamic_section
+ dynamic_nent
;
6854 switch (entry
->d_tag
)
6856 case DT_IA_64_VMS_STRTAB_OFFSET
:
6857 strtab_off
= entry
->d_un
.d_val
;
6860 strtab_sz
= entry
->d_un
.d_val
;
6862 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6863 1, strtab_sz
, _("dynamic string section"));
6866 case DT_IA_64_VMS_NEEDED_IDENT
:
6867 fixup
.needed_ident
= entry
->d_un
.d_val
;
6870 fixup
.needed
= entry
->d_un
.d_val
;
6872 case DT_IA_64_VMS_FIXUP_NEEDED
:
6873 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6875 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6876 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6878 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6879 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6880 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6883 case DT_IA_64_VMS_IMG_RELA_CNT
:
6884 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6886 case DT_IA_64_VMS_IMG_RELA_OFF
:
6887 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6888 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6910 dynamic_relocations
[] =
6912 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6913 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6914 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6917 /* Process the reloc section. */
6920 process_relocs (FILE * file
)
6922 unsigned long rel_size
;
6923 unsigned long rel_offset
;
6928 if (do_using_dynamic
)
6932 bfd_boolean has_dynamic_reloc
;
6935 has_dynamic_reloc
= FALSE
;
6937 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6939 is_rela
= dynamic_relocations
[i
].rela
;
6940 name
= dynamic_relocations
[i
].name
;
6941 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6942 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6945 has_dynamic_reloc
= TRUE
;
6947 if (is_rela
== UNKNOWN
)
6949 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6950 switch (dynamic_info
[DT_PLTREL
])
6964 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6965 name
, rel_offset
, rel_size
);
6967 dump_relocations (file
,
6968 offset_from_vma (file
, rel_offset
, rel_size
),
6970 dynamic_symbols
, num_dynamic_syms
,
6971 dynamic_strings
, dynamic_strings_length
,
6972 is_rela
, TRUE
/* is_dynamic */);
6977 if (process_ia64_vms_dynamic_relocs (file
))
6978 has_dynamic_reloc
= TRUE
;
6980 if (! has_dynamic_reloc
)
6981 printf (_("\nThere are no dynamic relocations in this file.\n"));
6985 Elf_Internal_Shdr
* section
;
6987 bfd_boolean found
= FALSE
;
6989 for (i
= 0, section
= section_headers
;
6990 i
< elf_header
.e_shnum
;
6993 if ( section
->sh_type
!= SHT_RELA
6994 && section
->sh_type
!= SHT_REL
)
6997 rel_offset
= section
->sh_offset
;
6998 rel_size
= section
->sh_size
;
7002 Elf_Internal_Shdr
* strsec
;
7005 printf (_("\nRelocation section "));
7007 if (string_table
== NULL
)
7008 printf ("%d", section
->sh_name
);
7010 printf ("'%s'", printable_section_name (section
));
7012 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7013 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
7015 is_rela
= section
->sh_type
== SHT_RELA
;
7017 if (section
->sh_link
!= 0
7018 && section
->sh_link
< elf_header
.e_shnum
)
7020 Elf_Internal_Shdr
* symsec
;
7021 Elf_Internal_Sym
* symtab
;
7022 unsigned long nsyms
;
7023 unsigned long strtablen
= 0;
7024 char * strtab
= NULL
;
7026 symsec
= section_headers
+ section
->sh_link
;
7027 if (symsec
->sh_type
!= SHT_SYMTAB
7028 && symsec
->sh_type
!= SHT_DYNSYM
)
7031 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7036 if (symsec
->sh_link
!= 0
7037 && symsec
->sh_link
< elf_header
.e_shnum
)
7039 strsec
= section_headers
+ symsec
->sh_link
;
7041 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7044 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7047 dump_relocations (file
, rel_offset
, rel_size
,
7048 symtab
, nsyms
, strtab
, strtablen
,
7050 symsec
->sh_type
== SHT_DYNSYM
);
7056 dump_relocations (file
, rel_offset
, rel_size
,
7057 NULL
, 0, NULL
, 0, is_rela
,
7058 FALSE
/* is_dynamic */);
7065 printf (_("\nThere are no relocations in this file.\n"));
7071 /* An absolute address consists of a section and an offset. If the
7072 section is NULL, the offset itself is the address, otherwise, the
7073 address equals to LOAD_ADDRESS(section) + offset. */
7077 unsigned short section
;
7081 #define ABSADDR(a) \
7083 ? section_headers [(a).section].sh_addr + (a).offset \
7086 /* Find the nearest symbol at or below ADDR. Returns the symbol
7087 name, if found, and the offset from the symbol to ADDR. */
7090 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7091 unsigned long nsyms
,
7092 const char * strtab
,
7093 unsigned long strtab_size
,
7094 struct absaddr addr
,
7095 const char ** symname
,
7098 bfd_vma dist
= 0x100000;
7099 Elf_Internal_Sym
* sym
;
7100 Elf_Internal_Sym
* beg
;
7101 Elf_Internal_Sym
* end
;
7102 Elf_Internal_Sym
* best
= NULL
;
7104 REMOVE_ARCH_BITS (addr
.offset
);
7106 end
= symtab
+ nsyms
;
7112 sym
= beg
+ (end
- beg
) / 2;
7114 value
= sym
->st_value
;
7115 REMOVE_ARCH_BITS (value
);
7117 if (sym
->st_name
!= 0
7118 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7119 && addr
.offset
>= value
7120 && addr
.offset
- value
< dist
)
7123 dist
= addr
.offset
- value
;
7128 if (addr
.offset
< value
)
7136 *symname
= (best
->st_name
>= strtab_size
7137 ? _("<corrupt>") : strtab
+ best
->st_name
);
7143 *offset
= addr
.offset
;
7146 static /* signed */ int
7147 symcmp (const void *p
, const void *q
)
7149 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7150 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7152 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7155 /* Process the unwind section. */
7157 #include "unwind-ia64.h"
7159 struct ia64_unw_table_entry
7161 struct absaddr start
;
7163 struct absaddr info
;
7166 struct ia64_unw_aux_info
7168 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7169 unsigned long table_len
; /* Length of unwind table. */
7170 unsigned char * info
; /* Unwind info. */
7171 unsigned long info_size
; /* Size of unwind info. */
7172 bfd_vma info_addr
; /* Starting address of unwind info. */
7173 bfd_vma seg_base
; /* Starting address of segment. */
7174 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7175 unsigned long nsyms
; /* Number of symbols. */
7176 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7177 unsigned long nfuns
; /* Number of entries in funtab. */
7178 char * strtab
; /* The string table. */
7179 unsigned long strtab_size
; /* Size of string table. */
7183 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7185 struct ia64_unw_table_entry
* tp
;
7186 unsigned long j
, nfuns
;
7188 bfd_boolean res
= TRUE
;
7190 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7191 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7192 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7193 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7195 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7197 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7201 const unsigned char * dp
;
7202 const unsigned char * head
;
7203 const unsigned char * end
;
7204 const char * procname
;
7206 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7207 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7209 fputs ("\n<", stdout
);
7213 fputs (procname
, stdout
);
7216 printf ("+%lx", (unsigned long) offset
);
7219 fputs (">: [", stdout
);
7220 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7221 fputc ('-', stdout
);
7222 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7223 printf ("], info at +0x%lx\n",
7224 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7226 /* PR 17531: file: 86232b32. */
7227 if (aux
->info
== NULL
)
7230 /* PR 17531: file: 0997b4d1. */
7231 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7233 warn (_("Invalid offset %lx in table entry %ld\n"),
7234 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7239 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7240 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7242 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7243 (unsigned) UNW_VER (stamp
),
7244 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7245 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7246 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7247 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7249 if (UNW_VER (stamp
) != 1)
7251 printf (_("\tUnknown version.\n"));
7256 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7257 /* PR 17531: file: 16ceda89. */
7258 if (end
> aux
->info
+ aux
->info_size
)
7259 end
= aux
->info
+ aux
->info_size
;
7260 for (dp
= head
+ 8; dp
< end
;)
7261 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7270 slurp_ia64_unwind_table (FILE * file
,
7271 struct ia64_unw_aux_info
* aux
,
7272 Elf_Internal_Shdr
* sec
)
7274 unsigned long size
, nrelas
, i
;
7275 Elf_Internal_Phdr
* seg
;
7276 struct ia64_unw_table_entry
* tep
;
7277 Elf_Internal_Shdr
* relsec
;
7278 Elf_Internal_Rela
* rela
;
7279 Elf_Internal_Rela
* rp
;
7280 unsigned char * table
;
7282 Elf_Internal_Sym
* sym
;
7283 const char * relname
;
7287 /* First, find the starting address of the segment that includes
7290 if (elf_header
.e_phnum
)
7292 if (! get_program_headers (file
))
7295 for (seg
= program_headers
;
7296 seg
< program_headers
+ elf_header
.e_phnum
;
7299 if (seg
->p_type
!= PT_LOAD
)
7302 if (sec
->sh_addr
>= seg
->p_vaddr
7303 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7305 aux
->seg_base
= seg
->p_vaddr
;
7311 /* Second, build the unwind table from the contents of the unwind section: */
7312 size
= sec
->sh_size
;
7313 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7318 aux
->table_len
= size
/ (3 * eh_addr_size
);
7319 aux
->table
= (struct ia64_unw_table_entry
*)
7320 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7323 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7325 tep
->start
.section
= SHN_UNDEF
;
7326 tep
->end
.section
= SHN_UNDEF
;
7327 tep
->info
.section
= SHN_UNDEF
;
7328 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7329 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7330 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7331 tep
->start
.offset
+= aux
->seg_base
;
7332 tep
->end
.offset
+= aux
->seg_base
;
7333 tep
->info
.offset
+= aux
->seg_base
;
7337 /* Third, apply any relocations to the unwind table: */
7338 for (relsec
= section_headers
;
7339 relsec
< section_headers
+ elf_header
.e_shnum
;
7342 if (relsec
->sh_type
!= SHT_RELA
7343 || relsec
->sh_info
>= elf_header
.e_shnum
7344 || section_headers
+ relsec
->sh_info
!= sec
)
7347 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7356 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7358 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7359 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7361 /* PR 17531: file: 9fa67536. */
7362 if (relname
== NULL
)
7364 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7368 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7370 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7374 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7376 /* PR 17531: file: 5bc8d9bf. */
7377 if (i
>= aux
->table_len
)
7379 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7383 switch (rp
->r_offset
/ eh_addr_size
% 3)
7386 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7387 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7390 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7391 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7394 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7395 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7409 ia64_process_unwind (FILE * file
)
7411 Elf_Internal_Shdr
* sec
;
7412 Elf_Internal_Shdr
* unwsec
= NULL
;
7413 Elf_Internal_Shdr
* strsec
;
7414 unsigned long i
, unwcount
= 0, unwstart
= 0;
7415 struct ia64_unw_aux_info aux
;
7416 bfd_boolean res
= TRUE
;
7418 memset (& aux
, 0, sizeof (aux
));
7420 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7422 if (sec
->sh_type
== SHT_SYMTAB
7423 && sec
->sh_link
< elf_header
.e_shnum
)
7425 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7427 strsec
= section_headers
+ sec
->sh_link
;
7428 if (aux
.strtab
!= NULL
)
7430 error (_("Multiple auxillary string tables encountered\n"));
7434 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7437 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7439 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7444 printf (_("\nThere are no unwind sections in this file.\n"));
7446 while (unwcount
-- > 0)
7451 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7452 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7453 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7458 /* We have already counted the number of SHT_IA64_UNWIND
7459 sections so the loop above should never fail. */
7460 assert (unwsec
!= NULL
);
7463 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7465 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7467 /* We need to find which section group it is in. */
7468 struct group_list
* g
;
7470 if (section_headers_groups
== NULL
7471 || section_headers_groups
[i
] == NULL
)
7472 i
= elf_header
.e_shnum
;
7475 g
= section_headers_groups
[i
]->root
;
7477 for (; g
!= NULL
; g
= g
->next
)
7479 sec
= section_headers
+ g
->section_index
;
7481 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7486 i
= elf_header
.e_shnum
;
7489 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7491 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7492 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7493 suffix
= SECTION_NAME (unwsec
) + len
;
7494 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7496 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7497 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7502 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7503 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7504 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7505 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7507 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7508 suffix
= SECTION_NAME (unwsec
) + len
;
7509 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7511 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7512 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7516 if (i
== elf_header
.e_shnum
)
7518 printf (_("\nCould not find unwind info section for "));
7520 if (string_table
== NULL
)
7521 printf ("%d", unwsec
->sh_name
);
7523 printf ("'%s'", printable_section_name (unwsec
));
7527 aux
.info_addr
= sec
->sh_addr
;
7528 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7531 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7533 printf (_("\nUnwind section "));
7535 if (string_table
== NULL
)
7536 printf ("%d", unwsec
->sh_name
);
7538 printf ("'%s'", printable_section_name (unwsec
));
7540 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7541 (unsigned long) unwsec
->sh_offset
,
7542 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7544 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7545 && aux
.table_len
> 0)
7546 dump_ia64_unwind (& aux
);
7549 free ((char *) aux
.table
);
7551 free ((char *) aux
.info
);
7560 free ((char *) aux
.strtab
);
7565 struct hppa_unw_table_entry
7567 struct absaddr start
;
7569 unsigned int Cannot_unwind
:1; /* 0 */
7570 unsigned int Millicode
:1; /* 1 */
7571 unsigned int Millicode_save_sr0
:1; /* 2 */
7572 unsigned int Region_description
:2; /* 3..4 */
7573 unsigned int reserved1
:1; /* 5 */
7574 unsigned int Entry_SR
:1; /* 6 */
7575 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7576 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7577 unsigned int Args_stored
:1; /* 16 */
7578 unsigned int Variable_Frame
:1; /* 17 */
7579 unsigned int Separate_Package_Body
:1; /* 18 */
7580 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7581 unsigned int Stack_Overflow_Check
:1; /* 20 */
7582 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7583 unsigned int Ada_Region
:1; /* 22 */
7584 unsigned int cxx_info
:1; /* 23 */
7585 unsigned int cxx_try_catch
:1; /* 24 */
7586 unsigned int sched_entry_seq
:1; /* 25 */
7587 unsigned int reserved2
:1; /* 26 */
7588 unsigned int Save_SP
:1; /* 27 */
7589 unsigned int Save_RP
:1; /* 28 */
7590 unsigned int Save_MRP_in_frame
:1; /* 29 */
7591 unsigned int extn_ptr_defined
:1; /* 30 */
7592 unsigned int Cleanup_defined
:1; /* 31 */
7594 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7595 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7596 unsigned int Large_frame
:1; /* 2 */
7597 unsigned int Pseudo_SP_Set
:1; /* 3 */
7598 unsigned int reserved4
:1; /* 4 */
7599 unsigned int Total_frame_size
:27; /* 5..31 */
7602 struct hppa_unw_aux_info
7604 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7605 unsigned long table_len
; /* Length of unwind table. */
7606 bfd_vma seg_base
; /* Starting address of segment. */
7607 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7608 unsigned long nsyms
; /* Number of symbols. */
7609 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7610 unsigned long nfuns
; /* Number of entries in funtab. */
7611 char * strtab
; /* The string table. */
7612 unsigned long strtab_size
; /* Size of string table. */
7616 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7618 struct hppa_unw_table_entry
* tp
;
7619 unsigned long j
, nfuns
;
7620 bfd_boolean res
= TRUE
;
7622 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7623 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7624 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7625 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7627 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7629 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7632 const char * procname
;
7634 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7635 aux
->strtab_size
, tp
->start
, &procname
,
7638 fputs ("\n<", stdout
);
7642 fputs (procname
, stdout
);
7645 printf ("+%lx", (unsigned long) offset
);
7648 fputs (">: [", stdout
);
7649 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7650 fputc ('-', stdout
);
7651 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7654 #define PF(_m) if (tp->_m) printf (#_m " ");
7655 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7658 PF(Millicode_save_sr0
);
7659 /* PV(Region_description); */
7665 PF(Separate_Package_Body
);
7666 PF(Frame_Extension_Millicode
);
7667 PF(Stack_Overflow_Check
);
7668 PF(Two_Instruction_SP_Increment
);
7672 PF(sched_entry_seq
);
7675 PF(Save_MRP_in_frame
);
7676 PF(extn_ptr_defined
);
7677 PF(Cleanup_defined
);
7678 PF(MPE_XL_interrupt_marker
);
7679 PF(HP_UX_interrupt_marker
);
7682 PV(Total_frame_size
);
7695 slurp_hppa_unwind_table (FILE * file
,
7696 struct hppa_unw_aux_info
* aux
,
7697 Elf_Internal_Shdr
* sec
)
7699 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7700 Elf_Internal_Phdr
* seg
;
7701 struct hppa_unw_table_entry
* tep
;
7702 Elf_Internal_Shdr
* relsec
;
7703 Elf_Internal_Rela
* rela
;
7704 Elf_Internal_Rela
* rp
;
7705 unsigned char * table
;
7707 Elf_Internal_Sym
* sym
;
7708 const char * relname
;
7710 /* First, find the starting address of the segment that includes
7712 if (elf_header
.e_phnum
)
7714 if (! get_program_headers (file
))
7717 for (seg
= program_headers
;
7718 seg
< program_headers
+ elf_header
.e_phnum
;
7721 if (seg
->p_type
!= PT_LOAD
)
7724 if (sec
->sh_addr
>= seg
->p_vaddr
7725 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7727 aux
->seg_base
= seg
->p_vaddr
;
7733 /* Second, build the unwind table from the contents of the unwind
7735 size
= sec
->sh_size
;
7736 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7742 nentries
= size
/ unw_ent_size
;
7743 size
= unw_ent_size
* nentries
;
7745 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7746 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7748 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7750 unsigned int tmp1
, tmp2
;
7752 tep
->start
.section
= SHN_UNDEF
;
7753 tep
->end
.section
= SHN_UNDEF
;
7755 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7756 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7757 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7758 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7760 tep
->start
.offset
+= aux
->seg_base
;
7761 tep
->end
.offset
+= aux
->seg_base
;
7763 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7764 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7765 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7766 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7767 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7768 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7769 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7770 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7771 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7772 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7773 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7774 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7775 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7776 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7777 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7778 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7779 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7780 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7781 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7782 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7783 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7784 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7785 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7786 tep
->Cleanup_defined
= tmp1
& 0x1;
7788 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7789 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7790 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7791 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7792 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7793 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7797 /* Third, apply any relocations to the unwind table. */
7798 for (relsec
= section_headers
;
7799 relsec
< section_headers
+ elf_header
.e_shnum
;
7802 if (relsec
->sh_type
!= SHT_RELA
7803 || relsec
->sh_info
>= elf_header
.e_shnum
7804 || section_headers
+ relsec
->sh_info
!= sec
)
7807 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7811 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7813 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7814 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7816 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7817 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7819 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7823 i
= rp
->r_offset
/ unw_ent_size
;
7825 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7828 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7829 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7832 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7833 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7843 aux
->table_len
= nentries
;
7849 hppa_process_unwind (FILE * file
)
7851 struct hppa_unw_aux_info aux
;
7852 Elf_Internal_Shdr
* unwsec
= NULL
;
7853 Elf_Internal_Shdr
* strsec
;
7854 Elf_Internal_Shdr
* sec
;
7856 bfd_boolean res
= TRUE
;
7858 if (string_table
== NULL
)
7861 memset (& aux
, 0, sizeof (aux
));
7863 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7865 if (sec
->sh_type
== SHT_SYMTAB
7866 && sec
->sh_link
< elf_header
.e_shnum
)
7868 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7870 strsec
= section_headers
+ sec
->sh_link
;
7871 if (aux
.strtab
!= NULL
)
7873 error (_("Multiple auxillary string tables encountered\n"));
7877 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7880 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7882 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7887 printf (_("\nThere are no unwind sections in this file.\n"));
7889 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7891 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7893 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7894 printable_section_name (sec
),
7895 (unsigned long) sec
->sh_offset
,
7896 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7898 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7901 if (aux
.table_len
> 0)
7903 if (! dump_hppa_unwind (&aux
))
7908 free ((char *) aux
.table
);
7916 free ((char *) aux
.strtab
);
7923 unsigned char * data
; /* The unwind data. */
7924 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7925 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7926 unsigned long nrelas
; /* The number of relocations. */
7927 unsigned int rel_type
; /* REL or RELA ? */
7928 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7931 struct arm_unw_aux_info
7933 FILE * file
; /* The file containing the unwind sections. */
7934 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7935 unsigned long nsyms
; /* Number of symbols. */
7936 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7937 unsigned long nfuns
; /* Number of these symbols. */
7938 char * strtab
; /* The file's string table. */
7939 unsigned long strtab_size
; /* Size of string table. */
7943 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7944 bfd_vma fn
, struct absaddr addr
)
7946 const char *procname
;
7949 if (addr
.section
== SHN_UNDEF
)
7952 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7953 aux
->strtab_size
, addr
, &procname
,
7956 print_vma (fn
, PREFIX_HEX
);
7960 fputs (" <", stdout
);
7961 fputs (procname
, stdout
);
7964 printf ("+0x%lx", (unsigned long) sym_offset
);
7965 fputc ('>', stdout
);
7972 arm_free_section (struct arm_section
*arm_sec
)
7974 if (arm_sec
->data
!= NULL
)
7975 free (arm_sec
->data
);
7977 if (arm_sec
->rela
!= NULL
)
7978 free (arm_sec
->rela
);
7981 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7982 cached section and install SEC instead.
7983 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7984 and return its valued in * WORDP, relocating if necessary.
7985 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7986 relocation's offset in ADDR.
7987 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7988 into the string table of the symbol associated with the reloc. If no
7989 reloc was applied store -1 there.
7990 5) Return TRUE upon success, FALSE otherwise. */
7993 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7994 struct arm_section
* arm_sec
,
7995 Elf_Internal_Shdr
* sec
,
7996 bfd_vma word_offset
,
7997 unsigned int * wordp
,
7998 struct absaddr
* addr
,
8001 Elf_Internal_Rela
*rp
;
8002 Elf_Internal_Sym
*sym
;
8003 const char * relname
;
8005 bfd_boolean wrapped
;
8007 if (sec
== NULL
|| arm_sec
== NULL
)
8010 addr
->section
= SHN_UNDEF
;
8013 if (sym_name
!= NULL
)
8014 *sym_name
= (bfd_vma
) -1;
8016 /* If necessary, update the section cache. */
8017 if (sec
!= arm_sec
->sec
)
8019 Elf_Internal_Shdr
*relsec
;
8021 arm_free_section (arm_sec
);
8024 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8025 sec
->sh_size
, _("unwind data"));
8026 arm_sec
->rela
= NULL
;
8027 arm_sec
->nrelas
= 0;
8029 for (relsec
= section_headers
;
8030 relsec
< section_headers
+ elf_header
.e_shnum
;
8033 if (relsec
->sh_info
>= elf_header
.e_shnum
8034 || section_headers
+ relsec
->sh_info
!= sec
8035 /* PR 15745: Check the section type as well. */
8036 || (relsec
->sh_type
!= SHT_REL
8037 && relsec
->sh_type
!= SHT_RELA
))
8040 arm_sec
->rel_type
= relsec
->sh_type
;
8041 if (relsec
->sh_type
== SHT_REL
)
8043 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8045 & arm_sec
->rela
, & arm_sec
->nrelas
))
8048 else /* relsec->sh_type == SHT_RELA */
8050 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8052 & arm_sec
->rela
, & arm_sec
->nrelas
))
8058 arm_sec
->next_rela
= arm_sec
->rela
;
8061 /* If there is no unwind data we can do nothing. */
8062 if (arm_sec
->data
== NULL
)
8065 /* If the offset is invalid then fail. */
8066 if (/* PR 21343 *//* PR 18879 */
8068 || word_offset
> (sec
->sh_size
- 4)
8069 || ((bfd_signed_vma
) word_offset
) < 0)
8072 /* Get the word at the required offset. */
8073 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8075 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8076 if (arm_sec
->rela
== NULL
)
8082 /* Look through the relocs to find the one that applies to the provided offset. */
8084 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8086 bfd_vma prelval
, offset
;
8088 if (rp
->r_offset
> word_offset
&& !wrapped
)
8093 if (rp
->r_offset
> word_offset
)
8096 if (rp
->r_offset
& 3)
8098 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8099 (unsigned long) rp
->r_offset
);
8103 if (rp
->r_offset
< word_offset
)
8106 /* PR 17531: file: 027-161405-0.004 */
8107 if (aux
->symtab
== NULL
)
8110 if (arm_sec
->rel_type
== SHT_REL
)
8112 offset
= word
& 0x7fffffff;
8113 if (offset
& 0x40000000)
8114 offset
|= ~ (bfd_vma
) 0x7fffffff;
8116 else if (arm_sec
->rel_type
== SHT_RELA
)
8117 offset
= rp
->r_addend
;
8120 error (_("Unknown section relocation type %d encountered\n"),
8125 /* PR 17531 file: 027-1241568-0.004. */
8126 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8128 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8129 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8133 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8134 offset
+= sym
->st_value
;
8135 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8137 /* Check that we are processing the expected reloc type. */
8138 if (elf_header
.e_machine
== EM_ARM
)
8140 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8141 if (relname
== NULL
)
8143 warn (_("Skipping unknown ARM relocation type: %d\n"),
8144 (int) ELF32_R_TYPE (rp
->r_info
));
8148 if (streq (relname
, "R_ARM_NONE"))
8151 if (! streq (relname
, "R_ARM_PREL31"))
8153 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8157 else if (elf_header
.e_machine
== EM_TI_C6000
)
8159 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8160 if (relname
== NULL
)
8162 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8163 (int) ELF32_R_TYPE (rp
->r_info
));
8167 if (streq (relname
, "R_C6000_NONE"))
8170 if (! streq (relname
, "R_C6000_PREL31"))
8172 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8180 /* This function currently only supports ARM and TI unwinders. */
8181 warn (_("Only TI and ARM unwinders are currently supported\n"));
8185 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8186 addr
->section
= sym
->st_shndx
;
8187 addr
->offset
= offset
;
8190 * sym_name
= sym
->st_name
;
8195 arm_sec
->next_rela
= rp
;
8200 static const char *tic6x_unwind_regnames
[16] =
8202 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8203 "A14", "A13", "A12", "A11", "A10",
8204 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8208 decode_tic6x_unwind_regmask (unsigned int mask
)
8212 for (i
= 12; mask
; mask
>>= 1, i
--)
8216 fputs (tic6x_unwind_regnames
[i
], stdout
);
8218 fputs (", ", stdout
);
8224 if (remaining == 0 && more_words) \
8227 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8228 data_offset, & word, & addr, NULL)) \
8234 #define GET_OP(OP) \
8239 (OP) = word >> 24; \
8244 printf (_("[Truncated opcode]\n")); \
8247 printf ("0x%02x ", OP)
8250 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8252 unsigned int remaining
,
8253 unsigned int more_words
,
8254 bfd_vma data_offset
,
8255 Elf_Internal_Shdr
* data_sec
,
8256 struct arm_section
* data_arm_sec
)
8258 struct absaddr addr
;
8259 bfd_boolean res
= TRUE
;
8261 /* Decode the unwinding instructions. */
8264 unsigned int op
, op2
;
8273 printf (" 0x%02x ", op
);
8275 if ((op
& 0xc0) == 0x00)
8277 int offset
= ((op
& 0x3f) << 2) + 4;
8279 printf (" vsp = vsp + %d", offset
);
8281 else if ((op
& 0xc0) == 0x40)
8283 int offset
= ((op
& 0x3f) << 2) + 4;
8285 printf (" vsp = vsp - %d", offset
);
8287 else if ((op
& 0xf0) == 0x80)
8290 if (op
== 0x80 && op2
== 0)
8291 printf (_("Refuse to unwind"));
8294 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8295 bfd_boolean first
= TRUE
;
8299 for (i
= 0; i
< 12; i
++)
8300 if (mask
& (1 << i
))
8306 printf ("r%d", 4 + i
);
8311 else if ((op
& 0xf0) == 0x90)
8313 if (op
== 0x9d || op
== 0x9f)
8314 printf (_(" [Reserved]"));
8316 printf (" vsp = r%d", op
& 0x0f);
8318 else if ((op
& 0xf0) == 0xa0)
8320 int end
= 4 + (op
& 0x07);
8321 bfd_boolean first
= TRUE
;
8325 for (i
= 4; i
<= end
; i
++)
8341 else if (op
== 0xb0)
8342 printf (_(" finish"));
8343 else if (op
== 0xb1)
8346 if (op2
== 0 || (op2
& 0xf0) != 0)
8347 printf (_("[Spare]"));
8350 unsigned int mask
= op2
& 0x0f;
8351 bfd_boolean first
= TRUE
;
8355 for (i
= 0; i
< 12; i
++)
8356 if (mask
& (1 << i
))
8367 else if (op
== 0xb2)
8369 unsigned char buf
[9];
8370 unsigned int i
, len
;
8371 unsigned long offset
;
8373 for (i
= 0; i
< sizeof (buf
); i
++)
8376 if ((buf
[i
] & 0x80) == 0)
8379 if (i
== sizeof (buf
))
8381 error (_("corrupt change to vsp"));
8386 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8387 assert (len
== i
+ 1);
8388 offset
= offset
* 4 + 0x204;
8389 printf ("vsp = vsp + %ld", offset
);
8392 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8394 unsigned int first
, last
;
8401 printf ("pop {D%d", first
);
8403 printf ("-D%d", first
+ last
);
8406 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8408 unsigned int count
= op
& 0x07;
8412 printf ("-D%d", 8 + count
);
8415 else if (op
>= 0xc0 && op
<= 0xc5)
8417 unsigned int count
= op
& 0x07;
8419 printf (" pop {wR10");
8421 printf ("-wR%d", 10 + count
);
8424 else if (op
== 0xc6)
8426 unsigned int first
, last
;
8431 printf ("pop {wR%d", first
);
8433 printf ("-wR%d", first
+ last
);
8436 else if (op
== 0xc7)
8439 if (op2
== 0 || (op2
& 0xf0) != 0)
8440 printf (_("[Spare]"));
8443 unsigned int mask
= op2
& 0x0f;
8444 bfd_boolean first
= TRUE
;
8448 for (i
= 0; i
< 4; i
++)
8449 if (mask
& (1 << i
))
8455 printf ("wCGR%d", i
);
8462 printf (_(" [unsupported opcode]"));
8473 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8475 unsigned int remaining
,
8476 unsigned int more_words
,
8477 bfd_vma data_offset
,
8478 Elf_Internal_Shdr
* data_sec
,
8479 struct arm_section
* data_arm_sec
)
8481 struct absaddr addr
;
8483 /* Decode the unwinding instructions. */
8486 unsigned int op
, op2
;
8495 printf (" 0x%02x ", op
);
8497 if ((op
& 0xc0) == 0x00)
8499 int offset
= ((op
& 0x3f) << 3) + 8;
8500 printf (" sp = sp + %d", offset
);
8502 else if ((op
& 0xc0) == 0x80)
8505 if (op
== 0x80 && op2
== 0)
8506 printf (_("Refuse to unwind"));
8509 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8511 printf ("pop compact {");
8515 decode_tic6x_unwind_regmask (mask
);
8519 else if ((op
& 0xf0) == 0xc0)
8527 unsigned int offset
;
8531 /* Scan entire instruction first so that GET_OP output is not
8532 interleaved with disassembly. */
8534 for (i
= 0; nregs
< (op
& 0xf); i
++)
8540 regpos
[nregs
].offset
= i
* 2;
8541 regpos
[nregs
].reg
= reg
;
8548 regpos
[nregs
].offset
= i
* 2 + 1;
8549 regpos
[nregs
].reg
= reg
;
8554 printf (_("pop frame {"));
8556 for (i
= i
* 2; i
> 0; i
--)
8558 if (regpos
[reg
].offset
== i
- 1)
8560 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8567 fputs (name
, stdout
);
8574 else if (op
== 0xd0)
8575 printf (" MOV FP, SP");
8576 else if (op
== 0xd1)
8577 printf (" __c6xabi_pop_rts");
8578 else if (op
== 0xd2)
8580 unsigned char buf
[9];
8581 unsigned int i
, len
;
8582 unsigned long offset
;
8584 for (i
= 0; i
< sizeof (buf
); i
++)
8587 if ((buf
[i
] & 0x80) == 0)
8590 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8591 if (i
== sizeof (buf
))
8593 warn (_("Corrupt stack pointer adjustment detected\n"));
8597 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8598 assert (len
== i
+ 1);
8599 offset
= offset
* 8 + 0x408;
8600 printf (_("sp = sp + %ld"), offset
);
8602 else if ((op
& 0xf0) == 0xe0)
8604 if ((op
& 0x0f) == 7)
8607 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8611 printf (_(" [unsupported opcode]"));
8620 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8624 offset
= word
& 0x7fffffff;
8625 if (offset
& 0x40000000)
8626 offset
|= ~ (bfd_vma
) 0x7fffffff;
8628 if (elf_header
.e_machine
== EM_TI_C6000
)
8631 return offset
+ where
;
8635 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8637 unsigned int remaining
,
8638 bfd_vma data_offset
,
8639 Elf_Internal_Shdr
* data_sec
,
8640 struct arm_section
* data_arm_sec
)
8643 unsigned int more_words
= 0;
8644 struct absaddr addr
;
8645 bfd_vma sym_name
= (bfd_vma
) -1;
8646 bfd_boolean res
= FALSE
;
8650 /* Fetch the first word.
8651 Note - when decoding an object file the address extracted
8652 here will always be 0. So we also pass in the sym_name
8653 parameter so that we can find the symbol associated with
8654 the personality routine. */
8655 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8656 & word
, & addr
, & sym_name
))
8662 if ((word
& 0x80000000) == 0)
8664 /* Expand prel31 for personality routine. */
8666 const char *procname
;
8668 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8669 printf (_(" Personality routine: "));
8671 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8672 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8674 procname
= aux
->strtab
+ sym_name
;
8675 print_vma (fn
, PREFIX_HEX
);
8678 fputs (" <", stdout
);
8679 fputs (procname
, stdout
);
8680 fputc ('>', stdout
);
8684 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8685 fputc ('\n', stdout
);
8687 /* The GCC personality routines use the standard compact
8688 encoding, starting with one byte giving the number of
8690 if (procname
!= NULL
8691 && (const_strneq (procname
, "__gcc_personality_v0")
8692 || const_strneq (procname
, "__gxx_personality_v0")
8693 || const_strneq (procname
, "__gcj_personality_v0")
8694 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8701 printf (_(" [Truncated data]\n"));
8704 more_words
= word
>> 24;
8714 /* ARM EHABI Section 6.3:
8716 An exception-handling table entry for the compact model looks like:
8720 1 0 index Data for personalityRoutine[index] */
8722 if (elf_header
.e_machine
== EM_ARM
8723 && (word
& 0x70000000))
8725 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8729 per_index
= (word
>> 24) & 0x7f;
8730 printf (_(" Compact model index: %d\n"), per_index
);
8737 else if (per_index
< 3)
8739 more_words
= (word
>> 16) & 0xff;
8745 switch (elf_header
.e_machine
)
8750 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8751 data_offset
, data_sec
, data_arm_sec
))
8756 warn (_("Unknown ARM compact model index encountered\n"));
8757 printf (_(" [reserved]\n"));
8765 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8766 data_offset
, data_sec
, data_arm_sec
))
8769 else if (per_index
< 5)
8771 if (((word
>> 17) & 0x7f) == 0x7f)
8772 printf (_(" Restore stack from frame pointer\n"));
8774 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8775 printf (_(" Registers restored: "));
8777 printf (" (compact) ");
8778 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8780 printf (_(" Return register: %s\n"),
8781 tic6x_unwind_regnames
[word
& 0xf]);
8784 printf (_(" [reserved (%d)]\n"), per_index
);
8788 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8789 elf_header
.e_machine
);
8793 /* Decode the descriptors. Not implemented. */
8799 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8801 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8802 unsigned int i
, exidx_len
;
8803 unsigned long j
, nfuns
;
8804 bfd_boolean res
= TRUE
;
8806 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8807 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8808 exidx_len
= exidx_sec
->sh_size
/ 8;
8810 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8811 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8812 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8813 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8815 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8817 for (i
= 0; i
< exidx_len
; i
++)
8819 unsigned int exidx_fn
, exidx_entry
;
8820 struct absaddr fn_addr
, entry_addr
;
8823 fputc ('\n', stdout
);
8825 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8826 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8827 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8828 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8831 arm_free_section (& exidx_arm_sec
);
8832 arm_free_section (& extab_arm_sec
);
8836 /* ARM EHABI, Section 5:
8837 An index table entry consists of 2 words.
8838 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8839 if (exidx_fn
& 0x80000000)
8841 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8845 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8847 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8848 fputs (": ", stdout
);
8850 if (exidx_entry
== 1)
8852 print_vma (exidx_entry
, PREFIX_HEX
);
8853 fputs (" [cantunwind]\n", stdout
);
8855 else if (exidx_entry
& 0x80000000)
8857 print_vma (exidx_entry
, PREFIX_HEX
);
8858 fputc ('\n', stdout
);
8859 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8863 bfd_vma table
, table_offset
= 0;
8864 Elf_Internal_Shdr
*table_sec
;
8866 fputs ("@", stdout
);
8867 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8868 print_vma (table
, PREFIX_HEX
);
8871 /* Locate the matching .ARM.extab. */
8872 if (entry_addr
.section
!= SHN_UNDEF
8873 && entry_addr
.section
< elf_header
.e_shnum
)
8875 table_sec
= section_headers
+ entry_addr
.section
;
8876 table_offset
= entry_addr
.offset
;
8878 if (table_offset
> table_sec
->sh_size
8879 || ((bfd_signed_vma
) table_offset
) < 0)
8881 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8882 (unsigned long) table_offset
,
8883 printable_section_name (table_sec
));
8890 table_sec
= find_section_by_address (table
);
8891 if (table_sec
!= NULL
)
8892 table_offset
= table
- table_sec
->sh_addr
;
8895 if (table_sec
== NULL
)
8897 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8898 (unsigned long) table
);
8903 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8912 arm_free_section (&exidx_arm_sec
);
8913 arm_free_section (&extab_arm_sec
);
8918 /* Used for both ARM and C6X unwinding tables. */
8921 arm_process_unwind (FILE *file
)
8923 struct arm_unw_aux_info aux
;
8924 Elf_Internal_Shdr
*unwsec
= NULL
;
8925 Elf_Internal_Shdr
*strsec
;
8926 Elf_Internal_Shdr
*sec
;
8928 unsigned int sec_type
;
8929 bfd_boolean res
= TRUE
;
8931 switch (elf_header
.e_machine
)
8934 sec_type
= SHT_ARM_EXIDX
;
8938 sec_type
= SHT_C6000_UNWIND
;
8942 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8943 elf_header
.e_machine
);
8947 if (string_table
== NULL
)
8950 memset (& aux
, 0, sizeof (aux
));
8953 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8955 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8957 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8959 strsec
= section_headers
+ sec
->sh_link
;
8961 /* PR binutils/17531 file: 011-12666-0.004. */
8962 if (aux
.strtab
!= NULL
)
8964 error (_("Multiple string tables found in file.\n"));
8968 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8969 1, strsec
->sh_size
, _("string table"));
8970 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8972 else if (sec
->sh_type
== sec_type
)
8977 printf (_("\nThere are no unwind sections in this file.\n"));
8979 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8981 if (sec
->sh_type
== sec_type
)
8983 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8984 printable_section_name (sec
),
8985 (unsigned long) sec
->sh_offset
,
8986 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8988 if (! dump_arm_unwind (&aux
, sec
))
8996 free ((char *) aux
.strtab
);
9002 process_unwind (FILE * file
)
9004 struct unwind_handler
9006 unsigned int machtype
;
9007 bfd_boolean (* handler
)(FILE *);
9010 { EM_ARM
, arm_process_unwind
},
9011 { EM_IA_64
, ia64_process_unwind
},
9012 { EM_PARISC
, hppa_process_unwind
},
9013 { EM_TI_C6000
, arm_process_unwind
},
9021 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9022 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9023 return handlers
[i
].handler (file
);
9025 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9026 get_machine_name (elf_header
.e_machine
));
9031 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9033 switch (entry
->d_tag
)
9036 if (entry
->d_un
.d_val
== 0)
9040 static const char * opts
[] =
9042 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9043 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9044 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9045 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9049 bfd_boolean first
= TRUE
;
9051 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9052 if (entry
->d_un
.d_val
& (1 << cnt
))
9054 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9060 case DT_MIPS_IVERSION
:
9061 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9062 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9066 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9067 /* Note: coded this way so that there is a single string for translation. */
9068 printf (_("<corrupt: %s>"), buf
);
9072 case DT_MIPS_TIME_STAMP
:
9076 time_t atime
= entry
->d_un
.d_val
;
9078 tmp
= gmtime (&atime
);
9079 /* PR 17531: file: 6accc532. */
9081 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9083 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9084 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9085 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9086 printf (_("Time Stamp: %s"), timebuf
);
9090 case DT_MIPS_RLD_VERSION
:
9091 case DT_MIPS_LOCAL_GOTNO
:
9092 case DT_MIPS_CONFLICTNO
:
9093 case DT_MIPS_LIBLISTNO
:
9094 case DT_MIPS_SYMTABNO
:
9095 case DT_MIPS_UNREFEXTNO
:
9096 case DT_MIPS_HIPAGENO
:
9097 case DT_MIPS_DELTA_CLASS_NO
:
9098 case DT_MIPS_DELTA_INSTANCE_NO
:
9099 case DT_MIPS_DELTA_RELOC_NO
:
9100 case DT_MIPS_DELTA_SYM_NO
:
9101 case DT_MIPS_DELTA_CLASSSYM_NO
:
9102 case DT_MIPS_COMPACT_SIZE
:
9103 print_vma (entry
->d_un
.d_val
, DEC
);
9107 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9113 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9115 switch (entry
->d_tag
)
9117 case DT_HP_DLD_FLAGS
:
9126 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9127 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9128 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9129 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9130 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9131 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9132 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9133 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9134 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9135 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9136 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9137 { DT_HP_GST
, "HP_GST" },
9138 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9139 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9140 { DT_HP_NODELETE
, "HP_NODELETE" },
9141 { DT_HP_GROUP
, "HP_GROUP" },
9142 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9144 bfd_boolean first
= TRUE
;
9146 bfd_vma val
= entry
->d_un
.d_val
;
9148 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9149 if (val
& flags
[cnt
].bit
)
9153 fputs (flags
[cnt
].str
, stdout
);
9155 val
^= flags
[cnt
].bit
;
9158 if (val
!= 0 || first
)
9162 print_vma (val
, HEX
);
9168 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9176 /* VMS vs Unix time offset and factor. */
9178 #define VMS_EPOCH_OFFSET 35067168000000000LL
9179 #define VMS_GRANULARITY_FACTOR 10000000
9181 /* Display a VMS time in a human readable format. */
9184 print_vms_time (bfd_int64_t vmstime
)
9189 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9190 tm
= gmtime (&unxtime
);
9191 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9192 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9193 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9198 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9200 switch (entry
->d_tag
)
9202 case DT_IA_64_PLT_RESERVE
:
9203 /* First 3 slots reserved. */
9204 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9206 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9209 case DT_IA_64_VMS_LINKTIME
:
9211 print_vms_time (entry
->d_un
.d_val
);
9215 case DT_IA_64_VMS_LNKFLAGS
:
9216 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9217 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9218 printf (" CALL_DEBUG");
9219 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9220 printf (" NOP0BUFS");
9221 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9222 printf (" P0IMAGE");
9223 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9224 printf (" MKTHREADS");
9225 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9226 printf (" UPCALLS");
9227 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9229 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9230 printf (" INITIALIZE");
9231 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9233 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9234 printf (" EXE_INIT");
9235 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9236 printf (" TBK_IN_IMG");
9237 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9238 printf (" DBG_IN_IMG");
9239 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9240 printf (" TBK_IN_DSF");
9241 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9242 printf (" DBG_IN_DSF");
9243 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9244 printf (" SIGNATURES");
9245 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9246 printf (" REL_SEG_OFF");
9250 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9257 get_32bit_dynamic_section (FILE * file
)
9259 Elf32_External_Dyn
* edyn
;
9260 Elf32_External_Dyn
* ext
;
9261 Elf_Internal_Dyn
* entry
;
9263 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9264 dynamic_size
, _("dynamic section"));
9268 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9269 might not have the luxury of section headers. Look for the DT_NULL
9270 terminator to determine the number of entries. */
9271 for (ext
= edyn
, dynamic_nent
= 0;
9272 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9276 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9280 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9282 if (dynamic_section
== NULL
)
9284 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9285 (unsigned long) dynamic_nent
);
9290 for (ext
= edyn
, entry
= dynamic_section
;
9291 entry
< dynamic_section
+ dynamic_nent
;
9294 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9295 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9304 get_64bit_dynamic_section (FILE * file
)
9306 Elf64_External_Dyn
* edyn
;
9307 Elf64_External_Dyn
* ext
;
9308 Elf_Internal_Dyn
* entry
;
9310 /* Read in the data. */
9311 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9312 dynamic_size
, _("dynamic section"));
9316 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9317 might not have the luxury of section headers. Look for the DT_NULL
9318 terminator to determine the number of entries. */
9319 for (ext
= edyn
, dynamic_nent
= 0;
9320 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9321 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9325 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9329 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9331 if (dynamic_section
== NULL
)
9333 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9334 (unsigned long) dynamic_nent
);
9339 /* Convert from external to internal formats. */
9340 for (ext
= edyn
, entry
= dynamic_section
;
9341 entry
< dynamic_section
+ dynamic_nent
;
9344 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9345 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9354 print_dynamic_flags (bfd_vma flags
)
9356 bfd_boolean first
= TRUE
;
9362 flag
= flags
& - flags
;
9372 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9373 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9374 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9375 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9376 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9377 default: fputs (_("unknown"), stdout
); break;
9383 /* Parse and display the contents of the dynamic section. */
9386 process_dynamic_section (FILE * file
)
9388 Elf_Internal_Dyn
* entry
;
9390 if (dynamic_size
== 0)
9393 printf (_("\nThere is no dynamic section in this file.\n"));
9400 if (! get_32bit_dynamic_section (file
))
9405 if (! get_64bit_dynamic_section (file
))
9409 /* Find the appropriate symbol table. */
9410 if (dynamic_symbols
== NULL
)
9412 for (entry
= dynamic_section
;
9413 entry
< dynamic_section
+ dynamic_nent
;
9416 Elf_Internal_Shdr section
;
9418 if (entry
->d_tag
!= DT_SYMTAB
)
9421 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9423 /* Since we do not know how big the symbol table is,
9424 we default to reading in the entire file (!) and
9425 processing that. This is overkill, I know, but it
9427 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9429 if (archive_file_offset
!= 0)
9430 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9433 if (fseek (file
, 0, SEEK_END
))
9434 error (_("Unable to seek to end of file!\n"));
9436 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9440 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9442 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9443 section
.sh_name
= string_table_length
;
9445 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9446 if (num_dynamic_syms
< 1)
9448 error (_("Unable to determine the number of symbols to load\n"));
9454 /* Similarly find a string table. */
9455 if (dynamic_strings
== NULL
)
9457 for (entry
= dynamic_section
;
9458 entry
< dynamic_section
+ dynamic_nent
;
9461 unsigned long offset
;
9464 if (entry
->d_tag
!= DT_STRTAB
)
9467 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9469 /* Since we do not know how big the string table is,
9470 we default to reading in the entire file (!) and
9471 processing that. This is overkill, I know, but it
9474 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9476 if (archive_file_offset
!= 0)
9477 str_tab_len
= archive_file_size
- offset
;
9480 if (fseek (file
, 0, SEEK_END
))
9481 error (_("Unable to seek to end of file\n"));
9482 str_tab_len
= ftell (file
) - offset
;
9485 if (str_tab_len
< 1)
9488 (_("Unable to determine the length of the dynamic string table\n"));
9492 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9494 _("dynamic string table"));
9495 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9500 /* And find the syminfo section if available. */
9501 if (dynamic_syminfo
== NULL
)
9503 unsigned long syminsz
= 0;
9505 for (entry
= dynamic_section
;
9506 entry
< dynamic_section
+ dynamic_nent
;
9509 if (entry
->d_tag
== DT_SYMINENT
)
9511 /* Note: these braces are necessary to avoid a syntax
9512 error from the SunOS4 C compiler. */
9513 /* PR binutils/17531: A corrupt file can trigger this test.
9514 So do not use an assert, instead generate an error message. */
9515 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9516 error (_("Bad value (%d) for SYMINENT entry\n"),
9517 (int) entry
->d_un
.d_val
);
9519 else if (entry
->d_tag
== DT_SYMINSZ
)
9520 syminsz
= entry
->d_un
.d_val
;
9521 else if (entry
->d_tag
== DT_SYMINFO
)
9522 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9526 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9528 Elf_External_Syminfo
* extsyminfo
;
9529 Elf_External_Syminfo
* extsym
;
9530 Elf_Internal_Syminfo
* syminfo
;
9532 /* There is a syminfo section. Read the data. */
9533 extsyminfo
= (Elf_External_Syminfo
*)
9534 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9535 _("symbol information"));
9539 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9540 if (dynamic_syminfo
== NULL
)
9542 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9543 (unsigned long) syminsz
);
9547 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9548 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9549 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9550 ++syminfo
, ++extsym
)
9552 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9553 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9560 if (do_dynamic
&& dynamic_addr
)
9561 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9562 dynamic_addr
, (unsigned long) dynamic_nent
);
9564 printf (_(" Tag Type Name/Value\n"));
9566 for (entry
= dynamic_section
;
9567 entry
< dynamic_section
+ dynamic_nent
;
9575 print_vma (entry
->d_tag
, FULL_HEX
);
9576 dtype
= get_dynamic_type (entry
->d_tag
);
9577 printf (" (%s)%*s", dtype
,
9578 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9581 switch (entry
->d_tag
)
9585 print_dynamic_flags (entry
->d_un
.d_val
);
9595 switch (entry
->d_tag
)
9598 printf (_("Auxiliary library"));
9602 printf (_("Filter library"));
9606 printf (_("Configuration file"));
9610 printf (_("Dependency audit library"));
9614 printf (_("Audit library"));
9618 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9619 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9623 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9632 printf (_("Flags:"));
9634 if (entry
->d_un
.d_val
== 0)
9635 printf (_(" None\n"));
9638 unsigned long int val
= entry
->d_un
.d_val
;
9640 if (val
& DTF_1_PARINIT
)
9642 printf (" PARINIT");
9643 val
^= DTF_1_PARINIT
;
9645 if (val
& DTF_1_CONFEXP
)
9647 printf (" CONFEXP");
9648 val
^= DTF_1_CONFEXP
;
9651 printf (" %lx", val
);
9660 printf (_("Flags:"));
9662 if (entry
->d_un
.d_val
== 0)
9663 printf (_(" None\n"));
9666 unsigned long int val
= entry
->d_un
.d_val
;
9668 if (val
& DF_P1_LAZYLOAD
)
9670 printf (" LAZYLOAD");
9671 val
^= DF_P1_LAZYLOAD
;
9673 if (val
& DF_P1_GROUPPERM
)
9675 printf (" GROUPPERM");
9676 val
^= DF_P1_GROUPPERM
;
9679 printf (" %lx", val
);
9688 printf (_("Flags:"));
9689 if (entry
->d_un
.d_val
== 0)
9690 printf (_(" None\n"));
9693 unsigned long int val
= entry
->d_un
.d_val
;
9700 if (val
& DF_1_GLOBAL
)
9705 if (val
& DF_1_GROUP
)
9710 if (val
& DF_1_NODELETE
)
9712 printf (" NODELETE");
9713 val
^= DF_1_NODELETE
;
9715 if (val
& DF_1_LOADFLTR
)
9717 printf (" LOADFLTR");
9718 val
^= DF_1_LOADFLTR
;
9720 if (val
& DF_1_INITFIRST
)
9722 printf (" INITFIRST");
9723 val
^= DF_1_INITFIRST
;
9725 if (val
& DF_1_NOOPEN
)
9730 if (val
& DF_1_ORIGIN
)
9735 if (val
& DF_1_DIRECT
)
9740 if (val
& DF_1_TRANS
)
9745 if (val
& DF_1_INTERPOSE
)
9747 printf (" INTERPOSE");
9748 val
^= DF_1_INTERPOSE
;
9750 if (val
& DF_1_NODEFLIB
)
9752 printf (" NODEFLIB");
9753 val
^= DF_1_NODEFLIB
;
9755 if (val
& DF_1_NODUMP
)
9760 if (val
& DF_1_CONFALT
)
9762 printf (" CONFALT");
9763 val
^= DF_1_CONFALT
;
9765 if (val
& DF_1_ENDFILTEE
)
9767 printf (" ENDFILTEE");
9768 val
^= DF_1_ENDFILTEE
;
9770 if (val
& DF_1_DISPRELDNE
)
9772 printf (" DISPRELDNE");
9773 val
^= DF_1_DISPRELDNE
;
9775 if (val
& DF_1_DISPRELPND
)
9777 printf (" DISPRELPND");
9778 val
^= DF_1_DISPRELPND
;
9780 if (val
& DF_1_NODIRECT
)
9782 printf (" NODIRECT");
9783 val
^= DF_1_NODIRECT
;
9785 if (val
& DF_1_IGNMULDEF
)
9787 printf (" IGNMULDEF");
9788 val
^= DF_1_IGNMULDEF
;
9790 if (val
& DF_1_NOKSYMS
)
9792 printf (" NOKSYMS");
9793 val
^= DF_1_NOKSYMS
;
9795 if (val
& DF_1_NOHDR
)
9800 if (val
& DF_1_EDITED
)
9805 if (val
& DF_1_NORELOC
)
9807 printf (" NORELOC");
9808 val
^= DF_1_NORELOC
;
9810 if (val
& DF_1_SYMINTPOSE
)
9812 printf (" SYMINTPOSE");
9813 val
^= DF_1_SYMINTPOSE
;
9815 if (val
& DF_1_GLOBAUDIT
)
9817 printf (" GLOBAUDIT");
9818 val
^= DF_1_GLOBAUDIT
;
9820 if (val
& DF_1_SINGLETON
)
9822 printf (" SINGLETON");
9823 val
^= DF_1_SINGLETON
;
9825 if (val
& DF_1_STUB
)
9836 printf (" %lx", val
);
9843 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9845 puts (get_dynamic_type (entry
->d_un
.d_val
));
9865 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9871 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9872 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9878 switch (entry
->d_tag
)
9881 printf (_("Shared library: [%s]"), name
);
9883 if (streq (name
, program_interpreter
))
9884 printf (_(" program interpreter"));
9888 printf (_("Library soname: [%s]"), name
);
9892 printf (_("Library rpath: [%s]"), name
);
9896 printf (_("Library runpath: [%s]"), name
);
9900 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9905 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9918 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9923 case DT_INIT_ARRAYSZ
:
9924 case DT_FINI_ARRAYSZ
:
9925 case DT_GNU_CONFLICTSZ
:
9926 case DT_GNU_LIBLISTSZ
:
9929 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9930 printf (_(" (bytes)\n"));
9940 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9953 if (entry
->d_tag
== DT_USED
9954 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9956 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9960 printf (_("Not needed object: [%s]\n"), name
);
9965 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9971 /* The value of this entry is ignored. */
9976 case DT_GNU_PRELINKED
:
9980 time_t atime
= entry
->d_un
.d_val
;
9982 tmp
= gmtime (&atime
);
9983 /* PR 17533 file: 041-1244816-0.004. */
9985 printf (_("<corrupt time val: %lx"),
9986 (unsigned long) atime
);
9988 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9989 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9990 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9996 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9999 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10005 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10006 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10011 switch (elf_header
.e_machine
)
10014 case EM_MIPS_RS3_LE
:
10015 dynamic_section_mips_val (entry
);
10018 dynamic_section_parisc_val (entry
);
10021 dynamic_section_ia64_val (entry
);
10024 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10036 get_ver_flags (unsigned int flags
)
10038 static char buff
[32];
10045 if (flags
& VER_FLG_BASE
)
10046 strcat (buff
, "BASE");
10048 if (flags
& VER_FLG_WEAK
)
10050 if (flags
& VER_FLG_BASE
)
10051 strcat (buff
, " | ");
10053 strcat (buff
, "WEAK");
10056 if (flags
& VER_FLG_INFO
)
10058 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10059 strcat (buff
, " | ");
10061 strcat (buff
, "INFO");
10064 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10066 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10067 strcat (buff
, " | ");
10069 strcat (buff
, _("<unknown>"));
10075 /* Display the contents of the version sections. */
10078 process_version_sections (FILE * file
)
10080 Elf_Internal_Shdr
* section
;
10082 bfd_boolean found
= FALSE
;
10087 for (i
= 0, section
= section_headers
;
10088 i
< elf_header
.e_shnum
;
10091 switch (section
->sh_type
)
10093 case SHT_GNU_verdef
:
10095 Elf_External_Verdef
* edefs
;
10103 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10104 printable_section_name (section
),
10107 printf (_(" Addr: 0x"));
10108 printf_vma (section
->sh_addr
);
10109 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10110 (unsigned long) section
->sh_offset
, section
->sh_link
,
10111 printable_section_name_from_index (section
->sh_link
));
10113 edefs
= (Elf_External_Verdef
*)
10114 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10115 _("version definition section"));
10118 endbuf
= (char *) edefs
+ section
->sh_size
;
10120 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10121 end
= (section
->sh_info
< section
->sh_size
10122 ? section
->sh_info
: section
->sh_size
);
10123 for (idx
= cnt
= 0; cnt
< end
; ++cnt
)
10126 Elf_External_Verdef
* edef
;
10127 Elf_Internal_Verdef ent
;
10128 Elf_External_Verdaux
* eaux
;
10129 Elf_Internal_Verdaux aux
;
10133 /* Check for very large indices. */
10134 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10137 vstart
= ((char *) edefs
) + idx
;
10138 if (vstart
+ sizeof (*edef
) > endbuf
)
10141 edef
= (Elf_External_Verdef
*) vstart
;
10143 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10144 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10145 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10146 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10147 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10148 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10149 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10151 printf (_(" %#06x: Rev: %d Flags: %s"),
10152 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10154 printf (_(" Index: %d Cnt: %d "),
10155 ent
.vd_ndx
, ent
.vd_cnt
);
10157 /* Check for overflow. */
10158 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
))
10161 vstart
+= ent
.vd_aux
;
10163 eaux
= (Elf_External_Verdaux
*) vstart
;
10165 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10166 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10168 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10169 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10171 printf (_("Name index: %ld\n"), aux
.vda_name
);
10173 isum
= idx
+ ent
.vd_aux
;
10175 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10177 /* Check for overflow. */
10178 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10181 isum
+= aux
.vda_next
;
10182 vstart
+= aux
.vda_next
;
10184 eaux
= (Elf_External_Verdaux
*) vstart
;
10185 if (vstart
+ sizeof (*eaux
) > endbuf
)
10188 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10189 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10191 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10192 printf (_(" %#06x: Parent %d: %s\n"),
10193 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10195 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10196 isum
, j
, aux
.vda_name
);
10199 if (j
< ent
.vd_cnt
)
10200 printf (_(" Version def aux past end of section\n"));
10203 file: id:000001,src:000172+005151,op:splice,rep:2. */
10204 if (idx
+ ent
.vd_next
< idx
)
10207 idx
+= ent
.vd_next
;
10210 if (cnt
< section
->sh_info
)
10211 printf (_(" Version definition past end of section\n"));
10217 case SHT_GNU_verneed
:
10219 Elf_External_Verneed
* eneed
;
10226 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10227 printable_section_name (section
), section
->sh_info
);
10229 printf (_(" Addr: 0x"));
10230 printf_vma (section
->sh_addr
);
10231 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10232 (unsigned long) section
->sh_offset
, section
->sh_link
,
10233 printable_section_name_from_index (section
->sh_link
));
10235 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10236 section
->sh_offset
, 1,
10238 _("Version Needs section"));
10241 endbuf
= (char *) eneed
+ section
->sh_size
;
10243 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10245 Elf_External_Verneed
* entry
;
10246 Elf_Internal_Verneed ent
;
10251 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10254 vstart
= ((char *) eneed
) + idx
;
10255 if (vstart
+ sizeof (*entry
) > endbuf
)
10258 entry
= (Elf_External_Verneed
*) vstart
;
10260 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10261 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10262 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10263 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10264 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10266 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10268 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10269 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10271 printf (_(" File: %lx"), ent
.vn_file
);
10273 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10275 /* Check for overflow. */
10276 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10278 vstart
+= ent
.vn_aux
;
10280 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10282 Elf_External_Vernaux
* eaux
;
10283 Elf_Internal_Vernaux aux
;
10285 if (vstart
+ sizeof (*eaux
) > endbuf
)
10287 eaux
= (Elf_External_Vernaux
*) vstart
;
10289 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10290 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10291 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10292 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10293 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10295 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10296 printf (_(" %#06x: Name: %s"),
10297 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10299 printf (_(" %#06x: Name index: %lx"),
10300 isum
, aux
.vna_name
);
10302 printf (_(" Flags: %s Version: %d\n"),
10303 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10305 /* Check for overflow. */
10306 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10307 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10309 warn (_("Invalid vna_next field of %lx\n"),
10314 isum
+= aux
.vna_next
;
10315 vstart
+= aux
.vna_next
;
10318 if (j
< ent
.vn_cnt
)
10319 warn (_("Missing Version Needs auxillary information\n"));
10321 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10323 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10324 cnt
= section
->sh_info
;
10327 idx
+= ent
.vn_next
;
10330 if (cnt
< section
->sh_info
)
10331 warn (_("Missing Version Needs information\n"));
10337 case SHT_GNU_versym
:
10339 Elf_Internal_Shdr
* link_section
;
10342 unsigned char * edata
;
10343 unsigned short * data
;
10345 Elf_Internal_Sym
* symbols
;
10346 Elf_Internal_Shdr
* string_sec
;
10347 unsigned long num_syms
;
10350 if (section
->sh_link
>= elf_header
.e_shnum
)
10353 link_section
= section_headers
+ section
->sh_link
;
10354 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10356 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10361 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10362 if (symbols
== NULL
)
10365 string_sec
= section_headers
+ link_section
->sh_link
;
10367 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10368 string_sec
->sh_size
,
10369 _("version string table"));
10376 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10377 printable_section_name (section
), (unsigned long) total
);
10379 printf (_(" Addr: "));
10380 printf_vma (section
->sh_addr
);
10381 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10382 (unsigned long) section
->sh_offset
, section
->sh_link
,
10383 printable_section_name (link_section
));
10385 off
= offset_from_vma (file
,
10386 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10387 total
* sizeof (short));
10388 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10390 _("version symbol data"));
10398 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10400 for (cnt
= total
; cnt
--;)
10401 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10406 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10410 char *invalid
= _("*invalid*");
10412 printf (" %03x:", cnt
);
10414 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10415 switch (data
[cnt
+ j
])
10418 fputs (_(" 0 (*local*) "), stdout
);
10422 fputs (_(" 1 (*global*) "), stdout
);
10426 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10427 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10429 /* If this index value is greater than the size of the symbols
10430 array, break to avoid an out-of-bounds read. */
10431 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10433 warn (_("invalid index into symbol array\n"));
10438 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10440 Elf_Internal_Verneed ivn
;
10441 unsigned long offset
;
10443 offset
= offset_from_vma
10444 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10445 sizeof (Elf_External_Verneed
));
10449 Elf_Internal_Vernaux ivna
;
10450 Elf_External_Verneed evn
;
10451 Elf_External_Vernaux evna
;
10452 unsigned long a_off
;
10454 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10455 _("version need")) == NULL
)
10458 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10459 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10461 a_off
= offset
+ ivn
.vn_aux
;
10465 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10466 1, _("version need aux (2)")) == NULL
)
10469 ivna
.vna_other
= 0;
10473 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10474 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10477 a_off
+= ivna
.vna_next
;
10479 while (ivna
.vna_other
!= data
[cnt
+ j
]
10480 && ivna
.vna_next
!= 0);
10482 if (ivna
.vna_other
== data
[cnt
+ j
])
10484 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10486 if (ivna
.vna_name
>= string_sec
->sh_size
)
10489 name
= strtab
+ ivna
.vna_name
;
10493 offset
+= ivn
.vn_next
;
10495 while (ivn
.vn_next
);
10498 if (data
[cnt
+ j
] != 0x8001
10499 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10501 Elf_Internal_Verdef ivd
;
10502 Elf_External_Verdef evd
;
10503 unsigned long offset
;
10505 offset
= offset_from_vma
10506 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10511 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10512 _("version def")) == NULL
)
10515 /* PR 17531: file: 046-1082287-0.004. */
10516 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10521 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10522 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10525 offset
+= ivd
.vd_next
;
10527 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10528 && ivd
.vd_next
!= 0);
10530 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10532 Elf_External_Verdaux evda
;
10533 Elf_Internal_Verdaux ivda
;
10535 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10537 if (get_data (&evda
, file
,
10538 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10540 _("version def aux")) == NULL
)
10543 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10545 if (ivda
.vda_name
>= string_sec
->sh_size
)
10547 else if (name
!= NULL
&& name
!= invalid
)
10548 name
= _("*both*");
10550 name
= strtab
+ ivda
.vda_name
;
10554 nn
+= printf ("(%s%-*s",
10556 12 - (int) strlen (name
),
10560 printf ("%*c", 18 - nn
, ' ');
10578 printf (_("\nNo version information found in this file.\n"));
10583 static const char *
10584 get_symbol_binding (unsigned int binding
)
10586 static char buff
[32];
10590 case STB_LOCAL
: return "LOCAL";
10591 case STB_GLOBAL
: return "GLOBAL";
10592 case STB_WEAK
: return "WEAK";
10594 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10595 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10597 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10599 if (binding
== STB_GNU_UNIQUE
10600 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10601 /* GNU is still using the default value 0. */
10602 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10604 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10607 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10612 static const char *
10613 get_symbol_type (unsigned int type
)
10615 static char buff
[32];
10619 case STT_NOTYPE
: return "NOTYPE";
10620 case STT_OBJECT
: return "OBJECT";
10621 case STT_FUNC
: return "FUNC";
10622 case STT_SECTION
: return "SECTION";
10623 case STT_FILE
: return "FILE";
10624 case STT_COMMON
: return "COMMON";
10625 case STT_TLS
: return "TLS";
10626 case STT_RELC
: return "RELC";
10627 case STT_SRELC
: return "SRELC";
10629 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10631 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10632 return "THUMB_FUNC";
10634 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10637 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10638 return "PARISC_MILLI";
10640 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10642 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10644 if (elf_header
.e_machine
== EM_PARISC
)
10646 if (type
== STT_HP_OPAQUE
)
10647 return "HP_OPAQUE";
10648 if (type
== STT_HP_STUB
)
10652 if (type
== STT_GNU_IFUNC
10653 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10654 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10655 /* GNU is still using the default value 0. */
10656 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10659 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10662 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10667 static const char *
10668 get_symbol_visibility (unsigned int visibility
)
10670 switch (visibility
)
10672 case STV_DEFAULT
: return "DEFAULT";
10673 case STV_INTERNAL
: return "INTERNAL";
10674 case STV_HIDDEN
: return "HIDDEN";
10675 case STV_PROTECTED
: return "PROTECTED";
10677 error (_("Unrecognized visibility value: %u"), visibility
);
10678 return _("<unknown>");
10682 static const char *
10683 get_solaris_symbol_visibility (unsigned int visibility
)
10685 switch (visibility
)
10687 case 4: return "EXPORTED";
10688 case 5: return "SINGLETON";
10689 case 6: return "ELIMINATE";
10690 default: return get_symbol_visibility (visibility
);
10694 static const char *
10695 get_mips_symbol_other (unsigned int other
)
10699 case STO_OPTIONAL
: return "OPTIONAL";
10700 case STO_MIPS_PLT
: return "MIPS PLT";
10701 case STO_MIPS_PIC
: return "MIPS PIC";
10702 case STO_MICROMIPS
: return "MICROMIPS";
10703 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10704 case STO_MIPS16
: return "MIPS16";
10705 default: return NULL
;
10709 static const char *
10710 get_ia64_symbol_other (unsigned int other
)
10712 if (is_ia64_vms ())
10714 static char res
[32];
10718 /* Function types is for images and .STB files only. */
10719 switch (elf_header
.e_type
)
10723 switch (VMS_ST_FUNC_TYPE (other
))
10725 case VMS_SFT_CODE_ADDR
:
10726 strcat (res
, " CA");
10728 case VMS_SFT_SYMV_IDX
:
10729 strcat (res
, " VEC");
10732 strcat (res
, " FD");
10734 case VMS_SFT_RESERVE
:
10735 strcat (res
, " RSV");
10738 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10739 VMS_ST_FUNC_TYPE (other
));
10740 strcat (res
, " <unknown>");
10747 switch (VMS_ST_LINKAGE (other
))
10749 case VMS_STL_IGNORE
:
10750 strcat (res
, " IGN");
10752 case VMS_STL_RESERVE
:
10753 strcat (res
, " RSV");
10756 strcat (res
, " STD");
10759 strcat (res
, " LNK");
10762 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10763 VMS_ST_LINKAGE (other
));
10764 strcat (res
, " <unknown>");
10776 static const char *
10777 get_ppc64_symbol_other (unsigned int other
)
10779 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10781 static char buf
[32];
10782 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10783 PPC64_LOCAL_ENTRY_OFFSET (other
));
10789 static const char *
10790 get_symbol_other (unsigned int other
)
10792 const char * result
= NULL
;
10793 static char buff
[32];
10798 switch (elf_header
.e_machine
)
10801 result
= get_mips_symbol_other (other
);
10804 result
= get_ia64_symbol_other (other
);
10807 result
= get_ppc64_symbol_other (other
);
10817 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10821 static const char *
10822 get_symbol_index_type (unsigned int type
)
10824 static char buff
[32];
10828 case SHN_UNDEF
: return "UND";
10829 case SHN_ABS
: return "ABS";
10830 case SHN_COMMON
: return "COM";
10832 if (type
== SHN_IA_64_ANSI_COMMON
10833 && elf_header
.e_machine
== EM_IA_64
10834 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10836 else if ((elf_header
.e_machine
== EM_X86_64
10837 || elf_header
.e_machine
== EM_L1OM
10838 || elf_header
.e_machine
== EM_K1OM
)
10839 && type
== SHN_X86_64_LCOMMON
)
10840 return "LARGE_COM";
10841 else if ((type
== SHN_MIPS_SCOMMON
10842 && elf_header
.e_machine
== EM_MIPS
)
10843 || (type
== SHN_TIC6X_SCOMMON
10844 && elf_header
.e_machine
== EM_TI_C6000
))
10846 else if (type
== SHN_MIPS_SUNDEFINED
10847 && elf_header
.e_machine
== EM_MIPS
)
10849 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10850 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10851 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10852 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10853 else if (type
>= SHN_LORESERVE
)
10854 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10855 else if (type
>= elf_header
.e_shnum
)
10856 sprintf (buff
, _("bad section index[%3d]"), type
);
10858 sprintf (buff
, "%3d", type
);
10866 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10868 unsigned char * e_data
;
10871 /* If the size_t type is smaller than the bfd_size_type, eg because
10872 you are building a 32-bit tool on a 64-bit host, then make sure
10873 that when (number) is cast to (size_t) no information is lost. */
10874 if (sizeof (size_t) < sizeof (bfd_size_type
)
10875 && (bfd_size_type
) ((size_t) number
) != number
)
10877 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10878 " elements of size %u\n"),
10883 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10884 attempting to allocate memory when the read is bound to fail. */
10885 if (ent_size
* number
> current_file_size
)
10887 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10892 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10893 if (e_data
== NULL
)
10895 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10900 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10902 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10903 number
* ent_size
);
10908 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10909 if (i_data
== NULL
)
10911 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10912 " dynamic entries\n"),
10919 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10927 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10929 Elf_Internal_Sym
* psym
;
10932 n
= print_vma (si
, DEC_5
);
10934 fputs (&" "[n
], stdout
);
10935 printf (" %3lu: ", hn
);
10937 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10939 printf (_("<No info available for dynamic symbol number %lu>\n"),
10940 (unsigned long) si
);
10944 psym
= dynamic_symbols
+ si
;
10945 print_vma (psym
->st_value
, LONG_HEX
);
10947 print_vma (psym
->st_size
, DEC_5
);
10949 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10950 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10952 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10953 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10956 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10958 printf (" %-7s", get_symbol_visibility (vis
));
10959 /* Check to see if any other bits in the st_other field are set.
10960 Note - displaying this information disrupts the layout of the
10961 table being generated, but for the moment this case is very
10963 if (psym
->st_other
^ vis
)
10964 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10967 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10968 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10969 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10971 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10975 static const char *
10976 get_symbol_version_string (FILE * file
,
10977 bfd_boolean is_dynsym
,
10978 const char * strtab
,
10979 unsigned long int strtab_size
,
10981 Elf_Internal_Sym
* psym
,
10982 enum versioned_symbol_info
* sym_info
,
10983 unsigned short * vna_other
)
10985 unsigned char data
[2];
10986 unsigned short vers_data
;
10987 unsigned long offset
;
10990 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10993 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10994 sizeof data
+ si
* sizeof (vers_data
));
10996 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10997 sizeof (data
), 1, _("version data")) == NULL
)
11000 vers_data
= byte_get (data
, 2);
11002 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11005 /* Usually we'd only see verdef for defined symbols, and verneed for
11006 undefined symbols. However, symbols defined by the linker in
11007 .dynbss for variables copied from a shared library in order to
11008 avoid text relocations are defined yet have verneed. We could
11009 use a heuristic to detect the special case, for example, check
11010 for verneed first on symbols defined in SHT_NOBITS sections, but
11011 it is simpler and more reliable to just look for both verdef and
11012 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11014 if (psym
->st_shndx
!= SHN_UNDEF
11015 && vers_data
!= 0x8001
11016 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11018 Elf_Internal_Verdef ivd
;
11019 Elf_Internal_Verdaux ivda
;
11020 Elf_External_Verdaux evda
;
11023 off
= offset_from_vma (file
,
11024 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11025 sizeof (Elf_External_Verdef
));
11029 Elf_External_Verdef evd
;
11031 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11032 _("version def")) == NULL
)
11040 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11041 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11042 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11045 off
+= ivd
.vd_next
;
11047 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11049 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11051 off
-= ivd
.vd_next
;
11054 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11055 _("version def aux")) != NULL
)
11057 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11059 if (psym
->st_name
!= ivda
.vda_name
)
11061 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11062 ? symbol_hidden
: symbol_public
);
11063 return (ivda
.vda_name
< strtab_size
11064 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11070 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11072 Elf_External_Verneed evn
;
11073 Elf_Internal_Verneed ivn
;
11074 Elf_Internal_Vernaux ivna
;
11076 offset
= offset_from_vma (file
,
11077 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11081 unsigned long vna_off
;
11083 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11084 _("version need")) == NULL
)
11087 ivna
.vna_other
= 0;
11092 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11093 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11095 vna_off
= offset
+ ivn
.vn_aux
;
11099 Elf_External_Vernaux evna
;
11101 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11102 _("version need aux (3)")) == NULL
)
11105 ivna
.vna_other
= 0;
11110 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11111 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11112 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11115 vna_off
+= ivna
.vna_next
;
11117 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11119 if (ivna
.vna_other
== vers_data
)
11122 offset
+= ivn
.vn_next
;
11124 while (ivn
.vn_next
!= 0);
11126 if (ivna
.vna_other
== vers_data
)
11128 *sym_info
= symbol_undefined
;
11129 *vna_other
= ivna
.vna_other
;
11130 return (ivna
.vna_name
< strtab_size
11131 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11137 /* Dump the symbol table. */
11139 process_symbol_table (FILE * file
)
11141 Elf_Internal_Shdr
* section
;
11142 bfd_size_type nbuckets
= 0;
11143 bfd_size_type nchains
= 0;
11144 bfd_vma
* buckets
= NULL
;
11145 bfd_vma
* chains
= NULL
;
11146 bfd_vma ngnubuckets
= 0;
11147 bfd_vma
* gnubuckets
= NULL
;
11148 bfd_vma
* gnuchains
= NULL
;
11149 bfd_vma gnusymidx
= 0;
11150 bfd_size_type ngnuchains
= 0;
11152 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11155 if (dynamic_info
[DT_HASH
]
11157 || (do_using_dynamic
11159 && dynamic_strings
!= NULL
)))
11161 unsigned char nb
[8];
11162 unsigned char nc
[8];
11163 unsigned int hash_ent_size
= 4;
11165 if ((elf_header
.e_machine
== EM_ALPHA
11166 || elf_header
.e_machine
== EM_S390
11167 || elf_header
.e_machine
== EM_S390_OLD
)
11168 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11172 (archive_file_offset
11173 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11174 sizeof nb
+ sizeof nc
)),
11177 error (_("Unable to seek to start of dynamic information\n"));
11181 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11183 error (_("Failed to read in number of buckets\n"));
11187 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11189 error (_("Failed to read in number of chains\n"));
11193 nbuckets
= byte_get (nb
, hash_ent_size
);
11194 nchains
= byte_get (nc
, hash_ent_size
);
11196 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11197 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11200 if (buckets
== NULL
|| chains
== NULL
)
11202 if (do_using_dynamic
)
11213 if (dynamic_info_DT_GNU_HASH
11215 || (do_using_dynamic
11217 && dynamic_strings
!= NULL
)))
11219 unsigned char nb
[16];
11220 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11221 bfd_vma buckets_vma
;
11224 (archive_file_offset
11225 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11229 error (_("Unable to seek to start of dynamic information\n"));
11233 if (fread (nb
, 16, 1, file
) != 1)
11235 error (_("Failed to read in number of buckets\n"));
11239 ngnubuckets
= byte_get (nb
, 4);
11240 gnusymidx
= byte_get (nb
+ 4, 4);
11241 bitmaskwords
= byte_get (nb
+ 8, 4);
11242 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11244 buckets_vma
+= bitmaskwords
* 4;
11246 buckets_vma
+= bitmaskwords
* 8;
11249 (archive_file_offset
11250 + offset_from_vma (file
, buckets_vma
, 4)),
11253 error (_("Unable to seek to start of dynamic information\n"));
11257 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11259 if (gnubuckets
== NULL
)
11262 for (i
= 0; i
< ngnubuckets
; i
++)
11263 if (gnubuckets
[i
] != 0)
11265 if (gnubuckets
[i
] < gnusymidx
)
11268 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11269 maxchain
= gnubuckets
[i
];
11272 if (maxchain
== 0xffffffff)
11275 maxchain
-= gnusymidx
;
11278 (archive_file_offset
11279 + offset_from_vma (file
, buckets_vma
11280 + 4 * (ngnubuckets
+ maxchain
), 4)),
11283 error (_("Unable to seek to start of dynamic information\n"));
11289 if (fread (nb
, 4, 1, file
) != 1)
11291 error (_("Failed to determine last chain length\n"));
11295 if (maxchain
+ 1 == 0)
11300 while ((byte_get (nb
, 4) & 1) == 0);
11303 (archive_file_offset
11304 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11307 error (_("Unable to seek to start of dynamic information\n"));
11311 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11312 ngnuchains
= maxchain
;
11315 if (gnuchains
== NULL
)
11320 if (do_using_dynamic
)
11325 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11327 && do_using_dynamic
11328 && dynamic_strings
!= NULL
11329 && dynamic_symbols
!= NULL
)
11333 if (dynamic_info
[DT_HASH
])
11337 printf (_("\nSymbol table for image:\n"));
11339 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11341 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11343 for (hn
= 0; hn
< nbuckets
; hn
++)
11348 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11349 print_dynamic_symbol (si
, hn
);
11353 if (dynamic_info_DT_GNU_HASH
)
11355 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11357 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11359 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11361 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11362 if (gnubuckets
[hn
] != 0)
11364 bfd_vma si
= gnubuckets
[hn
];
11365 bfd_vma off
= si
- gnusymidx
;
11369 print_dynamic_symbol (si
, hn
);
11372 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11376 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11377 && section_headers
!= NULL
)
11381 for (i
= 0, section
= section_headers
;
11382 i
< elf_header
.e_shnum
;
11386 char * strtab
= NULL
;
11387 unsigned long int strtab_size
= 0;
11388 Elf_Internal_Sym
* symtab
;
11389 Elf_Internal_Sym
* psym
;
11390 unsigned long num_syms
;
11392 if ((section
->sh_type
!= SHT_SYMTAB
11393 && section
->sh_type
!= SHT_DYNSYM
)
11395 && section
->sh_type
== SHT_SYMTAB
))
11398 if (section
->sh_entsize
== 0)
11400 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11401 printable_section_name (section
));
11405 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11406 printable_section_name (section
),
11407 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11410 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11412 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11414 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11415 if (symtab
== NULL
)
11418 if (section
->sh_link
== elf_header
.e_shstrndx
)
11420 strtab
= string_table
;
11421 strtab_size
= string_table_length
;
11423 else if (section
->sh_link
< elf_header
.e_shnum
)
11425 Elf_Internal_Shdr
* string_sec
;
11427 string_sec
= section_headers
+ section
->sh_link
;
11429 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11430 1, string_sec
->sh_size
,
11431 _("string table"));
11432 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11435 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11437 const char *version_string
;
11438 enum versioned_symbol_info sym_info
;
11439 unsigned short vna_other
;
11441 printf ("%6d: ", si
);
11442 print_vma (psym
->st_value
, LONG_HEX
);
11444 print_vma (psym
->st_size
, DEC_5
);
11445 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11446 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11447 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11448 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11451 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11453 printf (" %-7s", get_symbol_visibility (vis
));
11454 /* Check to see if any other bits in the st_other field are set.
11455 Note - displaying this information disrupts the layout of the
11456 table being generated, but for the moment this case is very rare. */
11457 if (psym
->st_other
^ vis
)
11458 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11460 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11461 print_symbol (25, psym
->st_name
< strtab_size
11462 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11465 = get_symbol_version_string (file
,
11466 section
->sh_type
== SHT_DYNSYM
,
11467 strtab
, strtab_size
, si
,
11468 psym
, &sym_info
, &vna_other
);
11469 if (version_string
)
11471 if (sym_info
== symbol_undefined
)
11472 printf ("@%s (%d)", version_string
, vna_other
);
11474 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11480 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11481 && si
>= section
->sh_info
11482 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11483 && elf_header
.e_machine
!= EM_MIPS
11484 /* Solaris binaries have been found to violate this requirement as
11485 well. Not sure if this is a bug or an ABI requirement. */
11486 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11487 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11488 si
, printable_section_name (section
), section
->sh_info
);
11492 if (strtab
!= string_table
)
11498 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11500 if (do_histogram
&& buckets
!= NULL
)
11502 unsigned long * lengths
;
11503 unsigned long * counts
;
11506 unsigned long maxlength
= 0;
11507 unsigned long nzero_counts
= 0;
11508 unsigned long nsyms
= 0;
11509 unsigned long chained
;
11511 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11512 (unsigned long) nbuckets
);
11514 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11515 if (lengths
== NULL
)
11517 error (_("Out of memory allocating space for histogram buckets\n"));
11521 printf (_(" Length Number %% of total Coverage\n"));
11522 for (hn
= 0; hn
< nbuckets
; ++hn
)
11524 for (si
= buckets
[hn
], chained
= 0;
11525 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11526 si
= chains
[si
], ++chained
)
11529 if (maxlength
< ++lengths
[hn
])
11533 /* PR binutils/17531: A corrupt binary could contain broken
11534 histogram data. Do not go into an infinite loop trying
11536 if (chained
> nchains
)
11538 error (_("histogram chain is corrupt\n"));
11543 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11544 if (counts
== NULL
)
11547 error (_("Out of memory allocating space for histogram counts\n"));
11551 for (hn
= 0; hn
< nbuckets
; ++hn
)
11552 ++counts
[lengths
[hn
]];
11557 printf (" 0 %-10lu (%5.1f%%)\n",
11558 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11559 for (i
= 1; i
<= maxlength
; ++i
)
11561 nzero_counts
+= counts
[i
] * i
;
11562 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11563 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11564 (nzero_counts
* 100.0) / nsyms
);
11572 if (buckets
!= NULL
)
11578 if (do_histogram
&& gnubuckets
!= NULL
)
11580 unsigned long * lengths
;
11581 unsigned long * counts
;
11583 unsigned long maxlength
= 0;
11584 unsigned long nzero_counts
= 0;
11585 unsigned long nsyms
= 0;
11587 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11588 (unsigned long) ngnubuckets
);
11590 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11591 if (lengths
== NULL
)
11593 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11597 printf (_(" Length Number %% of total Coverage\n"));
11599 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11600 if (gnubuckets
[hn
] != 0)
11602 bfd_vma off
, length
= 1;
11604 for (off
= gnubuckets
[hn
] - gnusymidx
;
11605 /* PR 17531 file: 010-77222-0.004. */
11606 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11609 lengths
[hn
] = length
;
11610 if (length
> maxlength
)
11611 maxlength
= length
;
11615 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11616 if (counts
== NULL
)
11619 error (_("Out of memory allocating space for gnu histogram counts\n"));
11623 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11624 ++counts
[lengths
[hn
]];
11626 if (ngnubuckets
> 0)
11629 printf (" 0 %-10lu (%5.1f%%)\n",
11630 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11631 for (j
= 1; j
<= maxlength
; ++j
)
11633 nzero_counts
+= counts
[j
] * j
;
11634 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11635 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11636 (nzero_counts
* 100.0) / nsyms
);
11650 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11654 if (dynamic_syminfo
== NULL
11656 /* No syminfo, this is ok. */
11659 /* There better should be a dynamic symbol section. */
11660 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11664 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11665 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11667 printf (_(" Num: Name BoundTo Flags\n"));
11668 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11670 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11672 printf ("%4d: ", i
);
11673 if (i
>= num_dynamic_syms
)
11674 printf (_("<corrupt index>"));
11675 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11676 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11678 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11681 switch (dynamic_syminfo
[i
].si_boundto
)
11683 case SYMINFO_BT_SELF
:
11684 fputs ("SELF ", stdout
);
11686 case SYMINFO_BT_PARENT
:
11687 fputs ("PARENT ", stdout
);
11690 if (dynamic_syminfo
[i
].si_boundto
> 0
11691 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11692 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11694 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11698 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11702 if (flags
& SYMINFO_FLG_DIRECT
)
11703 printf (" DIRECT");
11704 if (flags
& SYMINFO_FLG_PASSTHRU
)
11705 printf (" PASSTHRU");
11706 if (flags
& SYMINFO_FLG_COPY
)
11708 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11709 printf (" LAZYLOAD");
11717 #define IN_RANGE(START,END,ADDR,OFF) \
11718 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11720 /* Check to see if the given reloc needs to be handled in a target specific
11721 manner. If so then process the reloc and return TRUE otherwise return
11724 If called with reloc == NULL, then this is a signal that reloc processing
11725 for the current section has finished, and any saved state should be
11729 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11730 unsigned char * start
,
11731 unsigned char * end
,
11732 Elf_Internal_Sym
* symtab
,
11733 unsigned long num_syms
)
11735 unsigned int reloc_type
= 0;
11736 unsigned long sym_index
= 0;
11740 reloc_type
= get_reloc_type (reloc
->r_info
);
11741 sym_index
= get_reloc_symindex (reloc
->r_info
);
11744 switch (elf_header
.e_machine
)
11747 case EM_MSP430_OLD
:
11749 static Elf_Internal_Sym
* saved_sym
= NULL
;
11757 switch (reloc_type
)
11759 case 10: /* R_MSP430_SYM_DIFF */
11760 if (uses_msp430x_relocs ())
11762 /* Fall through. */
11763 case 21: /* R_MSP430X_SYM_DIFF */
11765 if (sym_index
>= num_syms
)
11766 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11769 saved_sym
= symtab
+ sym_index
;
11772 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11773 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11774 goto handle_sym_diff
;
11776 case 5: /* R_MSP430_16_BYTE */
11777 case 9: /* R_MSP430_8 */
11778 if (uses_msp430x_relocs ())
11780 goto handle_sym_diff
;
11782 case 2: /* R_MSP430_ABS16 */
11783 case 15: /* R_MSP430X_ABS16 */
11784 if (! uses_msp430x_relocs ())
11786 goto handle_sym_diff
;
11789 if (saved_sym
!= NULL
)
11791 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11794 if (sym_index
>= num_syms
)
11795 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11799 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11800 - saved_sym
->st_value
);
11802 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11803 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11806 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11807 (long) reloc
->r_offset
);
11816 if (saved_sym
!= NULL
)
11817 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11824 case EM_CYGNUS_MN10300
:
11826 static Elf_Internal_Sym
* saved_sym
= NULL
;
11834 switch (reloc_type
)
11836 case 34: /* R_MN10300_ALIGN */
11838 case 33: /* R_MN10300_SYM_DIFF */
11839 if (sym_index
>= num_syms
)
11840 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11843 saved_sym
= symtab
+ sym_index
;
11846 case 1: /* R_MN10300_32 */
11847 case 2: /* R_MN10300_16 */
11848 if (saved_sym
!= NULL
)
11850 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11853 if (sym_index
>= num_syms
)
11854 error (_("MN10300 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
);
11864 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11865 (long) reloc
->r_offset
);
11873 if (saved_sym
!= NULL
)
11874 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11882 static bfd_vma saved_sym1
= 0;
11883 static bfd_vma saved_sym2
= 0;
11884 static bfd_vma value
;
11888 saved_sym1
= saved_sym2
= 0;
11892 switch (reloc_type
)
11894 case 0x80: /* R_RL78_SYM. */
11895 saved_sym1
= saved_sym2
;
11896 if (sym_index
>= num_syms
)
11897 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11901 saved_sym2
= symtab
[sym_index
].st_value
;
11902 saved_sym2
+= reloc
->r_addend
;
11906 case 0x83: /* R_RL78_OPsub. */
11907 value
= saved_sym1
- saved_sym2
;
11908 saved_sym2
= saved_sym1
= 0;
11912 case 0x41: /* R_RL78_ABS32. */
11913 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11914 byte_put (start
+ reloc
->r_offset
, value
, 4);
11916 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11917 (long) reloc
->r_offset
);
11921 case 0x43: /* R_RL78_ABS16. */
11922 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11923 byte_put (start
+ reloc
->r_offset
, value
, 2);
11925 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11926 (long) reloc
->r_offset
);
11940 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11941 DWARF debug sections. This is a target specific test. Note - we do not
11942 go through the whole including-target-headers-multiple-times route, (as
11943 we have already done with <elf/h8.h>) because this would become very
11944 messy and even then this function would have to contain target specific
11945 information (the names of the relocs instead of their numeric values).
11946 FIXME: This is not the correct way to solve this problem. The proper way
11947 is to have target specific reloc sizing and typing functions created by
11948 the reloc-macros.h header, in the same way that it already creates the
11949 reloc naming functions. */
11952 is_32bit_abs_reloc (unsigned int reloc_type
)
11954 /* Please keep this table alpha-sorted for ease of visual lookup. */
11955 switch (elf_header
.e_machine
)
11959 return reloc_type
== 1; /* R_386_32. */
11961 return reloc_type
== 1; /* R_68K_32. */
11963 return reloc_type
== 1; /* R_860_32. */
11965 return reloc_type
== 2; /* R_960_32. */
11967 return (reloc_type
== 258
11968 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11969 case EM_ADAPTEVA_EPIPHANY
:
11970 return reloc_type
== 3;
11972 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11974 return reloc_type
== 1; /* R_ARC_32. */
11975 case EM_ARC_COMPACT
:
11976 case EM_ARC_COMPACT2
:
11977 return reloc_type
== 4; /* R_ARC_32. */
11979 return reloc_type
== 2; /* R_ARM_ABS32 */
11982 return reloc_type
== 1;
11984 return reloc_type
== 0x12; /* R_byte4_data. */
11986 return reloc_type
== 3; /* R_CRIS_32. */
11988 return reloc_type
== 3; /* R_CR16_NUM32. */
11990 return reloc_type
== 15; /* R_CRX_NUM32. */
11991 case EM_CYGNUS_FRV
:
11992 return reloc_type
== 1;
11993 case EM_CYGNUS_D10V
:
11995 return reloc_type
== 6; /* R_D10V_32. */
11996 case EM_CYGNUS_D30V
:
11998 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12000 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12001 case EM_CYGNUS_FR30
:
12003 return reloc_type
== 3; /* R_FR30_32. */
12005 return reloc_type
== 1; /* R_FT32_32. */
12009 return reloc_type
== 1; /* R_H8_DIR32. */
12011 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12012 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
12015 return reloc_type
== 2; /* R_IP2K_32. */
12017 return reloc_type
== 2; /* R_IQ2000_32. */
12018 case EM_LATTICEMICO32
:
12019 return reloc_type
== 3; /* R_LM32_32. */
12022 return reloc_type
== 3; /* R_M32C_32. */
12024 return reloc_type
== 34; /* R_M32R_32_RELA. */
12027 return reloc_type
== 6; /* R_M68HC11_32. */
12029 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12030 case EM_CYGNUS_MEP
:
12031 return reloc_type
== 4; /* R_MEP_32. */
12033 return reloc_type
== 2; /* R_METAG_ADDR32. */
12034 case EM_MICROBLAZE
:
12035 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12037 return reloc_type
== 2; /* R_MIPS_32. */
12039 return reloc_type
== 4; /* R_MMIX_32. */
12040 case EM_CYGNUS_MN10200
:
12042 return reloc_type
== 1; /* R_MN10200_32. */
12043 case EM_CYGNUS_MN10300
:
12045 return reloc_type
== 1; /* R_MN10300_32. */
12047 return reloc_type
== 1; /* R_MOXIE_32. */
12048 case EM_MSP430_OLD
:
12050 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12052 return reloc_type
== 2; /* R_MT_32. */
12054 return reloc_type
== 20; /* R_NDS32_RELA. */
12055 case EM_ALTERA_NIOS2
:
12056 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12058 return reloc_type
== 1; /* R_NIOS_32. */
12060 return reloc_type
== 1; /* R_OR1K_32. */
12062 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12063 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12066 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12068 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12070 return reloc_type
== 1; /* R_PPC_ADDR32. */
12072 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12074 return reloc_type
== 1; /* R_RISCV_32. */
12076 return reloc_type
== 1; /* R_RL78_DIR32. */
12078 return reloc_type
== 1; /* R_RX_DIR32. */
12080 return reloc_type
== 1; /* R_I370_ADDR31. */
12083 return reloc_type
== 4; /* R_S390_32. */
12085 return reloc_type
== 8; /* R_SCORE_ABS32. */
12087 return reloc_type
== 1; /* R_SH_DIR32. */
12088 case EM_SPARC32PLUS
:
12091 return reloc_type
== 3 /* R_SPARC_32. */
12092 || reloc_type
== 23; /* R_SPARC_UA32. */
12094 return reloc_type
== 6; /* R_SPU_ADDR32 */
12096 return reloc_type
== 1; /* R_C6000_ABS32. */
12098 return reloc_type
== 2; /* R_TILEGX_32. */
12100 return reloc_type
== 1; /* R_TILEPRO_32. */
12101 case EM_CYGNUS_V850
:
12103 return reloc_type
== 6; /* R_V850_ABS32. */
12105 return reloc_type
== 0x33; /* R_V810_WORD. */
12107 return reloc_type
== 1; /* R_VAX_32. */
12109 return reloc_type
== 3; /* R_VISIUM_32. */
12110 case EM_WEBASSEMBLY
:
12111 return reloc_type
== 1; /* R_WASM32_32. */
12115 return reloc_type
== 10; /* R_X86_64_32. */
12118 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12120 return reloc_type
== 4; /* R_XGATE_32. */
12122 return reloc_type
== 1; /* R_XSTROMY16_32. */
12123 case EM_XTENSA_OLD
:
12125 return reloc_type
== 1; /* R_XTENSA_32. */
12128 static unsigned int prev_warn
= 0;
12130 /* Avoid repeating the same warning multiple times. */
12131 if (prev_warn
!= elf_header
.e_machine
)
12132 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12133 elf_header
.e_machine
);
12134 prev_warn
= elf_header
.e_machine
;
12140 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12141 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12144 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12146 switch (elf_header
.e_machine
)
12147 /* Please keep this table alpha-sorted for ease of visual lookup. */
12151 return reloc_type
== 2; /* R_386_PC32. */
12153 return reloc_type
== 4; /* R_68K_PC32. */
12155 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12156 case EM_ADAPTEVA_EPIPHANY
:
12157 return reloc_type
== 6;
12159 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12160 case EM_ARC_COMPACT
:
12161 case EM_ARC_COMPACT2
:
12162 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12164 return reloc_type
== 3; /* R_ARM_REL32 */
12167 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12168 case EM_MICROBLAZE
:
12169 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12171 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12173 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12175 return reloc_type
== 26; /* R_PPC_REL32. */
12177 return reloc_type
== 26; /* R_PPC64_REL32. */
12180 return reloc_type
== 5; /* R_390_PC32. */
12182 return reloc_type
== 2; /* R_SH_REL32. */
12183 case EM_SPARC32PLUS
:
12186 return reloc_type
== 6; /* R_SPARC_DISP32. */
12188 return reloc_type
== 13; /* R_SPU_REL32. */
12190 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12192 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12194 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12198 return reloc_type
== 2; /* R_X86_64_PC32. */
12199 case EM_XTENSA_OLD
:
12201 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12203 /* Do not abort or issue an error message here. Not all targets use
12204 pc-relative 32-bit relocs in their DWARF debug information and we
12205 have already tested for target coverage in is_32bit_abs_reloc. A
12206 more helpful warning message will be generated by apply_relocations
12207 anyway, so just return. */
12212 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12213 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12216 is_64bit_abs_reloc (unsigned int reloc_type
)
12218 switch (elf_header
.e_machine
)
12221 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12223 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12225 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12227 return reloc_type
== 80; /* R_PARISC_DIR64. */
12229 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12231 return reloc_type
== 2; /* R_RISCV_64. */
12232 case EM_SPARC32PLUS
:
12235 return reloc_type
== 54; /* R_SPARC_UA64. */
12239 return reloc_type
== 1; /* R_X86_64_64. */
12242 return reloc_type
== 22; /* R_S390_64. */
12244 return reloc_type
== 1; /* R_TILEGX_64. */
12246 return reloc_type
== 18; /* R_MIPS_64. */
12252 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12253 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12256 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12258 switch (elf_header
.e_machine
)
12261 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12263 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12265 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12267 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12269 return reloc_type
== 44; /* R_PPC64_REL64. */
12270 case EM_SPARC32PLUS
:
12273 return reloc_type
== 46; /* R_SPARC_DISP64. */
12277 return reloc_type
== 24; /* R_X86_64_PC64. */
12280 return reloc_type
== 23; /* R_S390_PC64. */
12282 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12288 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12289 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12292 is_24bit_abs_reloc (unsigned int reloc_type
)
12294 switch (elf_header
.e_machine
)
12296 case EM_CYGNUS_MN10200
:
12298 return reloc_type
== 4; /* R_MN10200_24. */
12300 return reloc_type
== 5; /* R_FT32_20. */
12306 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12307 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12310 is_16bit_abs_reloc (unsigned int reloc_type
)
12312 /* Please keep this table alpha-sorted for ease of visual lookup. */
12313 switch (elf_header
.e_machine
)
12316 case EM_ARC_COMPACT
:
12317 case EM_ARC_COMPACT2
:
12318 return reloc_type
== 2; /* R_ARC_16. */
12319 case EM_ADAPTEVA_EPIPHANY
:
12320 return reloc_type
== 5;
12323 return reloc_type
== 4; /* R_AVR_16. */
12324 case EM_CYGNUS_D10V
:
12326 return reloc_type
== 3; /* R_D10V_16. */
12330 return reloc_type
== R_H8_DIR16
;
12333 return reloc_type
== 1; /* R_IP2K_16. */
12336 return reloc_type
== 1; /* R_M32C_16 */
12337 case EM_CYGNUS_MN10200
:
12339 return reloc_type
== 2; /* R_MN10200_16. */
12340 case EM_CYGNUS_MN10300
:
12342 return reloc_type
== 2; /* R_MN10300_16. */
12344 if (uses_msp430x_relocs ())
12345 return reloc_type
== 2; /* R_MSP430_ABS16. */
12346 /* Fall through. */
12347 case EM_MSP430_OLD
:
12348 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12350 return reloc_type
== 19; /* R_NDS32_RELA. */
12351 case EM_ALTERA_NIOS2
:
12352 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12354 return reloc_type
== 9; /* R_NIOS_16. */
12356 return reloc_type
== 2; /* R_OR1K_16. */
12358 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12360 return reloc_type
== 2; /* R_C6000_ABS16. */
12362 return reloc_type
== 2; /* R_VISIUM_16. */
12365 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12367 return reloc_type
== 3; /* R_XGATE_16. */
12373 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12374 relocation entries (possibly formerly used for SHT_GROUP sections). */
12377 is_none_reloc (unsigned int reloc_type
)
12379 switch (elf_header
.e_machine
)
12381 case EM_386
: /* R_386_NONE. */
12382 case EM_68K
: /* R_68K_NONE. */
12383 case EM_ADAPTEVA_EPIPHANY
:
12384 case EM_ALPHA
: /* R_ALPHA_NONE. */
12385 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12386 case EM_ARC
: /* R_ARC_NONE. */
12387 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12388 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12389 case EM_ARM
: /* R_ARM_NONE. */
12390 case EM_C166
: /* R_XC16X_NONE. */
12391 case EM_CRIS
: /* R_CRIS_NONE. */
12392 case EM_FT32
: /* R_FT32_NONE. */
12393 case EM_IA_64
: /* R_IA64_NONE. */
12394 case EM_K1OM
: /* R_X86_64_NONE. */
12395 case EM_L1OM
: /* R_X86_64_NONE. */
12396 case EM_M32R
: /* R_M32R_NONE. */
12397 case EM_MIPS
: /* R_MIPS_NONE. */
12398 case EM_MN10300
: /* R_MN10300_NONE. */
12399 case EM_MOXIE
: /* R_MOXIE_NONE. */
12400 case EM_NIOS32
: /* R_NIOS_NONE. */
12401 case EM_OR1K
: /* R_OR1K_NONE. */
12402 case EM_PARISC
: /* R_PARISC_NONE. */
12403 case EM_PPC64
: /* R_PPC64_NONE. */
12404 case EM_PPC
: /* R_PPC_NONE. */
12405 case EM_RISCV
: /* R_RISCV_NONE. */
12406 case EM_S390
: /* R_390_NONE. */
12408 case EM_SH
: /* R_SH_NONE. */
12409 case EM_SPARC32PLUS
:
12410 case EM_SPARC
: /* R_SPARC_NONE. */
12412 case EM_TILEGX
: /* R_TILEGX_NONE. */
12413 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12414 case EM_TI_C6000
:/* R_C6000_NONE. */
12415 case EM_X86_64
: /* R_X86_64_NONE. */
12417 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12418 return reloc_type
== 0;
12421 return reloc_type
== 0 || reloc_type
== 256;
12424 return (reloc_type
== 0 /* R_AVR_NONE. */
12425 || reloc_type
== 30 /* R_AVR_DIFF8. */
12426 || reloc_type
== 31 /* R_AVR_DIFF16. */
12427 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12429 return reloc_type
== 3; /* R_METAG_NONE. */
12431 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12432 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12433 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12434 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12435 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12437 return (reloc_type
== 0 /* R_PRU_NONE. */
12438 || reloc_type
== 65 /* R_PRU_DIFF8. */
12439 || reloc_type
== 66 /* R_PRU_DIFF16. */
12440 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12441 case EM_XTENSA_OLD
:
12443 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12444 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12445 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12446 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12451 /* Returns TRUE if there is a relocation against
12452 section NAME at OFFSET bytes. */
12455 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12457 Elf_Internal_Rela
* relocs
;
12458 Elf_Internal_Rela
* rp
;
12460 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12463 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12465 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12466 if (rp
->r_offset
== offset
)
12472 /* Apply relocations to a section.
12473 Returns TRUE upon success, FALSE otherwise.
12474 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12475 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12476 will be set to the number of relocs loaded.
12478 Note: So far support has been added only for those relocations
12479 which can be found in debug sections. FIXME: Add support for
12480 more relocations ? */
12483 apply_relocations (void * file
,
12484 const Elf_Internal_Shdr
* section
,
12485 unsigned char * start
,
12486 bfd_size_type size
,
12487 void ** relocs_return
,
12488 unsigned long * num_relocs_return
)
12490 Elf_Internal_Shdr
* relsec
;
12491 unsigned char * end
= start
+ size
;
12492 bfd_boolean res
= TRUE
;
12494 if (relocs_return
!= NULL
)
12496 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12497 * num_relocs_return
= 0;
12500 if (elf_header
.e_type
!= ET_REL
)
12501 /* No relocs to apply. */
12504 /* Find the reloc section associated with the section. */
12505 for (relsec
= section_headers
;
12506 relsec
< section_headers
+ elf_header
.e_shnum
;
12509 bfd_boolean is_rela
;
12510 unsigned long num_relocs
;
12511 Elf_Internal_Rela
* relocs
;
12512 Elf_Internal_Rela
* rp
;
12513 Elf_Internal_Shdr
* symsec
;
12514 Elf_Internal_Sym
* symtab
;
12515 unsigned long num_syms
;
12516 Elf_Internal_Sym
* sym
;
12518 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12519 || relsec
->sh_info
>= elf_header
.e_shnum
12520 || section_headers
+ relsec
->sh_info
!= section
12521 || relsec
->sh_size
== 0
12522 || relsec
->sh_link
>= elf_header
.e_shnum
)
12525 is_rela
= relsec
->sh_type
== SHT_RELA
;
12529 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12530 relsec
->sh_size
, & relocs
, & num_relocs
))
12535 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12536 relsec
->sh_size
, & relocs
, & num_relocs
))
12540 /* SH uses RELA but uses in place value instead of the addend field. */
12541 if (elf_header
.e_machine
== EM_SH
)
12544 symsec
= section_headers
+ relsec
->sh_link
;
12545 if (symsec
->sh_type
!= SHT_SYMTAB
12546 && symsec
->sh_type
!= SHT_DYNSYM
)
12548 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12550 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12553 unsigned int reloc_type
;
12554 unsigned int reloc_size
;
12555 unsigned char * rloc
;
12556 unsigned long sym_index
;
12558 reloc_type
= get_reloc_type (rp
->r_info
);
12560 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12562 else if (is_none_reloc (reloc_type
))
12564 else if (is_32bit_abs_reloc (reloc_type
)
12565 || is_32bit_pcrel_reloc (reloc_type
))
12567 else if (is_64bit_abs_reloc (reloc_type
)
12568 || is_64bit_pcrel_reloc (reloc_type
))
12570 else if (is_24bit_abs_reloc (reloc_type
))
12572 else if (is_16bit_abs_reloc (reloc_type
))
12576 static unsigned int prev_reloc
= 0;
12577 if (reloc_type
!= prev_reloc
)
12578 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12579 reloc_type
, printable_section_name (section
));
12580 prev_reloc
= reloc_type
;
12585 rloc
= start
+ rp
->r_offset
;
12586 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12588 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12589 (unsigned long) rp
->r_offset
,
12590 printable_section_name (section
));
12595 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12596 if (sym_index
>= num_syms
)
12598 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12599 sym_index
, printable_section_name (section
));
12603 sym
= symtab
+ sym_index
;
12605 /* If the reloc has a symbol associated with it,
12606 make sure that it is of an appropriate type.
12608 Relocations against symbols without type can happen.
12609 Gcc -feliminate-dwarf2-dups may generate symbols
12610 without type for debug info.
12612 Icc generates relocations against function symbols
12613 instead of local labels.
12615 Relocations against object symbols can happen, eg when
12616 referencing a global array. For an example of this see
12617 the _clz.o binary in libgcc.a. */
12619 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12620 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12622 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12623 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12624 (long int)(rp
- relocs
),
12625 printable_section_name (relsec
));
12632 addend
+= rp
->r_addend
;
12633 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12634 partial_inplace. */
12636 || (elf_header
.e_machine
== EM_XTENSA
12637 && reloc_type
== 1)
12638 || ((elf_header
.e_machine
== EM_PJ
12639 || elf_header
.e_machine
== EM_PJ_OLD
)
12640 && reloc_type
== 1)
12641 || ((elf_header
.e_machine
== EM_D30V
12642 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12643 && reloc_type
== 12))
12644 addend
+= byte_get (rloc
, reloc_size
);
12646 if (is_32bit_pcrel_reloc (reloc_type
)
12647 || is_64bit_pcrel_reloc (reloc_type
))
12649 /* On HPPA, all pc-relative relocations are biased by 8. */
12650 if (elf_header
.e_machine
== EM_PARISC
)
12652 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12656 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12660 /* Let the target specific reloc processing code know that
12661 we have finished with these relocs. */
12662 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12666 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12667 * num_relocs_return
= num_relocs
;
12678 #ifdef SUPPORT_DISASSEMBLY
12680 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12682 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12684 /* FIXME: XXX -- to be done --- XXX */
12690 /* Reads in the contents of SECTION from FILE, returning a pointer
12691 to a malloc'ed buffer or NULL if something went wrong. */
12694 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12696 bfd_size_type num_bytes
;
12698 num_bytes
= section
->sh_size
;
12700 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12702 printf (_("\nSection '%s' has no data to dump.\n"),
12703 printable_section_name (section
));
12707 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12708 _("section contents"));
12711 /* Uncompresses a section that was compressed using zlib, in place. */
12714 uncompress_section_contents (unsigned char **buffer
,
12715 dwarf_size_type uncompressed_size
,
12716 dwarf_size_type
*size
)
12718 dwarf_size_type compressed_size
= *size
;
12719 unsigned char * compressed_buffer
= *buffer
;
12720 unsigned char * uncompressed_buffer
;
12724 /* It is possible the section consists of several compressed
12725 buffers concatenated together, so we uncompress in a loop. */
12726 /* PR 18313: The state field in the z_stream structure is supposed
12727 to be invisible to the user (ie us), but some compilers will
12728 still complain about it being used without initialisation. So
12729 we first zero the entire z_stream structure and then set the fields
12731 memset (& strm
, 0, sizeof strm
);
12732 strm
.avail_in
= compressed_size
;
12733 strm
.next_in
= (Bytef
*) compressed_buffer
;
12734 strm
.avail_out
= uncompressed_size
;
12735 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12737 rc
= inflateInit (& strm
);
12738 while (strm
.avail_in
> 0)
12742 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12743 + (uncompressed_size
- strm
.avail_out
));
12744 rc
= inflate (&strm
, Z_FINISH
);
12745 if (rc
!= Z_STREAM_END
)
12747 rc
= inflateReset (& strm
);
12749 rc
= inflateEnd (& strm
);
12751 || strm
.avail_out
!= 0)
12754 *buffer
= uncompressed_buffer
;
12755 *size
= uncompressed_size
;
12759 free (uncompressed_buffer
);
12760 /* Indicate decompression failure. */
12766 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12768 Elf_Internal_Shdr
* relsec
;
12769 bfd_size_type num_bytes
;
12770 unsigned char * data
;
12771 unsigned char * end
;
12772 unsigned char * real_start
;
12773 unsigned char * start
;
12774 bfd_boolean some_strings_shown
;
12776 real_start
= start
= (unsigned char *) get_section_contents (section
,
12780 num_bytes
= section
->sh_size
;
12782 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12784 if (decompress_dumps
)
12786 dwarf_size_type new_size
= num_bytes
;
12787 dwarf_size_type uncompressed_size
= 0;
12789 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12791 Elf_Internal_Chdr chdr
;
12792 unsigned int compression_header_size
12793 = get_compression_header (& chdr
, (unsigned char *) start
,
12796 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12798 warn (_("section '%s' has unsupported compress type: %d\n"),
12799 printable_section_name (section
), chdr
.ch_type
);
12802 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12804 warn (_("compressed section '%s' is corrupted\n"),
12805 printable_section_name (section
));
12808 uncompressed_size
= chdr
.ch_size
;
12809 start
+= compression_header_size
;
12810 new_size
-= compression_header_size
;
12812 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12814 /* Read the zlib header. In this case, it should be "ZLIB"
12815 followed by the uncompressed section size, 8 bytes in
12816 big-endian order. */
12817 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12818 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12819 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12820 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12821 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12822 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12823 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12824 uncompressed_size
+= start
[11];
12829 if (uncompressed_size
)
12831 if (uncompress_section_contents (& start
,
12832 uncompressed_size
, & new_size
))
12833 num_bytes
= new_size
;
12836 error (_("Unable to decompress section %s\n"),
12837 printable_section_name (section
));
12842 start
= real_start
;
12845 /* If the section being dumped has relocations against it the user might
12846 be expecting these relocations to have been applied. Check for this
12847 case and issue a warning message in order to avoid confusion.
12848 FIXME: Maybe we ought to have an option that dumps a section with
12849 relocs applied ? */
12850 for (relsec
= section_headers
;
12851 relsec
< section_headers
+ elf_header
.e_shnum
;
12854 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12855 || relsec
->sh_info
>= elf_header
.e_shnum
12856 || section_headers
+ relsec
->sh_info
!= section
12857 || relsec
->sh_size
== 0
12858 || relsec
->sh_link
>= elf_header
.e_shnum
)
12861 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12866 end
= start
+ num_bytes
;
12867 some_strings_shown
= FALSE
;
12871 while (!ISPRINT (* data
))
12872 if (++ data
>= end
)
12877 size_t maxlen
= end
- data
;
12880 /* PR 11128: Use two separate invocations in order to work
12881 around bugs in the Solaris 8 implementation of printf. */
12882 printf (" [%6tx] ", data
- start
);
12884 printf (" [%6Ix] ", (size_t) (data
- start
));
12888 print_symbol ((int) maxlen
, (const char *) data
);
12890 data
+= strnlen ((const char *) data
, maxlen
);
12894 printf (_("<corrupt>\n"));
12897 some_strings_shown
= TRUE
;
12901 if (! some_strings_shown
)
12902 printf (_(" No strings found in this section."));
12911 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12913 bfd_boolean relocate
)
12915 Elf_Internal_Shdr
* relsec
;
12916 bfd_size_type bytes
;
12917 bfd_size_type section_size
;
12919 unsigned char * data
;
12920 unsigned char * real_start
;
12921 unsigned char * start
;
12923 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12927 section_size
= section
->sh_size
;
12929 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12931 if (decompress_dumps
)
12933 dwarf_size_type new_size
= section_size
;
12934 dwarf_size_type uncompressed_size
= 0;
12936 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12938 Elf_Internal_Chdr chdr
;
12939 unsigned int compression_header_size
12940 = get_compression_header (& chdr
, start
, section_size
);
12942 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12944 warn (_("section '%s' has unsupported compress type: %d\n"),
12945 printable_section_name (section
), chdr
.ch_type
);
12948 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12950 warn (_("compressed section '%s' is corrupted\n"),
12951 printable_section_name (section
));
12954 uncompressed_size
= chdr
.ch_size
;
12955 start
+= compression_header_size
;
12956 new_size
-= compression_header_size
;
12958 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12960 /* Read the zlib header. In this case, it should be "ZLIB"
12961 followed by the uncompressed section size, 8 bytes in
12962 big-endian order. */
12963 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12964 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12965 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12966 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12967 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12968 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12969 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12970 uncompressed_size
+= start
[11];
12975 if (uncompressed_size
)
12977 if (uncompress_section_contents (& start
, uncompressed_size
,
12980 section_size
= new_size
;
12984 error (_("Unable to decompress section %s\n"),
12985 printable_section_name (section
));
12986 /* FIXME: Print the section anyway ? */
12991 start
= real_start
;
12996 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
13001 /* If the section being dumped has relocations against it the user might
13002 be expecting these relocations to have been applied. Check for this
13003 case and issue a warning message in order to avoid confusion.
13004 FIXME: Maybe we ought to have an option that dumps a section with
13005 relocs applied ? */
13006 for (relsec
= section_headers
;
13007 relsec
< section_headers
+ elf_header
.e_shnum
;
13010 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13011 || relsec
->sh_info
>= elf_header
.e_shnum
13012 || section_headers
+ relsec
->sh_info
!= section
13013 || relsec
->sh_size
== 0
13014 || relsec
->sh_link
>= elf_header
.e_shnum
)
13017 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13022 addr
= section
->sh_addr
;
13023 bytes
= section_size
;
13032 lbytes
= (bytes
> 16 ? 16 : bytes
);
13034 printf (" 0x%8.8lx ", (unsigned long) addr
);
13036 for (j
= 0; j
< 16; j
++)
13039 printf ("%2.2x", data
[j
]);
13047 for (j
= 0; j
< lbytes
; j
++)
13050 if (k
>= ' ' && k
< 0x7f)
13070 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13071 const Elf_Internal_Shdr
* sec
, void * file
)
13073 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13076 /* If it is already loaded, do nothing. */
13077 if (section
->start
!= NULL
)
13080 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13081 section
->address
= sec
->sh_addr
;
13082 section
->user_data
= NULL
;
13083 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13085 sec
->sh_size
, buf
);
13086 if (section
->start
== NULL
)
13090 unsigned char *start
= section
->start
;
13091 dwarf_size_type size
= sec
->sh_size
;
13092 dwarf_size_type uncompressed_size
= 0;
13094 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13096 Elf_Internal_Chdr chdr
;
13097 unsigned int compression_header_size
;
13099 if (size
< (is_32bit_elf
13100 ? sizeof (Elf32_External_Chdr
)
13101 : sizeof (Elf64_External_Chdr
)))
13103 warn (_("compressed section %s is too small to contain a compression header"),
13108 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13110 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13112 warn (_("section '%s' has unsupported compress type: %d\n"),
13113 section
->name
, chdr
.ch_type
);
13116 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13118 warn (_("compressed section '%s' is corrupted\n"),
13122 uncompressed_size
= chdr
.ch_size
;
13123 start
+= compression_header_size
;
13124 size
-= compression_header_size
;
13126 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13128 /* Read the zlib header. In this case, it should be "ZLIB"
13129 followed by the uncompressed section size, 8 bytes in
13130 big-endian order. */
13131 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13132 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13133 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13134 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13135 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13136 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13137 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13138 uncompressed_size
+= start
[11];
13143 if (uncompressed_size
)
13145 if (uncompress_section_contents (&start
, uncompressed_size
,
13148 /* Free the compressed buffer, update the section buffer
13149 and the section size if uncompress is successful. */
13150 free (section
->start
);
13151 section
->start
= start
;
13155 error (_("Unable to decompress section %s\n"),
13156 printable_section_name (sec
));
13161 section
->size
= size
;
13164 if (section
->start
== NULL
)
13167 if (debug_displays
[debug
].relocate
)
13169 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13170 & section
->reloc_info
, & section
->num_relocs
))
13175 section
->reloc_info
= NULL
;
13176 section
->num_relocs
= 0;
13182 /* If this is not NULL, load_debug_section will only look for sections
13183 within the list of sections given here. */
13184 static unsigned int * section_subset
= NULL
;
13187 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13189 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13190 Elf_Internal_Shdr
* sec
;
13192 /* Locate the debug section. */
13193 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13195 section
->name
= section
->uncompressed_name
;
13198 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13200 section
->name
= section
->compressed_name
;
13205 /* If we're loading from a subset of sections, and we've loaded
13206 a section matching this name before, it's likely that it's a
13208 if (section_subset
!= NULL
)
13209 free_debug_section (debug
);
13211 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13215 free_debug_section (enum dwarf_section_display_enum debug
)
13217 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13219 if (section
->start
== NULL
)
13222 free ((char *) section
->start
);
13223 section
->start
= NULL
;
13224 section
->address
= 0;
13229 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13231 char * name
= SECTION_NAME (section
);
13232 const char * print_name
= printable_section_name (section
);
13233 bfd_size_type length
;
13234 bfd_boolean result
= TRUE
;
13237 length
= section
->sh_size
;
13240 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13243 if (section
->sh_type
== SHT_NOBITS
)
13245 /* There is no point in dumping the contents of a debugging section
13246 which has the NOBITS type - the bits in the file will be random.
13247 This can happen when a file containing a .eh_frame section is
13248 stripped with the --only-keep-debug command line option. */
13249 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13254 if (const_strneq (name
, ".gnu.linkonce.wi."))
13255 name
= ".debug_info";
13257 /* See if we know how to display the contents of this section. */
13258 for (i
= 0; i
< max
; i
++)
13259 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13260 || (i
== line
&& const_strneq (name
, ".debug_line."))
13261 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13263 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13264 int secondary
= (section
!= find_section (name
));
13267 free_debug_section ((enum dwarf_section_display_enum
) i
);
13269 if (i
== line
&& const_strneq (name
, ".debug_line."))
13271 else if (streq (sec
->uncompressed_name
, name
))
13272 sec
->name
= sec
->uncompressed_name
;
13274 sec
->name
= sec
->compressed_name
;
13275 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13278 /* If this debug section is part of a CU/TU set in a .dwp file,
13279 restrict load_debug_section to the sections in that set. */
13280 section_subset
= find_cu_tu_set (file
, shndx
);
13282 result
&= debug_displays
[i
].display (sec
, file
);
13284 section_subset
= NULL
;
13286 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13287 free_debug_section ((enum dwarf_section_display_enum
) i
);
13295 printf (_("Unrecognized debug section: %s\n"), print_name
);
13302 /* Set DUMP_SECTS for all sections where dumps were requested
13303 based on section name. */
13306 initialise_dumps_byname (void)
13308 struct dump_list_entry
* cur
;
13310 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13313 bfd_boolean any
= FALSE
;
13315 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13316 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13318 request_dump_bynumber (i
, cur
->type
);
13323 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13329 process_section_contents (FILE * file
)
13331 Elf_Internal_Shdr
* section
;
13333 bfd_boolean res
= TRUE
;
13338 initialise_dumps_byname ();
13340 for (i
= 0, section
= section_headers
;
13341 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13344 #ifdef SUPPORT_DISASSEMBLY
13345 if (dump_sects
[i
] & DISASS_DUMP
)
13346 disassemble_section (section
, file
);
13348 if (dump_sects
[i
] & HEX_DUMP
)
13350 if (! dump_section_as_bytes (section
, file
, FALSE
))
13354 if (dump_sects
[i
] & RELOC_DUMP
)
13356 if (! dump_section_as_bytes (section
, file
, TRUE
))
13360 if (dump_sects
[i
] & STRING_DUMP
)
13362 if (! dump_section_as_strings (section
, file
))
13366 if (dump_sects
[i
] & DEBUG_DUMP
)
13368 if (! display_debug_section (i
, section
, file
))
13373 /* Check to see if the user requested a
13374 dump of a section that does not exist. */
13375 while (i
< num_dump_sects
)
13379 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13389 process_mips_fpe_exception (int mask
)
13393 bfd_boolean first
= TRUE
;
13395 if (mask
& OEX_FPU_INEX
)
13396 fputs ("INEX", stdout
), first
= FALSE
;
13397 if (mask
& OEX_FPU_UFLO
)
13398 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13399 if (mask
& OEX_FPU_OFLO
)
13400 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13401 if (mask
& OEX_FPU_DIV0
)
13402 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13403 if (mask
& OEX_FPU_INVAL
)
13404 printf ("%sINVAL", first
? "" : "|");
13407 fputs ("0", stdout
);
13410 /* Display's the value of TAG at location P. If TAG is
13411 greater than 0 it is assumed to be an unknown tag, and
13412 a message is printed to this effect. Otherwise it is
13413 assumed that a message has already been printed.
13415 If the bottom bit of TAG is set it assumed to have a
13416 string value, otherwise it is assumed to have an integer
13419 Returns an updated P pointing to the first unread byte
13420 beyond the end of TAG's value.
13422 Reads at or beyond END will not be made. */
13424 static unsigned char *
13425 display_tag_value (signed int tag
,
13427 const unsigned char * const end
)
13432 printf (" Tag_unknown_%d: ", tag
);
13436 warn (_("<corrupt tag>\n"));
13440 /* PR 17531 file: 027-19978-0.004. */
13441 size_t maxlen
= (end
- p
) - 1;
13446 print_symbol ((int) maxlen
, (const char *) p
);
13447 p
+= strnlen ((char *) p
, maxlen
) + 1;
13451 printf (_("<corrupt string tag>"));
13452 p
= (unsigned char *) end
;
13460 val
= read_uleb128 (p
, &len
, end
);
13462 printf ("%ld (0x%lx)\n", val
, val
);
13469 /* ARM EABI attributes section. */
13474 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13476 const char ** table
;
13477 } arm_attr_public_tag
;
13479 static const char * arm_attr_tag_CPU_arch
[] =
13480 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13481 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13483 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13484 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13485 {"No", "Thumb-1", "Thumb-2", "Yes"};
13486 static const char * arm_attr_tag_FP_arch
[] =
13487 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13488 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13489 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13490 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13491 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13492 "NEON for ARMv8.1"};
13493 static const char * arm_attr_tag_PCS_config
[] =
13494 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13495 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13496 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13497 {"V6", "SB", "TLS", "Unused"};
13498 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13499 {"Absolute", "PC-relative", "SB-relative", "None"};
13500 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13501 {"Absolute", "PC-relative", "None"};
13502 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13503 {"None", "direct", "GOT-indirect"};
13504 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13505 {"None", "??? 1", "2", "??? 3", "4"};
13506 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13507 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13508 {"Unused", "Needed", "Sign only"};
13509 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13510 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13511 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13512 {"Unused", "Finite", "RTABI", "IEEE 754"};
13513 static const char * arm_attr_tag_ABI_enum_size
[] =
13514 {"Unused", "small", "int", "forced to int"};
13515 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13516 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13517 static const char * arm_attr_tag_ABI_VFP_args
[] =
13518 {"AAPCS", "VFP registers", "custom", "compatible"};
13519 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13520 {"AAPCS", "WMMX registers", "custom"};
13521 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13522 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13523 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13524 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13525 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13526 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13527 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13528 static const char * arm_attr_tag_FP_HP_extension
[] =
13529 {"Not Allowed", "Allowed"};
13530 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13531 {"None", "IEEE 754", "Alternative Format"};
13532 static const char * arm_attr_tag_DSP_extension
[] =
13533 {"Follow architecture", "Allowed"};
13534 static const char * arm_attr_tag_MPextension_use
[] =
13535 {"Not Allowed", "Allowed"};
13536 static const char * arm_attr_tag_DIV_use
[] =
13537 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13538 "Allowed in v7-A with integer division extension"};
13539 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13540 static const char * arm_attr_tag_Virtualization_use
[] =
13541 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13542 "TrustZone and Virtualization Extensions"};
13543 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13544 {"Not Allowed", "Allowed"};
13546 #define LOOKUP(id, name) \
13547 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13548 static arm_attr_public_tag arm_attr_public_tags
[] =
13550 {4, "CPU_raw_name", 1, NULL
},
13551 {5, "CPU_name", 1, NULL
},
13552 LOOKUP(6, CPU_arch
),
13553 {7, "CPU_arch_profile", 0, NULL
},
13554 LOOKUP(8, ARM_ISA_use
),
13555 LOOKUP(9, THUMB_ISA_use
),
13556 LOOKUP(10, FP_arch
),
13557 LOOKUP(11, WMMX_arch
),
13558 LOOKUP(12, Advanced_SIMD_arch
),
13559 LOOKUP(13, PCS_config
),
13560 LOOKUP(14, ABI_PCS_R9_use
),
13561 LOOKUP(15, ABI_PCS_RW_data
),
13562 LOOKUP(16, ABI_PCS_RO_data
),
13563 LOOKUP(17, ABI_PCS_GOT_use
),
13564 LOOKUP(18, ABI_PCS_wchar_t
),
13565 LOOKUP(19, ABI_FP_rounding
),
13566 LOOKUP(20, ABI_FP_denormal
),
13567 LOOKUP(21, ABI_FP_exceptions
),
13568 LOOKUP(22, ABI_FP_user_exceptions
),
13569 LOOKUP(23, ABI_FP_number_model
),
13570 {24, "ABI_align_needed", 0, NULL
},
13571 {25, "ABI_align_preserved", 0, NULL
},
13572 LOOKUP(26, ABI_enum_size
),
13573 LOOKUP(27, ABI_HardFP_use
),
13574 LOOKUP(28, ABI_VFP_args
),
13575 LOOKUP(29, ABI_WMMX_args
),
13576 LOOKUP(30, ABI_optimization_goals
),
13577 LOOKUP(31, ABI_FP_optimization_goals
),
13578 {32, "compatibility", 0, NULL
},
13579 LOOKUP(34, CPU_unaligned_access
),
13580 LOOKUP(36, FP_HP_extension
),
13581 LOOKUP(38, ABI_FP_16bit_format
),
13582 LOOKUP(42, MPextension_use
),
13583 LOOKUP(44, DIV_use
),
13584 LOOKUP(46, DSP_extension
),
13585 {64, "nodefaults", 0, NULL
},
13586 {65, "also_compatible_with", 0, NULL
},
13587 LOOKUP(66, T2EE_use
),
13588 {67, "conformance", 1, NULL
},
13589 LOOKUP(68, Virtualization_use
),
13590 LOOKUP(70, MPextension_use_legacy
)
13594 static unsigned char *
13595 display_arm_attribute (unsigned char * p
,
13596 const unsigned char * const end
)
13601 arm_attr_public_tag
* attr
;
13605 tag
= read_uleb128 (p
, &len
, end
);
13608 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13610 if (arm_attr_public_tags
[i
].tag
== tag
)
13612 attr
= &arm_attr_public_tags
[i
];
13619 printf (" Tag_%s: ", attr
->name
);
13620 switch (attr
->type
)
13625 case 7: /* Tag_CPU_arch_profile. */
13626 val
= read_uleb128 (p
, &len
, end
);
13630 case 0: printf (_("None\n")); break;
13631 case 'A': printf (_("Application\n")); break;
13632 case 'R': printf (_("Realtime\n")); break;
13633 case 'M': printf (_("Microcontroller\n")); break;
13634 case 'S': printf (_("Application or Realtime\n")); break;
13635 default: printf ("??? (%d)\n", val
); break;
13639 case 24: /* Tag_align_needed. */
13640 val
= read_uleb128 (p
, &len
, end
);
13644 case 0: printf (_("None\n")); break;
13645 case 1: printf (_("8-byte\n")); break;
13646 case 2: printf (_("4-byte\n")); break;
13647 case 3: printf ("??? 3\n"); break;
13650 printf (_("8-byte and up to %d-byte extended\n"),
13653 printf ("??? (%d)\n", val
);
13658 case 25: /* Tag_align_preserved. */
13659 val
= read_uleb128 (p
, &len
, end
);
13663 case 0: printf (_("None\n")); break;
13664 case 1: printf (_("8-byte, except leaf SP\n")); break;
13665 case 2: printf (_("8-byte\n")); break;
13666 case 3: printf ("??? 3\n"); break;
13669 printf (_("8-byte and up to %d-byte extended\n"),
13672 printf ("??? (%d)\n", val
);
13677 case 32: /* Tag_compatibility. */
13679 val
= read_uleb128 (p
, &len
, end
);
13681 printf (_("flag = %d, vendor = "), val
);
13684 size_t maxlen
= (end
- p
) - 1;
13686 print_symbol ((int) maxlen
, (const char *) p
);
13687 p
+= strnlen ((char *) p
, maxlen
) + 1;
13691 printf (_("<corrupt>"));
13692 p
= (unsigned char *) end
;
13698 case 64: /* Tag_nodefaults. */
13699 /* PR 17531: file: 001-505008-0.01. */
13702 printf (_("True\n"));
13705 case 65: /* Tag_also_compatible_with. */
13706 val
= read_uleb128 (p
, &len
, end
);
13708 if (val
== 6 /* Tag_CPU_arch. */)
13710 val
= read_uleb128 (p
, &len
, end
);
13712 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13713 printf ("??? (%d)\n", val
);
13715 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13719 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13724 printf (_("<unknown: %d>\n"), tag
);
13730 return display_tag_value (-1, p
, end
);
13732 return display_tag_value (0, p
, end
);
13735 assert (attr
->type
& 0x80);
13736 val
= read_uleb128 (p
, &len
, end
);
13738 type
= attr
->type
& 0x7f;
13740 printf ("??? (%d)\n", val
);
13742 printf ("%s\n", attr
->table
[val
]);
13747 return display_tag_value (tag
, p
, end
);
13750 static unsigned char *
13751 display_gnu_attribute (unsigned char * p
,
13752 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13753 const unsigned char * const end
)
13759 tag
= read_uleb128 (p
, &len
, end
);
13762 /* Tag_compatibility is the only generic GNU attribute defined at
13766 val
= read_uleb128 (p
, &len
, end
);
13769 printf (_("flag = %d, vendor = "), val
);
13772 printf (_("<corrupt>\n"));
13773 warn (_("corrupt vendor attribute\n"));
13779 size_t maxlen
= (end
- p
) - 1;
13781 print_symbol ((int) maxlen
, (const char *) p
);
13782 p
+= strnlen ((char *) p
, maxlen
) + 1;
13786 printf (_("<corrupt>"));
13787 p
= (unsigned char *) end
;
13794 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13795 return display_proc_gnu_attribute (p
, tag
, end
);
13797 return display_tag_value (tag
, p
, end
);
13800 static unsigned char *
13801 display_power_gnu_attribute (unsigned char * p
,
13803 const unsigned char * const end
)
13808 if (tag
== Tag_GNU_Power_ABI_FP
)
13810 val
= read_uleb128 (p
, &len
, end
);
13812 printf (" Tag_GNU_Power_ABI_FP: ");
13815 printf (_("<corrupt>\n"));
13820 printf ("(%#x), ", val
);
13825 printf (_("unspecified hard/soft float, "));
13828 printf (_("hard float, "));
13831 printf (_("soft float, "));
13834 printf (_("single-precision hard float, "));
13841 printf (_("unspecified long double\n"));
13844 printf (_("128-bit IBM long double\n"));
13847 printf (_("64-bit long double\n"));
13850 printf (_("128-bit IEEE long double\n"));
13856 if (tag
== Tag_GNU_Power_ABI_Vector
)
13858 val
= read_uleb128 (p
, &len
, end
);
13860 printf (" Tag_GNU_Power_ABI_Vector: ");
13863 printf (_("<corrupt>\n"));
13868 printf ("(%#x), ", val
);
13873 printf (_("unspecified\n"));
13876 printf (_("generic\n"));
13879 printf ("AltiVec\n");
13888 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13890 val
= read_uleb128 (p
, &len
, end
);
13892 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13895 printf (_("<corrupt>\n"));
13900 printf ("(%#x), ", val
);
13905 printf (_("unspecified\n"));
13908 printf ("r3/r4\n");
13911 printf (_("memory\n"));
13920 return display_tag_value (tag
& 1, p
, end
);
13923 static unsigned char *
13924 display_s390_gnu_attribute (unsigned char * p
,
13926 const unsigned char * const end
)
13931 if (tag
== Tag_GNU_S390_ABI_Vector
)
13933 val
= read_uleb128 (p
, &len
, end
);
13935 printf (" Tag_GNU_S390_ABI_Vector: ");
13940 printf (_("any\n"));
13943 printf (_("software\n"));
13946 printf (_("hardware\n"));
13949 printf ("??? (%d)\n", val
);
13955 return display_tag_value (tag
& 1, p
, end
);
13959 display_sparc_hwcaps (unsigned int mask
)
13963 bfd_boolean first
= TRUE
;
13965 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13966 fputs ("mul32", stdout
), first
= FALSE
;
13967 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13968 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
13969 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13970 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
13971 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13972 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
13973 if (mask
& ELF_SPARC_HWCAP_POPC
)
13974 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
13975 if (mask
& ELF_SPARC_HWCAP_VIS
)
13976 printf ("%svis", first
? "" : "|"), first
= FALSE
;
13977 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13978 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
13979 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13980 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
13981 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13982 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
13983 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13984 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
13985 if (mask
& ELF_SPARC_HWCAP_HPC
)
13986 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
13987 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13988 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
13989 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13990 printf ("%strans", first
? "" : "|"), first
= FALSE
;
13991 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13992 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
13993 if (mask
& ELF_SPARC_HWCAP_IMA
)
13994 printf ("%sima", first
? "" : "|"), first
= FALSE
;
13995 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13996 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
13999 fputc ('0', stdout
);
14000 fputc ('\n', stdout
);
14004 display_sparc_hwcaps2 (unsigned int mask
)
14008 bfd_boolean first
= TRUE
;
14010 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14011 fputs ("fjathplus", stdout
), first
= FALSE
;
14012 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14013 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14014 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14015 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14016 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14017 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14018 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14019 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14020 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14021 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14022 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14023 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14024 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14025 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14026 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14027 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14028 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14029 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14030 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14031 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14034 fputc ('0', stdout
);
14035 fputc ('\n', stdout
);
14038 static unsigned char *
14039 display_sparc_gnu_attribute (unsigned char * p
,
14041 const unsigned char * const end
)
14046 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14048 val
= read_uleb128 (p
, &len
, end
);
14050 printf (" Tag_GNU_Sparc_HWCAPS: ");
14051 display_sparc_hwcaps (val
);
14054 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14056 val
= read_uleb128 (p
, &len
, end
);
14058 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14059 display_sparc_hwcaps2 (val
);
14063 return display_tag_value (tag
, p
, end
);
14067 print_mips_fp_abi_value (unsigned int val
)
14071 case Val_GNU_MIPS_ABI_FP_ANY
:
14072 printf (_("Hard or soft float\n"));
14074 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14075 printf (_("Hard float (double precision)\n"));
14077 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14078 printf (_("Hard float (single precision)\n"));
14080 case Val_GNU_MIPS_ABI_FP_SOFT
:
14081 printf (_("Soft float\n"));
14083 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14084 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14086 case Val_GNU_MIPS_ABI_FP_XX
:
14087 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14089 case Val_GNU_MIPS_ABI_FP_64
:
14090 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14092 case Val_GNU_MIPS_ABI_FP_64A
:
14093 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14095 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14096 printf (_("NaN 2008 compatibility\n"));
14099 printf ("??? (%d)\n", val
);
14104 static unsigned char *
14105 display_mips_gnu_attribute (unsigned char * p
,
14107 const unsigned char * const end
)
14109 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14114 val
= read_uleb128 (p
, &len
, end
);
14116 printf (" Tag_GNU_MIPS_ABI_FP: ");
14118 print_mips_fp_abi_value (val
);
14123 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14128 val
= read_uleb128 (p
, &len
, end
);
14130 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14134 case Val_GNU_MIPS_ABI_MSA_ANY
:
14135 printf (_("Any MSA or not\n"));
14137 case Val_GNU_MIPS_ABI_MSA_128
:
14138 printf (_("128-bit MSA\n"));
14141 printf ("??? (%d)\n", val
);
14147 return display_tag_value (tag
& 1, p
, end
);
14150 static unsigned char *
14151 display_tic6x_attribute (unsigned char * p
,
14152 const unsigned char * const end
)
14158 tag
= read_uleb128 (p
, &len
, end
);
14164 val
= read_uleb128 (p
, &len
, end
);
14166 printf (" Tag_ISA: ");
14170 case C6XABI_Tag_ISA_none
:
14171 printf (_("None\n"));
14173 case C6XABI_Tag_ISA_C62X
:
14176 case C6XABI_Tag_ISA_C67X
:
14179 case C6XABI_Tag_ISA_C67XP
:
14180 printf ("C67x+\n");
14182 case C6XABI_Tag_ISA_C64X
:
14185 case C6XABI_Tag_ISA_C64XP
:
14186 printf ("C64x+\n");
14188 case C6XABI_Tag_ISA_C674X
:
14189 printf ("C674x\n");
14192 printf ("??? (%d)\n", val
);
14197 case Tag_ABI_wchar_t
:
14198 val
= read_uleb128 (p
, &len
, end
);
14200 printf (" Tag_ABI_wchar_t: ");
14204 printf (_("Not used\n"));
14207 printf (_("2 bytes\n"));
14210 printf (_("4 bytes\n"));
14213 printf ("??? (%d)\n", val
);
14218 case Tag_ABI_stack_align_needed
:
14219 val
= read_uleb128 (p
, &len
, end
);
14221 printf (" Tag_ABI_stack_align_needed: ");
14225 printf (_("8-byte\n"));
14228 printf (_("16-byte\n"));
14231 printf ("??? (%d)\n", val
);
14236 case Tag_ABI_stack_align_preserved
:
14237 val
= read_uleb128 (p
, &len
, end
);
14239 printf (" Tag_ABI_stack_align_preserved: ");
14243 printf (_("8-byte\n"));
14246 printf (_("16-byte\n"));
14249 printf ("??? (%d)\n", val
);
14255 val
= read_uleb128 (p
, &len
, end
);
14257 printf (" Tag_ABI_DSBT: ");
14261 printf (_("DSBT addressing not used\n"));
14264 printf (_("DSBT addressing used\n"));
14267 printf ("??? (%d)\n", val
);
14273 val
= read_uleb128 (p
, &len
, end
);
14275 printf (" Tag_ABI_PID: ");
14279 printf (_("Data addressing position-dependent\n"));
14282 printf (_("Data addressing position-independent, GOT near DP\n"));
14285 printf (_("Data addressing position-independent, GOT far from DP\n"));
14288 printf ("??? (%d)\n", val
);
14294 val
= read_uleb128 (p
, &len
, end
);
14296 printf (" Tag_ABI_PIC: ");
14300 printf (_("Code addressing position-dependent\n"));
14303 printf (_("Code addressing position-independent\n"));
14306 printf ("??? (%d)\n", val
);
14311 case Tag_ABI_array_object_alignment
:
14312 val
= read_uleb128 (p
, &len
, end
);
14314 printf (" Tag_ABI_array_object_alignment: ");
14318 printf (_("8-byte\n"));
14321 printf (_("4-byte\n"));
14324 printf (_("16-byte\n"));
14327 printf ("??? (%d)\n", val
);
14332 case Tag_ABI_array_object_align_expected
:
14333 val
= read_uleb128 (p
, &len
, end
);
14335 printf (" Tag_ABI_array_object_align_expected: ");
14339 printf (_("8-byte\n"));
14342 printf (_("4-byte\n"));
14345 printf (_("16-byte\n"));
14348 printf ("??? (%d)\n", val
);
14353 case Tag_ABI_compatibility
:
14355 val
= read_uleb128 (p
, &len
, end
);
14357 printf (" Tag_ABI_compatibility: ");
14358 printf (_("flag = %d, vendor = "), val
);
14361 size_t maxlen
= (end
- p
) - 1;
14363 print_symbol ((int) maxlen
, (const char *) p
);
14364 p
+= strnlen ((char *) p
, maxlen
) + 1;
14368 printf (_("<corrupt>"));
14369 p
= (unsigned char *) end
;
14375 case Tag_ABI_conformance
:
14377 printf (" Tag_ABI_conformance: \"");
14380 size_t maxlen
= (end
- p
) - 1;
14382 print_symbol ((int) maxlen
, (const char *) p
);
14383 p
+= strnlen ((char *) p
, maxlen
) + 1;
14387 printf (_("<corrupt>"));
14388 p
= (unsigned char *) end
;
14395 return display_tag_value (tag
, p
, end
);
14399 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14401 unsigned long addr
= 0;
14402 size_t bytes
= end
- p
;
14409 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14411 printf (" 0x%8.8lx ", addr
);
14413 for (j
= 0; j
< 16; j
++)
14416 printf ("%2.2x", p
[j
]);
14424 for (j
= 0; j
< lbytes
; j
++)
14427 if (k
>= ' ' && k
< 0x7f)
14443 static unsigned char *
14444 display_msp430x_attribute (unsigned char * p
,
14445 const unsigned char * const end
)
14451 tag
= read_uleb128 (p
, & len
, end
);
14456 case OFBA_MSPABI_Tag_ISA
:
14457 val
= read_uleb128 (p
, &len
, end
);
14459 printf (" Tag_ISA: ");
14462 case 0: printf (_("None\n")); break;
14463 case 1: printf (_("MSP430\n")); break;
14464 case 2: printf (_("MSP430X\n")); break;
14465 default: printf ("??? (%d)\n", val
); break;
14469 case OFBA_MSPABI_Tag_Code_Model
:
14470 val
= read_uleb128 (p
, &len
, end
);
14472 printf (" Tag_Code_Model: ");
14475 case 0: printf (_("None\n")); break;
14476 case 1: printf (_("Small\n")); break;
14477 case 2: printf (_("Large\n")); break;
14478 default: printf ("??? (%d)\n", val
); break;
14482 case OFBA_MSPABI_Tag_Data_Model
:
14483 val
= read_uleb128 (p
, &len
, end
);
14485 printf (" Tag_Data_Model: ");
14488 case 0: printf (_("None\n")); break;
14489 case 1: printf (_("Small\n")); break;
14490 case 2: printf (_("Large\n")); break;
14491 case 3: printf (_("Restricted Large\n")); break;
14492 default: printf ("??? (%d)\n", val
); break;
14497 printf (_(" <unknown tag %d>: "), tag
);
14504 size_t maxlen
= (end
- p
) - 1;
14506 print_symbol ((int) maxlen
, (const char *) p
);
14507 p
+= strnlen ((char *) p
, maxlen
) + 1;
14511 printf (_("<corrupt>"));
14512 p
= (unsigned char *) end
;
14518 val
= read_uleb128 (p
, &len
, end
);
14520 printf ("%d (0x%x)\n", val
, val
);
14530 process_attributes (FILE * file
,
14531 const char * public_name
,
14532 unsigned int proc_type
,
14533 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14534 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14536 Elf_Internal_Shdr
* sect
;
14538 bfd_boolean res
= TRUE
;
14540 /* Find the section header so that we get the size. */
14541 for (i
= 0, sect
= section_headers
;
14542 i
< elf_header
.e_shnum
;
14545 unsigned char * contents
;
14548 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14551 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14552 sect
->sh_size
, _("attributes"));
14553 if (contents
== NULL
)
14560 /* The first character is the version of the attributes.
14561 Currently only version 1, (aka 'A') is recognised here. */
14564 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14569 bfd_vma section_len
;
14571 section_len
= sect
->sh_size
- 1;
14574 while (section_len
> 0)
14577 unsigned int namelen
;
14578 bfd_boolean public_section
;
14579 bfd_boolean gnu_section
;
14581 if (section_len
<= 4)
14583 error (_("Tag section ends prematurely\n"));
14587 attr_len
= byte_get (p
, 4);
14590 if (attr_len
> section_len
)
14592 error (_("Bad attribute length (%u > %u)\n"),
14593 (unsigned) attr_len
, (unsigned) section_len
);
14594 attr_len
= section_len
;
14597 /* PR 17531: file: 001-101425-0.004 */
14598 else if (attr_len
< 5)
14600 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14605 section_len
-= attr_len
;
14608 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14609 if (namelen
== 0 || namelen
>= attr_len
)
14611 error (_("Corrupt attribute section name\n"));
14616 printf (_("Attribute Section: "));
14617 print_symbol (INT_MAX
, (const char *) p
);
14620 if (public_name
&& streq ((char *) p
, public_name
))
14621 public_section
= TRUE
;
14623 public_section
= FALSE
;
14625 if (streq ((char *) p
, "gnu"))
14626 gnu_section
= TRUE
;
14628 gnu_section
= FALSE
;
14631 attr_len
-= namelen
;
14633 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14638 unsigned char * end
;
14640 /* PR binutils/17531: Safe handling of corrupt files. */
14643 error (_("Unused bytes at end of section\n"));
14650 size
= byte_get (p
, 4);
14651 if (size
> attr_len
)
14653 error (_("Bad subsection length (%u > %u)\n"),
14654 (unsigned) size
, (unsigned) attr_len
);
14658 /* PR binutils/17531: Safe handling of corrupt files. */
14661 error (_("Bad subsection length (%u < 6)\n"),
14669 end
= p
+ size
- 1;
14670 assert (end
<= contents
+ sect
->sh_size
);
14676 printf (_("File Attributes\n"));
14679 printf (_("Section Attributes:"));
14682 printf (_("Symbol Attributes:"));
14683 /* Fall through. */
14689 val
= read_uleb128 (p
, &j
, end
);
14693 printf (" %d", val
);
14698 printf (_("Unknown tag: %d\n"), tag
);
14699 public_section
= FALSE
;
14703 if (public_section
&& display_pub_attribute
!= NULL
)
14706 p
= display_pub_attribute (p
, end
);
14709 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14712 p
= display_gnu_attribute (p
,
14713 display_proc_gnu_attribute
,
14719 printf (_(" Unknown attribute:\n"));
14720 display_raw_attribute (p
, end
);
14735 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14736 Print the Address, Access and Initial fields of an entry at VMA ADDR
14737 and return the VMA of the next entry, or -1 if there was a problem.
14738 Does not read from DATA_END or beyond. */
14741 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14742 unsigned char * data_end
)
14745 print_vma (addr
, LONG_HEX
);
14747 if (addr
< pltgot
+ 0xfff0)
14748 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14750 printf ("%10s", "");
14753 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14757 unsigned char * from
= data
+ addr
- pltgot
;
14759 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14761 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14762 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14763 return (bfd_vma
) -1;
14767 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14768 print_vma (entry
, LONG_HEX
);
14771 return addr
+ (is_32bit_elf
? 4 : 8);
14774 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14775 PLTGOT. Print the Address and Initial fields of an entry at VMA
14776 ADDR and return the VMA of the next entry. */
14779 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14782 print_vma (addr
, LONG_HEX
);
14785 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14790 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14791 print_vma (entry
, LONG_HEX
);
14793 return addr
+ (is_32bit_elf
? 4 : 8);
14797 print_mips_ases (unsigned int mask
)
14799 if (mask
& AFL_ASE_DSP
)
14800 fputs ("\n\tDSP ASE", stdout
);
14801 if (mask
& AFL_ASE_DSPR2
)
14802 fputs ("\n\tDSP R2 ASE", stdout
);
14803 if (mask
& AFL_ASE_DSPR3
)
14804 fputs ("\n\tDSP R3 ASE", stdout
);
14805 if (mask
& AFL_ASE_EVA
)
14806 fputs ("\n\tEnhanced VA Scheme", stdout
);
14807 if (mask
& AFL_ASE_MCU
)
14808 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14809 if (mask
& AFL_ASE_MDMX
)
14810 fputs ("\n\tMDMX ASE", stdout
);
14811 if (mask
& AFL_ASE_MIPS3D
)
14812 fputs ("\n\tMIPS-3D ASE", stdout
);
14813 if (mask
& AFL_ASE_MT
)
14814 fputs ("\n\tMT ASE", stdout
);
14815 if (mask
& AFL_ASE_SMARTMIPS
)
14816 fputs ("\n\tSmartMIPS ASE", stdout
);
14817 if (mask
& AFL_ASE_VIRT
)
14818 fputs ("\n\tVZ ASE", stdout
);
14819 if (mask
& AFL_ASE_MSA
)
14820 fputs ("\n\tMSA ASE", stdout
);
14821 if (mask
& AFL_ASE_MIPS16
)
14822 fputs ("\n\tMIPS16 ASE", stdout
);
14823 if (mask
& AFL_ASE_MICROMIPS
)
14824 fputs ("\n\tMICROMIPS ASE", stdout
);
14825 if (mask
& AFL_ASE_XPA
)
14826 fputs ("\n\tXPA ASE", stdout
);
14828 fprintf (stdout
, "\n\t%s", _("None"));
14829 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14830 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14834 print_mips_isa_ext (unsigned int isa_ext
)
14839 fputs (_("None"), stdout
);
14842 fputs ("RMI XLR", stdout
);
14844 case AFL_EXT_OCTEON3
:
14845 fputs ("Cavium Networks Octeon3", stdout
);
14847 case AFL_EXT_OCTEON2
:
14848 fputs ("Cavium Networks Octeon2", stdout
);
14850 case AFL_EXT_OCTEONP
:
14851 fputs ("Cavium Networks OcteonP", stdout
);
14853 case AFL_EXT_LOONGSON_3A
:
14854 fputs ("Loongson 3A", stdout
);
14856 case AFL_EXT_OCTEON
:
14857 fputs ("Cavium Networks Octeon", stdout
);
14860 fputs ("Toshiba R5900", stdout
);
14863 fputs ("MIPS R4650", stdout
);
14866 fputs ("LSI R4010", stdout
);
14869 fputs ("NEC VR4100", stdout
);
14872 fputs ("Toshiba R3900", stdout
);
14874 case AFL_EXT_10000
:
14875 fputs ("MIPS R10000", stdout
);
14878 fputs ("Broadcom SB-1", stdout
);
14881 fputs ("NEC VR4111/VR4181", stdout
);
14884 fputs ("NEC VR4120", stdout
);
14887 fputs ("NEC VR5400", stdout
);
14890 fputs ("NEC VR5500", stdout
);
14892 case AFL_EXT_LOONGSON_2E
:
14893 fputs ("ST Microelectronics Loongson 2E", stdout
);
14895 case AFL_EXT_LOONGSON_2F
:
14896 fputs ("ST Microelectronics Loongson 2F", stdout
);
14899 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14904 get_mips_reg_size (int reg_size
)
14906 return (reg_size
== AFL_REG_NONE
) ? 0
14907 : (reg_size
== AFL_REG_32
) ? 32
14908 : (reg_size
== AFL_REG_64
) ? 64
14909 : (reg_size
== AFL_REG_128
) ? 128
14914 process_mips_specific (FILE * file
)
14916 Elf_Internal_Dyn
* entry
;
14917 Elf_Internal_Shdr
*sect
= NULL
;
14918 size_t liblist_offset
= 0;
14919 size_t liblistno
= 0;
14920 size_t conflictsno
= 0;
14921 size_t options_offset
= 0;
14922 size_t conflicts_offset
= 0;
14923 size_t pltrelsz
= 0;
14925 bfd_vma pltgot
= 0;
14926 bfd_vma mips_pltgot
= 0;
14927 bfd_vma jmprel
= 0;
14928 bfd_vma local_gotno
= 0;
14929 bfd_vma gotsym
= 0;
14930 bfd_vma symtabno
= 0;
14931 bfd_boolean res
= TRUE
;
14933 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14934 display_mips_gnu_attribute
))
14937 sect
= find_section (".MIPS.abiflags");
14941 Elf_External_ABIFlags_v0
*abiflags_ext
;
14942 Elf_Internal_ABIFlags_v0 abiflags_in
;
14944 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14946 error (_("Corrupt MIPS ABI Flags section.\n"));
14951 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14952 sect
->sh_size
, _("MIPS ABI Flags section"));
14955 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14956 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14957 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14958 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14959 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14960 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14961 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14962 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14963 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14964 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14965 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14967 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14968 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14969 if (abiflags_in
.isa_rev
> 1)
14970 printf ("r%d", abiflags_in
.isa_rev
);
14971 printf ("\nGPR size: %d",
14972 get_mips_reg_size (abiflags_in
.gpr_size
));
14973 printf ("\nCPR1 size: %d",
14974 get_mips_reg_size (abiflags_in
.cpr1_size
));
14975 printf ("\nCPR2 size: %d",
14976 get_mips_reg_size (abiflags_in
.cpr2_size
));
14977 fputs ("\nFP ABI: ", stdout
);
14978 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14979 fputs ("ISA Extension: ", stdout
);
14980 print_mips_isa_ext (abiflags_in
.isa_ext
);
14981 fputs ("\nASEs:", stdout
);
14982 print_mips_ases (abiflags_in
.ases
);
14983 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14984 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14985 fputc ('\n', stdout
);
14986 free (abiflags_ext
);
14991 /* We have a lot of special sections. Thanks SGI! */
14992 if (dynamic_section
== NULL
)
14993 /* No information available. */
14996 for (entry
= dynamic_section
;
14997 /* PR 17531 file: 012-50589-0.004. */
14998 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15000 switch (entry
->d_tag
)
15002 case DT_MIPS_LIBLIST
:
15004 = offset_from_vma (file
, entry
->d_un
.d_val
,
15005 liblistno
* sizeof (Elf32_External_Lib
));
15007 case DT_MIPS_LIBLISTNO
:
15008 liblistno
= entry
->d_un
.d_val
;
15010 case DT_MIPS_OPTIONS
:
15011 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15013 case DT_MIPS_CONFLICT
:
15015 = offset_from_vma (file
, entry
->d_un
.d_val
,
15016 conflictsno
* sizeof (Elf32_External_Conflict
));
15018 case DT_MIPS_CONFLICTNO
:
15019 conflictsno
= entry
->d_un
.d_val
;
15022 pltgot
= entry
->d_un
.d_ptr
;
15024 case DT_MIPS_LOCAL_GOTNO
:
15025 local_gotno
= entry
->d_un
.d_val
;
15027 case DT_MIPS_GOTSYM
:
15028 gotsym
= entry
->d_un
.d_val
;
15030 case DT_MIPS_SYMTABNO
:
15031 symtabno
= entry
->d_un
.d_val
;
15033 case DT_MIPS_PLTGOT
:
15034 mips_pltgot
= entry
->d_un
.d_ptr
;
15037 pltrel
= entry
->d_un
.d_val
;
15040 pltrelsz
= entry
->d_un
.d_val
;
15043 jmprel
= entry
->d_un
.d_ptr
;
15049 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15051 Elf32_External_Lib
* elib
;
15054 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15056 sizeof (Elf32_External_Lib
),
15057 _("liblist section data"));
15060 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15061 (unsigned long) liblistno
);
15062 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15065 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15072 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15073 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15074 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15075 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15076 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15078 tmp
= gmtime (&atime
);
15079 snprintf (timebuf
, sizeof (timebuf
),
15080 "%04u-%02u-%02uT%02u:%02u:%02u",
15081 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15082 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15084 printf ("%3lu: ", (unsigned long) cnt
);
15085 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15086 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15088 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15089 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15090 liblist
.l_version
);
15092 if (liblist
.l_flags
== 0)
15096 static const struct
15103 { " EXACT_MATCH", LL_EXACT_MATCH
},
15104 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15105 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15106 { " EXPORTS", LL_EXPORTS
},
15107 { " DELAY_LOAD", LL_DELAY_LOAD
},
15108 { " DELTA", LL_DELTA
}
15110 int flags
= liblist
.l_flags
;
15113 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15114 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15116 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15117 flags
^= l_flags_vals
[fcnt
].bit
;
15120 printf (" %#x", (unsigned int) flags
);
15132 if (options_offset
!= 0)
15134 Elf_External_Options
* eopt
;
15135 Elf_Internal_Options
* iopt
;
15136 Elf_Internal_Options
* option
;
15139 sect
= section_headers
;
15141 /* Find the section header so that we get the size. */
15142 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15143 /* PR 17533 file: 012-277276-0.004. */
15146 error (_("No MIPS_OPTIONS header found\n"));
15150 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15151 sect
->sh_size
, _("options"));
15154 iopt
= (Elf_Internal_Options
*)
15155 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15158 error (_("Out of memory allocating space for MIPS options\n"));
15165 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15167 Elf_External_Options
* eoption
;
15169 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15171 option
->kind
= BYTE_GET (eoption
->kind
);
15172 option
->size
= BYTE_GET (eoption
->size
);
15173 option
->section
= BYTE_GET (eoption
->section
);
15174 option
->info
= BYTE_GET (eoption
->info
);
15176 /* PR 17531: file: ffa0fa3b. */
15177 if (option
->size
< sizeof (* eopt
)
15178 || offset
+ option
->size
> sect
->sh_size
)
15180 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15183 offset
+= option
->size
;
15189 printf (_("\nSection '%s' contains %d entries:\n"),
15190 printable_section_name (sect
), cnt
);
15199 switch (option
->kind
)
15202 /* This shouldn't happen. */
15203 printf (" NULL %d %lx", option
->section
, option
->info
);
15206 printf (" REGINFO ");
15207 if (elf_header
.e_machine
== EM_MIPS
)
15210 Elf32_External_RegInfo
* ereg
;
15211 Elf32_RegInfo reginfo
;
15213 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15214 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15215 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15216 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15217 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15218 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15219 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15221 printf ("GPR %08lx GP 0x%lx\n",
15222 reginfo
.ri_gprmask
,
15223 (unsigned long) reginfo
.ri_gp_value
);
15224 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15225 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15226 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15231 Elf64_External_RegInfo
* ereg
;
15232 Elf64_Internal_RegInfo reginfo
;
15234 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15235 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15236 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15237 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15238 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15239 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15240 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15242 printf ("GPR %08lx GP 0x",
15243 reginfo
.ri_gprmask
);
15244 printf_vma (reginfo
.ri_gp_value
);
15247 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15248 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15249 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15253 case ODK_EXCEPTIONS
:
15254 fputs (" EXCEPTIONS fpe_min(", stdout
);
15255 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15256 fputs (") fpe_max(", stdout
);
15257 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15258 fputs (")", stdout
);
15260 if (option
->info
& OEX_PAGE0
)
15261 fputs (" PAGE0", stdout
);
15262 if (option
->info
& OEX_SMM
)
15263 fputs (" SMM", stdout
);
15264 if (option
->info
& OEX_FPDBUG
)
15265 fputs (" FPDBUG", stdout
);
15266 if (option
->info
& OEX_DISMISS
)
15267 fputs (" DISMISS", stdout
);
15270 fputs (" PAD ", stdout
);
15271 if (option
->info
& OPAD_PREFIX
)
15272 fputs (" PREFIX", stdout
);
15273 if (option
->info
& OPAD_POSTFIX
)
15274 fputs (" POSTFIX", stdout
);
15275 if (option
->info
& OPAD_SYMBOL
)
15276 fputs (" SYMBOL", stdout
);
15279 fputs (" HWPATCH ", stdout
);
15280 if (option
->info
& OHW_R4KEOP
)
15281 fputs (" R4KEOP", stdout
);
15282 if (option
->info
& OHW_R8KPFETCH
)
15283 fputs (" R8KPFETCH", stdout
);
15284 if (option
->info
& OHW_R5KEOP
)
15285 fputs (" R5KEOP", stdout
);
15286 if (option
->info
& OHW_R5KCVTL
)
15287 fputs (" R5KCVTL", stdout
);
15290 fputs (" FILL ", stdout
);
15291 /* XXX Print content of info word? */
15294 fputs (" TAGS ", stdout
);
15295 /* XXX Print content of info word? */
15298 fputs (" HWAND ", stdout
);
15299 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15300 fputs (" R4KEOP_CHECKED", stdout
);
15301 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15302 fputs (" R4KEOP_CLEAN", stdout
);
15305 fputs (" HWOR ", stdout
);
15306 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15307 fputs (" R4KEOP_CHECKED", stdout
);
15308 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15309 fputs (" R4KEOP_CLEAN", stdout
);
15312 printf (" GP_GROUP %#06lx self-contained %#06lx",
15313 option
->info
& OGP_GROUP
,
15314 (option
->info
& OGP_SELF
) >> 16);
15317 printf (" IDENT %#06lx self-contained %#06lx",
15318 option
->info
& OGP_GROUP
,
15319 (option
->info
& OGP_SELF
) >> 16);
15322 /* This shouldn't happen. */
15323 printf (" %3d ??? %d %lx",
15324 option
->kind
, option
->section
, option
->info
);
15328 len
= sizeof (* eopt
);
15329 while (len
< option
->size
)
15331 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15333 if (ISPRINT (datum
))
15334 printf ("%c", datum
);
15336 printf ("\\%03o", datum
);
15339 fputs ("\n", stdout
);
15341 offset
+= option
->size
;
15351 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15353 Elf32_Conflict
* iconf
;
15356 if (dynamic_symbols
== NULL
)
15358 error (_("conflict list found without a dynamic symbol table\n"));
15362 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15365 error (_("Out of memory allocating space for dynamic conflicts\n"));
15371 Elf32_External_Conflict
* econf32
;
15373 econf32
= (Elf32_External_Conflict
*)
15374 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15375 sizeof (* econf32
), _("conflict"));
15379 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15380 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15386 Elf64_External_Conflict
* econf64
;
15388 econf64
= (Elf64_External_Conflict
*)
15389 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15390 sizeof (* econf64
), _("conflict"));
15394 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15395 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15400 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15401 (unsigned long) conflictsno
);
15402 puts (_(" Num: Index Value Name"));
15404 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15406 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15408 if (iconf
[cnt
] >= num_dynamic_syms
)
15409 printf (_("<corrupt symbol index>"));
15412 Elf_Internal_Sym
* psym
;
15414 psym
= & dynamic_symbols
[iconf
[cnt
]];
15415 print_vma (psym
->st_value
, FULL_HEX
);
15417 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15418 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15420 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15428 if (pltgot
!= 0 && local_gotno
!= 0)
15430 bfd_vma ent
, local_end
, global_end
;
15432 unsigned char * data
;
15433 unsigned char * data_end
;
15437 addr_size
= (is_32bit_elf
? 4 : 8);
15438 local_end
= pltgot
+ local_gotno
* addr_size
;
15440 /* PR binutils/17533 file: 012-111227-0.004 */
15441 if (symtabno
< gotsym
)
15443 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15444 (unsigned long) gotsym
, (unsigned long) symtabno
);
15448 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15449 /* PR 17531: file: 54c91a34. */
15450 if (global_end
< local_end
)
15452 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15456 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15457 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15458 global_end
- pltgot
, 1,
15459 _("Global Offset Table data"));
15462 data_end
= data
+ (global_end
- pltgot
);
15464 printf (_("\nPrimary GOT:\n"));
15465 printf (_(" Canonical gp value: "));
15466 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15469 printf (_(" Reserved entries:\n"));
15470 printf (_(" %*s %10s %*s Purpose\n"),
15471 addr_size
* 2, _("Address"), _("Access"),
15472 addr_size
* 2, _("Initial"));
15473 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15474 printf (_(" Lazy resolver\n"));
15475 if (ent
== (bfd_vma
) -1)
15476 goto got_print_fail
;
15481 if (data
+ ent
- pltgot
> data_end
- addr_size
)
15483 error (_("Invalid got entry - %#lx - overflows GOT table\n"),
15485 goto got_print_fail
;
15488 if (byte_get (data
+ ent
- pltgot
, addr_size
)
15489 >> (addr_size
* 8 - 1) != 0)
15491 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15492 printf (_(" Module pointer (GNU extension)\n"));
15493 if (ent
== (bfd_vma
) -1)
15494 goto got_print_fail
;
15499 if (ent
< local_end
)
15501 printf (_(" Local entries:\n"));
15502 printf (" %*s %10s %*s\n",
15503 addr_size
* 2, _("Address"), _("Access"),
15504 addr_size
* 2, _("Initial"));
15505 while (ent
< local_end
)
15507 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15509 if (ent
== (bfd_vma
) -1)
15510 goto got_print_fail
;
15515 if (gotsym
< symtabno
)
15519 printf (_(" Global entries:\n"));
15520 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15521 addr_size
* 2, _("Address"),
15523 addr_size
* 2, _("Initial"),
15524 addr_size
* 2, _("Sym.Val."),
15526 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15527 _("Ndx"), _("Name"));
15529 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15531 for (i
= gotsym
; i
< symtabno
; i
++)
15533 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15536 if (dynamic_symbols
== NULL
)
15537 printf (_("<no dynamic symbols>"));
15538 else if (i
< num_dynamic_syms
)
15540 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15542 print_vma (psym
->st_value
, LONG_HEX
);
15543 printf (" %-7s %3s ",
15544 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15545 get_symbol_index_type (psym
->st_shndx
));
15547 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15548 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15550 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15553 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15554 (unsigned long) i
);
15557 if (ent
== (bfd_vma
) -1)
15568 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15571 size_t offset
, rel_offset
;
15572 unsigned long count
, i
;
15573 unsigned char * data
;
15574 int addr_size
, sym_width
;
15575 Elf_Internal_Rela
* rels
;
15577 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15578 if (pltrel
== DT_RELA
)
15580 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15585 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15590 addr_size
= (is_32bit_elf
? 4 : 8);
15591 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15593 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15594 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15595 1, _("Procedure Linkage Table data"));
15599 printf ("\nPLT GOT:\n\n");
15600 printf (_(" Reserved entries:\n"));
15601 printf (_(" %*s %*s Purpose\n"),
15602 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15603 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15604 printf (_(" PLT lazy resolver\n"));
15605 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15606 printf (_(" Module pointer\n"));
15609 printf (_(" Entries:\n"));
15610 printf (" %*s %*s %*s %-7s %3s %s\n",
15611 addr_size
* 2, _("Address"),
15612 addr_size
* 2, _("Initial"),
15613 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15614 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15615 for (i
= 0; i
< count
; i
++)
15617 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15619 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15622 if (idx
>= num_dynamic_syms
)
15623 printf (_("<corrupt symbol index: %lu>"), idx
);
15626 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15628 print_vma (psym
->st_value
, LONG_HEX
);
15629 printf (" %-7s %3s ",
15630 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15631 get_symbol_index_type (psym
->st_shndx
));
15632 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15633 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15635 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15650 process_nds32_specific (FILE * file
)
15652 Elf_Internal_Shdr
*sect
= NULL
;
15654 sect
= find_section (".nds32_e_flags");
15657 unsigned int *flag
;
15659 printf ("\nNDS32 elf flags section:\n");
15660 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15661 sect
->sh_size
, _("NDS32 elf flags section"));
15666 switch ((*flag
) & 0x3)
15669 printf ("(VEC_SIZE):\tNo entry.\n");
15672 printf ("(VEC_SIZE):\t4 bytes\n");
15675 printf ("(VEC_SIZE):\t16 bytes\n");
15678 printf ("(VEC_SIZE):\treserved\n");
15687 process_gnu_liblist (FILE * file
)
15689 Elf_Internal_Shdr
* section
;
15690 Elf_Internal_Shdr
* string_sec
;
15691 Elf32_External_Lib
* elib
;
15693 size_t strtab_size
;
15696 bfd_boolean res
= TRUE
;
15701 for (i
= 0, section
= section_headers
;
15702 i
< elf_header
.e_shnum
;
15705 switch (section
->sh_type
)
15707 case SHT_GNU_LIBLIST
:
15708 if (section
->sh_link
>= elf_header
.e_shnum
)
15711 elib
= (Elf32_External_Lib
*)
15712 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15713 _("liblist section data"));
15721 string_sec
= section_headers
+ section
->sh_link
;
15722 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15723 string_sec
->sh_size
,
15724 _("liblist string table"));
15726 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15733 strtab_size
= string_sec
->sh_size
;
15735 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15736 printable_section_name (section
),
15737 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15739 puts (_(" Library Time Stamp Checksum Version Flags"));
15741 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15749 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15750 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15751 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15752 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15753 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15755 tmp
= gmtime (&atime
);
15756 snprintf (timebuf
, sizeof (timebuf
),
15757 "%04u-%02u-%02uT%02u:%02u:%02u",
15758 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15759 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15761 printf ("%3lu: ", (unsigned long) cnt
);
15763 printf ("%-20s", liblist
.l_name
< strtab_size
15764 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15766 printf ("%-20.20s", liblist
.l_name
< strtab_size
15767 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15768 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15769 liblist
.l_version
, liblist
.l_flags
);
15780 static const char *
15781 get_note_type (unsigned e_type
)
15783 static char buff
[64];
15785 if (elf_header
.e_type
== ET_CORE
)
15789 return _("NT_AUXV (auxiliary vector)");
15791 return _("NT_PRSTATUS (prstatus structure)");
15793 return _("NT_FPREGSET (floating point registers)");
15795 return _("NT_PRPSINFO (prpsinfo structure)");
15796 case NT_TASKSTRUCT
:
15797 return _("NT_TASKSTRUCT (task structure)");
15799 return _("NT_PRXFPREG (user_xfpregs structure)");
15801 return _("NT_PPC_VMX (ppc Altivec registers)");
15803 return _("NT_PPC_VSX (ppc VSX registers)");
15805 return _("NT_386_TLS (x86 TLS information)");
15806 case NT_386_IOPERM
:
15807 return _("NT_386_IOPERM (x86 I/O permissions)");
15808 case NT_X86_XSTATE
:
15809 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15810 case NT_S390_HIGH_GPRS
:
15811 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15812 case NT_S390_TIMER
:
15813 return _("NT_S390_TIMER (s390 timer register)");
15814 case NT_S390_TODCMP
:
15815 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15816 case NT_S390_TODPREG
:
15817 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15819 return _("NT_S390_CTRS (s390 control registers)");
15820 case NT_S390_PREFIX
:
15821 return _("NT_S390_PREFIX (s390 prefix register)");
15822 case NT_S390_LAST_BREAK
:
15823 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15824 case NT_S390_SYSTEM_CALL
:
15825 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15827 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15828 case NT_S390_VXRS_LOW
:
15829 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15830 case NT_S390_VXRS_HIGH
:
15831 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15833 return _("NT_ARM_VFP (arm VFP registers)");
15835 return _("NT_ARM_TLS (AArch TLS registers)");
15836 case NT_ARM_HW_BREAK
:
15837 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15838 case NT_ARM_HW_WATCH
:
15839 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15841 return _("NT_PSTATUS (pstatus structure)");
15843 return _("NT_FPREGS (floating point registers)");
15845 return _("NT_PSINFO (psinfo structure)");
15847 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15849 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15850 case NT_WIN32PSTATUS
:
15851 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15853 return _("NT_SIGINFO (siginfo_t data)");
15855 return _("NT_FILE (mapped files)");
15863 return _("NT_VERSION (version)");
15865 return _("NT_ARCH (architecture)");
15866 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
15867 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15868 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
15869 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15874 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15879 print_core_note (Elf_Internal_Note
*pnote
)
15881 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15882 bfd_vma count
, page_size
;
15883 unsigned char *descdata
, *filenames
, *descend
;
15885 if (pnote
->type
!= NT_FILE
)
15891 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15892 /* Still "successful". */
15897 if (pnote
->descsz
< 2 * addr_size
)
15899 error (_(" Malformed note - too short for header\n"));
15903 descdata
= (unsigned char *) pnote
->descdata
;
15904 descend
= descdata
+ pnote
->descsz
;
15906 if (descdata
[pnote
->descsz
- 1] != '\0')
15908 error (_(" Malformed note - does not end with \\0\n"));
15912 count
= byte_get (descdata
, addr_size
);
15913 descdata
+= addr_size
;
15915 page_size
= byte_get (descdata
, addr_size
);
15916 descdata
+= addr_size
;
15918 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15920 error (_(" Malformed note - too short for supplied file count\n"));
15924 printf (_(" Page size: "));
15925 print_vma (page_size
, DEC
);
15928 printf (_(" %*s%*s%*s\n"),
15929 (int) (2 + 2 * addr_size
), _("Start"),
15930 (int) (4 + 2 * addr_size
), _("End"),
15931 (int) (4 + 2 * addr_size
), _("Page Offset"));
15932 filenames
= descdata
+ count
* 3 * addr_size
;
15933 while (count
-- > 0)
15935 bfd_vma start
, end
, file_ofs
;
15937 if (filenames
== descend
)
15939 error (_(" Malformed note - filenames end too early\n"));
15943 start
= byte_get (descdata
, addr_size
);
15944 descdata
+= addr_size
;
15945 end
= byte_get (descdata
, addr_size
);
15946 descdata
+= addr_size
;
15947 file_ofs
= byte_get (descdata
, addr_size
);
15948 descdata
+= addr_size
;
15951 print_vma (start
, FULL_HEX
);
15953 print_vma (end
, FULL_HEX
);
15955 print_vma (file_ofs
, FULL_HEX
);
15956 printf ("\n %s\n", filenames
);
15958 filenames
+= 1 + strlen ((char *) filenames
);
15964 static const char *
15965 get_gnu_elf_note_type (unsigned e_type
)
15967 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15970 case NT_GNU_ABI_TAG
:
15971 return _("NT_GNU_ABI_TAG (ABI version tag)");
15973 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15974 case NT_GNU_BUILD_ID
:
15975 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15976 case NT_GNU_GOLD_VERSION
:
15977 return _("NT_GNU_GOLD_VERSION (gold version)");
15978 case NT_GNU_PROPERTY_TYPE_0
:
15979 return _("NT_GNU_PROPERTY_TYPE_0");
15980 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
15981 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15982 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
15983 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15986 static char buff
[64];
15988 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15995 decode_x86_isa (unsigned int bitmask
)
15999 unsigned int bit
= bitmask
& (- bitmask
);
16004 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16005 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16006 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16007 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16008 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16009 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16010 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16011 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16012 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16013 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16014 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16015 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16016 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16017 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16018 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16019 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16020 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16021 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16022 default: printf (_("<unknown: %x>"), bit
); break;
16030 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16032 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16033 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16034 unsigned int size
= is_32bit_elf
? 4 : 8;
16036 printf (_(" Properties: "));
16038 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16040 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16047 unsigned int type
= byte_get (ptr
, 4);
16048 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16052 if ((ptr
+ datasz
) > ptr_end
)
16054 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16059 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16061 if (elf_header
.e_machine
== EM_X86_64
16062 || elf_header
.e_machine
== EM_IAMCU
16063 || elf_header
.e_machine
== EM_386
)
16067 case GNU_PROPERTY_X86_ISA_1_USED
:
16068 printf ("x86 ISA used: ");
16070 printf (_("<corrupt length: %#x> "), datasz
);
16072 decode_x86_isa (byte_get (ptr
, 4));
16075 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16076 printf ("x86 ISA needed: ");
16078 printf (_("<corrupt length: %#x> "), datasz
);
16080 decode_x86_isa (byte_get (ptr
, 4));
16092 case GNU_PROPERTY_STACK_SIZE
:
16093 printf (_("stack size: "));
16094 if (datasz
!= size
)
16095 printf (_("<corrupt length: %#x> "), datasz
);
16097 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16100 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16101 printf ("no copy on protected ");
16103 printf (_("<corrupt length: %#x> "), datasz
);
16111 if (type
< GNU_PROPERTY_LOPROC
)
16112 printf (_("<unknown type %#x data: "), type
);
16113 else if (type
< GNU_PROPERTY_LOUSER
)
16114 printf (_("<procesor-specific type %#x data: "), type
);
16116 printf (_("<application-specific type %#x data: "), type
);
16117 for (j
= 0; j
< datasz
; ++j
)
16118 printf ("%02x ", ptr
[j
] & 0xff);
16122 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16123 if (ptr
== ptr_end
)
16133 if (ptr
> (ptr_end
- 8))
16135 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16144 print_gnu_note (Elf_Internal_Note
*pnote
)
16146 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16147 switch (pnote
->type
)
16149 case NT_GNU_BUILD_ID
:
16153 printf (_(" Build ID: "));
16154 for (i
= 0; i
< pnote
->descsz
; ++i
)
16155 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16160 case NT_GNU_ABI_TAG
:
16162 unsigned long os
, major
, minor
, subminor
;
16163 const char *osname
;
16165 /* PR 17531: file: 030-599401-0.004. */
16166 if (pnote
->descsz
< 16)
16168 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16172 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16173 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16174 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16175 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16179 case GNU_ABI_TAG_LINUX
:
16182 case GNU_ABI_TAG_HURD
:
16185 case GNU_ABI_TAG_SOLARIS
:
16186 osname
= "Solaris";
16188 case GNU_ABI_TAG_FREEBSD
:
16189 osname
= "FreeBSD";
16191 case GNU_ABI_TAG_NETBSD
:
16194 case GNU_ABI_TAG_SYLLABLE
:
16195 osname
= "Syllable";
16197 case GNU_ABI_TAG_NACL
:
16201 osname
= "Unknown";
16205 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16206 major
, minor
, subminor
);
16210 case NT_GNU_GOLD_VERSION
:
16214 printf (_(" Version: "));
16215 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16216 printf ("%c", pnote
->descdata
[i
]);
16223 unsigned long num_entries
, mask
;
16225 /* Hardware capabilities information. Word 0 is the number of entries.
16226 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16227 is a series of entries, where each entry is a single byte followed
16228 by a nul terminated string. The byte gives the bit number to test
16229 if enabled in the bitmask. */
16230 printf (_(" Hardware Capabilities: "));
16231 if (pnote
->descsz
< 8)
16233 error (_("<corrupt GNU_HWCAP>\n"));
16236 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16237 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16238 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16239 /* FIXME: Add code to display the entries... */
16243 case NT_GNU_PROPERTY_TYPE_0
:
16244 print_gnu_property_note (pnote
);
16248 /* Handle unrecognised types. An error message should have already been
16249 created by get_gnu_elf_note_type(), so all that we need to do is to
16250 display the data. */
16254 printf (_(" Description data: "));
16255 for (i
= 0; i
< pnote
->descsz
; ++i
)
16256 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16265 static const char *
16266 get_v850_elf_note_type (enum v850_notes n_type
)
16268 static char buff
[64];
16272 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16273 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16274 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16275 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16276 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16277 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16279 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16285 print_v850_note (Elf_Internal_Note
* pnote
)
16289 if (pnote
->descsz
!= 4)
16292 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16296 printf (_("not set\n"));
16300 switch (pnote
->type
)
16302 case V850_NOTE_ALIGNMENT
:
16305 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16306 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16310 case V850_NOTE_DATA_SIZE
:
16313 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16314 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16318 case V850_NOTE_FPU_INFO
:
16321 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16322 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16326 case V850_NOTE_MMU_INFO
:
16327 case V850_NOTE_CACHE_INFO
:
16328 case V850_NOTE_SIMD_INFO
:
16329 if (val
== EF_RH850_SIMD
)
16331 printf (_("yes\n"));
16337 /* An 'unknown note type' message will already have been displayed. */
16341 printf (_("unknown value: %x\n"), val
);
16346 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16348 unsigned int version
;
16350 switch (pnote
->type
)
16352 case NT_NETBSD_IDENT
:
16353 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16354 if ((version
/ 10000) % 100)
16355 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16356 version
, version
/ 100000000, (version
/ 1000000) % 100,
16357 (version
/ 10000) % 100 > 26 ? "Z" : "",
16358 'A' + (version
/ 10000) % 26);
16360 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16361 version
, version
/ 100000000, (version
/ 1000000) % 100,
16362 (version
/ 100) % 100);
16365 case NT_NETBSD_MARCH
:
16366 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16371 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16377 static const char *
16378 get_freebsd_elfcore_note_type (unsigned e_type
)
16382 case NT_FREEBSD_THRMISC
:
16383 return _("NT_THRMISC (thrmisc structure)");
16384 case NT_FREEBSD_PROCSTAT_PROC
:
16385 return _("NT_PROCSTAT_PROC (proc data)");
16386 case NT_FREEBSD_PROCSTAT_FILES
:
16387 return _("NT_PROCSTAT_FILES (files data)");
16388 case NT_FREEBSD_PROCSTAT_VMMAP
:
16389 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16390 case NT_FREEBSD_PROCSTAT_GROUPS
:
16391 return _("NT_PROCSTAT_GROUPS (groups data)");
16392 case NT_FREEBSD_PROCSTAT_UMASK
:
16393 return _("NT_PROCSTAT_UMASK (umask data)");
16394 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16395 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16396 case NT_FREEBSD_PROCSTAT_OSREL
:
16397 return _("NT_PROCSTAT_OSREL (osreldate data)");
16398 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16399 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16400 case NT_FREEBSD_PROCSTAT_AUXV
:
16401 return _("NT_PROCSTAT_AUXV (auxv data)");
16403 return get_note_type (e_type
);
16406 static const char *
16407 get_netbsd_elfcore_note_type (unsigned e_type
)
16409 static char buff
[64];
16411 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16413 /* NetBSD core "procinfo" structure. */
16414 return _("NetBSD procinfo structure");
16417 /* As of Jan 2002 there are no other machine-independent notes
16418 defined for NetBSD core files. If the note type is less
16419 than the start of the machine-dependent note types, we don't
16422 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16424 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16428 switch (elf_header
.e_machine
)
16430 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16431 and PT_GETFPREGS == mach+2. */
16436 case EM_SPARC32PLUS
:
16440 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16441 return _("PT_GETREGS (reg structure)");
16442 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16443 return _("PT_GETFPREGS (fpreg structure)");
16449 /* On all other arch's, PT_GETREGS == mach+1 and
16450 PT_GETFPREGS == mach+3. */
16454 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16455 return _("PT_GETREGS (reg structure)");
16456 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16457 return _("PT_GETFPREGS (fpreg structure)");
16463 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16464 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16468 static const char *
16469 get_stapsdt_note_type (unsigned e_type
)
16471 static char buff
[64];
16476 return _("NT_STAPSDT (SystemTap probe descriptors)");
16482 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16487 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16489 int addr_size
= is_32bit_elf
? 4 : 8;
16490 char *data
= pnote
->descdata
;
16491 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16492 bfd_vma pc
, base_addr
, semaphore
;
16493 char *provider
, *probe
, *arg_fmt
;
16495 pc
= byte_get ((unsigned char *) data
, addr_size
);
16497 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16499 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16503 data
+= strlen (data
) + 1;
16505 data
+= strlen (data
) + 1;
16507 data
+= strlen (data
) + 1;
16509 printf (_(" Provider: %s\n"), provider
);
16510 printf (_(" Name: %s\n"), probe
);
16511 printf (_(" Location: "));
16512 print_vma (pc
, FULL_HEX
);
16513 printf (_(", Base: "));
16514 print_vma (base_addr
, FULL_HEX
);
16515 printf (_(", Semaphore: "));
16516 print_vma (semaphore
, FULL_HEX
);
16518 printf (_(" Arguments: %s\n"), arg_fmt
);
16520 return data
== data_end
;
16523 static const char *
16524 get_ia64_vms_note_type (unsigned e_type
)
16526 static char buff
[64];
16531 return _("NT_VMS_MHD (module header)");
16533 return _("NT_VMS_LNM (language name)");
16535 return _("NT_VMS_SRC (source files)");
16537 return "NT_VMS_TITLE";
16539 return _("NT_VMS_EIDC (consistency check)");
16540 case NT_VMS_FPMODE
:
16541 return _("NT_VMS_FPMODE (FP mode)");
16542 case NT_VMS_LINKTIME
:
16543 return "NT_VMS_LINKTIME";
16544 case NT_VMS_IMGNAM
:
16545 return _("NT_VMS_IMGNAM (image name)");
16547 return _("NT_VMS_IMGID (image id)");
16548 case NT_VMS_LINKID
:
16549 return _("NT_VMS_LINKID (link id)");
16550 case NT_VMS_IMGBID
:
16551 return _("NT_VMS_IMGBID (build id)");
16552 case NT_VMS_GSTNAM
:
16553 return _("NT_VMS_GSTNAM (sym table name)");
16554 case NT_VMS_ORIG_DYN
:
16555 return "NT_VMS_ORIG_DYN";
16556 case NT_VMS_PATCHTIME
:
16557 return "NT_VMS_PATCHTIME";
16559 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16565 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16567 switch (pnote
->type
)
16570 if (pnote
->descsz
> 36)
16572 size_t l
= strlen (pnote
->descdata
+ 34);
16573 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16574 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16575 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16576 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16579 printf (_(" Invalid size\n"));
16582 printf (_(" Language: %s\n"), pnote
->descdata
);
16585 case NT_VMS_FPMODE
:
16586 printf (_(" Floating Point mode: "));
16587 printf ("0x%016" BFD_VMA_FMT
"x\n",
16588 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16590 case NT_VMS_LINKTIME
:
16591 printf (_(" Link time: "));
16593 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16596 case NT_VMS_PATCHTIME
:
16597 printf (_(" Patch time: "));
16599 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16602 case NT_VMS_ORIG_DYN
:
16603 printf (_(" Major id: %u, minor id: %u\n"),
16604 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16605 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16606 printf (_(" Last modified : "));
16608 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16609 printf (_("\n Link flags : "));
16610 printf ("0x%016" BFD_VMA_FMT
"x\n",
16611 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16612 printf (_(" Header flags: 0x%08x\n"),
16613 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16614 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16617 case NT_VMS_IMGNAM
:
16618 printf (_(" Image name: %s\n"), pnote
->descdata
);
16620 case NT_VMS_GSTNAM
:
16621 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16624 printf (_(" Image id: %s\n"), pnote
->descdata
);
16626 case NT_VMS_LINKID
:
16627 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16635 /* Print the name of the symbol associated with a build attribute
16636 that is attached to address OFFSET. */
16639 print_symbol_for_build_attribute (FILE * file
,
16640 unsigned long offset
,
16641 bfd_boolean is_open_attr
)
16643 static FILE * saved_file
= NULL
;
16644 static char * strtab
;
16645 static unsigned long strtablen
;
16646 static Elf_Internal_Sym
* symtab
;
16647 static unsigned long nsyms
;
16648 Elf_Internal_Sym
* saved_sym
= NULL
;
16649 Elf_Internal_Sym
* sym
;
16651 if (saved_file
== NULL
|| file
!= saved_file
)
16653 Elf_Internal_Shdr
* symsec
;
16655 /* Load the symbol and string sections. */
16656 for (symsec
= section_headers
;
16657 symsec
< section_headers
+ elf_header
.e_shnum
;
16660 if (symsec
->sh_type
== SHT_SYMTAB
)
16662 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
16664 if (symsec
->sh_link
< elf_header
.e_shnum
)
16666 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
16668 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
16669 1, strtab_sec
->sh_size
,
16670 _("string table"));
16671 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
16678 if (symtab
== NULL
|| strtab
== NULL
)
16684 /* Find a symbol whose value matches offset. */
16685 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
16686 if (sym
->st_value
== offset
)
16688 if (sym
->st_name
>= strtablen
)
16689 /* Huh ? This should not happen. */
16692 if (strtab
[sym
->st_name
] == 0)
16697 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
16698 and FILE or OBJECT symbols over NOTYPE symbols. We skip
16699 FUNC symbols entirely. */
16700 switch (ELF_ST_TYPE (sym
->st_info
))
16704 /* We can stop searching now. */
16705 sym
= symtab
+ nsyms
;
16713 /* Ignore function symbols. */
16720 switch (ELF_ST_BIND (sym
->st_info
))
16723 if (saved_sym
== NULL
16724 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
16729 if (saved_sym
== NULL
)
16739 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
16747 printf (" (%s: %s)\n",
16748 is_open_attr
? _("file") : _("func"),
16749 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
16754 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
16757 static unsigned long global_offset
= 0;
16758 unsigned long offset
;
16759 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
16760 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
16762 if (pnote
->descsz
== 0)
16766 printf (_(" Applies from offset %#lx\n"), global_offset
);
16771 printf (_(" Applies to func at %#lx"), global_offset
);
16772 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
16776 if (pnote
->descsz
!= desc_size
)
16778 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
16779 printf (_(" <invalid descsz>"));
16783 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
16787 printf (_(" Applies from offset %#lx"), offset
);
16788 global_offset
= offset
;
16792 printf (_(" Applies to func at %#lx"), offset
);
16795 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
16799 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
16802 char name_attribute
;
16803 char * expected_types
;
16804 const char * name
= pnote
->namedata
;
16808 if (name
== NULL
|| pnote
->namesz
< 2)
16810 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
16811 print_symbol (-20, _(" <corrupt name field>"));
16815 switch ((name_type
= * name
))
16817 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
16818 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
16819 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
16820 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
16821 printf ("%c", * name
);
16824 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
16825 print_symbol (-20, _("<unknown name type>"));
16833 switch ((name_attribute
= * name
))
16835 case GNU_BUILD_ATTRIBUTE_VERSION
:
16836 text
= _("<version>");
16837 expected_types
= "$";
16840 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
16841 text
= _("<stack prot>");
16842 expected_types
= "!+*";
16845 case GNU_BUILD_ATTRIBUTE_RELRO
:
16846 text
= _("<relro>");
16847 expected_types
= "!+";
16850 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
16851 text
= _("<stack size>");
16852 expected_types
= "*";
16855 case GNU_BUILD_ATTRIBUTE_TOOL
:
16856 text
= _("<tool>");
16857 expected_types
= "$";
16860 case GNU_BUILD_ATTRIBUTE_ABI
:
16862 expected_types
= "$*";
16865 case GNU_BUILD_ATTRIBUTE_PIC
:
16867 expected_types
= "*";
16870 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
16871 text
= _("<short enum>");
16872 expected_types
= "!+";
16877 if (ISPRINT (* name
))
16879 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
16881 if (len
> left
&& ! do_wide
)
16883 printf ("%.*s:", len
, name
);
16889 error (_("unexpected character in name field\n"));
16890 print_symbol (- left
, _("<unknown attribute>"));
16893 expected_types
= "*$!+";
16899 printf ("%s", text
);
16900 left
-= strlen (text
);
16903 if (strchr (expected_types
, name_type
) == NULL
)
16904 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
16906 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
16908 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
16909 (unsigned long) pnote
->namesz
,
16910 (long) (name
- pnote
->namedata
));
16914 if (left
< 1 && ! do_wide
)
16919 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
16921 unsigned int bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
16922 unsigned long val
= 0;
16923 unsigned int shift
= 0;
16924 char * decoded
= NULL
;
16928 unsigned long byte
= (* name
++) & 0xff;
16930 val
|= byte
<< shift
;
16934 switch (name_attribute
)
16936 case GNU_BUILD_ATTRIBUTE_PIC
:
16939 case 0: decoded
= "static"; break;
16940 case 1: decoded
= "pic"; break;
16941 case 2: decoded
= "PIC"; break;
16942 case 3: decoded
= "pie"; break;
16943 case 4: decoded
= "PIE"; break;
16947 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
16950 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
16951 case 0: decoded
= "off"; break;
16952 case 1: decoded
= "on"; break;
16953 case 2: decoded
= "all"; break;
16954 case 3: decoded
= "strong"; break;
16955 case 4: decoded
= "explicit"; break;
16963 if (decoded
!= NULL
)
16964 print_symbol (-left
, decoded
);
16968 left
-= printf ("0x%lx", val
);
16970 left
-= printf ("0x%-.*lx", left
, val
);
16974 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
16975 left
-= print_symbol (- left
, name
);
16977 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
16978 left
-= print_symbol (- left
, "true");
16980 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
16981 left
-= print_symbol (- left
, "false");
16985 if (do_wide
&& left
> 0)
16986 printf ("%-*s", left
, " ");
16991 /* Note that by the ELF standard, the name field is already null byte
16992 terminated, and namesz includes the terminating null byte.
16993 I.E. the value of namesz for the name "FSF" is 4.
16995 If the value of namesz is zero, there is no name present. */
16998 process_note (Elf_Internal_Note
* pnote
,
17001 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17004 if (pnote
->namesz
== 0)
17005 /* If there is no note name, then use the default set of
17006 note type strings. */
17007 nt
= get_note_type (pnote
->type
);
17009 else if (const_strneq (pnote
->namedata
, "GNU"))
17010 /* GNU-specific object file notes. */
17011 nt
= get_gnu_elf_note_type (pnote
->type
);
17013 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17014 /* FreeBSD-specific core file notes. */
17015 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
17017 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17018 /* NetBSD-specific core file notes. */
17019 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17021 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17022 /* NetBSD-specific core file notes. */
17023 return process_netbsd_elf_note (pnote
);
17025 else if (strneq (pnote
->namedata
, "SPU/", 4))
17027 /* SPU-specific core file notes. */
17028 nt
= pnote
->namedata
+ 4;
17032 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17033 /* VMS/ia64-specific file notes. */
17034 nt
= get_ia64_vms_note_type (pnote
->type
);
17036 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17037 nt
= get_stapsdt_note_type (pnote
->type
);
17040 /* Don't recognize this note name; just use the default set of
17041 note type strings. */
17042 nt
= get_note_type (pnote
->type
);
17046 if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17047 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17048 print_gnu_build_attribute_name (pnote
);
17050 print_symbol (-20, name
);
17053 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17055 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17057 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17058 return print_ia64_vms_note (pnote
);
17059 else if (const_strneq (pnote
->namedata
, "GNU"))
17060 return print_gnu_note (pnote
);
17061 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17062 return print_stapsdt_note (pnote
);
17063 else if (const_strneq (pnote
->namedata
, "CORE"))
17064 return print_core_note (pnote
);
17065 else if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17066 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17067 return print_gnu_build_attribute_description (pnote
, file
);
17073 printf (_(" description data: "));
17074 for (i
= 0; i
< pnote
->descsz
; i
++)
17075 printf ("%02x ", pnote
->descdata
[i
]);
17085 process_notes_at (FILE * file
,
17086 Elf_Internal_Shdr
* section
,
17090 Elf_External_Note
* pnotes
;
17091 Elf_External_Note
* external
;
17093 bfd_boolean res
= TRUE
;
17100 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17103 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17108 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17110 if (pnotes
== NULL
)
17116 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17118 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17119 (unsigned long) offset
, (unsigned long) length
);
17121 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17123 end
= (char *) pnotes
+ length
;
17124 while ((char *) external
< end
)
17126 Elf_Internal_Note inote
;
17129 char * temp
= NULL
;
17130 size_t data_remaining
= end
- (char *) external
;
17132 if (!is_ia64_vms ())
17134 /* PR binutils/15191
17135 Make sure that there is enough data to read. */
17136 min_notesz
= offsetof (Elf_External_Note
, name
);
17137 if (data_remaining
< min_notesz
)
17139 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17140 (int) data_remaining
);
17143 inote
.type
= BYTE_GET (external
->type
);
17144 inote
.namesz
= BYTE_GET (external
->namesz
);
17145 inote
.namedata
= external
->name
;
17146 inote
.descsz
= BYTE_GET (external
->descsz
);
17147 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17148 /* PR 17531: file: 3443835e. */
17149 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17151 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17152 inote
.namesz
, (long)(end
- inote
.namedata
));
17153 inote
.descdata
= inote
.namedata
;
17157 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17158 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17162 Elf64_External_VMS_Note
*vms_external
;
17164 /* PR binutils/15191
17165 Make sure that there is enough data to read. */
17166 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17167 if (data_remaining
< min_notesz
)
17169 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17170 (int) data_remaining
);
17174 vms_external
= (Elf64_External_VMS_Note
*) external
;
17175 inote
.type
= BYTE_GET (vms_external
->type
);
17176 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17177 inote
.namedata
= vms_external
->name
;
17178 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17179 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17180 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17181 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17184 if (inote
.descdata
< (char *) external
+ min_notesz
17185 || next
< (char *) external
+ min_notesz
17186 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17187 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17188 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17189 || data_remaining
< (size_t)(next
- (char *) external
))
17191 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17192 (unsigned long) ((char *) external
- (char *) pnotes
));
17193 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17194 inote
.type
, inote
.namesz
, inote
.descsz
);
17198 external
= (Elf_External_Note
*) next
;
17200 /* Verify that name is null terminated. It appears that at least
17201 one version of Linux (RedHat 6.0) generates corefiles that don't
17202 comply with the ELF spec by failing to include the null byte in
17204 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17206 temp
= (char *) malloc (inote
.namesz
+ 1);
17209 error (_("Out of memory allocating space for inote name\n"));
17214 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17215 temp
[inote
.namesz
] = 0;
17217 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17218 inote
.namedata
= temp
;
17221 if (! process_note (& inote
, file
))
17237 process_corefile_note_segments (FILE * file
)
17239 Elf_Internal_Phdr
* segment
;
17241 bfd_boolean res
= TRUE
;
17243 if (! get_program_headers (file
))
17246 for (i
= 0, segment
= program_headers
;
17247 i
< elf_header
.e_phnum
;
17250 if (segment
->p_type
== PT_NOTE
)
17251 if (! process_notes_at (file
, NULL
,
17252 (bfd_vma
) segment
->p_offset
,
17253 (bfd_vma
) segment
->p_filesz
))
17261 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17263 Elf_External_Note
* pnotes
;
17264 Elf_External_Note
* external
;
17266 bfd_boolean res
= TRUE
;
17271 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17273 if (pnotes
== NULL
)
17277 end
= (char*) pnotes
+ length
;
17279 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17280 (unsigned long) offset
, (unsigned long) length
);
17282 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17284 Elf_External_Note
* next
;
17285 Elf_Internal_Note inote
;
17287 inote
.type
= BYTE_GET (external
->type
);
17288 inote
.namesz
= BYTE_GET (external
->namesz
);
17289 inote
.namedata
= external
->name
;
17290 inote
.descsz
= BYTE_GET (external
->descsz
);
17291 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17292 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17294 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17296 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17297 inote
.descdata
= inote
.namedata
;
17301 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17303 if ( ((char *) next
> end
)
17304 || ((char *) next
< (char *) pnotes
))
17306 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17307 (unsigned long) ((char *) external
- (char *) pnotes
));
17308 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17309 inote
.type
, inote
.namesz
, inote
.descsz
);
17315 /* Prevent out-of-bounds indexing. */
17316 if ( inote
.namedata
+ inote
.namesz
> end
17317 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17319 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17320 (unsigned long) ((char *) external
- (char *) pnotes
));
17321 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17322 inote
.type
, inote
.namesz
, inote
.descsz
);
17326 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17328 if (! print_v850_note (& inote
))
17331 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17332 inote
.namesz
, inote
.descsz
);
17342 process_note_sections (FILE * file
)
17344 Elf_Internal_Shdr
* section
;
17346 unsigned int n
= 0;
17347 bfd_boolean res
= TRUE
;
17349 for (i
= 0, section
= section_headers
;
17350 i
< elf_header
.e_shnum
&& section
!= NULL
;
17353 if (section
->sh_type
== SHT_NOTE
)
17355 if (! process_notes_at (file
, section
,
17356 (bfd_vma
) section
->sh_offset
,
17357 (bfd_vma
) section
->sh_size
))
17362 if (( elf_header
.e_machine
== EM_V800
17363 || elf_header
.e_machine
== EM_V850
17364 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17365 && section
->sh_type
== SHT_RENESAS_INFO
)
17367 if (! process_v850_notes (file
,
17368 (bfd_vma
) section
->sh_offset
,
17369 (bfd_vma
) section
->sh_size
))
17376 /* Try processing NOTE segments instead. */
17377 return process_corefile_note_segments (file
);
17383 process_notes (FILE * file
)
17385 /* If we have not been asked to display the notes then do nothing. */
17389 if (elf_header
.e_type
!= ET_CORE
)
17390 return process_note_sections (file
);
17392 /* No program headers means no NOTE segment. */
17393 if (elf_header
.e_phnum
> 0)
17394 return process_corefile_note_segments (file
);
17396 printf (_("No note segments present in the core file.\n"));
17400 static unsigned char *
17401 display_public_gnu_attributes (unsigned char * start
,
17402 const unsigned char * const end
)
17404 printf (_(" Unknown GNU attribute: %s\n"), start
);
17406 start
+= strnlen ((char *) start
, end
- start
);
17407 display_raw_attribute (start
, end
);
17409 return (unsigned char *) end
;
17412 static unsigned char *
17413 display_generic_attribute (unsigned char * start
,
17415 const unsigned char * const end
)
17418 return (unsigned char *) end
;
17420 return display_tag_value (tag
, start
, end
);
17424 process_arch_specific (FILE * file
)
17429 switch (elf_header
.e_machine
)
17432 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17433 display_arm_attribute
,
17434 display_generic_attribute
);
17437 case EM_MIPS_RS3_LE
:
17438 return process_mips_specific (file
);
17441 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17442 display_msp430x_attribute
,
17443 display_generic_attribute
);
17446 return process_nds32_specific (file
);
17450 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17451 display_power_gnu_attribute
);
17455 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17456 display_s390_gnu_attribute
);
17459 case EM_SPARC32PLUS
:
17461 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17462 display_sparc_gnu_attribute
);
17465 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17466 display_tic6x_attribute
,
17467 display_generic_attribute
);
17470 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17471 display_public_gnu_attributes
,
17472 display_generic_attribute
);
17477 get_file_header (FILE * file
)
17479 /* Read in the identity array. */
17480 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
17483 /* Determine how to read the rest of the header. */
17484 switch (elf_header
.e_ident
[EI_DATA
])
17489 byte_get
= byte_get_little_endian
;
17490 byte_put
= byte_put_little_endian
;
17493 byte_get
= byte_get_big_endian
;
17494 byte_put
= byte_put_big_endian
;
17498 /* For now we only support 32 bit and 64 bit ELF files. */
17499 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
17501 /* Read in the rest of the header. */
17504 Elf32_External_Ehdr ehdr32
;
17506 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
17509 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
17510 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
17511 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
17512 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
17513 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
17514 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
17515 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
17516 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
17517 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
17518 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
17519 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
17520 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
17521 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
17525 Elf64_External_Ehdr ehdr64
;
17527 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17528 we will not be able to cope with the 64bit data found in
17529 64 ELF files. Detect this now and abort before we start
17530 overwriting things. */
17531 if (sizeof (bfd_vma
) < 8)
17533 error (_("This instance of readelf has been built without support for a\n\
17534 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17538 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
17541 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
17542 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
17543 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
17544 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
17545 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
17546 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
17547 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
17548 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
17549 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
17550 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
17551 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
17552 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
17553 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
17556 if (elf_header
.e_shoff
)
17558 /* There may be some extensions in the first section header. Don't
17559 bomb if we can't read it. */
17561 get_32bit_section_headers (file
, TRUE
);
17563 get_64bit_section_headers (file
, TRUE
);
17569 /* Process one ELF object file according to the command line options.
17570 This file may actually be stored in an archive. The file is
17571 positioned at the start of the ELF object. Returns TRUE if no
17572 problems were encountered, FALSE otherwise. */
17575 process_object (char * file_name
, FILE * file
)
17578 bfd_boolean res
= TRUE
;
17580 if (! get_file_header (file
))
17582 error (_("%s: Failed to read file header\n"), file_name
);
17586 /* Initialise per file variables. */
17587 for (i
= ARRAY_SIZE (version_info
); i
--;)
17588 version_info
[i
] = 0;
17590 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
17591 dynamic_info
[i
] = 0;
17592 dynamic_info_DT_GNU_HASH
= 0;
17594 /* Process the file. */
17596 printf (_("\nFile: %s\n"), file_name
);
17598 /* Initialise the dump_sects array from the cmdline_dump_sects array.
17599 Note we do this even if cmdline_dump_sects is empty because we
17600 must make sure that the dump_sets array is zeroed out before each
17601 object file is processed. */
17602 if (num_dump_sects
> num_cmdline_dump_sects
)
17603 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
17605 if (num_cmdline_dump_sects
> 0)
17607 if (num_dump_sects
== 0)
17608 /* A sneaky way of allocating the dump_sects array. */
17609 request_dump_bynumber (num_cmdline_dump_sects
, 0);
17611 assert (num_dump_sects
>= num_cmdline_dump_sects
);
17612 memcpy (dump_sects
, cmdline_dump_sects
,
17613 num_cmdline_dump_sects
* sizeof (* dump_sects
));
17616 if (! process_file_header ())
17619 if (! process_section_headers (file
))
17621 /* Without loaded section headers we cannot process lots of things. */
17622 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
17624 if (! do_using_dynamic
)
17625 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
17628 if (! process_section_groups (file
))
17629 /* Without loaded section groups we cannot process unwind. */
17632 if (process_program_headers (file
))
17633 process_dynamic_section (file
);
17637 if (! process_relocs (file
))
17640 if (! process_unwind (file
))
17643 if (! process_symbol_table (file
))
17646 if (! process_syminfo (file
))
17649 if (! process_version_sections (file
))
17652 if (! process_section_contents (file
))
17655 if (! process_notes (file
))
17658 if (! process_gnu_liblist (file
))
17661 if (! process_arch_specific (file
))
17664 if (program_headers
)
17666 free (program_headers
);
17667 program_headers
= NULL
;
17670 if (section_headers
)
17672 free (section_headers
);
17673 section_headers
= NULL
;
17678 free (string_table
);
17679 string_table
= NULL
;
17680 string_table_length
= 0;
17683 if (dynamic_strings
)
17685 free (dynamic_strings
);
17686 dynamic_strings
= NULL
;
17687 dynamic_strings_length
= 0;
17690 if (dynamic_symbols
)
17692 free (dynamic_symbols
);
17693 dynamic_symbols
= NULL
;
17694 num_dynamic_syms
= 0;
17697 if (dynamic_syminfo
)
17699 free (dynamic_syminfo
);
17700 dynamic_syminfo
= NULL
;
17703 if (dynamic_section
)
17705 free (dynamic_section
);
17706 dynamic_section
= NULL
;
17709 if (section_headers_groups
)
17711 free (section_headers_groups
);
17712 section_headers_groups
= NULL
;
17715 if (section_groups
)
17717 struct group_list
* g
;
17718 struct group_list
* next
;
17720 for (i
= 0; i
< group_count
; i
++)
17722 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
17729 free (section_groups
);
17730 section_groups
= NULL
;
17733 free_debug_memory ();
17738 /* Process an ELF archive.
17739 On entry the file is positioned just after the ARMAG string.
17740 Returns TRUE upon success, FALSE otherwise. */
17743 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
17745 struct archive_info arch
;
17746 struct archive_info nested_arch
;
17748 bfd_boolean ret
= TRUE
;
17752 /* The ARCH structure is used to hold information about this archive. */
17753 arch
.file_name
= NULL
;
17755 arch
.index_array
= NULL
;
17756 arch
.sym_table
= NULL
;
17757 arch
.longnames
= NULL
;
17759 /* The NESTED_ARCH structure is used as a single-item cache of information
17760 about a nested archive (when members of a thin archive reside within
17761 another regular archive file). */
17762 nested_arch
.file_name
= NULL
;
17763 nested_arch
.file
= NULL
;
17764 nested_arch
.index_array
= NULL
;
17765 nested_arch
.sym_table
= NULL
;
17766 nested_arch
.longnames
= NULL
;
17768 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
17774 if (do_archive_index
)
17776 if (arch
.sym_table
== NULL
)
17777 error (_("%s: unable to dump the index as none was found\n"), file_name
);
17780 unsigned long i
, l
;
17781 unsigned long current_pos
;
17783 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17784 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
17785 current_pos
= ftell (file
);
17787 for (i
= l
= 0; i
< arch
.index_num
; i
++)
17789 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
17791 char * member_name
;
17793 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
17795 if (member_name
!= NULL
)
17797 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
17799 if (qualified_name
!= NULL
)
17801 printf (_("Contents of binary %s at offset "), qualified_name
);
17802 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
17804 free (qualified_name
);
17809 if (l
>= arch
.sym_size
)
17811 error (_("%s: end of the symbol table reached before the end of the index\n"),
17816 /* PR 17531: file: 0b6630b2. */
17817 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
17818 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
17821 if (arch
.uses_64bit_indicies
)
17826 if (l
< arch
.sym_size
)
17828 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17829 file_name
, arch
.sym_size
- l
);
17833 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
17835 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
17841 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
17842 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
17843 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
17844 && !do_section_groups
&& !do_dyn_syms
)
17846 ret
= TRUE
; /* Archive index only. */
17855 char * qualified_name
;
17857 /* Read the next archive header. */
17858 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
17860 error (_("%s: failed to seek to next archive header\n"), file_name
);
17863 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
17864 if (got
!= sizeof arch
.arhdr
)
17868 error (_("%s: failed to read archive header\n"), file_name
);
17872 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
17874 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
17879 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
17881 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
17882 if (archive_file_size
& 01)
17883 ++archive_file_size
;
17885 name
= get_archive_member_name (&arch
, &nested_arch
);
17888 error (_("%s: bad archive file name\n"), file_name
);
17892 namelen
= strlen (name
);
17894 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
17895 if (qualified_name
== NULL
)
17897 error (_("%s: bad archive file name\n"), file_name
);
17902 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
17904 /* This is a proxy for an external member of a thin archive. */
17905 FILE * member_file
;
17906 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
17908 if (member_file_name
== NULL
)
17914 member_file
= fopen (member_file_name
, "rb");
17915 if (member_file
== NULL
)
17917 error (_("Input file '%s' is not readable.\n"), member_file_name
);
17918 free (member_file_name
);
17923 archive_file_offset
= arch
.nested_member_origin
;
17925 if (! process_object (qualified_name
, member_file
))
17928 fclose (member_file
);
17929 free (member_file_name
);
17931 else if (is_thin_archive
)
17933 /* PR 15140: Allow for corrupt thin archives. */
17934 if (nested_arch
.file
== NULL
)
17936 error (_("%s: contains corrupt thin archive: %s\n"),
17942 /* This is a proxy for a member of a nested archive. */
17943 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
17945 /* The nested archive file will have been opened and setup by
17946 get_archive_member_name. */
17947 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17949 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17954 if (! process_object (qualified_name
, nested_arch
.file
))
17959 archive_file_offset
= arch
.next_arhdr_offset
;
17960 arch
.next_arhdr_offset
+= archive_file_size
;
17962 if (! process_object (qualified_name
, file
))
17966 if (dump_sects
!= NULL
)
17970 num_dump_sects
= 0;
17973 free (qualified_name
);
17977 if (nested_arch
.file
!= NULL
)
17978 fclose (nested_arch
.file
);
17979 release_archive (&nested_arch
);
17980 release_archive (&arch
);
17986 process_file (char * file_name
)
17989 struct stat statbuf
;
17990 char armag
[SARMAG
];
17991 bfd_boolean ret
= TRUE
;
17993 if (stat (file_name
, &statbuf
) < 0)
17995 if (errno
== ENOENT
)
17996 error (_("'%s': No such file\n"), file_name
);
17998 error (_("Could not locate '%s'. System error message: %s\n"),
17999 file_name
, strerror (errno
));
18003 if (! S_ISREG (statbuf
.st_mode
))
18005 error (_("'%s' is not an ordinary file\n"), file_name
);
18009 file
= fopen (file_name
, "rb");
18012 error (_("Input file '%s' is not readable.\n"), file_name
);
18016 if (fread (armag
, SARMAG
, 1, file
) != 1)
18018 error (_("%s: Failed to read file's magic number\n"), file_name
);
18023 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18025 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18027 if (! process_archive (file_name
, file
, FALSE
))
18030 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18032 if ( ! process_archive (file_name
, file
, TRUE
))
18037 if (do_archive_index
)
18038 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18042 archive_file_size
= archive_file_offset
= 0;
18044 if (! process_object (file_name
, file
))
18049 current_file_size
= 0;
18054 #ifdef SUPPORT_DISASSEMBLY
18055 /* Needed by the i386 disassembler. For extra credit, someone could
18056 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18060 print_address (unsigned int addr
, FILE * outfile
)
18062 fprintf (outfile
,"0x%8.8x", addr
);
18065 /* Needed by the i386 disassembler. */
18067 db_task_printsym (unsigned int addr
)
18069 print_address (addr
, stderr
);
18074 main (int argc
, char ** argv
)
18078 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18079 setlocale (LC_MESSAGES
, "");
18081 #if defined (HAVE_SETLOCALE)
18082 setlocale (LC_CTYPE
, "");
18084 bindtextdomain (PACKAGE
, LOCALEDIR
);
18085 textdomain (PACKAGE
);
18087 expandargv (&argc
, &argv
);
18089 parse_args (argc
, argv
);
18091 if (num_dump_sects
> 0)
18093 /* Make a copy of the dump_sects array. */
18094 cmdline_dump_sects
= (dump_type
*)
18095 malloc (num_dump_sects
* sizeof (* dump_sects
));
18096 if (cmdline_dump_sects
== NULL
)
18097 error (_("Out of memory allocating dump request table.\n"));
18100 memcpy (cmdline_dump_sects
, dump_sects
,
18101 num_dump_sects
* sizeof (* dump_sects
));
18102 num_cmdline_dump_sects
= num_dump_sects
;
18106 if (optind
< (argc
- 1))
18108 else if (optind
>= argc
)
18110 warn (_("Nothing to do.\n"));
18115 while (optind
< argc
)
18116 if (! process_file (argv
[optind
++]))
18119 if (dump_sects
!= NULL
)
18121 if (cmdline_dump_sects
!= NULL
)
18122 free (cmdline_dump_sects
);
18124 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;