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 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4798 sizeof (Elf_Internal_Phdr
));
4802 error (_("Out of memory reading %u program headers\n"),
4803 elf_header
.e_phnum
);
4808 ? get_32bit_program_headers (file
, phdrs
)
4809 : get_64bit_program_headers (file
, phdrs
))
4811 program_headers
= phdrs
;
4819 /* Returns TRUE if the program headers were loaded. */
4822 process_program_headers (FILE * file
)
4824 Elf_Internal_Phdr
* segment
;
4826 Elf_Internal_Phdr
* previous_load
= NULL
;
4828 if (elf_header
.e_phnum
== 0)
4830 /* PR binutils/12467. */
4831 if (elf_header
.e_phoff
!= 0)
4833 warn (_("possibly corrupt ELF header - it has a non-zero program"
4834 " header offset, but no program headers\n"));
4837 else if (do_segments
)
4838 printf (_("\nThere are no program headers in this file.\n"));
4842 if (do_segments
&& !do_header
)
4844 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4845 printf (_("Entry point "));
4846 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4847 printf (_("\nThere are %d program headers, starting at offset "),
4848 elf_header
.e_phnum
);
4849 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4853 if (! get_program_headers (file
))
4858 if (elf_header
.e_phnum
> 1)
4859 printf (_("\nProgram Headers:\n"));
4861 printf (_("\nProgram Headers:\n"));
4865 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4868 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4872 (_(" Type Offset VirtAddr PhysAddr\n"));
4874 (_(" FileSiz MemSiz Flags Align\n"));
4881 for (i
= 0, segment
= program_headers
;
4882 i
< elf_header
.e_phnum
;
4887 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4891 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4892 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4893 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4894 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4895 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4897 (segment
->p_flags
& PF_R
? 'R' : ' '),
4898 (segment
->p_flags
& PF_W
? 'W' : ' '),
4899 (segment
->p_flags
& PF_X
? 'E' : ' '));
4900 printf ("%#lx", (unsigned long) segment
->p_align
);
4904 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4905 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4908 print_vma (segment
->p_offset
, FULL_HEX
);
4912 print_vma (segment
->p_vaddr
, FULL_HEX
);
4914 print_vma (segment
->p_paddr
, FULL_HEX
);
4917 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4918 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4921 print_vma (segment
->p_filesz
, FULL_HEX
);
4925 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4926 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4929 print_vma (segment
->p_memsz
, FULL_HEX
);
4933 (segment
->p_flags
& PF_R
? 'R' : ' '),
4934 (segment
->p_flags
& PF_W
? 'W' : ' '),
4935 (segment
->p_flags
& PF_X
? 'E' : ' '));
4937 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4938 printf ("%#lx", (unsigned long) segment
->p_align
);
4941 print_vma (segment
->p_align
, PREFIX_HEX
);
4946 print_vma (segment
->p_offset
, FULL_HEX
);
4948 print_vma (segment
->p_vaddr
, FULL_HEX
);
4950 print_vma (segment
->p_paddr
, FULL_HEX
);
4952 print_vma (segment
->p_filesz
, FULL_HEX
);
4954 print_vma (segment
->p_memsz
, FULL_HEX
);
4956 (segment
->p_flags
& PF_R
? 'R' : ' '),
4957 (segment
->p_flags
& PF_W
? 'W' : ' '),
4958 (segment
->p_flags
& PF_X
? 'E' : ' '));
4959 print_vma (segment
->p_align
, PREFIX_HEX
);
4962 putc ('\n', stdout
);
4965 switch (segment
->p_type
)
4968 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4969 required by the ELF standard, several programs, including the Linux
4970 kernel, make use of non-ordered segments. */
4972 && previous_load
->p_vaddr
> segment
->p_vaddr
)
4973 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4975 if (segment
->p_memsz
< segment
->p_filesz
)
4976 error (_("the segment's file size is larger than its memory size\n"));
4977 previous_load
= segment
;
4981 /* PR 20815 - Verify that the program header is loaded into memory. */
4982 if (i
> 0 && previous_load
!= NULL
)
4983 error (_("the PHDR segment must occur before any LOAD segment\n"));
4984 if (elf_header
.e_machine
!= EM_PARISC
)
4988 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
4989 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
4990 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
4991 >= (segment
->p_vaddr
+ segment
->p_filesz
))
4993 if (j
== elf_header
.e_phnum
)
4994 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5000 error (_("more than one dynamic segment\n"));
5002 /* By default, assume that the .dynamic section is the first
5003 section in the DYNAMIC segment. */
5004 dynamic_addr
= segment
->p_offset
;
5005 dynamic_size
= segment
->p_filesz
;
5007 /* Try to locate the .dynamic section. If there is
5008 a section header table, we can easily locate it. */
5009 if (section_headers
!= NULL
)
5011 Elf_Internal_Shdr
* sec
;
5013 sec
= find_section (".dynamic");
5014 if (sec
== NULL
|| sec
->sh_size
== 0)
5016 /* A corresponding .dynamic section is expected, but on
5017 IA-64/OpenVMS it is OK for it to be missing. */
5018 if (!is_ia64_vms ())
5019 error (_("no .dynamic section in the dynamic segment\n"));
5023 if (sec
->sh_type
== SHT_NOBITS
)
5029 dynamic_addr
= sec
->sh_offset
;
5030 dynamic_size
= sec
->sh_size
;
5032 if (dynamic_addr
< segment
->p_offset
5033 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5034 warn (_("the .dynamic section is not contained"
5035 " within the dynamic segment\n"));
5036 else if (dynamic_addr
> segment
->p_offset
)
5037 warn (_("the .dynamic section is not the first section"
5038 " in the dynamic segment.\n"));
5041 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5042 segment. Check this after matching against the section headers
5043 so we don't warn on debuginfo file (which have NOBITS .dynamic
5045 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5047 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5048 dynamic_addr
= dynamic_size
= 0;
5053 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5055 error (_("Unable to find program interpreter name\n"));
5059 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5061 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5062 error (_("Internal error: failed to create format string to display program interpreter\n"));
5064 program_interpreter
[0] = 0;
5065 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5066 error (_("Unable to read program interpreter name\n"));
5069 printf (_(" [Requesting program interpreter: %s]\n"),
5070 program_interpreter
);
5076 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5078 printf (_("\n Section to Segment mapping:\n"));
5079 printf (_(" Segment Sections...\n"));
5081 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5084 Elf_Internal_Shdr
* section
;
5086 segment
= program_headers
+ i
;
5087 section
= section_headers
+ 1;
5089 printf (" %2.2d ", i
);
5091 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5093 if (!ELF_TBSS_SPECIAL (section
, segment
)
5094 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5095 printf ("%s ", printable_section_name (section
));
5106 /* Find the file offset corresponding to VMA by using the program headers. */
5109 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5111 Elf_Internal_Phdr
* seg
;
5113 if (! get_program_headers (file
))
5115 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5119 for (seg
= program_headers
;
5120 seg
< program_headers
+ elf_header
.e_phnum
;
5123 if (seg
->p_type
!= PT_LOAD
)
5126 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5127 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5128 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5131 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5132 (unsigned long) vma
);
5137 /* Allocate memory and load the sections headers into the global pointer
5138 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5139 generate any error messages if the load fails. */
5142 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5144 Elf32_External_Shdr
* shdrs
;
5145 Elf_Internal_Shdr
* internal
;
5147 unsigned int size
= elf_header
.e_shentsize
;
5148 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5150 /* PR binutils/17531: Cope with unexpected section header sizes. */
5151 if (size
== 0 || num
== 0)
5153 if (size
< sizeof * shdrs
)
5156 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5159 if (!probe
&& size
> sizeof * shdrs
)
5160 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5162 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5164 probe
? NULL
: _("section headers"));
5168 if (section_headers
!= NULL
)
5169 free (section_headers
);
5170 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5171 sizeof (Elf_Internal_Shdr
));
5172 if (section_headers
== NULL
)
5175 error (_("Out of memory reading %u section headers\n"), num
);
5179 for (i
= 0, internal
= section_headers
;
5183 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5184 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5185 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5186 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5187 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5188 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5189 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5190 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5191 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5192 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5193 if (!probe
&& internal
->sh_link
> num
)
5194 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5195 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5196 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5204 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5206 Elf64_External_Shdr
* shdrs
;
5207 Elf_Internal_Shdr
* internal
;
5209 unsigned int size
= elf_header
.e_shentsize
;
5210 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5212 /* PR binutils/17531: Cope with unexpected section header sizes. */
5213 if (size
== 0 || num
== 0)
5215 if (size
< sizeof * shdrs
)
5218 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5221 if (! probe
&& size
> sizeof * shdrs
)
5222 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5224 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5226 probe
? NULL
: _("section headers"));
5230 if (section_headers
!= NULL
)
5231 free (section_headers
);
5232 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5233 sizeof (Elf_Internal_Shdr
));
5234 if (section_headers
== NULL
)
5237 error (_("Out of memory reading %u section headers\n"), num
);
5241 for (i
= 0, internal
= section_headers
;
5245 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5246 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5247 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5248 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5249 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5250 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5251 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5252 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5253 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5254 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5255 if (!probe
&& internal
->sh_link
> num
)
5256 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5257 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5258 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5265 static Elf_Internal_Sym
*
5266 get_32bit_elf_symbols (FILE * file
,
5267 Elf_Internal_Shdr
* section
,
5268 unsigned long * num_syms_return
)
5270 unsigned long number
= 0;
5271 Elf32_External_Sym
* esyms
= NULL
;
5272 Elf_External_Sym_Shndx
* shndx
= NULL
;
5273 Elf_Internal_Sym
* isyms
= NULL
;
5274 Elf_Internal_Sym
* psym
;
5277 if (section
->sh_size
== 0)
5279 if (num_syms_return
!= NULL
)
5280 * num_syms_return
= 0;
5284 /* Run some sanity checks first. */
5285 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5287 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5288 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5292 if (section
->sh_size
> current_file_size
)
5294 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5295 printable_section_name (section
), (unsigned long) section
->sh_size
);
5299 number
= section
->sh_size
/ section
->sh_entsize
;
5301 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5303 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5304 (unsigned long) section
->sh_size
,
5305 printable_section_name (section
),
5306 (unsigned long) section
->sh_entsize
);
5310 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5311 section
->sh_size
, _("symbols"));
5316 elf_section_list
* entry
;
5319 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5320 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5322 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5323 entry
->hdr
->sh_offset
,
5324 1, entry
->hdr
->sh_size
,
5325 _("symbol table section indicies"));
5328 /* PR17531: file: heap-buffer-overflow */
5329 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5331 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5332 printable_section_name (entry
->hdr
),
5333 (unsigned long) entry
->hdr
->sh_size
,
5334 (unsigned long) section
->sh_size
);
5340 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5344 error (_("Out of memory reading %lu symbols\n"),
5345 (unsigned long) number
);
5349 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5351 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5352 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5353 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5354 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5355 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5357 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5358 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5359 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5360 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5361 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5370 if (num_syms_return
!= NULL
)
5371 * num_syms_return
= isyms
== NULL
? 0 : number
;
5376 static Elf_Internal_Sym
*
5377 get_64bit_elf_symbols (FILE * file
,
5378 Elf_Internal_Shdr
* section
,
5379 unsigned long * num_syms_return
)
5381 unsigned long number
= 0;
5382 Elf64_External_Sym
* esyms
= NULL
;
5383 Elf_External_Sym_Shndx
* shndx
= NULL
;
5384 Elf_Internal_Sym
* isyms
= NULL
;
5385 Elf_Internal_Sym
* psym
;
5388 if (section
->sh_size
== 0)
5390 if (num_syms_return
!= NULL
)
5391 * num_syms_return
= 0;
5395 /* Run some sanity checks first. */
5396 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5398 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5399 printable_section_name (section
),
5400 (unsigned long) section
->sh_entsize
);
5404 if (section
->sh_size
> current_file_size
)
5406 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5407 printable_section_name (section
),
5408 (unsigned long) section
->sh_size
);
5412 number
= section
->sh_size
/ section
->sh_entsize
;
5414 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5416 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5417 (unsigned long) section
->sh_size
,
5418 printable_section_name (section
),
5419 (unsigned long) section
->sh_entsize
);
5423 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5424 section
->sh_size
, _("symbols"));
5429 elf_section_list
* entry
;
5432 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5433 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5435 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5436 entry
->hdr
->sh_offset
,
5437 1, entry
->hdr
->sh_size
,
5438 _("symbol table section indicies"));
5441 /* PR17531: file: heap-buffer-overflow */
5442 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5444 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5445 printable_section_name (entry
->hdr
),
5446 (unsigned long) entry
->hdr
->sh_size
,
5447 (unsigned long) section
->sh_size
);
5453 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5457 error (_("Out of memory reading %lu symbols\n"),
5458 (unsigned long) number
);
5462 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5464 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5465 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5466 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5467 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5469 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5471 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5472 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5473 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5475 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5476 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5485 if (num_syms_return
!= NULL
)
5486 * num_syms_return
= isyms
== NULL
? 0 : number
;
5492 get_elf_section_flags (bfd_vma sh_flags
)
5494 static char buff
[1024];
5496 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5498 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5499 bfd_vma os_flags
= 0;
5500 bfd_vma proc_flags
= 0;
5501 bfd_vma unknown_flags
= 0;
5509 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5510 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5511 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5512 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5513 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5514 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5515 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5516 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5517 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5518 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5519 /* IA-64 specific. */
5520 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5521 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5522 /* IA-64 OpenVMS specific. */
5523 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5524 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5525 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5526 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5527 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5528 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5530 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5531 /* SPARC specific. */
5532 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5533 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5535 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5536 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5537 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5540 if (do_section_details
)
5542 sprintf (buff
, "[%*.*lx]: ",
5543 field_size
, field_size
, (unsigned long) sh_flags
);
5544 p
+= field_size
+ 4;
5551 flag
= sh_flags
& - sh_flags
;
5554 if (do_section_details
)
5558 case SHF_WRITE
: sindex
= 0; break;
5559 case SHF_ALLOC
: sindex
= 1; break;
5560 case SHF_EXECINSTR
: sindex
= 2; break;
5561 case SHF_MERGE
: sindex
= 3; break;
5562 case SHF_STRINGS
: sindex
= 4; break;
5563 case SHF_INFO_LINK
: sindex
= 5; break;
5564 case SHF_LINK_ORDER
: sindex
= 6; break;
5565 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5566 case SHF_GROUP
: sindex
= 8; break;
5567 case SHF_TLS
: sindex
= 9; break;
5568 case SHF_EXCLUDE
: sindex
= 18; break;
5569 case SHF_COMPRESSED
: sindex
= 20; break;
5573 switch (elf_header
.e_machine
)
5576 if (flag
== SHF_IA_64_SHORT
)
5578 else if (flag
== SHF_IA_64_NORECOV
)
5581 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5584 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5585 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5586 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5587 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5588 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5589 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5600 case EM_OLD_SPARCV9
:
5601 case EM_SPARC32PLUS
:
5604 if (flag
== SHF_ORDERED
)
5611 case SHF_ENTRYSECT
: sindex
= 21; break;
5612 case SHF_ARM_PURECODE
: sindex
= 22; break;
5613 case SHF_COMDEF
: sindex
= 23; break;
5625 if (p
!= buff
+ field_size
+ 4)
5627 if (size
< (10 + 2))
5629 warn (_("Internal error: not enough buffer room for section flag info"));
5630 return _("<unknown>");
5637 size
-= flags
[sindex
].len
;
5638 p
= stpcpy (p
, flags
[sindex
].str
);
5640 else if (flag
& SHF_MASKOS
)
5642 else if (flag
& SHF_MASKPROC
)
5645 unknown_flags
|= flag
;
5651 case SHF_WRITE
: *p
= 'W'; break;
5652 case SHF_ALLOC
: *p
= 'A'; break;
5653 case SHF_EXECINSTR
: *p
= 'X'; break;
5654 case SHF_MERGE
: *p
= 'M'; break;
5655 case SHF_STRINGS
: *p
= 'S'; break;
5656 case SHF_INFO_LINK
: *p
= 'I'; break;
5657 case SHF_LINK_ORDER
: *p
= 'L'; break;
5658 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5659 case SHF_GROUP
: *p
= 'G'; break;
5660 case SHF_TLS
: *p
= 'T'; break;
5661 case SHF_EXCLUDE
: *p
= 'E'; break;
5662 case SHF_COMPRESSED
: *p
= 'C'; break;
5665 if ((elf_header
.e_machine
== EM_X86_64
5666 || elf_header
.e_machine
== EM_L1OM
5667 || elf_header
.e_machine
== EM_K1OM
)
5668 && flag
== SHF_X86_64_LARGE
)
5670 else if (elf_header
.e_machine
== EM_ARM
5671 && flag
== SHF_ARM_PURECODE
)
5673 else if (flag
& SHF_MASKOS
)
5676 sh_flags
&= ~ SHF_MASKOS
;
5678 else if (flag
& SHF_MASKPROC
)
5681 sh_flags
&= ~ SHF_MASKPROC
;
5691 if (do_section_details
)
5695 size
-= 5 + field_size
;
5696 if (p
!= buff
+ field_size
+ 4)
5700 warn (_("Internal error: not enough buffer room for section flag info"));
5701 return _("<unknown>");
5707 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5708 (unsigned long) os_flags
);
5709 p
+= 5 + field_size
;
5713 size
-= 7 + field_size
;
5714 if (p
!= buff
+ field_size
+ 4)
5718 warn (_("Internal error: not enough buffer room for section flag info"));
5719 return _("<unknown>");
5725 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5726 (unsigned long) proc_flags
);
5727 p
+= 7 + field_size
;
5731 size
-= 10 + field_size
;
5732 if (p
!= buff
+ field_size
+ 4)
5736 warn (_("Internal error: not enough buffer room for section flag info"));
5737 return _("<unknown>");
5743 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5744 (unsigned long) unknown_flags
);
5745 p
+= 10 + field_size
;
5754 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5758 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5760 if (size
< sizeof (* echdr
))
5762 error (_("Compressed section is too small even for a compression header\n"));
5766 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5767 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5768 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5769 return sizeof (*echdr
);
5773 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5775 if (size
< sizeof (* echdr
))
5777 error (_("Compressed section is too small even for a compression header\n"));
5781 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5782 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5783 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5784 return sizeof (*echdr
);
5789 process_section_headers (FILE * file
)
5791 Elf_Internal_Shdr
* section
;
5794 section_headers
= NULL
;
5796 if (elf_header
.e_shnum
== 0)
5798 /* PR binutils/12467. */
5799 if (elf_header
.e_shoff
!= 0)
5801 warn (_("possibly corrupt ELF file header - it has a non-zero"
5802 " section header offset, but no section headers\n"));
5805 else if (do_sections
)
5806 printf (_("\nThere are no sections in this file.\n"));
5811 if (do_sections
&& !do_header
)
5812 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5813 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5817 if (! get_32bit_section_headers (file
, FALSE
))
5822 if (! get_64bit_section_headers (file
, FALSE
))
5826 /* Read in the string table, so that we have names to display. */
5827 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5828 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5830 section
= section_headers
+ elf_header
.e_shstrndx
;
5832 if (section
->sh_size
!= 0)
5834 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5835 1, section
->sh_size
,
5838 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5842 /* Scan the sections for the dynamic symbol table
5843 and dynamic string table and debug sections. */
5844 dynamic_symbols
= NULL
;
5845 dynamic_strings
= NULL
;
5846 dynamic_syminfo
= NULL
;
5847 symtab_shndx_list
= NULL
;
5849 eh_addr_size
= is_32bit_elf
? 4 : 8;
5850 switch (elf_header
.e_machine
)
5853 case EM_MIPS_RS3_LE
:
5854 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5855 FDE addresses. However, the ABI also has a semi-official ILP32
5856 variant for which the normal FDE address size rules apply.
5858 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5859 section, where XX is the size of longs in bits. Unfortunately,
5860 earlier compilers provided no way of distinguishing ILP32 objects
5861 from LP64 objects, so if there's any doubt, we should assume that
5862 the official LP64 form is being used. */
5863 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5864 && find_section (".gcc_compiled_long32") == NULL
)
5870 switch (elf_header
.e_flags
& EF_H8_MACH
)
5872 case E_H8_MACH_H8300
:
5873 case E_H8_MACH_H8300HN
:
5874 case E_H8_MACH_H8300SN
:
5875 case E_H8_MACH_H8300SXN
:
5878 case E_H8_MACH_H8300H
:
5879 case E_H8_MACH_H8300S
:
5880 case E_H8_MACH_H8300SX
:
5888 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5890 case EF_M32C_CPU_M16C
:
5897 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5900 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5901 if (section->sh_entsize != expected_entsize) \
5904 sprintf_vma (buf, section->sh_entsize); \
5905 /* Note: coded this way so that there is a single string for \
5907 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5908 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5909 (unsigned) expected_entsize); \
5910 section->sh_entsize = expected_entsize; \
5915 #define CHECK_ENTSIZE(section, i, type) \
5916 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5917 sizeof (Elf64_External_##type))
5919 for (i
= 0, section
= section_headers
;
5920 i
< elf_header
.e_shnum
;
5923 char * name
= SECTION_NAME (section
);
5925 if (section
->sh_type
== SHT_DYNSYM
)
5927 if (dynamic_symbols
!= NULL
)
5929 error (_("File contains multiple dynamic symbol tables\n"));
5933 CHECK_ENTSIZE (section
, i
, Sym
);
5934 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5936 else if (section
->sh_type
== SHT_STRTAB
5937 && streq (name
, ".dynstr"))
5939 if (dynamic_strings
!= NULL
)
5941 error (_("File contains multiple dynamic string tables\n"));
5945 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5946 1, section
->sh_size
,
5947 _("dynamic strings"));
5948 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5950 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5952 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5953 entry
->hdr
= section
;
5954 entry
->next
= symtab_shndx_list
;
5955 symtab_shndx_list
= entry
;
5957 else if (section
->sh_type
== SHT_SYMTAB
)
5958 CHECK_ENTSIZE (section
, i
, Sym
);
5959 else if (section
->sh_type
== SHT_GROUP
)
5960 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5961 else if (section
->sh_type
== SHT_REL
)
5962 CHECK_ENTSIZE (section
, i
, Rel
);
5963 else if (section
->sh_type
== SHT_RELA
)
5964 CHECK_ENTSIZE (section
, i
, Rela
);
5965 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5966 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5967 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5968 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5969 || do_debug_addr
|| do_debug_cu_index
)
5970 && (const_strneq (name
, ".debug_")
5971 || const_strneq (name
, ".zdebug_")))
5974 name
+= sizeof (".zdebug_") - 1;
5976 name
+= sizeof (".debug_") - 1;
5979 || (do_debug_info
&& const_strneq (name
, "info"))
5980 || (do_debug_info
&& const_strneq (name
, "types"))
5981 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5982 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5983 || (do_debug_lines
&& const_strneq (name
, "line."))
5984 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5985 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5986 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5987 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5988 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5989 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5990 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
5991 || (do_debug_frames
&& const_strneq (name
, "frame"))
5992 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5993 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5994 || (do_debug_str
&& const_strneq (name
, "str"))
5995 || (do_debug_loc
&& const_strneq (name
, "loc"))
5996 || (do_debug_loc
&& const_strneq (name
, "loclists"))
5997 || (do_debug_addr
&& const_strneq (name
, "addr"))
5998 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5999 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6001 request_dump_bynumber (i
, DEBUG_DUMP
);
6003 /* Linkonce section to be combined with .debug_info at link time. */
6004 else if ((do_debugging
|| do_debug_info
)
6005 && const_strneq (name
, ".gnu.linkonce.wi."))
6006 request_dump_bynumber (i
, DEBUG_DUMP
);
6007 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6008 request_dump_bynumber (i
, DEBUG_DUMP
);
6009 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
6010 request_dump_bynumber (i
, DEBUG_DUMP
);
6011 /* Trace sections for Itanium VMS. */
6012 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6013 || do_trace_aranges
)
6014 && const_strneq (name
, ".trace_"))
6016 name
+= sizeof (".trace_") - 1;
6019 || (do_trace_info
&& streq (name
, "info"))
6020 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6021 || (do_trace_aranges
&& streq (name
, "aranges"))
6023 request_dump_bynumber (i
, DEBUG_DUMP
);
6030 if (elf_header
.e_shnum
> 1)
6031 printf (_("\nSection Headers:\n"));
6033 printf (_("\nSection Header:\n"));
6037 if (do_section_details
)
6039 printf (_(" [Nr] Name\n"));
6040 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6044 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6048 if (do_section_details
)
6050 printf (_(" [Nr] Name\n"));
6051 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6055 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6059 if (do_section_details
)
6061 printf (_(" [Nr] Name\n"));
6062 printf (_(" Type Address Offset Link\n"));
6063 printf (_(" Size EntSize Info Align\n"));
6067 printf (_(" [Nr] Name Type Address Offset\n"));
6068 printf (_(" Size EntSize Flags Link Info Align\n"));
6072 if (do_section_details
)
6073 printf (_(" Flags\n"));
6075 for (i
= 0, section
= section_headers
;
6076 i
< elf_header
.e_shnum
;
6079 /* Run some sanity checks on the section header. */
6081 /* Check the sh_link field. */
6082 switch (section
->sh_type
)
6084 case SHT_SYMTAB_SHNDX
:
6088 case SHT_GNU_versym
:
6091 if (section
->sh_link
< 1
6092 || section
->sh_link
>= elf_header
.e_shnum
6093 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6094 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6095 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6096 i
, section
->sh_link
);
6102 case SHT_GNU_verneed
:
6103 case SHT_GNU_verdef
:
6104 case SHT_GNU_LIBLIST
:
6105 if (section
->sh_link
< 1
6106 || section
->sh_link
>= elf_header
.e_shnum
6107 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6108 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6109 i
, section
->sh_link
);
6112 case SHT_INIT_ARRAY
:
6113 case SHT_FINI_ARRAY
:
6114 case SHT_PREINIT_ARRAY
:
6115 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6116 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6117 i
, section
->sh_link
);
6121 /* FIXME: Add support for target specific section types. */
6122 #if 0 /* Currently we do not check other section types as there are too
6123 many special cases. Stab sections for example have a type
6124 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6126 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6127 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6128 i
, section
->sh_link
);
6133 /* Check the sh_info field. */
6134 switch (section
->sh_type
)
6138 if (section
->sh_info
< 1
6139 || section
->sh_info
>= elf_header
.e_shnum
6140 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6141 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6142 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6143 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6144 /* FIXME: Are other section types valid ? */
6145 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6147 if (section
->sh_info
== 0
6148 && (streq (SECTION_NAME (section
), ".rel.dyn")
6149 || streq (SECTION_NAME (section
), ".rela.dyn")))
6150 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6151 of zero. The relocations in these sections may apply
6152 to many different sections. */
6155 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6156 i
, section
->sh_info
);
6162 case SHT_SYMTAB_SHNDX
:
6163 case SHT_INIT_ARRAY
:
6164 case SHT_FINI_ARRAY
:
6165 case SHT_PREINIT_ARRAY
:
6166 if (section
->sh_info
!= 0)
6167 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6168 i
, section
->sh_info
);
6174 /* A symbol index - we assume that it is valid. */
6178 /* FIXME: Add support for target specific section types. */
6179 if (section
->sh_type
== SHT_NOBITS
)
6180 /* NOBITS section headers with non-zero sh_info fields can be
6181 created when a binary is stripped of everything but its debug
6182 information. The stripped sections have their headers
6183 preserved but their types set to SHT_NOBITS. So do not check
6184 this type of section. */
6186 else if (section
->sh_flags
& SHF_INFO_LINK
)
6188 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6189 warn (_("[%2u]: Expected link to another section in info field"), i
);
6191 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6192 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6193 i
, section
->sh_info
);
6197 printf (" [%2u] ", i
);
6198 if (do_section_details
)
6199 printf ("%s\n ", printable_section_name (section
));
6201 print_symbol (-17, SECTION_NAME (section
));
6203 printf (do_wide
? " %-15s " : " %-15.15s ",
6204 get_section_type_name (section
->sh_type
));
6208 const char * link_too_big
= NULL
;
6210 print_vma (section
->sh_addr
, LONG_HEX
);
6212 printf ( " %6.6lx %6.6lx %2.2lx",
6213 (unsigned long) section
->sh_offset
,
6214 (unsigned long) section
->sh_size
,
6215 (unsigned long) section
->sh_entsize
);
6217 if (do_section_details
)
6218 fputs (" ", stdout
);
6220 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6222 if (section
->sh_link
>= elf_header
.e_shnum
)
6225 /* The sh_link value is out of range. Normally this indicates
6226 an error but it can have special values in Solaris binaries. */
6227 switch (elf_header
.e_machine
)
6234 case EM_OLD_SPARCV9
:
6235 case EM_SPARC32PLUS
:
6238 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6239 link_too_big
= "BEFORE";
6240 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6241 link_too_big
= "AFTER";
6248 if (do_section_details
)
6250 if (link_too_big
!= NULL
&& * link_too_big
)
6251 printf ("<%s> ", link_too_big
);
6253 printf ("%2u ", section
->sh_link
);
6254 printf ("%3u %2lu\n", section
->sh_info
,
6255 (unsigned long) section
->sh_addralign
);
6258 printf ("%2u %3u %2lu\n",
6261 (unsigned long) section
->sh_addralign
);
6263 if (link_too_big
&& ! * link_too_big
)
6264 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6265 i
, section
->sh_link
);
6269 print_vma (section
->sh_addr
, LONG_HEX
);
6271 if ((long) section
->sh_offset
== section
->sh_offset
)
6272 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6276 print_vma (section
->sh_offset
, LONG_HEX
);
6279 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6280 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6284 print_vma (section
->sh_size
, LONG_HEX
);
6287 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6288 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6292 print_vma (section
->sh_entsize
, LONG_HEX
);
6295 if (do_section_details
)
6296 fputs (" ", stdout
);
6298 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6300 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6302 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6303 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6306 print_vma (section
->sh_addralign
, DEC
);
6310 else if (do_section_details
)
6312 printf (" %-15.15s ",
6313 get_section_type_name (section
->sh_type
));
6314 print_vma (section
->sh_addr
, LONG_HEX
);
6315 if ((long) section
->sh_offset
== section
->sh_offset
)
6316 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6320 print_vma (section
->sh_offset
, LONG_HEX
);
6322 printf (" %u\n ", section
->sh_link
);
6323 print_vma (section
->sh_size
, LONG_HEX
);
6325 print_vma (section
->sh_entsize
, LONG_HEX
);
6327 printf (" %-16u %lu\n",
6329 (unsigned long) section
->sh_addralign
);
6334 print_vma (section
->sh_addr
, LONG_HEX
);
6335 if ((long) section
->sh_offset
== section
->sh_offset
)
6336 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6340 print_vma (section
->sh_offset
, LONG_HEX
);
6343 print_vma (section
->sh_size
, LONG_HEX
);
6345 print_vma (section
->sh_entsize
, LONG_HEX
);
6347 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6349 printf (" %2u %3u %lu\n",
6352 (unsigned long) section
->sh_addralign
);
6355 if (do_section_details
)
6357 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6358 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6360 /* Minimum section size is 12 bytes for 32-bit compression
6361 header + 12 bytes for compressed data header. */
6362 unsigned char buf
[24];
6364 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6365 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6366 sizeof (buf
), _("compression header")))
6368 Elf_Internal_Chdr chdr
;
6370 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6372 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6375 printf (_(" [<unknown>: 0x%x], "),
6377 print_vma (chdr
.ch_size
, LONG_HEX
);
6378 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6384 if (!do_section_details
)
6386 /* The ordering of the letters shown here matches the ordering of the
6387 corresponding SHF_xxx values, and hence the order in which these
6388 letters will be displayed to the user. */
6389 printf (_("Key to Flags:\n\
6390 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6391 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6392 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6393 if (elf_header
.e_machine
== EM_X86_64
6394 || elf_header
.e_machine
== EM_L1OM
6395 || elf_header
.e_machine
== EM_K1OM
)
6396 printf (_("l (large), "));
6397 else if (elf_header
.e_machine
== EM_ARM
)
6398 printf (_("y (purecode), "));
6399 printf ("p (processor specific)\n");
6406 get_group_flags (unsigned int flags
)
6408 static char buff
[128];
6412 else if (flags
== GRP_COMDAT
)
6415 snprintf (buff
, 14, _("[0x%x: "), flags
);
6417 flags
&= ~ GRP_COMDAT
;
6418 if (flags
& GRP_MASKOS
)
6420 strcat (buff
, "<OS specific>");
6421 flags
&= ~ GRP_MASKOS
;
6424 if (flags
& GRP_MASKPROC
)
6426 strcat (buff
, "<PROC specific>");
6427 flags
&= ~ GRP_MASKPROC
;
6431 strcat (buff
, "<unknown>");
6438 process_section_groups (FILE * file
)
6440 Elf_Internal_Shdr
* section
;
6442 struct group
* group
;
6443 Elf_Internal_Shdr
* symtab_sec
;
6444 Elf_Internal_Shdr
* strtab_sec
;
6445 Elf_Internal_Sym
* symtab
;
6446 unsigned long num_syms
;
6450 /* Don't process section groups unless needed. */
6451 if (!do_unwind
&& !do_section_groups
)
6454 if (elf_header
.e_shnum
== 0)
6456 if (do_section_groups
)
6457 printf (_("\nThere are no sections to group in this file.\n"));
6462 if (section_headers
== NULL
)
6464 error (_("Section headers are not available!\n"));
6465 /* PR 13622: This can happen with a corrupt ELF header. */
6469 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6470 sizeof (struct group
*));
6472 if (section_headers_groups
== NULL
)
6474 error (_("Out of memory reading %u section group headers\n"),
6475 elf_header
.e_shnum
);
6479 /* Scan the sections for the group section. */
6481 for (i
= 0, section
= section_headers
;
6482 i
< elf_header
.e_shnum
;
6484 if (section
->sh_type
== SHT_GROUP
)
6487 if (group_count
== 0)
6489 if (do_section_groups
)
6490 printf (_("\nThere are no section groups in this file.\n"));
6495 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6497 if (section_groups
== NULL
)
6499 error (_("Out of memory reading %lu groups\n"),
6500 (unsigned long) group_count
);
6510 for (i
= 0, section
= section_headers
, group
= section_groups
;
6511 i
< elf_header
.e_shnum
;
6514 if (section
->sh_type
== SHT_GROUP
)
6516 const char * name
= printable_section_name (section
);
6517 const char * group_name
;
6518 unsigned char * start
;
6519 unsigned char * indices
;
6520 unsigned int entry
, j
, size
;
6521 Elf_Internal_Shdr
* sec
;
6522 Elf_Internal_Sym
* sym
;
6524 /* Get the symbol table. */
6525 if (section
->sh_link
>= elf_header
.e_shnum
6526 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6529 error (_("Bad sh_link in group section `%s'\n"), name
);
6533 if (symtab_sec
!= sec
)
6538 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6543 error (_("Corrupt header in group section `%s'\n"), name
);
6547 if (section
->sh_info
>= num_syms
)
6549 error (_("Bad sh_info in group section `%s'\n"), name
);
6553 sym
= symtab
+ section
->sh_info
;
6555 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6557 if (sym
->st_shndx
== 0
6558 || sym
->st_shndx
>= elf_header
.e_shnum
)
6560 error (_("Bad sh_info in group section `%s'\n"), name
);
6564 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6573 /* Get the string table. */
6574 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6583 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6589 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6590 1, strtab_sec
->sh_size
,
6592 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6594 group_name
= sym
->st_name
< strtab_size
6595 ? strtab
+ sym
->st_name
: _("<corrupt>");
6598 /* PR 17531: file: loop. */
6599 if (section
->sh_entsize
> section
->sh_size
)
6601 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6602 printable_section_name (section
),
6603 (unsigned long) section
->sh_entsize
,
6604 (unsigned long) section
->sh_size
);
6608 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6609 1, section
->sh_size
,
6615 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6616 entry
= byte_get (indices
, 4);
6619 if (do_section_groups
)
6621 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6622 get_group_flags (entry
), i
, name
, group_name
, size
);
6624 printf (_(" [Index] Name\n"));
6627 group
->group_index
= i
;
6629 for (j
= 0; j
< size
; j
++)
6631 struct group_list
* g
;
6633 entry
= byte_get (indices
, 4);
6636 if (entry
>= elf_header
.e_shnum
)
6638 static unsigned num_group_errors
= 0;
6640 if (num_group_errors
++ < 10)
6642 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6643 entry
, i
, elf_header
.e_shnum
- 1);
6644 if (num_group_errors
== 10)
6645 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6650 if (section_headers_groups
[entry
] != NULL
)
6654 static unsigned num_errs
= 0;
6656 if (num_errs
++ < 10)
6658 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6660 section_headers_groups
[entry
]->group_index
);
6662 warn (_("Further error messages about already contained group sections suppressed\n"));
6668 /* Intel C/C++ compiler may put section 0 in a
6669 section group. We just warn it the first time
6670 and ignore it afterwards. */
6671 static bfd_boolean warned
= FALSE
;
6674 error (_("section 0 in group section [%5u]\n"),
6675 section_headers_groups
[entry
]->group_index
);
6681 section_headers_groups
[entry
] = group
;
6683 if (do_section_groups
)
6685 sec
= section_headers
+ entry
;
6686 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6689 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6690 g
->section_index
= entry
;
6691 g
->next
= group
->root
;
6709 /* Data used to display dynamic fixups. */
6711 struct ia64_vms_dynfixup
6713 bfd_vma needed_ident
; /* Library ident number. */
6714 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6715 bfd_vma fixup_needed
; /* Index of the library. */
6716 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6717 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6720 /* Data used to display dynamic relocations. */
6722 struct ia64_vms_dynimgrela
6724 bfd_vma img_rela_cnt
; /* Number of relocations. */
6725 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6728 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6732 dump_ia64_vms_dynamic_fixups (FILE * file
,
6733 struct ia64_vms_dynfixup
* fixup
,
6734 const char * strtab
,
6735 unsigned int strtab_sz
)
6737 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6739 const char * lib_name
;
6741 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6742 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6743 _("dynamic section image fixups"));
6747 if (fixup
->needed
< strtab_sz
)
6748 lib_name
= strtab
+ fixup
->needed
;
6751 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6752 (unsigned long) fixup
->needed
);
6755 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6756 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6758 (_("Seg Offset Type SymVec DataType\n"));
6760 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6765 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6766 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6767 type
= BYTE_GET (imfs
[i
].type
);
6768 rtype
= elf_ia64_reloc_type (type
);
6770 printf (" 0x%08x ", type
);
6772 printf (" %-32s ", rtype
);
6773 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6774 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6781 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6784 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6786 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6789 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6790 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6791 _("dynamic section image relocations"));
6795 printf (_("\nImage relocs\n"));
6797 (_("Seg Offset Type Addend Seg Sym Off\n"));
6799 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6804 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6805 printf ("%08" BFD_VMA_FMT
"x ",
6806 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6807 type
= BYTE_GET (imrs
[i
].type
);
6808 rtype
= elf_ia64_reloc_type (type
);
6810 printf ("0x%08x ", type
);
6812 printf ("%-31s ", rtype
);
6813 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6814 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6815 printf ("%08" BFD_VMA_FMT
"x\n",
6816 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6823 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6826 process_ia64_vms_dynamic_relocs (FILE *file
)
6828 struct ia64_vms_dynfixup fixup
;
6829 struct ia64_vms_dynimgrela imgrela
;
6830 Elf_Internal_Dyn
*entry
;
6831 bfd_vma strtab_off
= 0;
6832 bfd_vma strtab_sz
= 0;
6833 char *strtab
= NULL
;
6834 bfd_boolean res
= TRUE
;
6836 memset (&fixup
, 0, sizeof (fixup
));
6837 memset (&imgrela
, 0, sizeof (imgrela
));
6839 /* Note: the order of the entries is specified by the OpenVMS specs. */
6840 for (entry
= dynamic_section
;
6841 entry
< dynamic_section
+ dynamic_nent
;
6844 switch (entry
->d_tag
)
6846 case DT_IA_64_VMS_STRTAB_OFFSET
:
6847 strtab_off
= entry
->d_un
.d_val
;
6850 strtab_sz
= entry
->d_un
.d_val
;
6852 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6853 1, strtab_sz
, _("dynamic string section"));
6856 case DT_IA_64_VMS_NEEDED_IDENT
:
6857 fixup
.needed_ident
= entry
->d_un
.d_val
;
6860 fixup
.needed
= entry
->d_un
.d_val
;
6862 case DT_IA_64_VMS_FIXUP_NEEDED
:
6863 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6865 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6866 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6868 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6869 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6870 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6873 case DT_IA_64_VMS_IMG_RELA_CNT
:
6874 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6876 case DT_IA_64_VMS_IMG_RELA_OFF
:
6877 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6878 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6900 dynamic_relocations
[] =
6902 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6903 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6904 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6907 /* Process the reloc section. */
6910 process_relocs (FILE * file
)
6912 unsigned long rel_size
;
6913 unsigned long rel_offset
;
6918 if (do_using_dynamic
)
6922 bfd_boolean has_dynamic_reloc
;
6925 has_dynamic_reloc
= FALSE
;
6927 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6929 is_rela
= dynamic_relocations
[i
].rela
;
6930 name
= dynamic_relocations
[i
].name
;
6931 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6932 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6935 has_dynamic_reloc
= TRUE
;
6937 if (is_rela
== UNKNOWN
)
6939 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6940 switch (dynamic_info
[DT_PLTREL
])
6954 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6955 name
, rel_offset
, rel_size
);
6957 dump_relocations (file
,
6958 offset_from_vma (file
, rel_offset
, rel_size
),
6960 dynamic_symbols
, num_dynamic_syms
,
6961 dynamic_strings
, dynamic_strings_length
,
6962 is_rela
, TRUE
/* is_dynamic */);
6967 if (process_ia64_vms_dynamic_relocs (file
))
6968 has_dynamic_reloc
= TRUE
;
6970 if (! has_dynamic_reloc
)
6971 printf (_("\nThere are no dynamic relocations in this file.\n"));
6975 Elf_Internal_Shdr
* section
;
6977 bfd_boolean found
= FALSE
;
6979 for (i
= 0, section
= section_headers
;
6980 i
< elf_header
.e_shnum
;
6983 if ( section
->sh_type
!= SHT_RELA
6984 && section
->sh_type
!= SHT_REL
)
6987 rel_offset
= section
->sh_offset
;
6988 rel_size
= section
->sh_size
;
6992 Elf_Internal_Shdr
* strsec
;
6995 printf (_("\nRelocation section "));
6997 if (string_table
== NULL
)
6998 printf ("%d", section
->sh_name
);
7000 printf ("'%s'", printable_section_name (section
));
7002 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7003 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
7005 is_rela
= section
->sh_type
== SHT_RELA
;
7007 if (section
->sh_link
!= 0
7008 && section
->sh_link
< elf_header
.e_shnum
)
7010 Elf_Internal_Shdr
* symsec
;
7011 Elf_Internal_Sym
* symtab
;
7012 unsigned long nsyms
;
7013 unsigned long strtablen
= 0;
7014 char * strtab
= NULL
;
7016 symsec
= section_headers
+ section
->sh_link
;
7017 if (symsec
->sh_type
!= SHT_SYMTAB
7018 && symsec
->sh_type
!= SHT_DYNSYM
)
7021 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7026 if (symsec
->sh_link
!= 0
7027 && symsec
->sh_link
< elf_header
.e_shnum
)
7029 strsec
= section_headers
+ symsec
->sh_link
;
7031 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7034 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7037 dump_relocations (file
, rel_offset
, rel_size
,
7038 symtab
, nsyms
, strtab
, strtablen
,
7040 symsec
->sh_type
== SHT_DYNSYM
);
7046 dump_relocations (file
, rel_offset
, rel_size
,
7047 NULL
, 0, NULL
, 0, is_rela
,
7048 FALSE
/* is_dynamic */);
7055 printf (_("\nThere are no relocations in this file.\n"));
7061 /* An absolute address consists of a section and an offset. If the
7062 section is NULL, the offset itself is the address, otherwise, the
7063 address equals to LOAD_ADDRESS(section) + offset. */
7067 unsigned short section
;
7071 #define ABSADDR(a) \
7073 ? section_headers [(a).section].sh_addr + (a).offset \
7076 /* Find the nearest symbol at or below ADDR. Returns the symbol
7077 name, if found, and the offset from the symbol to ADDR. */
7080 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7081 unsigned long nsyms
,
7082 const char * strtab
,
7083 unsigned long strtab_size
,
7084 struct absaddr addr
,
7085 const char ** symname
,
7088 bfd_vma dist
= 0x100000;
7089 Elf_Internal_Sym
* sym
;
7090 Elf_Internal_Sym
* beg
;
7091 Elf_Internal_Sym
* end
;
7092 Elf_Internal_Sym
* best
= NULL
;
7094 REMOVE_ARCH_BITS (addr
.offset
);
7096 end
= symtab
+ nsyms
;
7102 sym
= beg
+ (end
- beg
) / 2;
7104 value
= sym
->st_value
;
7105 REMOVE_ARCH_BITS (value
);
7107 if (sym
->st_name
!= 0
7108 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7109 && addr
.offset
>= value
7110 && addr
.offset
- value
< dist
)
7113 dist
= addr
.offset
- value
;
7118 if (addr
.offset
< value
)
7126 *symname
= (best
->st_name
>= strtab_size
7127 ? _("<corrupt>") : strtab
+ best
->st_name
);
7133 *offset
= addr
.offset
;
7136 static /* signed */ int
7137 symcmp (const void *p
, const void *q
)
7139 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7140 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7142 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7145 /* Process the unwind section. */
7147 #include "unwind-ia64.h"
7149 struct ia64_unw_table_entry
7151 struct absaddr start
;
7153 struct absaddr info
;
7156 struct ia64_unw_aux_info
7158 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7159 unsigned long table_len
; /* Length of unwind table. */
7160 unsigned char * info
; /* Unwind info. */
7161 unsigned long info_size
; /* Size of unwind info. */
7162 bfd_vma info_addr
; /* Starting address of unwind info. */
7163 bfd_vma seg_base
; /* Starting address of segment. */
7164 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7165 unsigned long nsyms
; /* Number of symbols. */
7166 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7167 unsigned long nfuns
; /* Number of entries in funtab. */
7168 char * strtab
; /* The string table. */
7169 unsigned long strtab_size
; /* Size of string table. */
7173 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7175 struct ia64_unw_table_entry
* tp
;
7176 unsigned long j
, nfuns
;
7178 bfd_boolean res
= TRUE
;
7180 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7181 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7182 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7183 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7185 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7187 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7191 const unsigned char * dp
;
7192 const unsigned char * head
;
7193 const unsigned char * end
;
7194 const char * procname
;
7196 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7197 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7199 fputs ("\n<", stdout
);
7203 fputs (procname
, stdout
);
7206 printf ("+%lx", (unsigned long) offset
);
7209 fputs (">: [", stdout
);
7210 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7211 fputc ('-', stdout
);
7212 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7213 printf ("], info at +0x%lx\n",
7214 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7216 /* PR 17531: file: 86232b32. */
7217 if (aux
->info
== NULL
)
7220 /* PR 17531: file: 0997b4d1. */
7221 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7223 warn (_("Invalid offset %lx in table entry %ld\n"),
7224 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7229 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7230 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7232 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7233 (unsigned) UNW_VER (stamp
),
7234 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7235 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7236 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7237 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7239 if (UNW_VER (stamp
) != 1)
7241 printf (_("\tUnknown version.\n"));
7246 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7247 /* PR 17531: file: 16ceda89. */
7248 if (end
> aux
->info
+ aux
->info_size
)
7249 end
= aux
->info
+ aux
->info_size
;
7250 for (dp
= head
+ 8; dp
< end
;)
7251 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7260 slurp_ia64_unwind_table (FILE * file
,
7261 struct ia64_unw_aux_info
* aux
,
7262 Elf_Internal_Shdr
* sec
)
7264 unsigned long size
, nrelas
, i
;
7265 Elf_Internal_Phdr
* seg
;
7266 struct ia64_unw_table_entry
* tep
;
7267 Elf_Internal_Shdr
* relsec
;
7268 Elf_Internal_Rela
* rela
;
7269 Elf_Internal_Rela
* rp
;
7270 unsigned char * table
;
7272 Elf_Internal_Sym
* sym
;
7273 const char * relname
;
7277 /* First, find the starting address of the segment that includes
7280 if (elf_header
.e_phnum
)
7282 if (! get_program_headers (file
))
7285 for (seg
= program_headers
;
7286 seg
< program_headers
+ elf_header
.e_phnum
;
7289 if (seg
->p_type
!= PT_LOAD
)
7292 if (sec
->sh_addr
>= seg
->p_vaddr
7293 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7295 aux
->seg_base
= seg
->p_vaddr
;
7301 /* Second, build the unwind table from the contents of the unwind section: */
7302 size
= sec
->sh_size
;
7303 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7308 aux
->table_len
= size
/ (3 * eh_addr_size
);
7309 aux
->table
= (struct ia64_unw_table_entry
*)
7310 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7313 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7315 tep
->start
.section
= SHN_UNDEF
;
7316 tep
->end
.section
= SHN_UNDEF
;
7317 tep
->info
.section
= SHN_UNDEF
;
7318 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7319 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7320 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7321 tep
->start
.offset
+= aux
->seg_base
;
7322 tep
->end
.offset
+= aux
->seg_base
;
7323 tep
->info
.offset
+= aux
->seg_base
;
7327 /* Third, apply any relocations to the unwind table: */
7328 for (relsec
= section_headers
;
7329 relsec
< section_headers
+ elf_header
.e_shnum
;
7332 if (relsec
->sh_type
!= SHT_RELA
7333 || relsec
->sh_info
>= elf_header
.e_shnum
7334 || section_headers
+ relsec
->sh_info
!= sec
)
7337 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7346 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7348 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7349 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7351 /* PR 17531: file: 9fa67536. */
7352 if (relname
== NULL
)
7354 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7358 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7360 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7364 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7366 /* PR 17531: file: 5bc8d9bf. */
7367 if (i
>= aux
->table_len
)
7369 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7373 switch (rp
->r_offset
/ eh_addr_size
% 3)
7376 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7377 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7380 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7381 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7384 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7385 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7399 ia64_process_unwind (FILE * file
)
7401 Elf_Internal_Shdr
* sec
;
7402 Elf_Internal_Shdr
* unwsec
= NULL
;
7403 Elf_Internal_Shdr
* strsec
;
7404 unsigned long i
, unwcount
= 0, unwstart
= 0;
7405 struct ia64_unw_aux_info aux
;
7406 bfd_boolean res
= TRUE
;
7408 memset (& aux
, 0, sizeof (aux
));
7410 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7412 if (sec
->sh_type
== SHT_SYMTAB
7413 && sec
->sh_link
< elf_header
.e_shnum
)
7415 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7417 strsec
= section_headers
+ sec
->sh_link
;
7418 if (aux
.strtab
!= NULL
)
7420 error (_("Multiple auxillary string tables encountered\n"));
7424 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7427 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7429 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7434 printf (_("\nThere are no unwind sections in this file.\n"));
7436 while (unwcount
-- > 0)
7441 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7442 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7443 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7448 /* We have already counted the number of SHT_IA64_UNWIND
7449 sections so the loop above should never fail. */
7450 assert (unwsec
!= NULL
);
7453 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7455 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7457 /* We need to find which section group it is in. */
7458 struct group_list
* g
;
7460 if (section_headers_groups
== NULL
7461 || section_headers_groups
[i
] == NULL
)
7462 i
= elf_header
.e_shnum
;
7465 g
= section_headers_groups
[i
]->root
;
7467 for (; g
!= NULL
; g
= g
->next
)
7469 sec
= section_headers
+ g
->section_index
;
7471 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7476 i
= elf_header
.e_shnum
;
7479 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7481 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7482 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7483 suffix
= SECTION_NAME (unwsec
) + len
;
7484 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7486 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7487 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7492 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7493 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7494 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7495 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7497 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7498 suffix
= SECTION_NAME (unwsec
) + len
;
7499 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7501 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7502 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7506 if (i
== elf_header
.e_shnum
)
7508 printf (_("\nCould not find unwind info section for "));
7510 if (string_table
== NULL
)
7511 printf ("%d", unwsec
->sh_name
);
7513 printf ("'%s'", printable_section_name (unwsec
));
7517 aux
.info_addr
= sec
->sh_addr
;
7518 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7521 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7523 printf (_("\nUnwind section "));
7525 if (string_table
== NULL
)
7526 printf ("%d", unwsec
->sh_name
);
7528 printf ("'%s'", printable_section_name (unwsec
));
7530 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7531 (unsigned long) unwsec
->sh_offset
,
7532 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7534 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7535 && aux
.table_len
> 0)
7536 dump_ia64_unwind (& aux
);
7539 free ((char *) aux
.table
);
7541 free ((char *) aux
.info
);
7550 free ((char *) aux
.strtab
);
7555 struct hppa_unw_table_entry
7557 struct absaddr start
;
7559 unsigned int Cannot_unwind
:1; /* 0 */
7560 unsigned int Millicode
:1; /* 1 */
7561 unsigned int Millicode_save_sr0
:1; /* 2 */
7562 unsigned int Region_description
:2; /* 3..4 */
7563 unsigned int reserved1
:1; /* 5 */
7564 unsigned int Entry_SR
:1; /* 6 */
7565 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7566 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7567 unsigned int Args_stored
:1; /* 16 */
7568 unsigned int Variable_Frame
:1; /* 17 */
7569 unsigned int Separate_Package_Body
:1; /* 18 */
7570 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7571 unsigned int Stack_Overflow_Check
:1; /* 20 */
7572 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7573 unsigned int Ada_Region
:1; /* 22 */
7574 unsigned int cxx_info
:1; /* 23 */
7575 unsigned int cxx_try_catch
:1; /* 24 */
7576 unsigned int sched_entry_seq
:1; /* 25 */
7577 unsigned int reserved2
:1; /* 26 */
7578 unsigned int Save_SP
:1; /* 27 */
7579 unsigned int Save_RP
:1; /* 28 */
7580 unsigned int Save_MRP_in_frame
:1; /* 29 */
7581 unsigned int extn_ptr_defined
:1; /* 30 */
7582 unsigned int Cleanup_defined
:1; /* 31 */
7584 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7585 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7586 unsigned int Large_frame
:1; /* 2 */
7587 unsigned int Pseudo_SP_Set
:1; /* 3 */
7588 unsigned int reserved4
:1; /* 4 */
7589 unsigned int Total_frame_size
:27; /* 5..31 */
7592 struct hppa_unw_aux_info
7594 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7595 unsigned long table_len
; /* Length of unwind table. */
7596 bfd_vma seg_base
; /* Starting address of segment. */
7597 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7598 unsigned long nsyms
; /* Number of symbols. */
7599 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7600 unsigned long nfuns
; /* Number of entries in funtab. */
7601 char * strtab
; /* The string table. */
7602 unsigned long strtab_size
; /* Size of string table. */
7606 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7608 struct hppa_unw_table_entry
* tp
;
7609 unsigned long j
, nfuns
;
7610 bfd_boolean res
= TRUE
;
7612 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7613 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7614 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7615 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7617 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7619 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7622 const char * procname
;
7624 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7625 aux
->strtab_size
, tp
->start
, &procname
,
7628 fputs ("\n<", stdout
);
7632 fputs (procname
, stdout
);
7635 printf ("+%lx", (unsigned long) offset
);
7638 fputs (">: [", stdout
);
7639 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7640 fputc ('-', stdout
);
7641 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7644 #define PF(_m) if (tp->_m) printf (#_m " ");
7645 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7648 PF(Millicode_save_sr0
);
7649 /* PV(Region_description); */
7655 PF(Separate_Package_Body
);
7656 PF(Frame_Extension_Millicode
);
7657 PF(Stack_Overflow_Check
);
7658 PF(Two_Instruction_SP_Increment
);
7662 PF(sched_entry_seq
);
7665 PF(Save_MRP_in_frame
);
7666 PF(extn_ptr_defined
);
7667 PF(Cleanup_defined
);
7668 PF(MPE_XL_interrupt_marker
);
7669 PF(HP_UX_interrupt_marker
);
7672 PV(Total_frame_size
);
7685 slurp_hppa_unwind_table (FILE * file
,
7686 struct hppa_unw_aux_info
* aux
,
7687 Elf_Internal_Shdr
* sec
)
7689 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7690 Elf_Internal_Phdr
* seg
;
7691 struct hppa_unw_table_entry
* tep
;
7692 Elf_Internal_Shdr
* relsec
;
7693 Elf_Internal_Rela
* rela
;
7694 Elf_Internal_Rela
* rp
;
7695 unsigned char * table
;
7697 Elf_Internal_Sym
* sym
;
7698 const char * relname
;
7700 /* First, find the starting address of the segment that includes
7702 if (elf_header
.e_phnum
)
7704 if (! get_program_headers (file
))
7707 for (seg
= program_headers
;
7708 seg
< program_headers
+ elf_header
.e_phnum
;
7711 if (seg
->p_type
!= PT_LOAD
)
7714 if (sec
->sh_addr
>= seg
->p_vaddr
7715 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7717 aux
->seg_base
= seg
->p_vaddr
;
7723 /* Second, build the unwind table from the contents of the unwind
7725 size
= sec
->sh_size
;
7726 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7732 nentries
= size
/ unw_ent_size
;
7733 size
= unw_ent_size
* nentries
;
7735 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7736 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7738 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7740 unsigned int tmp1
, tmp2
;
7742 tep
->start
.section
= SHN_UNDEF
;
7743 tep
->end
.section
= SHN_UNDEF
;
7745 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7746 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7747 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7748 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7750 tep
->start
.offset
+= aux
->seg_base
;
7751 tep
->end
.offset
+= aux
->seg_base
;
7753 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7754 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7755 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7756 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7757 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7758 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7759 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7760 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7761 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7762 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7763 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7764 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7765 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7766 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7767 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7768 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7769 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7770 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7771 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7772 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7773 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7774 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7775 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7776 tep
->Cleanup_defined
= tmp1
& 0x1;
7778 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7779 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7780 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7781 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7782 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7783 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7787 /* Third, apply any relocations to the unwind table. */
7788 for (relsec
= section_headers
;
7789 relsec
< section_headers
+ elf_header
.e_shnum
;
7792 if (relsec
->sh_type
!= SHT_RELA
7793 || relsec
->sh_info
>= elf_header
.e_shnum
7794 || section_headers
+ relsec
->sh_info
!= sec
)
7797 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7801 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7803 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7804 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7806 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7807 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7809 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7813 i
= rp
->r_offset
/ unw_ent_size
;
7815 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7818 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7819 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7822 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7823 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7833 aux
->table_len
= nentries
;
7839 hppa_process_unwind (FILE * file
)
7841 struct hppa_unw_aux_info aux
;
7842 Elf_Internal_Shdr
* unwsec
= NULL
;
7843 Elf_Internal_Shdr
* strsec
;
7844 Elf_Internal_Shdr
* sec
;
7846 bfd_boolean res
= TRUE
;
7848 if (string_table
== NULL
)
7851 memset (& aux
, 0, sizeof (aux
));
7853 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7855 if (sec
->sh_type
== SHT_SYMTAB
7856 && sec
->sh_link
< elf_header
.e_shnum
)
7858 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7860 strsec
= section_headers
+ sec
->sh_link
;
7861 if (aux
.strtab
!= NULL
)
7863 error (_("Multiple auxillary string tables encountered\n"));
7867 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7870 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7872 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7877 printf (_("\nThere are no unwind sections in this file.\n"));
7879 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7881 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7883 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7884 printable_section_name (sec
),
7885 (unsigned long) sec
->sh_offset
,
7886 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7888 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7891 if (aux
.table_len
> 0)
7893 if (! dump_hppa_unwind (&aux
))
7898 free ((char *) aux
.table
);
7906 free ((char *) aux
.strtab
);
7913 unsigned char * data
; /* The unwind data. */
7914 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7915 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7916 unsigned long nrelas
; /* The number of relocations. */
7917 unsigned int rel_type
; /* REL or RELA ? */
7918 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7921 struct arm_unw_aux_info
7923 FILE * file
; /* The file containing the unwind sections. */
7924 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7925 unsigned long nsyms
; /* Number of symbols. */
7926 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7927 unsigned long nfuns
; /* Number of these symbols. */
7928 char * strtab
; /* The file's string table. */
7929 unsigned long strtab_size
; /* Size of string table. */
7933 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7934 bfd_vma fn
, struct absaddr addr
)
7936 const char *procname
;
7939 if (addr
.section
== SHN_UNDEF
)
7942 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7943 aux
->strtab_size
, addr
, &procname
,
7946 print_vma (fn
, PREFIX_HEX
);
7950 fputs (" <", stdout
);
7951 fputs (procname
, stdout
);
7954 printf ("+0x%lx", (unsigned long) sym_offset
);
7955 fputc ('>', stdout
);
7962 arm_free_section (struct arm_section
*arm_sec
)
7964 if (arm_sec
->data
!= NULL
)
7965 free (arm_sec
->data
);
7967 if (arm_sec
->rela
!= NULL
)
7968 free (arm_sec
->rela
);
7971 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7972 cached section and install SEC instead.
7973 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7974 and return its valued in * WORDP, relocating if necessary.
7975 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7976 relocation's offset in ADDR.
7977 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7978 into the string table of the symbol associated with the reloc. If no
7979 reloc was applied store -1 there.
7980 5) Return TRUE upon success, FALSE otherwise. */
7983 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7984 struct arm_section
* arm_sec
,
7985 Elf_Internal_Shdr
* sec
,
7986 bfd_vma word_offset
,
7987 unsigned int * wordp
,
7988 struct absaddr
* addr
,
7991 Elf_Internal_Rela
*rp
;
7992 Elf_Internal_Sym
*sym
;
7993 const char * relname
;
7995 bfd_boolean wrapped
;
7997 if (sec
== NULL
|| arm_sec
== NULL
)
8000 addr
->section
= SHN_UNDEF
;
8003 if (sym_name
!= NULL
)
8004 *sym_name
= (bfd_vma
) -1;
8006 /* If necessary, update the section cache. */
8007 if (sec
!= arm_sec
->sec
)
8009 Elf_Internal_Shdr
*relsec
;
8011 arm_free_section (arm_sec
);
8014 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8015 sec
->sh_size
, _("unwind data"));
8016 arm_sec
->rela
= NULL
;
8017 arm_sec
->nrelas
= 0;
8019 for (relsec
= section_headers
;
8020 relsec
< section_headers
+ elf_header
.e_shnum
;
8023 if (relsec
->sh_info
>= elf_header
.e_shnum
8024 || section_headers
+ relsec
->sh_info
!= sec
8025 /* PR 15745: Check the section type as well. */
8026 || (relsec
->sh_type
!= SHT_REL
8027 && relsec
->sh_type
!= SHT_RELA
))
8030 arm_sec
->rel_type
= relsec
->sh_type
;
8031 if (relsec
->sh_type
== SHT_REL
)
8033 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8035 & arm_sec
->rela
, & arm_sec
->nrelas
))
8038 else /* relsec->sh_type == SHT_RELA */
8040 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8042 & arm_sec
->rela
, & arm_sec
->nrelas
))
8048 arm_sec
->next_rela
= arm_sec
->rela
;
8051 /* If there is no unwind data we can do nothing. */
8052 if (arm_sec
->data
== NULL
)
8055 /* If the offset is invalid then fail. */
8056 if (/* PR 21343 *//* PR 18879 */
8058 || word_offset
> (sec
->sh_size
- 4)
8059 || ((bfd_signed_vma
) word_offset
) < 0)
8062 /* Get the word at the required offset. */
8063 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8065 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8066 if (arm_sec
->rela
== NULL
)
8072 /* Look through the relocs to find the one that applies to the provided offset. */
8074 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8076 bfd_vma prelval
, offset
;
8078 if (rp
->r_offset
> word_offset
&& !wrapped
)
8083 if (rp
->r_offset
> word_offset
)
8086 if (rp
->r_offset
& 3)
8088 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8089 (unsigned long) rp
->r_offset
);
8093 if (rp
->r_offset
< word_offset
)
8096 /* PR 17531: file: 027-161405-0.004 */
8097 if (aux
->symtab
== NULL
)
8100 if (arm_sec
->rel_type
== SHT_REL
)
8102 offset
= word
& 0x7fffffff;
8103 if (offset
& 0x40000000)
8104 offset
|= ~ (bfd_vma
) 0x7fffffff;
8106 else if (arm_sec
->rel_type
== SHT_RELA
)
8107 offset
= rp
->r_addend
;
8110 error (_("Unknown section relocation type %d encountered\n"),
8115 /* PR 17531 file: 027-1241568-0.004. */
8116 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8118 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8119 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8123 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8124 offset
+= sym
->st_value
;
8125 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8127 /* Check that we are processing the expected reloc type. */
8128 if (elf_header
.e_machine
== EM_ARM
)
8130 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8131 if (relname
== NULL
)
8133 warn (_("Skipping unknown ARM relocation type: %d\n"),
8134 (int) ELF32_R_TYPE (rp
->r_info
));
8138 if (streq (relname
, "R_ARM_NONE"))
8141 if (! streq (relname
, "R_ARM_PREL31"))
8143 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8147 else if (elf_header
.e_machine
== EM_TI_C6000
)
8149 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8150 if (relname
== NULL
)
8152 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8153 (int) ELF32_R_TYPE (rp
->r_info
));
8157 if (streq (relname
, "R_C6000_NONE"))
8160 if (! streq (relname
, "R_C6000_PREL31"))
8162 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8170 /* This function currently only supports ARM and TI unwinders. */
8171 warn (_("Only TI and ARM unwinders are currently supported\n"));
8175 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8176 addr
->section
= sym
->st_shndx
;
8177 addr
->offset
= offset
;
8180 * sym_name
= sym
->st_name
;
8185 arm_sec
->next_rela
= rp
;
8190 static const char *tic6x_unwind_regnames
[16] =
8192 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8193 "A14", "A13", "A12", "A11", "A10",
8194 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8198 decode_tic6x_unwind_regmask (unsigned int mask
)
8202 for (i
= 12; mask
; mask
>>= 1, i
--)
8206 fputs (tic6x_unwind_regnames
[i
], stdout
);
8208 fputs (", ", stdout
);
8214 if (remaining == 0 && more_words) \
8217 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8218 data_offset, & word, & addr, NULL)) \
8224 #define GET_OP(OP) \
8229 (OP) = word >> 24; \
8234 printf (_("[Truncated opcode]\n")); \
8237 printf ("0x%02x ", OP)
8240 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8242 unsigned int remaining
,
8243 unsigned int more_words
,
8244 bfd_vma data_offset
,
8245 Elf_Internal_Shdr
* data_sec
,
8246 struct arm_section
* data_arm_sec
)
8248 struct absaddr addr
;
8249 bfd_boolean res
= TRUE
;
8251 /* Decode the unwinding instructions. */
8254 unsigned int op
, op2
;
8263 printf (" 0x%02x ", op
);
8265 if ((op
& 0xc0) == 0x00)
8267 int offset
= ((op
& 0x3f) << 2) + 4;
8269 printf (" vsp = vsp + %d", offset
);
8271 else if ((op
& 0xc0) == 0x40)
8273 int offset
= ((op
& 0x3f) << 2) + 4;
8275 printf (" vsp = vsp - %d", offset
);
8277 else if ((op
& 0xf0) == 0x80)
8280 if (op
== 0x80 && op2
== 0)
8281 printf (_("Refuse to unwind"));
8284 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8285 bfd_boolean first
= TRUE
;
8289 for (i
= 0; i
< 12; i
++)
8290 if (mask
& (1 << i
))
8296 printf ("r%d", 4 + i
);
8301 else if ((op
& 0xf0) == 0x90)
8303 if (op
== 0x9d || op
== 0x9f)
8304 printf (_(" [Reserved]"));
8306 printf (" vsp = r%d", op
& 0x0f);
8308 else if ((op
& 0xf0) == 0xa0)
8310 int end
= 4 + (op
& 0x07);
8311 bfd_boolean first
= TRUE
;
8315 for (i
= 4; i
<= end
; i
++)
8331 else if (op
== 0xb0)
8332 printf (_(" finish"));
8333 else if (op
== 0xb1)
8336 if (op2
== 0 || (op2
& 0xf0) != 0)
8337 printf (_("[Spare]"));
8340 unsigned int mask
= op2
& 0x0f;
8341 bfd_boolean first
= TRUE
;
8345 for (i
= 0; i
< 12; i
++)
8346 if (mask
& (1 << i
))
8357 else if (op
== 0xb2)
8359 unsigned char buf
[9];
8360 unsigned int i
, len
;
8361 unsigned long offset
;
8363 for (i
= 0; i
< sizeof (buf
); i
++)
8366 if ((buf
[i
] & 0x80) == 0)
8369 if (i
== sizeof (buf
))
8371 error (_("corrupt change to vsp"));
8376 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8377 assert (len
== i
+ 1);
8378 offset
= offset
* 4 + 0x204;
8379 printf ("vsp = vsp + %ld", offset
);
8382 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8384 unsigned int first
, last
;
8391 printf ("pop {D%d", first
);
8393 printf ("-D%d", first
+ last
);
8396 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8398 unsigned int count
= op
& 0x07;
8402 printf ("-D%d", 8 + count
);
8405 else if (op
>= 0xc0 && op
<= 0xc5)
8407 unsigned int count
= op
& 0x07;
8409 printf (" pop {wR10");
8411 printf ("-wR%d", 10 + count
);
8414 else if (op
== 0xc6)
8416 unsigned int first
, last
;
8421 printf ("pop {wR%d", first
);
8423 printf ("-wR%d", first
+ last
);
8426 else if (op
== 0xc7)
8429 if (op2
== 0 || (op2
& 0xf0) != 0)
8430 printf (_("[Spare]"));
8433 unsigned int mask
= op2
& 0x0f;
8434 bfd_boolean first
= TRUE
;
8438 for (i
= 0; i
< 4; i
++)
8439 if (mask
& (1 << i
))
8445 printf ("wCGR%d", i
);
8452 printf (_(" [unsupported opcode]"));
8463 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8465 unsigned int remaining
,
8466 unsigned int more_words
,
8467 bfd_vma data_offset
,
8468 Elf_Internal_Shdr
* data_sec
,
8469 struct arm_section
* data_arm_sec
)
8471 struct absaddr addr
;
8473 /* Decode the unwinding instructions. */
8476 unsigned int op
, op2
;
8485 printf (" 0x%02x ", op
);
8487 if ((op
& 0xc0) == 0x00)
8489 int offset
= ((op
& 0x3f) << 3) + 8;
8490 printf (" sp = sp + %d", offset
);
8492 else if ((op
& 0xc0) == 0x80)
8495 if (op
== 0x80 && op2
== 0)
8496 printf (_("Refuse to unwind"));
8499 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8501 printf ("pop compact {");
8505 decode_tic6x_unwind_regmask (mask
);
8509 else if ((op
& 0xf0) == 0xc0)
8517 unsigned int offset
;
8521 /* Scan entire instruction first so that GET_OP output is not
8522 interleaved with disassembly. */
8524 for (i
= 0; nregs
< (op
& 0xf); i
++)
8530 regpos
[nregs
].offset
= i
* 2;
8531 regpos
[nregs
].reg
= reg
;
8538 regpos
[nregs
].offset
= i
* 2 + 1;
8539 regpos
[nregs
].reg
= reg
;
8544 printf (_("pop frame {"));
8546 for (i
= i
* 2; i
> 0; i
--)
8548 if (regpos
[reg
].offset
== i
- 1)
8550 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8557 fputs (name
, stdout
);
8564 else if (op
== 0xd0)
8565 printf (" MOV FP, SP");
8566 else if (op
== 0xd1)
8567 printf (" __c6xabi_pop_rts");
8568 else if (op
== 0xd2)
8570 unsigned char buf
[9];
8571 unsigned int i
, len
;
8572 unsigned long offset
;
8574 for (i
= 0; i
< sizeof (buf
); i
++)
8577 if ((buf
[i
] & 0x80) == 0)
8580 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8581 if (i
== sizeof (buf
))
8583 warn (_("Corrupt stack pointer adjustment detected\n"));
8587 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8588 assert (len
== i
+ 1);
8589 offset
= offset
* 8 + 0x408;
8590 printf (_("sp = sp + %ld"), offset
);
8592 else if ((op
& 0xf0) == 0xe0)
8594 if ((op
& 0x0f) == 7)
8597 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8601 printf (_(" [unsupported opcode]"));
8610 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8614 offset
= word
& 0x7fffffff;
8615 if (offset
& 0x40000000)
8616 offset
|= ~ (bfd_vma
) 0x7fffffff;
8618 if (elf_header
.e_machine
== EM_TI_C6000
)
8621 return offset
+ where
;
8625 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8627 unsigned int remaining
,
8628 bfd_vma data_offset
,
8629 Elf_Internal_Shdr
* data_sec
,
8630 struct arm_section
* data_arm_sec
)
8633 unsigned int more_words
= 0;
8634 struct absaddr addr
;
8635 bfd_vma sym_name
= (bfd_vma
) -1;
8636 bfd_boolean res
= FALSE
;
8640 /* Fetch the first word.
8641 Note - when decoding an object file the address extracted
8642 here will always be 0. So we also pass in the sym_name
8643 parameter so that we can find the symbol associated with
8644 the personality routine. */
8645 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8646 & word
, & addr
, & sym_name
))
8652 if ((word
& 0x80000000) == 0)
8654 /* Expand prel31 for personality routine. */
8656 const char *procname
;
8658 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8659 printf (_(" Personality routine: "));
8661 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8662 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8664 procname
= aux
->strtab
+ sym_name
;
8665 print_vma (fn
, PREFIX_HEX
);
8668 fputs (" <", stdout
);
8669 fputs (procname
, stdout
);
8670 fputc ('>', stdout
);
8674 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8675 fputc ('\n', stdout
);
8677 /* The GCC personality routines use the standard compact
8678 encoding, starting with one byte giving the number of
8680 if (procname
!= NULL
8681 && (const_strneq (procname
, "__gcc_personality_v0")
8682 || const_strneq (procname
, "__gxx_personality_v0")
8683 || const_strneq (procname
, "__gcj_personality_v0")
8684 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8691 printf (_(" [Truncated data]\n"));
8694 more_words
= word
>> 24;
8704 /* ARM EHABI Section 6.3:
8706 An exception-handling table entry for the compact model looks like:
8710 1 0 index Data for personalityRoutine[index] */
8712 if (elf_header
.e_machine
== EM_ARM
8713 && (word
& 0x70000000))
8715 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8719 per_index
= (word
>> 24) & 0x7f;
8720 printf (_(" Compact model index: %d\n"), per_index
);
8727 else if (per_index
< 3)
8729 more_words
= (word
>> 16) & 0xff;
8735 switch (elf_header
.e_machine
)
8740 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8741 data_offset
, data_sec
, data_arm_sec
))
8746 warn (_("Unknown ARM compact model index encountered\n"));
8747 printf (_(" [reserved]\n"));
8755 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8756 data_offset
, data_sec
, data_arm_sec
))
8759 else if (per_index
< 5)
8761 if (((word
>> 17) & 0x7f) == 0x7f)
8762 printf (_(" Restore stack from frame pointer\n"));
8764 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8765 printf (_(" Registers restored: "));
8767 printf (" (compact) ");
8768 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8770 printf (_(" Return register: %s\n"),
8771 tic6x_unwind_regnames
[word
& 0xf]);
8774 printf (_(" [reserved (%d)]\n"), per_index
);
8778 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8779 elf_header
.e_machine
);
8783 /* Decode the descriptors. Not implemented. */
8789 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8791 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8792 unsigned int i
, exidx_len
;
8793 unsigned long j
, nfuns
;
8794 bfd_boolean res
= TRUE
;
8796 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8797 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8798 exidx_len
= exidx_sec
->sh_size
/ 8;
8800 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8801 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8802 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8803 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8805 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8807 for (i
= 0; i
< exidx_len
; i
++)
8809 unsigned int exidx_fn
, exidx_entry
;
8810 struct absaddr fn_addr
, entry_addr
;
8813 fputc ('\n', stdout
);
8815 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8816 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8817 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8818 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8821 arm_free_section (& exidx_arm_sec
);
8822 arm_free_section (& extab_arm_sec
);
8826 /* ARM EHABI, Section 5:
8827 An index table entry consists of 2 words.
8828 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8829 if (exidx_fn
& 0x80000000)
8831 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8835 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8837 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8838 fputs (": ", stdout
);
8840 if (exidx_entry
== 1)
8842 print_vma (exidx_entry
, PREFIX_HEX
);
8843 fputs (" [cantunwind]\n", stdout
);
8845 else if (exidx_entry
& 0x80000000)
8847 print_vma (exidx_entry
, PREFIX_HEX
);
8848 fputc ('\n', stdout
);
8849 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8853 bfd_vma table
, table_offset
= 0;
8854 Elf_Internal_Shdr
*table_sec
;
8856 fputs ("@", stdout
);
8857 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8858 print_vma (table
, PREFIX_HEX
);
8861 /* Locate the matching .ARM.extab. */
8862 if (entry_addr
.section
!= SHN_UNDEF
8863 && entry_addr
.section
< elf_header
.e_shnum
)
8865 table_sec
= section_headers
+ entry_addr
.section
;
8866 table_offset
= entry_addr
.offset
;
8868 if (table_offset
> table_sec
->sh_size
8869 || ((bfd_signed_vma
) table_offset
) < 0)
8871 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8872 (unsigned long) table_offset
,
8873 printable_section_name (table_sec
));
8880 table_sec
= find_section_by_address (table
);
8881 if (table_sec
!= NULL
)
8882 table_offset
= table
- table_sec
->sh_addr
;
8885 if (table_sec
== NULL
)
8887 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8888 (unsigned long) table
);
8893 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8902 arm_free_section (&exidx_arm_sec
);
8903 arm_free_section (&extab_arm_sec
);
8908 /* Used for both ARM and C6X unwinding tables. */
8911 arm_process_unwind (FILE *file
)
8913 struct arm_unw_aux_info aux
;
8914 Elf_Internal_Shdr
*unwsec
= NULL
;
8915 Elf_Internal_Shdr
*strsec
;
8916 Elf_Internal_Shdr
*sec
;
8918 unsigned int sec_type
;
8919 bfd_boolean res
= TRUE
;
8921 switch (elf_header
.e_machine
)
8924 sec_type
= SHT_ARM_EXIDX
;
8928 sec_type
= SHT_C6000_UNWIND
;
8932 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8933 elf_header
.e_machine
);
8937 if (string_table
== NULL
)
8940 memset (& aux
, 0, sizeof (aux
));
8943 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8945 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8947 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8949 strsec
= section_headers
+ sec
->sh_link
;
8951 /* PR binutils/17531 file: 011-12666-0.004. */
8952 if (aux
.strtab
!= NULL
)
8954 error (_("Multiple string tables found in file.\n"));
8958 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8959 1, strsec
->sh_size
, _("string table"));
8960 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8962 else if (sec
->sh_type
== sec_type
)
8967 printf (_("\nThere are no unwind sections in this file.\n"));
8969 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8971 if (sec
->sh_type
== sec_type
)
8973 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8974 printable_section_name (sec
),
8975 (unsigned long) sec
->sh_offset
,
8976 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8978 if (! dump_arm_unwind (&aux
, sec
))
8986 free ((char *) aux
.strtab
);
8992 process_unwind (FILE * file
)
8994 struct unwind_handler
8996 unsigned int machtype
;
8997 bfd_boolean (* handler
)(FILE *);
9000 { EM_ARM
, arm_process_unwind
},
9001 { EM_IA_64
, ia64_process_unwind
},
9002 { EM_PARISC
, hppa_process_unwind
},
9003 { EM_TI_C6000
, arm_process_unwind
},
9011 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9012 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9013 return handlers
[i
].handler (file
);
9015 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9016 get_machine_name (elf_header
.e_machine
));
9021 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9023 switch (entry
->d_tag
)
9026 if (entry
->d_un
.d_val
== 0)
9030 static const char * opts
[] =
9032 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9033 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9034 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9035 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9039 bfd_boolean first
= TRUE
;
9041 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9042 if (entry
->d_un
.d_val
& (1 << cnt
))
9044 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9050 case DT_MIPS_IVERSION
:
9051 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9052 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9056 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9057 /* Note: coded this way so that there is a single string for translation. */
9058 printf (_("<corrupt: %s>"), buf
);
9062 case DT_MIPS_TIME_STAMP
:
9066 time_t atime
= entry
->d_un
.d_val
;
9068 tmp
= gmtime (&atime
);
9069 /* PR 17531: file: 6accc532. */
9071 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9073 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9074 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9075 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9076 printf (_("Time Stamp: %s"), timebuf
);
9080 case DT_MIPS_RLD_VERSION
:
9081 case DT_MIPS_LOCAL_GOTNO
:
9082 case DT_MIPS_CONFLICTNO
:
9083 case DT_MIPS_LIBLISTNO
:
9084 case DT_MIPS_SYMTABNO
:
9085 case DT_MIPS_UNREFEXTNO
:
9086 case DT_MIPS_HIPAGENO
:
9087 case DT_MIPS_DELTA_CLASS_NO
:
9088 case DT_MIPS_DELTA_INSTANCE_NO
:
9089 case DT_MIPS_DELTA_RELOC_NO
:
9090 case DT_MIPS_DELTA_SYM_NO
:
9091 case DT_MIPS_DELTA_CLASSSYM_NO
:
9092 case DT_MIPS_COMPACT_SIZE
:
9093 print_vma (entry
->d_un
.d_val
, DEC
);
9097 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9103 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9105 switch (entry
->d_tag
)
9107 case DT_HP_DLD_FLAGS
:
9116 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9117 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9118 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9119 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9120 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9121 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9122 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9123 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9124 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9125 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9126 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9127 { DT_HP_GST
, "HP_GST" },
9128 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9129 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9130 { DT_HP_NODELETE
, "HP_NODELETE" },
9131 { DT_HP_GROUP
, "HP_GROUP" },
9132 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9134 bfd_boolean first
= TRUE
;
9136 bfd_vma val
= entry
->d_un
.d_val
;
9138 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9139 if (val
& flags
[cnt
].bit
)
9143 fputs (flags
[cnt
].str
, stdout
);
9145 val
^= flags
[cnt
].bit
;
9148 if (val
!= 0 || first
)
9152 print_vma (val
, HEX
);
9158 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9166 /* VMS vs Unix time offset and factor. */
9168 #define VMS_EPOCH_OFFSET 35067168000000000LL
9169 #define VMS_GRANULARITY_FACTOR 10000000
9171 /* Display a VMS time in a human readable format. */
9174 print_vms_time (bfd_int64_t vmstime
)
9179 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9180 tm
= gmtime (&unxtime
);
9181 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9182 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9183 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9188 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9190 switch (entry
->d_tag
)
9192 case DT_IA_64_PLT_RESERVE
:
9193 /* First 3 slots reserved. */
9194 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9196 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9199 case DT_IA_64_VMS_LINKTIME
:
9201 print_vms_time (entry
->d_un
.d_val
);
9205 case DT_IA_64_VMS_LNKFLAGS
:
9206 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9207 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9208 printf (" CALL_DEBUG");
9209 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9210 printf (" NOP0BUFS");
9211 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9212 printf (" P0IMAGE");
9213 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9214 printf (" MKTHREADS");
9215 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9216 printf (" UPCALLS");
9217 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9219 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9220 printf (" INITIALIZE");
9221 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9223 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9224 printf (" EXE_INIT");
9225 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9226 printf (" TBK_IN_IMG");
9227 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9228 printf (" DBG_IN_IMG");
9229 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9230 printf (" TBK_IN_DSF");
9231 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9232 printf (" DBG_IN_DSF");
9233 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9234 printf (" SIGNATURES");
9235 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9236 printf (" REL_SEG_OFF");
9240 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9247 get_32bit_dynamic_section (FILE * file
)
9249 Elf32_External_Dyn
* edyn
;
9250 Elf32_External_Dyn
* ext
;
9251 Elf_Internal_Dyn
* entry
;
9253 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9254 dynamic_size
, _("dynamic section"));
9258 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9259 might not have the luxury of section headers. Look for the DT_NULL
9260 terminator to determine the number of entries. */
9261 for (ext
= edyn
, dynamic_nent
= 0;
9262 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9266 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9270 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9272 if (dynamic_section
== NULL
)
9274 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9275 (unsigned long) dynamic_nent
);
9280 for (ext
= edyn
, entry
= dynamic_section
;
9281 entry
< dynamic_section
+ dynamic_nent
;
9284 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9285 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9294 get_64bit_dynamic_section (FILE * file
)
9296 Elf64_External_Dyn
* edyn
;
9297 Elf64_External_Dyn
* ext
;
9298 Elf_Internal_Dyn
* entry
;
9300 /* Read in the data. */
9301 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9302 dynamic_size
, _("dynamic section"));
9306 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9307 might not have the luxury of section headers. Look for the DT_NULL
9308 terminator to determine the number of entries. */
9309 for (ext
= edyn
, dynamic_nent
= 0;
9310 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9311 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9315 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9319 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9321 if (dynamic_section
== NULL
)
9323 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9324 (unsigned long) dynamic_nent
);
9329 /* Convert from external to internal formats. */
9330 for (ext
= edyn
, entry
= dynamic_section
;
9331 entry
< dynamic_section
+ dynamic_nent
;
9334 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9335 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9344 print_dynamic_flags (bfd_vma flags
)
9346 bfd_boolean first
= TRUE
;
9352 flag
= flags
& - flags
;
9362 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9363 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9364 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9365 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9366 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9367 default: fputs (_("unknown"), stdout
); break;
9373 /* Parse and display the contents of the dynamic section. */
9376 process_dynamic_section (FILE * file
)
9378 Elf_Internal_Dyn
* entry
;
9380 if (dynamic_size
== 0)
9383 printf (_("\nThere is no dynamic section in this file.\n"));
9390 if (! get_32bit_dynamic_section (file
))
9395 if (! get_64bit_dynamic_section (file
))
9399 /* Find the appropriate symbol table. */
9400 if (dynamic_symbols
== NULL
)
9402 for (entry
= dynamic_section
;
9403 entry
< dynamic_section
+ dynamic_nent
;
9406 Elf_Internal_Shdr section
;
9408 if (entry
->d_tag
!= DT_SYMTAB
)
9411 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9413 /* Since we do not know how big the symbol table is,
9414 we default to reading in the entire file (!) and
9415 processing that. This is overkill, I know, but it
9417 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9419 if (archive_file_offset
!= 0)
9420 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9423 if (fseek (file
, 0, SEEK_END
))
9424 error (_("Unable to seek to end of file!\n"));
9426 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9430 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9432 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9433 section
.sh_name
= string_table_length
;
9435 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9436 if (num_dynamic_syms
< 1)
9438 error (_("Unable to determine the number of symbols to load\n"));
9444 /* Similarly find a string table. */
9445 if (dynamic_strings
== NULL
)
9447 for (entry
= dynamic_section
;
9448 entry
< dynamic_section
+ dynamic_nent
;
9451 unsigned long offset
;
9454 if (entry
->d_tag
!= DT_STRTAB
)
9457 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9459 /* Since we do not know how big the string table is,
9460 we default to reading in the entire file (!) and
9461 processing that. This is overkill, I know, but it
9464 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9466 if (archive_file_offset
!= 0)
9467 str_tab_len
= archive_file_size
- offset
;
9470 if (fseek (file
, 0, SEEK_END
))
9471 error (_("Unable to seek to end of file\n"));
9472 str_tab_len
= ftell (file
) - offset
;
9475 if (str_tab_len
< 1)
9478 (_("Unable to determine the length of the dynamic string table\n"));
9482 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9484 _("dynamic string table"));
9485 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9490 /* And find the syminfo section if available. */
9491 if (dynamic_syminfo
== NULL
)
9493 unsigned long syminsz
= 0;
9495 for (entry
= dynamic_section
;
9496 entry
< dynamic_section
+ dynamic_nent
;
9499 if (entry
->d_tag
== DT_SYMINENT
)
9501 /* Note: these braces are necessary to avoid a syntax
9502 error from the SunOS4 C compiler. */
9503 /* PR binutils/17531: A corrupt file can trigger this test.
9504 So do not use an assert, instead generate an error message. */
9505 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9506 error (_("Bad value (%d) for SYMINENT entry\n"),
9507 (int) entry
->d_un
.d_val
);
9509 else if (entry
->d_tag
== DT_SYMINSZ
)
9510 syminsz
= entry
->d_un
.d_val
;
9511 else if (entry
->d_tag
== DT_SYMINFO
)
9512 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9516 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9518 Elf_External_Syminfo
* extsyminfo
;
9519 Elf_External_Syminfo
* extsym
;
9520 Elf_Internal_Syminfo
* syminfo
;
9522 /* There is a syminfo section. Read the data. */
9523 extsyminfo
= (Elf_External_Syminfo
*)
9524 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9525 _("symbol information"));
9529 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9530 if (dynamic_syminfo
== NULL
)
9532 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9533 (unsigned long) syminsz
);
9537 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9538 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9539 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9540 ++syminfo
, ++extsym
)
9542 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9543 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9550 if (do_dynamic
&& dynamic_addr
)
9551 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9552 dynamic_addr
, (unsigned long) dynamic_nent
);
9554 printf (_(" Tag Type Name/Value\n"));
9556 for (entry
= dynamic_section
;
9557 entry
< dynamic_section
+ dynamic_nent
;
9565 print_vma (entry
->d_tag
, FULL_HEX
);
9566 dtype
= get_dynamic_type (entry
->d_tag
);
9567 printf (" (%s)%*s", dtype
,
9568 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9571 switch (entry
->d_tag
)
9575 print_dynamic_flags (entry
->d_un
.d_val
);
9585 switch (entry
->d_tag
)
9588 printf (_("Auxiliary library"));
9592 printf (_("Filter library"));
9596 printf (_("Configuration file"));
9600 printf (_("Dependency audit library"));
9604 printf (_("Audit library"));
9608 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9609 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9613 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9622 printf (_("Flags:"));
9624 if (entry
->d_un
.d_val
== 0)
9625 printf (_(" None\n"));
9628 unsigned long int val
= entry
->d_un
.d_val
;
9630 if (val
& DTF_1_PARINIT
)
9632 printf (" PARINIT");
9633 val
^= DTF_1_PARINIT
;
9635 if (val
& DTF_1_CONFEXP
)
9637 printf (" CONFEXP");
9638 val
^= DTF_1_CONFEXP
;
9641 printf (" %lx", val
);
9650 printf (_("Flags:"));
9652 if (entry
->d_un
.d_val
== 0)
9653 printf (_(" None\n"));
9656 unsigned long int val
= entry
->d_un
.d_val
;
9658 if (val
& DF_P1_LAZYLOAD
)
9660 printf (" LAZYLOAD");
9661 val
^= DF_P1_LAZYLOAD
;
9663 if (val
& DF_P1_GROUPPERM
)
9665 printf (" GROUPPERM");
9666 val
^= DF_P1_GROUPPERM
;
9669 printf (" %lx", val
);
9678 printf (_("Flags:"));
9679 if (entry
->d_un
.d_val
== 0)
9680 printf (_(" None\n"));
9683 unsigned long int val
= entry
->d_un
.d_val
;
9690 if (val
& DF_1_GLOBAL
)
9695 if (val
& DF_1_GROUP
)
9700 if (val
& DF_1_NODELETE
)
9702 printf (" NODELETE");
9703 val
^= DF_1_NODELETE
;
9705 if (val
& DF_1_LOADFLTR
)
9707 printf (" LOADFLTR");
9708 val
^= DF_1_LOADFLTR
;
9710 if (val
& DF_1_INITFIRST
)
9712 printf (" INITFIRST");
9713 val
^= DF_1_INITFIRST
;
9715 if (val
& DF_1_NOOPEN
)
9720 if (val
& DF_1_ORIGIN
)
9725 if (val
& DF_1_DIRECT
)
9730 if (val
& DF_1_TRANS
)
9735 if (val
& DF_1_INTERPOSE
)
9737 printf (" INTERPOSE");
9738 val
^= DF_1_INTERPOSE
;
9740 if (val
& DF_1_NODEFLIB
)
9742 printf (" NODEFLIB");
9743 val
^= DF_1_NODEFLIB
;
9745 if (val
& DF_1_NODUMP
)
9750 if (val
& DF_1_CONFALT
)
9752 printf (" CONFALT");
9753 val
^= DF_1_CONFALT
;
9755 if (val
& DF_1_ENDFILTEE
)
9757 printf (" ENDFILTEE");
9758 val
^= DF_1_ENDFILTEE
;
9760 if (val
& DF_1_DISPRELDNE
)
9762 printf (" DISPRELDNE");
9763 val
^= DF_1_DISPRELDNE
;
9765 if (val
& DF_1_DISPRELPND
)
9767 printf (" DISPRELPND");
9768 val
^= DF_1_DISPRELPND
;
9770 if (val
& DF_1_NODIRECT
)
9772 printf (" NODIRECT");
9773 val
^= DF_1_NODIRECT
;
9775 if (val
& DF_1_IGNMULDEF
)
9777 printf (" IGNMULDEF");
9778 val
^= DF_1_IGNMULDEF
;
9780 if (val
& DF_1_NOKSYMS
)
9782 printf (" NOKSYMS");
9783 val
^= DF_1_NOKSYMS
;
9785 if (val
& DF_1_NOHDR
)
9790 if (val
& DF_1_EDITED
)
9795 if (val
& DF_1_NORELOC
)
9797 printf (" NORELOC");
9798 val
^= DF_1_NORELOC
;
9800 if (val
& DF_1_SYMINTPOSE
)
9802 printf (" SYMINTPOSE");
9803 val
^= DF_1_SYMINTPOSE
;
9805 if (val
& DF_1_GLOBAUDIT
)
9807 printf (" GLOBAUDIT");
9808 val
^= DF_1_GLOBAUDIT
;
9810 if (val
& DF_1_SINGLETON
)
9812 printf (" SINGLETON");
9813 val
^= DF_1_SINGLETON
;
9815 if (val
& DF_1_STUB
)
9826 printf (" %lx", val
);
9833 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9835 puts (get_dynamic_type (entry
->d_un
.d_val
));
9855 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9861 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9862 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9868 switch (entry
->d_tag
)
9871 printf (_("Shared library: [%s]"), name
);
9873 if (streq (name
, program_interpreter
))
9874 printf (_(" program interpreter"));
9878 printf (_("Library soname: [%s]"), name
);
9882 printf (_("Library rpath: [%s]"), name
);
9886 printf (_("Library runpath: [%s]"), name
);
9890 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9895 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9908 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9913 case DT_INIT_ARRAYSZ
:
9914 case DT_FINI_ARRAYSZ
:
9915 case DT_GNU_CONFLICTSZ
:
9916 case DT_GNU_LIBLISTSZ
:
9919 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9920 printf (_(" (bytes)\n"));
9930 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9943 if (entry
->d_tag
== DT_USED
9944 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9946 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9950 printf (_("Not needed object: [%s]\n"), name
);
9955 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9961 /* The value of this entry is ignored. */
9966 case DT_GNU_PRELINKED
:
9970 time_t atime
= entry
->d_un
.d_val
;
9972 tmp
= gmtime (&atime
);
9973 /* PR 17533 file: 041-1244816-0.004. */
9975 printf (_("<corrupt time val: %lx"),
9976 (unsigned long) atime
);
9978 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9979 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9980 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9986 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9989 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9995 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9996 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10001 switch (elf_header
.e_machine
)
10004 case EM_MIPS_RS3_LE
:
10005 dynamic_section_mips_val (entry
);
10008 dynamic_section_parisc_val (entry
);
10011 dynamic_section_ia64_val (entry
);
10014 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10026 get_ver_flags (unsigned int flags
)
10028 static char buff
[32];
10035 if (flags
& VER_FLG_BASE
)
10036 strcat (buff
, "BASE");
10038 if (flags
& VER_FLG_WEAK
)
10040 if (flags
& VER_FLG_BASE
)
10041 strcat (buff
, " | ");
10043 strcat (buff
, "WEAK");
10046 if (flags
& VER_FLG_INFO
)
10048 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10049 strcat (buff
, " | ");
10051 strcat (buff
, "INFO");
10054 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10056 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10057 strcat (buff
, " | ");
10059 strcat (buff
, _("<unknown>"));
10065 /* Display the contents of the version sections. */
10068 process_version_sections (FILE * file
)
10070 Elf_Internal_Shdr
* section
;
10072 bfd_boolean found
= FALSE
;
10077 for (i
= 0, section
= section_headers
;
10078 i
< elf_header
.e_shnum
;
10081 switch (section
->sh_type
)
10083 case SHT_GNU_verdef
:
10085 Elf_External_Verdef
* edefs
;
10093 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10094 printable_section_name (section
),
10097 printf (_(" Addr: 0x"));
10098 printf_vma (section
->sh_addr
);
10099 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10100 (unsigned long) section
->sh_offset
, section
->sh_link
,
10101 printable_section_name_from_index (section
->sh_link
));
10103 edefs
= (Elf_External_Verdef
*)
10104 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10105 _("version definition section"));
10108 endbuf
= (char *) edefs
+ section
->sh_size
;
10110 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10111 end
= (section
->sh_info
< section
->sh_size
10112 ? section
->sh_info
: section
->sh_size
);
10113 for (idx
= cnt
= 0; cnt
< end
; ++cnt
)
10116 Elf_External_Verdef
* edef
;
10117 Elf_Internal_Verdef ent
;
10118 Elf_External_Verdaux
* eaux
;
10119 Elf_Internal_Verdaux aux
;
10123 /* Check for very large indices. */
10124 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10127 vstart
= ((char *) edefs
) + idx
;
10128 if (vstart
+ sizeof (*edef
) > endbuf
)
10131 edef
= (Elf_External_Verdef
*) vstart
;
10133 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10134 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10135 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10136 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10137 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10138 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10139 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10141 printf (_(" %#06x: Rev: %d Flags: %s"),
10142 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10144 printf (_(" Index: %d Cnt: %d "),
10145 ent
.vd_ndx
, ent
.vd_cnt
);
10147 /* Check for overflow. */
10148 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
))
10151 vstart
+= ent
.vd_aux
;
10153 eaux
= (Elf_External_Verdaux
*) vstart
;
10155 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10156 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10158 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10159 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10161 printf (_("Name index: %ld\n"), aux
.vda_name
);
10163 isum
= idx
+ ent
.vd_aux
;
10165 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10167 /* Check for overflow. */
10168 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10171 isum
+= aux
.vda_next
;
10172 vstart
+= aux
.vda_next
;
10174 eaux
= (Elf_External_Verdaux
*) vstart
;
10175 if (vstart
+ sizeof (*eaux
) > endbuf
)
10178 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10179 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10181 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10182 printf (_(" %#06x: Parent %d: %s\n"),
10183 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10185 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10186 isum
, j
, aux
.vda_name
);
10189 if (j
< ent
.vd_cnt
)
10190 printf (_(" Version def aux past end of section\n"));
10193 file: id:000001,src:000172+005151,op:splice,rep:2. */
10194 if (idx
+ ent
.vd_next
< idx
)
10197 idx
+= ent
.vd_next
;
10200 if (cnt
< section
->sh_info
)
10201 printf (_(" Version definition past end of section\n"));
10207 case SHT_GNU_verneed
:
10209 Elf_External_Verneed
* eneed
;
10216 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10217 printable_section_name (section
), section
->sh_info
);
10219 printf (_(" Addr: 0x"));
10220 printf_vma (section
->sh_addr
);
10221 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10222 (unsigned long) section
->sh_offset
, section
->sh_link
,
10223 printable_section_name_from_index (section
->sh_link
));
10225 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10226 section
->sh_offset
, 1,
10228 _("Version Needs section"));
10231 endbuf
= (char *) eneed
+ section
->sh_size
;
10233 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10235 Elf_External_Verneed
* entry
;
10236 Elf_Internal_Verneed ent
;
10241 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10244 vstart
= ((char *) eneed
) + idx
;
10245 if (vstart
+ sizeof (*entry
) > endbuf
)
10248 entry
= (Elf_External_Verneed
*) vstart
;
10250 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10251 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10252 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10253 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10254 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10256 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10258 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10259 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10261 printf (_(" File: %lx"), ent
.vn_file
);
10263 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10265 /* Check for overflow. */
10266 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10268 vstart
+= ent
.vn_aux
;
10270 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10272 Elf_External_Vernaux
* eaux
;
10273 Elf_Internal_Vernaux aux
;
10275 if (vstart
+ sizeof (*eaux
) > endbuf
)
10277 eaux
= (Elf_External_Vernaux
*) vstart
;
10279 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10280 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10281 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10282 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10283 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10285 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10286 printf (_(" %#06x: Name: %s"),
10287 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10289 printf (_(" %#06x: Name index: %lx"),
10290 isum
, aux
.vna_name
);
10292 printf (_(" Flags: %s Version: %d\n"),
10293 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10295 /* Check for overflow. */
10296 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10297 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10299 warn (_("Invalid vna_next field of %lx\n"),
10304 isum
+= aux
.vna_next
;
10305 vstart
+= aux
.vna_next
;
10308 if (j
< ent
.vn_cnt
)
10309 warn (_("Missing Version Needs auxillary information\n"));
10311 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10313 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10314 cnt
= section
->sh_info
;
10317 idx
+= ent
.vn_next
;
10320 if (cnt
< section
->sh_info
)
10321 warn (_("Missing Version Needs information\n"));
10327 case SHT_GNU_versym
:
10329 Elf_Internal_Shdr
* link_section
;
10332 unsigned char * edata
;
10333 unsigned short * data
;
10335 Elf_Internal_Sym
* symbols
;
10336 Elf_Internal_Shdr
* string_sec
;
10337 unsigned long num_syms
;
10340 if (section
->sh_link
>= elf_header
.e_shnum
)
10343 link_section
= section_headers
+ section
->sh_link
;
10344 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10346 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10351 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10352 if (symbols
== NULL
)
10355 string_sec
= section_headers
+ link_section
->sh_link
;
10357 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10358 string_sec
->sh_size
,
10359 _("version string table"));
10366 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10367 printable_section_name (section
), (unsigned long) total
);
10369 printf (_(" Addr: "));
10370 printf_vma (section
->sh_addr
);
10371 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10372 (unsigned long) section
->sh_offset
, section
->sh_link
,
10373 printable_section_name (link_section
));
10375 off
= offset_from_vma (file
,
10376 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10377 total
* sizeof (short));
10378 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10380 _("version symbol data"));
10388 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10390 for (cnt
= total
; cnt
--;)
10391 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10396 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10400 char *invalid
= _("*invalid*");
10402 printf (" %03x:", cnt
);
10404 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10405 switch (data
[cnt
+ j
])
10408 fputs (_(" 0 (*local*) "), stdout
);
10412 fputs (_(" 1 (*global*) "), stdout
);
10416 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10417 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10419 /* If this index value is greater than the size of the symbols
10420 array, break to avoid an out-of-bounds read. */
10421 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10423 warn (_("invalid index into symbol array\n"));
10428 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10430 Elf_Internal_Verneed ivn
;
10431 unsigned long offset
;
10433 offset
= offset_from_vma
10434 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10435 sizeof (Elf_External_Verneed
));
10439 Elf_Internal_Vernaux ivna
;
10440 Elf_External_Verneed evn
;
10441 Elf_External_Vernaux evna
;
10442 unsigned long a_off
;
10444 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10445 _("version need")) == NULL
)
10448 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10449 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10451 a_off
= offset
+ ivn
.vn_aux
;
10455 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10456 1, _("version need aux (2)")) == NULL
)
10459 ivna
.vna_other
= 0;
10463 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10464 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10467 a_off
+= ivna
.vna_next
;
10469 while (ivna
.vna_other
!= data
[cnt
+ j
]
10470 && ivna
.vna_next
!= 0);
10472 if (ivna
.vna_other
== data
[cnt
+ j
])
10474 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10476 if (ivna
.vna_name
>= string_sec
->sh_size
)
10479 name
= strtab
+ ivna
.vna_name
;
10483 offset
+= ivn
.vn_next
;
10485 while (ivn
.vn_next
);
10488 if (data
[cnt
+ j
] != 0x8001
10489 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10491 Elf_Internal_Verdef ivd
;
10492 Elf_External_Verdef evd
;
10493 unsigned long offset
;
10495 offset
= offset_from_vma
10496 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10501 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10502 _("version def")) == NULL
)
10505 /* PR 17531: file: 046-1082287-0.004. */
10506 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10511 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10512 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10515 offset
+= ivd
.vd_next
;
10517 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10518 && ivd
.vd_next
!= 0);
10520 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10522 Elf_External_Verdaux evda
;
10523 Elf_Internal_Verdaux ivda
;
10525 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10527 if (get_data (&evda
, file
,
10528 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10530 _("version def aux")) == NULL
)
10533 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10535 if (ivda
.vda_name
>= string_sec
->sh_size
)
10537 else if (name
!= NULL
&& name
!= invalid
)
10538 name
= _("*both*");
10540 name
= strtab
+ ivda
.vda_name
;
10544 nn
+= printf ("(%s%-*s",
10546 12 - (int) strlen (name
),
10550 printf ("%*c", 18 - nn
, ' ');
10568 printf (_("\nNo version information found in this file.\n"));
10573 static const char *
10574 get_symbol_binding (unsigned int binding
)
10576 static char buff
[32];
10580 case STB_LOCAL
: return "LOCAL";
10581 case STB_GLOBAL
: return "GLOBAL";
10582 case STB_WEAK
: return "WEAK";
10584 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10585 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10587 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10589 if (binding
== STB_GNU_UNIQUE
10590 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10591 /* GNU is still using the default value 0. */
10592 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10594 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10597 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10602 static const char *
10603 get_symbol_type (unsigned int type
)
10605 static char buff
[32];
10609 case STT_NOTYPE
: return "NOTYPE";
10610 case STT_OBJECT
: return "OBJECT";
10611 case STT_FUNC
: return "FUNC";
10612 case STT_SECTION
: return "SECTION";
10613 case STT_FILE
: return "FILE";
10614 case STT_COMMON
: return "COMMON";
10615 case STT_TLS
: return "TLS";
10616 case STT_RELC
: return "RELC";
10617 case STT_SRELC
: return "SRELC";
10619 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10621 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10622 return "THUMB_FUNC";
10624 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10627 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10628 return "PARISC_MILLI";
10630 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10632 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10634 if (elf_header
.e_machine
== EM_PARISC
)
10636 if (type
== STT_HP_OPAQUE
)
10637 return "HP_OPAQUE";
10638 if (type
== STT_HP_STUB
)
10642 if (type
== STT_GNU_IFUNC
10643 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10644 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10645 /* GNU is still using the default value 0. */
10646 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10649 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10652 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10657 static const char *
10658 get_symbol_visibility (unsigned int visibility
)
10660 switch (visibility
)
10662 case STV_DEFAULT
: return "DEFAULT";
10663 case STV_INTERNAL
: return "INTERNAL";
10664 case STV_HIDDEN
: return "HIDDEN";
10665 case STV_PROTECTED
: return "PROTECTED";
10667 error (_("Unrecognized visibility value: %u"), visibility
);
10668 return _("<unknown>");
10672 static const char *
10673 get_solaris_symbol_visibility (unsigned int visibility
)
10675 switch (visibility
)
10677 case 4: return "EXPORTED";
10678 case 5: return "SINGLETON";
10679 case 6: return "ELIMINATE";
10680 default: return get_symbol_visibility (visibility
);
10684 static const char *
10685 get_mips_symbol_other (unsigned int other
)
10689 case STO_OPTIONAL
: return "OPTIONAL";
10690 case STO_MIPS_PLT
: return "MIPS PLT";
10691 case STO_MIPS_PIC
: return "MIPS PIC";
10692 case STO_MICROMIPS
: return "MICROMIPS";
10693 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10694 case STO_MIPS16
: return "MIPS16";
10695 default: return NULL
;
10699 static const char *
10700 get_ia64_symbol_other (unsigned int other
)
10702 if (is_ia64_vms ())
10704 static char res
[32];
10708 /* Function types is for images and .STB files only. */
10709 switch (elf_header
.e_type
)
10713 switch (VMS_ST_FUNC_TYPE (other
))
10715 case VMS_SFT_CODE_ADDR
:
10716 strcat (res
, " CA");
10718 case VMS_SFT_SYMV_IDX
:
10719 strcat (res
, " VEC");
10722 strcat (res
, " FD");
10724 case VMS_SFT_RESERVE
:
10725 strcat (res
, " RSV");
10728 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10729 VMS_ST_FUNC_TYPE (other
));
10730 strcat (res
, " <unknown>");
10737 switch (VMS_ST_LINKAGE (other
))
10739 case VMS_STL_IGNORE
:
10740 strcat (res
, " IGN");
10742 case VMS_STL_RESERVE
:
10743 strcat (res
, " RSV");
10746 strcat (res
, " STD");
10749 strcat (res
, " LNK");
10752 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10753 VMS_ST_LINKAGE (other
));
10754 strcat (res
, " <unknown>");
10766 static const char *
10767 get_ppc64_symbol_other (unsigned int other
)
10769 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10771 static char buf
[32];
10772 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10773 PPC64_LOCAL_ENTRY_OFFSET (other
));
10779 static const char *
10780 get_symbol_other (unsigned int other
)
10782 const char * result
= NULL
;
10783 static char buff
[32];
10788 switch (elf_header
.e_machine
)
10791 result
= get_mips_symbol_other (other
);
10794 result
= get_ia64_symbol_other (other
);
10797 result
= get_ppc64_symbol_other (other
);
10807 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10811 static const char *
10812 get_symbol_index_type (unsigned int type
)
10814 static char buff
[32];
10818 case SHN_UNDEF
: return "UND";
10819 case SHN_ABS
: return "ABS";
10820 case SHN_COMMON
: return "COM";
10822 if (type
== SHN_IA_64_ANSI_COMMON
10823 && elf_header
.e_machine
== EM_IA_64
10824 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10826 else if ((elf_header
.e_machine
== EM_X86_64
10827 || elf_header
.e_machine
== EM_L1OM
10828 || elf_header
.e_machine
== EM_K1OM
)
10829 && type
== SHN_X86_64_LCOMMON
)
10830 return "LARGE_COM";
10831 else if ((type
== SHN_MIPS_SCOMMON
10832 && elf_header
.e_machine
== EM_MIPS
)
10833 || (type
== SHN_TIC6X_SCOMMON
10834 && elf_header
.e_machine
== EM_TI_C6000
))
10836 else if (type
== SHN_MIPS_SUNDEFINED
10837 && elf_header
.e_machine
== EM_MIPS
)
10839 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10840 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10841 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10842 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10843 else if (type
>= SHN_LORESERVE
)
10844 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10845 else if (type
>= elf_header
.e_shnum
)
10846 sprintf (buff
, _("bad section index[%3d]"), type
);
10848 sprintf (buff
, "%3d", type
);
10856 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10858 unsigned char * e_data
;
10861 /* If the size_t type is smaller than the bfd_size_type, eg because
10862 you are building a 32-bit tool on a 64-bit host, then make sure
10863 that when (number) is cast to (size_t) no information is lost. */
10864 if (sizeof (size_t) < sizeof (bfd_size_type
)
10865 && (bfd_size_type
) ((size_t) number
) != number
)
10867 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10868 " elements of size %u\n"),
10873 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10874 attempting to allocate memory when the read is bound to fail. */
10875 if (ent_size
* number
> current_file_size
)
10877 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10882 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10883 if (e_data
== NULL
)
10885 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10890 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10892 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10893 number
* ent_size
);
10898 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10899 if (i_data
== NULL
)
10901 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10902 " dynamic entries\n"),
10909 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10917 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10919 Elf_Internal_Sym
* psym
;
10922 n
= print_vma (si
, DEC_5
);
10924 fputs (&" "[n
], stdout
);
10925 printf (" %3lu: ", hn
);
10927 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10929 printf (_("<No info available for dynamic symbol number %lu>\n"),
10930 (unsigned long) si
);
10934 psym
= dynamic_symbols
+ si
;
10935 print_vma (psym
->st_value
, LONG_HEX
);
10937 print_vma (psym
->st_size
, DEC_5
);
10939 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10940 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10942 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10943 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10946 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10948 printf (" %-7s", get_symbol_visibility (vis
));
10949 /* Check to see if any other bits in the st_other field are set.
10950 Note - displaying this information disrupts the layout of the
10951 table being generated, but for the moment this case is very
10953 if (psym
->st_other
^ vis
)
10954 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10957 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10958 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10959 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10961 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10965 static const char *
10966 get_symbol_version_string (FILE * file
,
10967 bfd_boolean is_dynsym
,
10968 const char * strtab
,
10969 unsigned long int strtab_size
,
10971 Elf_Internal_Sym
* psym
,
10972 enum versioned_symbol_info
* sym_info
,
10973 unsigned short * vna_other
)
10975 unsigned char data
[2];
10976 unsigned short vers_data
;
10977 unsigned long offset
;
10980 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10983 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10984 sizeof data
+ si
* sizeof (vers_data
));
10986 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10987 sizeof (data
), 1, _("version data")) == NULL
)
10990 vers_data
= byte_get (data
, 2);
10992 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10995 /* Usually we'd only see verdef for defined symbols, and verneed for
10996 undefined symbols. However, symbols defined by the linker in
10997 .dynbss for variables copied from a shared library in order to
10998 avoid text relocations are defined yet have verneed. We could
10999 use a heuristic to detect the special case, for example, check
11000 for verneed first on symbols defined in SHT_NOBITS sections, but
11001 it is simpler and more reliable to just look for both verdef and
11002 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11004 if (psym
->st_shndx
!= SHN_UNDEF
11005 && vers_data
!= 0x8001
11006 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11008 Elf_Internal_Verdef ivd
;
11009 Elf_Internal_Verdaux ivda
;
11010 Elf_External_Verdaux evda
;
11013 off
= offset_from_vma (file
,
11014 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11015 sizeof (Elf_External_Verdef
));
11019 Elf_External_Verdef evd
;
11021 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11022 _("version def")) == NULL
)
11030 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11031 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11032 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11035 off
+= ivd
.vd_next
;
11037 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11039 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11041 off
-= ivd
.vd_next
;
11044 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11045 _("version def aux")) != NULL
)
11047 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11049 if (psym
->st_name
!= ivda
.vda_name
)
11051 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11052 ? symbol_hidden
: symbol_public
);
11053 return (ivda
.vda_name
< strtab_size
11054 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11060 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11062 Elf_External_Verneed evn
;
11063 Elf_Internal_Verneed ivn
;
11064 Elf_Internal_Vernaux ivna
;
11066 offset
= offset_from_vma (file
,
11067 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11071 unsigned long vna_off
;
11073 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11074 _("version need")) == NULL
)
11077 ivna
.vna_other
= 0;
11082 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11083 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11085 vna_off
= offset
+ ivn
.vn_aux
;
11089 Elf_External_Vernaux evna
;
11091 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11092 _("version need aux (3)")) == NULL
)
11095 ivna
.vna_other
= 0;
11100 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11101 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11102 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11105 vna_off
+= ivna
.vna_next
;
11107 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11109 if (ivna
.vna_other
== vers_data
)
11112 offset
+= ivn
.vn_next
;
11114 while (ivn
.vn_next
!= 0);
11116 if (ivna
.vna_other
== vers_data
)
11118 *sym_info
= symbol_undefined
;
11119 *vna_other
= ivna
.vna_other
;
11120 return (ivna
.vna_name
< strtab_size
11121 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11127 /* Dump the symbol table. */
11129 process_symbol_table (FILE * file
)
11131 Elf_Internal_Shdr
* section
;
11132 bfd_size_type nbuckets
= 0;
11133 bfd_size_type nchains
= 0;
11134 bfd_vma
* buckets
= NULL
;
11135 bfd_vma
* chains
= NULL
;
11136 bfd_vma ngnubuckets
= 0;
11137 bfd_vma
* gnubuckets
= NULL
;
11138 bfd_vma
* gnuchains
= NULL
;
11139 bfd_vma gnusymidx
= 0;
11140 bfd_size_type ngnuchains
= 0;
11142 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11145 if (dynamic_info
[DT_HASH
]
11147 || (do_using_dynamic
11149 && dynamic_strings
!= NULL
)))
11151 unsigned char nb
[8];
11152 unsigned char nc
[8];
11153 unsigned int hash_ent_size
= 4;
11155 if ((elf_header
.e_machine
== EM_ALPHA
11156 || elf_header
.e_machine
== EM_S390
11157 || elf_header
.e_machine
== EM_S390_OLD
)
11158 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11162 (archive_file_offset
11163 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11164 sizeof nb
+ sizeof nc
)),
11167 error (_("Unable to seek to start of dynamic information\n"));
11171 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11173 error (_("Failed to read in number of buckets\n"));
11177 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11179 error (_("Failed to read in number of chains\n"));
11183 nbuckets
= byte_get (nb
, hash_ent_size
);
11184 nchains
= byte_get (nc
, hash_ent_size
);
11186 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11187 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11190 if (buckets
== NULL
|| chains
== NULL
)
11192 if (do_using_dynamic
)
11203 if (dynamic_info_DT_GNU_HASH
11205 || (do_using_dynamic
11207 && dynamic_strings
!= NULL
)))
11209 unsigned char nb
[16];
11210 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11211 bfd_vma buckets_vma
;
11214 (archive_file_offset
11215 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11219 error (_("Unable to seek to start of dynamic information\n"));
11223 if (fread (nb
, 16, 1, file
) != 1)
11225 error (_("Failed to read in number of buckets\n"));
11229 ngnubuckets
= byte_get (nb
, 4);
11230 gnusymidx
= byte_get (nb
+ 4, 4);
11231 bitmaskwords
= byte_get (nb
+ 8, 4);
11232 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11234 buckets_vma
+= bitmaskwords
* 4;
11236 buckets_vma
+= bitmaskwords
* 8;
11239 (archive_file_offset
11240 + offset_from_vma (file
, buckets_vma
, 4)),
11243 error (_("Unable to seek to start of dynamic information\n"));
11247 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11249 if (gnubuckets
== NULL
)
11252 for (i
= 0; i
< ngnubuckets
; i
++)
11253 if (gnubuckets
[i
] != 0)
11255 if (gnubuckets
[i
] < gnusymidx
)
11258 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11259 maxchain
= gnubuckets
[i
];
11262 if (maxchain
== 0xffffffff)
11265 maxchain
-= gnusymidx
;
11268 (archive_file_offset
11269 + offset_from_vma (file
, buckets_vma
11270 + 4 * (ngnubuckets
+ maxchain
), 4)),
11273 error (_("Unable to seek to start of dynamic information\n"));
11279 if (fread (nb
, 4, 1, file
) != 1)
11281 error (_("Failed to determine last chain length\n"));
11285 if (maxchain
+ 1 == 0)
11290 while ((byte_get (nb
, 4) & 1) == 0);
11293 (archive_file_offset
11294 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11297 error (_("Unable to seek to start of dynamic information\n"));
11301 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11302 ngnuchains
= maxchain
;
11305 if (gnuchains
== NULL
)
11310 if (do_using_dynamic
)
11315 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11317 && do_using_dynamic
11318 && dynamic_strings
!= NULL
11319 && dynamic_symbols
!= NULL
)
11323 if (dynamic_info
[DT_HASH
])
11327 printf (_("\nSymbol table for image:\n"));
11329 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11331 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11333 for (hn
= 0; hn
< nbuckets
; hn
++)
11338 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11339 print_dynamic_symbol (si
, hn
);
11343 if (dynamic_info_DT_GNU_HASH
)
11345 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11347 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11349 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11351 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11352 if (gnubuckets
[hn
] != 0)
11354 bfd_vma si
= gnubuckets
[hn
];
11355 bfd_vma off
= si
- gnusymidx
;
11359 print_dynamic_symbol (si
, hn
);
11362 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11366 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11367 && section_headers
!= NULL
)
11371 for (i
= 0, section
= section_headers
;
11372 i
< elf_header
.e_shnum
;
11376 char * strtab
= NULL
;
11377 unsigned long int strtab_size
= 0;
11378 Elf_Internal_Sym
* symtab
;
11379 Elf_Internal_Sym
* psym
;
11380 unsigned long num_syms
;
11382 if ((section
->sh_type
!= SHT_SYMTAB
11383 && section
->sh_type
!= SHT_DYNSYM
)
11385 && section
->sh_type
== SHT_SYMTAB
))
11388 if (section
->sh_entsize
== 0)
11390 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11391 printable_section_name (section
));
11395 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11396 printable_section_name (section
),
11397 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11400 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11402 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11404 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11405 if (symtab
== NULL
)
11408 if (section
->sh_link
== elf_header
.e_shstrndx
)
11410 strtab
= string_table
;
11411 strtab_size
= string_table_length
;
11413 else if (section
->sh_link
< elf_header
.e_shnum
)
11415 Elf_Internal_Shdr
* string_sec
;
11417 string_sec
= section_headers
+ section
->sh_link
;
11419 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11420 1, string_sec
->sh_size
,
11421 _("string table"));
11422 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11425 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11427 const char *version_string
;
11428 enum versioned_symbol_info sym_info
;
11429 unsigned short vna_other
;
11431 printf ("%6d: ", si
);
11432 print_vma (psym
->st_value
, LONG_HEX
);
11434 print_vma (psym
->st_size
, DEC_5
);
11435 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11436 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11437 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11438 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11441 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11443 printf (" %-7s", get_symbol_visibility (vis
));
11444 /* Check to see if any other bits in the st_other field are set.
11445 Note - displaying this information disrupts the layout of the
11446 table being generated, but for the moment this case is very rare. */
11447 if (psym
->st_other
^ vis
)
11448 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11450 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11451 print_symbol (25, psym
->st_name
< strtab_size
11452 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11455 = get_symbol_version_string (file
,
11456 section
->sh_type
== SHT_DYNSYM
,
11457 strtab
, strtab_size
, si
,
11458 psym
, &sym_info
, &vna_other
);
11459 if (version_string
)
11461 if (sym_info
== symbol_undefined
)
11462 printf ("@%s (%d)", version_string
, vna_other
);
11464 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11470 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11471 && si
>= section
->sh_info
11472 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11473 && elf_header
.e_machine
!= EM_MIPS
11474 /* Solaris binaries have been found to violate this requirement as
11475 well. Not sure if this is a bug or an ABI requirement. */
11476 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11477 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11478 si
, printable_section_name (section
), section
->sh_info
);
11482 if (strtab
!= string_table
)
11488 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11490 if (do_histogram
&& buckets
!= NULL
)
11492 unsigned long * lengths
;
11493 unsigned long * counts
;
11496 unsigned long maxlength
= 0;
11497 unsigned long nzero_counts
= 0;
11498 unsigned long nsyms
= 0;
11499 unsigned long chained
;
11501 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11502 (unsigned long) nbuckets
);
11504 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11505 if (lengths
== NULL
)
11507 error (_("Out of memory allocating space for histogram buckets\n"));
11511 printf (_(" Length Number %% of total Coverage\n"));
11512 for (hn
= 0; hn
< nbuckets
; ++hn
)
11514 for (si
= buckets
[hn
], chained
= 0;
11515 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11516 si
= chains
[si
], ++chained
)
11519 if (maxlength
< ++lengths
[hn
])
11523 /* PR binutils/17531: A corrupt binary could contain broken
11524 histogram data. Do not go into an infinite loop trying
11526 if (chained
> nchains
)
11528 error (_("histogram chain is corrupt\n"));
11533 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11534 if (counts
== NULL
)
11537 error (_("Out of memory allocating space for histogram counts\n"));
11541 for (hn
= 0; hn
< nbuckets
; ++hn
)
11542 ++counts
[lengths
[hn
]];
11547 printf (" 0 %-10lu (%5.1f%%)\n",
11548 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11549 for (i
= 1; i
<= maxlength
; ++i
)
11551 nzero_counts
+= counts
[i
] * i
;
11552 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11553 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11554 (nzero_counts
* 100.0) / nsyms
);
11562 if (buckets
!= NULL
)
11568 if (do_histogram
&& gnubuckets
!= NULL
)
11570 unsigned long * lengths
;
11571 unsigned long * counts
;
11573 unsigned long maxlength
= 0;
11574 unsigned long nzero_counts
= 0;
11575 unsigned long nsyms
= 0;
11577 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11578 (unsigned long) ngnubuckets
);
11580 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11581 if (lengths
== NULL
)
11583 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11587 printf (_(" Length Number %% of total Coverage\n"));
11589 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11590 if (gnubuckets
[hn
] != 0)
11592 bfd_vma off
, length
= 1;
11594 for (off
= gnubuckets
[hn
] - gnusymidx
;
11595 /* PR 17531 file: 010-77222-0.004. */
11596 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11599 lengths
[hn
] = length
;
11600 if (length
> maxlength
)
11601 maxlength
= length
;
11605 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11606 if (counts
== NULL
)
11609 error (_("Out of memory allocating space for gnu histogram counts\n"));
11613 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11614 ++counts
[lengths
[hn
]];
11616 if (ngnubuckets
> 0)
11619 printf (" 0 %-10lu (%5.1f%%)\n",
11620 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11621 for (j
= 1; j
<= maxlength
; ++j
)
11623 nzero_counts
+= counts
[j
] * j
;
11624 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11625 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11626 (nzero_counts
* 100.0) / nsyms
);
11640 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11644 if (dynamic_syminfo
== NULL
11646 /* No syminfo, this is ok. */
11649 /* There better should be a dynamic symbol section. */
11650 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11654 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11655 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11657 printf (_(" Num: Name BoundTo Flags\n"));
11658 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11660 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11662 printf ("%4d: ", i
);
11663 if (i
>= num_dynamic_syms
)
11664 printf (_("<corrupt index>"));
11665 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11666 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11668 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11671 switch (dynamic_syminfo
[i
].si_boundto
)
11673 case SYMINFO_BT_SELF
:
11674 fputs ("SELF ", stdout
);
11676 case SYMINFO_BT_PARENT
:
11677 fputs ("PARENT ", stdout
);
11680 if (dynamic_syminfo
[i
].si_boundto
> 0
11681 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11682 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11684 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11688 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11692 if (flags
& SYMINFO_FLG_DIRECT
)
11693 printf (" DIRECT");
11694 if (flags
& SYMINFO_FLG_PASSTHRU
)
11695 printf (" PASSTHRU");
11696 if (flags
& SYMINFO_FLG_COPY
)
11698 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11699 printf (" LAZYLOAD");
11707 #define IN_RANGE(START,END,ADDR,OFF) \
11708 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11710 /* Check to see if the given reloc needs to be handled in a target specific
11711 manner. If so then process the reloc and return TRUE otherwise return
11714 If called with reloc == NULL, then this is a signal that reloc processing
11715 for the current section has finished, and any saved state should be
11719 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11720 unsigned char * start
,
11721 unsigned char * end
,
11722 Elf_Internal_Sym
* symtab
,
11723 unsigned long num_syms
)
11725 unsigned int reloc_type
= 0;
11726 unsigned long sym_index
= 0;
11730 reloc_type
= get_reloc_type (reloc
->r_info
);
11731 sym_index
= get_reloc_symindex (reloc
->r_info
);
11734 switch (elf_header
.e_machine
)
11737 case EM_MSP430_OLD
:
11739 static Elf_Internal_Sym
* saved_sym
= NULL
;
11747 switch (reloc_type
)
11749 case 10: /* R_MSP430_SYM_DIFF */
11750 if (uses_msp430x_relocs ())
11752 /* Fall through. */
11753 case 21: /* R_MSP430X_SYM_DIFF */
11755 if (sym_index
>= num_syms
)
11756 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11759 saved_sym
= symtab
+ sym_index
;
11762 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11763 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11764 goto handle_sym_diff
;
11766 case 5: /* R_MSP430_16_BYTE */
11767 case 9: /* R_MSP430_8 */
11768 if (uses_msp430x_relocs ())
11770 goto handle_sym_diff
;
11772 case 2: /* R_MSP430_ABS16 */
11773 case 15: /* R_MSP430X_ABS16 */
11774 if (! uses_msp430x_relocs ())
11776 goto handle_sym_diff
;
11779 if (saved_sym
!= NULL
)
11781 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11784 if (sym_index
>= num_syms
)
11785 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11789 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11790 - saved_sym
->st_value
);
11792 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11793 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11796 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11797 (long) reloc
->r_offset
);
11806 if (saved_sym
!= NULL
)
11807 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11814 case EM_CYGNUS_MN10300
:
11816 static Elf_Internal_Sym
* saved_sym
= NULL
;
11824 switch (reloc_type
)
11826 case 34: /* R_MN10300_ALIGN */
11828 case 33: /* R_MN10300_SYM_DIFF */
11829 if (sym_index
>= num_syms
)
11830 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11833 saved_sym
= symtab
+ sym_index
;
11836 case 1: /* R_MN10300_32 */
11837 case 2: /* R_MN10300_16 */
11838 if (saved_sym
!= NULL
)
11840 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11843 if (sym_index
>= num_syms
)
11844 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11848 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11849 - saved_sym
->st_value
);
11851 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11852 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11854 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11855 (long) reloc
->r_offset
);
11863 if (saved_sym
!= NULL
)
11864 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11872 static bfd_vma saved_sym1
= 0;
11873 static bfd_vma saved_sym2
= 0;
11874 static bfd_vma value
;
11878 saved_sym1
= saved_sym2
= 0;
11882 switch (reloc_type
)
11884 case 0x80: /* R_RL78_SYM. */
11885 saved_sym1
= saved_sym2
;
11886 if (sym_index
>= num_syms
)
11887 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11891 saved_sym2
= symtab
[sym_index
].st_value
;
11892 saved_sym2
+= reloc
->r_addend
;
11896 case 0x83: /* R_RL78_OPsub. */
11897 value
= saved_sym1
- saved_sym2
;
11898 saved_sym2
= saved_sym1
= 0;
11902 case 0x41: /* R_RL78_ABS32. */
11903 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11904 byte_put (start
+ reloc
->r_offset
, value
, 4);
11906 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11907 (long) reloc
->r_offset
);
11911 case 0x43: /* R_RL78_ABS16. */
11912 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11913 byte_put (start
+ reloc
->r_offset
, value
, 2);
11915 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11916 (long) reloc
->r_offset
);
11930 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11931 DWARF debug sections. This is a target specific test. Note - we do not
11932 go through the whole including-target-headers-multiple-times route, (as
11933 we have already done with <elf/h8.h>) because this would become very
11934 messy and even then this function would have to contain target specific
11935 information (the names of the relocs instead of their numeric values).
11936 FIXME: This is not the correct way to solve this problem. The proper way
11937 is to have target specific reloc sizing and typing functions created by
11938 the reloc-macros.h header, in the same way that it already creates the
11939 reloc naming functions. */
11942 is_32bit_abs_reloc (unsigned int reloc_type
)
11944 /* Please keep this table alpha-sorted for ease of visual lookup. */
11945 switch (elf_header
.e_machine
)
11949 return reloc_type
== 1; /* R_386_32. */
11951 return reloc_type
== 1; /* R_68K_32. */
11953 return reloc_type
== 1; /* R_860_32. */
11955 return reloc_type
== 2; /* R_960_32. */
11957 return (reloc_type
== 258
11958 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11959 case EM_ADAPTEVA_EPIPHANY
:
11960 return reloc_type
== 3;
11962 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11964 return reloc_type
== 1; /* R_ARC_32. */
11965 case EM_ARC_COMPACT
:
11966 case EM_ARC_COMPACT2
:
11967 return reloc_type
== 4; /* R_ARC_32. */
11969 return reloc_type
== 2; /* R_ARM_ABS32 */
11972 return reloc_type
== 1;
11974 return reloc_type
== 0x12; /* R_byte4_data. */
11976 return reloc_type
== 3; /* R_CRIS_32. */
11978 return reloc_type
== 3; /* R_CR16_NUM32. */
11980 return reloc_type
== 15; /* R_CRX_NUM32. */
11981 case EM_CYGNUS_FRV
:
11982 return reloc_type
== 1;
11983 case EM_CYGNUS_D10V
:
11985 return reloc_type
== 6; /* R_D10V_32. */
11986 case EM_CYGNUS_D30V
:
11988 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11990 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11991 case EM_CYGNUS_FR30
:
11993 return reloc_type
== 3; /* R_FR30_32. */
11995 return reloc_type
== 1; /* R_FT32_32. */
11999 return reloc_type
== 1; /* R_H8_DIR32. */
12001 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12002 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
12005 return reloc_type
== 2; /* R_IP2K_32. */
12007 return reloc_type
== 2; /* R_IQ2000_32. */
12008 case EM_LATTICEMICO32
:
12009 return reloc_type
== 3; /* R_LM32_32. */
12012 return reloc_type
== 3; /* R_M32C_32. */
12014 return reloc_type
== 34; /* R_M32R_32_RELA. */
12017 return reloc_type
== 6; /* R_M68HC11_32. */
12019 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12020 case EM_CYGNUS_MEP
:
12021 return reloc_type
== 4; /* R_MEP_32. */
12023 return reloc_type
== 2; /* R_METAG_ADDR32. */
12024 case EM_MICROBLAZE
:
12025 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12027 return reloc_type
== 2; /* R_MIPS_32. */
12029 return reloc_type
== 4; /* R_MMIX_32. */
12030 case EM_CYGNUS_MN10200
:
12032 return reloc_type
== 1; /* R_MN10200_32. */
12033 case EM_CYGNUS_MN10300
:
12035 return reloc_type
== 1; /* R_MN10300_32. */
12037 return reloc_type
== 1; /* R_MOXIE_32. */
12038 case EM_MSP430_OLD
:
12040 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12042 return reloc_type
== 2; /* R_MT_32. */
12044 return reloc_type
== 20; /* R_NDS32_RELA. */
12045 case EM_ALTERA_NIOS2
:
12046 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12048 return reloc_type
== 1; /* R_NIOS_32. */
12050 return reloc_type
== 1; /* R_OR1K_32. */
12052 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12053 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12056 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12058 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12060 return reloc_type
== 1; /* R_PPC_ADDR32. */
12062 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12064 return reloc_type
== 1; /* R_RISCV_32. */
12066 return reloc_type
== 1; /* R_RL78_DIR32. */
12068 return reloc_type
== 1; /* R_RX_DIR32. */
12070 return reloc_type
== 1; /* R_I370_ADDR31. */
12073 return reloc_type
== 4; /* R_S390_32. */
12075 return reloc_type
== 8; /* R_SCORE_ABS32. */
12077 return reloc_type
== 1; /* R_SH_DIR32. */
12078 case EM_SPARC32PLUS
:
12081 return reloc_type
== 3 /* R_SPARC_32. */
12082 || reloc_type
== 23; /* R_SPARC_UA32. */
12084 return reloc_type
== 6; /* R_SPU_ADDR32 */
12086 return reloc_type
== 1; /* R_C6000_ABS32. */
12088 return reloc_type
== 2; /* R_TILEGX_32. */
12090 return reloc_type
== 1; /* R_TILEPRO_32. */
12091 case EM_CYGNUS_V850
:
12093 return reloc_type
== 6; /* R_V850_ABS32. */
12095 return reloc_type
== 0x33; /* R_V810_WORD. */
12097 return reloc_type
== 1; /* R_VAX_32. */
12099 return reloc_type
== 3; /* R_VISIUM_32. */
12100 case EM_WEBASSEMBLY
:
12101 return reloc_type
== 1; /* R_WASM32_32. */
12105 return reloc_type
== 10; /* R_X86_64_32. */
12108 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12110 return reloc_type
== 4; /* R_XGATE_32. */
12112 return reloc_type
== 1; /* R_XSTROMY16_32. */
12113 case EM_XTENSA_OLD
:
12115 return reloc_type
== 1; /* R_XTENSA_32. */
12118 static unsigned int prev_warn
= 0;
12120 /* Avoid repeating the same warning multiple times. */
12121 if (prev_warn
!= elf_header
.e_machine
)
12122 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12123 elf_header
.e_machine
);
12124 prev_warn
= elf_header
.e_machine
;
12130 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12131 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12134 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12136 switch (elf_header
.e_machine
)
12137 /* Please keep this table alpha-sorted for ease of visual lookup. */
12141 return reloc_type
== 2; /* R_386_PC32. */
12143 return reloc_type
== 4; /* R_68K_PC32. */
12145 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12146 case EM_ADAPTEVA_EPIPHANY
:
12147 return reloc_type
== 6;
12149 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12150 case EM_ARC_COMPACT
:
12151 case EM_ARC_COMPACT2
:
12152 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12154 return reloc_type
== 3; /* R_ARM_REL32 */
12157 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12158 case EM_MICROBLAZE
:
12159 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12161 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12163 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12165 return reloc_type
== 26; /* R_PPC_REL32. */
12167 return reloc_type
== 26; /* R_PPC64_REL32. */
12170 return reloc_type
== 5; /* R_390_PC32. */
12172 return reloc_type
== 2; /* R_SH_REL32. */
12173 case EM_SPARC32PLUS
:
12176 return reloc_type
== 6; /* R_SPARC_DISP32. */
12178 return reloc_type
== 13; /* R_SPU_REL32. */
12180 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12182 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12184 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12188 return reloc_type
== 2; /* R_X86_64_PC32. */
12189 case EM_XTENSA_OLD
:
12191 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12193 /* Do not abort or issue an error message here. Not all targets use
12194 pc-relative 32-bit relocs in their DWARF debug information and we
12195 have already tested for target coverage in is_32bit_abs_reloc. A
12196 more helpful warning message will be generated by apply_relocations
12197 anyway, so just return. */
12202 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12203 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12206 is_64bit_abs_reloc (unsigned int reloc_type
)
12208 switch (elf_header
.e_machine
)
12211 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12213 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12215 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12217 return reloc_type
== 80; /* R_PARISC_DIR64. */
12219 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12221 return reloc_type
== 2; /* R_RISCV_64. */
12222 case EM_SPARC32PLUS
:
12225 return reloc_type
== 54; /* R_SPARC_UA64. */
12229 return reloc_type
== 1; /* R_X86_64_64. */
12232 return reloc_type
== 22; /* R_S390_64. */
12234 return reloc_type
== 1; /* R_TILEGX_64. */
12236 return reloc_type
== 18; /* R_MIPS_64. */
12242 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12243 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12246 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12248 switch (elf_header
.e_machine
)
12251 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12253 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12255 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12257 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12259 return reloc_type
== 44; /* R_PPC64_REL64. */
12260 case EM_SPARC32PLUS
:
12263 return reloc_type
== 46; /* R_SPARC_DISP64. */
12267 return reloc_type
== 24; /* R_X86_64_PC64. */
12270 return reloc_type
== 23; /* R_S390_PC64. */
12272 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12278 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12279 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12282 is_24bit_abs_reloc (unsigned int reloc_type
)
12284 switch (elf_header
.e_machine
)
12286 case EM_CYGNUS_MN10200
:
12288 return reloc_type
== 4; /* R_MN10200_24. */
12290 return reloc_type
== 5; /* R_FT32_20. */
12296 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12297 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12300 is_16bit_abs_reloc (unsigned int reloc_type
)
12302 /* Please keep this table alpha-sorted for ease of visual lookup. */
12303 switch (elf_header
.e_machine
)
12306 case EM_ARC_COMPACT
:
12307 case EM_ARC_COMPACT2
:
12308 return reloc_type
== 2; /* R_ARC_16. */
12309 case EM_ADAPTEVA_EPIPHANY
:
12310 return reloc_type
== 5;
12313 return reloc_type
== 4; /* R_AVR_16. */
12314 case EM_CYGNUS_D10V
:
12316 return reloc_type
== 3; /* R_D10V_16. */
12320 return reloc_type
== R_H8_DIR16
;
12323 return reloc_type
== 1; /* R_IP2K_16. */
12326 return reloc_type
== 1; /* R_M32C_16 */
12327 case EM_CYGNUS_MN10200
:
12329 return reloc_type
== 2; /* R_MN10200_16. */
12330 case EM_CYGNUS_MN10300
:
12332 return reloc_type
== 2; /* R_MN10300_16. */
12334 if (uses_msp430x_relocs ())
12335 return reloc_type
== 2; /* R_MSP430_ABS16. */
12336 /* Fall through. */
12337 case EM_MSP430_OLD
:
12338 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12340 return reloc_type
== 19; /* R_NDS32_RELA. */
12341 case EM_ALTERA_NIOS2
:
12342 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12344 return reloc_type
== 9; /* R_NIOS_16. */
12346 return reloc_type
== 2; /* R_OR1K_16. */
12348 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12350 return reloc_type
== 2; /* R_C6000_ABS16. */
12352 return reloc_type
== 2; /* R_VISIUM_16. */
12355 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12357 return reloc_type
== 3; /* R_XGATE_16. */
12363 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12364 relocation entries (possibly formerly used for SHT_GROUP sections). */
12367 is_none_reloc (unsigned int reloc_type
)
12369 switch (elf_header
.e_machine
)
12371 case EM_386
: /* R_386_NONE. */
12372 case EM_68K
: /* R_68K_NONE. */
12373 case EM_ADAPTEVA_EPIPHANY
:
12374 case EM_ALPHA
: /* R_ALPHA_NONE. */
12375 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12376 case EM_ARC
: /* R_ARC_NONE. */
12377 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12378 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12379 case EM_ARM
: /* R_ARM_NONE. */
12380 case EM_C166
: /* R_XC16X_NONE. */
12381 case EM_CRIS
: /* R_CRIS_NONE. */
12382 case EM_FT32
: /* R_FT32_NONE. */
12383 case EM_IA_64
: /* R_IA64_NONE. */
12384 case EM_K1OM
: /* R_X86_64_NONE. */
12385 case EM_L1OM
: /* R_X86_64_NONE. */
12386 case EM_M32R
: /* R_M32R_NONE. */
12387 case EM_MIPS
: /* R_MIPS_NONE. */
12388 case EM_MN10300
: /* R_MN10300_NONE. */
12389 case EM_MOXIE
: /* R_MOXIE_NONE. */
12390 case EM_NIOS32
: /* R_NIOS_NONE. */
12391 case EM_OR1K
: /* R_OR1K_NONE. */
12392 case EM_PARISC
: /* R_PARISC_NONE. */
12393 case EM_PPC64
: /* R_PPC64_NONE. */
12394 case EM_PPC
: /* R_PPC_NONE. */
12395 case EM_RISCV
: /* R_RISCV_NONE. */
12396 case EM_S390
: /* R_390_NONE. */
12398 case EM_SH
: /* R_SH_NONE. */
12399 case EM_SPARC32PLUS
:
12400 case EM_SPARC
: /* R_SPARC_NONE. */
12402 case EM_TILEGX
: /* R_TILEGX_NONE. */
12403 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12404 case EM_TI_C6000
:/* R_C6000_NONE. */
12405 case EM_X86_64
: /* R_X86_64_NONE. */
12407 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12408 return reloc_type
== 0;
12411 return reloc_type
== 0 || reloc_type
== 256;
12414 return (reloc_type
== 0 /* R_AVR_NONE. */
12415 || reloc_type
== 30 /* R_AVR_DIFF8. */
12416 || reloc_type
== 31 /* R_AVR_DIFF16. */
12417 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12419 return reloc_type
== 3; /* R_METAG_NONE. */
12421 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12422 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12423 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12424 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12425 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12427 return (reloc_type
== 0 /* R_PRU_NONE. */
12428 || reloc_type
== 65 /* R_PRU_DIFF8. */
12429 || reloc_type
== 66 /* R_PRU_DIFF16. */
12430 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12431 case EM_XTENSA_OLD
:
12433 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12434 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12435 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12436 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12441 /* Returns TRUE if there is a relocation against
12442 section NAME at OFFSET bytes. */
12445 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12447 Elf_Internal_Rela
* relocs
;
12448 Elf_Internal_Rela
* rp
;
12450 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12453 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12455 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12456 if (rp
->r_offset
== offset
)
12462 /* Apply relocations to a section.
12463 Returns TRUE upon success, FALSE otherwise.
12464 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12465 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12466 will be set to the number of relocs loaded.
12468 Note: So far support has been added only for those relocations
12469 which can be found in debug sections. FIXME: Add support for
12470 more relocations ? */
12473 apply_relocations (void * file
,
12474 const Elf_Internal_Shdr
* section
,
12475 unsigned char * start
,
12476 bfd_size_type size
,
12477 void ** relocs_return
,
12478 unsigned long * num_relocs_return
)
12480 Elf_Internal_Shdr
* relsec
;
12481 unsigned char * end
= start
+ size
;
12482 bfd_boolean res
= TRUE
;
12484 if (relocs_return
!= NULL
)
12486 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12487 * num_relocs_return
= 0;
12490 if (elf_header
.e_type
!= ET_REL
)
12491 /* No relocs to apply. */
12494 /* Find the reloc section associated with the section. */
12495 for (relsec
= section_headers
;
12496 relsec
< section_headers
+ elf_header
.e_shnum
;
12499 bfd_boolean is_rela
;
12500 unsigned long num_relocs
;
12501 Elf_Internal_Rela
* relocs
;
12502 Elf_Internal_Rela
* rp
;
12503 Elf_Internal_Shdr
* symsec
;
12504 Elf_Internal_Sym
* symtab
;
12505 unsigned long num_syms
;
12506 Elf_Internal_Sym
* sym
;
12508 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12509 || relsec
->sh_info
>= elf_header
.e_shnum
12510 || section_headers
+ relsec
->sh_info
!= section
12511 || relsec
->sh_size
== 0
12512 || relsec
->sh_link
>= elf_header
.e_shnum
)
12515 is_rela
= relsec
->sh_type
== SHT_RELA
;
12519 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12520 relsec
->sh_size
, & relocs
, & num_relocs
))
12525 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12526 relsec
->sh_size
, & relocs
, & num_relocs
))
12530 /* SH uses RELA but uses in place value instead of the addend field. */
12531 if (elf_header
.e_machine
== EM_SH
)
12534 symsec
= section_headers
+ relsec
->sh_link
;
12535 if (symsec
->sh_type
!= SHT_SYMTAB
12536 && symsec
->sh_type
!= SHT_DYNSYM
)
12538 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12540 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12543 unsigned int reloc_type
;
12544 unsigned int reloc_size
;
12545 unsigned char * rloc
;
12546 unsigned long sym_index
;
12548 reloc_type
= get_reloc_type (rp
->r_info
);
12550 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12552 else if (is_none_reloc (reloc_type
))
12554 else if (is_32bit_abs_reloc (reloc_type
)
12555 || is_32bit_pcrel_reloc (reloc_type
))
12557 else if (is_64bit_abs_reloc (reloc_type
)
12558 || is_64bit_pcrel_reloc (reloc_type
))
12560 else if (is_24bit_abs_reloc (reloc_type
))
12562 else if (is_16bit_abs_reloc (reloc_type
))
12566 static unsigned int prev_reloc
= 0;
12567 if (reloc_type
!= prev_reloc
)
12568 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12569 reloc_type
, printable_section_name (section
));
12570 prev_reloc
= reloc_type
;
12575 rloc
= start
+ rp
->r_offset
;
12576 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12578 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12579 (unsigned long) rp
->r_offset
,
12580 printable_section_name (section
));
12585 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12586 if (sym_index
>= num_syms
)
12588 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12589 sym_index
, printable_section_name (section
));
12593 sym
= symtab
+ sym_index
;
12595 /* If the reloc has a symbol associated with it,
12596 make sure that it is of an appropriate type.
12598 Relocations against symbols without type can happen.
12599 Gcc -feliminate-dwarf2-dups may generate symbols
12600 without type for debug info.
12602 Icc generates relocations against function symbols
12603 instead of local labels.
12605 Relocations against object symbols can happen, eg when
12606 referencing a global array. For an example of this see
12607 the _clz.o binary in libgcc.a. */
12609 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12610 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12612 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12613 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12614 (long int)(rp
- relocs
),
12615 printable_section_name (relsec
));
12622 addend
+= rp
->r_addend
;
12623 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12624 partial_inplace. */
12626 || (elf_header
.e_machine
== EM_XTENSA
12627 && reloc_type
== 1)
12628 || ((elf_header
.e_machine
== EM_PJ
12629 || elf_header
.e_machine
== EM_PJ_OLD
)
12630 && reloc_type
== 1)
12631 || ((elf_header
.e_machine
== EM_D30V
12632 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12633 && reloc_type
== 12))
12634 addend
+= byte_get (rloc
, reloc_size
);
12636 if (is_32bit_pcrel_reloc (reloc_type
)
12637 || is_64bit_pcrel_reloc (reloc_type
))
12639 /* On HPPA, all pc-relative relocations are biased by 8. */
12640 if (elf_header
.e_machine
== EM_PARISC
)
12642 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12646 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12650 /* Let the target specific reloc processing code know that
12651 we have finished with these relocs. */
12652 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12656 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12657 * num_relocs_return
= num_relocs
;
12668 #ifdef SUPPORT_DISASSEMBLY
12670 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12672 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12674 /* FIXME: XXX -- to be done --- XXX */
12680 /* Reads in the contents of SECTION from FILE, returning a pointer
12681 to a malloc'ed buffer or NULL if something went wrong. */
12684 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12686 bfd_size_type num_bytes
;
12688 num_bytes
= section
->sh_size
;
12690 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12692 printf (_("\nSection '%s' has no data to dump.\n"),
12693 printable_section_name (section
));
12697 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12698 _("section contents"));
12701 /* Uncompresses a section that was compressed using zlib, in place. */
12704 uncompress_section_contents (unsigned char **buffer
,
12705 dwarf_size_type uncompressed_size
,
12706 dwarf_size_type
*size
)
12708 dwarf_size_type compressed_size
= *size
;
12709 unsigned char * compressed_buffer
= *buffer
;
12710 unsigned char * uncompressed_buffer
;
12714 /* It is possible the section consists of several compressed
12715 buffers concatenated together, so we uncompress in a loop. */
12716 /* PR 18313: The state field in the z_stream structure is supposed
12717 to be invisible to the user (ie us), but some compilers will
12718 still complain about it being used without initialisation. So
12719 we first zero the entire z_stream structure and then set the fields
12721 memset (& strm
, 0, sizeof strm
);
12722 strm
.avail_in
= compressed_size
;
12723 strm
.next_in
= (Bytef
*) compressed_buffer
;
12724 strm
.avail_out
= uncompressed_size
;
12725 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12727 rc
= inflateInit (& strm
);
12728 while (strm
.avail_in
> 0)
12732 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12733 + (uncompressed_size
- strm
.avail_out
));
12734 rc
= inflate (&strm
, Z_FINISH
);
12735 if (rc
!= Z_STREAM_END
)
12737 rc
= inflateReset (& strm
);
12739 rc
= inflateEnd (& strm
);
12741 || strm
.avail_out
!= 0)
12744 *buffer
= uncompressed_buffer
;
12745 *size
= uncompressed_size
;
12749 free (uncompressed_buffer
);
12750 /* Indicate decompression failure. */
12756 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12758 Elf_Internal_Shdr
* relsec
;
12759 bfd_size_type num_bytes
;
12760 unsigned char * data
;
12761 unsigned char * end
;
12762 unsigned char * real_start
;
12763 unsigned char * start
;
12764 bfd_boolean some_strings_shown
;
12766 real_start
= start
= (unsigned char *) get_section_contents (section
,
12770 num_bytes
= section
->sh_size
;
12772 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12774 if (decompress_dumps
)
12776 dwarf_size_type new_size
= num_bytes
;
12777 dwarf_size_type uncompressed_size
= 0;
12779 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12781 Elf_Internal_Chdr chdr
;
12782 unsigned int compression_header_size
12783 = get_compression_header (& chdr
, (unsigned char *) start
,
12786 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12788 warn (_("section '%s' has unsupported compress type: %d\n"),
12789 printable_section_name (section
), chdr
.ch_type
);
12792 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12794 warn (_("compressed section '%s' is corrupted\n"),
12795 printable_section_name (section
));
12798 uncompressed_size
= chdr
.ch_size
;
12799 start
+= compression_header_size
;
12800 new_size
-= compression_header_size
;
12802 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12804 /* Read the zlib header. In this case, it should be "ZLIB"
12805 followed by the uncompressed section size, 8 bytes in
12806 big-endian order. */
12807 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12808 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12809 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12810 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12811 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12812 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12813 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12814 uncompressed_size
+= start
[11];
12819 if (uncompressed_size
)
12821 if (uncompress_section_contents (& start
,
12822 uncompressed_size
, & new_size
))
12823 num_bytes
= new_size
;
12826 error (_("Unable to decompress section %s\n"),
12827 printable_section_name (section
));
12832 start
= real_start
;
12835 /* If the section being dumped has relocations against it the user might
12836 be expecting these relocations to have been applied. Check for this
12837 case and issue a warning message in order to avoid confusion.
12838 FIXME: Maybe we ought to have an option that dumps a section with
12839 relocs applied ? */
12840 for (relsec
= section_headers
;
12841 relsec
< section_headers
+ elf_header
.e_shnum
;
12844 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12845 || relsec
->sh_info
>= elf_header
.e_shnum
12846 || section_headers
+ relsec
->sh_info
!= section
12847 || relsec
->sh_size
== 0
12848 || relsec
->sh_link
>= elf_header
.e_shnum
)
12851 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12856 end
= start
+ num_bytes
;
12857 some_strings_shown
= FALSE
;
12861 while (!ISPRINT (* data
))
12862 if (++ data
>= end
)
12867 size_t maxlen
= end
- data
;
12870 /* PR 11128: Use two separate invocations in order to work
12871 around bugs in the Solaris 8 implementation of printf. */
12872 printf (" [%6tx] ", data
- start
);
12874 printf (" [%6Ix] ", (size_t) (data
- start
));
12878 print_symbol ((int) maxlen
, (const char *) data
);
12880 data
+= strnlen ((const char *) data
, maxlen
);
12884 printf (_("<corrupt>\n"));
12887 some_strings_shown
= TRUE
;
12891 if (! some_strings_shown
)
12892 printf (_(" No strings found in this section."));
12901 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12903 bfd_boolean relocate
)
12905 Elf_Internal_Shdr
* relsec
;
12906 bfd_size_type bytes
;
12907 bfd_size_type section_size
;
12909 unsigned char * data
;
12910 unsigned char * real_start
;
12911 unsigned char * start
;
12913 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12917 section_size
= section
->sh_size
;
12919 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12921 if (decompress_dumps
)
12923 dwarf_size_type new_size
= section_size
;
12924 dwarf_size_type uncompressed_size
= 0;
12926 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12928 Elf_Internal_Chdr chdr
;
12929 unsigned int compression_header_size
12930 = get_compression_header (& chdr
, start
, section_size
);
12932 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12934 warn (_("section '%s' has unsupported compress type: %d\n"),
12935 printable_section_name (section
), chdr
.ch_type
);
12938 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12940 warn (_("compressed section '%s' is corrupted\n"),
12941 printable_section_name (section
));
12944 uncompressed_size
= chdr
.ch_size
;
12945 start
+= compression_header_size
;
12946 new_size
-= compression_header_size
;
12948 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12950 /* Read the zlib header. In this case, it should be "ZLIB"
12951 followed by the uncompressed section size, 8 bytes in
12952 big-endian order. */
12953 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12954 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12955 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12956 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12957 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12958 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12959 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12960 uncompressed_size
+= start
[11];
12965 if (uncompressed_size
)
12967 if (uncompress_section_contents (& start
, uncompressed_size
,
12970 section_size
= new_size
;
12974 error (_("Unable to decompress section %s\n"),
12975 printable_section_name (section
));
12976 /* FIXME: Print the section anyway ? */
12981 start
= real_start
;
12986 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
12991 /* If the section being dumped has relocations against it the user might
12992 be expecting these relocations to have been applied. Check for this
12993 case and issue a warning message in order to avoid confusion.
12994 FIXME: Maybe we ought to have an option that dumps a section with
12995 relocs applied ? */
12996 for (relsec
= section_headers
;
12997 relsec
< section_headers
+ elf_header
.e_shnum
;
13000 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13001 || relsec
->sh_info
>= elf_header
.e_shnum
13002 || section_headers
+ relsec
->sh_info
!= section
13003 || relsec
->sh_size
== 0
13004 || relsec
->sh_link
>= elf_header
.e_shnum
)
13007 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13012 addr
= section
->sh_addr
;
13013 bytes
= section_size
;
13022 lbytes
= (bytes
> 16 ? 16 : bytes
);
13024 printf (" 0x%8.8lx ", (unsigned long) addr
);
13026 for (j
= 0; j
< 16; j
++)
13029 printf ("%2.2x", data
[j
]);
13037 for (j
= 0; j
< lbytes
; j
++)
13040 if (k
>= ' ' && k
< 0x7f)
13060 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13061 const Elf_Internal_Shdr
* sec
, void * file
)
13063 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13066 /* If it is already loaded, do nothing. */
13067 if (section
->start
!= NULL
)
13070 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13071 section
->address
= sec
->sh_addr
;
13072 section
->user_data
= NULL
;
13073 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13075 sec
->sh_size
, buf
);
13076 if (section
->start
== NULL
)
13080 unsigned char *start
= section
->start
;
13081 dwarf_size_type size
= sec
->sh_size
;
13082 dwarf_size_type uncompressed_size
= 0;
13084 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13086 Elf_Internal_Chdr chdr
;
13087 unsigned int compression_header_size
;
13089 if (size
< (is_32bit_elf
13090 ? sizeof (Elf32_External_Chdr
)
13091 : sizeof (Elf64_External_Chdr
)))
13093 warn (_("compressed section %s is too small to contain a compression header"),
13098 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13100 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13102 warn (_("section '%s' has unsupported compress type: %d\n"),
13103 section
->name
, chdr
.ch_type
);
13106 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13108 warn (_("compressed section '%s' is corrupted\n"),
13112 uncompressed_size
= chdr
.ch_size
;
13113 start
+= compression_header_size
;
13114 size
-= compression_header_size
;
13116 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13118 /* Read the zlib header. In this case, it should be "ZLIB"
13119 followed by the uncompressed section size, 8 bytes in
13120 big-endian order. */
13121 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13122 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13123 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13124 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13125 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13126 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13127 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13128 uncompressed_size
+= start
[11];
13133 if (uncompressed_size
)
13135 if (uncompress_section_contents (&start
, uncompressed_size
,
13138 /* Free the compressed buffer, update the section buffer
13139 and the section size if uncompress is successful. */
13140 free (section
->start
);
13141 section
->start
= start
;
13145 error (_("Unable to decompress section %s\n"),
13146 printable_section_name (sec
));
13151 section
->size
= size
;
13154 if (section
->start
== NULL
)
13157 if (debug_displays
[debug
].relocate
)
13159 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13160 & section
->reloc_info
, & section
->num_relocs
))
13165 section
->reloc_info
= NULL
;
13166 section
->num_relocs
= 0;
13172 /* If this is not NULL, load_debug_section will only look for sections
13173 within the list of sections given here. */
13174 static unsigned int * section_subset
= NULL
;
13177 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13179 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13180 Elf_Internal_Shdr
* sec
;
13182 /* Locate the debug section. */
13183 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13185 section
->name
= section
->uncompressed_name
;
13188 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13190 section
->name
= section
->compressed_name
;
13195 /* If we're loading from a subset of sections, and we've loaded
13196 a section matching this name before, it's likely that it's a
13198 if (section_subset
!= NULL
)
13199 free_debug_section (debug
);
13201 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13205 free_debug_section (enum dwarf_section_display_enum debug
)
13207 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13209 if (section
->start
== NULL
)
13212 free ((char *) section
->start
);
13213 section
->start
= NULL
;
13214 section
->address
= 0;
13219 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13221 char * name
= SECTION_NAME (section
);
13222 const char * print_name
= printable_section_name (section
);
13223 bfd_size_type length
;
13224 bfd_boolean result
= TRUE
;
13227 length
= section
->sh_size
;
13230 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13233 if (section
->sh_type
== SHT_NOBITS
)
13235 /* There is no point in dumping the contents of a debugging section
13236 which has the NOBITS type - the bits in the file will be random.
13237 This can happen when a file containing a .eh_frame section is
13238 stripped with the --only-keep-debug command line option. */
13239 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13244 if (const_strneq (name
, ".gnu.linkonce.wi."))
13245 name
= ".debug_info";
13247 /* See if we know how to display the contents of this section. */
13248 for (i
= 0; i
< max
; i
++)
13249 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13250 || (i
== line
&& const_strneq (name
, ".debug_line."))
13251 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13253 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13254 int secondary
= (section
!= find_section (name
));
13257 free_debug_section ((enum dwarf_section_display_enum
) i
);
13259 if (i
== line
&& const_strneq (name
, ".debug_line."))
13261 else if (streq (sec
->uncompressed_name
, name
))
13262 sec
->name
= sec
->uncompressed_name
;
13264 sec
->name
= sec
->compressed_name
;
13265 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13268 /* If this debug section is part of a CU/TU set in a .dwp file,
13269 restrict load_debug_section to the sections in that set. */
13270 section_subset
= find_cu_tu_set (file
, shndx
);
13272 result
&= debug_displays
[i
].display (sec
, file
);
13274 section_subset
= NULL
;
13276 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13277 free_debug_section ((enum dwarf_section_display_enum
) i
);
13285 printf (_("Unrecognized debug section: %s\n"), print_name
);
13292 /* Set DUMP_SECTS for all sections where dumps were requested
13293 based on section name. */
13296 initialise_dumps_byname (void)
13298 struct dump_list_entry
* cur
;
13300 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13303 bfd_boolean any
= FALSE
;
13305 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13306 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13308 request_dump_bynumber (i
, cur
->type
);
13313 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13319 process_section_contents (FILE * file
)
13321 Elf_Internal_Shdr
* section
;
13323 bfd_boolean res
= TRUE
;
13328 initialise_dumps_byname ();
13330 for (i
= 0, section
= section_headers
;
13331 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13334 #ifdef SUPPORT_DISASSEMBLY
13335 if (dump_sects
[i
] & DISASS_DUMP
)
13336 disassemble_section (section
, file
);
13338 if (dump_sects
[i
] & HEX_DUMP
)
13340 if (! dump_section_as_bytes (section
, file
, FALSE
))
13344 if (dump_sects
[i
] & RELOC_DUMP
)
13346 if (! dump_section_as_bytes (section
, file
, TRUE
))
13350 if (dump_sects
[i
] & STRING_DUMP
)
13352 if (! dump_section_as_strings (section
, file
))
13356 if (dump_sects
[i
] & DEBUG_DUMP
)
13358 if (! display_debug_section (i
, section
, file
))
13363 /* Check to see if the user requested a
13364 dump of a section that does not exist. */
13365 while (i
< num_dump_sects
)
13369 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13379 process_mips_fpe_exception (int mask
)
13383 bfd_boolean first
= TRUE
;
13385 if (mask
& OEX_FPU_INEX
)
13386 fputs ("INEX", stdout
), first
= FALSE
;
13387 if (mask
& OEX_FPU_UFLO
)
13388 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13389 if (mask
& OEX_FPU_OFLO
)
13390 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13391 if (mask
& OEX_FPU_DIV0
)
13392 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13393 if (mask
& OEX_FPU_INVAL
)
13394 printf ("%sINVAL", first
? "" : "|");
13397 fputs ("0", stdout
);
13400 /* Display's the value of TAG at location P. If TAG is
13401 greater than 0 it is assumed to be an unknown tag, and
13402 a message is printed to this effect. Otherwise it is
13403 assumed that a message has already been printed.
13405 If the bottom bit of TAG is set it assumed to have a
13406 string value, otherwise it is assumed to have an integer
13409 Returns an updated P pointing to the first unread byte
13410 beyond the end of TAG's value.
13412 Reads at or beyond END will not be made. */
13414 static unsigned char *
13415 display_tag_value (signed int tag
,
13417 const unsigned char * const end
)
13422 printf (" Tag_unknown_%d: ", tag
);
13426 warn (_("<corrupt tag>\n"));
13430 /* PR 17531 file: 027-19978-0.004. */
13431 size_t maxlen
= (end
- p
) - 1;
13436 print_symbol ((int) maxlen
, (const char *) p
);
13437 p
+= strnlen ((char *) p
, maxlen
) + 1;
13441 printf (_("<corrupt string tag>"));
13442 p
= (unsigned char *) end
;
13450 val
= read_uleb128 (p
, &len
, end
);
13452 printf ("%ld (0x%lx)\n", val
, val
);
13459 /* ARM EABI attributes section. */
13464 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13466 const char ** table
;
13467 } arm_attr_public_tag
;
13469 static const char * arm_attr_tag_CPU_arch
[] =
13470 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13471 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13473 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13474 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13475 {"No", "Thumb-1", "Thumb-2", "Yes"};
13476 static const char * arm_attr_tag_FP_arch
[] =
13477 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13478 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13479 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13480 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13481 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13482 "NEON for ARMv8.1"};
13483 static const char * arm_attr_tag_PCS_config
[] =
13484 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13485 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13486 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13487 {"V6", "SB", "TLS", "Unused"};
13488 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13489 {"Absolute", "PC-relative", "SB-relative", "None"};
13490 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13491 {"Absolute", "PC-relative", "None"};
13492 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13493 {"None", "direct", "GOT-indirect"};
13494 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13495 {"None", "??? 1", "2", "??? 3", "4"};
13496 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13497 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13498 {"Unused", "Needed", "Sign only"};
13499 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13500 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13501 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13502 {"Unused", "Finite", "RTABI", "IEEE 754"};
13503 static const char * arm_attr_tag_ABI_enum_size
[] =
13504 {"Unused", "small", "int", "forced to int"};
13505 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13506 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13507 static const char * arm_attr_tag_ABI_VFP_args
[] =
13508 {"AAPCS", "VFP registers", "custom", "compatible"};
13509 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13510 {"AAPCS", "WMMX registers", "custom"};
13511 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13512 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13513 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13514 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13515 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13516 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13517 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13518 static const char * arm_attr_tag_FP_HP_extension
[] =
13519 {"Not Allowed", "Allowed"};
13520 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13521 {"None", "IEEE 754", "Alternative Format"};
13522 static const char * arm_attr_tag_DSP_extension
[] =
13523 {"Follow architecture", "Allowed"};
13524 static const char * arm_attr_tag_MPextension_use
[] =
13525 {"Not Allowed", "Allowed"};
13526 static const char * arm_attr_tag_DIV_use
[] =
13527 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13528 "Allowed in v7-A with integer division extension"};
13529 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13530 static const char * arm_attr_tag_Virtualization_use
[] =
13531 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13532 "TrustZone and Virtualization Extensions"};
13533 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13534 {"Not Allowed", "Allowed"};
13536 #define LOOKUP(id, name) \
13537 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13538 static arm_attr_public_tag arm_attr_public_tags
[] =
13540 {4, "CPU_raw_name", 1, NULL
},
13541 {5, "CPU_name", 1, NULL
},
13542 LOOKUP(6, CPU_arch
),
13543 {7, "CPU_arch_profile", 0, NULL
},
13544 LOOKUP(8, ARM_ISA_use
),
13545 LOOKUP(9, THUMB_ISA_use
),
13546 LOOKUP(10, FP_arch
),
13547 LOOKUP(11, WMMX_arch
),
13548 LOOKUP(12, Advanced_SIMD_arch
),
13549 LOOKUP(13, PCS_config
),
13550 LOOKUP(14, ABI_PCS_R9_use
),
13551 LOOKUP(15, ABI_PCS_RW_data
),
13552 LOOKUP(16, ABI_PCS_RO_data
),
13553 LOOKUP(17, ABI_PCS_GOT_use
),
13554 LOOKUP(18, ABI_PCS_wchar_t
),
13555 LOOKUP(19, ABI_FP_rounding
),
13556 LOOKUP(20, ABI_FP_denormal
),
13557 LOOKUP(21, ABI_FP_exceptions
),
13558 LOOKUP(22, ABI_FP_user_exceptions
),
13559 LOOKUP(23, ABI_FP_number_model
),
13560 {24, "ABI_align_needed", 0, NULL
},
13561 {25, "ABI_align_preserved", 0, NULL
},
13562 LOOKUP(26, ABI_enum_size
),
13563 LOOKUP(27, ABI_HardFP_use
),
13564 LOOKUP(28, ABI_VFP_args
),
13565 LOOKUP(29, ABI_WMMX_args
),
13566 LOOKUP(30, ABI_optimization_goals
),
13567 LOOKUP(31, ABI_FP_optimization_goals
),
13568 {32, "compatibility", 0, NULL
},
13569 LOOKUP(34, CPU_unaligned_access
),
13570 LOOKUP(36, FP_HP_extension
),
13571 LOOKUP(38, ABI_FP_16bit_format
),
13572 LOOKUP(42, MPextension_use
),
13573 LOOKUP(44, DIV_use
),
13574 LOOKUP(46, DSP_extension
),
13575 {64, "nodefaults", 0, NULL
},
13576 {65, "also_compatible_with", 0, NULL
},
13577 LOOKUP(66, T2EE_use
),
13578 {67, "conformance", 1, NULL
},
13579 LOOKUP(68, Virtualization_use
),
13580 LOOKUP(70, MPextension_use_legacy
)
13584 static unsigned char *
13585 display_arm_attribute (unsigned char * p
,
13586 const unsigned char * const end
)
13591 arm_attr_public_tag
* attr
;
13595 tag
= read_uleb128 (p
, &len
, end
);
13598 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13600 if (arm_attr_public_tags
[i
].tag
== tag
)
13602 attr
= &arm_attr_public_tags
[i
];
13609 printf (" Tag_%s: ", attr
->name
);
13610 switch (attr
->type
)
13615 case 7: /* Tag_CPU_arch_profile. */
13616 val
= read_uleb128 (p
, &len
, end
);
13620 case 0: printf (_("None\n")); break;
13621 case 'A': printf (_("Application\n")); break;
13622 case 'R': printf (_("Realtime\n")); break;
13623 case 'M': printf (_("Microcontroller\n")); break;
13624 case 'S': printf (_("Application or Realtime\n")); break;
13625 default: printf ("??? (%d)\n", val
); break;
13629 case 24: /* Tag_align_needed. */
13630 val
= read_uleb128 (p
, &len
, end
);
13634 case 0: printf (_("None\n")); break;
13635 case 1: printf (_("8-byte\n")); break;
13636 case 2: printf (_("4-byte\n")); break;
13637 case 3: printf ("??? 3\n"); break;
13640 printf (_("8-byte and up to %d-byte extended\n"),
13643 printf ("??? (%d)\n", val
);
13648 case 25: /* Tag_align_preserved. */
13649 val
= read_uleb128 (p
, &len
, end
);
13653 case 0: printf (_("None\n")); break;
13654 case 1: printf (_("8-byte, except leaf SP\n")); break;
13655 case 2: printf (_("8-byte\n")); break;
13656 case 3: printf ("??? 3\n"); break;
13659 printf (_("8-byte and up to %d-byte extended\n"),
13662 printf ("??? (%d)\n", val
);
13667 case 32: /* Tag_compatibility. */
13669 val
= read_uleb128 (p
, &len
, end
);
13671 printf (_("flag = %d, vendor = "), val
);
13674 size_t maxlen
= (end
- p
) - 1;
13676 print_symbol ((int) maxlen
, (const char *) p
);
13677 p
+= strnlen ((char *) p
, maxlen
) + 1;
13681 printf (_("<corrupt>"));
13682 p
= (unsigned char *) end
;
13688 case 64: /* Tag_nodefaults. */
13689 /* PR 17531: file: 001-505008-0.01. */
13692 printf (_("True\n"));
13695 case 65: /* Tag_also_compatible_with. */
13696 val
= read_uleb128 (p
, &len
, end
);
13698 if (val
== 6 /* Tag_CPU_arch. */)
13700 val
= read_uleb128 (p
, &len
, end
);
13702 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13703 printf ("??? (%d)\n", val
);
13705 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13709 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13714 printf (_("<unknown: %d>\n"), tag
);
13720 return display_tag_value (-1, p
, end
);
13722 return display_tag_value (0, p
, end
);
13725 assert (attr
->type
& 0x80);
13726 val
= read_uleb128 (p
, &len
, end
);
13728 type
= attr
->type
& 0x7f;
13730 printf ("??? (%d)\n", val
);
13732 printf ("%s\n", attr
->table
[val
]);
13737 return display_tag_value (tag
, p
, end
);
13740 static unsigned char *
13741 display_gnu_attribute (unsigned char * p
,
13742 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13743 const unsigned char * const end
)
13749 tag
= read_uleb128 (p
, &len
, end
);
13752 /* Tag_compatibility is the only generic GNU attribute defined at
13756 val
= read_uleb128 (p
, &len
, end
);
13759 printf (_("flag = %d, vendor = "), val
);
13762 printf (_("<corrupt>\n"));
13763 warn (_("corrupt vendor attribute\n"));
13769 size_t maxlen
= (end
- p
) - 1;
13771 print_symbol ((int) maxlen
, (const char *) p
);
13772 p
+= strnlen ((char *) p
, maxlen
) + 1;
13776 printf (_("<corrupt>"));
13777 p
= (unsigned char *) end
;
13784 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13785 return display_proc_gnu_attribute (p
, tag
, end
);
13787 return display_tag_value (tag
, p
, end
);
13790 static unsigned char *
13791 display_power_gnu_attribute (unsigned char * p
,
13793 const unsigned char * const end
)
13798 if (tag
== Tag_GNU_Power_ABI_FP
)
13800 val
= read_uleb128 (p
, &len
, end
);
13802 printf (" Tag_GNU_Power_ABI_FP: ");
13805 printf (_("<corrupt>\n"));
13810 printf ("(%#x), ", val
);
13815 printf (_("unspecified hard/soft float, "));
13818 printf (_("hard float, "));
13821 printf (_("soft float, "));
13824 printf (_("single-precision hard float, "));
13831 printf (_("unspecified long double\n"));
13834 printf (_("128-bit IBM long double\n"));
13837 printf (_("64-bit long double\n"));
13840 printf (_("128-bit IEEE long double\n"));
13846 if (tag
== Tag_GNU_Power_ABI_Vector
)
13848 val
= read_uleb128 (p
, &len
, end
);
13850 printf (" Tag_GNU_Power_ABI_Vector: ");
13853 printf (_("<corrupt>\n"));
13858 printf ("(%#x), ", val
);
13863 printf (_("unspecified\n"));
13866 printf (_("generic\n"));
13869 printf ("AltiVec\n");
13878 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13880 val
= read_uleb128 (p
, &len
, end
);
13882 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13885 printf (_("<corrupt>\n"));
13890 printf ("(%#x), ", val
);
13895 printf (_("unspecified\n"));
13898 printf ("r3/r4\n");
13901 printf (_("memory\n"));
13910 return display_tag_value (tag
& 1, p
, end
);
13913 static unsigned char *
13914 display_s390_gnu_attribute (unsigned char * p
,
13916 const unsigned char * const end
)
13921 if (tag
== Tag_GNU_S390_ABI_Vector
)
13923 val
= read_uleb128 (p
, &len
, end
);
13925 printf (" Tag_GNU_S390_ABI_Vector: ");
13930 printf (_("any\n"));
13933 printf (_("software\n"));
13936 printf (_("hardware\n"));
13939 printf ("??? (%d)\n", val
);
13945 return display_tag_value (tag
& 1, p
, end
);
13949 display_sparc_hwcaps (unsigned int mask
)
13953 bfd_boolean first
= TRUE
;
13955 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13956 fputs ("mul32", stdout
), first
= FALSE
;
13957 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13958 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
13959 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13960 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
13961 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13962 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
13963 if (mask
& ELF_SPARC_HWCAP_POPC
)
13964 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
13965 if (mask
& ELF_SPARC_HWCAP_VIS
)
13966 printf ("%svis", first
? "" : "|"), first
= FALSE
;
13967 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13968 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
13969 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13970 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
13971 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13972 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
13973 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13974 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
13975 if (mask
& ELF_SPARC_HWCAP_HPC
)
13976 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
13977 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13978 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
13979 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13980 printf ("%strans", first
? "" : "|"), first
= FALSE
;
13981 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13982 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
13983 if (mask
& ELF_SPARC_HWCAP_IMA
)
13984 printf ("%sima", first
? "" : "|"), first
= FALSE
;
13985 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13986 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
13989 fputc ('0', stdout
);
13990 fputc ('\n', stdout
);
13994 display_sparc_hwcaps2 (unsigned int mask
)
13998 bfd_boolean first
= TRUE
;
14000 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14001 fputs ("fjathplus", stdout
), first
= FALSE
;
14002 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14003 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14004 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14005 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14006 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14007 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14008 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14009 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14010 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14011 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14012 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14013 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14014 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14015 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14016 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14017 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14018 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14019 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14020 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14021 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14024 fputc ('0', stdout
);
14025 fputc ('\n', stdout
);
14028 static unsigned char *
14029 display_sparc_gnu_attribute (unsigned char * p
,
14031 const unsigned char * const end
)
14036 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14038 val
= read_uleb128 (p
, &len
, end
);
14040 printf (" Tag_GNU_Sparc_HWCAPS: ");
14041 display_sparc_hwcaps (val
);
14044 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14046 val
= read_uleb128 (p
, &len
, end
);
14048 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14049 display_sparc_hwcaps2 (val
);
14053 return display_tag_value (tag
, p
, end
);
14057 print_mips_fp_abi_value (unsigned int val
)
14061 case Val_GNU_MIPS_ABI_FP_ANY
:
14062 printf (_("Hard or soft float\n"));
14064 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14065 printf (_("Hard float (double precision)\n"));
14067 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14068 printf (_("Hard float (single precision)\n"));
14070 case Val_GNU_MIPS_ABI_FP_SOFT
:
14071 printf (_("Soft float\n"));
14073 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14074 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14076 case Val_GNU_MIPS_ABI_FP_XX
:
14077 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14079 case Val_GNU_MIPS_ABI_FP_64
:
14080 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14082 case Val_GNU_MIPS_ABI_FP_64A
:
14083 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14085 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14086 printf (_("NaN 2008 compatibility\n"));
14089 printf ("??? (%d)\n", val
);
14094 static unsigned char *
14095 display_mips_gnu_attribute (unsigned char * p
,
14097 const unsigned char * const end
)
14099 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14104 val
= read_uleb128 (p
, &len
, end
);
14106 printf (" Tag_GNU_MIPS_ABI_FP: ");
14108 print_mips_fp_abi_value (val
);
14113 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14118 val
= read_uleb128 (p
, &len
, end
);
14120 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14124 case Val_GNU_MIPS_ABI_MSA_ANY
:
14125 printf (_("Any MSA or not\n"));
14127 case Val_GNU_MIPS_ABI_MSA_128
:
14128 printf (_("128-bit MSA\n"));
14131 printf ("??? (%d)\n", val
);
14137 return display_tag_value (tag
& 1, p
, end
);
14140 static unsigned char *
14141 display_tic6x_attribute (unsigned char * p
,
14142 const unsigned char * const end
)
14148 tag
= read_uleb128 (p
, &len
, end
);
14154 val
= read_uleb128 (p
, &len
, end
);
14156 printf (" Tag_ISA: ");
14160 case C6XABI_Tag_ISA_none
:
14161 printf (_("None\n"));
14163 case C6XABI_Tag_ISA_C62X
:
14166 case C6XABI_Tag_ISA_C67X
:
14169 case C6XABI_Tag_ISA_C67XP
:
14170 printf ("C67x+\n");
14172 case C6XABI_Tag_ISA_C64X
:
14175 case C6XABI_Tag_ISA_C64XP
:
14176 printf ("C64x+\n");
14178 case C6XABI_Tag_ISA_C674X
:
14179 printf ("C674x\n");
14182 printf ("??? (%d)\n", val
);
14187 case Tag_ABI_wchar_t
:
14188 val
= read_uleb128 (p
, &len
, end
);
14190 printf (" Tag_ABI_wchar_t: ");
14194 printf (_("Not used\n"));
14197 printf (_("2 bytes\n"));
14200 printf (_("4 bytes\n"));
14203 printf ("??? (%d)\n", val
);
14208 case Tag_ABI_stack_align_needed
:
14209 val
= read_uleb128 (p
, &len
, end
);
14211 printf (" Tag_ABI_stack_align_needed: ");
14215 printf (_("8-byte\n"));
14218 printf (_("16-byte\n"));
14221 printf ("??? (%d)\n", val
);
14226 case Tag_ABI_stack_align_preserved
:
14227 val
= read_uleb128 (p
, &len
, end
);
14229 printf (" Tag_ABI_stack_align_preserved: ");
14233 printf (_("8-byte\n"));
14236 printf (_("16-byte\n"));
14239 printf ("??? (%d)\n", val
);
14245 val
= read_uleb128 (p
, &len
, end
);
14247 printf (" Tag_ABI_DSBT: ");
14251 printf (_("DSBT addressing not used\n"));
14254 printf (_("DSBT addressing used\n"));
14257 printf ("??? (%d)\n", val
);
14263 val
= read_uleb128 (p
, &len
, end
);
14265 printf (" Tag_ABI_PID: ");
14269 printf (_("Data addressing position-dependent\n"));
14272 printf (_("Data addressing position-independent, GOT near DP\n"));
14275 printf (_("Data addressing position-independent, GOT far from DP\n"));
14278 printf ("??? (%d)\n", val
);
14284 val
= read_uleb128 (p
, &len
, end
);
14286 printf (" Tag_ABI_PIC: ");
14290 printf (_("Code addressing position-dependent\n"));
14293 printf (_("Code addressing position-independent\n"));
14296 printf ("??? (%d)\n", val
);
14301 case Tag_ABI_array_object_alignment
:
14302 val
= read_uleb128 (p
, &len
, end
);
14304 printf (" Tag_ABI_array_object_alignment: ");
14308 printf (_("8-byte\n"));
14311 printf (_("4-byte\n"));
14314 printf (_("16-byte\n"));
14317 printf ("??? (%d)\n", val
);
14322 case Tag_ABI_array_object_align_expected
:
14323 val
= read_uleb128 (p
, &len
, end
);
14325 printf (" Tag_ABI_array_object_align_expected: ");
14329 printf (_("8-byte\n"));
14332 printf (_("4-byte\n"));
14335 printf (_("16-byte\n"));
14338 printf ("??? (%d)\n", val
);
14343 case Tag_ABI_compatibility
:
14345 val
= read_uleb128 (p
, &len
, end
);
14347 printf (" Tag_ABI_compatibility: ");
14348 printf (_("flag = %d, vendor = "), val
);
14351 size_t maxlen
= (end
- p
) - 1;
14353 print_symbol ((int) maxlen
, (const char *) p
);
14354 p
+= strnlen ((char *) p
, maxlen
) + 1;
14358 printf (_("<corrupt>"));
14359 p
= (unsigned char *) end
;
14365 case Tag_ABI_conformance
:
14367 printf (" Tag_ABI_conformance: \"");
14370 size_t maxlen
= (end
- p
) - 1;
14372 print_symbol ((int) maxlen
, (const char *) p
);
14373 p
+= strnlen ((char *) p
, maxlen
) + 1;
14377 printf (_("<corrupt>"));
14378 p
= (unsigned char *) end
;
14385 return display_tag_value (tag
, p
, end
);
14389 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14391 unsigned long addr
= 0;
14392 size_t bytes
= end
- p
;
14399 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14401 printf (" 0x%8.8lx ", addr
);
14403 for (j
= 0; j
< 16; j
++)
14406 printf ("%2.2x", p
[j
]);
14414 for (j
= 0; j
< lbytes
; j
++)
14417 if (k
>= ' ' && k
< 0x7f)
14433 static unsigned char *
14434 display_msp430x_attribute (unsigned char * p
,
14435 const unsigned char * const end
)
14441 tag
= read_uleb128 (p
, & len
, end
);
14446 case OFBA_MSPABI_Tag_ISA
:
14447 val
= read_uleb128 (p
, &len
, end
);
14449 printf (" Tag_ISA: ");
14452 case 0: printf (_("None\n")); break;
14453 case 1: printf (_("MSP430\n")); break;
14454 case 2: printf (_("MSP430X\n")); break;
14455 default: printf ("??? (%d)\n", val
); break;
14459 case OFBA_MSPABI_Tag_Code_Model
:
14460 val
= read_uleb128 (p
, &len
, end
);
14462 printf (" Tag_Code_Model: ");
14465 case 0: printf (_("None\n")); break;
14466 case 1: printf (_("Small\n")); break;
14467 case 2: printf (_("Large\n")); break;
14468 default: printf ("??? (%d)\n", val
); break;
14472 case OFBA_MSPABI_Tag_Data_Model
:
14473 val
= read_uleb128 (p
, &len
, end
);
14475 printf (" Tag_Data_Model: ");
14478 case 0: printf (_("None\n")); break;
14479 case 1: printf (_("Small\n")); break;
14480 case 2: printf (_("Large\n")); break;
14481 case 3: printf (_("Restricted Large\n")); break;
14482 default: printf ("??? (%d)\n", val
); break;
14487 printf (_(" <unknown tag %d>: "), tag
);
14494 size_t maxlen
= (end
- p
) - 1;
14496 print_symbol ((int) maxlen
, (const char *) p
);
14497 p
+= strnlen ((char *) p
, maxlen
) + 1;
14501 printf (_("<corrupt>"));
14502 p
= (unsigned char *) end
;
14508 val
= read_uleb128 (p
, &len
, end
);
14510 printf ("%d (0x%x)\n", val
, val
);
14520 process_attributes (FILE * file
,
14521 const char * public_name
,
14522 unsigned int proc_type
,
14523 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14524 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14526 Elf_Internal_Shdr
* sect
;
14528 bfd_boolean res
= TRUE
;
14530 /* Find the section header so that we get the size. */
14531 for (i
= 0, sect
= section_headers
;
14532 i
< elf_header
.e_shnum
;
14535 unsigned char * contents
;
14538 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14541 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14542 sect
->sh_size
, _("attributes"));
14543 if (contents
== NULL
)
14550 /* The first character is the version of the attributes.
14551 Currently only version 1, (aka 'A') is recognised here. */
14554 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14559 bfd_vma section_len
;
14561 section_len
= sect
->sh_size
- 1;
14564 while (section_len
> 0)
14567 unsigned int namelen
;
14568 bfd_boolean public_section
;
14569 bfd_boolean gnu_section
;
14571 if (section_len
<= 4)
14573 error (_("Tag section ends prematurely\n"));
14577 attr_len
= byte_get (p
, 4);
14580 if (attr_len
> section_len
)
14582 error (_("Bad attribute length (%u > %u)\n"),
14583 (unsigned) attr_len
, (unsigned) section_len
);
14584 attr_len
= section_len
;
14587 /* PR 17531: file: 001-101425-0.004 */
14588 else if (attr_len
< 5)
14590 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14595 section_len
-= attr_len
;
14598 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14599 if (namelen
== 0 || namelen
>= attr_len
)
14601 error (_("Corrupt attribute section name\n"));
14606 printf (_("Attribute Section: "));
14607 print_symbol (INT_MAX
, (const char *) p
);
14610 if (public_name
&& streq ((char *) p
, public_name
))
14611 public_section
= TRUE
;
14613 public_section
= FALSE
;
14615 if (streq ((char *) p
, "gnu"))
14616 gnu_section
= TRUE
;
14618 gnu_section
= FALSE
;
14621 attr_len
-= namelen
;
14623 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14628 unsigned char * end
;
14630 /* PR binutils/17531: Safe handling of corrupt files. */
14633 error (_("Unused bytes at end of section\n"));
14640 size
= byte_get (p
, 4);
14641 if (size
> attr_len
)
14643 error (_("Bad subsection length (%u > %u)\n"),
14644 (unsigned) size
, (unsigned) attr_len
);
14648 /* PR binutils/17531: Safe handling of corrupt files. */
14651 error (_("Bad subsection length (%u < 6)\n"),
14659 end
= p
+ size
- 1;
14660 assert (end
<= contents
+ sect
->sh_size
);
14666 printf (_("File Attributes\n"));
14669 printf (_("Section Attributes:"));
14672 printf (_("Symbol Attributes:"));
14673 /* Fall through. */
14679 val
= read_uleb128 (p
, &j
, end
);
14683 printf (" %d", val
);
14688 printf (_("Unknown tag: %d\n"), tag
);
14689 public_section
= FALSE
;
14693 if (public_section
&& display_pub_attribute
!= NULL
)
14696 p
= display_pub_attribute (p
, end
);
14699 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14702 p
= display_gnu_attribute (p
,
14703 display_proc_gnu_attribute
,
14709 printf (_(" Unknown attribute:\n"));
14710 display_raw_attribute (p
, end
);
14725 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14726 Print the Address, Access and Initial fields of an entry at VMA ADDR
14727 and return the VMA of the next entry, or -1 if there was a problem.
14728 Does not read from DATA_END or beyond. */
14731 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14732 unsigned char * data_end
)
14735 print_vma (addr
, LONG_HEX
);
14737 if (addr
< pltgot
+ 0xfff0)
14738 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14740 printf ("%10s", "");
14743 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14747 unsigned char * from
= data
+ addr
- pltgot
;
14749 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14751 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14752 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14753 return (bfd_vma
) -1;
14757 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14758 print_vma (entry
, LONG_HEX
);
14761 return addr
+ (is_32bit_elf
? 4 : 8);
14764 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14765 PLTGOT. Print the Address and Initial fields of an entry at VMA
14766 ADDR and return the VMA of the next entry. */
14769 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14772 print_vma (addr
, LONG_HEX
);
14775 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14780 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14781 print_vma (entry
, LONG_HEX
);
14783 return addr
+ (is_32bit_elf
? 4 : 8);
14787 print_mips_ases (unsigned int mask
)
14789 if (mask
& AFL_ASE_DSP
)
14790 fputs ("\n\tDSP ASE", stdout
);
14791 if (mask
& AFL_ASE_DSPR2
)
14792 fputs ("\n\tDSP R2 ASE", stdout
);
14793 if (mask
& AFL_ASE_DSPR3
)
14794 fputs ("\n\tDSP R3 ASE", stdout
);
14795 if (mask
& AFL_ASE_EVA
)
14796 fputs ("\n\tEnhanced VA Scheme", stdout
);
14797 if (mask
& AFL_ASE_MCU
)
14798 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14799 if (mask
& AFL_ASE_MDMX
)
14800 fputs ("\n\tMDMX ASE", stdout
);
14801 if (mask
& AFL_ASE_MIPS3D
)
14802 fputs ("\n\tMIPS-3D ASE", stdout
);
14803 if (mask
& AFL_ASE_MT
)
14804 fputs ("\n\tMT ASE", stdout
);
14805 if (mask
& AFL_ASE_SMARTMIPS
)
14806 fputs ("\n\tSmartMIPS ASE", stdout
);
14807 if (mask
& AFL_ASE_VIRT
)
14808 fputs ("\n\tVZ ASE", stdout
);
14809 if (mask
& AFL_ASE_MSA
)
14810 fputs ("\n\tMSA ASE", stdout
);
14811 if (mask
& AFL_ASE_MIPS16
)
14812 fputs ("\n\tMIPS16 ASE", stdout
);
14813 if (mask
& AFL_ASE_MICROMIPS
)
14814 fputs ("\n\tMICROMIPS ASE", stdout
);
14815 if (mask
& AFL_ASE_XPA
)
14816 fputs ("\n\tXPA ASE", stdout
);
14818 fprintf (stdout
, "\n\t%s", _("None"));
14819 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14820 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14824 print_mips_isa_ext (unsigned int isa_ext
)
14829 fputs (_("None"), stdout
);
14832 fputs ("RMI XLR", stdout
);
14834 case AFL_EXT_OCTEON3
:
14835 fputs ("Cavium Networks Octeon3", stdout
);
14837 case AFL_EXT_OCTEON2
:
14838 fputs ("Cavium Networks Octeon2", stdout
);
14840 case AFL_EXT_OCTEONP
:
14841 fputs ("Cavium Networks OcteonP", stdout
);
14843 case AFL_EXT_LOONGSON_3A
:
14844 fputs ("Loongson 3A", stdout
);
14846 case AFL_EXT_OCTEON
:
14847 fputs ("Cavium Networks Octeon", stdout
);
14850 fputs ("Toshiba R5900", stdout
);
14853 fputs ("MIPS R4650", stdout
);
14856 fputs ("LSI R4010", stdout
);
14859 fputs ("NEC VR4100", stdout
);
14862 fputs ("Toshiba R3900", stdout
);
14864 case AFL_EXT_10000
:
14865 fputs ("MIPS R10000", stdout
);
14868 fputs ("Broadcom SB-1", stdout
);
14871 fputs ("NEC VR4111/VR4181", stdout
);
14874 fputs ("NEC VR4120", stdout
);
14877 fputs ("NEC VR5400", stdout
);
14880 fputs ("NEC VR5500", stdout
);
14882 case AFL_EXT_LOONGSON_2E
:
14883 fputs ("ST Microelectronics Loongson 2E", stdout
);
14885 case AFL_EXT_LOONGSON_2F
:
14886 fputs ("ST Microelectronics Loongson 2F", stdout
);
14889 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14894 get_mips_reg_size (int reg_size
)
14896 return (reg_size
== AFL_REG_NONE
) ? 0
14897 : (reg_size
== AFL_REG_32
) ? 32
14898 : (reg_size
== AFL_REG_64
) ? 64
14899 : (reg_size
== AFL_REG_128
) ? 128
14904 process_mips_specific (FILE * file
)
14906 Elf_Internal_Dyn
* entry
;
14907 Elf_Internal_Shdr
*sect
= NULL
;
14908 size_t liblist_offset
= 0;
14909 size_t liblistno
= 0;
14910 size_t conflictsno
= 0;
14911 size_t options_offset
= 0;
14912 size_t conflicts_offset
= 0;
14913 size_t pltrelsz
= 0;
14915 bfd_vma pltgot
= 0;
14916 bfd_vma mips_pltgot
= 0;
14917 bfd_vma jmprel
= 0;
14918 bfd_vma local_gotno
= 0;
14919 bfd_vma gotsym
= 0;
14920 bfd_vma symtabno
= 0;
14921 bfd_boolean res
= TRUE
;
14923 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14924 display_mips_gnu_attribute
))
14927 sect
= find_section (".MIPS.abiflags");
14931 Elf_External_ABIFlags_v0
*abiflags_ext
;
14932 Elf_Internal_ABIFlags_v0 abiflags_in
;
14934 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14936 error (_("Corrupt MIPS ABI Flags section.\n"));
14941 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14942 sect
->sh_size
, _("MIPS ABI Flags section"));
14945 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14946 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14947 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14948 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14949 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14950 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14951 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14952 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14953 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14954 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14955 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14957 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14958 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14959 if (abiflags_in
.isa_rev
> 1)
14960 printf ("r%d", abiflags_in
.isa_rev
);
14961 printf ("\nGPR size: %d",
14962 get_mips_reg_size (abiflags_in
.gpr_size
));
14963 printf ("\nCPR1 size: %d",
14964 get_mips_reg_size (abiflags_in
.cpr1_size
));
14965 printf ("\nCPR2 size: %d",
14966 get_mips_reg_size (abiflags_in
.cpr2_size
));
14967 fputs ("\nFP ABI: ", stdout
);
14968 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14969 fputs ("ISA Extension: ", stdout
);
14970 print_mips_isa_ext (abiflags_in
.isa_ext
);
14971 fputs ("\nASEs:", stdout
);
14972 print_mips_ases (abiflags_in
.ases
);
14973 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14974 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14975 fputc ('\n', stdout
);
14976 free (abiflags_ext
);
14981 /* We have a lot of special sections. Thanks SGI! */
14982 if (dynamic_section
== NULL
)
14983 /* No information available. */
14986 for (entry
= dynamic_section
;
14987 /* PR 17531 file: 012-50589-0.004. */
14988 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14990 switch (entry
->d_tag
)
14992 case DT_MIPS_LIBLIST
:
14994 = offset_from_vma (file
, entry
->d_un
.d_val
,
14995 liblistno
* sizeof (Elf32_External_Lib
));
14997 case DT_MIPS_LIBLISTNO
:
14998 liblistno
= entry
->d_un
.d_val
;
15000 case DT_MIPS_OPTIONS
:
15001 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15003 case DT_MIPS_CONFLICT
:
15005 = offset_from_vma (file
, entry
->d_un
.d_val
,
15006 conflictsno
* sizeof (Elf32_External_Conflict
));
15008 case DT_MIPS_CONFLICTNO
:
15009 conflictsno
= entry
->d_un
.d_val
;
15012 pltgot
= entry
->d_un
.d_ptr
;
15014 case DT_MIPS_LOCAL_GOTNO
:
15015 local_gotno
= entry
->d_un
.d_val
;
15017 case DT_MIPS_GOTSYM
:
15018 gotsym
= entry
->d_un
.d_val
;
15020 case DT_MIPS_SYMTABNO
:
15021 symtabno
= entry
->d_un
.d_val
;
15023 case DT_MIPS_PLTGOT
:
15024 mips_pltgot
= entry
->d_un
.d_ptr
;
15027 pltrel
= entry
->d_un
.d_val
;
15030 pltrelsz
= entry
->d_un
.d_val
;
15033 jmprel
= entry
->d_un
.d_ptr
;
15039 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15041 Elf32_External_Lib
* elib
;
15044 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15046 sizeof (Elf32_External_Lib
),
15047 _("liblist section data"));
15050 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15051 (unsigned long) liblistno
);
15052 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15055 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15062 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15063 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15064 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15065 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15066 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15068 tmp
= gmtime (&atime
);
15069 snprintf (timebuf
, sizeof (timebuf
),
15070 "%04u-%02u-%02uT%02u:%02u:%02u",
15071 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15072 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15074 printf ("%3lu: ", (unsigned long) cnt
);
15075 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15076 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15078 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15079 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15080 liblist
.l_version
);
15082 if (liblist
.l_flags
== 0)
15086 static const struct
15093 { " EXACT_MATCH", LL_EXACT_MATCH
},
15094 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15095 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15096 { " EXPORTS", LL_EXPORTS
},
15097 { " DELAY_LOAD", LL_DELAY_LOAD
},
15098 { " DELTA", LL_DELTA
}
15100 int flags
= liblist
.l_flags
;
15103 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15104 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15106 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15107 flags
^= l_flags_vals
[fcnt
].bit
;
15110 printf (" %#x", (unsigned int) flags
);
15122 if (options_offset
!= 0)
15124 Elf_External_Options
* eopt
;
15125 Elf_Internal_Options
* iopt
;
15126 Elf_Internal_Options
* option
;
15129 sect
= section_headers
;
15131 /* Find the section header so that we get the size. */
15132 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15133 /* PR 17533 file: 012-277276-0.004. */
15136 error (_("No MIPS_OPTIONS header found\n"));
15140 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15141 sect
->sh_size
, _("options"));
15144 iopt
= (Elf_Internal_Options
*)
15145 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15148 error (_("Out of memory allocating space for MIPS options\n"));
15155 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15157 Elf_External_Options
* eoption
;
15159 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15161 option
->kind
= BYTE_GET (eoption
->kind
);
15162 option
->size
= BYTE_GET (eoption
->size
);
15163 option
->section
= BYTE_GET (eoption
->section
);
15164 option
->info
= BYTE_GET (eoption
->info
);
15166 /* PR 17531: file: ffa0fa3b. */
15167 if (option
->size
< sizeof (* eopt
)
15168 || offset
+ option
->size
> sect
->sh_size
)
15170 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15173 offset
+= option
->size
;
15179 printf (_("\nSection '%s' contains %d entries:\n"),
15180 printable_section_name (sect
), cnt
);
15189 switch (option
->kind
)
15192 /* This shouldn't happen. */
15193 printf (" NULL %d %lx", option
->section
, option
->info
);
15196 printf (" REGINFO ");
15197 if (elf_header
.e_machine
== EM_MIPS
)
15200 Elf32_External_RegInfo
* ereg
;
15201 Elf32_RegInfo reginfo
;
15203 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15204 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15205 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15206 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15207 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15208 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15209 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15211 printf ("GPR %08lx GP 0x%lx\n",
15212 reginfo
.ri_gprmask
,
15213 (unsigned long) reginfo
.ri_gp_value
);
15214 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15215 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15216 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15221 Elf64_External_RegInfo
* ereg
;
15222 Elf64_Internal_RegInfo reginfo
;
15224 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15225 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15226 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15227 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15228 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15229 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15230 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15232 printf ("GPR %08lx GP 0x",
15233 reginfo
.ri_gprmask
);
15234 printf_vma (reginfo
.ri_gp_value
);
15237 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15238 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15239 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15243 case ODK_EXCEPTIONS
:
15244 fputs (" EXCEPTIONS fpe_min(", stdout
);
15245 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15246 fputs (") fpe_max(", stdout
);
15247 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15248 fputs (")", stdout
);
15250 if (option
->info
& OEX_PAGE0
)
15251 fputs (" PAGE0", stdout
);
15252 if (option
->info
& OEX_SMM
)
15253 fputs (" SMM", stdout
);
15254 if (option
->info
& OEX_FPDBUG
)
15255 fputs (" FPDBUG", stdout
);
15256 if (option
->info
& OEX_DISMISS
)
15257 fputs (" DISMISS", stdout
);
15260 fputs (" PAD ", stdout
);
15261 if (option
->info
& OPAD_PREFIX
)
15262 fputs (" PREFIX", stdout
);
15263 if (option
->info
& OPAD_POSTFIX
)
15264 fputs (" POSTFIX", stdout
);
15265 if (option
->info
& OPAD_SYMBOL
)
15266 fputs (" SYMBOL", stdout
);
15269 fputs (" HWPATCH ", stdout
);
15270 if (option
->info
& OHW_R4KEOP
)
15271 fputs (" R4KEOP", stdout
);
15272 if (option
->info
& OHW_R8KPFETCH
)
15273 fputs (" R8KPFETCH", stdout
);
15274 if (option
->info
& OHW_R5KEOP
)
15275 fputs (" R5KEOP", stdout
);
15276 if (option
->info
& OHW_R5KCVTL
)
15277 fputs (" R5KCVTL", stdout
);
15280 fputs (" FILL ", stdout
);
15281 /* XXX Print content of info word? */
15284 fputs (" TAGS ", stdout
);
15285 /* XXX Print content of info word? */
15288 fputs (" HWAND ", stdout
);
15289 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15290 fputs (" R4KEOP_CHECKED", stdout
);
15291 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15292 fputs (" R4KEOP_CLEAN", stdout
);
15295 fputs (" HWOR ", stdout
);
15296 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15297 fputs (" R4KEOP_CHECKED", stdout
);
15298 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15299 fputs (" R4KEOP_CLEAN", stdout
);
15302 printf (" GP_GROUP %#06lx self-contained %#06lx",
15303 option
->info
& OGP_GROUP
,
15304 (option
->info
& OGP_SELF
) >> 16);
15307 printf (" IDENT %#06lx self-contained %#06lx",
15308 option
->info
& OGP_GROUP
,
15309 (option
->info
& OGP_SELF
) >> 16);
15312 /* This shouldn't happen. */
15313 printf (" %3d ??? %d %lx",
15314 option
->kind
, option
->section
, option
->info
);
15318 len
= sizeof (* eopt
);
15319 while (len
< option
->size
)
15321 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15323 if (ISPRINT (datum
))
15324 printf ("%c", datum
);
15326 printf ("\\%03o", datum
);
15329 fputs ("\n", stdout
);
15331 offset
+= option
->size
;
15341 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15343 Elf32_Conflict
* iconf
;
15346 if (dynamic_symbols
== NULL
)
15348 error (_("conflict list found without a dynamic symbol table\n"));
15352 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15355 error (_("Out of memory allocating space for dynamic conflicts\n"));
15361 Elf32_External_Conflict
* econf32
;
15363 econf32
= (Elf32_External_Conflict
*)
15364 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15365 sizeof (* econf32
), _("conflict"));
15369 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15370 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15376 Elf64_External_Conflict
* econf64
;
15378 econf64
= (Elf64_External_Conflict
*)
15379 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15380 sizeof (* econf64
), _("conflict"));
15384 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15385 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15390 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15391 (unsigned long) conflictsno
);
15392 puts (_(" Num: Index Value Name"));
15394 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15396 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15398 if (iconf
[cnt
] >= num_dynamic_syms
)
15399 printf (_("<corrupt symbol index>"));
15402 Elf_Internal_Sym
* psym
;
15404 psym
= & dynamic_symbols
[iconf
[cnt
]];
15405 print_vma (psym
->st_value
, FULL_HEX
);
15407 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15408 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15410 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15418 if (pltgot
!= 0 && local_gotno
!= 0)
15420 bfd_vma ent
, local_end
, global_end
;
15422 unsigned char * data
;
15423 unsigned char * data_end
;
15427 addr_size
= (is_32bit_elf
? 4 : 8);
15428 local_end
= pltgot
+ local_gotno
* addr_size
;
15430 /* PR binutils/17533 file: 012-111227-0.004 */
15431 if (symtabno
< gotsym
)
15433 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15434 (unsigned long) gotsym
, (unsigned long) symtabno
);
15438 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15439 /* PR 17531: file: 54c91a34. */
15440 if (global_end
< local_end
)
15442 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15446 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15447 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15448 global_end
- pltgot
, 1,
15449 _("Global Offset Table data"));
15452 data_end
= data
+ (global_end
- pltgot
);
15454 printf (_("\nPrimary GOT:\n"));
15455 printf (_(" Canonical gp value: "));
15456 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15459 printf (_(" Reserved entries:\n"));
15460 printf (_(" %*s %10s %*s Purpose\n"),
15461 addr_size
* 2, _("Address"), _("Access"),
15462 addr_size
* 2, _("Initial"));
15463 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15464 printf (_(" Lazy resolver\n"));
15465 if (ent
== (bfd_vma
) -1)
15466 goto got_print_fail
;
15468 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15469 >> (addr_size
* 8 - 1)) != 0)
15471 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15472 printf (_(" Module pointer (GNU extension)\n"));
15473 if (ent
== (bfd_vma
) -1)
15474 goto got_print_fail
;
15478 if (ent
< local_end
)
15480 printf (_(" Local entries:\n"));
15481 printf (" %*s %10s %*s\n",
15482 addr_size
* 2, _("Address"), _("Access"),
15483 addr_size
* 2, _("Initial"));
15484 while (ent
< local_end
)
15486 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15488 if (ent
== (bfd_vma
) -1)
15489 goto got_print_fail
;
15494 if (gotsym
< symtabno
)
15498 printf (_(" Global entries:\n"));
15499 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15500 addr_size
* 2, _("Address"),
15502 addr_size
* 2, _("Initial"),
15503 addr_size
* 2, _("Sym.Val."),
15505 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15506 _("Ndx"), _("Name"));
15508 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15510 for (i
= gotsym
; i
< symtabno
; i
++)
15512 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15515 if (dynamic_symbols
== NULL
)
15516 printf (_("<no dynamic symbols>"));
15517 else if (i
< num_dynamic_syms
)
15519 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15521 print_vma (psym
->st_value
, LONG_HEX
);
15522 printf (" %-7s %3s ",
15523 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15524 get_symbol_index_type (psym
->st_shndx
));
15526 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15527 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15529 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15532 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15533 (unsigned long) i
);
15536 if (ent
== (bfd_vma
) -1)
15547 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15550 size_t offset
, rel_offset
;
15551 unsigned long count
, i
;
15552 unsigned char * data
;
15553 int addr_size
, sym_width
;
15554 Elf_Internal_Rela
* rels
;
15556 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15557 if (pltrel
== DT_RELA
)
15559 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15564 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15569 addr_size
= (is_32bit_elf
? 4 : 8);
15570 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15572 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15573 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15574 1, _("Procedure Linkage Table data"));
15578 printf ("\nPLT GOT:\n\n");
15579 printf (_(" Reserved entries:\n"));
15580 printf (_(" %*s %*s Purpose\n"),
15581 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15582 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15583 printf (_(" PLT lazy resolver\n"));
15584 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15585 printf (_(" Module pointer\n"));
15588 printf (_(" Entries:\n"));
15589 printf (" %*s %*s %*s %-7s %3s %s\n",
15590 addr_size
* 2, _("Address"),
15591 addr_size
* 2, _("Initial"),
15592 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15593 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15594 for (i
= 0; i
< count
; i
++)
15596 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15598 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15601 if (idx
>= num_dynamic_syms
)
15602 printf (_("<corrupt symbol index: %lu>"), idx
);
15605 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15607 print_vma (psym
->st_value
, LONG_HEX
);
15608 printf (" %-7s %3s ",
15609 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15610 get_symbol_index_type (psym
->st_shndx
));
15611 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15612 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15614 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15629 process_nds32_specific (FILE * file
)
15631 Elf_Internal_Shdr
*sect
= NULL
;
15633 sect
= find_section (".nds32_e_flags");
15636 unsigned int *flag
;
15638 printf ("\nNDS32 elf flags section:\n");
15639 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15640 sect
->sh_size
, _("NDS32 elf flags section"));
15645 switch ((*flag
) & 0x3)
15648 printf ("(VEC_SIZE):\tNo entry.\n");
15651 printf ("(VEC_SIZE):\t4 bytes\n");
15654 printf ("(VEC_SIZE):\t16 bytes\n");
15657 printf ("(VEC_SIZE):\treserved\n");
15666 process_gnu_liblist (FILE * file
)
15668 Elf_Internal_Shdr
* section
;
15669 Elf_Internal_Shdr
* string_sec
;
15670 Elf32_External_Lib
* elib
;
15672 size_t strtab_size
;
15675 bfd_boolean res
= TRUE
;
15680 for (i
= 0, section
= section_headers
;
15681 i
< elf_header
.e_shnum
;
15684 switch (section
->sh_type
)
15686 case SHT_GNU_LIBLIST
:
15687 if (section
->sh_link
>= elf_header
.e_shnum
)
15690 elib
= (Elf32_External_Lib
*)
15691 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15692 _("liblist section data"));
15700 string_sec
= section_headers
+ section
->sh_link
;
15701 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15702 string_sec
->sh_size
,
15703 _("liblist string table"));
15705 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15712 strtab_size
= string_sec
->sh_size
;
15714 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15715 printable_section_name (section
),
15716 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15718 puts (_(" Library Time Stamp Checksum Version Flags"));
15720 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15728 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15729 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15730 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15731 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15732 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15734 tmp
= gmtime (&atime
);
15735 snprintf (timebuf
, sizeof (timebuf
),
15736 "%04u-%02u-%02uT%02u:%02u:%02u",
15737 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15738 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15740 printf ("%3lu: ", (unsigned long) cnt
);
15742 printf ("%-20s", liblist
.l_name
< strtab_size
15743 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15745 printf ("%-20.20s", liblist
.l_name
< strtab_size
15746 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15747 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15748 liblist
.l_version
, liblist
.l_flags
);
15759 static const char *
15760 get_note_type (unsigned e_type
)
15762 static char buff
[64];
15764 if (elf_header
.e_type
== ET_CORE
)
15768 return _("NT_AUXV (auxiliary vector)");
15770 return _("NT_PRSTATUS (prstatus structure)");
15772 return _("NT_FPREGSET (floating point registers)");
15774 return _("NT_PRPSINFO (prpsinfo structure)");
15775 case NT_TASKSTRUCT
:
15776 return _("NT_TASKSTRUCT (task structure)");
15778 return _("NT_PRXFPREG (user_xfpregs structure)");
15780 return _("NT_PPC_VMX (ppc Altivec registers)");
15782 return _("NT_PPC_VSX (ppc VSX registers)");
15784 return _("NT_386_TLS (x86 TLS information)");
15785 case NT_386_IOPERM
:
15786 return _("NT_386_IOPERM (x86 I/O permissions)");
15787 case NT_X86_XSTATE
:
15788 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15789 case NT_S390_HIGH_GPRS
:
15790 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15791 case NT_S390_TIMER
:
15792 return _("NT_S390_TIMER (s390 timer register)");
15793 case NT_S390_TODCMP
:
15794 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15795 case NT_S390_TODPREG
:
15796 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15798 return _("NT_S390_CTRS (s390 control registers)");
15799 case NT_S390_PREFIX
:
15800 return _("NT_S390_PREFIX (s390 prefix register)");
15801 case NT_S390_LAST_BREAK
:
15802 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15803 case NT_S390_SYSTEM_CALL
:
15804 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15806 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15807 case NT_S390_VXRS_LOW
:
15808 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15809 case NT_S390_VXRS_HIGH
:
15810 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15812 return _("NT_ARM_VFP (arm VFP registers)");
15814 return _("NT_ARM_TLS (AArch TLS registers)");
15815 case NT_ARM_HW_BREAK
:
15816 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15817 case NT_ARM_HW_WATCH
:
15818 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15820 return _("NT_PSTATUS (pstatus structure)");
15822 return _("NT_FPREGS (floating point registers)");
15824 return _("NT_PSINFO (psinfo structure)");
15826 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15828 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15829 case NT_WIN32PSTATUS
:
15830 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15832 return _("NT_SIGINFO (siginfo_t data)");
15834 return _("NT_FILE (mapped files)");
15842 return _("NT_VERSION (version)");
15844 return _("NT_ARCH (architecture)");
15845 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
15846 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15847 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
15848 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15853 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15858 print_core_note (Elf_Internal_Note
*pnote
)
15860 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15861 bfd_vma count
, page_size
;
15862 unsigned char *descdata
, *filenames
, *descend
;
15864 if (pnote
->type
!= NT_FILE
)
15870 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15871 /* Still "successful". */
15876 if (pnote
->descsz
< 2 * addr_size
)
15878 error (_(" Malformed note - too short for header\n"));
15882 descdata
= (unsigned char *) pnote
->descdata
;
15883 descend
= descdata
+ pnote
->descsz
;
15885 if (descdata
[pnote
->descsz
- 1] != '\0')
15887 error (_(" Malformed note - does not end with \\0\n"));
15891 count
= byte_get (descdata
, addr_size
);
15892 descdata
+= addr_size
;
15894 page_size
= byte_get (descdata
, addr_size
);
15895 descdata
+= addr_size
;
15897 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15899 error (_(" Malformed note - too short for supplied file count\n"));
15903 printf (_(" Page size: "));
15904 print_vma (page_size
, DEC
);
15907 printf (_(" %*s%*s%*s\n"),
15908 (int) (2 + 2 * addr_size
), _("Start"),
15909 (int) (4 + 2 * addr_size
), _("End"),
15910 (int) (4 + 2 * addr_size
), _("Page Offset"));
15911 filenames
= descdata
+ count
* 3 * addr_size
;
15912 while (count
-- > 0)
15914 bfd_vma start
, end
, file_ofs
;
15916 if (filenames
== descend
)
15918 error (_(" Malformed note - filenames end too early\n"));
15922 start
= byte_get (descdata
, addr_size
);
15923 descdata
+= addr_size
;
15924 end
= byte_get (descdata
, addr_size
);
15925 descdata
+= addr_size
;
15926 file_ofs
= byte_get (descdata
, addr_size
);
15927 descdata
+= addr_size
;
15930 print_vma (start
, FULL_HEX
);
15932 print_vma (end
, FULL_HEX
);
15934 print_vma (file_ofs
, FULL_HEX
);
15935 printf ("\n %s\n", filenames
);
15937 filenames
+= 1 + strlen ((char *) filenames
);
15943 static const char *
15944 get_gnu_elf_note_type (unsigned e_type
)
15946 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15949 case NT_GNU_ABI_TAG
:
15950 return _("NT_GNU_ABI_TAG (ABI version tag)");
15952 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15953 case NT_GNU_BUILD_ID
:
15954 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15955 case NT_GNU_GOLD_VERSION
:
15956 return _("NT_GNU_GOLD_VERSION (gold version)");
15957 case NT_GNU_PROPERTY_TYPE_0
:
15958 return _("NT_GNU_PROPERTY_TYPE_0");
15959 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
15960 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15961 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
15962 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15965 static char buff
[64];
15967 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15974 decode_x86_isa (unsigned int bitmask
)
15978 unsigned int bit
= bitmask
& (- bitmask
);
15983 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
15984 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
15985 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
15986 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
15987 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
15988 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
15989 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
15990 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
15991 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
15992 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
15993 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
15994 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
15995 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
15996 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
15997 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
15998 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
15999 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16000 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16001 default: printf (_("<unknown: %x>"), bit
); break;
16009 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16011 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16012 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16013 unsigned int size
= is_32bit_elf
? 4 : 8;
16015 printf (_(" Properties: "));
16017 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16019 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16026 unsigned int type
= byte_get (ptr
, 4);
16027 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16031 if ((ptr
+ datasz
) > ptr_end
)
16033 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16038 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16040 if (elf_header
.e_machine
== EM_X86_64
16041 || elf_header
.e_machine
== EM_IAMCU
16042 || elf_header
.e_machine
== EM_386
)
16046 case GNU_PROPERTY_X86_ISA_1_USED
:
16047 printf ("x86 ISA used: ");
16049 printf (_("<corrupt length: %#x> "), datasz
);
16051 decode_x86_isa (byte_get (ptr
, 4));
16054 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16055 printf ("x86 ISA needed: ");
16057 printf (_("<corrupt length: %#x> "), datasz
);
16059 decode_x86_isa (byte_get (ptr
, 4));
16071 case GNU_PROPERTY_STACK_SIZE
:
16072 printf (_("stack size: "));
16073 if (datasz
!= size
)
16074 printf (_("<corrupt length: %#x> "), datasz
);
16076 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16079 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16080 printf ("no copy on protected ");
16082 printf (_("<corrupt length: %#x> "), datasz
);
16090 if (type
< GNU_PROPERTY_LOPROC
)
16091 printf (_("<unknown type %#x data: "), type
);
16092 else if (type
< GNU_PROPERTY_LOUSER
)
16093 printf (_("<procesor-specific type %#x data: "), type
);
16095 printf (_("<application-specific type %#x data: "), type
);
16096 for (j
= 0; j
< datasz
; ++j
)
16097 printf ("%02x ", ptr
[j
] & 0xff);
16101 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16102 if (ptr
== ptr_end
)
16112 if (ptr
> (ptr_end
- 8))
16114 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16123 print_gnu_note (Elf_Internal_Note
*pnote
)
16125 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16126 switch (pnote
->type
)
16128 case NT_GNU_BUILD_ID
:
16132 printf (_(" Build ID: "));
16133 for (i
= 0; i
< pnote
->descsz
; ++i
)
16134 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16139 case NT_GNU_ABI_TAG
:
16141 unsigned long os
, major
, minor
, subminor
;
16142 const char *osname
;
16144 /* PR 17531: file: 030-599401-0.004. */
16145 if (pnote
->descsz
< 16)
16147 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16151 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16152 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16153 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16154 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16158 case GNU_ABI_TAG_LINUX
:
16161 case GNU_ABI_TAG_HURD
:
16164 case GNU_ABI_TAG_SOLARIS
:
16165 osname
= "Solaris";
16167 case GNU_ABI_TAG_FREEBSD
:
16168 osname
= "FreeBSD";
16170 case GNU_ABI_TAG_NETBSD
:
16173 case GNU_ABI_TAG_SYLLABLE
:
16174 osname
= "Syllable";
16176 case GNU_ABI_TAG_NACL
:
16180 osname
= "Unknown";
16184 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16185 major
, minor
, subminor
);
16189 case NT_GNU_GOLD_VERSION
:
16193 printf (_(" Version: "));
16194 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16195 printf ("%c", pnote
->descdata
[i
]);
16202 unsigned long num_entries
, mask
;
16204 /* Hardware capabilities information. Word 0 is the number of entries.
16205 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16206 is a series of entries, where each entry is a single byte followed
16207 by a nul terminated string. The byte gives the bit number to test
16208 if enabled in the bitmask. */
16209 printf (_(" Hardware Capabilities: "));
16210 if (pnote
->descsz
< 8)
16212 error (_("<corrupt GNU_HWCAP>\n"));
16215 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16216 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16217 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16218 /* FIXME: Add code to display the entries... */
16222 case NT_GNU_PROPERTY_TYPE_0
:
16223 print_gnu_property_note (pnote
);
16227 /* Handle unrecognised types. An error message should have already been
16228 created by get_gnu_elf_note_type(), so all that we need to do is to
16229 display the data. */
16233 printf (_(" Description data: "));
16234 for (i
= 0; i
< pnote
->descsz
; ++i
)
16235 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16244 static const char *
16245 get_v850_elf_note_type (enum v850_notes n_type
)
16247 static char buff
[64];
16251 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16252 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16253 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16254 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16255 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16256 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16258 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16264 print_v850_note (Elf_Internal_Note
* pnote
)
16268 if (pnote
->descsz
!= 4)
16271 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16275 printf (_("not set\n"));
16279 switch (pnote
->type
)
16281 case V850_NOTE_ALIGNMENT
:
16284 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16285 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16289 case V850_NOTE_DATA_SIZE
:
16292 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16293 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16297 case V850_NOTE_FPU_INFO
:
16300 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16301 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16305 case V850_NOTE_MMU_INFO
:
16306 case V850_NOTE_CACHE_INFO
:
16307 case V850_NOTE_SIMD_INFO
:
16308 if (val
== EF_RH850_SIMD
)
16310 printf (_("yes\n"));
16316 /* An 'unknown note type' message will already have been displayed. */
16320 printf (_("unknown value: %x\n"), val
);
16325 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16327 unsigned int version
;
16329 switch (pnote
->type
)
16331 case NT_NETBSD_IDENT
:
16332 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16333 if ((version
/ 10000) % 100)
16334 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16335 version
, version
/ 100000000, (version
/ 1000000) % 100,
16336 (version
/ 10000) % 100 > 26 ? "Z" : "",
16337 'A' + (version
/ 10000) % 26);
16339 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16340 version
, version
/ 100000000, (version
/ 1000000) % 100,
16341 (version
/ 100) % 100);
16344 case NT_NETBSD_MARCH
:
16345 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16350 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16356 static const char *
16357 get_freebsd_elfcore_note_type (unsigned e_type
)
16361 case NT_FREEBSD_THRMISC
:
16362 return _("NT_THRMISC (thrmisc structure)");
16363 case NT_FREEBSD_PROCSTAT_PROC
:
16364 return _("NT_PROCSTAT_PROC (proc data)");
16365 case NT_FREEBSD_PROCSTAT_FILES
:
16366 return _("NT_PROCSTAT_FILES (files data)");
16367 case NT_FREEBSD_PROCSTAT_VMMAP
:
16368 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16369 case NT_FREEBSD_PROCSTAT_GROUPS
:
16370 return _("NT_PROCSTAT_GROUPS (groups data)");
16371 case NT_FREEBSD_PROCSTAT_UMASK
:
16372 return _("NT_PROCSTAT_UMASK (umask data)");
16373 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16374 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16375 case NT_FREEBSD_PROCSTAT_OSREL
:
16376 return _("NT_PROCSTAT_OSREL (osreldate data)");
16377 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16378 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16379 case NT_FREEBSD_PROCSTAT_AUXV
:
16380 return _("NT_PROCSTAT_AUXV (auxv data)");
16382 return get_note_type (e_type
);
16385 static const char *
16386 get_netbsd_elfcore_note_type (unsigned e_type
)
16388 static char buff
[64];
16390 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16392 /* NetBSD core "procinfo" structure. */
16393 return _("NetBSD procinfo structure");
16396 /* As of Jan 2002 there are no other machine-independent notes
16397 defined for NetBSD core files. If the note type is less
16398 than the start of the machine-dependent note types, we don't
16401 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16403 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16407 switch (elf_header
.e_machine
)
16409 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16410 and PT_GETFPREGS == mach+2. */
16415 case EM_SPARC32PLUS
:
16419 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16420 return _("PT_GETREGS (reg structure)");
16421 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16422 return _("PT_GETFPREGS (fpreg structure)");
16428 /* On all other arch's, PT_GETREGS == mach+1 and
16429 PT_GETFPREGS == mach+3. */
16433 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16434 return _("PT_GETREGS (reg structure)");
16435 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16436 return _("PT_GETFPREGS (fpreg structure)");
16442 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16443 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16447 static const char *
16448 get_stapsdt_note_type (unsigned e_type
)
16450 static char buff
[64];
16455 return _("NT_STAPSDT (SystemTap probe descriptors)");
16461 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16466 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16468 int addr_size
= is_32bit_elf
? 4 : 8;
16469 char *data
= pnote
->descdata
;
16470 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16471 bfd_vma pc
, base_addr
, semaphore
;
16472 char *provider
, *probe
, *arg_fmt
;
16474 pc
= byte_get ((unsigned char *) data
, addr_size
);
16476 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16478 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16482 data
+= strlen (data
) + 1;
16484 data
+= strlen (data
) + 1;
16486 data
+= strlen (data
) + 1;
16488 printf (_(" Provider: %s\n"), provider
);
16489 printf (_(" Name: %s\n"), probe
);
16490 printf (_(" Location: "));
16491 print_vma (pc
, FULL_HEX
);
16492 printf (_(", Base: "));
16493 print_vma (base_addr
, FULL_HEX
);
16494 printf (_(", Semaphore: "));
16495 print_vma (semaphore
, FULL_HEX
);
16497 printf (_(" Arguments: %s\n"), arg_fmt
);
16499 return data
== data_end
;
16502 static const char *
16503 get_ia64_vms_note_type (unsigned e_type
)
16505 static char buff
[64];
16510 return _("NT_VMS_MHD (module header)");
16512 return _("NT_VMS_LNM (language name)");
16514 return _("NT_VMS_SRC (source files)");
16516 return "NT_VMS_TITLE";
16518 return _("NT_VMS_EIDC (consistency check)");
16519 case NT_VMS_FPMODE
:
16520 return _("NT_VMS_FPMODE (FP mode)");
16521 case NT_VMS_LINKTIME
:
16522 return "NT_VMS_LINKTIME";
16523 case NT_VMS_IMGNAM
:
16524 return _("NT_VMS_IMGNAM (image name)");
16526 return _("NT_VMS_IMGID (image id)");
16527 case NT_VMS_LINKID
:
16528 return _("NT_VMS_LINKID (link id)");
16529 case NT_VMS_IMGBID
:
16530 return _("NT_VMS_IMGBID (build id)");
16531 case NT_VMS_GSTNAM
:
16532 return _("NT_VMS_GSTNAM (sym table name)");
16533 case NT_VMS_ORIG_DYN
:
16534 return "NT_VMS_ORIG_DYN";
16535 case NT_VMS_PATCHTIME
:
16536 return "NT_VMS_PATCHTIME";
16538 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16544 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16546 switch (pnote
->type
)
16549 if (pnote
->descsz
> 36)
16551 size_t l
= strlen (pnote
->descdata
+ 34);
16552 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16553 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16554 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16555 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16558 printf (_(" Invalid size\n"));
16561 printf (_(" Language: %s\n"), pnote
->descdata
);
16564 case NT_VMS_FPMODE
:
16565 printf (_(" Floating Point mode: "));
16566 printf ("0x%016" BFD_VMA_FMT
"x\n",
16567 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16569 case NT_VMS_LINKTIME
:
16570 printf (_(" Link time: "));
16572 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16575 case NT_VMS_PATCHTIME
:
16576 printf (_(" Patch time: "));
16578 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16581 case NT_VMS_ORIG_DYN
:
16582 printf (_(" Major id: %u, minor id: %u\n"),
16583 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16584 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16585 printf (_(" Last modified : "));
16587 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16588 printf (_("\n Link flags : "));
16589 printf ("0x%016" BFD_VMA_FMT
"x\n",
16590 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16591 printf (_(" Header flags: 0x%08x\n"),
16592 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16593 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16596 case NT_VMS_IMGNAM
:
16597 printf (_(" Image name: %s\n"), pnote
->descdata
);
16599 case NT_VMS_GSTNAM
:
16600 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16603 printf (_(" Image id: %s\n"), pnote
->descdata
);
16605 case NT_VMS_LINKID
:
16606 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16614 /* Print the name of the symbol associated with a build attribute
16615 that is attached to address OFFSET. */
16618 print_symbol_for_build_attribute (FILE * file
,
16619 unsigned long offset
,
16620 bfd_boolean is_open_attr
)
16622 static FILE * saved_file
= NULL
;
16623 static char * strtab
;
16624 static unsigned long strtablen
;
16625 static Elf_Internal_Sym
* symtab
;
16626 static unsigned long nsyms
;
16627 Elf_Internal_Sym
* saved_sym
= NULL
;
16628 Elf_Internal_Sym
* sym
;
16630 if (saved_file
== NULL
|| file
!= saved_file
)
16632 Elf_Internal_Shdr
* symsec
;
16634 /* Load the symbol and string sections. */
16635 for (symsec
= section_headers
;
16636 symsec
< section_headers
+ elf_header
.e_shnum
;
16639 if (symsec
->sh_type
== SHT_SYMTAB
)
16641 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
16643 if (symsec
->sh_link
< elf_header
.e_shnum
)
16645 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
16647 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
16648 1, strtab_sec
->sh_size
,
16649 _("string table"));
16650 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
16657 if (symtab
== NULL
|| strtab
== NULL
)
16663 /* Find a symbol whose value matches offset. */
16664 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
16665 if (sym
->st_value
== offset
)
16667 if (sym
->st_name
>= strtablen
)
16668 /* Huh ? This should not happen. */
16671 if (strtab
[sym
->st_name
] == 0)
16676 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
16677 and FILE or OBJECT symbols over NOTYPE symbols. We skip
16678 FUNC symbols entirely. */
16679 switch (ELF_ST_TYPE (sym
->st_info
))
16683 /* We can stop searching now. */
16684 sym
= symtab
+ nsyms
;
16692 /* Ignore function symbols. */
16699 switch (ELF_ST_BIND (sym
->st_info
))
16702 if (saved_sym
== NULL
16703 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
16708 if (saved_sym
== NULL
)
16718 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
16726 printf (" (%s: %s)\n",
16727 is_open_attr
? _("file") : _("func"),
16728 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
16733 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
16736 static unsigned long global_offset
= 0;
16737 unsigned long offset
;
16738 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
16739 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
16741 if (pnote
->descsz
== 0)
16745 printf (_(" Applies from offset %#lx\n"), global_offset
);
16750 printf (_(" Applies to func at %#lx"), global_offset
);
16751 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
16755 if (pnote
->descsz
!= desc_size
)
16757 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
16758 printf (_(" <invalid descsz>"));
16762 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
16766 printf (_(" Applies from offset %#lx"), offset
);
16767 global_offset
= offset
;
16771 printf (_(" Applies to func at %#lx"), offset
);
16774 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
16778 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
16781 char name_attribute
;
16782 char * expected_types
;
16783 const char * name
= pnote
->namedata
;
16787 if (name
== NULL
|| pnote
->namesz
< 2)
16789 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
16790 print_symbol (-20, _(" <corrupt name field>"));
16794 switch ((name_type
= * name
))
16796 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
16797 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
16798 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
16799 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
16800 printf ("%c", * name
);
16803 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
16804 print_symbol (-20, _("<unknown name type>"));
16812 switch ((name_attribute
= * name
))
16814 case GNU_BUILD_ATTRIBUTE_VERSION
:
16815 text
= _("<version>");
16816 expected_types
= "$";
16819 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
16820 text
= _("<stack prot>");
16821 expected_types
= "!+*";
16824 case GNU_BUILD_ATTRIBUTE_RELRO
:
16825 text
= _("<relro>");
16826 expected_types
= "!+";
16829 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
16830 text
= _("<stack size>");
16831 expected_types
= "*";
16834 case GNU_BUILD_ATTRIBUTE_TOOL
:
16835 text
= _("<tool>");
16836 expected_types
= "$";
16839 case GNU_BUILD_ATTRIBUTE_ABI
:
16841 expected_types
= "$*";
16844 case GNU_BUILD_ATTRIBUTE_PIC
:
16846 expected_types
= "*";
16849 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
16850 text
= _("<short enum>");
16851 expected_types
= "!+";
16856 if (ISPRINT (* name
))
16858 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
16860 if (len
> left
&& ! do_wide
)
16862 printf ("%.*s:", len
, name
);
16868 error (_("unexpected character in name field\n"));
16869 print_symbol (- left
, _("<unknown attribute>"));
16872 expected_types
= "*$!+";
16878 printf ("%s", text
);
16879 left
-= strlen (text
);
16882 if (strchr (expected_types
, name_type
) == NULL
)
16883 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
16885 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
16887 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
16888 (unsigned long) pnote
->namesz
,
16889 (long) (name
- pnote
->namedata
));
16893 if (left
< 1 && ! do_wide
)
16898 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
16900 unsigned int bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
16901 unsigned long val
= 0;
16902 unsigned int shift
= 0;
16903 char * decoded
= NULL
;
16907 unsigned long byte
= (* name
++) & 0xff;
16909 val
|= byte
<< shift
;
16913 switch (name_attribute
)
16915 case GNU_BUILD_ATTRIBUTE_PIC
:
16918 case 0: decoded
= "static"; break;
16919 case 1: decoded
= "pic"; break;
16920 case 2: decoded
= "PIC"; break;
16921 case 3: decoded
= "pie"; break;
16922 case 4: decoded
= "PIE"; break;
16926 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
16929 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
16930 case 0: decoded
= "off"; break;
16931 case 1: decoded
= "on"; break;
16932 case 2: decoded
= "all"; break;
16933 case 3: decoded
= "strong"; break;
16934 case 4: decoded
= "explicit"; break;
16942 if (decoded
!= NULL
)
16943 print_symbol (-left
, decoded
);
16947 left
-= printf ("0x%lx", val
);
16949 left
-= printf ("0x%-.*lx", left
, val
);
16953 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
16954 left
-= print_symbol (- left
, name
);
16956 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
16957 left
-= print_symbol (- left
, "true");
16959 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
16960 left
-= print_symbol (- left
, "false");
16964 if (do_wide
&& left
> 0)
16965 printf ("%-*s", left
, " ");
16970 /* Note that by the ELF standard, the name field is already null byte
16971 terminated, and namesz includes the terminating null byte.
16972 I.E. the value of namesz for the name "FSF" is 4.
16974 If the value of namesz is zero, there is no name present. */
16977 process_note (Elf_Internal_Note
* pnote
,
16980 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16983 if (pnote
->namesz
== 0)
16984 /* If there is no note name, then use the default set of
16985 note type strings. */
16986 nt
= get_note_type (pnote
->type
);
16988 else if (const_strneq (pnote
->namedata
, "GNU"))
16989 /* GNU-specific object file notes. */
16990 nt
= get_gnu_elf_note_type (pnote
->type
);
16992 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16993 /* FreeBSD-specific core file notes. */
16994 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16996 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16997 /* NetBSD-specific core file notes. */
16998 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17000 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17001 /* NetBSD-specific core file notes. */
17002 return process_netbsd_elf_note (pnote
);
17004 else if (strneq (pnote
->namedata
, "SPU/", 4))
17006 /* SPU-specific core file notes. */
17007 nt
= pnote
->namedata
+ 4;
17011 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17012 /* VMS/ia64-specific file notes. */
17013 nt
= get_ia64_vms_note_type (pnote
->type
);
17015 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17016 nt
= get_stapsdt_note_type (pnote
->type
);
17019 /* Don't recognize this note name; just use the default set of
17020 note type strings. */
17021 nt
= get_note_type (pnote
->type
);
17025 if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17026 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17027 print_gnu_build_attribute_name (pnote
);
17029 print_symbol (-20, name
);
17032 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17034 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17036 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17037 return print_ia64_vms_note (pnote
);
17038 else if (const_strneq (pnote
->namedata
, "GNU"))
17039 return print_gnu_note (pnote
);
17040 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17041 return print_stapsdt_note (pnote
);
17042 else if (const_strneq (pnote
->namedata
, "CORE"))
17043 return print_core_note (pnote
);
17044 else if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17045 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17046 return print_gnu_build_attribute_description (pnote
, file
);
17052 printf (_(" description data: "));
17053 for (i
= 0; i
< pnote
->descsz
; i
++)
17054 printf ("%02x ", pnote
->descdata
[i
]);
17064 process_notes_at (FILE * file
,
17065 Elf_Internal_Shdr
* section
,
17069 Elf_External_Note
* pnotes
;
17070 Elf_External_Note
* external
;
17072 bfd_boolean res
= TRUE
;
17079 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17082 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17087 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17089 if (pnotes
== NULL
)
17095 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17097 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17098 (unsigned long) offset
, (unsigned long) length
);
17100 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17102 end
= (char *) pnotes
+ length
;
17103 while ((char *) external
< end
)
17105 Elf_Internal_Note inote
;
17108 char * temp
= NULL
;
17109 size_t data_remaining
= end
- (char *) external
;
17111 if (!is_ia64_vms ())
17113 /* PR binutils/15191
17114 Make sure that there is enough data to read. */
17115 min_notesz
= offsetof (Elf_External_Note
, name
);
17116 if (data_remaining
< min_notesz
)
17118 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17119 (int) data_remaining
);
17122 inote
.type
= BYTE_GET (external
->type
);
17123 inote
.namesz
= BYTE_GET (external
->namesz
);
17124 inote
.namedata
= external
->name
;
17125 inote
.descsz
= BYTE_GET (external
->descsz
);
17126 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17127 /* PR 17531: file: 3443835e. */
17128 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17130 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17131 inote
.namesz
, (long)(end
- inote
.namedata
));
17132 inote
.descdata
= inote
.namedata
;
17136 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17137 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17141 Elf64_External_VMS_Note
*vms_external
;
17143 /* PR binutils/15191
17144 Make sure that there is enough data to read. */
17145 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17146 if (data_remaining
< min_notesz
)
17148 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17149 (int) data_remaining
);
17153 vms_external
= (Elf64_External_VMS_Note
*) external
;
17154 inote
.type
= BYTE_GET (vms_external
->type
);
17155 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17156 inote
.namedata
= vms_external
->name
;
17157 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17158 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17159 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17160 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17163 if (inote
.descdata
< (char *) external
+ min_notesz
17164 || next
< (char *) external
+ min_notesz
17165 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17166 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17167 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17168 || data_remaining
< (size_t)(next
- (char *) external
))
17170 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17171 (unsigned long) ((char *) external
- (char *) pnotes
));
17172 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17173 inote
.type
, inote
.namesz
, inote
.descsz
);
17177 external
= (Elf_External_Note
*) next
;
17179 /* Verify that name is null terminated. It appears that at least
17180 one version of Linux (RedHat 6.0) generates corefiles that don't
17181 comply with the ELF spec by failing to include the null byte in
17183 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17185 temp
= (char *) malloc (inote
.namesz
+ 1);
17188 error (_("Out of memory allocating space for inote name\n"));
17193 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17194 temp
[inote
.namesz
] = 0;
17196 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17197 inote
.namedata
= temp
;
17200 if (! process_note (& inote
, file
))
17216 process_corefile_note_segments (FILE * file
)
17218 Elf_Internal_Phdr
* segment
;
17220 bfd_boolean res
= TRUE
;
17222 if (! get_program_headers (file
))
17225 for (i
= 0, segment
= program_headers
;
17226 i
< elf_header
.e_phnum
;
17229 if (segment
->p_type
== PT_NOTE
)
17230 if (! process_notes_at (file
, NULL
,
17231 (bfd_vma
) segment
->p_offset
,
17232 (bfd_vma
) segment
->p_filesz
))
17240 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17242 Elf_External_Note
* pnotes
;
17243 Elf_External_Note
* external
;
17245 bfd_boolean res
= TRUE
;
17250 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17252 if (pnotes
== NULL
)
17256 end
= (char*) pnotes
+ length
;
17258 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17259 (unsigned long) offset
, (unsigned long) length
);
17261 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17263 Elf_External_Note
* next
;
17264 Elf_Internal_Note inote
;
17266 inote
.type
= BYTE_GET (external
->type
);
17267 inote
.namesz
= BYTE_GET (external
->namesz
);
17268 inote
.namedata
= external
->name
;
17269 inote
.descsz
= BYTE_GET (external
->descsz
);
17270 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17271 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17273 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17275 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17276 inote
.descdata
= inote
.namedata
;
17280 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17282 if ( ((char *) next
> end
)
17283 || ((char *) next
< (char *) pnotes
))
17285 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17286 (unsigned long) ((char *) external
- (char *) pnotes
));
17287 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17288 inote
.type
, inote
.namesz
, inote
.descsz
);
17294 /* Prevent out-of-bounds indexing. */
17295 if ( inote
.namedata
+ inote
.namesz
> end
17296 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17298 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17299 (unsigned long) ((char *) external
- (char *) pnotes
));
17300 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17301 inote
.type
, inote
.namesz
, inote
.descsz
);
17305 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17307 if (! print_v850_note (& inote
))
17310 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17311 inote
.namesz
, inote
.descsz
);
17321 process_note_sections (FILE * file
)
17323 Elf_Internal_Shdr
* section
;
17325 unsigned int n
= 0;
17326 bfd_boolean res
= TRUE
;
17328 for (i
= 0, section
= section_headers
;
17329 i
< elf_header
.e_shnum
&& section
!= NULL
;
17332 if (section
->sh_type
== SHT_NOTE
)
17334 if (! process_notes_at (file
, section
,
17335 (bfd_vma
) section
->sh_offset
,
17336 (bfd_vma
) section
->sh_size
))
17341 if (( elf_header
.e_machine
== EM_V800
17342 || elf_header
.e_machine
== EM_V850
17343 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17344 && section
->sh_type
== SHT_RENESAS_INFO
)
17346 if (! process_v850_notes (file
,
17347 (bfd_vma
) section
->sh_offset
,
17348 (bfd_vma
) section
->sh_size
))
17355 /* Try processing NOTE segments instead. */
17356 return process_corefile_note_segments (file
);
17362 process_notes (FILE * file
)
17364 /* If we have not been asked to display the notes then do nothing. */
17368 if (elf_header
.e_type
!= ET_CORE
)
17369 return process_note_sections (file
);
17371 /* No program headers means no NOTE segment. */
17372 if (elf_header
.e_phnum
> 0)
17373 return process_corefile_note_segments (file
);
17375 printf (_("No note segments present in the core file.\n"));
17379 static unsigned char *
17380 display_public_gnu_attributes (unsigned char * start
,
17381 const unsigned char * const end
)
17383 printf (_(" Unknown GNU attribute: %s\n"), start
);
17385 start
+= strnlen ((char *) start
, end
- start
);
17386 display_raw_attribute (start
, end
);
17388 return (unsigned char *) end
;
17391 static unsigned char *
17392 display_generic_attribute (unsigned char * start
,
17394 const unsigned char * const end
)
17397 return (unsigned char *) end
;
17399 return display_tag_value (tag
, start
, end
);
17403 process_arch_specific (FILE * file
)
17408 switch (elf_header
.e_machine
)
17411 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17412 display_arm_attribute
,
17413 display_generic_attribute
);
17416 case EM_MIPS_RS3_LE
:
17417 return process_mips_specific (file
);
17420 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17421 display_msp430x_attribute
,
17422 display_generic_attribute
);
17425 return process_nds32_specific (file
);
17429 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17430 display_power_gnu_attribute
);
17434 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17435 display_s390_gnu_attribute
);
17438 case EM_SPARC32PLUS
:
17440 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17441 display_sparc_gnu_attribute
);
17444 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17445 display_tic6x_attribute
,
17446 display_generic_attribute
);
17449 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17450 display_public_gnu_attributes
,
17451 display_generic_attribute
);
17456 get_file_header (FILE * file
)
17458 /* Read in the identity array. */
17459 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
17462 /* Determine how to read the rest of the header. */
17463 switch (elf_header
.e_ident
[EI_DATA
])
17468 byte_get
= byte_get_little_endian
;
17469 byte_put
= byte_put_little_endian
;
17472 byte_get
= byte_get_big_endian
;
17473 byte_put
= byte_put_big_endian
;
17477 /* For now we only support 32 bit and 64 bit ELF files. */
17478 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
17480 /* Read in the rest of the header. */
17483 Elf32_External_Ehdr ehdr32
;
17485 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
17488 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
17489 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
17490 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
17491 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
17492 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
17493 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
17494 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
17495 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
17496 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
17497 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
17498 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
17499 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
17500 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
17504 Elf64_External_Ehdr ehdr64
;
17506 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17507 we will not be able to cope with the 64bit data found in
17508 64 ELF files. Detect this now and abort before we start
17509 overwriting things. */
17510 if (sizeof (bfd_vma
) < 8)
17512 error (_("This instance of readelf has been built without support for a\n\
17513 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17517 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
17520 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
17521 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
17522 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
17523 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
17524 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
17525 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
17526 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
17527 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
17528 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
17529 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
17530 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
17531 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
17532 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
17535 if (elf_header
.e_shoff
)
17537 /* There may be some extensions in the first section header. Don't
17538 bomb if we can't read it. */
17540 get_32bit_section_headers (file
, TRUE
);
17542 get_64bit_section_headers (file
, TRUE
);
17548 /* Process one ELF object file according to the command line options.
17549 This file may actually be stored in an archive. The file is
17550 positioned at the start of the ELF object. Returns TRUE if no
17551 problems were encountered, FALSE otherwise. */
17554 process_object (char * file_name
, FILE * file
)
17557 bfd_boolean res
= TRUE
;
17559 if (! get_file_header (file
))
17561 error (_("%s: Failed to read file header\n"), file_name
);
17565 /* Initialise per file variables. */
17566 for (i
= ARRAY_SIZE (version_info
); i
--;)
17567 version_info
[i
] = 0;
17569 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
17570 dynamic_info
[i
] = 0;
17571 dynamic_info_DT_GNU_HASH
= 0;
17573 /* Process the file. */
17575 printf (_("\nFile: %s\n"), file_name
);
17577 /* Initialise the dump_sects array from the cmdline_dump_sects array.
17578 Note we do this even if cmdline_dump_sects is empty because we
17579 must make sure that the dump_sets array is zeroed out before each
17580 object file is processed. */
17581 if (num_dump_sects
> num_cmdline_dump_sects
)
17582 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
17584 if (num_cmdline_dump_sects
> 0)
17586 if (num_dump_sects
== 0)
17587 /* A sneaky way of allocating the dump_sects array. */
17588 request_dump_bynumber (num_cmdline_dump_sects
, 0);
17590 assert (num_dump_sects
>= num_cmdline_dump_sects
);
17591 memcpy (dump_sects
, cmdline_dump_sects
,
17592 num_cmdline_dump_sects
* sizeof (* dump_sects
));
17595 if (! process_file_header ())
17598 if (! process_section_headers (file
))
17600 /* Without loaded section headers we cannot process lots of things. */
17601 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
17603 if (! do_using_dynamic
)
17604 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
17607 if (! process_section_groups (file
))
17608 /* Without loaded section groups we cannot process unwind. */
17611 if (process_program_headers (file
))
17612 process_dynamic_section (file
);
17616 if (! process_relocs (file
))
17619 if (! process_unwind (file
))
17622 if (! process_symbol_table (file
))
17625 if (! process_syminfo (file
))
17628 if (! process_version_sections (file
))
17631 if (! process_section_contents (file
))
17634 if (! process_notes (file
))
17637 if (! process_gnu_liblist (file
))
17640 if (! process_arch_specific (file
))
17643 if (program_headers
)
17645 free (program_headers
);
17646 program_headers
= NULL
;
17649 if (section_headers
)
17651 free (section_headers
);
17652 section_headers
= NULL
;
17657 free (string_table
);
17658 string_table
= NULL
;
17659 string_table_length
= 0;
17662 if (dynamic_strings
)
17664 free (dynamic_strings
);
17665 dynamic_strings
= NULL
;
17666 dynamic_strings_length
= 0;
17669 if (dynamic_symbols
)
17671 free (dynamic_symbols
);
17672 dynamic_symbols
= NULL
;
17673 num_dynamic_syms
= 0;
17676 if (dynamic_syminfo
)
17678 free (dynamic_syminfo
);
17679 dynamic_syminfo
= NULL
;
17682 if (dynamic_section
)
17684 free (dynamic_section
);
17685 dynamic_section
= NULL
;
17688 if (section_headers_groups
)
17690 free (section_headers_groups
);
17691 section_headers_groups
= NULL
;
17694 if (section_groups
)
17696 struct group_list
* g
;
17697 struct group_list
* next
;
17699 for (i
= 0; i
< group_count
; i
++)
17701 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
17708 free (section_groups
);
17709 section_groups
= NULL
;
17712 free_debug_memory ();
17717 /* Process an ELF archive.
17718 On entry the file is positioned just after the ARMAG string.
17719 Returns TRUE upon success, FALSE otherwise. */
17722 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
17724 struct archive_info arch
;
17725 struct archive_info nested_arch
;
17727 bfd_boolean ret
= TRUE
;
17731 /* The ARCH structure is used to hold information about this archive. */
17732 arch
.file_name
= NULL
;
17734 arch
.index_array
= NULL
;
17735 arch
.sym_table
= NULL
;
17736 arch
.longnames
= NULL
;
17738 /* The NESTED_ARCH structure is used as a single-item cache of information
17739 about a nested archive (when members of a thin archive reside within
17740 another regular archive file). */
17741 nested_arch
.file_name
= NULL
;
17742 nested_arch
.file
= NULL
;
17743 nested_arch
.index_array
= NULL
;
17744 nested_arch
.sym_table
= NULL
;
17745 nested_arch
.longnames
= NULL
;
17747 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
17753 if (do_archive_index
)
17755 if (arch
.sym_table
== NULL
)
17756 error (_("%s: unable to dump the index as none was found\n"), file_name
);
17759 unsigned long i
, l
;
17760 unsigned long current_pos
;
17762 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17763 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
17764 current_pos
= ftell (file
);
17766 for (i
= l
= 0; i
< arch
.index_num
; i
++)
17768 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
17770 char * member_name
;
17772 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
17774 if (member_name
!= NULL
)
17776 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
17778 if (qualified_name
!= NULL
)
17780 printf (_("Contents of binary %s at offset "), qualified_name
);
17781 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
17783 free (qualified_name
);
17788 if (l
>= arch
.sym_size
)
17790 error (_("%s: end of the symbol table reached before the end of the index\n"),
17795 /* PR 17531: file: 0b6630b2. */
17796 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
17797 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
17800 if (arch
.uses_64bit_indicies
)
17805 if (l
< arch
.sym_size
)
17807 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17808 file_name
, arch
.sym_size
- l
);
17812 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
17814 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
17820 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
17821 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
17822 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
17823 && !do_section_groups
&& !do_dyn_syms
)
17825 ret
= TRUE
; /* Archive index only. */
17834 char * qualified_name
;
17836 /* Read the next archive header. */
17837 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
17839 error (_("%s: failed to seek to next archive header\n"), file_name
);
17842 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
17843 if (got
!= sizeof arch
.arhdr
)
17847 error (_("%s: failed to read archive header\n"), file_name
);
17851 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
17853 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
17858 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
17860 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
17861 if (archive_file_size
& 01)
17862 ++archive_file_size
;
17864 name
= get_archive_member_name (&arch
, &nested_arch
);
17867 error (_("%s: bad archive file name\n"), file_name
);
17871 namelen
= strlen (name
);
17873 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
17874 if (qualified_name
== NULL
)
17876 error (_("%s: bad archive file name\n"), file_name
);
17881 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
17883 /* This is a proxy for an external member of a thin archive. */
17884 FILE * member_file
;
17885 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
17887 if (member_file_name
== NULL
)
17893 member_file
= fopen (member_file_name
, "rb");
17894 if (member_file
== NULL
)
17896 error (_("Input file '%s' is not readable.\n"), member_file_name
);
17897 free (member_file_name
);
17902 archive_file_offset
= arch
.nested_member_origin
;
17904 if (! process_object (qualified_name
, member_file
))
17907 fclose (member_file
);
17908 free (member_file_name
);
17910 else if (is_thin_archive
)
17912 /* PR 15140: Allow for corrupt thin archives. */
17913 if (nested_arch
.file
== NULL
)
17915 error (_("%s: contains corrupt thin archive: %s\n"),
17921 /* This is a proxy for a member of a nested archive. */
17922 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
17924 /* The nested archive file will have been opened and setup by
17925 get_archive_member_name. */
17926 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17928 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17933 if (! process_object (qualified_name
, nested_arch
.file
))
17938 archive_file_offset
= arch
.next_arhdr_offset
;
17939 arch
.next_arhdr_offset
+= archive_file_size
;
17941 if (! process_object (qualified_name
, file
))
17945 if (dump_sects
!= NULL
)
17949 num_dump_sects
= 0;
17952 free (qualified_name
);
17956 if (nested_arch
.file
!= NULL
)
17957 fclose (nested_arch
.file
);
17958 release_archive (&nested_arch
);
17959 release_archive (&arch
);
17965 process_file (char * file_name
)
17968 struct stat statbuf
;
17969 char armag
[SARMAG
];
17970 bfd_boolean ret
= TRUE
;
17972 if (stat (file_name
, &statbuf
) < 0)
17974 if (errno
== ENOENT
)
17975 error (_("'%s': No such file\n"), file_name
);
17977 error (_("Could not locate '%s'. System error message: %s\n"),
17978 file_name
, strerror (errno
));
17982 if (! S_ISREG (statbuf
.st_mode
))
17984 error (_("'%s' is not an ordinary file\n"), file_name
);
17988 file
= fopen (file_name
, "rb");
17991 error (_("Input file '%s' is not readable.\n"), file_name
);
17995 if (fread (armag
, SARMAG
, 1, file
) != 1)
17997 error (_("%s: Failed to read file's magic number\n"), file_name
);
18002 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18004 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18006 if (! process_archive (file_name
, file
, FALSE
))
18009 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18011 if ( ! process_archive (file_name
, file
, TRUE
))
18016 if (do_archive_index
)
18017 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18021 archive_file_size
= archive_file_offset
= 0;
18023 if (! process_object (file_name
, file
))
18028 current_file_size
= 0;
18033 #ifdef SUPPORT_DISASSEMBLY
18034 /* Needed by the i386 disassembler. For extra credit, someone could
18035 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18039 print_address (unsigned int addr
, FILE * outfile
)
18041 fprintf (outfile
,"0x%8.8x", addr
);
18044 /* Needed by the i386 disassembler. */
18046 db_task_printsym (unsigned int addr
)
18048 print_address (addr
, stderr
);
18053 main (int argc
, char ** argv
)
18057 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18058 setlocale (LC_MESSAGES
, "");
18060 #if defined (HAVE_SETLOCALE)
18061 setlocale (LC_CTYPE
, "");
18063 bindtextdomain (PACKAGE
, LOCALEDIR
);
18064 textdomain (PACKAGE
);
18066 expandargv (&argc
, &argv
);
18068 parse_args (argc
, argv
);
18070 if (num_dump_sects
> 0)
18072 /* Make a copy of the dump_sects array. */
18073 cmdline_dump_sects
= (dump_type
*)
18074 malloc (num_dump_sects
* sizeof (* dump_sects
));
18075 if (cmdline_dump_sects
== NULL
)
18076 error (_("Out of memory allocating dump request table.\n"));
18079 memcpy (cmdline_dump_sects
, dump_sects
,
18080 num_dump_sects
* sizeof (* dump_sects
));
18081 num_cmdline_dump_sects
= num_dump_sects
;
18085 if (optind
< (argc
- 1))
18087 else if (optind
>= argc
)
18089 warn (_("Nothing to do.\n"));
18094 while (optind
< argc
)
18095 if (! process_file (argv
[optind
++]))
18098 if (dump_sects
!= NULL
)
18100 if (cmdline_dump_sects
!= NULL
)
18101 free (cmdline_dump_sects
);
18103 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;