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/x86-64.h"
155 #include "elf/xc16x.h"
156 #include "elf/xgate.h"
157 #include "elf/xstormy16.h"
158 #include "elf/xtensa.h"
161 #include "libiberty.h"
162 #include "safe-ctype.h"
163 #include "filenames.h"
166 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
169 typedef struct elf_section_list
171 Elf_Internal_Shdr
* hdr
;
172 struct elf_section_list
* next
;
175 char * program_name
= "readelf";
176 static unsigned long archive_file_offset
;
177 static unsigned long archive_file_size
;
178 static bfd_size_type current_file_size
;
179 static unsigned long dynamic_addr
;
180 static bfd_size_type dynamic_size
;
181 static size_t dynamic_nent
;
182 static char * dynamic_strings
;
183 static unsigned long dynamic_strings_length
;
184 static char * string_table
;
185 static unsigned long string_table_length
;
186 static unsigned long num_dynamic_syms
;
187 static Elf_Internal_Sym
* dynamic_symbols
;
188 static Elf_Internal_Syminfo
* dynamic_syminfo
;
189 static unsigned long dynamic_syminfo_offset
;
190 static unsigned int dynamic_syminfo_nent
;
191 static char program_interpreter
[PATH_MAX
];
192 static bfd_vma dynamic_info
[DT_ENCODING
];
193 static bfd_vma dynamic_info_DT_GNU_HASH
;
194 static bfd_vma version_info
[16];
195 static Elf_Internal_Ehdr elf_header
;
196 static Elf_Internal_Shdr
* section_headers
;
197 static Elf_Internal_Phdr
* program_headers
;
198 static Elf_Internal_Dyn
* dynamic_section
;
199 static elf_section_list
* symtab_shndx_list
;
200 static bfd_boolean show_name
= FALSE
;
201 static bfd_boolean do_dynamic
= FALSE
;
202 static bfd_boolean do_syms
= FALSE
;
203 static bfd_boolean do_dyn_syms
= FALSE
;
204 static bfd_boolean do_reloc
= FALSE
;
205 static bfd_boolean do_sections
= FALSE
;
206 static bfd_boolean do_section_groups
= FALSE
;
207 static bfd_boolean do_section_details
= FALSE
;
208 static bfd_boolean do_segments
= FALSE
;
209 static bfd_boolean do_unwind
= FALSE
;
210 static bfd_boolean do_using_dynamic
= FALSE
;
211 static bfd_boolean do_header
= FALSE
;
212 static bfd_boolean do_dump
= FALSE
;
213 static bfd_boolean do_version
= FALSE
;
214 static bfd_boolean do_histogram
= FALSE
;
215 static bfd_boolean do_debugging
= FALSE
;
216 static bfd_boolean do_arch
= FALSE
;
217 static bfd_boolean do_notes
= FALSE
;
218 static bfd_boolean do_archive_index
= FALSE
;
219 static bfd_boolean is_32bit_elf
= FALSE
;
220 static bfd_boolean decompress_dumps
= FALSE
;
224 struct group_list
* next
;
225 unsigned int section_index
;
230 struct group_list
* root
;
231 unsigned int group_index
;
234 static size_t group_count
;
235 static struct group
* section_groups
;
236 static struct group
** section_headers_groups
;
239 /* Flag bits indicating particular types of dump. */
240 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
241 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
242 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
243 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
244 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
246 typedef unsigned char dump_type
;
248 /* A linked list of the section names for which dumps were requested. */
249 struct dump_list_entry
253 struct dump_list_entry
* next
;
255 static struct dump_list_entry
* dump_sects_byname
;
257 /* A dynamic array of flags indicating for which sections a dump
258 has been requested via command line switches. */
259 static dump_type
* cmdline_dump_sects
= NULL
;
260 static unsigned int num_cmdline_dump_sects
= 0;
262 /* A dynamic array of flags indicating for which sections a dump of
263 some kind has been requested. It is reset on a per-object file
264 basis and then initialised from the cmdline_dump_sects array,
265 the results of interpreting the -w switch, and the
266 dump_sects_byname list. */
267 static dump_type
* dump_sects
= NULL
;
268 static unsigned int num_dump_sects
= 0;
271 /* How to print a vma value. */
272 typedef enum print_mode
284 /* Versioned symbol info. */
285 enum versioned_symbol_info
292 static const char * get_symbol_version_string
293 (FILE *, bfd_boolean
, const char *, unsigned long, unsigned,
294 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
298 #define SECTION_NAME(X) \
299 ((X) == NULL ? _("<none>") \
300 : string_table == NULL ? _("<no-name>") \
301 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
302 : string_table + (X)->sh_name))
304 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
306 #define GET_ELF_SYMBOLS(file, section, sym_count) \
307 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
308 : get_64bit_elf_symbols (file, section, sym_count))
310 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
311 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
312 already been called and verified that the string exists. */
313 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
315 #define REMOVE_ARCH_BITS(ADDR) \
318 if (elf_header.e_machine == EM_ARM) \
323 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
324 the offset of the current archive member, if we are examining an archive.
325 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
326 using malloc and fill that. In either case return the pointer to the start of
327 the retrieved data or NULL if something went wrong. If something does go wrong
328 and REASON is not NULL then emit an error message using REASON as part of the
332 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
333 bfd_size_type nmemb
, const char * reason
)
336 bfd_size_type amt
= size
* nmemb
;
338 if (size
== 0 || nmemb
== 0)
341 /* If the size_t type is smaller than the bfd_size_type, eg because
342 you are building a 32-bit tool on a 64-bit host, then make sure
343 that when the sizes are cast to (size_t) no information is lost. */
344 if (sizeof (size_t) < sizeof (bfd_size_type
)
345 && ( (bfd_size_type
) ((size_t) size
) != size
346 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
349 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT
"x"
350 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
351 nmemb
, size
, reason
);
355 /* Check for size overflow. */
359 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT
"x"
360 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
361 nmemb
, size
, reason
);
365 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
366 attempting to allocate memory when the read is bound to fail. */
367 if (amt
> current_file_size
368 || offset
+ archive_file_offset
+ amt
> current_file_size
)
371 error (_("Reading 0x%" BFD_VMA_FMT
"x"
372 " bytes extends past end of file for %s\n"),
377 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
380 error (_("Unable to seek to 0x%lx for %s\n"),
381 archive_file_offset
+ offset
, reason
);
388 /* Check for overflow. */
389 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
390 /* + 1 so that we can '\0' terminate invalid string table sections. */
391 mvar
= malloc ((size_t) amt
+ 1);
396 error (_("Out of memory allocating 0x%" BFD_VMA_FMT
"x"
402 ((char *) mvar
)[amt
] = '\0';
405 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
408 error (_("Unable to read in 0x%" BFD_VMA_FMT
"x bytes of %s\n"),
418 /* Print a VMA value in the MODE specified.
419 Returns the number of characters displayed. */
422 print_vma (bfd_vma vma
, print_mode mode
)
434 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
441 return printf ("%5" BFD_VMA_FMT
"d", vma
);
447 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
450 return printf ("%" BFD_VMA_FMT
"d", vma
);
453 return printf ("%" BFD_VMA_FMT
"u", vma
);
456 /* FIXME: Report unrecognised mode ? */
461 /* Display a symbol on stdout. Handles the display of control characters and
462 multibye characters (assuming the host environment supports them).
464 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
466 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
467 padding as necessary.
469 Returns the number of emitted characters. */
472 print_symbol (signed int width
, const char *symbol
)
474 bfd_boolean extra_padding
= FALSE
;
475 signed int num_printed
= 0;
476 #ifdef HAVE_MBSTATE_T
479 unsigned int width_remaining
;
483 /* Keep the width positive. This also helps. */
485 extra_padding
= TRUE
;
490 /* Set the remaining width to a very large value.
491 This simplifies the code below. */
492 width_remaining
= INT_MAX
;
494 width_remaining
= width
;
496 #ifdef HAVE_MBSTATE_T
497 /* Initialise the multibyte conversion state. */
498 memset (& state
, 0, sizeof (state
));
501 while (width_remaining
)
504 const char c
= *symbol
++;
509 /* Do not print control characters directly as they can affect terminal
510 settings. Such characters usually appear in the names generated
511 by the assembler for local labels. */
514 if (width_remaining
< 2)
517 printf ("^%c", c
+ 0x40);
518 width_remaining
-= 2;
521 else if (ISPRINT (c
))
529 #ifdef HAVE_MBSTATE_T
532 /* Let printf do the hard work of displaying multibyte characters. */
533 printf ("%.1s", symbol
- 1);
537 #ifdef HAVE_MBSTATE_T
538 /* Try to find out how many bytes made up the character that was
539 just printed. Advance the symbol pointer past the bytes that
541 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
545 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
550 if (extra_padding
&& num_printed
< width
)
552 /* Fill in the remaining spaces. */
553 printf ("%-*s", width
- num_printed
, " ");
560 /* Returns a pointer to a static buffer containing a printable version of
561 the given section's name. Like print_symbol, except that it does not try
562 to print multibyte characters, it just interprets them as hex values. */
565 printable_section_name (const Elf_Internal_Shdr
* sec
)
567 #define MAX_PRINT_SEC_NAME_LEN 128
568 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
569 const char * name
= SECTION_NAME (sec
);
570 char * buf
= sec_name_buf
;
572 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
574 while ((c
= * name
++) != 0)
585 else if (ISPRINT (c
))
592 static char hex
[17] = "0123456789ABCDEF";
597 * buf
++ = hex
[(c
& 0xf0) >> 4];
598 * buf
++ = hex
[c
& 0x0f];
612 printable_section_name_from_index (unsigned long ndx
)
614 if (ndx
>= elf_header
.e_shnum
)
615 return _("<corrupt>");
617 return printable_section_name (section_headers
+ ndx
);
620 /* Return a pointer to section NAME, or NULL if no such section exists. */
622 static Elf_Internal_Shdr
*
623 find_section (const char * name
)
627 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
628 if (streq (SECTION_NAME (section_headers
+ i
), name
))
629 return section_headers
+ i
;
634 /* Return a pointer to a section containing ADDR, or NULL if no such
637 static Elf_Internal_Shdr
*
638 find_section_by_address (bfd_vma addr
)
642 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
644 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
645 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
652 static Elf_Internal_Shdr
*
653 find_section_by_type (unsigned int type
)
657 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
659 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
660 if (sec
->sh_type
== type
)
667 /* Return a pointer to section NAME, or NULL if no such section exists,
668 restricted to the list of sections given in SET. */
670 static Elf_Internal_Shdr
*
671 find_section_in_set (const char * name
, unsigned int * set
)
677 while ((i
= *set
++) > 0)
679 /* See PR 21156 for a reproducer. */
680 if (i
>= elf_header
.e_shnum
)
681 continue; /* FIXME: Should we issue an error message ? */
683 if (streq (SECTION_NAME (section_headers
+ i
), name
))
684 return section_headers
+ i
;
688 return find_section (name
);
691 /* Read an unsigned LEB128 encoded value from DATA.
692 Set *LENGTH_RETURN to the number of bytes read. */
694 static inline unsigned long
695 read_uleb128 (unsigned char * data
,
696 unsigned int * length_return
,
697 const unsigned char * const end
)
699 return read_leb128 (data
, length_return
, FALSE
, end
);
702 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
703 This OS has so many departures from the ELF standard that we test it at
706 static inline bfd_boolean
709 return elf_header
.e_machine
== EM_IA_64
710 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
713 /* Guess the relocation size commonly used by the specific machines. */
716 guess_is_rela (unsigned int e_machine
)
720 /* Targets that use REL relocations. */
735 /* Targets that use RELA relocations. */
739 case EM_ADAPTEVA_EPIPHANY
:
741 case EM_ALTERA_NIOS2
:
744 case EM_ARC_COMPACT2
:
764 case EM_LATTICEMICO32
:
773 case EM_CYGNUS_MN10200
:
775 case EM_CYGNUS_MN10300
:
811 case EM_MICROBLAZE_OLD
:
832 warn (_("Don't know about relocations on this machine architecture\n"));
837 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
838 Returns TRUE upon success, FALSE otherwise. If successful then a
839 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
840 and the number of relocs loaded is placed in *NRELASP. It is the caller's
841 responsibility to free the allocated buffer. */
844 slurp_rela_relocs (FILE * file
,
845 unsigned long rel_offset
,
846 unsigned long rel_size
,
847 Elf_Internal_Rela
** relasp
,
848 unsigned long * nrelasp
)
850 Elf_Internal_Rela
* relas
;
856 Elf32_External_Rela
* erelas
;
858 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
859 rel_size
, _("32-bit relocation data"));
863 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
865 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
866 sizeof (Elf_Internal_Rela
));
871 error (_("out of memory parsing relocs\n"));
875 for (i
= 0; i
< nrelas
; i
++)
877 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
878 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
879 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
886 Elf64_External_Rela
* erelas
;
888 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
889 rel_size
, _("64-bit relocation data"));
893 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
895 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
896 sizeof (Elf_Internal_Rela
));
901 error (_("out of memory parsing relocs\n"));
905 for (i
= 0; i
< nrelas
; i
++)
907 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
908 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
909 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
911 /* The #ifdef BFD64 below is to prevent a compile time
912 warning. We know that if we do not have a 64 bit data
913 type that we will never execute this code anyway. */
915 if (elf_header
.e_machine
== EM_MIPS
916 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
918 /* In little-endian objects, r_info isn't really a
919 64-bit little-endian value: it has a 32-bit
920 little-endian symbol index followed by four
921 individual byte fields. Reorder INFO
923 bfd_vma inf
= relas
[i
].r_info
;
924 inf
= (((inf
& 0xffffffff) << 32)
925 | ((inf
>> 56) & 0xff)
926 | ((inf
>> 40) & 0xff00)
927 | ((inf
>> 24) & 0xff0000)
928 | ((inf
>> 8) & 0xff000000));
929 relas
[i
].r_info
= inf
;
942 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
943 Returns TRUE upon success, FALSE otherwise. If successful then a
944 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
945 and the number of relocs loaded is placed in *NRELSP. It is the caller's
946 responsibility to free the allocated buffer. */
949 slurp_rel_relocs (FILE * file
,
950 unsigned long rel_offset
,
951 unsigned long rel_size
,
952 Elf_Internal_Rela
** relsp
,
953 unsigned long * nrelsp
)
955 Elf_Internal_Rela
* rels
;
961 Elf32_External_Rel
* erels
;
963 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
964 rel_size
, _("32-bit relocation data"));
968 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
970 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
975 error (_("out of memory parsing relocs\n"));
979 for (i
= 0; i
< nrels
; i
++)
981 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
982 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
983 rels
[i
].r_addend
= 0;
990 Elf64_External_Rel
* erels
;
992 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
993 rel_size
, _("64-bit relocation data"));
997 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
999 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1004 error (_("out of memory parsing relocs\n"));
1008 for (i
= 0; i
< nrels
; i
++)
1010 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1011 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1012 rels
[i
].r_addend
= 0;
1014 /* The #ifdef BFD64 below is to prevent a compile time
1015 warning. We know that if we do not have a 64 bit data
1016 type that we will never execute this code anyway. */
1018 if (elf_header
.e_machine
== EM_MIPS
1019 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1021 /* In little-endian objects, r_info isn't really a
1022 64-bit little-endian value: it has a 32-bit
1023 little-endian symbol index followed by four
1024 individual byte fields. Reorder INFO
1026 bfd_vma inf
= rels
[i
].r_info
;
1027 inf
= (((inf
& 0xffffffff) << 32)
1028 | ((inf
>> 56) & 0xff)
1029 | ((inf
>> 40) & 0xff00)
1030 | ((inf
>> 24) & 0xff0000)
1031 | ((inf
>> 8) & 0xff000000));
1032 rels
[i
].r_info
= inf
;
1045 /* Returns the reloc type extracted from the reloc info field. */
1048 get_reloc_type (bfd_vma reloc_info
)
1051 return ELF32_R_TYPE (reloc_info
);
1053 switch (elf_header
.e_machine
)
1056 /* Note: We assume that reloc_info has already been adjusted for us. */
1057 return ELF64_MIPS_R_TYPE (reloc_info
);
1060 return ELF64_R_TYPE_ID (reloc_info
);
1063 return ELF64_R_TYPE (reloc_info
);
1067 /* Return the symbol index extracted from the reloc info field. */
1070 get_reloc_symindex (bfd_vma reloc_info
)
1072 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1075 static inline bfd_boolean
1076 uses_msp430x_relocs (void)
1079 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1080 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1081 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1082 /* TI compiler uses ELFOSABI_NONE. */
1083 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1086 /* Display the contents of the relocation data found at the specified
1090 dump_relocations (FILE * file
,
1091 unsigned long rel_offset
,
1092 unsigned long rel_size
,
1093 Elf_Internal_Sym
* symtab
,
1094 unsigned long nsyms
,
1096 unsigned long strtablen
,
1098 bfd_boolean is_dynsym
)
1101 Elf_Internal_Rela
* rels
;
1102 bfd_boolean res
= TRUE
;
1104 if (is_rela
== UNKNOWN
)
1105 is_rela
= guess_is_rela (elf_header
.e_machine
);
1109 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1114 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1123 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1125 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1130 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1132 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1140 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1142 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1147 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1149 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1153 for (i
= 0; i
< rel_size
; i
++)
1158 bfd_vma symtab_index
;
1161 offset
= rels
[i
].r_offset
;
1162 inf
= rels
[i
].r_info
;
1164 type
= get_reloc_type (inf
);
1165 symtab_index
= get_reloc_symindex (inf
);
1169 printf ("%8.8lx %8.8lx ",
1170 (unsigned long) offset
& 0xffffffff,
1171 (unsigned long) inf
& 0xffffffff);
1175 #if BFD_HOST_64BIT_LONG
1177 ? "%16.16lx %16.16lx "
1178 : "%12.12lx %12.12lx ",
1180 #elif BFD_HOST_64BIT_LONG_LONG
1183 ? "%16.16llx %16.16llx "
1184 : "%12.12llx %12.12llx ",
1188 ? "%16.16I64x %16.16I64x "
1189 : "%12.12I64x %12.12I64x ",
1194 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1195 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1196 _bfd_int64_high (offset
),
1197 _bfd_int64_low (offset
),
1198 _bfd_int64_high (inf
),
1199 _bfd_int64_low (inf
));
1203 switch (elf_header
.e_machine
)
1210 rtype
= elf_aarch64_reloc_type (type
);
1214 case EM_CYGNUS_M32R
:
1215 rtype
= elf_m32r_reloc_type (type
);
1220 rtype
= elf_i386_reloc_type (type
);
1225 rtype
= elf_m68hc11_reloc_type (type
);
1229 rtype
= elf_m68k_reloc_type (type
);
1233 rtype
= elf_i960_reloc_type (type
);
1238 rtype
= elf_avr_reloc_type (type
);
1241 case EM_OLD_SPARCV9
:
1242 case EM_SPARC32PLUS
:
1245 rtype
= elf_sparc_reloc_type (type
);
1249 rtype
= elf_spu_reloc_type (type
);
1253 rtype
= v800_reloc_type (type
);
1256 case EM_CYGNUS_V850
:
1257 rtype
= v850_reloc_type (type
);
1261 case EM_CYGNUS_D10V
:
1262 rtype
= elf_d10v_reloc_type (type
);
1266 case EM_CYGNUS_D30V
:
1267 rtype
= elf_d30v_reloc_type (type
);
1271 rtype
= elf_dlx_reloc_type (type
);
1275 rtype
= elf_sh_reloc_type (type
);
1279 case EM_CYGNUS_MN10300
:
1280 rtype
= elf_mn10300_reloc_type (type
);
1284 case EM_CYGNUS_MN10200
:
1285 rtype
= elf_mn10200_reloc_type (type
);
1289 case EM_CYGNUS_FR30
:
1290 rtype
= elf_fr30_reloc_type (type
);
1294 rtype
= elf_frv_reloc_type (type
);
1298 rtype
= elf_ft32_reloc_type (type
);
1302 rtype
= elf_mcore_reloc_type (type
);
1306 rtype
= elf_mmix_reloc_type (type
);
1310 rtype
= elf_moxie_reloc_type (type
);
1314 if (uses_msp430x_relocs ())
1316 rtype
= elf_msp430x_reloc_type (type
);
1321 rtype
= elf_msp430_reloc_type (type
);
1325 rtype
= elf_nds32_reloc_type (type
);
1329 rtype
= elf_ppc_reloc_type (type
);
1333 rtype
= elf_ppc64_reloc_type (type
);
1337 case EM_MIPS_RS3_LE
:
1338 rtype
= elf_mips_reloc_type (type
);
1342 rtype
= elf_riscv_reloc_type (type
);
1346 rtype
= elf_alpha_reloc_type (type
);
1350 rtype
= elf_arm_reloc_type (type
);
1354 case EM_ARC_COMPACT
:
1355 case EM_ARC_COMPACT2
:
1356 rtype
= elf_arc_reloc_type (type
);
1360 rtype
= elf_hppa_reloc_type (type
);
1366 rtype
= elf_h8_reloc_type (type
);
1370 rtype
= elf_or1k_reloc_type (type
);
1375 rtype
= elf_pj_reloc_type (type
);
1378 rtype
= elf_ia64_reloc_type (type
);
1382 rtype
= elf_cris_reloc_type (type
);
1386 rtype
= elf_i860_reloc_type (type
);
1392 rtype
= elf_x86_64_reloc_type (type
);
1396 rtype
= i370_reloc_type (type
);
1401 rtype
= elf_s390_reloc_type (type
);
1405 rtype
= elf_score_reloc_type (type
);
1409 rtype
= elf_xstormy16_reloc_type (type
);
1413 rtype
= elf_crx_reloc_type (type
);
1417 rtype
= elf_vax_reloc_type (type
);
1421 rtype
= elf_visium_reloc_type (type
);
1424 case EM_ADAPTEVA_EPIPHANY
:
1425 rtype
= elf_epiphany_reloc_type (type
);
1430 rtype
= elf_ip2k_reloc_type (type
);
1434 rtype
= elf_iq2000_reloc_type (type
);
1439 rtype
= elf_xtensa_reloc_type (type
);
1442 case EM_LATTICEMICO32
:
1443 rtype
= elf_lm32_reloc_type (type
);
1448 rtype
= elf_m32c_reloc_type (type
);
1452 rtype
= elf_mt_reloc_type (type
);
1456 rtype
= elf_bfin_reloc_type (type
);
1460 rtype
= elf_mep_reloc_type (type
);
1464 rtype
= elf_cr16_reloc_type (type
);
1468 case EM_MICROBLAZE_OLD
:
1469 rtype
= elf_microblaze_reloc_type (type
);
1473 rtype
= elf_rl78_reloc_type (type
);
1477 rtype
= elf_rx_reloc_type (type
);
1481 rtype
= elf_metag_reloc_type (type
);
1486 rtype
= elf_xc16x_reloc_type (type
);
1490 rtype
= elf_tic6x_reloc_type (type
);
1494 rtype
= elf_tilegx_reloc_type (type
);
1498 rtype
= elf_tilepro_reloc_type (type
);
1502 rtype
= elf_xgate_reloc_type (type
);
1505 case EM_ALTERA_NIOS2
:
1506 rtype
= elf_nios2_reloc_type (type
);
1510 rtype
= elf_pru_reloc_type (type
);
1515 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1517 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1519 if (elf_header
.e_machine
== EM_ALPHA
1521 && streq (rtype
, "R_ALPHA_LITUSE")
1524 switch (rels
[i
].r_addend
)
1526 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1527 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1528 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1529 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1530 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1531 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1532 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1533 default: rtype
= NULL
;
1537 printf (" (%s)", rtype
);
1541 printf (_("<unknown addend: %lx>"),
1542 (unsigned long) rels
[i
].r_addend
);
1546 else if (symtab_index
)
1548 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1550 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1555 Elf_Internal_Sym
* psym
;
1556 const char * version_string
;
1557 enum versioned_symbol_info sym_info
;
1558 unsigned short vna_other
;
1560 psym
= symtab
+ symtab_index
;
1563 = get_symbol_version_string (file
, is_dynsym
,
1572 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1576 unsigned int width
= is_32bit_elf
? 8 : 14;
1578 /* Relocations against GNU_IFUNC symbols do not use the value
1579 of the symbol as the address to relocate against. Instead
1580 they invoke the function named by the symbol and use its
1581 result as the address for relocation.
1583 To indicate this to the user, do not display the value of
1584 the symbol in the "Symbols's Value" field. Instead show
1585 its name followed by () as a hint that the symbol is
1589 || psym
->st_name
== 0
1590 || psym
->st_name
>= strtablen
)
1593 name
= strtab
+ psym
->st_name
;
1595 len
= print_symbol (width
, name
);
1597 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1599 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1603 print_vma (psym
->st_value
, LONG_HEX
);
1605 printf (is_32bit_elf
? " " : " ");
1608 if (psym
->st_name
== 0)
1610 const char * sec_name
= "<null>";
1613 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1615 if (psym
->st_shndx
< elf_header
.e_shnum
)
1616 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1617 else if (psym
->st_shndx
== SHN_ABS
)
1619 else if (psym
->st_shndx
== SHN_COMMON
)
1620 sec_name
= "COMMON";
1621 else if ((elf_header
.e_machine
== EM_MIPS
1622 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1623 || (elf_header
.e_machine
== EM_TI_C6000
1624 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1625 sec_name
= "SCOMMON";
1626 else if (elf_header
.e_machine
== EM_MIPS
1627 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1628 sec_name
= "SUNDEF";
1629 else if ((elf_header
.e_machine
== EM_X86_64
1630 || elf_header
.e_machine
== EM_L1OM
1631 || elf_header
.e_machine
== EM_K1OM
)
1632 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1633 sec_name
= "LARGE_COMMON";
1634 else if (elf_header
.e_machine
== EM_IA_64
1635 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1636 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1637 sec_name
= "ANSI_COM";
1638 else if (is_ia64_vms ()
1639 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1640 sec_name
= "VMS_SYMVEC";
1643 sprintf (name_buf
, "<section 0x%x>",
1644 (unsigned int) psym
->st_shndx
);
1645 sec_name
= name_buf
;
1648 print_symbol (22, sec_name
);
1650 else if (strtab
== NULL
)
1651 printf (_("<string table index: %3ld>"), psym
->st_name
);
1652 else if (psym
->st_name
>= strtablen
)
1654 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1659 print_symbol (22, strtab
+ psym
->st_name
);
1661 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1667 bfd_vma off
= rels
[i
].r_addend
;
1669 if ((bfd_signed_vma
) off
< 0)
1670 printf (" - %" BFD_VMA_FMT
"x", - off
);
1672 printf (" + %" BFD_VMA_FMT
"x", off
);
1678 bfd_vma off
= rels
[i
].r_addend
;
1680 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1681 if ((bfd_signed_vma
) off
< 0)
1682 printf ("-%" BFD_VMA_FMT
"x", - off
);
1684 printf ("%" BFD_VMA_FMT
"x", off
);
1687 if (elf_header
.e_machine
== EM_SPARCV9
1689 && streq (rtype
, "R_SPARC_OLO10"))
1690 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1695 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1697 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1698 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1699 const char * rtype2
= elf_mips_reloc_type (type2
);
1700 const char * rtype3
= elf_mips_reloc_type (type3
);
1702 printf (" Type2: ");
1705 printf (_("unrecognized: %-7lx"),
1706 (unsigned long) type2
& 0xffffffff);
1708 printf ("%-17.17s", rtype2
);
1710 printf ("\n Type3: ");
1713 printf (_("unrecognized: %-7lx"),
1714 (unsigned long) type3
& 0xffffffff);
1716 printf ("%-17.17s", rtype3
);
1729 get_mips_dynamic_type (unsigned long type
)
1733 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1734 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1735 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1736 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1737 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1738 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1739 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1740 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1741 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1742 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1743 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1744 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1745 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1746 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1747 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1748 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1749 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1750 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1751 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1752 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1753 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1754 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1755 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1756 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1757 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1758 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1759 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1760 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1761 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1762 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1763 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1764 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1765 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1766 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1767 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1768 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1769 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1770 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1771 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1772 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1773 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1774 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1775 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1776 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1777 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1778 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1785 get_sparc64_dynamic_type (unsigned long type
)
1789 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1796 get_ppc_dynamic_type (unsigned long type
)
1800 case DT_PPC_GOT
: return "PPC_GOT";
1801 case DT_PPC_OPT
: return "PPC_OPT";
1808 get_ppc64_dynamic_type (unsigned long type
)
1812 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1813 case DT_PPC64_OPD
: return "PPC64_OPD";
1814 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1815 case DT_PPC64_OPT
: return "PPC64_OPT";
1822 get_parisc_dynamic_type (unsigned long type
)
1826 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1827 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1828 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1829 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1830 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1831 case DT_HP_PREINIT
: return "HP_PREINIT";
1832 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1833 case DT_HP_NEEDED
: return "HP_NEEDED";
1834 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1835 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1836 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1837 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1838 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1839 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1840 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1841 case DT_HP_FILTERED
: return "HP_FILTERED";
1842 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1843 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1844 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1845 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1846 case DT_PLT
: return "PLT";
1847 case DT_PLT_SIZE
: return "PLT_SIZE";
1848 case DT_DLT
: return "DLT";
1849 case DT_DLT_SIZE
: return "DLT_SIZE";
1856 get_ia64_dynamic_type (unsigned long type
)
1860 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1861 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1862 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1863 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1864 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1865 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1866 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1867 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1868 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1869 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1870 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1871 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1872 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1873 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1874 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1875 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1876 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1877 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1878 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1879 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1880 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1881 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1882 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1883 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1884 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1885 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1886 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1887 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1888 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1889 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1890 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1897 get_solaris_section_type (unsigned long type
)
1901 case 0x6fffffee: return "SUNW_ancillary";
1902 case 0x6fffffef: return "SUNW_capchain";
1903 case 0x6ffffff0: return "SUNW_capinfo";
1904 case 0x6ffffff1: return "SUNW_symsort";
1905 case 0x6ffffff2: return "SUNW_tlssort";
1906 case 0x6ffffff3: return "SUNW_LDYNSYM";
1907 case 0x6ffffff4: return "SUNW_dof";
1908 case 0x6ffffff5: return "SUNW_cap";
1909 case 0x6ffffff6: return "SUNW_SIGNATURE";
1910 case 0x6ffffff7: return "SUNW_ANNOTATE";
1911 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1912 case 0x6ffffff9: return "SUNW_DEBUG";
1913 case 0x6ffffffa: return "SUNW_move";
1914 case 0x6ffffffb: return "SUNW_COMDAT";
1915 case 0x6ffffffc: return "SUNW_syminfo";
1916 case 0x6ffffffd: return "SUNW_verdef";
1917 case 0x6ffffffe: return "SUNW_verneed";
1918 case 0x6fffffff: return "SUNW_versym";
1919 case 0x70000000: return "SPARC_GOTDATA";
1920 default: return NULL
;
1925 get_alpha_dynamic_type (unsigned long type
)
1929 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1930 default: return NULL
;
1935 get_score_dynamic_type (unsigned long type
)
1939 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1940 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1941 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1942 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1943 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1944 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1945 default: return NULL
;
1950 get_tic6x_dynamic_type (unsigned long type
)
1954 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1955 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1956 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1957 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1958 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1959 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1960 default: return NULL
;
1965 get_nios2_dynamic_type (unsigned long type
)
1969 case DT_NIOS2_GP
: return "NIOS2_GP";
1970 default: return NULL
;
1975 get_solaris_dynamic_type (unsigned long type
)
1979 case 0x6000000d: return "SUNW_AUXILIARY";
1980 case 0x6000000e: return "SUNW_RTLDINF";
1981 case 0x6000000f: return "SUNW_FILTER";
1982 case 0x60000010: return "SUNW_CAP";
1983 case 0x60000011: return "SUNW_SYMTAB";
1984 case 0x60000012: return "SUNW_SYMSZ";
1985 case 0x60000013: return "SUNW_SORTENT";
1986 case 0x60000014: return "SUNW_SYMSORT";
1987 case 0x60000015: return "SUNW_SYMSORTSZ";
1988 case 0x60000016: return "SUNW_TLSSORT";
1989 case 0x60000017: return "SUNW_TLSSORTSZ";
1990 case 0x60000018: return "SUNW_CAPINFO";
1991 case 0x60000019: return "SUNW_STRPAD";
1992 case 0x6000001a: return "SUNW_CAPCHAIN";
1993 case 0x6000001b: return "SUNW_LDMACH";
1994 case 0x6000001d: return "SUNW_CAPCHAINENT";
1995 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1996 case 0x60000021: return "SUNW_PARENT";
1997 case 0x60000023: return "SUNW_ASLR";
1998 case 0x60000025: return "SUNW_RELAX";
1999 case 0x60000029: return "SUNW_NXHEAP";
2000 case 0x6000002b: return "SUNW_NXSTACK";
2002 case 0x70000001: return "SPARC_REGISTER";
2003 case 0x7ffffffd: return "AUXILIARY";
2004 case 0x7ffffffe: return "USED";
2005 case 0x7fffffff: return "FILTER";
2007 default: return NULL
;
2012 get_dynamic_type (unsigned long type
)
2014 static char buff
[64];
2018 case DT_NULL
: return "NULL";
2019 case DT_NEEDED
: return "NEEDED";
2020 case DT_PLTRELSZ
: return "PLTRELSZ";
2021 case DT_PLTGOT
: return "PLTGOT";
2022 case DT_HASH
: return "HASH";
2023 case DT_STRTAB
: return "STRTAB";
2024 case DT_SYMTAB
: return "SYMTAB";
2025 case DT_RELA
: return "RELA";
2026 case DT_RELASZ
: return "RELASZ";
2027 case DT_RELAENT
: return "RELAENT";
2028 case DT_STRSZ
: return "STRSZ";
2029 case DT_SYMENT
: return "SYMENT";
2030 case DT_INIT
: return "INIT";
2031 case DT_FINI
: return "FINI";
2032 case DT_SONAME
: return "SONAME";
2033 case DT_RPATH
: return "RPATH";
2034 case DT_SYMBOLIC
: return "SYMBOLIC";
2035 case DT_REL
: return "REL";
2036 case DT_RELSZ
: return "RELSZ";
2037 case DT_RELENT
: return "RELENT";
2038 case DT_PLTREL
: return "PLTREL";
2039 case DT_DEBUG
: return "DEBUG";
2040 case DT_TEXTREL
: return "TEXTREL";
2041 case DT_JMPREL
: return "JMPREL";
2042 case DT_BIND_NOW
: return "BIND_NOW";
2043 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2044 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2045 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2046 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2047 case DT_RUNPATH
: return "RUNPATH";
2048 case DT_FLAGS
: return "FLAGS";
2050 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2051 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2052 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2054 case DT_CHECKSUM
: return "CHECKSUM";
2055 case DT_PLTPADSZ
: return "PLTPADSZ";
2056 case DT_MOVEENT
: return "MOVEENT";
2057 case DT_MOVESZ
: return "MOVESZ";
2058 case DT_FEATURE
: return "FEATURE";
2059 case DT_POSFLAG_1
: return "POSFLAG_1";
2060 case DT_SYMINSZ
: return "SYMINSZ";
2061 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2063 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2064 case DT_CONFIG
: return "CONFIG";
2065 case DT_DEPAUDIT
: return "DEPAUDIT";
2066 case DT_AUDIT
: return "AUDIT";
2067 case DT_PLTPAD
: return "PLTPAD";
2068 case DT_MOVETAB
: return "MOVETAB";
2069 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2071 case DT_VERSYM
: return "VERSYM";
2073 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2074 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2075 case DT_RELACOUNT
: return "RELACOUNT";
2076 case DT_RELCOUNT
: return "RELCOUNT";
2077 case DT_FLAGS_1
: return "FLAGS_1";
2078 case DT_VERDEF
: return "VERDEF";
2079 case DT_VERDEFNUM
: return "VERDEFNUM";
2080 case DT_VERNEED
: return "VERNEED";
2081 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2083 case DT_AUXILIARY
: return "AUXILIARY";
2084 case DT_USED
: return "USED";
2085 case DT_FILTER
: return "FILTER";
2087 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2088 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2089 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2090 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2091 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2092 case DT_GNU_HASH
: return "GNU_HASH";
2095 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2097 const char * result
;
2099 switch (elf_header
.e_machine
)
2102 case EM_MIPS_RS3_LE
:
2103 result
= get_mips_dynamic_type (type
);
2106 result
= get_sparc64_dynamic_type (type
);
2109 result
= get_ppc_dynamic_type (type
);
2112 result
= get_ppc64_dynamic_type (type
);
2115 result
= get_ia64_dynamic_type (type
);
2118 result
= get_alpha_dynamic_type (type
);
2121 result
= get_score_dynamic_type (type
);
2124 result
= get_tic6x_dynamic_type (type
);
2126 case EM_ALTERA_NIOS2
:
2127 result
= get_nios2_dynamic_type (type
);
2130 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2131 result
= get_solaris_dynamic_type (type
);
2140 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2142 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2143 || (elf_header
.e_machine
== EM_PARISC
2144 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2146 const char * result
;
2148 switch (elf_header
.e_machine
)
2151 result
= get_parisc_dynamic_type (type
);
2154 result
= get_ia64_dynamic_type (type
);
2157 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2158 result
= get_solaris_dynamic_type (type
);
2167 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2171 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2178 get_file_type (unsigned e_type
)
2180 static char buff
[32];
2184 case ET_NONE
: return _("NONE (None)");
2185 case ET_REL
: return _("REL (Relocatable file)");
2186 case ET_EXEC
: return _("EXEC (Executable file)");
2187 case ET_DYN
: return _("DYN (Shared object file)");
2188 case ET_CORE
: return _("CORE (Core file)");
2191 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2192 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2193 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2194 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2196 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2202 get_machine_name (unsigned e_machine
)
2204 static char buff
[64]; /* XXX */
2208 /* Please keep this switch table sorted by increasing EM_ value. */
2210 case EM_NONE
: return _("None");
2211 case EM_M32
: return "WE32100";
2212 case EM_SPARC
: return "Sparc";
2213 case EM_386
: return "Intel 80386";
2214 case EM_68K
: return "MC68000";
2215 case EM_88K
: return "MC88000";
2216 case EM_IAMCU
: return "Intel MCU";
2217 case EM_860
: return "Intel 80860";
2218 case EM_MIPS
: return "MIPS R3000";
2219 case EM_S370
: return "IBM System/370";
2221 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2222 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2223 case EM_PARISC
: return "HPPA";
2224 case EM_VPP550
: return "Fujitsu VPP500";
2225 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2226 case EM_960
: return "Intel 90860";
2227 case EM_PPC
: return "PowerPC";
2229 case EM_PPC64
: return "PowerPC64";
2231 case EM_S390
: return "IBM S/390";
2232 case EM_SPU
: return "SPU";
2234 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2235 case EM_FR20
: return "Fujitsu FR20";
2236 case EM_RH32
: return "TRW RH32";
2237 case EM_MCORE
: return "MCORE";
2239 case EM_ARM
: return "ARM";
2240 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2241 case EM_SH
: return "Renesas / SuperH SH";
2242 case EM_SPARCV9
: return "Sparc v9";
2243 case EM_TRICORE
: return "Siemens Tricore";
2244 case EM_ARC
: return "ARC";
2245 case EM_H8_300
: return "Renesas H8/300";
2246 case EM_H8_300H
: return "Renesas H8/300H";
2247 case EM_H8S
: return "Renesas H8S";
2248 case EM_H8_500
: return "Renesas H8/500";
2250 case EM_IA_64
: return "Intel IA-64";
2251 case EM_MIPS_X
: return "Stanford MIPS-X";
2252 case EM_COLDFIRE
: return "Motorola Coldfire";
2253 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2254 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2255 case EM_PCP
: return "Siemens PCP";
2256 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2257 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2258 case EM_STARCORE
: return "Motorola Star*Core processor";
2259 case EM_ME16
: return "Toyota ME16 processor";
2261 case EM_ST100
: return "STMicroelectronics ST100 processor";
2262 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2263 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2264 case EM_PDSP
: return "Sony DSP processor";
2265 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2266 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2267 case EM_FX66
: return "Siemens FX66 microcontroller";
2268 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2269 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2270 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2272 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2273 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2274 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2275 case EM_SVX
: return "Silicon Graphics SVx";
2276 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2277 case EM_VAX
: return "Digital VAX";
2278 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2279 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2280 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2281 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2283 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2284 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2285 case EM_PRISM
: return "Vitesse Prism";
2287 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2288 case EM_CYGNUS_FR30
:
2289 case EM_FR30
: return "Fujitsu FR30";
2290 case EM_CYGNUS_D10V
:
2291 case EM_D10V
: return "d10v";
2292 case EM_CYGNUS_D30V
:
2293 case EM_D30V
: return "d30v";
2294 case EM_CYGNUS_V850
:
2295 case EM_V850
: return "Renesas V850";
2296 case EM_CYGNUS_M32R
:
2297 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2298 case EM_CYGNUS_MN10300
:
2299 case EM_MN10300
: return "mn10300";
2301 case EM_CYGNUS_MN10200
:
2302 case EM_MN10200
: return "mn10200";
2303 case EM_PJ
: return "picoJava";
2304 case EM_OR1K
: return "OpenRISC 1000";
2305 case EM_ARC_COMPACT
: return "ARCompact";
2307 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2308 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2309 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2310 case EM_NS32K
: return "National Semiconductor 32000 series";
2311 case EM_TPC
: return "Tenor Network TPC processor";
2312 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2314 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2316 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2317 case EM_MAX
: return "MAX Processor";
2318 case EM_CR
: return "National Semiconductor CompactRISC";
2319 case EM_F2MC16
: return "Fujitsu F2MC16";
2320 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2321 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2322 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2323 case EM_SEP
: return "Sharp embedded microprocessor";
2324 case EM_ARCA
: return "Arca RISC microprocessor";
2326 case EM_UNICORE
: return "Unicore";
2327 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2328 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2329 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2330 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2331 case EM_XGATE
: return "Motorola XGATE embedded processor";
2333 case EM_XC16X
: return "Infineon Technologies xc16x";
2334 case EM_M16C
: return "Renesas M16C series microprocessors";
2335 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2336 case EM_CE
: return "Freescale Communication Engine RISC core";
2338 case EM_M32C
: return "Renesas M32c";
2340 case EM_TSK3000
: return "Altium TSK3000 core";
2341 case EM_RS08
: return "Freescale RS08 embedded processor";
2342 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2343 case EM_SCORE
: return "SUNPLUS S+Core";
2344 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2345 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2346 case EM_LATTICEMICO32
: return "Lattice Mico32";
2347 case EM_SE_C17
: return "Seiko Epson C17 family";
2349 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2350 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2351 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2352 case EM_TI_PRU
: return "TI PRU I/O processor";
2354 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2355 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2356 case EM_R32C
: return "Renesas R32C series microprocessors";
2357 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2358 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2359 case EM_8051
: return "Intel 8051 and variants";
2360 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2361 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2362 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2363 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2365 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2366 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2367 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2368 case EM_RX
: return "Renesas RX";
2369 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2370 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2371 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2374 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2375 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2376 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2378 case EM_L1OM
: return "Intel L1OM";
2379 case EM_K1OM
: return "Intel K1OM";
2380 case EM_INTEL182
: return "Intel (reserved)";
2381 case EM_AARCH64
: return "AArch64";
2382 case EM_ARM184
: return "ARM (reserved)";
2383 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2384 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2385 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2386 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2388 case EM_CUDA
: return "NVIDIA CUDA architecture";
2389 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2390 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2391 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2392 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2393 case EM_ARC_COMPACT2
: return "ARCv2";
2394 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2395 case EM_RL78
: return "Renesas RL78";
2396 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2397 case EM_78K0R
: return "Renesas 78K0R";
2399 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2400 case EM_BA1
: return "Beyond BA1 CPU architecture";
2401 case EM_BA2
: return "Beyond BA2 CPU architecture";
2402 case EM_XCORE
: return "XMOS xCORE processor family";
2403 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2405 case EM_KM32
: return "KM211 KM32 32-bit processor";
2406 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2407 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2408 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2409 case EM_KVARC
: return "KM211 KVARC processor";
2410 case EM_CDP
: return "Paneve CDP architecture family";
2411 case EM_COGE
: return "Cognitive Smart Memory Processor";
2412 case EM_COOL
: return "Bluechip Systems CoolEngine";
2413 case EM_NORC
: return "Nanoradio Optimized RISC";
2414 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2416 case EM_Z80
: return "Zilog Z80";
2417 case EM_VISIUM
: return "CDS VISIUMcore processor";
2418 case EM_FT32
: return "FTDI Chip FT32";
2419 case EM_MOXIE
: return "Moxie";
2420 case EM_AMDGPU
: return "AMD GPU";
2421 case EM_RISCV
: return "RISC-V";
2422 case EM_LANAI
: return "Lanai 32-bit processor";
2423 case EM_BPF
: return "Linux BPF";
2425 /* Large numbers... */
2426 case EM_MT
: return "Morpho Techologies MT processor";
2427 case EM_ALPHA
: return "Alpha";
2428 case EM_WEBASSEMBLY
: return "Web Assembly";
2429 case EM_DLX
: return "OpenDLX";
2430 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2431 case EM_IQ2000
: return "Vitesse IQ2000";
2433 case EM_NIOS32
: return "Altera Nios";
2434 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2435 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2436 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2439 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2445 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2447 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2448 other compilers don't a specific architecture type in the e_flags, and
2449 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2450 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2453 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2454 but also sets a specific architecture type in the e_flags field.
2456 However, when decoding the flags we don't worry if we see an
2457 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2458 ARCEM architecture type. */
2460 switch (e_flags
& EF_ARC_MACH_MSK
)
2462 /* We only expect these to occur for EM_ARC_COMPACT2. */
2463 case EF_ARC_CPU_ARCV2EM
:
2464 strcat (buf
, ", ARC EM");
2466 case EF_ARC_CPU_ARCV2HS
:
2467 strcat (buf
, ", ARC HS");
2470 /* We only expect these to occur for EM_ARC_COMPACT. */
2471 case E_ARC_MACH_ARC600
:
2472 strcat (buf
, ", ARC600");
2474 case E_ARC_MACH_ARC601
:
2475 strcat (buf
, ", ARC601");
2477 case E_ARC_MACH_ARC700
:
2478 strcat (buf
, ", ARC700");
2481 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2482 new ELF with new architecture being read by an old version of
2483 readelf, or (c) An ELF built with non-GNU compiler that does not
2484 set the architecture in the e_flags. */
2486 if (e_machine
== EM_ARC_COMPACT
)
2487 strcat (buf
, ", Unknown ARCompact");
2489 strcat (buf
, ", Unknown ARC");
2493 switch (e_flags
& EF_ARC_OSABI_MSK
)
2495 case E_ARC_OSABI_ORIG
:
2496 strcat (buf
, ", (ABI:legacy)");
2498 case E_ARC_OSABI_V2
:
2499 strcat (buf
, ", (ABI:v2)");
2501 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2502 case E_ARC_OSABI_V3
:
2503 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2506 strcat (buf
, ", unrecognised ARC OSABI flag");
2512 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2515 bfd_boolean unknown
= FALSE
;
2517 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2518 e_flags
&= ~ EF_ARM_EABIMASK
;
2520 /* Handle "generic" ARM flags. */
2521 if (e_flags
& EF_ARM_RELEXEC
)
2523 strcat (buf
, ", relocatable executable");
2524 e_flags
&= ~ EF_ARM_RELEXEC
;
2527 /* Now handle EABI specific flags. */
2531 strcat (buf
, ", <unrecognized EABI>");
2536 case EF_ARM_EABI_VER1
:
2537 strcat (buf
, ", Version1 EABI");
2542 /* Process flags one bit at a time. */
2543 flag
= e_flags
& - e_flags
;
2548 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2549 strcat (buf
, ", sorted symbol tables");
2559 case EF_ARM_EABI_VER2
:
2560 strcat (buf
, ", Version2 EABI");
2565 /* Process flags one bit at a time. */
2566 flag
= e_flags
& - e_flags
;
2571 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2572 strcat (buf
, ", sorted symbol tables");
2575 case EF_ARM_DYNSYMSUSESEGIDX
:
2576 strcat (buf
, ", dynamic symbols use segment index");
2579 case EF_ARM_MAPSYMSFIRST
:
2580 strcat (buf
, ", mapping symbols precede others");
2590 case EF_ARM_EABI_VER3
:
2591 strcat (buf
, ", Version3 EABI");
2594 case EF_ARM_EABI_VER4
:
2595 strcat (buf
, ", Version4 EABI");
2600 /* Process flags one bit at a time. */
2601 flag
= e_flags
& - e_flags
;
2607 strcat (buf
, ", BE8");
2611 strcat (buf
, ", LE8");
2621 case EF_ARM_EABI_VER5
:
2622 strcat (buf
, ", Version5 EABI");
2627 /* Process flags one bit at a time. */
2628 flag
= e_flags
& - e_flags
;
2634 strcat (buf
, ", BE8");
2638 strcat (buf
, ", LE8");
2641 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2642 strcat (buf
, ", soft-float ABI");
2645 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2646 strcat (buf
, ", hard-float ABI");
2656 case EF_ARM_EABI_UNKNOWN
:
2657 strcat (buf
, ", GNU EABI");
2662 /* Process flags one bit at a time. */
2663 flag
= e_flags
& - e_flags
;
2668 case EF_ARM_INTERWORK
:
2669 strcat (buf
, ", interworking enabled");
2672 case EF_ARM_APCS_26
:
2673 strcat (buf
, ", uses APCS/26");
2676 case EF_ARM_APCS_FLOAT
:
2677 strcat (buf
, ", uses APCS/float");
2681 strcat (buf
, ", position independent");
2685 strcat (buf
, ", 8 bit structure alignment");
2688 case EF_ARM_NEW_ABI
:
2689 strcat (buf
, ", uses new ABI");
2692 case EF_ARM_OLD_ABI
:
2693 strcat (buf
, ", uses old ABI");
2696 case EF_ARM_SOFT_FLOAT
:
2697 strcat (buf
, ", software FP");
2700 case EF_ARM_VFP_FLOAT
:
2701 strcat (buf
, ", VFP");
2704 case EF_ARM_MAVERICK_FLOAT
:
2705 strcat (buf
, ", Maverick FP");
2716 strcat (buf
,_(", <unknown>"));
2720 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2722 --size
; /* Leave space for null terminator. */
2724 switch (e_flags
& EF_AVR_MACH
)
2726 case E_AVR_MACH_AVR1
:
2727 strncat (buf
, ", avr:1", size
);
2729 case E_AVR_MACH_AVR2
:
2730 strncat (buf
, ", avr:2", size
);
2732 case E_AVR_MACH_AVR25
:
2733 strncat (buf
, ", avr:25", size
);
2735 case E_AVR_MACH_AVR3
:
2736 strncat (buf
, ", avr:3", size
);
2738 case E_AVR_MACH_AVR31
:
2739 strncat (buf
, ", avr:31", size
);
2741 case E_AVR_MACH_AVR35
:
2742 strncat (buf
, ", avr:35", size
);
2744 case E_AVR_MACH_AVR4
:
2745 strncat (buf
, ", avr:4", size
);
2747 case E_AVR_MACH_AVR5
:
2748 strncat (buf
, ", avr:5", size
);
2750 case E_AVR_MACH_AVR51
:
2751 strncat (buf
, ", avr:51", size
);
2753 case E_AVR_MACH_AVR6
:
2754 strncat (buf
, ", avr:6", size
);
2756 case E_AVR_MACH_AVRTINY
:
2757 strncat (buf
, ", avr:100", size
);
2759 case E_AVR_MACH_XMEGA1
:
2760 strncat (buf
, ", avr:101", size
);
2762 case E_AVR_MACH_XMEGA2
:
2763 strncat (buf
, ", avr:102", size
);
2765 case E_AVR_MACH_XMEGA3
:
2766 strncat (buf
, ", avr:103", size
);
2768 case E_AVR_MACH_XMEGA4
:
2769 strncat (buf
, ", avr:104", size
);
2771 case E_AVR_MACH_XMEGA5
:
2772 strncat (buf
, ", avr:105", size
);
2774 case E_AVR_MACH_XMEGA6
:
2775 strncat (buf
, ", avr:106", size
);
2777 case E_AVR_MACH_XMEGA7
:
2778 strncat (buf
, ", avr:107", size
);
2781 strncat (buf
, ", avr:<unknown>", size
);
2785 size
-= strlen (buf
);
2786 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2787 strncat (buf
, ", link-relax", size
);
2791 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2797 bfd_boolean has_fpu
= FALSE
;
2800 static const char *ABI_STRINGS
[] =
2802 "ABI v0", /* use r5 as return register; only used in N1213HC */
2803 "ABI v1", /* use r0 as return register */
2804 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2805 "ABI v2fp", /* for FPU */
2809 static const char *VER_STRINGS
[] =
2811 "Andes ELF V1.3 or older",
2815 static const char *ARCH_STRINGS
[] =
2824 abi
= EF_NDS_ABI
& e_flags
;
2825 arch
= EF_NDS_ARCH
& e_flags
;
2826 config
= EF_NDS_INST
& e_flags
;
2827 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2829 memset (buf
, 0, size
);
2836 case E_NDS_ABI_V2FP
:
2837 case E_NDS_ABI_AABI
:
2838 case E_NDS_ABI_V2FP_PLUS
:
2839 /* In case there are holes in the array. */
2840 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2844 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2850 case E_NDS32_ELF_VER_1_2
:
2851 case E_NDS32_ELF_VER_1_3
:
2852 case E_NDS32_ELF_VER_1_4
:
2853 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2857 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2861 if (E_NDS_ABI_V0
== abi
)
2863 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2864 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2865 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2866 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2872 case E_NDS_ARCH_STAR_V1_0
:
2873 case E_NDS_ARCH_STAR_V2_0
:
2874 case E_NDS_ARCH_STAR_V3_0
:
2875 case E_NDS_ARCH_STAR_V3_M
:
2876 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2880 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2881 /* ARCH version determines how the e_flags are interpreted.
2882 If it is unknown, we cannot proceed. */
2886 /* Newer ABI; Now handle architecture specific flags. */
2887 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2889 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2890 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2892 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2893 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2895 if (config
& E_NDS32_HAS_DIV_INST
)
2896 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2898 if (config
& E_NDS32_HAS_16BIT_INST
)
2899 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2903 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2905 if (version
<= E_NDS32_ELF_VER_1_3
)
2906 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2908 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2911 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2912 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2914 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2915 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2917 if (config
& E_NDS32_HAS_16BIT_INST
)
2919 if (version
<= E_NDS32_ELF_VER_1_3
)
2920 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2922 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2926 if (config
& E_NDS32_HAS_EXT_INST
)
2927 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2929 if (config
& E_NDS32_HAS_EXT2_INST
)
2930 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2932 if (config
& E_NDS32_HAS_FPU_INST
)
2935 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2938 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2941 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2944 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2947 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2952 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2954 case E_NDS32_FPU_REG_8SP_4DP
:
2955 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2957 case E_NDS32_FPU_REG_16SP_8DP
:
2958 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2960 case E_NDS32_FPU_REG_32SP_16DP
:
2961 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2963 case E_NDS32_FPU_REG_32SP_32DP
:
2964 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2969 if (config
& E_NDS32_HAS_AUDIO_INST
)
2970 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2972 if (config
& E_NDS32_HAS_STRING_INST
)
2973 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2975 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2976 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2978 if (config
& E_NDS32_HAS_VIDEO_INST
)
2980 if (version
<= E_NDS32_ELF_VER_1_3
)
2981 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2983 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2986 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2987 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2989 if (config
& E_NDS32_HAS_L2C_INST
)
2990 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2994 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2996 static char buf
[1024];
3007 case EM_ARC_COMPACT2
:
3008 case EM_ARC_COMPACT
:
3009 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3013 decode_ARM_machine_flags (e_flags
, buf
);
3017 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3021 if (e_flags
& EF_BFIN_PIC
)
3022 strcat (buf
, ", PIC");
3024 if (e_flags
& EF_BFIN_FDPIC
)
3025 strcat (buf
, ", FDPIC");
3027 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3028 strcat (buf
, ", code in L1");
3030 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3031 strcat (buf
, ", data in L1");
3036 switch (e_flags
& EF_FRV_CPU_MASK
)
3038 case EF_FRV_CPU_GENERIC
:
3042 strcat (buf
, ", fr???");
3045 case EF_FRV_CPU_FR300
:
3046 strcat (buf
, ", fr300");
3049 case EF_FRV_CPU_FR400
:
3050 strcat (buf
, ", fr400");
3052 case EF_FRV_CPU_FR405
:
3053 strcat (buf
, ", fr405");
3056 case EF_FRV_CPU_FR450
:
3057 strcat (buf
, ", fr450");
3060 case EF_FRV_CPU_FR500
:
3061 strcat (buf
, ", fr500");
3063 case EF_FRV_CPU_FR550
:
3064 strcat (buf
, ", fr550");
3067 case EF_FRV_CPU_SIMPLE
:
3068 strcat (buf
, ", simple");
3070 case EF_FRV_CPU_TOMCAT
:
3071 strcat (buf
, ", tomcat");
3077 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3078 strcat (buf
, ", m68000");
3079 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3080 strcat (buf
, ", cpu32");
3081 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3082 strcat (buf
, ", fido_a");
3085 char const * isa
= _("unknown");
3086 char const * mac
= _("unknown mac");
3087 char const * additional
= NULL
;
3089 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3091 case EF_M68K_CF_ISA_A_NODIV
:
3093 additional
= ", nodiv";
3095 case EF_M68K_CF_ISA_A
:
3098 case EF_M68K_CF_ISA_A_PLUS
:
3101 case EF_M68K_CF_ISA_B_NOUSP
:
3103 additional
= ", nousp";
3105 case EF_M68K_CF_ISA_B
:
3108 case EF_M68K_CF_ISA_C
:
3111 case EF_M68K_CF_ISA_C_NODIV
:
3113 additional
= ", nodiv";
3116 strcat (buf
, ", cf, isa ");
3119 strcat (buf
, additional
);
3120 if (e_flags
& EF_M68K_CF_FLOAT
)
3121 strcat (buf
, ", float");
3122 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3127 case EF_M68K_CF_MAC
:
3130 case EF_M68K_CF_EMAC
:
3133 case EF_M68K_CF_EMAC_B
:
3146 switch (e_flags
& EF_MEP_CPU_MASK
)
3148 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3149 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3150 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3151 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3152 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3153 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3154 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3157 switch (e_flags
& EF_MEP_COP_MASK
)
3159 case EF_MEP_COP_NONE
: break;
3160 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3161 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3162 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3163 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3164 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3167 if (e_flags
& EF_MEP_LIBRARY
)
3168 strcat (buf
, ", Built for Library");
3170 if (e_flags
& EF_MEP_INDEX_MASK
)
3171 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3172 e_flags
& EF_MEP_INDEX_MASK
);
3174 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3175 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3176 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3180 if (e_flags
& EF_PPC_EMB
)
3181 strcat (buf
, ", emb");
3183 if (e_flags
& EF_PPC_RELOCATABLE
)
3184 strcat (buf
, _(", relocatable"));
3186 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3187 strcat (buf
, _(", relocatable-lib"));
3191 if (e_flags
& EF_PPC64_ABI
)
3193 char abi
[] = ", abiv0";
3195 abi
[6] += e_flags
& EF_PPC64_ABI
;
3201 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3202 strcat (buf
, ", RH850 ABI");
3204 if (e_flags
& EF_V800_850E3
)
3205 strcat (buf
, ", V3 architecture");
3207 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3208 strcat (buf
, ", FPU not used");
3210 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3211 strcat (buf
, ", regmode: COMMON");
3213 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3214 strcat (buf
, ", r4 not used");
3216 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3217 strcat (buf
, ", r30 not used");
3219 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3220 strcat (buf
, ", r5 not used");
3222 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3223 strcat (buf
, ", r2 not used");
3225 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3227 switch (e_flags
& - e_flags
)
3229 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3230 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3231 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3232 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3233 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3234 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3235 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3236 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3237 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3238 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3239 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3240 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3247 case EM_CYGNUS_V850
:
3248 switch (e_flags
& EF_V850_ARCH
)
3250 case E_V850E3V5_ARCH
:
3251 strcat (buf
, ", v850e3v5");
3253 case E_V850E2V3_ARCH
:
3254 strcat (buf
, ", v850e2v3");
3257 strcat (buf
, ", v850e2");
3260 strcat (buf
, ", v850e1");
3263 strcat (buf
, ", v850e");
3266 strcat (buf
, ", v850");
3269 strcat (buf
, _(", unknown v850 architecture variant"));
3275 case EM_CYGNUS_M32R
:
3276 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3277 strcat (buf
, ", m32r");
3281 case EM_MIPS_RS3_LE
:
3282 if (e_flags
& EF_MIPS_NOREORDER
)
3283 strcat (buf
, ", noreorder");
3285 if (e_flags
& EF_MIPS_PIC
)
3286 strcat (buf
, ", pic");
3288 if (e_flags
& EF_MIPS_CPIC
)
3289 strcat (buf
, ", cpic");
3291 if (e_flags
& EF_MIPS_UCODE
)
3292 strcat (buf
, ", ugen_reserved");
3294 if (e_flags
& EF_MIPS_ABI2
)
3295 strcat (buf
, ", abi2");
3297 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3298 strcat (buf
, ", odk first");
3300 if (e_flags
& EF_MIPS_32BITMODE
)
3301 strcat (buf
, ", 32bitmode");
3303 if (e_flags
& EF_MIPS_NAN2008
)
3304 strcat (buf
, ", nan2008");
3306 if (e_flags
& EF_MIPS_FP64
)
3307 strcat (buf
, ", fp64");
3309 switch ((e_flags
& EF_MIPS_MACH
))
3311 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3312 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3313 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3314 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3315 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3316 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3317 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3318 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3319 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3320 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3321 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3322 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3323 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3324 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3325 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3326 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3327 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3329 /* We simply ignore the field in this case to avoid confusion:
3330 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3333 default: strcat (buf
, _(", unknown CPU")); break;
3336 switch ((e_flags
& EF_MIPS_ABI
))
3338 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3339 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3340 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3341 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3343 /* We simply ignore the field in this case to avoid confusion:
3344 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3345 This means it is likely to be an o32 file, but not for
3348 default: strcat (buf
, _(", unknown ABI")); break;
3351 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3352 strcat (buf
, ", mdmx");
3354 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3355 strcat (buf
, ", mips16");
3357 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3358 strcat (buf
, ", micromips");
3360 switch ((e_flags
& EF_MIPS_ARCH
))
3362 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3363 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3364 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3365 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3366 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3367 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3368 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3369 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3370 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3371 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3372 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3373 default: strcat (buf
, _(", unknown ISA")); break;
3378 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3382 if (e_flags
& EF_RISCV_RVC
)
3383 strcat (buf
, ", RVC");
3385 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3387 case EF_RISCV_FLOAT_ABI_SOFT
:
3388 strcat (buf
, ", soft-float ABI");
3391 case EF_RISCV_FLOAT_ABI_SINGLE
:
3392 strcat (buf
, ", single-float ABI");
3395 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3396 strcat (buf
, ", double-float ABI");
3399 case EF_RISCV_FLOAT_ABI_QUAD
:
3400 strcat (buf
, ", quad-float ABI");
3406 switch ((e_flags
& EF_SH_MACH_MASK
))
3408 case EF_SH1
: strcat (buf
, ", sh1"); break;
3409 case EF_SH2
: strcat (buf
, ", sh2"); break;
3410 case EF_SH3
: strcat (buf
, ", sh3"); break;
3411 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3412 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3413 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3414 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3415 case EF_SH4
: strcat (buf
, ", sh4"); break;
3416 case EF_SH5
: strcat (buf
, ", sh5"); break;
3417 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3418 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3419 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3420 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3421 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3422 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3423 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3424 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3425 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3426 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3427 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3428 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3429 default: strcat (buf
, _(", unknown ISA")); break;
3432 if (e_flags
& EF_SH_PIC
)
3433 strcat (buf
, ", pic");
3435 if (e_flags
& EF_SH_FDPIC
)
3436 strcat (buf
, ", fdpic");
3440 if (e_flags
& EF_OR1K_NODELAY
)
3441 strcat (buf
, ", no delay");
3445 if (e_flags
& EF_SPARC_32PLUS
)
3446 strcat (buf
, ", v8+");
3448 if (e_flags
& EF_SPARC_SUN_US1
)
3449 strcat (buf
, ", ultrasparcI");
3451 if (e_flags
& EF_SPARC_SUN_US3
)
3452 strcat (buf
, ", ultrasparcIII");
3454 if (e_flags
& EF_SPARC_HAL_R1
)
3455 strcat (buf
, ", halr1");
3457 if (e_flags
& EF_SPARC_LEDATA
)
3458 strcat (buf
, ", ledata");
3460 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3461 strcat (buf
, ", tso");
3463 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3464 strcat (buf
, ", pso");
3466 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3467 strcat (buf
, ", rmo");
3471 switch (e_flags
& EF_PARISC_ARCH
)
3473 case EFA_PARISC_1_0
:
3474 strcpy (buf
, ", PA-RISC 1.0");
3476 case EFA_PARISC_1_1
:
3477 strcpy (buf
, ", PA-RISC 1.1");
3479 case EFA_PARISC_2_0
:
3480 strcpy (buf
, ", PA-RISC 2.0");
3485 if (e_flags
& EF_PARISC_TRAPNIL
)
3486 strcat (buf
, ", trapnil");
3487 if (e_flags
& EF_PARISC_EXT
)
3488 strcat (buf
, ", ext");
3489 if (e_flags
& EF_PARISC_LSB
)
3490 strcat (buf
, ", lsb");
3491 if (e_flags
& EF_PARISC_WIDE
)
3492 strcat (buf
, ", wide");
3493 if (e_flags
& EF_PARISC_NO_KABP
)
3494 strcat (buf
, ", no kabp");
3495 if (e_flags
& EF_PARISC_LAZYSWAP
)
3496 strcat (buf
, ", lazyswap");
3501 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3502 strcat (buf
, ", new calling convention");
3504 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3505 strcat (buf
, ", gnu calling convention");
3509 if ((e_flags
& EF_IA_64_ABI64
))
3510 strcat (buf
, ", 64-bit");
3512 strcat (buf
, ", 32-bit");
3513 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3514 strcat (buf
, ", reduced fp model");
3515 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3516 strcat (buf
, ", no function descriptors, constant gp");
3517 else if ((e_flags
& EF_IA_64_CONS_GP
))
3518 strcat (buf
, ", constant gp");
3519 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3520 strcat (buf
, ", absolute");
3521 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3523 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3524 strcat (buf
, ", vms_linkages");
3525 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3527 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3529 case EF_IA_64_VMS_COMCOD_WARNING
:
3530 strcat (buf
, ", warning");
3532 case EF_IA_64_VMS_COMCOD_ERROR
:
3533 strcat (buf
, ", error");
3535 case EF_IA_64_VMS_COMCOD_ABORT
:
3536 strcat (buf
, ", abort");
3539 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3540 e_flags
& EF_IA_64_VMS_COMCOD
);
3541 strcat (buf
, ", <unknown>");
3547 if ((e_flags
& EF_VAX_NONPIC
))
3548 strcat (buf
, ", non-PIC");
3549 if ((e_flags
& EF_VAX_DFLOAT
))
3550 strcat (buf
, ", D-Float");
3551 if ((e_flags
& EF_VAX_GFLOAT
))
3552 strcat (buf
, ", G-Float");
3556 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3557 strcat (buf
, ", mcm");
3558 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3559 strcat (buf
, ", mcm24");
3560 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3561 strcat (buf
, ", gr6");
3565 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3567 case E_FLAG_RL78_ANY_CPU
: break;
3568 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3569 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3570 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3572 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3573 strcat (buf
, ", 64-bit doubles");
3577 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3578 strcat (buf
, ", 64-bit doubles");
3579 if (e_flags
& E_FLAG_RX_DSP
)
3580 strcat (buf
, ", dsp");
3581 if (e_flags
& E_FLAG_RX_PID
)
3582 strcat (buf
, ", pid");
3583 if (e_flags
& E_FLAG_RX_ABI
)
3584 strcat (buf
, ", RX ABI");
3585 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3586 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3587 ? ", uses String instructions" : ", bans String instructions");
3588 if (e_flags
& E_FLAG_RX_V2
)
3589 strcat (buf
, ", V2");
3593 if (e_flags
& EF_S390_HIGH_GPRS
)
3594 strcat (buf
, ", highgprs");
3598 if ((e_flags
& EF_C6000_REL
))
3599 strcat (buf
, ", relocatable module");
3603 strcat (buf
, _(": architecture variant: "));
3604 switch (e_flags
& EF_MSP430_MACH
)
3606 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3607 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3608 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3609 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3610 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3611 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3612 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3613 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3614 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3615 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3616 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3617 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3618 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3619 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3620 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3622 strcat (buf
, _(": unknown")); break;
3625 if (e_flags
& ~ EF_MSP430_MACH
)
3626 strcat (buf
, _(": unknown extra flag bits also present"));
3634 get_osabi_name (unsigned int osabi
)
3636 static char buff
[32];
3640 case ELFOSABI_NONE
: return "UNIX - System V";
3641 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3642 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3643 case ELFOSABI_GNU
: return "UNIX - GNU";
3644 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3645 case ELFOSABI_AIX
: return "UNIX - AIX";
3646 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3647 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3648 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3649 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3650 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3651 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3652 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3653 case ELFOSABI_AROS
: return "AROS";
3654 case ELFOSABI_FENIXOS
: return "FenixOS";
3655 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3656 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3659 switch (elf_header
.e_machine
)
3664 case ELFOSABI_ARM
: return "ARM";
3675 case ELFOSABI_STANDALONE
: return _("Standalone App");
3684 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3685 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3694 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3700 get_aarch64_segment_type (unsigned long type
)
3704 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3705 default: return NULL
;
3710 get_arm_segment_type (unsigned long type
)
3714 case PT_ARM_EXIDX
: return "EXIDX";
3715 default: return NULL
;
3720 get_mips_segment_type (unsigned long type
)
3724 case PT_MIPS_REGINFO
: return "REGINFO";
3725 case PT_MIPS_RTPROC
: return "RTPROC";
3726 case PT_MIPS_OPTIONS
: return "OPTIONS";
3727 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3728 default: return NULL
;
3733 get_parisc_segment_type (unsigned long type
)
3737 case PT_HP_TLS
: return "HP_TLS";
3738 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3739 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3740 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3741 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3742 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3743 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3744 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3745 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3746 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3747 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3748 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3749 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3750 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3751 case PT_HP_STACK
: return "HP_STACK";
3752 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3753 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3754 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3755 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3756 default: return NULL
;
3761 get_ia64_segment_type (unsigned long type
)
3765 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3766 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3767 case PT_HP_TLS
: return "HP_TLS";
3768 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3769 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3770 case PT_IA_64_HP_STACK
: return "HP_STACK";
3771 default: return NULL
;
3776 get_tic6x_segment_type (unsigned long type
)
3780 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3781 default: return NULL
;
3786 get_solaris_segment_type (unsigned long type
)
3790 case 0x6464e550: return "PT_SUNW_UNWIND";
3791 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3792 case 0x6ffffff7: return "PT_LOSUNW";
3793 case 0x6ffffffa: return "PT_SUNWBSS";
3794 case 0x6ffffffb: return "PT_SUNWSTACK";
3795 case 0x6ffffffc: return "PT_SUNWDTRACE";
3796 case 0x6ffffffd: return "PT_SUNWCAP";
3797 case 0x6fffffff: return "PT_HISUNW";
3798 default: return NULL
;
3803 get_segment_type (unsigned long p_type
)
3805 static char buff
[32];
3809 case PT_NULL
: return "NULL";
3810 case PT_LOAD
: return "LOAD";
3811 case PT_DYNAMIC
: return "DYNAMIC";
3812 case PT_INTERP
: return "INTERP";
3813 case PT_NOTE
: return "NOTE";
3814 case PT_SHLIB
: return "SHLIB";
3815 case PT_PHDR
: return "PHDR";
3816 case PT_TLS
: return "TLS";
3817 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3818 case PT_GNU_STACK
: return "GNU_STACK";
3819 case PT_GNU_RELRO
: return "GNU_RELRO";
3822 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3824 const char * result
;
3826 switch (elf_header
.e_machine
)
3829 result
= get_aarch64_segment_type (p_type
);
3832 result
= get_arm_segment_type (p_type
);
3835 case EM_MIPS_RS3_LE
:
3836 result
= get_mips_segment_type (p_type
);
3839 result
= get_parisc_segment_type (p_type
);
3842 result
= get_ia64_segment_type (p_type
);
3845 result
= get_tic6x_segment_type (p_type
);
3855 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3857 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3859 const char * result
;
3861 switch (elf_header
.e_machine
)
3864 result
= get_parisc_segment_type (p_type
);
3867 result
= get_ia64_segment_type (p_type
);
3870 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3871 result
= get_solaris_segment_type (p_type
);
3880 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3883 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3890 get_mips_section_type_name (unsigned int sh_type
)
3894 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3895 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3896 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3897 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3898 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3899 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3900 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3901 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3902 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3903 case SHT_MIPS_RELD
: return "MIPS_RELD";
3904 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3905 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3906 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3907 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3908 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3909 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3910 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3911 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3912 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3913 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3914 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3915 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3916 case SHT_MIPS_LINE
: return "MIPS_LINE";
3917 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3918 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3919 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3920 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3921 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3922 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3923 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3924 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3925 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3926 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3927 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3928 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3929 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3930 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3931 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3932 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3933 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3941 get_parisc_section_type_name (unsigned int sh_type
)
3945 case SHT_PARISC_EXT
: return "PARISC_EXT";
3946 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3947 case SHT_PARISC_DOC
: return "PARISC_DOC";
3948 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3949 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3950 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3951 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3952 default: return NULL
;
3957 get_ia64_section_type_name (unsigned int sh_type
)
3959 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3960 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3961 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3965 case SHT_IA_64_EXT
: return "IA_64_EXT";
3966 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3967 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3968 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3969 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3970 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3971 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3972 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3973 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3974 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3982 get_x86_64_section_type_name (unsigned int sh_type
)
3986 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3987 default: return NULL
;
3992 get_aarch64_section_type_name (unsigned int sh_type
)
3996 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
3997 default: return NULL
;
4002 get_arm_section_type_name (unsigned int sh_type
)
4006 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4007 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4008 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4009 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4010 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4011 default: return NULL
;
4016 get_tic6x_section_type_name (unsigned int sh_type
)
4020 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4021 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4022 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4023 case SHT_TI_ICODE
: return "TI_ICODE";
4024 case SHT_TI_XREF
: return "TI_XREF";
4025 case SHT_TI_HANDLER
: return "TI_HANDLER";
4026 case SHT_TI_INITINFO
: return "TI_INITINFO";
4027 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4028 default: return NULL
;
4033 get_msp430x_section_type_name (unsigned int sh_type
)
4037 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4038 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4039 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4040 default: return NULL
;
4045 get_v850_section_type_name (unsigned int sh_type
)
4049 case SHT_V850_SCOMMON
: return "V850 Small Common";
4050 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4051 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4052 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4053 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4054 default: return NULL
;
4059 get_section_type_name (unsigned int sh_type
)
4061 static char buff
[32];
4062 const char * result
;
4066 case SHT_NULL
: return "NULL";
4067 case SHT_PROGBITS
: return "PROGBITS";
4068 case SHT_SYMTAB
: return "SYMTAB";
4069 case SHT_STRTAB
: return "STRTAB";
4070 case SHT_RELA
: return "RELA";
4071 case SHT_HASH
: return "HASH";
4072 case SHT_DYNAMIC
: return "DYNAMIC";
4073 case SHT_NOTE
: return "NOTE";
4074 case SHT_NOBITS
: return "NOBITS";
4075 case SHT_REL
: return "REL";
4076 case SHT_SHLIB
: return "SHLIB";
4077 case SHT_DYNSYM
: return "DYNSYM";
4078 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4079 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4080 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4081 case SHT_GNU_HASH
: return "GNU_HASH";
4082 case SHT_GROUP
: return "GROUP";
4083 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4084 case SHT_GNU_verdef
: return "VERDEF";
4085 case SHT_GNU_verneed
: return "VERNEED";
4086 case SHT_GNU_versym
: return "VERSYM";
4087 case 0x6ffffff0: return "VERSYM";
4088 case 0x6ffffffc: return "VERDEF";
4089 case 0x7ffffffd: return "AUXILIARY";
4090 case 0x7fffffff: return "FILTER";
4091 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4094 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4096 switch (elf_header
.e_machine
)
4099 case EM_MIPS_RS3_LE
:
4100 result
= get_mips_section_type_name (sh_type
);
4103 result
= get_parisc_section_type_name (sh_type
);
4106 result
= get_ia64_section_type_name (sh_type
);
4111 result
= get_x86_64_section_type_name (sh_type
);
4114 result
= get_aarch64_section_type_name (sh_type
);
4117 result
= get_arm_section_type_name (sh_type
);
4120 result
= get_tic6x_section_type_name (sh_type
);
4123 result
= get_msp430x_section_type_name (sh_type
);
4127 case EM_CYGNUS_V850
:
4128 result
= get_v850_section_type_name (sh_type
);
4138 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4140 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4142 switch (elf_header
.e_machine
)
4145 result
= get_ia64_section_type_name (sh_type
);
4148 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4149 result
= get_solaris_section_type (sh_type
);
4154 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4155 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4156 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4157 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4169 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4171 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4173 switch (elf_header
.e_machine
)
4177 case EM_CYGNUS_V850
:
4178 result
= get_v850_section_type_name (sh_type
);
4188 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4191 /* This message is probably going to be displayed in a 15
4192 character wide field, so put the hex value first. */
4193 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4199 #define OPTION_DEBUG_DUMP 512
4200 #define OPTION_DYN_SYMS 513
4201 #define OPTION_DWARF_DEPTH 514
4202 #define OPTION_DWARF_START 515
4203 #define OPTION_DWARF_CHECK 516
4205 static struct option options
[] =
4207 {"all", no_argument
, 0, 'a'},
4208 {"file-header", no_argument
, 0, 'h'},
4209 {"program-headers", no_argument
, 0, 'l'},
4210 {"headers", no_argument
, 0, 'e'},
4211 {"histogram", no_argument
, 0, 'I'},
4212 {"segments", no_argument
, 0, 'l'},
4213 {"sections", no_argument
, 0, 'S'},
4214 {"section-headers", no_argument
, 0, 'S'},
4215 {"section-groups", no_argument
, 0, 'g'},
4216 {"section-details", no_argument
, 0, 't'},
4217 {"full-section-name",no_argument
, 0, 'N'},
4218 {"symbols", no_argument
, 0, 's'},
4219 {"syms", no_argument
, 0, 's'},
4220 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4221 {"relocs", no_argument
, 0, 'r'},
4222 {"notes", no_argument
, 0, 'n'},
4223 {"dynamic", no_argument
, 0, 'd'},
4224 {"arch-specific", no_argument
, 0, 'A'},
4225 {"version-info", no_argument
, 0, 'V'},
4226 {"use-dynamic", no_argument
, 0, 'D'},
4227 {"unwind", no_argument
, 0, 'u'},
4228 {"archive-index", no_argument
, 0, 'c'},
4229 {"hex-dump", required_argument
, 0, 'x'},
4230 {"relocated-dump", required_argument
, 0, 'R'},
4231 {"string-dump", required_argument
, 0, 'p'},
4232 {"decompress", no_argument
, 0, 'z'},
4233 #ifdef SUPPORT_DISASSEMBLY
4234 {"instruction-dump", required_argument
, 0, 'i'},
4236 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4238 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4239 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4240 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4242 {"version", no_argument
, 0, 'v'},
4243 {"wide", no_argument
, 0, 'W'},
4244 {"help", no_argument
, 0, 'H'},
4245 {0, no_argument
, 0, 0}
4249 usage (FILE * stream
)
4251 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4252 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4253 fprintf (stream
, _(" Options are:\n\
4254 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4255 -h --file-header Display the ELF file header\n\
4256 -l --program-headers Display the program headers\n\
4257 --segments An alias for --program-headers\n\
4258 -S --section-headers Display the sections' header\n\
4259 --sections An alias for --section-headers\n\
4260 -g --section-groups Display the section groups\n\
4261 -t --section-details Display the section details\n\
4262 -e --headers Equivalent to: -h -l -S\n\
4263 -s --syms Display the symbol table\n\
4264 --symbols An alias for --syms\n\
4265 --dyn-syms Display the dynamic symbol table\n\
4266 -n --notes Display the core notes (if present)\n\
4267 -r --relocs Display the relocations (if present)\n\
4268 -u --unwind Display the unwind info (if present)\n\
4269 -d --dynamic Display the dynamic section (if present)\n\
4270 -V --version-info Display the version sections (if present)\n\
4271 -A --arch-specific Display architecture specific information (if any)\n\
4272 -c --archive-index Display the symbol/file index in an archive\n\
4273 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4274 -x --hex-dump=<number|name>\n\
4275 Dump the contents of section <number|name> as bytes\n\
4276 -p --string-dump=<number|name>\n\
4277 Dump the contents of section <number|name> as strings\n\
4278 -R --relocated-dump=<number|name>\n\
4279 Dump the contents of section <number|name> as relocated bytes\n\
4280 -z --decompress Decompress section before dumping it\n\
4281 -w[lLiaprmfFsoRt] or\n\
4282 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4283 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4284 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4286 Display the contents of DWARF2 debug sections\n"));
4287 fprintf (stream
, _("\
4288 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4289 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4291 #ifdef SUPPORT_DISASSEMBLY
4292 fprintf (stream
, _("\
4293 -i --instruction-dump=<number|name>\n\
4294 Disassemble the contents of section <number|name>\n"));
4296 fprintf (stream
, _("\
4297 -I --histogram Display histogram of bucket list lengths\n\
4298 -W --wide Allow output width to exceed 80 characters\n\
4299 @<file> Read options from <file>\n\
4300 -H --help Display this information\n\
4301 -v --version Display the version number of readelf\n"));
4303 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4304 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4306 exit (stream
== stdout
? 0 : 1);
4309 /* Record the fact that the user wants the contents of section number
4310 SECTION to be displayed using the method(s) encoded as flags bits
4311 in TYPE. Note, TYPE can be zero if we are creating the array for
4315 request_dump_bynumber (unsigned int section
, dump_type type
)
4317 if (section
>= num_dump_sects
)
4319 dump_type
* new_dump_sects
;
4321 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4322 sizeof (* dump_sects
));
4324 if (new_dump_sects
== NULL
)
4325 error (_("Out of memory allocating dump request table.\n"));
4330 /* Copy current flag settings. */
4331 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4336 dump_sects
= new_dump_sects
;
4337 num_dump_sects
= section
+ 1;
4342 dump_sects
[section
] |= type
;
4347 /* Request a dump by section name. */
4350 request_dump_byname (const char * section
, dump_type type
)
4352 struct dump_list_entry
* new_request
;
4354 new_request
= (struct dump_list_entry
*)
4355 malloc (sizeof (struct dump_list_entry
));
4357 error (_("Out of memory allocating dump request table.\n"));
4359 new_request
->name
= strdup (section
);
4360 if (!new_request
->name
)
4361 error (_("Out of memory allocating dump request table.\n"));
4363 new_request
->type
= type
;
4365 new_request
->next
= dump_sects_byname
;
4366 dump_sects_byname
= new_request
;
4370 request_dump (dump_type type
)
4376 section
= strtoul (optarg
, & cp
, 0);
4378 if (! *cp
&& section
>= 0)
4379 request_dump_bynumber (section
, type
);
4381 request_dump_byname (optarg
, type
);
4386 parse_args (int argc
, char ** argv
)
4393 while ((c
= getopt_long
4394 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4412 do_section_groups
= TRUE
;
4415 do_histogram
= TRUE
;
4420 do_section_groups
= TRUE
;
4425 do_section_details
= TRUE
;
4436 do_using_dynamic
= TRUE
;
4460 do_histogram
= TRUE
;
4466 do_archive_index
= TRUE
;
4469 request_dump (HEX_DUMP
);
4472 request_dump (STRING_DUMP
);
4475 request_dump (RELOC_DUMP
);
4478 decompress_dumps
= TRUE
;
4484 do_debugging
= TRUE
;
4485 dwarf_select_sections_all ();
4489 do_debugging
= FALSE
;
4490 dwarf_select_sections_by_letters (optarg
);
4493 case OPTION_DEBUG_DUMP
:
4496 do_debugging
= TRUE
;
4499 do_debugging
= FALSE
;
4500 dwarf_select_sections_by_names (optarg
);
4503 case OPTION_DWARF_DEPTH
:
4507 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4510 case OPTION_DWARF_START
:
4514 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4517 case OPTION_DWARF_CHECK
:
4520 case OPTION_DYN_SYMS
:
4523 #ifdef SUPPORT_DISASSEMBLY
4525 request_dump (DISASS_DUMP
);
4529 print_version (program_name
);
4538 /* xgettext:c-format */
4539 error (_("Invalid option '-%c'\n"), c
);
4546 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4547 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4548 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4549 && !do_section_groups
&& !do_archive_index
4555 get_elf_class (unsigned int elf_class
)
4557 static char buff
[32];
4561 case ELFCLASSNONE
: return _("none");
4562 case ELFCLASS32
: return "ELF32";
4563 case ELFCLASS64
: return "ELF64";
4565 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4571 get_data_encoding (unsigned int encoding
)
4573 static char buff
[32];
4577 case ELFDATANONE
: return _("none");
4578 case ELFDATA2LSB
: return _("2's complement, little endian");
4579 case ELFDATA2MSB
: return _("2's complement, big endian");
4581 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4586 /* Decode the data held in 'elf_header'. */
4589 process_file_header (void)
4591 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4592 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4593 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4594 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4597 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4601 init_dwarf_regnames (elf_header
.e_machine
);
4607 printf (_("ELF Header:\n"));
4608 printf (_(" Magic: "));
4609 for (i
= 0; i
< EI_NIDENT
; i
++)
4610 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4612 printf (_(" Class: %s\n"),
4613 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4614 printf (_(" Data: %s\n"),
4615 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4616 printf (_(" Version: %d %s\n"),
4617 elf_header
.e_ident
[EI_VERSION
],
4618 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4620 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4621 ? _("<unknown: %lx>")
4623 printf (_(" OS/ABI: %s\n"),
4624 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4625 printf (_(" ABI Version: %d\n"),
4626 elf_header
.e_ident
[EI_ABIVERSION
]);
4627 printf (_(" Type: %s\n"),
4628 get_file_type (elf_header
.e_type
));
4629 printf (_(" Machine: %s\n"),
4630 get_machine_name (elf_header
.e_machine
));
4631 printf (_(" Version: 0x%lx\n"),
4632 (unsigned long) elf_header
.e_version
);
4634 printf (_(" Entry point address: "));
4635 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4636 printf (_("\n Start of program headers: "));
4637 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4638 printf (_(" (bytes into file)\n Start of section headers: "));
4639 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4640 printf (_(" (bytes into file)\n"));
4642 printf (_(" Flags: 0x%lx%s\n"),
4643 (unsigned long) elf_header
.e_flags
,
4644 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4645 printf (_(" Size of this header: %ld (bytes)\n"),
4646 (long) elf_header
.e_ehsize
);
4647 printf (_(" Size of program headers: %ld (bytes)\n"),
4648 (long) elf_header
.e_phentsize
);
4649 printf (_(" Number of program headers: %ld"),
4650 (long) elf_header
.e_phnum
);
4651 if (section_headers
!= NULL
4652 && elf_header
.e_phnum
== PN_XNUM
4653 && section_headers
[0].sh_info
!= 0)
4654 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4655 putc ('\n', stdout
);
4656 printf (_(" Size of section headers: %ld (bytes)\n"),
4657 (long) elf_header
.e_shentsize
);
4658 printf (_(" Number of section headers: %ld"),
4659 (long) elf_header
.e_shnum
);
4660 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4661 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4662 putc ('\n', stdout
);
4663 printf (_(" Section header string table index: %ld"),
4664 (long) elf_header
.e_shstrndx
);
4665 if (section_headers
!= NULL
4666 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4667 printf (" (%u)", section_headers
[0].sh_link
);
4668 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4669 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4670 printf (_(" <corrupt: out of range>"));
4671 putc ('\n', stdout
);
4674 if (section_headers
!= NULL
)
4676 if (elf_header
.e_phnum
== PN_XNUM
4677 && section_headers
[0].sh_info
!= 0)
4678 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4679 if (elf_header
.e_shnum
== SHN_UNDEF
)
4680 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4681 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4682 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4683 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4684 elf_header
.e_shstrndx
= SHN_UNDEF
;
4685 free (section_headers
);
4686 section_headers
= NULL
;
4693 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4695 Elf32_External_Phdr
* phdrs
;
4696 Elf32_External_Phdr
* external
;
4697 Elf_Internal_Phdr
* internal
;
4699 unsigned int size
= elf_header
.e_phentsize
;
4700 unsigned int num
= elf_header
.e_phnum
;
4702 /* PR binutils/17531: Cope with unexpected section header sizes. */
4703 if (size
== 0 || num
== 0)
4705 if (size
< sizeof * phdrs
)
4707 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4710 if (size
> sizeof * phdrs
)
4711 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4713 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4714 size
, num
, _("program headers"));
4718 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4719 i
< elf_header
.e_phnum
;
4720 i
++, internal
++, external
++)
4722 internal
->p_type
= BYTE_GET (external
->p_type
);
4723 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4724 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4725 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4726 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4727 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4728 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4729 internal
->p_align
= BYTE_GET (external
->p_align
);
4737 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4739 Elf64_External_Phdr
* phdrs
;
4740 Elf64_External_Phdr
* external
;
4741 Elf_Internal_Phdr
* internal
;
4743 unsigned int size
= elf_header
.e_phentsize
;
4744 unsigned int num
= elf_header
.e_phnum
;
4746 /* PR binutils/17531: Cope with unexpected section header sizes. */
4747 if (size
== 0 || num
== 0)
4749 if (size
< sizeof * phdrs
)
4751 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4754 if (size
> sizeof * phdrs
)
4755 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4757 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4758 size
, num
, _("program headers"));
4762 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4763 i
< elf_header
.e_phnum
;
4764 i
++, internal
++, external
++)
4766 internal
->p_type
= BYTE_GET (external
->p_type
);
4767 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4768 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4769 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4770 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4771 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4772 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4773 internal
->p_align
= BYTE_GET (external
->p_align
);
4780 /* Returns TRUE if the program headers were read into `program_headers'. */
4783 get_program_headers (FILE * file
)
4785 Elf_Internal_Phdr
* phdrs
;
4787 /* Check cache of prior read. */
4788 if (program_headers
!= NULL
)
4791 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4792 sizeof (Elf_Internal_Phdr
));
4796 error (_("Out of memory reading %u program headers\n"),
4797 elf_header
.e_phnum
);
4802 ? get_32bit_program_headers (file
, phdrs
)
4803 : get_64bit_program_headers (file
, phdrs
))
4805 program_headers
= phdrs
;
4813 /* Returns TRUE if the program headers were loaded. */
4816 process_program_headers (FILE * file
)
4818 Elf_Internal_Phdr
* segment
;
4820 Elf_Internal_Phdr
* previous_load
= NULL
;
4822 if (elf_header
.e_phnum
== 0)
4824 /* PR binutils/12467. */
4825 if (elf_header
.e_phoff
!= 0)
4827 warn (_("possibly corrupt ELF header - it has a non-zero program"
4828 " header offset, but no program headers\n"));
4831 else if (do_segments
)
4832 printf (_("\nThere are no program headers in this file.\n"));
4836 if (do_segments
&& !do_header
)
4838 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4839 printf (_("Entry point "));
4840 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4841 printf (_("\nThere are %d program headers, starting at offset "),
4842 elf_header
.e_phnum
);
4843 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4847 if (! get_program_headers (file
))
4852 if (elf_header
.e_phnum
> 1)
4853 printf (_("\nProgram Headers:\n"));
4855 printf (_("\nProgram Headers:\n"));
4859 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4862 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4866 (_(" Type Offset VirtAddr PhysAddr\n"));
4868 (_(" FileSiz MemSiz Flags Align\n"));
4875 for (i
= 0, segment
= program_headers
;
4876 i
< elf_header
.e_phnum
;
4881 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4885 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4886 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4887 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4888 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4889 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4891 (segment
->p_flags
& PF_R
? 'R' : ' '),
4892 (segment
->p_flags
& PF_W
? 'W' : ' '),
4893 (segment
->p_flags
& PF_X
? 'E' : ' '));
4894 printf ("%#lx", (unsigned long) segment
->p_align
);
4898 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4899 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4902 print_vma (segment
->p_offset
, FULL_HEX
);
4906 print_vma (segment
->p_vaddr
, FULL_HEX
);
4908 print_vma (segment
->p_paddr
, FULL_HEX
);
4911 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4912 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4915 print_vma (segment
->p_filesz
, FULL_HEX
);
4919 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4920 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4923 print_vma (segment
->p_memsz
, FULL_HEX
);
4927 (segment
->p_flags
& PF_R
? 'R' : ' '),
4928 (segment
->p_flags
& PF_W
? 'W' : ' '),
4929 (segment
->p_flags
& PF_X
? 'E' : ' '));
4931 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4932 printf ("%#lx", (unsigned long) segment
->p_align
);
4935 print_vma (segment
->p_align
, PREFIX_HEX
);
4940 print_vma (segment
->p_offset
, FULL_HEX
);
4942 print_vma (segment
->p_vaddr
, FULL_HEX
);
4944 print_vma (segment
->p_paddr
, FULL_HEX
);
4946 print_vma (segment
->p_filesz
, FULL_HEX
);
4948 print_vma (segment
->p_memsz
, FULL_HEX
);
4950 (segment
->p_flags
& PF_R
? 'R' : ' '),
4951 (segment
->p_flags
& PF_W
? 'W' : ' '),
4952 (segment
->p_flags
& PF_X
? 'E' : ' '));
4953 print_vma (segment
->p_align
, PREFIX_HEX
);
4956 putc ('\n', stdout
);
4959 switch (segment
->p_type
)
4962 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4963 required by the ELF standard, several programs, including the Linux
4964 kernel, make use of non-ordered segments. */
4966 && previous_load
->p_vaddr
> segment
->p_vaddr
)
4967 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4969 if (segment
->p_memsz
< segment
->p_filesz
)
4970 error (_("the segment's file size is larger than its memory size\n"));
4971 previous_load
= segment
;
4975 /* PR 20815 - Verify that the program header is loaded into memory. */
4976 if (i
> 0 && previous_load
!= NULL
)
4977 error (_("the PHDR segment must occur before any LOAD segment\n"));
4978 if (elf_header
.e_machine
!= EM_PARISC
)
4982 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
4983 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
4984 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
4985 >= (segment
->p_vaddr
+ segment
->p_filesz
))
4987 if (j
== elf_header
.e_phnum
)
4988 error (_("the PHDR segment is not covered by a LOAD segment\n"));
4994 error (_("more than one dynamic segment\n"));
4996 /* By default, assume that the .dynamic section is the first
4997 section in the DYNAMIC segment. */
4998 dynamic_addr
= segment
->p_offset
;
4999 dynamic_size
= segment
->p_filesz
;
5000 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
5001 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5003 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5004 dynamic_addr
= dynamic_size
= 0;
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"));
5043 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5045 error (_("Unable to find program interpreter name\n"));
5049 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5051 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5052 error (_("Internal error: failed to create format string to display program interpreter\n"));
5054 program_interpreter
[0] = 0;
5055 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5056 error (_("Unable to read program interpreter name\n"));
5059 printf (_(" [Requesting program interpreter: %s]\n"),
5060 program_interpreter
);
5066 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5068 printf (_("\n Section to Segment mapping:\n"));
5069 printf (_(" Segment Sections...\n"));
5071 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5074 Elf_Internal_Shdr
* section
;
5076 segment
= program_headers
+ i
;
5077 section
= section_headers
+ 1;
5079 printf (" %2.2d ", i
);
5081 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5083 if (!ELF_TBSS_SPECIAL (section
, segment
)
5084 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5085 printf ("%s ", printable_section_name (section
));
5096 /* Find the file offset corresponding to VMA by using the program headers. */
5099 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5101 Elf_Internal_Phdr
* seg
;
5103 if (! get_program_headers (file
))
5105 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5109 for (seg
= program_headers
;
5110 seg
< program_headers
+ elf_header
.e_phnum
;
5113 if (seg
->p_type
!= PT_LOAD
)
5116 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5117 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5118 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5121 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5122 (unsigned long) vma
);
5127 /* Allocate memory and load the sections headers into the global pointer
5128 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5129 generate any error messages if the load fails. */
5132 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5134 Elf32_External_Shdr
* shdrs
;
5135 Elf_Internal_Shdr
* internal
;
5137 unsigned int size
= elf_header
.e_shentsize
;
5138 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5140 /* PR binutils/17531: Cope with unexpected section header sizes. */
5141 if (size
== 0 || num
== 0)
5143 if (size
< sizeof * shdrs
)
5146 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5149 if (!probe
&& size
> sizeof * shdrs
)
5150 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5152 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5154 probe
? NULL
: _("section headers"));
5158 if (section_headers
!= NULL
)
5159 free (section_headers
);
5160 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5161 sizeof (Elf_Internal_Shdr
));
5162 if (section_headers
== NULL
)
5165 error (_("Out of memory reading %u section headers\n"), num
);
5169 for (i
= 0, internal
= section_headers
;
5173 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5174 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5175 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5176 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5177 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5178 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5179 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5180 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5181 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5182 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5183 if (!probe
&& internal
->sh_link
> num
)
5184 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5185 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5186 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5194 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5196 Elf64_External_Shdr
* shdrs
;
5197 Elf_Internal_Shdr
* internal
;
5199 unsigned int size
= elf_header
.e_shentsize
;
5200 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5202 /* PR binutils/17531: Cope with unexpected section header sizes. */
5203 if (size
== 0 || num
== 0)
5205 if (size
< sizeof * shdrs
)
5208 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5211 if (! probe
&& size
> sizeof * shdrs
)
5212 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5214 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5216 probe
? NULL
: _("section headers"));
5220 if (section_headers
!= NULL
)
5221 free (section_headers
);
5222 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5223 sizeof (Elf_Internal_Shdr
));
5224 if (section_headers
== NULL
)
5227 error (_("Out of memory reading %u section headers\n"), num
);
5231 for (i
= 0, internal
= section_headers
;
5235 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5236 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5237 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5238 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5239 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5240 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5241 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5242 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5243 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5244 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5245 if (!probe
&& internal
->sh_link
> num
)
5246 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5247 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5248 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5255 static Elf_Internal_Sym
*
5256 get_32bit_elf_symbols (FILE * file
,
5257 Elf_Internal_Shdr
* section
,
5258 unsigned long * num_syms_return
)
5260 unsigned long number
= 0;
5261 Elf32_External_Sym
* esyms
= NULL
;
5262 Elf_External_Sym_Shndx
* shndx
= NULL
;
5263 Elf_Internal_Sym
* isyms
= NULL
;
5264 Elf_Internal_Sym
* psym
;
5267 if (section
->sh_size
== 0)
5269 if (num_syms_return
!= NULL
)
5270 * num_syms_return
= 0;
5274 /* Run some sanity checks first. */
5275 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5277 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5278 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5282 if (section
->sh_size
> current_file_size
)
5284 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5285 printable_section_name (section
), (unsigned long) section
->sh_size
);
5289 number
= section
->sh_size
/ section
->sh_entsize
;
5291 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5293 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5294 (unsigned long) section
->sh_size
,
5295 printable_section_name (section
),
5296 (unsigned long) section
->sh_entsize
);
5300 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5301 section
->sh_size
, _("symbols"));
5306 elf_section_list
* entry
;
5309 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5310 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5312 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5313 entry
->hdr
->sh_offset
,
5314 1, entry
->hdr
->sh_size
,
5315 _("symbol table section indicies"));
5318 /* PR17531: file: heap-buffer-overflow */
5319 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5321 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5322 printable_section_name (entry
->hdr
),
5323 (unsigned long) entry
->hdr
->sh_size
,
5324 (unsigned long) section
->sh_size
);
5330 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5334 error (_("Out of memory reading %lu symbols\n"),
5335 (unsigned long) number
);
5339 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5341 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5342 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5343 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5344 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5345 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5347 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5348 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5349 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5350 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5351 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5360 if (num_syms_return
!= NULL
)
5361 * num_syms_return
= isyms
== NULL
? 0 : number
;
5366 static Elf_Internal_Sym
*
5367 get_64bit_elf_symbols (FILE * file
,
5368 Elf_Internal_Shdr
* section
,
5369 unsigned long * num_syms_return
)
5371 unsigned long number
= 0;
5372 Elf64_External_Sym
* esyms
= NULL
;
5373 Elf_External_Sym_Shndx
* shndx
= NULL
;
5374 Elf_Internal_Sym
* isyms
= NULL
;
5375 Elf_Internal_Sym
* psym
;
5378 if (section
->sh_size
== 0)
5380 if (num_syms_return
!= NULL
)
5381 * num_syms_return
= 0;
5385 /* Run some sanity checks first. */
5386 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5388 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5389 printable_section_name (section
),
5390 (unsigned long) section
->sh_entsize
);
5394 if (section
->sh_size
> current_file_size
)
5396 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5397 printable_section_name (section
),
5398 (unsigned long) section
->sh_size
);
5402 number
= section
->sh_size
/ section
->sh_entsize
;
5404 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5406 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5407 (unsigned long) section
->sh_size
,
5408 printable_section_name (section
),
5409 (unsigned long) section
->sh_entsize
);
5413 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5414 section
->sh_size
, _("symbols"));
5419 elf_section_list
* entry
;
5422 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5423 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5425 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5426 entry
->hdr
->sh_offset
,
5427 1, entry
->hdr
->sh_size
,
5428 _("symbol table section indicies"));
5431 /* PR17531: file: heap-buffer-overflow */
5432 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5434 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5435 printable_section_name (entry
->hdr
),
5436 (unsigned long) entry
->hdr
->sh_size
,
5437 (unsigned long) section
->sh_size
);
5443 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5447 error (_("Out of memory reading %lu symbols\n"),
5448 (unsigned long) number
);
5452 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5454 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5455 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5456 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5457 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5459 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5461 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5462 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5463 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5465 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5466 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5475 if (num_syms_return
!= NULL
)
5476 * num_syms_return
= isyms
== NULL
? 0 : number
;
5482 get_elf_section_flags (bfd_vma sh_flags
)
5484 static char buff
[1024];
5486 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5488 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5489 bfd_vma os_flags
= 0;
5490 bfd_vma proc_flags
= 0;
5491 bfd_vma unknown_flags
= 0;
5499 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5500 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5501 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5502 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5503 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5504 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5505 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5506 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5507 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5508 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5509 /* IA-64 specific. */
5510 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5511 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5512 /* IA-64 OpenVMS specific. */
5513 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5514 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5515 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5516 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5517 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5518 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5520 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5521 /* SPARC specific. */
5522 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5523 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5525 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5526 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5527 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5530 if (do_section_details
)
5532 sprintf (buff
, "[%*.*lx]: ",
5533 field_size
, field_size
, (unsigned long) sh_flags
);
5534 p
+= field_size
+ 4;
5541 flag
= sh_flags
& - sh_flags
;
5544 if (do_section_details
)
5548 case SHF_WRITE
: sindex
= 0; break;
5549 case SHF_ALLOC
: sindex
= 1; break;
5550 case SHF_EXECINSTR
: sindex
= 2; break;
5551 case SHF_MERGE
: sindex
= 3; break;
5552 case SHF_STRINGS
: sindex
= 4; break;
5553 case SHF_INFO_LINK
: sindex
= 5; break;
5554 case SHF_LINK_ORDER
: sindex
= 6; break;
5555 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5556 case SHF_GROUP
: sindex
= 8; break;
5557 case SHF_TLS
: sindex
= 9; break;
5558 case SHF_EXCLUDE
: sindex
= 18; break;
5559 case SHF_COMPRESSED
: sindex
= 20; break;
5563 switch (elf_header
.e_machine
)
5566 if (flag
== SHF_IA_64_SHORT
)
5568 else if (flag
== SHF_IA_64_NORECOV
)
5571 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5574 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5575 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5576 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5577 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5578 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5579 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5590 case EM_OLD_SPARCV9
:
5591 case EM_SPARC32PLUS
:
5594 if (flag
== SHF_ORDERED
)
5601 case SHF_ENTRYSECT
: sindex
= 21; break;
5602 case SHF_ARM_PURECODE
: sindex
= 22; break;
5603 case SHF_COMDEF
: sindex
= 23; break;
5615 if (p
!= buff
+ field_size
+ 4)
5617 if (size
< (10 + 2))
5619 warn (_("Internal error: not enough buffer room for section flag info"));
5620 return _("<unknown>");
5627 size
-= flags
[sindex
].len
;
5628 p
= stpcpy (p
, flags
[sindex
].str
);
5630 else if (flag
& SHF_MASKOS
)
5632 else if (flag
& SHF_MASKPROC
)
5635 unknown_flags
|= flag
;
5641 case SHF_WRITE
: *p
= 'W'; break;
5642 case SHF_ALLOC
: *p
= 'A'; break;
5643 case SHF_EXECINSTR
: *p
= 'X'; break;
5644 case SHF_MERGE
: *p
= 'M'; break;
5645 case SHF_STRINGS
: *p
= 'S'; break;
5646 case SHF_INFO_LINK
: *p
= 'I'; break;
5647 case SHF_LINK_ORDER
: *p
= 'L'; break;
5648 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5649 case SHF_GROUP
: *p
= 'G'; break;
5650 case SHF_TLS
: *p
= 'T'; break;
5651 case SHF_EXCLUDE
: *p
= 'E'; break;
5652 case SHF_COMPRESSED
: *p
= 'C'; break;
5655 if ((elf_header
.e_machine
== EM_X86_64
5656 || elf_header
.e_machine
== EM_L1OM
5657 || elf_header
.e_machine
== EM_K1OM
)
5658 && flag
== SHF_X86_64_LARGE
)
5660 else if (elf_header
.e_machine
== EM_ARM
5661 && flag
== SHF_ARM_PURECODE
)
5663 else if (flag
& SHF_MASKOS
)
5666 sh_flags
&= ~ SHF_MASKOS
;
5668 else if (flag
& SHF_MASKPROC
)
5671 sh_flags
&= ~ SHF_MASKPROC
;
5681 if (do_section_details
)
5685 size
-= 5 + field_size
;
5686 if (p
!= buff
+ field_size
+ 4)
5690 warn (_("Internal error: not enough buffer room for section flag info"));
5691 return _("<unknown>");
5697 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5698 (unsigned long) os_flags
);
5699 p
+= 5 + field_size
;
5703 size
-= 7 + field_size
;
5704 if (p
!= buff
+ field_size
+ 4)
5708 warn (_("Internal error: not enough buffer room for section flag info"));
5709 return _("<unknown>");
5715 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5716 (unsigned long) proc_flags
);
5717 p
+= 7 + field_size
;
5721 size
-= 10 + field_size
;
5722 if (p
!= buff
+ field_size
+ 4)
5726 warn (_("Internal error: not enough buffer room for section flag info"));
5727 return _("<unknown>");
5733 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5734 (unsigned long) unknown_flags
);
5735 p
+= 10 + field_size
;
5744 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5748 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5750 if (size
< sizeof (* echdr
))
5752 error (_("Compressed section is too small even for a compression header\n"));
5756 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5757 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5758 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5759 return sizeof (*echdr
);
5763 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5765 if (size
< sizeof (* echdr
))
5767 error (_("Compressed section is too small even for a compression header\n"));
5771 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5772 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5773 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5774 return sizeof (*echdr
);
5779 process_section_headers (FILE * file
)
5781 Elf_Internal_Shdr
* section
;
5784 section_headers
= NULL
;
5786 if (elf_header
.e_shnum
== 0)
5788 /* PR binutils/12467. */
5789 if (elf_header
.e_shoff
!= 0)
5791 warn (_("possibly corrupt ELF file header - it has a non-zero"
5792 " section header offset, but no section headers\n"));
5795 else if (do_sections
)
5796 printf (_("\nThere are no sections in this file.\n"));
5801 if (do_sections
&& !do_header
)
5802 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5803 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5807 if (! get_32bit_section_headers (file
, FALSE
))
5812 if (! get_64bit_section_headers (file
, FALSE
))
5816 /* Read in the string table, so that we have names to display. */
5817 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5818 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5820 section
= section_headers
+ elf_header
.e_shstrndx
;
5822 if (section
->sh_size
!= 0)
5824 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5825 1, section
->sh_size
,
5828 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5832 /* Scan the sections for the dynamic symbol table
5833 and dynamic string table and debug sections. */
5834 dynamic_symbols
= NULL
;
5835 dynamic_strings
= NULL
;
5836 dynamic_syminfo
= NULL
;
5837 symtab_shndx_list
= NULL
;
5839 eh_addr_size
= is_32bit_elf
? 4 : 8;
5840 switch (elf_header
.e_machine
)
5843 case EM_MIPS_RS3_LE
:
5844 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5845 FDE addresses. However, the ABI also has a semi-official ILP32
5846 variant for which the normal FDE address size rules apply.
5848 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5849 section, where XX is the size of longs in bits. Unfortunately,
5850 earlier compilers provided no way of distinguishing ILP32 objects
5851 from LP64 objects, so if there's any doubt, we should assume that
5852 the official LP64 form is being used. */
5853 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5854 && find_section (".gcc_compiled_long32") == NULL
)
5860 switch (elf_header
.e_flags
& EF_H8_MACH
)
5862 case E_H8_MACH_H8300
:
5863 case E_H8_MACH_H8300HN
:
5864 case E_H8_MACH_H8300SN
:
5865 case E_H8_MACH_H8300SXN
:
5868 case E_H8_MACH_H8300H
:
5869 case E_H8_MACH_H8300S
:
5870 case E_H8_MACH_H8300SX
:
5878 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5880 case EF_M32C_CPU_M16C
:
5887 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5890 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5891 if (section->sh_entsize != expected_entsize) \
5894 sprintf_vma (buf, section->sh_entsize); \
5895 /* Note: coded this way so that there is a single string for \
5897 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5898 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5899 (unsigned) expected_entsize); \
5900 section->sh_entsize = expected_entsize; \
5905 #define CHECK_ENTSIZE(section, i, type) \
5906 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5907 sizeof (Elf64_External_##type))
5909 for (i
= 0, section
= section_headers
;
5910 i
< elf_header
.e_shnum
;
5913 char * name
= SECTION_NAME (section
);
5915 if (section
->sh_type
== SHT_DYNSYM
)
5917 if (dynamic_symbols
!= NULL
)
5919 error (_("File contains multiple dynamic symbol tables\n"));
5923 CHECK_ENTSIZE (section
, i
, Sym
);
5924 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5926 else if (section
->sh_type
== SHT_STRTAB
5927 && streq (name
, ".dynstr"))
5929 if (dynamic_strings
!= NULL
)
5931 error (_("File contains multiple dynamic string tables\n"));
5935 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5936 1, section
->sh_size
,
5937 _("dynamic strings"));
5938 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5940 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5942 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5943 entry
->hdr
= section
;
5944 entry
->next
= symtab_shndx_list
;
5945 symtab_shndx_list
= entry
;
5947 else if (section
->sh_type
== SHT_SYMTAB
)
5948 CHECK_ENTSIZE (section
, i
, Sym
);
5949 else if (section
->sh_type
== SHT_GROUP
)
5950 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5951 else if (section
->sh_type
== SHT_REL
)
5952 CHECK_ENTSIZE (section
, i
, Rel
);
5953 else if (section
->sh_type
== SHT_RELA
)
5954 CHECK_ENTSIZE (section
, i
, Rela
);
5955 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5956 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5957 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5958 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5959 || do_debug_addr
|| do_debug_cu_index
)
5960 && (const_strneq (name
, ".debug_")
5961 || const_strneq (name
, ".zdebug_")))
5964 name
+= sizeof (".zdebug_") - 1;
5966 name
+= sizeof (".debug_") - 1;
5969 || (do_debug_info
&& const_strneq (name
, "info"))
5970 || (do_debug_info
&& const_strneq (name
, "types"))
5971 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5972 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5973 || (do_debug_lines
&& const_strneq (name
, "line."))
5974 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5975 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5976 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5977 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5978 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5979 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5980 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
5981 || (do_debug_frames
&& const_strneq (name
, "frame"))
5982 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5983 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5984 || (do_debug_str
&& const_strneq (name
, "str"))
5985 || (do_debug_loc
&& const_strneq (name
, "loc"))
5986 || (do_debug_loc
&& const_strneq (name
, "loclists"))
5987 || (do_debug_addr
&& const_strneq (name
, "addr"))
5988 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5989 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5991 request_dump_bynumber (i
, DEBUG_DUMP
);
5993 /* Linkonce section to be combined with .debug_info at link time. */
5994 else if ((do_debugging
|| do_debug_info
)
5995 && const_strneq (name
, ".gnu.linkonce.wi."))
5996 request_dump_bynumber (i
, DEBUG_DUMP
);
5997 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5998 request_dump_bynumber (i
, DEBUG_DUMP
);
5999 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
6000 request_dump_bynumber (i
, DEBUG_DUMP
);
6001 /* Trace sections for Itanium VMS. */
6002 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6003 || do_trace_aranges
)
6004 && const_strneq (name
, ".trace_"))
6006 name
+= sizeof (".trace_") - 1;
6009 || (do_trace_info
&& streq (name
, "info"))
6010 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6011 || (do_trace_aranges
&& streq (name
, "aranges"))
6013 request_dump_bynumber (i
, DEBUG_DUMP
);
6020 if (elf_header
.e_shnum
> 1)
6021 printf (_("\nSection Headers:\n"));
6023 printf (_("\nSection Header:\n"));
6027 if (do_section_details
)
6029 printf (_(" [Nr] Name\n"));
6030 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6034 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6038 if (do_section_details
)
6040 printf (_(" [Nr] Name\n"));
6041 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6045 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6049 if (do_section_details
)
6051 printf (_(" [Nr] Name\n"));
6052 printf (_(" Type Address Offset Link\n"));
6053 printf (_(" Size EntSize Info Align\n"));
6057 printf (_(" [Nr] Name Type Address Offset\n"));
6058 printf (_(" Size EntSize Flags Link Info Align\n"));
6062 if (do_section_details
)
6063 printf (_(" Flags\n"));
6065 for (i
= 0, section
= section_headers
;
6066 i
< elf_header
.e_shnum
;
6069 /* Run some sanity checks on the section header. */
6071 /* Check the sh_link field. */
6072 switch (section
->sh_type
)
6074 case SHT_SYMTAB_SHNDX
:
6078 case SHT_GNU_versym
:
6081 if (section
->sh_link
< 1
6082 || section
->sh_link
>= elf_header
.e_shnum
6083 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6084 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6085 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6086 i
, section
->sh_link
);
6092 case SHT_GNU_verneed
:
6093 case SHT_GNU_verdef
:
6094 case SHT_GNU_LIBLIST
:
6095 if (section
->sh_link
< 1
6096 || section
->sh_link
>= elf_header
.e_shnum
6097 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6098 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6099 i
, section
->sh_link
);
6102 case SHT_INIT_ARRAY
:
6103 case SHT_FINI_ARRAY
:
6104 case SHT_PREINIT_ARRAY
:
6105 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6106 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6107 i
, section
->sh_link
);
6111 /* FIXME: Add support for target specific section types. */
6112 #if 0 /* Currently we do not check other section types as there are too
6113 many special cases. Stab sections for example have a type
6114 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6116 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6117 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6118 i
, section
->sh_link
);
6123 /* Check the sh_info field. */
6124 switch (section
->sh_type
)
6128 if (section
->sh_info
< 1
6129 || section
->sh_info
>= elf_header
.e_shnum
6130 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6131 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6132 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6133 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6134 /* FIXME: Are other section types valid ? */
6135 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6137 if (section
->sh_info
== 0
6138 && (streq (SECTION_NAME (section
), ".rel.dyn")
6139 || streq (SECTION_NAME (section
), ".rela.dyn")))
6140 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6141 of zero. The relocations in these sections may apply
6142 to many different sections. */
6145 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6146 i
, section
->sh_info
);
6152 case SHT_SYMTAB_SHNDX
:
6153 case SHT_INIT_ARRAY
:
6154 case SHT_FINI_ARRAY
:
6155 case SHT_PREINIT_ARRAY
:
6156 if (section
->sh_info
!= 0)
6157 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6158 i
, section
->sh_info
);
6164 /* A symbol index - we assume that it is valid. */
6168 /* FIXME: Add support for target specific section types. */
6169 if (section
->sh_type
== SHT_NOBITS
)
6170 /* NOBITS section headers with non-zero sh_info fields can be
6171 created when a binary is stripped of everything but its debug
6172 information. The stripped sections have their headers
6173 preserved but their types set to SHT_NOBITS. So do not check
6174 this type of section. */
6176 else if (section
->sh_flags
& SHF_INFO_LINK
)
6178 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6179 warn (_("[%2u]: Expected link to another section in info field"), i
);
6181 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6182 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6183 i
, section
->sh_info
);
6187 printf (" [%2u] ", i
);
6188 if (do_section_details
)
6189 printf ("%s\n ", printable_section_name (section
));
6191 print_symbol (-17, SECTION_NAME (section
));
6193 printf (do_wide
? " %-15s " : " %-15.15s ",
6194 get_section_type_name (section
->sh_type
));
6198 const char * link_too_big
= NULL
;
6200 print_vma (section
->sh_addr
, LONG_HEX
);
6202 printf ( " %6.6lx %6.6lx %2.2lx",
6203 (unsigned long) section
->sh_offset
,
6204 (unsigned long) section
->sh_size
,
6205 (unsigned long) section
->sh_entsize
);
6207 if (do_section_details
)
6208 fputs (" ", stdout
);
6210 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6212 if (section
->sh_link
>= elf_header
.e_shnum
)
6215 /* The sh_link value is out of range. Normally this indicates
6216 an error but it can have special values in Solaris binaries. */
6217 switch (elf_header
.e_machine
)
6224 case EM_OLD_SPARCV9
:
6225 case EM_SPARC32PLUS
:
6228 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6229 link_too_big
= "BEFORE";
6230 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6231 link_too_big
= "AFTER";
6238 if (do_section_details
)
6240 if (link_too_big
!= NULL
&& * link_too_big
)
6241 printf ("<%s> ", link_too_big
);
6243 printf ("%2u ", section
->sh_link
);
6244 printf ("%3u %2lu\n", section
->sh_info
,
6245 (unsigned long) section
->sh_addralign
);
6248 printf ("%2u %3u %2lu\n",
6251 (unsigned long) section
->sh_addralign
);
6253 if (link_too_big
&& ! * link_too_big
)
6254 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6255 i
, section
->sh_link
);
6259 print_vma (section
->sh_addr
, LONG_HEX
);
6261 if ((long) section
->sh_offset
== section
->sh_offset
)
6262 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6266 print_vma (section
->sh_offset
, LONG_HEX
);
6269 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6270 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6274 print_vma (section
->sh_size
, LONG_HEX
);
6277 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6278 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6282 print_vma (section
->sh_entsize
, LONG_HEX
);
6285 if (do_section_details
)
6286 fputs (" ", stdout
);
6288 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6290 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6292 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6293 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6296 print_vma (section
->sh_addralign
, DEC
);
6300 else if (do_section_details
)
6302 printf (" %-15.15s ",
6303 get_section_type_name (section
->sh_type
));
6304 print_vma (section
->sh_addr
, LONG_HEX
);
6305 if ((long) section
->sh_offset
== section
->sh_offset
)
6306 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6310 print_vma (section
->sh_offset
, LONG_HEX
);
6312 printf (" %u\n ", section
->sh_link
);
6313 print_vma (section
->sh_size
, LONG_HEX
);
6315 print_vma (section
->sh_entsize
, LONG_HEX
);
6317 printf (" %-16u %lu\n",
6319 (unsigned long) section
->sh_addralign
);
6324 print_vma (section
->sh_addr
, LONG_HEX
);
6325 if ((long) section
->sh_offset
== section
->sh_offset
)
6326 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6330 print_vma (section
->sh_offset
, LONG_HEX
);
6333 print_vma (section
->sh_size
, LONG_HEX
);
6335 print_vma (section
->sh_entsize
, LONG_HEX
);
6337 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6339 printf (" %2u %3u %lu\n",
6342 (unsigned long) section
->sh_addralign
);
6345 if (do_section_details
)
6347 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6348 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6350 /* Minimum section size is 12 bytes for 32-bit compression
6351 header + 12 bytes for compressed data header. */
6352 unsigned char buf
[24];
6354 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6355 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6356 sizeof (buf
), _("compression header")))
6358 Elf_Internal_Chdr chdr
;
6360 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6362 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6365 printf (_(" [<unknown>: 0x%x], "),
6367 print_vma (chdr
.ch_size
, LONG_HEX
);
6368 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6374 if (!do_section_details
)
6376 /* The ordering of the letters shown here matches the ordering of the
6377 corresponding SHF_xxx values, and hence the order in which these
6378 letters will be displayed to the user. */
6379 printf (_("Key to Flags:\n\
6380 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6381 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6382 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6383 if (elf_header
.e_machine
== EM_X86_64
6384 || elf_header
.e_machine
== EM_L1OM
6385 || elf_header
.e_machine
== EM_K1OM
)
6386 printf (_("l (large), "));
6387 else if (elf_header
.e_machine
== EM_ARM
)
6388 printf (_("y (purecode), "));
6389 printf ("p (processor specific)\n");
6396 get_group_flags (unsigned int flags
)
6398 static char buff
[128];
6402 else if (flags
== GRP_COMDAT
)
6405 snprintf (buff
, 14, _("[0x%x: "), flags
);
6407 flags
&= ~ GRP_COMDAT
;
6408 if (flags
& GRP_MASKOS
)
6410 strcat (buff
, "<OS specific>");
6411 flags
&= ~ GRP_MASKOS
;
6414 if (flags
& GRP_MASKPROC
)
6416 strcat (buff
, "<PROC specific>");
6417 flags
&= ~ GRP_MASKPROC
;
6421 strcat (buff
, "<unknown>");
6428 process_section_groups (FILE * file
)
6430 Elf_Internal_Shdr
* section
;
6432 struct group
* group
;
6433 Elf_Internal_Shdr
* symtab_sec
;
6434 Elf_Internal_Shdr
* strtab_sec
;
6435 Elf_Internal_Sym
* symtab
;
6436 unsigned long num_syms
;
6440 /* Don't process section groups unless needed. */
6441 if (!do_unwind
&& !do_section_groups
)
6444 if (elf_header
.e_shnum
== 0)
6446 if (do_section_groups
)
6447 printf (_("\nThere are no sections to group in this file.\n"));
6452 if (section_headers
== NULL
)
6454 error (_("Section headers are not available!\n"));
6455 /* PR 13622: This can happen with a corrupt ELF header. */
6459 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6460 sizeof (struct group
*));
6462 if (section_headers_groups
== NULL
)
6464 error (_("Out of memory reading %u section group headers\n"),
6465 elf_header
.e_shnum
);
6469 /* Scan the sections for the group section. */
6471 for (i
= 0, section
= section_headers
;
6472 i
< elf_header
.e_shnum
;
6474 if (section
->sh_type
== SHT_GROUP
)
6477 if (group_count
== 0)
6479 if (do_section_groups
)
6480 printf (_("\nThere are no section groups in this file.\n"));
6485 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6487 if (section_groups
== NULL
)
6489 error (_("Out of memory reading %lu groups\n"),
6490 (unsigned long) group_count
);
6500 for (i
= 0, section
= section_headers
, group
= section_groups
;
6501 i
< elf_header
.e_shnum
;
6504 if (section
->sh_type
== SHT_GROUP
)
6506 const char * name
= printable_section_name (section
);
6507 const char * group_name
;
6508 unsigned char * start
;
6509 unsigned char * indices
;
6510 unsigned int entry
, j
, size
;
6511 Elf_Internal_Shdr
* sec
;
6512 Elf_Internal_Sym
* sym
;
6514 /* Get the symbol table. */
6515 if (section
->sh_link
>= elf_header
.e_shnum
6516 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6519 error (_("Bad sh_link in group section `%s'\n"), name
);
6523 if (symtab_sec
!= sec
)
6528 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6533 error (_("Corrupt header in group section `%s'\n"), name
);
6537 if (section
->sh_info
>= num_syms
)
6539 error (_("Bad sh_info in group section `%s'\n"), name
);
6543 sym
= symtab
+ section
->sh_info
;
6545 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6547 if (sym
->st_shndx
== 0
6548 || sym
->st_shndx
>= elf_header
.e_shnum
)
6550 error (_("Bad sh_info in group section `%s'\n"), name
);
6554 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6563 /* Get the string table. */
6564 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6573 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6579 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6580 1, strtab_sec
->sh_size
,
6582 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6584 group_name
= sym
->st_name
< strtab_size
6585 ? strtab
+ sym
->st_name
: _("<corrupt>");
6588 /* PR 17531: file: loop. */
6589 if (section
->sh_entsize
> section
->sh_size
)
6591 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6592 printable_section_name (section
),
6593 (unsigned long) section
->sh_entsize
,
6594 (unsigned long) section
->sh_size
);
6598 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6599 1, section
->sh_size
,
6605 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6606 entry
= byte_get (indices
, 4);
6609 if (do_section_groups
)
6611 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6612 get_group_flags (entry
), i
, name
, group_name
, size
);
6614 printf (_(" [Index] Name\n"));
6617 group
->group_index
= i
;
6619 for (j
= 0; j
< size
; j
++)
6621 struct group_list
* g
;
6623 entry
= byte_get (indices
, 4);
6626 if (entry
>= elf_header
.e_shnum
)
6628 static unsigned num_group_errors
= 0;
6630 if (num_group_errors
++ < 10)
6632 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6633 entry
, i
, elf_header
.e_shnum
- 1);
6634 if (num_group_errors
== 10)
6635 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6640 if (section_headers_groups
[entry
] != NULL
)
6644 static unsigned num_errs
= 0;
6646 if (num_errs
++ < 10)
6648 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6650 section_headers_groups
[entry
]->group_index
);
6652 warn (_("Further error messages about already contained group sections suppressed\n"));
6658 /* Intel C/C++ compiler may put section 0 in a
6659 section group. We just warn it the first time
6660 and ignore it afterwards. */
6661 static bfd_boolean warned
= FALSE
;
6664 error (_("section 0 in group section [%5u]\n"),
6665 section_headers_groups
[entry
]->group_index
);
6671 section_headers_groups
[entry
] = group
;
6673 if (do_section_groups
)
6675 sec
= section_headers
+ entry
;
6676 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6679 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6680 g
->section_index
= entry
;
6681 g
->next
= group
->root
;
6699 /* Data used to display dynamic fixups. */
6701 struct ia64_vms_dynfixup
6703 bfd_vma needed_ident
; /* Library ident number. */
6704 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6705 bfd_vma fixup_needed
; /* Index of the library. */
6706 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6707 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6710 /* Data used to display dynamic relocations. */
6712 struct ia64_vms_dynimgrela
6714 bfd_vma img_rela_cnt
; /* Number of relocations. */
6715 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6718 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6722 dump_ia64_vms_dynamic_fixups (FILE * file
,
6723 struct ia64_vms_dynfixup
* fixup
,
6724 const char * strtab
,
6725 unsigned int strtab_sz
)
6727 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6729 const char * lib_name
;
6731 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6732 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6733 _("dynamic section image fixups"));
6737 if (fixup
->needed
< strtab_sz
)
6738 lib_name
= strtab
+ fixup
->needed
;
6741 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6742 (unsigned long) fixup
->needed
);
6745 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6746 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6748 (_("Seg Offset Type SymVec DataType\n"));
6750 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6755 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6756 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6757 type
= BYTE_GET (imfs
[i
].type
);
6758 rtype
= elf_ia64_reloc_type (type
);
6760 printf (" 0x%08x ", type
);
6762 printf (" %-32s ", rtype
);
6763 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6764 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6771 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6774 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6776 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6779 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6780 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6781 _("dynamic section image relocations"));
6785 printf (_("\nImage relocs\n"));
6787 (_("Seg Offset Type Addend Seg Sym Off\n"));
6789 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6794 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6795 printf ("%08" BFD_VMA_FMT
"x ",
6796 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6797 type
= BYTE_GET (imrs
[i
].type
);
6798 rtype
= elf_ia64_reloc_type (type
);
6800 printf ("0x%08x ", type
);
6802 printf ("%-31s ", rtype
);
6803 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6804 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6805 printf ("%08" BFD_VMA_FMT
"x\n",
6806 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6813 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6816 process_ia64_vms_dynamic_relocs (FILE *file
)
6818 struct ia64_vms_dynfixup fixup
;
6819 struct ia64_vms_dynimgrela imgrela
;
6820 Elf_Internal_Dyn
*entry
;
6821 bfd_vma strtab_off
= 0;
6822 bfd_vma strtab_sz
= 0;
6823 char *strtab
= NULL
;
6824 bfd_boolean res
= TRUE
;
6826 memset (&fixup
, 0, sizeof (fixup
));
6827 memset (&imgrela
, 0, sizeof (imgrela
));
6829 /* Note: the order of the entries is specified by the OpenVMS specs. */
6830 for (entry
= dynamic_section
;
6831 entry
< dynamic_section
+ dynamic_nent
;
6834 switch (entry
->d_tag
)
6836 case DT_IA_64_VMS_STRTAB_OFFSET
:
6837 strtab_off
= entry
->d_un
.d_val
;
6840 strtab_sz
= entry
->d_un
.d_val
;
6842 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6843 1, strtab_sz
, _("dynamic string section"));
6846 case DT_IA_64_VMS_NEEDED_IDENT
:
6847 fixup
.needed_ident
= entry
->d_un
.d_val
;
6850 fixup
.needed
= entry
->d_un
.d_val
;
6852 case DT_IA_64_VMS_FIXUP_NEEDED
:
6853 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6855 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6856 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6858 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6859 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6860 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6863 case DT_IA_64_VMS_IMG_RELA_CNT
:
6864 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6866 case DT_IA_64_VMS_IMG_RELA_OFF
:
6867 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6868 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6890 dynamic_relocations
[] =
6892 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6893 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6894 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6897 /* Process the reloc section. */
6900 process_relocs (FILE * file
)
6902 unsigned long rel_size
;
6903 unsigned long rel_offset
;
6908 if (do_using_dynamic
)
6912 bfd_boolean has_dynamic_reloc
;
6915 has_dynamic_reloc
= FALSE
;
6917 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6919 is_rela
= dynamic_relocations
[i
].rela
;
6920 name
= dynamic_relocations
[i
].name
;
6921 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6922 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6925 has_dynamic_reloc
= TRUE
;
6927 if (is_rela
== UNKNOWN
)
6929 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6930 switch (dynamic_info
[DT_PLTREL
])
6944 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6945 name
, rel_offset
, rel_size
);
6947 dump_relocations (file
,
6948 offset_from_vma (file
, rel_offset
, rel_size
),
6950 dynamic_symbols
, num_dynamic_syms
,
6951 dynamic_strings
, dynamic_strings_length
,
6952 is_rela
, TRUE
/* is_dynamic */);
6957 if (process_ia64_vms_dynamic_relocs (file
))
6958 has_dynamic_reloc
= TRUE
;
6960 if (! has_dynamic_reloc
)
6961 printf (_("\nThere are no dynamic relocations in this file.\n"));
6965 Elf_Internal_Shdr
* section
;
6967 bfd_boolean found
= FALSE
;
6969 for (i
= 0, section
= section_headers
;
6970 i
< elf_header
.e_shnum
;
6973 if ( section
->sh_type
!= SHT_RELA
6974 && section
->sh_type
!= SHT_REL
)
6977 rel_offset
= section
->sh_offset
;
6978 rel_size
= section
->sh_size
;
6982 Elf_Internal_Shdr
* strsec
;
6985 printf (_("\nRelocation section "));
6987 if (string_table
== NULL
)
6988 printf ("%d", section
->sh_name
);
6990 printf ("'%s'", printable_section_name (section
));
6992 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6993 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6995 is_rela
= section
->sh_type
== SHT_RELA
;
6997 if (section
->sh_link
!= 0
6998 && section
->sh_link
< elf_header
.e_shnum
)
7000 Elf_Internal_Shdr
* symsec
;
7001 Elf_Internal_Sym
* symtab
;
7002 unsigned long nsyms
;
7003 unsigned long strtablen
= 0;
7004 char * strtab
= NULL
;
7006 symsec
= section_headers
+ section
->sh_link
;
7007 if (symsec
->sh_type
!= SHT_SYMTAB
7008 && symsec
->sh_type
!= SHT_DYNSYM
)
7011 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7016 if (symsec
->sh_link
!= 0
7017 && symsec
->sh_link
< elf_header
.e_shnum
)
7019 strsec
= section_headers
+ symsec
->sh_link
;
7021 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7024 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7027 dump_relocations (file
, rel_offset
, rel_size
,
7028 symtab
, nsyms
, strtab
, strtablen
,
7030 symsec
->sh_type
== SHT_DYNSYM
);
7036 dump_relocations (file
, rel_offset
, rel_size
,
7037 NULL
, 0, NULL
, 0, is_rela
,
7038 FALSE
/* is_dynamic */);
7045 printf (_("\nThere are no relocations in this file.\n"));
7051 /* An absolute address consists of a section and an offset. If the
7052 section is NULL, the offset itself is the address, otherwise, the
7053 address equals to LOAD_ADDRESS(section) + offset. */
7057 unsigned short section
;
7061 #define ABSADDR(a) \
7063 ? section_headers [(a).section].sh_addr + (a).offset \
7066 /* Find the nearest symbol at or below ADDR. Returns the symbol
7067 name, if found, and the offset from the symbol to ADDR. */
7070 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7071 unsigned long nsyms
,
7072 const char * strtab
,
7073 unsigned long strtab_size
,
7074 struct absaddr addr
,
7075 const char ** symname
,
7078 bfd_vma dist
= 0x100000;
7079 Elf_Internal_Sym
* sym
;
7080 Elf_Internal_Sym
* beg
;
7081 Elf_Internal_Sym
* end
;
7082 Elf_Internal_Sym
* best
= NULL
;
7084 REMOVE_ARCH_BITS (addr
.offset
);
7086 end
= symtab
+ nsyms
;
7092 sym
= beg
+ (end
- beg
) / 2;
7094 value
= sym
->st_value
;
7095 REMOVE_ARCH_BITS (value
);
7097 if (sym
->st_name
!= 0
7098 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7099 && addr
.offset
>= value
7100 && addr
.offset
- value
< dist
)
7103 dist
= addr
.offset
- value
;
7108 if (addr
.offset
< value
)
7116 *symname
= (best
->st_name
>= strtab_size
7117 ? _("<corrupt>") : strtab
+ best
->st_name
);
7123 *offset
= addr
.offset
;
7126 static /* signed */ int
7127 symcmp (const void *p
, const void *q
)
7129 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7130 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7132 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7135 /* Process the unwind section. */
7137 #include "unwind-ia64.h"
7139 struct ia64_unw_table_entry
7141 struct absaddr start
;
7143 struct absaddr info
;
7146 struct ia64_unw_aux_info
7148 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7149 unsigned long table_len
; /* Length of unwind table. */
7150 unsigned char * info
; /* Unwind info. */
7151 unsigned long info_size
; /* Size of unwind info. */
7152 bfd_vma info_addr
; /* Starting address of unwind info. */
7153 bfd_vma seg_base
; /* Starting address of segment. */
7154 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7155 unsigned long nsyms
; /* Number of symbols. */
7156 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7157 unsigned long nfuns
; /* Number of entries in funtab. */
7158 char * strtab
; /* The string table. */
7159 unsigned long strtab_size
; /* Size of string table. */
7163 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7165 struct ia64_unw_table_entry
* tp
;
7166 unsigned long j
, nfuns
;
7168 bfd_boolean res
= TRUE
;
7170 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7171 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7172 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7173 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7175 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7177 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7181 const unsigned char * dp
;
7182 const unsigned char * head
;
7183 const unsigned char * end
;
7184 const char * procname
;
7186 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7187 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7189 fputs ("\n<", stdout
);
7193 fputs (procname
, stdout
);
7196 printf ("+%lx", (unsigned long) offset
);
7199 fputs (">: [", stdout
);
7200 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7201 fputc ('-', stdout
);
7202 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7203 printf ("], info at +0x%lx\n",
7204 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7206 /* PR 17531: file: 86232b32. */
7207 if (aux
->info
== NULL
)
7210 /* PR 17531: file: 0997b4d1. */
7211 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7213 warn (_("Invalid offset %lx in table entry %ld\n"),
7214 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7219 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7220 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7222 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7223 (unsigned) UNW_VER (stamp
),
7224 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7225 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7226 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7227 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7229 if (UNW_VER (stamp
) != 1)
7231 printf (_("\tUnknown version.\n"));
7236 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7237 /* PR 17531: file: 16ceda89. */
7238 if (end
> aux
->info
+ aux
->info_size
)
7239 end
= aux
->info
+ aux
->info_size
;
7240 for (dp
= head
+ 8; dp
< end
;)
7241 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7250 slurp_ia64_unwind_table (FILE * file
,
7251 struct ia64_unw_aux_info
* aux
,
7252 Elf_Internal_Shdr
* sec
)
7254 unsigned long size
, nrelas
, i
;
7255 Elf_Internal_Phdr
* seg
;
7256 struct ia64_unw_table_entry
* tep
;
7257 Elf_Internal_Shdr
* relsec
;
7258 Elf_Internal_Rela
* rela
;
7259 Elf_Internal_Rela
* rp
;
7260 unsigned char * table
;
7262 Elf_Internal_Sym
* sym
;
7263 const char * relname
;
7267 /* First, find the starting address of the segment that includes
7270 if (elf_header
.e_phnum
)
7272 if (! get_program_headers (file
))
7275 for (seg
= program_headers
;
7276 seg
< program_headers
+ elf_header
.e_phnum
;
7279 if (seg
->p_type
!= PT_LOAD
)
7282 if (sec
->sh_addr
>= seg
->p_vaddr
7283 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7285 aux
->seg_base
= seg
->p_vaddr
;
7291 /* Second, build the unwind table from the contents of the unwind section: */
7292 size
= sec
->sh_size
;
7293 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7298 aux
->table_len
= size
/ (3 * eh_addr_size
);
7299 aux
->table
= (struct ia64_unw_table_entry
*)
7300 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7303 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7305 tep
->start
.section
= SHN_UNDEF
;
7306 tep
->end
.section
= SHN_UNDEF
;
7307 tep
->info
.section
= SHN_UNDEF
;
7308 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7309 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7310 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7311 tep
->start
.offset
+= aux
->seg_base
;
7312 tep
->end
.offset
+= aux
->seg_base
;
7313 tep
->info
.offset
+= aux
->seg_base
;
7317 /* Third, apply any relocations to the unwind table: */
7318 for (relsec
= section_headers
;
7319 relsec
< section_headers
+ elf_header
.e_shnum
;
7322 if (relsec
->sh_type
!= SHT_RELA
7323 || relsec
->sh_info
>= elf_header
.e_shnum
7324 || section_headers
+ relsec
->sh_info
!= sec
)
7327 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7336 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7338 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7339 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7341 /* PR 17531: file: 9fa67536. */
7342 if (relname
== NULL
)
7344 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7348 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7350 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7354 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7356 /* PR 17531: file: 5bc8d9bf. */
7357 if (i
>= aux
->table_len
)
7359 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7363 switch (rp
->r_offset
/ eh_addr_size
% 3)
7366 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7367 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7370 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7371 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7374 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7375 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7389 ia64_process_unwind (FILE * file
)
7391 Elf_Internal_Shdr
* sec
;
7392 Elf_Internal_Shdr
* unwsec
= NULL
;
7393 Elf_Internal_Shdr
* strsec
;
7394 unsigned long i
, unwcount
= 0, unwstart
= 0;
7395 struct ia64_unw_aux_info aux
;
7396 bfd_boolean res
= TRUE
;
7398 memset (& aux
, 0, sizeof (aux
));
7400 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7402 if (sec
->sh_type
== SHT_SYMTAB
7403 && sec
->sh_link
< elf_header
.e_shnum
)
7405 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7407 strsec
= section_headers
+ sec
->sh_link
;
7408 if (aux
.strtab
!= NULL
)
7410 error (_("Multiple auxillary string tables encountered\n"));
7414 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7417 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7419 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7424 printf (_("\nThere are no unwind sections in this file.\n"));
7426 while (unwcount
-- > 0)
7431 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7432 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7433 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7438 /* We have already counted the number of SHT_IA64_UNWIND
7439 sections so the loop above should never fail. */
7440 assert (unwsec
!= NULL
);
7443 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7445 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7447 /* We need to find which section group it is in. */
7448 struct group_list
* g
;
7450 if (section_headers_groups
== NULL
7451 || section_headers_groups
[i
] == NULL
)
7452 i
= elf_header
.e_shnum
;
7455 g
= section_headers_groups
[i
]->root
;
7457 for (; g
!= NULL
; g
= g
->next
)
7459 sec
= section_headers
+ g
->section_index
;
7461 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7466 i
= elf_header
.e_shnum
;
7469 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7471 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7472 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7473 suffix
= SECTION_NAME (unwsec
) + len
;
7474 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7476 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7477 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7482 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7483 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7484 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7485 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7487 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7488 suffix
= SECTION_NAME (unwsec
) + len
;
7489 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7491 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7492 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7496 if (i
== elf_header
.e_shnum
)
7498 printf (_("\nCould not find unwind info section for "));
7500 if (string_table
== NULL
)
7501 printf ("%d", unwsec
->sh_name
);
7503 printf ("'%s'", printable_section_name (unwsec
));
7507 aux
.info_addr
= sec
->sh_addr
;
7508 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7511 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7513 printf (_("\nUnwind section "));
7515 if (string_table
== NULL
)
7516 printf ("%d", unwsec
->sh_name
);
7518 printf ("'%s'", printable_section_name (unwsec
));
7520 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7521 (unsigned long) unwsec
->sh_offset
,
7522 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7524 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7525 && aux
.table_len
> 0)
7526 dump_ia64_unwind (& aux
);
7529 free ((char *) aux
.table
);
7531 free ((char *) aux
.info
);
7540 free ((char *) aux
.strtab
);
7545 struct hppa_unw_table_entry
7547 struct absaddr start
;
7549 unsigned int Cannot_unwind
:1; /* 0 */
7550 unsigned int Millicode
:1; /* 1 */
7551 unsigned int Millicode_save_sr0
:1; /* 2 */
7552 unsigned int Region_description
:2; /* 3..4 */
7553 unsigned int reserved1
:1; /* 5 */
7554 unsigned int Entry_SR
:1; /* 6 */
7555 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7556 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7557 unsigned int Args_stored
:1; /* 16 */
7558 unsigned int Variable_Frame
:1; /* 17 */
7559 unsigned int Separate_Package_Body
:1; /* 18 */
7560 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7561 unsigned int Stack_Overflow_Check
:1; /* 20 */
7562 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7563 unsigned int Ada_Region
:1; /* 22 */
7564 unsigned int cxx_info
:1; /* 23 */
7565 unsigned int cxx_try_catch
:1; /* 24 */
7566 unsigned int sched_entry_seq
:1; /* 25 */
7567 unsigned int reserved2
:1; /* 26 */
7568 unsigned int Save_SP
:1; /* 27 */
7569 unsigned int Save_RP
:1; /* 28 */
7570 unsigned int Save_MRP_in_frame
:1; /* 29 */
7571 unsigned int extn_ptr_defined
:1; /* 30 */
7572 unsigned int Cleanup_defined
:1; /* 31 */
7574 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7575 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7576 unsigned int Large_frame
:1; /* 2 */
7577 unsigned int Pseudo_SP_Set
:1; /* 3 */
7578 unsigned int reserved4
:1; /* 4 */
7579 unsigned int Total_frame_size
:27; /* 5..31 */
7582 struct hppa_unw_aux_info
7584 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7585 unsigned long table_len
; /* Length of unwind table. */
7586 bfd_vma seg_base
; /* Starting address of segment. */
7587 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7588 unsigned long nsyms
; /* Number of symbols. */
7589 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7590 unsigned long nfuns
; /* Number of entries in funtab. */
7591 char * strtab
; /* The string table. */
7592 unsigned long strtab_size
; /* Size of string table. */
7596 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7598 struct hppa_unw_table_entry
* tp
;
7599 unsigned long j
, nfuns
;
7600 bfd_boolean res
= TRUE
;
7602 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7603 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7604 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7605 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7607 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7609 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7612 const char * procname
;
7614 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7615 aux
->strtab_size
, tp
->start
, &procname
,
7618 fputs ("\n<", stdout
);
7622 fputs (procname
, stdout
);
7625 printf ("+%lx", (unsigned long) offset
);
7628 fputs (">: [", stdout
);
7629 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7630 fputc ('-', stdout
);
7631 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7634 #define PF(_m) if (tp->_m) printf (#_m " ");
7635 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7638 PF(Millicode_save_sr0
);
7639 /* PV(Region_description); */
7645 PF(Separate_Package_Body
);
7646 PF(Frame_Extension_Millicode
);
7647 PF(Stack_Overflow_Check
);
7648 PF(Two_Instruction_SP_Increment
);
7652 PF(sched_entry_seq
);
7655 PF(Save_MRP_in_frame
);
7656 PF(extn_ptr_defined
);
7657 PF(Cleanup_defined
);
7658 PF(MPE_XL_interrupt_marker
);
7659 PF(HP_UX_interrupt_marker
);
7662 PV(Total_frame_size
);
7675 slurp_hppa_unwind_table (FILE * file
,
7676 struct hppa_unw_aux_info
* aux
,
7677 Elf_Internal_Shdr
* sec
)
7679 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7680 Elf_Internal_Phdr
* seg
;
7681 struct hppa_unw_table_entry
* tep
;
7682 Elf_Internal_Shdr
* relsec
;
7683 Elf_Internal_Rela
* rela
;
7684 Elf_Internal_Rela
* rp
;
7685 unsigned char * table
;
7687 Elf_Internal_Sym
* sym
;
7688 const char * relname
;
7690 /* First, find the starting address of the segment that includes
7692 if (elf_header
.e_phnum
)
7694 if (! get_program_headers (file
))
7697 for (seg
= program_headers
;
7698 seg
< program_headers
+ elf_header
.e_phnum
;
7701 if (seg
->p_type
!= PT_LOAD
)
7704 if (sec
->sh_addr
>= seg
->p_vaddr
7705 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7707 aux
->seg_base
= seg
->p_vaddr
;
7713 /* Second, build the unwind table from the contents of the unwind
7715 size
= sec
->sh_size
;
7716 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7722 nentries
= size
/ unw_ent_size
;
7723 size
= unw_ent_size
* nentries
;
7725 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7726 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7728 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7730 unsigned int tmp1
, tmp2
;
7732 tep
->start
.section
= SHN_UNDEF
;
7733 tep
->end
.section
= SHN_UNDEF
;
7735 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7736 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7737 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7738 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7740 tep
->start
.offset
+= aux
->seg_base
;
7741 tep
->end
.offset
+= aux
->seg_base
;
7743 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7744 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7745 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7746 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7747 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7748 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7749 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7750 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7751 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7752 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7753 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7754 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7755 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7756 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7757 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7758 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7759 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7760 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7761 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7762 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7763 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7764 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7765 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7766 tep
->Cleanup_defined
= tmp1
& 0x1;
7768 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7769 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7770 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7771 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7772 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7773 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7777 /* Third, apply any relocations to the unwind table. */
7778 for (relsec
= section_headers
;
7779 relsec
< section_headers
+ elf_header
.e_shnum
;
7782 if (relsec
->sh_type
!= SHT_RELA
7783 || relsec
->sh_info
>= elf_header
.e_shnum
7784 || section_headers
+ relsec
->sh_info
!= sec
)
7787 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7791 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7793 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7794 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7796 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7797 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7799 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7803 i
= rp
->r_offset
/ unw_ent_size
;
7805 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7808 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7809 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7812 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7813 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7823 aux
->table_len
= nentries
;
7829 hppa_process_unwind (FILE * file
)
7831 struct hppa_unw_aux_info aux
;
7832 Elf_Internal_Shdr
* unwsec
= NULL
;
7833 Elf_Internal_Shdr
* strsec
;
7834 Elf_Internal_Shdr
* sec
;
7836 bfd_boolean res
= TRUE
;
7838 if (string_table
== NULL
)
7841 memset (& aux
, 0, sizeof (aux
));
7843 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7845 if (sec
->sh_type
== SHT_SYMTAB
7846 && sec
->sh_link
< elf_header
.e_shnum
)
7848 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7850 strsec
= section_headers
+ sec
->sh_link
;
7851 if (aux
.strtab
!= NULL
)
7853 error (_("Multiple auxillary string tables encountered\n"));
7857 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7860 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7862 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7867 printf (_("\nThere are no unwind sections in this file.\n"));
7869 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7871 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7873 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7874 printable_section_name (sec
),
7875 (unsigned long) sec
->sh_offset
,
7876 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7878 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7881 if (aux
.table_len
> 0)
7883 if (! dump_hppa_unwind (&aux
))
7888 free ((char *) aux
.table
);
7896 free ((char *) aux
.strtab
);
7903 unsigned char * data
; /* The unwind data. */
7904 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7905 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7906 unsigned long nrelas
; /* The number of relocations. */
7907 unsigned int rel_type
; /* REL or RELA ? */
7908 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7911 struct arm_unw_aux_info
7913 FILE * file
; /* The file containing the unwind sections. */
7914 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7915 unsigned long nsyms
; /* Number of symbols. */
7916 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7917 unsigned long nfuns
; /* Number of these symbols. */
7918 char * strtab
; /* The file's string table. */
7919 unsigned long strtab_size
; /* Size of string table. */
7923 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7924 bfd_vma fn
, struct absaddr addr
)
7926 const char *procname
;
7929 if (addr
.section
== SHN_UNDEF
)
7932 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7933 aux
->strtab_size
, addr
, &procname
,
7936 print_vma (fn
, PREFIX_HEX
);
7940 fputs (" <", stdout
);
7941 fputs (procname
, stdout
);
7944 printf ("+0x%lx", (unsigned long) sym_offset
);
7945 fputc ('>', stdout
);
7952 arm_free_section (struct arm_section
*arm_sec
)
7954 if (arm_sec
->data
!= NULL
)
7955 free (arm_sec
->data
);
7957 if (arm_sec
->rela
!= NULL
)
7958 free (arm_sec
->rela
);
7961 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7962 cached section and install SEC instead.
7963 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7964 and return its valued in * WORDP, relocating if necessary.
7965 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7966 relocation's offset in ADDR.
7967 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7968 into the string table of the symbol associated with the reloc. If no
7969 reloc was applied store -1 there.
7970 5) Return TRUE upon success, FALSE otherwise. */
7973 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7974 struct arm_section
* arm_sec
,
7975 Elf_Internal_Shdr
* sec
,
7976 bfd_vma word_offset
,
7977 unsigned int * wordp
,
7978 struct absaddr
* addr
,
7981 Elf_Internal_Rela
*rp
;
7982 Elf_Internal_Sym
*sym
;
7983 const char * relname
;
7985 bfd_boolean wrapped
;
7987 if (sec
== NULL
|| arm_sec
== NULL
)
7990 addr
->section
= SHN_UNDEF
;
7993 if (sym_name
!= NULL
)
7994 *sym_name
= (bfd_vma
) -1;
7996 /* If necessary, update the section cache. */
7997 if (sec
!= arm_sec
->sec
)
7999 Elf_Internal_Shdr
*relsec
;
8001 arm_free_section (arm_sec
);
8004 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8005 sec
->sh_size
, _("unwind data"));
8006 arm_sec
->rela
= NULL
;
8007 arm_sec
->nrelas
= 0;
8009 for (relsec
= section_headers
;
8010 relsec
< section_headers
+ elf_header
.e_shnum
;
8013 if (relsec
->sh_info
>= elf_header
.e_shnum
8014 || section_headers
+ relsec
->sh_info
!= sec
8015 /* PR 15745: Check the section type as well. */
8016 || (relsec
->sh_type
!= SHT_REL
8017 && relsec
->sh_type
!= SHT_RELA
))
8020 arm_sec
->rel_type
= relsec
->sh_type
;
8021 if (relsec
->sh_type
== SHT_REL
)
8023 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8025 & arm_sec
->rela
, & arm_sec
->nrelas
))
8028 else /* relsec->sh_type == SHT_RELA */
8030 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8032 & arm_sec
->rela
, & arm_sec
->nrelas
))
8038 arm_sec
->next_rela
= arm_sec
->rela
;
8041 /* If there is no unwind data we can do nothing. */
8042 if (arm_sec
->data
== NULL
)
8045 /* If the offset is invalid then fail. */
8046 if (word_offset
> (sec
->sh_size
- 4)
8048 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
8049 || ((bfd_signed_vma
) word_offset
) < 0)
8052 /* Get the word at the required offset. */
8053 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8055 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8056 if (arm_sec
->rela
== NULL
)
8062 /* Look through the relocs to find the one that applies to the provided offset. */
8064 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8066 bfd_vma prelval
, offset
;
8068 if (rp
->r_offset
> word_offset
&& !wrapped
)
8073 if (rp
->r_offset
> word_offset
)
8076 if (rp
->r_offset
& 3)
8078 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8079 (unsigned long) rp
->r_offset
);
8083 if (rp
->r_offset
< word_offset
)
8086 /* PR 17531: file: 027-161405-0.004 */
8087 if (aux
->symtab
== NULL
)
8090 if (arm_sec
->rel_type
== SHT_REL
)
8092 offset
= word
& 0x7fffffff;
8093 if (offset
& 0x40000000)
8094 offset
|= ~ (bfd_vma
) 0x7fffffff;
8096 else if (arm_sec
->rel_type
== SHT_RELA
)
8097 offset
= rp
->r_addend
;
8100 error (_("Unknown section relocation type %d encountered\n"),
8105 /* PR 17531 file: 027-1241568-0.004. */
8106 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8108 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8109 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8113 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8114 offset
+= sym
->st_value
;
8115 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8117 /* Check that we are processing the expected reloc type. */
8118 if (elf_header
.e_machine
== EM_ARM
)
8120 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8121 if (relname
== NULL
)
8123 warn (_("Skipping unknown ARM relocation type: %d\n"),
8124 (int) ELF32_R_TYPE (rp
->r_info
));
8128 if (streq (relname
, "R_ARM_NONE"))
8131 if (! streq (relname
, "R_ARM_PREL31"))
8133 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8137 else if (elf_header
.e_machine
== EM_TI_C6000
)
8139 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8140 if (relname
== NULL
)
8142 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8143 (int) ELF32_R_TYPE (rp
->r_info
));
8147 if (streq (relname
, "R_C6000_NONE"))
8150 if (! streq (relname
, "R_C6000_PREL31"))
8152 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8160 /* This function currently only supports ARM and TI unwinders. */
8161 warn (_("Only TI and ARM unwinders are currently supported\n"));
8165 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8166 addr
->section
= sym
->st_shndx
;
8167 addr
->offset
= offset
;
8170 * sym_name
= sym
->st_name
;
8175 arm_sec
->next_rela
= rp
;
8180 static const char *tic6x_unwind_regnames
[16] =
8182 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8183 "A14", "A13", "A12", "A11", "A10",
8184 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8188 decode_tic6x_unwind_regmask (unsigned int mask
)
8192 for (i
= 12; mask
; mask
>>= 1, i
--)
8196 fputs (tic6x_unwind_regnames
[i
], stdout
);
8198 fputs (", ", stdout
);
8204 if (remaining == 0 && more_words) \
8207 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8208 data_offset, & word, & addr, NULL)) \
8214 #define GET_OP(OP) \
8219 (OP) = word >> 24; \
8224 printf (_("[Truncated opcode]\n")); \
8227 printf ("0x%02x ", OP)
8230 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8232 unsigned int remaining
,
8233 unsigned int more_words
,
8234 bfd_vma data_offset
,
8235 Elf_Internal_Shdr
* data_sec
,
8236 struct arm_section
* data_arm_sec
)
8238 struct absaddr addr
;
8239 bfd_boolean res
= TRUE
;
8241 /* Decode the unwinding instructions. */
8244 unsigned int op
, op2
;
8253 printf (" 0x%02x ", op
);
8255 if ((op
& 0xc0) == 0x00)
8257 int offset
= ((op
& 0x3f) << 2) + 4;
8259 printf (" vsp = vsp + %d", offset
);
8261 else if ((op
& 0xc0) == 0x40)
8263 int offset
= ((op
& 0x3f) << 2) + 4;
8265 printf (" vsp = vsp - %d", offset
);
8267 else if ((op
& 0xf0) == 0x80)
8270 if (op
== 0x80 && op2
== 0)
8271 printf (_("Refuse to unwind"));
8274 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8275 bfd_boolean first
= TRUE
;
8279 for (i
= 0; i
< 12; i
++)
8280 if (mask
& (1 << i
))
8286 printf ("r%d", 4 + i
);
8291 else if ((op
& 0xf0) == 0x90)
8293 if (op
== 0x9d || op
== 0x9f)
8294 printf (_(" [Reserved]"));
8296 printf (" vsp = r%d", op
& 0x0f);
8298 else if ((op
& 0xf0) == 0xa0)
8300 int end
= 4 + (op
& 0x07);
8301 bfd_boolean first
= TRUE
;
8305 for (i
= 4; i
<= end
; i
++)
8321 else if (op
== 0xb0)
8322 printf (_(" finish"));
8323 else if (op
== 0xb1)
8326 if (op2
== 0 || (op2
& 0xf0) != 0)
8327 printf (_("[Spare]"));
8330 unsigned int mask
= op2
& 0x0f;
8331 bfd_boolean first
= TRUE
;
8335 for (i
= 0; i
< 12; i
++)
8336 if (mask
& (1 << i
))
8347 else if (op
== 0xb2)
8349 unsigned char buf
[9];
8350 unsigned int i
, len
;
8351 unsigned long offset
;
8353 for (i
= 0; i
< sizeof (buf
); i
++)
8356 if ((buf
[i
] & 0x80) == 0)
8359 if (i
== sizeof (buf
))
8361 error (_("corrupt change to vsp"));
8366 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8367 assert (len
== i
+ 1);
8368 offset
= offset
* 4 + 0x204;
8369 printf ("vsp = vsp + %ld", offset
);
8372 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8374 unsigned int first
, last
;
8381 printf ("pop {D%d", first
);
8383 printf ("-D%d", first
+ last
);
8386 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8388 unsigned int count
= op
& 0x07;
8392 printf ("-D%d", 8 + count
);
8395 else if (op
>= 0xc0 && op
<= 0xc5)
8397 unsigned int count
= op
& 0x07;
8399 printf (" pop {wR10");
8401 printf ("-wR%d", 10 + count
);
8404 else if (op
== 0xc6)
8406 unsigned int first
, last
;
8411 printf ("pop {wR%d", first
);
8413 printf ("-wR%d", first
+ last
);
8416 else if (op
== 0xc7)
8419 if (op2
== 0 || (op2
& 0xf0) != 0)
8420 printf (_("[Spare]"));
8423 unsigned int mask
= op2
& 0x0f;
8424 bfd_boolean first
= TRUE
;
8428 for (i
= 0; i
< 4; i
++)
8429 if (mask
& (1 << i
))
8435 printf ("wCGR%d", i
);
8442 printf (_(" [unsupported opcode]"));
8453 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8455 unsigned int remaining
,
8456 unsigned int more_words
,
8457 bfd_vma data_offset
,
8458 Elf_Internal_Shdr
* data_sec
,
8459 struct arm_section
* data_arm_sec
)
8461 struct absaddr addr
;
8463 /* Decode the unwinding instructions. */
8466 unsigned int op
, op2
;
8475 printf (" 0x%02x ", op
);
8477 if ((op
& 0xc0) == 0x00)
8479 int offset
= ((op
& 0x3f) << 3) + 8;
8480 printf (" sp = sp + %d", offset
);
8482 else if ((op
& 0xc0) == 0x80)
8485 if (op
== 0x80 && op2
== 0)
8486 printf (_("Refuse to unwind"));
8489 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8491 printf ("pop compact {");
8495 decode_tic6x_unwind_regmask (mask
);
8499 else if ((op
& 0xf0) == 0xc0)
8507 unsigned int offset
;
8511 /* Scan entire instruction first so that GET_OP output is not
8512 interleaved with disassembly. */
8514 for (i
= 0; nregs
< (op
& 0xf); i
++)
8520 regpos
[nregs
].offset
= i
* 2;
8521 regpos
[nregs
].reg
= reg
;
8528 regpos
[nregs
].offset
= i
* 2 + 1;
8529 regpos
[nregs
].reg
= reg
;
8534 printf (_("pop frame {"));
8536 for (i
= i
* 2; i
> 0; i
--)
8538 if (regpos
[reg
].offset
== i
- 1)
8540 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8547 fputs (name
, stdout
);
8554 else if (op
== 0xd0)
8555 printf (" MOV FP, SP");
8556 else if (op
== 0xd1)
8557 printf (" __c6xabi_pop_rts");
8558 else if (op
== 0xd2)
8560 unsigned char buf
[9];
8561 unsigned int i
, len
;
8562 unsigned long offset
;
8564 for (i
= 0; i
< sizeof (buf
); i
++)
8567 if ((buf
[i
] & 0x80) == 0)
8570 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8571 if (i
== sizeof (buf
))
8573 warn (_("Corrupt stack pointer adjustment detected\n"));
8577 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8578 assert (len
== i
+ 1);
8579 offset
= offset
* 8 + 0x408;
8580 printf (_("sp = sp + %ld"), offset
);
8582 else if ((op
& 0xf0) == 0xe0)
8584 if ((op
& 0x0f) == 7)
8587 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8591 printf (_(" [unsupported opcode]"));
8600 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8604 offset
= word
& 0x7fffffff;
8605 if (offset
& 0x40000000)
8606 offset
|= ~ (bfd_vma
) 0x7fffffff;
8608 if (elf_header
.e_machine
== EM_TI_C6000
)
8611 return offset
+ where
;
8615 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8617 unsigned int remaining
,
8618 bfd_vma data_offset
,
8619 Elf_Internal_Shdr
* data_sec
,
8620 struct arm_section
* data_arm_sec
)
8623 unsigned int more_words
= 0;
8624 struct absaddr addr
;
8625 bfd_vma sym_name
= (bfd_vma
) -1;
8626 bfd_boolean res
= FALSE
;
8630 /* Fetch the first word.
8631 Note - when decoding an object file the address extracted
8632 here will always be 0. So we also pass in the sym_name
8633 parameter so that we can find the symbol associated with
8634 the personality routine. */
8635 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8636 & word
, & addr
, & sym_name
))
8642 if ((word
& 0x80000000) == 0)
8644 /* Expand prel31 for personality routine. */
8646 const char *procname
;
8648 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8649 printf (_(" Personality routine: "));
8651 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8652 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8654 procname
= aux
->strtab
+ sym_name
;
8655 print_vma (fn
, PREFIX_HEX
);
8658 fputs (" <", stdout
);
8659 fputs (procname
, stdout
);
8660 fputc ('>', stdout
);
8664 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8665 fputc ('\n', stdout
);
8667 /* The GCC personality routines use the standard compact
8668 encoding, starting with one byte giving the number of
8670 if (procname
!= NULL
8671 && (const_strneq (procname
, "__gcc_personality_v0")
8672 || const_strneq (procname
, "__gxx_personality_v0")
8673 || const_strneq (procname
, "__gcj_personality_v0")
8674 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8681 printf (_(" [Truncated data]\n"));
8684 more_words
= word
>> 24;
8694 /* ARM EHABI Section 6.3:
8696 An exception-handling table entry for the compact model looks like:
8700 1 0 index Data for personalityRoutine[index] */
8702 if (elf_header
.e_machine
== EM_ARM
8703 && (word
& 0x70000000))
8705 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8709 per_index
= (word
>> 24) & 0x7f;
8710 printf (_(" Compact model index: %d\n"), per_index
);
8717 else if (per_index
< 3)
8719 more_words
= (word
>> 16) & 0xff;
8725 switch (elf_header
.e_machine
)
8730 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8731 data_offset
, data_sec
, data_arm_sec
))
8736 warn (_("Unknown ARM compact model index encountered\n"));
8737 printf (_(" [reserved]\n"));
8745 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8746 data_offset
, data_sec
, data_arm_sec
))
8749 else if (per_index
< 5)
8751 if (((word
>> 17) & 0x7f) == 0x7f)
8752 printf (_(" Restore stack from frame pointer\n"));
8754 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8755 printf (_(" Registers restored: "));
8757 printf (" (compact) ");
8758 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8760 printf (_(" Return register: %s\n"),
8761 tic6x_unwind_regnames
[word
& 0xf]);
8764 printf (_(" [reserved (%d)]\n"), per_index
);
8768 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8769 elf_header
.e_machine
);
8773 /* Decode the descriptors. Not implemented. */
8779 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8781 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8782 unsigned int i
, exidx_len
;
8783 unsigned long j
, nfuns
;
8784 bfd_boolean res
= TRUE
;
8786 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8787 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8788 exidx_len
= exidx_sec
->sh_size
/ 8;
8790 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8791 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8792 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8793 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8795 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8797 for (i
= 0; i
< exidx_len
; i
++)
8799 unsigned int exidx_fn
, exidx_entry
;
8800 struct absaddr fn_addr
, entry_addr
;
8803 fputc ('\n', stdout
);
8805 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8806 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8807 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8808 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8811 arm_free_section (& exidx_arm_sec
);
8812 arm_free_section (& extab_arm_sec
);
8816 /* ARM EHABI, Section 5:
8817 An index table entry consists of 2 words.
8818 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8819 if (exidx_fn
& 0x80000000)
8821 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8825 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8827 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8828 fputs (": ", stdout
);
8830 if (exidx_entry
== 1)
8832 print_vma (exidx_entry
, PREFIX_HEX
);
8833 fputs (" [cantunwind]\n", stdout
);
8835 else if (exidx_entry
& 0x80000000)
8837 print_vma (exidx_entry
, PREFIX_HEX
);
8838 fputc ('\n', stdout
);
8839 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8843 bfd_vma table
, table_offset
= 0;
8844 Elf_Internal_Shdr
*table_sec
;
8846 fputs ("@", stdout
);
8847 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8848 print_vma (table
, PREFIX_HEX
);
8851 /* Locate the matching .ARM.extab. */
8852 if (entry_addr
.section
!= SHN_UNDEF
8853 && entry_addr
.section
< elf_header
.e_shnum
)
8855 table_sec
= section_headers
+ entry_addr
.section
;
8856 table_offset
= entry_addr
.offset
;
8858 if (table_offset
> table_sec
->sh_size
8859 || ((bfd_signed_vma
) table_offset
) < 0)
8861 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8862 (unsigned long) table_offset
,
8863 printable_section_name (table_sec
));
8870 table_sec
= find_section_by_address (table
);
8871 if (table_sec
!= NULL
)
8872 table_offset
= table
- table_sec
->sh_addr
;
8875 if (table_sec
== NULL
)
8877 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8878 (unsigned long) table
);
8883 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8892 arm_free_section (&exidx_arm_sec
);
8893 arm_free_section (&extab_arm_sec
);
8898 /* Used for both ARM and C6X unwinding tables. */
8901 arm_process_unwind (FILE *file
)
8903 struct arm_unw_aux_info aux
;
8904 Elf_Internal_Shdr
*unwsec
= NULL
;
8905 Elf_Internal_Shdr
*strsec
;
8906 Elf_Internal_Shdr
*sec
;
8908 unsigned int sec_type
;
8909 bfd_boolean res
= TRUE
;
8911 switch (elf_header
.e_machine
)
8914 sec_type
= SHT_ARM_EXIDX
;
8918 sec_type
= SHT_C6000_UNWIND
;
8922 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8923 elf_header
.e_machine
);
8927 if (string_table
== NULL
)
8930 memset (& aux
, 0, sizeof (aux
));
8933 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8935 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8937 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8939 strsec
= section_headers
+ sec
->sh_link
;
8941 /* PR binutils/17531 file: 011-12666-0.004. */
8942 if (aux
.strtab
!= NULL
)
8944 error (_("Multiple string tables found in file.\n"));
8948 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8949 1, strsec
->sh_size
, _("string table"));
8950 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8952 else if (sec
->sh_type
== sec_type
)
8957 printf (_("\nThere are no unwind sections in this file.\n"));
8959 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8961 if (sec
->sh_type
== sec_type
)
8963 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8964 printable_section_name (sec
),
8965 (unsigned long) sec
->sh_offset
,
8966 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8968 if (! dump_arm_unwind (&aux
, sec
))
8976 free ((char *) aux
.strtab
);
8982 process_unwind (FILE * file
)
8984 struct unwind_handler
8986 unsigned int machtype
;
8987 bfd_boolean (* handler
)(FILE *);
8990 { EM_ARM
, arm_process_unwind
},
8991 { EM_IA_64
, ia64_process_unwind
},
8992 { EM_PARISC
, hppa_process_unwind
},
8993 { EM_TI_C6000
, arm_process_unwind
},
9001 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9002 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9003 return handlers
[i
].handler (file
);
9005 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9006 get_machine_name (elf_header
.e_machine
));
9011 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9013 switch (entry
->d_tag
)
9016 if (entry
->d_un
.d_val
== 0)
9020 static const char * opts
[] =
9022 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9023 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9024 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9025 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9029 bfd_boolean first
= TRUE
;
9031 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9032 if (entry
->d_un
.d_val
& (1 << cnt
))
9034 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9040 case DT_MIPS_IVERSION
:
9041 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9042 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9046 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9047 /* Note: coded this way so that there is a single string for translation. */
9048 printf (_("<corrupt: %s>"), buf
);
9052 case DT_MIPS_TIME_STAMP
:
9056 time_t atime
= entry
->d_un
.d_val
;
9058 tmp
= gmtime (&atime
);
9059 /* PR 17531: file: 6accc532. */
9061 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9063 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9064 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9065 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9066 printf (_("Time Stamp: %s"), timebuf
);
9070 case DT_MIPS_RLD_VERSION
:
9071 case DT_MIPS_LOCAL_GOTNO
:
9072 case DT_MIPS_CONFLICTNO
:
9073 case DT_MIPS_LIBLISTNO
:
9074 case DT_MIPS_SYMTABNO
:
9075 case DT_MIPS_UNREFEXTNO
:
9076 case DT_MIPS_HIPAGENO
:
9077 case DT_MIPS_DELTA_CLASS_NO
:
9078 case DT_MIPS_DELTA_INSTANCE_NO
:
9079 case DT_MIPS_DELTA_RELOC_NO
:
9080 case DT_MIPS_DELTA_SYM_NO
:
9081 case DT_MIPS_DELTA_CLASSSYM_NO
:
9082 case DT_MIPS_COMPACT_SIZE
:
9083 print_vma (entry
->d_un
.d_val
, DEC
);
9087 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9093 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9095 switch (entry
->d_tag
)
9097 case DT_HP_DLD_FLAGS
:
9106 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9107 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9108 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9109 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9110 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9111 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9112 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9113 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9114 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9115 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9116 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9117 { DT_HP_GST
, "HP_GST" },
9118 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9119 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9120 { DT_HP_NODELETE
, "HP_NODELETE" },
9121 { DT_HP_GROUP
, "HP_GROUP" },
9122 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9124 bfd_boolean first
= TRUE
;
9126 bfd_vma val
= entry
->d_un
.d_val
;
9128 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9129 if (val
& flags
[cnt
].bit
)
9133 fputs (flags
[cnt
].str
, stdout
);
9135 val
^= flags
[cnt
].bit
;
9138 if (val
!= 0 || first
)
9142 print_vma (val
, HEX
);
9148 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9156 /* VMS vs Unix time offset and factor. */
9158 #define VMS_EPOCH_OFFSET 35067168000000000LL
9159 #define VMS_GRANULARITY_FACTOR 10000000
9161 /* Display a VMS time in a human readable format. */
9164 print_vms_time (bfd_int64_t vmstime
)
9169 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9170 tm
= gmtime (&unxtime
);
9171 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9172 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9173 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9178 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9180 switch (entry
->d_tag
)
9182 case DT_IA_64_PLT_RESERVE
:
9183 /* First 3 slots reserved. */
9184 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9186 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9189 case DT_IA_64_VMS_LINKTIME
:
9191 print_vms_time (entry
->d_un
.d_val
);
9195 case DT_IA_64_VMS_LNKFLAGS
:
9196 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9197 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9198 printf (" CALL_DEBUG");
9199 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9200 printf (" NOP0BUFS");
9201 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9202 printf (" P0IMAGE");
9203 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9204 printf (" MKTHREADS");
9205 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9206 printf (" UPCALLS");
9207 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9209 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9210 printf (" INITIALIZE");
9211 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9213 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9214 printf (" EXE_INIT");
9215 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9216 printf (" TBK_IN_IMG");
9217 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9218 printf (" DBG_IN_IMG");
9219 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9220 printf (" TBK_IN_DSF");
9221 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9222 printf (" DBG_IN_DSF");
9223 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9224 printf (" SIGNATURES");
9225 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9226 printf (" REL_SEG_OFF");
9230 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9237 get_32bit_dynamic_section (FILE * file
)
9239 Elf32_External_Dyn
* edyn
;
9240 Elf32_External_Dyn
* ext
;
9241 Elf_Internal_Dyn
* entry
;
9243 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9244 dynamic_size
, _("dynamic section"));
9248 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9249 might not have the luxury of section headers. Look for the DT_NULL
9250 terminator to determine the number of entries. */
9251 for (ext
= edyn
, dynamic_nent
= 0;
9252 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9256 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9260 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9262 if (dynamic_section
== NULL
)
9264 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9265 (unsigned long) dynamic_nent
);
9270 for (ext
= edyn
, entry
= dynamic_section
;
9271 entry
< dynamic_section
+ dynamic_nent
;
9274 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9275 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9284 get_64bit_dynamic_section (FILE * file
)
9286 Elf64_External_Dyn
* edyn
;
9287 Elf64_External_Dyn
* ext
;
9288 Elf_Internal_Dyn
* entry
;
9290 /* Read in the data. */
9291 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9292 dynamic_size
, _("dynamic section"));
9296 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9297 might not have the luxury of section headers. Look for the DT_NULL
9298 terminator to determine the number of entries. */
9299 for (ext
= edyn
, dynamic_nent
= 0;
9300 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9301 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9305 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9309 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9311 if (dynamic_section
== NULL
)
9313 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9314 (unsigned long) dynamic_nent
);
9319 /* Convert from external to internal formats. */
9320 for (ext
= edyn
, entry
= dynamic_section
;
9321 entry
< dynamic_section
+ dynamic_nent
;
9324 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9325 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9334 print_dynamic_flags (bfd_vma flags
)
9336 bfd_boolean first
= TRUE
;
9342 flag
= flags
& - flags
;
9352 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9353 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9354 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9355 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9356 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9357 default: fputs (_("unknown"), stdout
); break;
9363 /* Parse and display the contents of the dynamic section. */
9366 process_dynamic_section (FILE * file
)
9368 Elf_Internal_Dyn
* entry
;
9370 if (dynamic_size
== 0)
9373 printf (_("\nThere is no dynamic section in this file.\n"));
9380 if (! get_32bit_dynamic_section (file
))
9385 if (! get_64bit_dynamic_section (file
))
9389 /* Find the appropriate symbol table. */
9390 if (dynamic_symbols
== NULL
)
9392 for (entry
= dynamic_section
;
9393 entry
< dynamic_section
+ dynamic_nent
;
9396 Elf_Internal_Shdr section
;
9398 if (entry
->d_tag
!= DT_SYMTAB
)
9401 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9403 /* Since we do not know how big the symbol table is,
9404 we default to reading in the entire file (!) and
9405 processing that. This is overkill, I know, but it
9407 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9409 if (archive_file_offset
!= 0)
9410 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9413 if (fseek (file
, 0, SEEK_END
))
9414 error (_("Unable to seek to end of file!\n"));
9416 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9420 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9422 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9423 section
.sh_name
= string_table_length
;
9425 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9426 if (num_dynamic_syms
< 1)
9428 error (_("Unable to determine the number of symbols to load\n"));
9434 /* Similarly find a string table. */
9435 if (dynamic_strings
== NULL
)
9437 for (entry
= dynamic_section
;
9438 entry
< dynamic_section
+ dynamic_nent
;
9441 unsigned long offset
;
9444 if (entry
->d_tag
!= DT_STRTAB
)
9447 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9449 /* Since we do not know how big the string table is,
9450 we default to reading in the entire file (!) and
9451 processing that. This is overkill, I know, but it
9454 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9456 if (archive_file_offset
!= 0)
9457 str_tab_len
= archive_file_size
- offset
;
9460 if (fseek (file
, 0, SEEK_END
))
9461 error (_("Unable to seek to end of file\n"));
9462 str_tab_len
= ftell (file
) - offset
;
9465 if (str_tab_len
< 1)
9468 (_("Unable to determine the length of the dynamic string table\n"));
9472 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9474 _("dynamic string table"));
9475 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9480 /* And find the syminfo section if available. */
9481 if (dynamic_syminfo
== NULL
)
9483 unsigned long syminsz
= 0;
9485 for (entry
= dynamic_section
;
9486 entry
< dynamic_section
+ dynamic_nent
;
9489 if (entry
->d_tag
== DT_SYMINENT
)
9491 /* Note: these braces are necessary to avoid a syntax
9492 error from the SunOS4 C compiler. */
9493 /* PR binutils/17531: A corrupt file can trigger this test.
9494 So do not use an assert, instead generate an error message. */
9495 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9496 error (_("Bad value (%d) for SYMINENT entry\n"),
9497 (int) entry
->d_un
.d_val
);
9499 else if (entry
->d_tag
== DT_SYMINSZ
)
9500 syminsz
= entry
->d_un
.d_val
;
9501 else if (entry
->d_tag
== DT_SYMINFO
)
9502 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9506 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9508 Elf_External_Syminfo
* extsyminfo
;
9509 Elf_External_Syminfo
* extsym
;
9510 Elf_Internal_Syminfo
* syminfo
;
9512 /* There is a syminfo section. Read the data. */
9513 extsyminfo
= (Elf_External_Syminfo
*)
9514 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9515 _("symbol information"));
9519 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9520 if (dynamic_syminfo
== NULL
)
9522 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9523 (unsigned long) syminsz
);
9527 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9528 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9529 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9530 ++syminfo
, ++extsym
)
9532 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9533 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9540 if (do_dynamic
&& dynamic_addr
)
9541 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9542 dynamic_addr
, (unsigned long) dynamic_nent
);
9544 printf (_(" Tag Type Name/Value\n"));
9546 for (entry
= dynamic_section
;
9547 entry
< dynamic_section
+ dynamic_nent
;
9555 print_vma (entry
->d_tag
, FULL_HEX
);
9556 dtype
= get_dynamic_type (entry
->d_tag
);
9557 printf (" (%s)%*s", dtype
,
9558 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9561 switch (entry
->d_tag
)
9565 print_dynamic_flags (entry
->d_un
.d_val
);
9575 switch (entry
->d_tag
)
9578 printf (_("Auxiliary library"));
9582 printf (_("Filter library"));
9586 printf (_("Configuration file"));
9590 printf (_("Dependency audit library"));
9594 printf (_("Audit library"));
9598 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9599 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9603 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9612 printf (_("Flags:"));
9614 if (entry
->d_un
.d_val
== 0)
9615 printf (_(" None\n"));
9618 unsigned long int val
= entry
->d_un
.d_val
;
9620 if (val
& DTF_1_PARINIT
)
9622 printf (" PARINIT");
9623 val
^= DTF_1_PARINIT
;
9625 if (val
& DTF_1_CONFEXP
)
9627 printf (" CONFEXP");
9628 val
^= DTF_1_CONFEXP
;
9631 printf (" %lx", val
);
9640 printf (_("Flags:"));
9642 if (entry
->d_un
.d_val
== 0)
9643 printf (_(" None\n"));
9646 unsigned long int val
= entry
->d_un
.d_val
;
9648 if (val
& DF_P1_LAZYLOAD
)
9650 printf (" LAZYLOAD");
9651 val
^= DF_P1_LAZYLOAD
;
9653 if (val
& DF_P1_GROUPPERM
)
9655 printf (" GROUPPERM");
9656 val
^= DF_P1_GROUPPERM
;
9659 printf (" %lx", val
);
9668 printf (_("Flags:"));
9669 if (entry
->d_un
.d_val
== 0)
9670 printf (_(" None\n"));
9673 unsigned long int val
= entry
->d_un
.d_val
;
9680 if (val
& DF_1_GLOBAL
)
9685 if (val
& DF_1_GROUP
)
9690 if (val
& DF_1_NODELETE
)
9692 printf (" NODELETE");
9693 val
^= DF_1_NODELETE
;
9695 if (val
& DF_1_LOADFLTR
)
9697 printf (" LOADFLTR");
9698 val
^= DF_1_LOADFLTR
;
9700 if (val
& DF_1_INITFIRST
)
9702 printf (" INITFIRST");
9703 val
^= DF_1_INITFIRST
;
9705 if (val
& DF_1_NOOPEN
)
9710 if (val
& DF_1_ORIGIN
)
9715 if (val
& DF_1_DIRECT
)
9720 if (val
& DF_1_TRANS
)
9725 if (val
& DF_1_INTERPOSE
)
9727 printf (" INTERPOSE");
9728 val
^= DF_1_INTERPOSE
;
9730 if (val
& DF_1_NODEFLIB
)
9732 printf (" NODEFLIB");
9733 val
^= DF_1_NODEFLIB
;
9735 if (val
& DF_1_NODUMP
)
9740 if (val
& DF_1_CONFALT
)
9742 printf (" CONFALT");
9743 val
^= DF_1_CONFALT
;
9745 if (val
& DF_1_ENDFILTEE
)
9747 printf (" ENDFILTEE");
9748 val
^= DF_1_ENDFILTEE
;
9750 if (val
& DF_1_DISPRELDNE
)
9752 printf (" DISPRELDNE");
9753 val
^= DF_1_DISPRELDNE
;
9755 if (val
& DF_1_DISPRELPND
)
9757 printf (" DISPRELPND");
9758 val
^= DF_1_DISPRELPND
;
9760 if (val
& DF_1_NODIRECT
)
9762 printf (" NODIRECT");
9763 val
^= DF_1_NODIRECT
;
9765 if (val
& DF_1_IGNMULDEF
)
9767 printf (" IGNMULDEF");
9768 val
^= DF_1_IGNMULDEF
;
9770 if (val
& DF_1_NOKSYMS
)
9772 printf (" NOKSYMS");
9773 val
^= DF_1_NOKSYMS
;
9775 if (val
& DF_1_NOHDR
)
9780 if (val
& DF_1_EDITED
)
9785 if (val
& DF_1_NORELOC
)
9787 printf (" NORELOC");
9788 val
^= DF_1_NORELOC
;
9790 if (val
& DF_1_SYMINTPOSE
)
9792 printf (" SYMINTPOSE");
9793 val
^= DF_1_SYMINTPOSE
;
9795 if (val
& DF_1_GLOBAUDIT
)
9797 printf (" GLOBAUDIT");
9798 val
^= DF_1_GLOBAUDIT
;
9800 if (val
& DF_1_SINGLETON
)
9802 printf (" SINGLETON");
9803 val
^= DF_1_SINGLETON
;
9805 if (val
& DF_1_STUB
)
9816 printf (" %lx", val
);
9823 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9825 puts (get_dynamic_type (entry
->d_un
.d_val
));
9845 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9851 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9852 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9858 switch (entry
->d_tag
)
9861 printf (_("Shared library: [%s]"), name
);
9863 if (streq (name
, program_interpreter
))
9864 printf (_(" program interpreter"));
9868 printf (_("Library soname: [%s]"), name
);
9872 printf (_("Library rpath: [%s]"), name
);
9876 printf (_("Library runpath: [%s]"), name
);
9880 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9885 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9898 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9903 case DT_INIT_ARRAYSZ
:
9904 case DT_FINI_ARRAYSZ
:
9905 case DT_GNU_CONFLICTSZ
:
9906 case DT_GNU_LIBLISTSZ
:
9909 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9910 printf (_(" (bytes)\n"));
9920 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9933 if (entry
->d_tag
== DT_USED
9934 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9936 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9940 printf (_("Not needed object: [%s]\n"), name
);
9945 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9951 /* The value of this entry is ignored. */
9956 case DT_GNU_PRELINKED
:
9960 time_t atime
= entry
->d_un
.d_val
;
9962 tmp
= gmtime (&atime
);
9963 /* PR 17533 file: 041-1244816-0.004. */
9965 printf (_("<corrupt time val: %lx"),
9966 (unsigned long) atime
);
9968 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9969 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9970 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9976 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9979 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9985 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9986 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9991 switch (elf_header
.e_machine
)
9994 case EM_MIPS_RS3_LE
:
9995 dynamic_section_mips_val (entry
);
9998 dynamic_section_parisc_val (entry
);
10001 dynamic_section_ia64_val (entry
);
10004 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10016 get_ver_flags (unsigned int flags
)
10018 static char buff
[32];
10025 if (flags
& VER_FLG_BASE
)
10026 strcat (buff
, "BASE");
10028 if (flags
& VER_FLG_WEAK
)
10030 if (flags
& VER_FLG_BASE
)
10031 strcat (buff
, " | ");
10033 strcat (buff
, "WEAK");
10036 if (flags
& VER_FLG_INFO
)
10038 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10039 strcat (buff
, " | ");
10041 strcat (buff
, "INFO");
10044 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10046 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10047 strcat (buff
, " | ");
10049 strcat (buff
, _("<unknown>"));
10055 /* Display the contents of the version sections. */
10058 process_version_sections (FILE * file
)
10060 Elf_Internal_Shdr
* section
;
10062 bfd_boolean found
= FALSE
;
10067 for (i
= 0, section
= section_headers
;
10068 i
< elf_header
.e_shnum
;
10071 switch (section
->sh_type
)
10073 case SHT_GNU_verdef
:
10075 Elf_External_Verdef
* edefs
;
10083 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10084 printable_section_name (section
),
10087 printf (_(" Addr: 0x"));
10088 printf_vma (section
->sh_addr
);
10089 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10090 (unsigned long) section
->sh_offset
, section
->sh_link
,
10091 printable_section_name_from_index (section
->sh_link
));
10093 edefs
= (Elf_External_Verdef
*)
10094 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10095 _("version definition section"));
10098 endbuf
= (char *) edefs
+ section
->sh_size
;
10100 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10101 end
= (section
->sh_info
< section
->sh_size
10102 ? section
->sh_info
: section
->sh_size
);
10103 for (idx
= cnt
= 0; cnt
< end
; ++cnt
)
10106 Elf_External_Verdef
* edef
;
10107 Elf_Internal_Verdef ent
;
10108 Elf_External_Verdaux
* eaux
;
10109 Elf_Internal_Verdaux aux
;
10113 /* Check for very large indices. */
10114 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10117 vstart
= ((char *) edefs
) + idx
;
10118 if (vstart
+ sizeof (*edef
) > endbuf
)
10121 edef
= (Elf_External_Verdef
*) vstart
;
10123 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10124 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10125 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10126 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10127 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10128 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10129 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10131 printf (_(" %#06x: Rev: %d Flags: %s"),
10132 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10134 printf (_(" Index: %d Cnt: %d "),
10135 ent
.vd_ndx
, ent
.vd_cnt
);
10137 /* Check for overflow. */
10138 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
))
10141 vstart
+= ent
.vd_aux
;
10143 eaux
= (Elf_External_Verdaux
*) vstart
;
10145 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10146 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10148 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10149 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10151 printf (_("Name index: %ld\n"), aux
.vda_name
);
10153 isum
= idx
+ ent
.vd_aux
;
10155 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10157 /* Check for overflow. */
10158 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10161 isum
+= aux
.vda_next
;
10162 vstart
+= aux
.vda_next
;
10164 eaux
= (Elf_External_Verdaux
*) vstart
;
10165 if (vstart
+ sizeof (*eaux
) > endbuf
)
10168 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10169 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10171 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10172 printf (_(" %#06x: Parent %d: %s\n"),
10173 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10175 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10176 isum
, j
, aux
.vda_name
);
10179 if (j
< ent
.vd_cnt
)
10180 printf (_(" Version def aux past end of section\n"));
10183 file: id:000001,src:000172+005151,op:splice,rep:2. */
10184 if (idx
+ ent
.vd_next
< idx
)
10187 idx
+= ent
.vd_next
;
10190 if (cnt
< section
->sh_info
)
10191 printf (_(" Version definition past end of section\n"));
10197 case SHT_GNU_verneed
:
10199 Elf_External_Verneed
* eneed
;
10206 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10207 printable_section_name (section
), section
->sh_info
);
10209 printf (_(" Addr: 0x"));
10210 printf_vma (section
->sh_addr
);
10211 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10212 (unsigned long) section
->sh_offset
, section
->sh_link
,
10213 printable_section_name_from_index (section
->sh_link
));
10215 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10216 section
->sh_offset
, 1,
10218 _("Version Needs section"));
10221 endbuf
= (char *) eneed
+ section
->sh_size
;
10223 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10225 Elf_External_Verneed
* entry
;
10226 Elf_Internal_Verneed ent
;
10231 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10234 vstart
= ((char *) eneed
) + idx
;
10235 if (vstart
+ sizeof (*entry
) > endbuf
)
10238 entry
= (Elf_External_Verneed
*) vstart
;
10240 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10241 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10242 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10243 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10244 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10246 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10248 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10249 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10251 printf (_(" File: %lx"), ent
.vn_file
);
10253 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10255 /* Check for overflow. */
10256 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10258 vstart
+= ent
.vn_aux
;
10260 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10262 Elf_External_Vernaux
* eaux
;
10263 Elf_Internal_Vernaux aux
;
10265 if (vstart
+ sizeof (*eaux
) > endbuf
)
10267 eaux
= (Elf_External_Vernaux
*) vstart
;
10269 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10270 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10271 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10272 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10273 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10275 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10276 printf (_(" %#06x: Name: %s"),
10277 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10279 printf (_(" %#06x: Name index: %lx"),
10280 isum
, aux
.vna_name
);
10282 printf (_(" Flags: %s Version: %d\n"),
10283 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10285 /* Check for overflow. */
10286 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10287 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10289 warn (_("Invalid vna_next field of %lx\n"),
10294 isum
+= aux
.vna_next
;
10295 vstart
+= aux
.vna_next
;
10298 if (j
< ent
.vn_cnt
)
10299 warn (_("Missing Version Needs auxillary information\n"));
10301 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10303 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10304 cnt
= section
->sh_info
;
10307 idx
+= ent
.vn_next
;
10310 if (cnt
< section
->sh_info
)
10311 warn (_("Missing Version Needs information\n"));
10317 case SHT_GNU_versym
:
10319 Elf_Internal_Shdr
* link_section
;
10322 unsigned char * edata
;
10323 unsigned short * data
;
10325 Elf_Internal_Sym
* symbols
;
10326 Elf_Internal_Shdr
* string_sec
;
10327 unsigned long num_syms
;
10330 if (section
->sh_link
>= elf_header
.e_shnum
)
10333 link_section
= section_headers
+ section
->sh_link
;
10334 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10336 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10341 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10342 if (symbols
== NULL
)
10345 string_sec
= section_headers
+ link_section
->sh_link
;
10347 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10348 string_sec
->sh_size
,
10349 _("version string table"));
10356 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10357 printable_section_name (section
), (unsigned long) total
);
10359 printf (_(" Addr: "));
10360 printf_vma (section
->sh_addr
);
10361 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10362 (unsigned long) section
->sh_offset
, section
->sh_link
,
10363 printable_section_name (link_section
));
10365 off
= offset_from_vma (file
,
10366 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10367 total
* sizeof (short));
10368 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10370 _("version symbol data"));
10378 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10380 for (cnt
= total
; cnt
--;)
10381 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10386 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10390 char *invalid
= _("*invalid*");
10392 printf (" %03x:", cnt
);
10394 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10395 switch (data
[cnt
+ j
])
10398 fputs (_(" 0 (*local*) "), stdout
);
10402 fputs (_(" 1 (*global*) "), stdout
);
10406 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10407 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10409 /* If this index value is greater than the size of the symbols
10410 array, break to avoid an out-of-bounds read. */
10411 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10413 warn (_("invalid index into symbol array\n"));
10418 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10420 Elf_Internal_Verneed ivn
;
10421 unsigned long offset
;
10423 offset
= offset_from_vma
10424 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10425 sizeof (Elf_External_Verneed
));
10429 Elf_Internal_Vernaux ivna
;
10430 Elf_External_Verneed evn
;
10431 Elf_External_Vernaux evna
;
10432 unsigned long a_off
;
10434 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10435 _("version need")) == NULL
)
10438 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10439 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10441 a_off
= offset
+ ivn
.vn_aux
;
10445 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10446 1, _("version need aux (2)")) == NULL
)
10449 ivna
.vna_other
= 0;
10453 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10454 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10457 a_off
+= ivna
.vna_next
;
10459 while (ivna
.vna_other
!= data
[cnt
+ j
]
10460 && ivna
.vna_next
!= 0);
10462 if (ivna
.vna_other
== data
[cnt
+ j
])
10464 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10466 if (ivna
.vna_name
>= string_sec
->sh_size
)
10469 name
= strtab
+ ivna
.vna_name
;
10473 offset
+= ivn
.vn_next
;
10475 while (ivn
.vn_next
);
10478 if (data
[cnt
+ j
] != 0x8001
10479 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10481 Elf_Internal_Verdef ivd
;
10482 Elf_External_Verdef evd
;
10483 unsigned long offset
;
10485 offset
= offset_from_vma
10486 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10491 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10492 _("version def")) == NULL
)
10495 /* PR 17531: file: 046-1082287-0.004. */
10496 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10501 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10502 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10505 offset
+= ivd
.vd_next
;
10507 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10508 && ivd
.vd_next
!= 0);
10510 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10512 Elf_External_Verdaux evda
;
10513 Elf_Internal_Verdaux ivda
;
10515 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10517 if (get_data (&evda
, file
,
10518 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10520 _("version def aux")) == NULL
)
10523 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10525 if (ivda
.vda_name
>= string_sec
->sh_size
)
10527 else if (name
!= NULL
&& name
!= invalid
)
10528 name
= _("*both*");
10530 name
= strtab
+ ivda
.vda_name
;
10534 nn
+= printf ("(%s%-*s",
10536 12 - (int) strlen (name
),
10540 printf ("%*c", 18 - nn
, ' ');
10558 printf (_("\nNo version information found in this file.\n"));
10563 static const char *
10564 get_symbol_binding (unsigned int binding
)
10566 static char buff
[32];
10570 case STB_LOCAL
: return "LOCAL";
10571 case STB_GLOBAL
: return "GLOBAL";
10572 case STB_WEAK
: return "WEAK";
10574 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10575 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10577 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10579 if (binding
== STB_GNU_UNIQUE
10580 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10581 /* GNU is still using the default value 0. */
10582 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10584 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10587 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10592 static const char *
10593 get_symbol_type (unsigned int type
)
10595 static char buff
[32];
10599 case STT_NOTYPE
: return "NOTYPE";
10600 case STT_OBJECT
: return "OBJECT";
10601 case STT_FUNC
: return "FUNC";
10602 case STT_SECTION
: return "SECTION";
10603 case STT_FILE
: return "FILE";
10604 case STT_COMMON
: return "COMMON";
10605 case STT_TLS
: return "TLS";
10606 case STT_RELC
: return "RELC";
10607 case STT_SRELC
: return "SRELC";
10609 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10611 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10612 return "THUMB_FUNC";
10614 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10617 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10618 return "PARISC_MILLI";
10620 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10622 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10624 if (elf_header
.e_machine
== EM_PARISC
)
10626 if (type
== STT_HP_OPAQUE
)
10627 return "HP_OPAQUE";
10628 if (type
== STT_HP_STUB
)
10632 if (type
== STT_GNU_IFUNC
10633 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10634 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10635 /* GNU is still using the default value 0. */
10636 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10639 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10642 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10647 static const char *
10648 get_symbol_visibility (unsigned int visibility
)
10650 switch (visibility
)
10652 case STV_DEFAULT
: return "DEFAULT";
10653 case STV_INTERNAL
: return "INTERNAL";
10654 case STV_HIDDEN
: return "HIDDEN";
10655 case STV_PROTECTED
: return "PROTECTED";
10657 error (_("Unrecognized visibility value: %u"), visibility
);
10658 return _("<unknown>");
10662 static const char *
10663 get_solaris_symbol_visibility (unsigned int visibility
)
10665 switch (visibility
)
10667 case 4: return "EXPORTED";
10668 case 5: return "SINGLETON";
10669 case 6: return "ELIMINATE";
10670 default: return get_symbol_visibility (visibility
);
10674 static const char *
10675 get_mips_symbol_other (unsigned int other
)
10679 case STO_OPTIONAL
: return "OPTIONAL";
10680 case STO_MIPS_PLT
: return "MIPS PLT";
10681 case STO_MIPS_PIC
: return "MIPS PIC";
10682 case STO_MICROMIPS
: return "MICROMIPS";
10683 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10684 case STO_MIPS16
: return "MIPS16";
10685 default: return NULL
;
10689 static const char *
10690 get_ia64_symbol_other (unsigned int other
)
10692 if (is_ia64_vms ())
10694 static char res
[32];
10698 /* Function types is for images and .STB files only. */
10699 switch (elf_header
.e_type
)
10703 switch (VMS_ST_FUNC_TYPE (other
))
10705 case VMS_SFT_CODE_ADDR
:
10706 strcat (res
, " CA");
10708 case VMS_SFT_SYMV_IDX
:
10709 strcat (res
, " VEC");
10712 strcat (res
, " FD");
10714 case VMS_SFT_RESERVE
:
10715 strcat (res
, " RSV");
10718 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10719 VMS_ST_FUNC_TYPE (other
));
10720 strcat (res
, " <unknown>");
10727 switch (VMS_ST_LINKAGE (other
))
10729 case VMS_STL_IGNORE
:
10730 strcat (res
, " IGN");
10732 case VMS_STL_RESERVE
:
10733 strcat (res
, " RSV");
10736 strcat (res
, " STD");
10739 strcat (res
, " LNK");
10742 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10743 VMS_ST_LINKAGE (other
));
10744 strcat (res
, " <unknown>");
10756 static const char *
10757 get_ppc64_symbol_other (unsigned int other
)
10759 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10761 static char buf
[32];
10762 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10763 PPC64_LOCAL_ENTRY_OFFSET (other
));
10769 static const char *
10770 get_symbol_other (unsigned int other
)
10772 const char * result
= NULL
;
10773 static char buff
[32];
10778 switch (elf_header
.e_machine
)
10781 result
= get_mips_symbol_other (other
);
10784 result
= get_ia64_symbol_other (other
);
10787 result
= get_ppc64_symbol_other (other
);
10797 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10801 static const char *
10802 get_symbol_index_type (unsigned int type
)
10804 static char buff
[32];
10808 case SHN_UNDEF
: return "UND";
10809 case SHN_ABS
: return "ABS";
10810 case SHN_COMMON
: return "COM";
10812 if (type
== SHN_IA_64_ANSI_COMMON
10813 && elf_header
.e_machine
== EM_IA_64
10814 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10816 else if ((elf_header
.e_machine
== EM_X86_64
10817 || elf_header
.e_machine
== EM_L1OM
10818 || elf_header
.e_machine
== EM_K1OM
)
10819 && type
== SHN_X86_64_LCOMMON
)
10820 return "LARGE_COM";
10821 else if ((type
== SHN_MIPS_SCOMMON
10822 && elf_header
.e_machine
== EM_MIPS
)
10823 || (type
== SHN_TIC6X_SCOMMON
10824 && elf_header
.e_machine
== EM_TI_C6000
))
10826 else if (type
== SHN_MIPS_SUNDEFINED
10827 && elf_header
.e_machine
== EM_MIPS
)
10829 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10830 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10831 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10832 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10833 else if (type
>= SHN_LORESERVE
)
10834 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10835 else if (type
>= elf_header
.e_shnum
)
10836 sprintf (buff
, _("bad section index[%3d]"), type
);
10838 sprintf (buff
, "%3d", type
);
10846 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10848 unsigned char * e_data
;
10851 /* If the size_t type is smaller than the bfd_size_type, eg because
10852 you are building a 32-bit tool on a 64-bit host, then make sure
10853 that when (number) is cast to (size_t) no information is lost. */
10854 if (sizeof (size_t) < sizeof (bfd_size_type
)
10855 && (bfd_size_type
) ((size_t) number
) != number
)
10857 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10858 " elements of size %u\n"),
10863 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10864 attempting to allocate memory when the read is bound to fail. */
10865 if (ent_size
* number
> current_file_size
)
10867 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10872 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10873 if (e_data
== NULL
)
10875 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10880 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10882 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10883 number
* ent_size
);
10888 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10889 if (i_data
== NULL
)
10891 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10892 " dynamic entries\n"),
10899 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10907 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10909 Elf_Internal_Sym
* psym
;
10912 n
= print_vma (si
, DEC_5
);
10914 fputs (&" "[n
], stdout
);
10915 printf (" %3lu: ", hn
);
10917 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10919 printf (_("<No info available for dynamic symbol number %lu>\n"),
10920 (unsigned long) si
);
10924 psym
= dynamic_symbols
+ si
;
10925 print_vma (psym
->st_value
, LONG_HEX
);
10927 print_vma (psym
->st_size
, DEC_5
);
10929 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10930 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10932 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10933 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10936 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10938 printf (" %-7s", get_symbol_visibility (vis
));
10939 /* Check to see if any other bits in the st_other field are set.
10940 Note - displaying this information disrupts the layout of the
10941 table being generated, but for the moment this case is very
10943 if (psym
->st_other
^ vis
)
10944 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10947 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10948 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10949 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10951 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10955 static const char *
10956 get_symbol_version_string (FILE * file
,
10957 bfd_boolean is_dynsym
,
10958 const char * strtab
,
10959 unsigned long int strtab_size
,
10961 Elf_Internal_Sym
* psym
,
10962 enum versioned_symbol_info
* sym_info
,
10963 unsigned short * vna_other
)
10965 unsigned char data
[2];
10966 unsigned short vers_data
;
10967 unsigned long offset
;
10970 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10973 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10974 sizeof data
+ si
* sizeof (vers_data
));
10976 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10977 sizeof (data
), 1, _("version data")) == NULL
)
10980 vers_data
= byte_get (data
, 2);
10982 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10985 /* Usually we'd only see verdef for defined symbols, and verneed for
10986 undefined symbols. However, symbols defined by the linker in
10987 .dynbss for variables copied from a shared library in order to
10988 avoid text relocations are defined yet have verneed. We could
10989 use a heuristic to detect the special case, for example, check
10990 for verneed first on symbols defined in SHT_NOBITS sections, but
10991 it is simpler and more reliable to just look for both verdef and
10992 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10994 if (psym
->st_shndx
!= SHN_UNDEF
10995 && vers_data
!= 0x8001
10996 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10998 Elf_Internal_Verdef ivd
;
10999 Elf_Internal_Verdaux ivda
;
11000 Elf_External_Verdaux evda
;
11003 off
= offset_from_vma (file
,
11004 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11005 sizeof (Elf_External_Verdef
));
11009 Elf_External_Verdef evd
;
11011 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11012 _("version def")) == NULL
)
11020 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11021 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11022 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11025 off
+= ivd
.vd_next
;
11027 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11029 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11031 off
-= ivd
.vd_next
;
11034 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11035 _("version def aux")) != NULL
)
11037 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11039 if (psym
->st_name
!= ivda
.vda_name
)
11041 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11042 ? symbol_hidden
: symbol_public
);
11043 return (ivda
.vda_name
< strtab_size
11044 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11050 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11052 Elf_External_Verneed evn
;
11053 Elf_Internal_Verneed ivn
;
11054 Elf_Internal_Vernaux ivna
;
11056 offset
= offset_from_vma (file
,
11057 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11061 unsigned long vna_off
;
11063 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11064 _("version need")) == NULL
)
11067 ivna
.vna_other
= 0;
11072 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11073 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11075 vna_off
= offset
+ ivn
.vn_aux
;
11079 Elf_External_Vernaux evna
;
11081 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11082 _("version need aux (3)")) == NULL
)
11085 ivna
.vna_other
= 0;
11090 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11091 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11092 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11095 vna_off
+= ivna
.vna_next
;
11097 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11099 if (ivna
.vna_other
== vers_data
)
11102 offset
+= ivn
.vn_next
;
11104 while (ivn
.vn_next
!= 0);
11106 if (ivna
.vna_other
== vers_data
)
11108 *sym_info
= symbol_undefined
;
11109 *vna_other
= ivna
.vna_other
;
11110 return (ivna
.vna_name
< strtab_size
11111 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11117 /* Dump the symbol table. */
11119 process_symbol_table (FILE * file
)
11121 Elf_Internal_Shdr
* section
;
11122 bfd_size_type nbuckets
= 0;
11123 bfd_size_type nchains
= 0;
11124 bfd_vma
* buckets
= NULL
;
11125 bfd_vma
* chains
= NULL
;
11126 bfd_vma ngnubuckets
= 0;
11127 bfd_vma
* gnubuckets
= NULL
;
11128 bfd_vma
* gnuchains
= NULL
;
11129 bfd_vma gnusymidx
= 0;
11130 bfd_size_type ngnuchains
= 0;
11132 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11135 if (dynamic_info
[DT_HASH
]
11137 || (do_using_dynamic
11139 && dynamic_strings
!= NULL
)))
11141 unsigned char nb
[8];
11142 unsigned char nc
[8];
11143 unsigned int hash_ent_size
= 4;
11145 if ((elf_header
.e_machine
== EM_ALPHA
11146 || elf_header
.e_machine
== EM_S390
11147 || elf_header
.e_machine
== EM_S390_OLD
)
11148 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11152 (archive_file_offset
11153 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11154 sizeof nb
+ sizeof nc
)),
11157 error (_("Unable to seek to start of dynamic information\n"));
11161 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11163 error (_("Failed to read in number of buckets\n"));
11167 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11169 error (_("Failed to read in number of chains\n"));
11173 nbuckets
= byte_get (nb
, hash_ent_size
);
11174 nchains
= byte_get (nc
, hash_ent_size
);
11176 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11177 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11180 if (buckets
== NULL
|| chains
== NULL
)
11182 if (do_using_dynamic
)
11193 if (dynamic_info_DT_GNU_HASH
11195 || (do_using_dynamic
11197 && dynamic_strings
!= NULL
)))
11199 unsigned char nb
[16];
11200 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11201 bfd_vma buckets_vma
;
11204 (archive_file_offset
11205 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11209 error (_("Unable to seek to start of dynamic information\n"));
11213 if (fread (nb
, 16, 1, file
) != 1)
11215 error (_("Failed to read in number of buckets\n"));
11219 ngnubuckets
= byte_get (nb
, 4);
11220 gnusymidx
= byte_get (nb
+ 4, 4);
11221 bitmaskwords
= byte_get (nb
+ 8, 4);
11222 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11224 buckets_vma
+= bitmaskwords
* 4;
11226 buckets_vma
+= bitmaskwords
* 8;
11229 (archive_file_offset
11230 + offset_from_vma (file
, buckets_vma
, 4)),
11233 error (_("Unable to seek to start of dynamic information\n"));
11237 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11239 if (gnubuckets
== NULL
)
11242 for (i
= 0; i
< ngnubuckets
; i
++)
11243 if (gnubuckets
[i
] != 0)
11245 if (gnubuckets
[i
] < gnusymidx
)
11248 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11249 maxchain
= gnubuckets
[i
];
11252 if (maxchain
== 0xffffffff)
11255 maxchain
-= gnusymidx
;
11258 (archive_file_offset
11259 + offset_from_vma (file
, buckets_vma
11260 + 4 * (ngnubuckets
+ maxchain
), 4)),
11263 error (_("Unable to seek to start of dynamic information\n"));
11269 if (fread (nb
, 4, 1, file
) != 1)
11271 error (_("Failed to determine last chain length\n"));
11275 if (maxchain
+ 1 == 0)
11280 while ((byte_get (nb
, 4) & 1) == 0);
11283 (archive_file_offset
11284 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11287 error (_("Unable to seek to start of dynamic information\n"));
11291 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11292 ngnuchains
= maxchain
;
11295 if (gnuchains
== NULL
)
11300 if (do_using_dynamic
)
11305 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11307 && do_using_dynamic
11308 && dynamic_strings
!= NULL
11309 && dynamic_symbols
!= NULL
)
11313 if (dynamic_info
[DT_HASH
])
11317 printf (_("\nSymbol table for image:\n"));
11319 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11321 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11323 for (hn
= 0; hn
< nbuckets
; hn
++)
11328 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11329 print_dynamic_symbol (si
, hn
);
11333 if (dynamic_info_DT_GNU_HASH
)
11335 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11337 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11339 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11341 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11342 if (gnubuckets
[hn
] != 0)
11344 bfd_vma si
= gnubuckets
[hn
];
11345 bfd_vma off
= si
- gnusymidx
;
11349 print_dynamic_symbol (si
, hn
);
11352 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11356 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11357 && section_headers
!= NULL
)
11361 for (i
= 0, section
= section_headers
;
11362 i
< elf_header
.e_shnum
;
11366 char * strtab
= NULL
;
11367 unsigned long int strtab_size
= 0;
11368 Elf_Internal_Sym
* symtab
;
11369 Elf_Internal_Sym
* psym
;
11370 unsigned long num_syms
;
11372 if ((section
->sh_type
!= SHT_SYMTAB
11373 && section
->sh_type
!= SHT_DYNSYM
)
11375 && section
->sh_type
== SHT_SYMTAB
))
11378 if (section
->sh_entsize
== 0)
11380 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11381 printable_section_name (section
));
11385 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11386 printable_section_name (section
),
11387 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11390 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11392 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11394 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11395 if (symtab
== NULL
)
11398 if (section
->sh_link
== elf_header
.e_shstrndx
)
11400 strtab
= string_table
;
11401 strtab_size
= string_table_length
;
11403 else if (section
->sh_link
< elf_header
.e_shnum
)
11405 Elf_Internal_Shdr
* string_sec
;
11407 string_sec
= section_headers
+ section
->sh_link
;
11409 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11410 1, string_sec
->sh_size
,
11411 _("string table"));
11412 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11415 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11417 const char *version_string
;
11418 enum versioned_symbol_info sym_info
;
11419 unsigned short vna_other
;
11421 printf ("%6d: ", si
);
11422 print_vma (psym
->st_value
, LONG_HEX
);
11424 print_vma (psym
->st_size
, DEC_5
);
11425 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11426 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11427 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11428 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11431 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11433 printf (" %-7s", get_symbol_visibility (vis
));
11434 /* Check to see if any other bits in the st_other field are set.
11435 Note - displaying this information disrupts the layout of the
11436 table being generated, but for the moment this case is very rare. */
11437 if (psym
->st_other
^ vis
)
11438 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11440 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11441 print_symbol (25, psym
->st_name
< strtab_size
11442 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11445 = get_symbol_version_string (file
,
11446 section
->sh_type
== SHT_DYNSYM
,
11447 strtab
, strtab_size
, si
,
11448 psym
, &sym_info
, &vna_other
);
11449 if (version_string
)
11451 if (sym_info
== symbol_undefined
)
11452 printf ("@%s (%d)", version_string
, vna_other
);
11454 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11460 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11461 && si
>= section
->sh_info
11462 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11463 && elf_header
.e_machine
!= EM_MIPS
11464 /* Solaris binaries have been found to violate this requirement as
11465 well. Not sure if this is a bug or an ABI requirement. */
11466 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11467 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11468 si
, printable_section_name (section
), section
->sh_info
);
11472 if (strtab
!= string_table
)
11478 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11480 if (do_histogram
&& buckets
!= NULL
)
11482 unsigned long * lengths
;
11483 unsigned long * counts
;
11486 unsigned long maxlength
= 0;
11487 unsigned long nzero_counts
= 0;
11488 unsigned long nsyms
= 0;
11489 unsigned long chained
;
11491 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11492 (unsigned long) nbuckets
);
11494 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11495 if (lengths
== NULL
)
11497 error (_("Out of memory allocating space for histogram buckets\n"));
11501 printf (_(" Length Number %% of total Coverage\n"));
11502 for (hn
= 0; hn
< nbuckets
; ++hn
)
11504 for (si
= buckets
[hn
], chained
= 0;
11505 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11506 si
= chains
[si
], ++chained
)
11509 if (maxlength
< ++lengths
[hn
])
11513 /* PR binutils/17531: A corrupt binary could contain broken
11514 histogram data. Do not go into an infinite loop trying
11516 if (chained
> nchains
)
11518 error (_("histogram chain is corrupt\n"));
11523 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11524 if (counts
== NULL
)
11527 error (_("Out of memory allocating space for histogram counts\n"));
11531 for (hn
= 0; hn
< nbuckets
; ++hn
)
11532 ++counts
[lengths
[hn
]];
11537 printf (" 0 %-10lu (%5.1f%%)\n",
11538 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11539 for (i
= 1; i
<= maxlength
; ++i
)
11541 nzero_counts
+= counts
[i
] * i
;
11542 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11543 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11544 (nzero_counts
* 100.0) / nsyms
);
11552 if (buckets
!= NULL
)
11558 if (do_histogram
&& gnubuckets
!= NULL
)
11560 unsigned long * lengths
;
11561 unsigned long * counts
;
11563 unsigned long maxlength
= 0;
11564 unsigned long nzero_counts
= 0;
11565 unsigned long nsyms
= 0;
11567 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11568 (unsigned long) ngnubuckets
);
11570 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11571 if (lengths
== NULL
)
11573 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11577 printf (_(" Length Number %% of total Coverage\n"));
11579 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11580 if (gnubuckets
[hn
] != 0)
11582 bfd_vma off
, length
= 1;
11584 for (off
= gnubuckets
[hn
] - gnusymidx
;
11585 /* PR 17531 file: 010-77222-0.004. */
11586 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11589 lengths
[hn
] = length
;
11590 if (length
> maxlength
)
11591 maxlength
= length
;
11595 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11596 if (counts
== NULL
)
11599 error (_("Out of memory allocating space for gnu histogram counts\n"));
11603 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11604 ++counts
[lengths
[hn
]];
11606 if (ngnubuckets
> 0)
11609 printf (" 0 %-10lu (%5.1f%%)\n",
11610 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11611 for (j
= 1; j
<= maxlength
; ++j
)
11613 nzero_counts
+= counts
[j
] * j
;
11614 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11615 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11616 (nzero_counts
* 100.0) / nsyms
);
11630 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11634 if (dynamic_syminfo
== NULL
11636 /* No syminfo, this is ok. */
11639 /* There better should be a dynamic symbol section. */
11640 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11644 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11645 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11647 printf (_(" Num: Name BoundTo Flags\n"));
11648 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11650 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11652 printf ("%4d: ", i
);
11653 if (i
>= num_dynamic_syms
)
11654 printf (_("<corrupt index>"));
11655 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11656 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11658 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11661 switch (dynamic_syminfo
[i
].si_boundto
)
11663 case SYMINFO_BT_SELF
:
11664 fputs ("SELF ", stdout
);
11666 case SYMINFO_BT_PARENT
:
11667 fputs ("PARENT ", stdout
);
11670 if (dynamic_syminfo
[i
].si_boundto
> 0
11671 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11672 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11674 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11678 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11682 if (flags
& SYMINFO_FLG_DIRECT
)
11683 printf (" DIRECT");
11684 if (flags
& SYMINFO_FLG_PASSTHRU
)
11685 printf (" PASSTHRU");
11686 if (flags
& SYMINFO_FLG_COPY
)
11688 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11689 printf (" LAZYLOAD");
11697 #define IN_RANGE(START,END,ADDR,OFF) \
11698 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11700 /* Check to see if the given reloc needs to be handled in a target specific
11701 manner. If so then process the reloc and return TRUE otherwise return
11704 If called with reloc == NULL, then this is a signal that reloc processing
11705 for the current section has finished, and any saved state should be
11709 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11710 unsigned char * start
,
11711 unsigned char * end
,
11712 Elf_Internal_Sym
* symtab
,
11713 unsigned long num_syms
)
11715 unsigned int reloc_type
= 0;
11716 unsigned long sym_index
= 0;
11720 reloc_type
= get_reloc_type (reloc
->r_info
);
11721 sym_index
= get_reloc_symindex (reloc
->r_info
);
11724 switch (elf_header
.e_machine
)
11727 case EM_MSP430_OLD
:
11729 static Elf_Internal_Sym
* saved_sym
= NULL
;
11737 switch (reloc_type
)
11739 case 10: /* R_MSP430_SYM_DIFF */
11740 if (uses_msp430x_relocs ())
11742 /* Fall through. */
11743 case 21: /* R_MSP430X_SYM_DIFF */
11745 if (sym_index
>= num_syms
)
11746 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11749 saved_sym
= symtab
+ sym_index
;
11752 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11753 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11754 goto handle_sym_diff
;
11756 case 5: /* R_MSP430_16_BYTE */
11757 case 9: /* R_MSP430_8 */
11758 if (uses_msp430x_relocs ())
11760 goto handle_sym_diff
;
11762 case 2: /* R_MSP430_ABS16 */
11763 case 15: /* R_MSP430X_ABS16 */
11764 if (! uses_msp430x_relocs ())
11766 goto handle_sym_diff
;
11769 if (saved_sym
!= NULL
)
11771 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11774 if (sym_index
>= num_syms
)
11775 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11779 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11780 - saved_sym
->st_value
);
11782 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11783 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11786 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11787 (long) reloc
->r_offset
);
11796 if (saved_sym
!= NULL
)
11797 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11804 case EM_CYGNUS_MN10300
:
11806 static Elf_Internal_Sym
* saved_sym
= NULL
;
11814 switch (reloc_type
)
11816 case 34: /* R_MN10300_ALIGN */
11818 case 33: /* R_MN10300_SYM_DIFF */
11819 if (sym_index
>= num_syms
)
11820 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11823 saved_sym
= symtab
+ sym_index
;
11826 case 1: /* R_MN10300_32 */
11827 case 2: /* R_MN10300_16 */
11828 if (saved_sym
!= NULL
)
11830 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11833 if (sym_index
>= num_syms
)
11834 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11838 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11839 - saved_sym
->st_value
);
11841 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11842 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11844 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11845 (long) reloc
->r_offset
);
11853 if (saved_sym
!= NULL
)
11854 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11862 static bfd_vma saved_sym1
= 0;
11863 static bfd_vma saved_sym2
= 0;
11864 static bfd_vma value
;
11868 saved_sym1
= saved_sym2
= 0;
11872 switch (reloc_type
)
11874 case 0x80: /* R_RL78_SYM. */
11875 saved_sym1
= saved_sym2
;
11876 if (sym_index
>= num_syms
)
11877 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11881 saved_sym2
= symtab
[sym_index
].st_value
;
11882 saved_sym2
+= reloc
->r_addend
;
11886 case 0x83: /* R_RL78_OPsub. */
11887 value
= saved_sym1
- saved_sym2
;
11888 saved_sym2
= saved_sym1
= 0;
11892 case 0x41: /* R_RL78_ABS32. */
11893 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11894 byte_put (start
+ reloc
->r_offset
, value
, 4);
11896 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11897 (long) reloc
->r_offset
);
11901 case 0x43: /* R_RL78_ABS16. */
11902 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11903 byte_put (start
+ reloc
->r_offset
, value
, 2);
11905 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11906 (long) reloc
->r_offset
);
11920 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11921 DWARF debug sections. This is a target specific test. Note - we do not
11922 go through the whole including-target-headers-multiple-times route, (as
11923 we have already done with <elf/h8.h>) because this would become very
11924 messy and even then this function would have to contain target specific
11925 information (the names of the relocs instead of their numeric values).
11926 FIXME: This is not the correct way to solve this problem. The proper way
11927 is to have target specific reloc sizing and typing functions created by
11928 the reloc-macros.h header, in the same way that it already creates the
11929 reloc naming functions. */
11932 is_32bit_abs_reloc (unsigned int reloc_type
)
11934 /* Please keep this table alpha-sorted for ease of visual lookup. */
11935 switch (elf_header
.e_machine
)
11939 return reloc_type
== 1; /* R_386_32. */
11941 return reloc_type
== 1; /* R_68K_32. */
11943 return reloc_type
== 1; /* R_860_32. */
11945 return reloc_type
== 2; /* R_960_32. */
11947 return (reloc_type
== 258
11948 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11949 case EM_ADAPTEVA_EPIPHANY
:
11950 return reloc_type
== 3;
11952 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11954 return reloc_type
== 1; /* R_ARC_32. */
11955 case EM_ARC_COMPACT
:
11956 case EM_ARC_COMPACT2
:
11957 return reloc_type
== 4; /* R_ARC_32. */
11959 return reloc_type
== 2; /* R_ARM_ABS32 */
11962 return reloc_type
== 1;
11964 return reloc_type
== 0x12; /* R_byte4_data. */
11966 return reloc_type
== 3; /* R_CRIS_32. */
11968 return reloc_type
== 3; /* R_CR16_NUM32. */
11970 return reloc_type
== 15; /* R_CRX_NUM32. */
11971 case EM_CYGNUS_FRV
:
11972 return reloc_type
== 1;
11973 case EM_CYGNUS_D10V
:
11975 return reloc_type
== 6; /* R_D10V_32. */
11976 case EM_CYGNUS_D30V
:
11978 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11980 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11981 case EM_CYGNUS_FR30
:
11983 return reloc_type
== 3; /* R_FR30_32. */
11985 return reloc_type
== 1; /* R_FT32_32. */
11989 return reloc_type
== 1; /* R_H8_DIR32. */
11991 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11992 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11995 return reloc_type
== 2; /* R_IP2K_32. */
11997 return reloc_type
== 2; /* R_IQ2000_32. */
11998 case EM_LATTICEMICO32
:
11999 return reloc_type
== 3; /* R_LM32_32. */
12002 return reloc_type
== 3; /* R_M32C_32. */
12004 return reloc_type
== 34; /* R_M32R_32_RELA. */
12007 return reloc_type
== 6; /* R_M68HC11_32. */
12009 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12010 case EM_CYGNUS_MEP
:
12011 return reloc_type
== 4; /* R_MEP_32. */
12013 return reloc_type
== 2; /* R_METAG_ADDR32. */
12014 case EM_MICROBLAZE
:
12015 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12017 return reloc_type
== 2; /* R_MIPS_32. */
12019 return reloc_type
== 4; /* R_MMIX_32. */
12020 case EM_CYGNUS_MN10200
:
12022 return reloc_type
== 1; /* R_MN10200_32. */
12023 case EM_CYGNUS_MN10300
:
12025 return reloc_type
== 1; /* R_MN10300_32. */
12027 return reloc_type
== 1; /* R_MOXIE_32. */
12028 case EM_MSP430_OLD
:
12030 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12032 return reloc_type
== 2; /* R_MT_32. */
12034 return reloc_type
== 20; /* R_NDS32_RELA. */
12035 case EM_ALTERA_NIOS2
:
12036 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12038 return reloc_type
== 1; /* R_NIOS_32. */
12040 return reloc_type
== 1; /* R_OR1K_32. */
12042 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12043 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12046 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12048 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12050 return reloc_type
== 1; /* R_PPC_ADDR32. */
12052 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12054 return reloc_type
== 1; /* R_RISCV_32. */
12056 return reloc_type
== 1; /* R_RL78_DIR32. */
12058 return reloc_type
== 1; /* R_RX_DIR32. */
12060 return reloc_type
== 1; /* R_I370_ADDR31. */
12063 return reloc_type
== 4; /* R_S390_32. */
12065 return reloc_type
== 8; /* R_SCORE_ABS32. */
12067 return reloc_type
== 1; /* R_SH_DIR32. */
12068 case EM_SPARC32PLUS
:
12071 return reloc_type
== 3 /* R_SPARC_32. */
12072 || reloc_type
== 23; /* R_SPARC_UA32. */
12074 return reloc_type
== 6; /* R_SPU_ADDR32 */
12076 return reloc_type
== 1; /* R_C6000_ABS32. */
12078 return reloc_type
== 2; /* R_TILEGX_32. */
12080 return reloc_type
== 1; /* R_TILEPRO_32. */
12081 case EM_CYGNUS_V850
:
12083 return reloc_type
== 6; /* R_V850_ABS32. */
12085 return reloc_type
== 0x33; /* R_V810_WORD. */
12087 return reloc_type
== 1; /* R_VAX_32. */
12089 return reloc_type
== 3; /* R_VISIUM_32. */
12093 return reloc_type
== 10; /* R_X86_64_32. */
12096 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12098 return reloc_type
== 4; /* R_XGATE_32. */
12100 return reloc_type
== 1; /* R_XSTROMY16_32. */
12101 case EM_XTENSA_OLD
:
12103 return reloc_type
== 1; /* R_XTENSA_32. */
12106 static unsigned int prev_warn
= 0;
12108 /* Avoid repeating the same warning multiple times. */
12109 if (prev_warn
!= elf_header
.e_machine
)
12110 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12111 elf_header
.e_machine
);
12112 prev_warn
= elf_header
.e_machine
;
12118 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12119 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12122 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12124 switch (elf_header
.e_machine
)
12125 /* Please keep this table alpha-sorted for ease of visual lookup. */
12129 return reloc_type
== 2; /* R_386_PC32. */
12131 return reloc_type
== 4; /* R_68K_PC32. */
12133 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12134 case EM_ADAPTEVA_EPIPHANY
:
12135 return reloc_type
== 6;
12137 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12138 case EM_ARC_COMPACT
:
12139 case EM_ARC_COMPACT2
:
12140 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12142 return reloc_type
== 3; /* R_ARM_REL32 */
12145 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12146 case EM_MICROBLAZE
:
12147 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12149 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12151 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12153 return reloc_type
== 26; /* R_PPC_REL32. */
12155 return reloc_type
== 26; /* R_PPC64_REL32. */
12158 return reloc_type
== 5; /* R_390_PC32. */
12160 return reloc_type
== 2; /* R_SH_REL32. */
12161 case EM_SPARC32PLUS
:
12164 return reloc_type
== 6; /* R_SPARC_DISP32. */
12166 return reloc_type
== 13; /* R_SPU_REL32. */
12168 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12170 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12172 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12176 return reloc_type
== 2; /* R_X86_64_PC32. */
12177 case EM_XTENSA_OLD
:
12179 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12181 /* Do not abort or issue an error message here. Not all targets use
12182 pc-relative 32-bit relocs in their DWARF debug information and we
12183 have already tested for target coverage in is_32bit_abs_reloc. A
12184 more helpful warning message will be generated by apply_relocations
12185 anyway, so just return. */
12190 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12191 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12194 is_64bit_abs_reloc (unsigned int reloc_type
)
12196 switch (elf_header
.e_machine
)
12199 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12201 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12203 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12205 return reloc_type
== 80; /* R_PARISC_DIR64. */
12207 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12209 return reloc_type
== 2; /* R_RISCV_64. */
12210 case EM_SPARC32PLUS
:
12213 return reloc_type
== 54; /* R_SPARC_UA64. */
12217 return reloc_type
== 1; /* R_X86_64_64. */
12220 return reloc_type
== 22; /* R_S390_64. */
12222 return reloc_type
== 1; /* R_TILEGX_64. */
12224 return reloc_type
== 18; /* R_MIPS_64. */
12230 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12231 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12234 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12236 switch (elf_header
.e_machine
)
12239 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12241 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12243 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12245 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12247 return reloc_type
== 44; /* R_PPC64_REL64. */
12248 case EM_SPARC32PLUS
:
12251 return reloc_type
== 46; /* R_SPARC_DISP64. */
12255 return reloc_type
== 24; /* R_X86_64_PC64. */
12258 return reloc_type
== 23; /* R_S390_PC64. */
12260 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12266 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12267 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12270 is_24bit_abs_reloc (unsigned int reloc_type
)
12272 switch (elf_header
.e_machine
)
12274 case EM_CYGNUS_MN10200
:
12276 return reloc_type
== 4; /* R_MN10200_24. */
12278 return reloc_type
== 5; /* R_FT32_20. */
12284 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12285 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12288 is_16bit_abs_reloc (unsigned int reloc_type
)
12290 /* Please keep this table alpha-sorted for ease of visual lookup. */
12291 switch (elf_header
.e_machine
)
12294 case EM_ARC_COMPACT
:
12295 case EM_ARC_COMPACT2
:
12296 return reloc_type
== 2; /* R_ARC_16. */
12297 case EM_ADAPTEVA_EPIPHANY
:
12298 return reloc_type
== 5;
12301 return reloc_type
== 4; /* R_AVR_16. */
12302 case EM_CYGNUS_D10V
:
12304 return reloc_type
== 3; /* R_D10V_16. */
12308 return reloc_type
== R_H8_DIR16
;
12311 return reloc_type
== 1; /* R_IP2K_16. */
12314 return reloc_type
== 1; /* R_M32C_16 */
12315 case EM_CYGNUS_MN10200
:
12317 return reloc_type
== 2; /* R_MN10200_16. */
12318 case EM_CYGNUS_MN10300
:
12320 return reloc_type
== 2; /* R_MN10300_16. */
12322 if (uses_msp430x_relocs ())
12323 return reloc_type
== 2; /* R_MSP430_ABS16. */
12324 /* Fall through. */
12325 case EM_MSP430_OLD
:
12326 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12328 return reloc_type
== 19; /* R_NDS32_RELA. */
12329 case EM_ALTERA_NIOS2
:
12330 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12332 return reloc_type
== 9; /* R_NIOS_16. */
12334 return reloc_type
== 2; /* R_OR1K_16. */
12336 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12338 return reloc_type
== 2; /* R_C6000_ABS16. */
12340 return reloc_type
== 2; /* R_VISIUM_16. */
12343 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12345 return reloc_type
== 3; /* R_XGATE_16. */
12351 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12352 relocation entries (possibly formerly used for SHT_GROUP sections). */
12355 is_none_reloc (unsigned int reloc_type
)
12357 switch (elf_header
.e_machine
)
12359 case EM_386
: /* R_386_NONE. */
12360 case EM_68K
: /* R_68K_NONE. */
12361 case EM_ADAPTEVA_EPIPHANY
:
12362 case EM_ALPHA
: /* R_ALPHA_NONE. */
12363 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12364 case EM_ARC
: /* R_ARC_NONE. */
12365 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12366 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12367 case EM_ARM
: /* R_ARM_NONE. */
12368 case EM_C166
: /* R_XC16X_NONE. */
12369 case EM_CRIS
: /* R_CRIS_NONE. */
12370 case EM_FT32
: /* R_FT32_NONE. */
12371 case EM_IA_64
: /* R_IA64_NONE. */
12372 case EM_K1OM
: /* R_X86_64_NONE. */
12373 case EM_L1OM
: /* R_X86_64_NONE. */
12374 case EM_M32R
: /* R_M32R_NONE. */
12375 case EM_MIPS
: /* R_MIPS_NONE. */
12376 case EM_MN10300
: /* R_MN10300_NONE. */
12377 case EM_MOXIE
: /* R_MOXIE_NONE. */
12378 case EM_NIOS32
: /* R_NIOS_NONE. */
12379 case EM_OR1K
: /* R_OR1K_NONE. */
12380 case EM_PARISC
: /* R_PARISC_NONE. */
12381 case EM_PPC64
: /* R_PPC64_NONE. */
12382 case EM_PPC
: /* R_PPC_NONE. */
12383 case EM_RISCV
: /* R_RISCV_NONE. */
12384 case EM_S390
: /* R_390_NONE. */
12386 case EM_SH
: /* R_SH_NONE. */
12387 case EM_SPARC32PLUS
:
12388 case EM_SPARC
: /* R_SPARC_NONE. */
12390 case EM_TILEGX
: /* R_TILEGX_NONE. */
12391 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12392 case EM_TI_C6000
:/* R_C6000_NONE. */
12393 case EM_X86_64
: /* R_X86_64_NONE. */
12395 return reloc_type
== 0;
12398 return reloc_type
== 0 || reloc_type
== 256;
12401 return (reloc_type
== 0 /* R_AVR_NONE. */
12402 || reloc_type
== 30 /* R_AVR_DIFF8. */
12403 || reloc_type
== 31 /* R_AVR_DIFF16. */
12404 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12406 return reloc_type
== 3; /* R_METAG_NONE. */
12408 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12409 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12410 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12411 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12412 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12414 return (reloc_type
== 0 /* R_PRU_NONE. */
12415 || reloc_type
== 65 /* R_PRU_DIFF8. */
12416 || reloc_type
== 66 /* R_PRU_DIFF16. */
12417 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12418 case EM_XTENSA_OLD
:
12420 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12421 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12422 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12423 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12428 /* Returns TRUE if there is a relocation against
12429 section NAME at OFFSET bytes. */
12432 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12434 Elf_Internal_Rela
* relocs
;
12435 Elf_Internal_Rela
* rp
;
12437 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12440 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12442 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12443 if (rp
->r_offset
== offset
)
12449 /* Apply relocations to a section.
12450 Returns TRUE upon success, FALSE otherwise.
12451 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12452 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12453 will be set to the number of relocs loaded.
12455 Note: So far support has been added only for those relocations
12456 which can be found in debug sections. FIXME: Add support for
12457 more relocations ? */
12460 apply_relocations (void * file
,
12461 const Elf_Internal_Shdr
* section
,
12462 unsigned char * start
,
12463 bfd_size_type size
,
12464 void ** relocs_return
,
12465 unsigned long * num_relocs_return
)
12467 Elf_Internal_Shdr
* relsec
;
12468 unsigned char * end
= start
+ size
;
12469 bfd_boolean res
= TRUE
;
12471 if (relocs_return
!= NULL
)
12473 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12474 * num_relocs_return
= 0;
12477 if (elf_header
.e_type
!= ET_REL
)
12478 /* No relocs to apply. */
12481 /* Find the reloc section associated with the section. */
12482 for (relsec
= section_headers
;
12483 relsec
< section_headers
+ elf_header
.e_shnum
;
12486 bfd_boolean is_rela
;
12487 unsigned long num_relocs
;
12488 Elf_Internal_Rela
* relocs
;
12489 Elf_Internal_Rela
* rp
;
12490 Elf_Internal_Shdr
* symsec
;
12491 Elf_Internal_Sym
* symtab
;
12492 unsigned long num_syms
;
12493 Elf_Internal_Sym
* sym
;
12495 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12496 || relsec
->sh_info
>= elf_header
.e_shnum
12497 || section_headers
+ relsec
->sh_info
!= section
12498 || relsec
->sh_size
== 0
12499 || relsec
->sh_link
>= elf_header
.e_shnum
)
12502 is_rela
= relsec
->sh_type
== SHT_RELA
;
12506 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12507 relsec
->sh_size
, & relocs
, & num_relocs
))
12512 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12513 relsec
->sh_size
, & relocs
, & num_relocs
))
12517 /* SH uses RELA but uses in place value instead of the addend field. */
12518 if (elf_header
.e_machine
== EM_SH
)
12521 symsec
= section_headers
+ relsec
->sh_link
;
12522 if (symsec
->sh_type
!= SHT_SYMTAB
12523 && symsec
->sh_type
!= SHT_DYNSYM
)
12525 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12527 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12530 unsigned int reloc_type
;
12531 unsigned int reloc_size
;
12532 unsigned char * rloc
;
12533 unsigned long sym_index
;
12535 reloc_type
= get_reloc_type (rp
->r_info
);
12537 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12539 else if (is_none_reloc (reloc_type
))
12541 else if (is_32bit_abs_reloc (reloc_type
)
12542 || is_32bit_pcrel_reloc (reloc_type
))
12544 else if (is_64bit_abs_reloc (reloc_type
)
12545 || is_64bit_pcrel_reloc (reloc_type
))
12547 else if (is_24bit_abs_reloc (reloc_type
))
12549 else if (is_16bit_abs_reloc (reloc_type
))
12553 static unsigned int prev_reloc
= 0;
12554 if (reloc_type
!= prev_reloc
)
12555 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12556 reloc_type
, printable_section_name (section
));
12557 prev_reloc
= reloc_type
;
12562 rloc
= start
+ rp
->r_offset
;
12563 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12565 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12566 (unsigned long) rp
->r_offset
,
12567 printable_section_name (section
));
12572 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12573 if (sym_index
>= num_syms
)
12575 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12576 sym_index
, printable_section_name (section
));
12580 sym
= symtab
+ sym_index
;
12582 /* If the reloc has a symbol associated with it,
12583 make sure that it is of an appropriate type.
12585 Relocations against symbols without type can happen.
12586 Gcc -feliminate-dwarf2-dups may generate symbols
12587 without type for debug info.
12589 Icc generates relocations against function symbols
12590 instead of local labels.
12592 Relocations against object symbols can happen, eg when
12593 referencing a global array. For an example of this see
12594 the _clz.o binary in libgcc.a. */
12596 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12597 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12599 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12600 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12601 (long int)(rp
- relocs
),
12602 printable_section_name (relsec
));
12609 addend
+= rp
->r_addend
;
12610 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12611 partial_inplace. */
12613 || (elf_header
.e_machine
== EM_XTENSA
12614 && reloc_type
== 1)
12615 || ((elf_header
.e_machine
== EM_PJ
12616 || elf_header
.e_machine
== EM_PJ_OLD
)
12617 && reloc_type
== 1)
12618 || ((elf_header
.e_machine
== EM_D30V
12619 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12620 && reloc_type
== 12))
12621 addend
+= byte_get (rloc
, reloc_size
);
12623 if (is_32bit_pcrel_reloc (reloc_type
)
12624 || is_64bit_pcrel_reloc (reloc_type
))
12626 /* On HPPA, all pc-relative relocations are biased by 8. */
12627 if (elf_header
.e_machine
== EM_PARISC
)
12629 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12633 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12637 /* Let the target specific reloc processing code know that
12638 we have finished with these relocs. */
12639 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12643 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12644 * num_relocs_return
= num_relocs
;
12655 #ifdef SUPPORT_DISASSEMBLY
12657 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12659 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12661 /* FIXME: XXX -- to be done --- XXX */
12667 /* Reads in the contents of SECTION from FILE, returning a pointer
12668 to a malloc'ed buffer or NULL if something went wrong. */
12671 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12673 bfd_size_type num_bytes
;
12675 num_bytes
= section
->sh_size
;
12677 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12679 printf (_("\nSection '%s' has no data to dump.\n"),
12680 printable_section_name (section
));
12684 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12685 _("section contents"));
12688 /* Uncompresses a section that was compressed using zlib, in place. */
12691 uncompress_section_contents (unsigned char **buffer
,
12692 dwarf_size_type uncompressed_size
,
12693 dwarf_size_type
*size
)
12695 dwarf_size_type compressed_size
= *size
;
12696 unsigned char * compressed_buffer
= *buffer
;
12697 unsigned char * uncompressed_buffer
;
12701 /* It is possible the section consists of several compressed
12702 buffers concatenated together, so we uncompress in a loop. */
12703 /* PR 18313: The state field in the z_stream structure is supposed
12704 to be invisible to the user (ie us), but some compilers will
12705 still complain about it being used without initialisation. So
12706 we first zero the entire z_stream structure and then set the fields
12708 memset (& strm
, 0, sizeof strm
);
12709 strm
.avail_in
= compressed_size
;
12710 strm
.next_in
= (Bytef
*) compressed_buffer
;
12711 strm
.avail_out
= uncompressed_size
;
12712 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12714 rc
= inflateInit (& strm
);
12715 while (strm
.avail_in
> 0)
12719 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12720 + (uncompressed_size
- strm
.avail_out
));
12721 rc
= inflate (&strm
, Z_FINISH
);
12722 if (rc
!= Z_STREAM_END
)
12724 rc
= inflateReset (& strm
);
12726 rc
= inflateEnd (& strm
);
12728 || strm
.avail_out
!= 0)
12731 *buffer
= uncompressed_buffer
;
12732 *size
= uncompressed_size
;
12736 free (uncompressed_buffer
);
12737 /* Indicate decompression failure. */
12743 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12745 Elf_Internal_Shdr
* relsec
;
12746 bfd_size_type num_bytes
;
12747 unsigned char * data
;
12748 unsigned char * end
;
12749 unsigned char * real_start
;
12750 unsigned char * start
;
12751 bfd_boolean some_strings_shown
;
12753 real_start
= start
= (unsigned char *) get_section_contents (section
,
12757 num_bytes
= section
->sh_size
;
12759 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12761 if (decompress_dumps
)
12763 dwarf_size_type new_size
= num_bytes
;
12764 dwarf_size_type uncompressed_size
= 0;
12766 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12768 Elf_Internal_Chdr chdr
;
12769 unsigned int compression_header_size
12770 = get_compression_header (& chdr
, (unsigned char *) start
,
12773 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12775 warn (_("section '%s' has unsupported compress type: %d\n"),
12776 printable_section_name (section
), chdr
.ch_type
);
12779 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12781 warn (_("compressed section '%s' is corrupted\n"),
12782 printable_section_name (section
));
12785 uncompressed_size
= chdr
.ch_size
;
12786 start
+= compression_header_size
;
12787 new_size
-= compression_header_size
;
12789 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12791 /* Read the zlib header. In this case, it should be "ZLIB"
12792 followed by the uncompressed section size, 8 bytes in
12793 big-endian order. */
12794 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12795 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12796 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12797 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12798 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12799 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12800 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12801 uncompressed_size
+= start
[11];
12806 if (uncompressed_size
)
12808 if (uncompress_section_contents (& start
,
12809 uncompressed_size
, & new_size
))
12810 num_bytes
= new_size
;
12813 error (_("Unable to decompress section %s\n"),
12814 printable_section_name (section
));
12819 start
= real_start
;
12822 /* If the section being dumped has relocations against it the user might
12823 be expecting these relocations to have been applied. Check for this
12824 case and issue a warning message in order to avoid confusion.
12825 FIXME: Maybe we ought to have an option that dumps a section with
12826 relocs applied ? */
12827 for (relsec
= section_headers
;
12828 relsec
< section_headers
+ elf_header
.e_shnum
;
12831 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12832 || relsec
->sh_info
>= elf_header
.e_shnum
12833 || section_headers
+ relsec
->sh_info
!= section
12834 || relsec
->sh_size
== 0
12835 || relsec
->sh_link
>= elf_header
.e_shnum
)
12838 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12843 end
= start
+ num_bytes
;
12844 some_strings_shown
= FALSE
;
12848 while (!ISPRINT (* data
))
12849 if (++ data
>= end
)
12854 size_t maxlen
= end
- data
;
12857 /* PR 11128: Use two separate invocations in order to work
12858 around bugs in the Solaris 8 implementation of printf. */
12859 printf (" [%6tx] ", data
- start
);
12861 printf (" [%6Ix] ", (size_t) (data
- start
));
12865 print_symbol ((int) maxlen
, (const char *) data
);
12867 data
+= strnlen ((const char *) data
, maxlen
);
12871 printf (_("<corrupt>\n"));
12874 some_strings_shown
= TRUE
;
12878 if (! some_strings_shown
)
12879 printf (_(" No strings found in this section."));
12888 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12890 bfd_boolean relocate
)
12892 Elf_Internal_Shdr
* relsec
;
12893 bfd_size_type bytes
;
12894 bfd_size_type section_size
;
12896 unsigned char * data
;
12897 unsigned char * real_start
;
12898 unsigned char * start
;
12900 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12904 section_size
= section
->sh_size
;
12906 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12908 if (decompress_dumps
)
12910 dwarf_size_type new_size
= section_size
;
12911 dwarf_size_type uncompressed_size
= 0;
12913 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12915 Elf_Internal_Chdr chdr
;
12916 unsigned int compression_header_size
12917 = get_compression_header (& chdr
, start
, section_size
);
12919 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12921 warn (_("section '%s' has unsupported compress type: %d\n"),
12922 printable_section_name (section
), chdr
.ch_type
);
12925 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12927 warn (_("compressed section '%s' is corrupted\n"),
12928 printable_section_name (section
));
12931 uncompressed_size
= chdr
.ch_size
;
12932 start
+= compression_header_size
;
12933 new_size
-= compression_header_size
;
12935 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12937 /* Read the zlib header. In this case, it should be "ZLIB"
12938 followed by the uncompressed section size, 8 bytes in
12939 big-endian order. */
12940 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12941 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12942 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12943 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12944 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12945 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12946 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12947 uncompressed_size
+= start
[11];
12952 if (uncompressed_size
)
12954 if (uncompress_section_contents (& start
, uncompressed_size
,
12957 section_size
= new_size
;
12961 error (_("Unable to decompress section %s\n"),
12962 printable_section_name (section
));
12963 /* FIXME: Print the section anyway ? */
12968 start
= real_start
;
12973 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
12978 /* If the section being dumped has relocations against it the user might
12979 be expecting these relocations to have been applied. Check for this
12980 case and issue a warning message in order to avoid confusion.
12981 FIXME: Maybe we ought to have an option that dumps a section with
12982 relocs applied ? */
12983 for (relsec
= section_headers
;
12984 relsec
< section_headers
+ elf_header
.e_shnum
;
12987 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12988 || relsec
->sh_info
>= elf_header
.e_shnum
12989 || section_headers
+ relsec
->sh_info
!= section
12990 || relsec
->sh_size
== 0
12991 || relsec
->sh_link
>= elf_header
.e_shnum
)
12994 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12999 addr
= section
->sh_addr
;
13000 bytes
= section_size
;
13009 lbytes
= (bytes
> 16 ? 16 : bytes
);
13011 printf (" 0x%8.8lx ", (unsigned long) addr
);
13013 for (j
= 0; j
< 16; j
++)
13016 printf ("%2.2x", data
[j
]);
13024 for (j
= 0; j
< lbytes
; j
++)
13027 if (k
>= ' ' && k
< 0x7f)
13047 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13048 const Elf_Internal_Shdr
* sec
, void * file
)
13050 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13053 /* If it is already loaded, do nothing. */
13054 if (section
->start
!= NULL
)
13057 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13058 section
->address
= sec
->sh_addr
;
13059 section
->user_data
= NULL
;
13060 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13062 sec
->sh_size
, buf
);
13063 if (section
->start
== NULL
)
13067 unsigned char *start
= section
->start
;
13068 dwarf_size_type size
= sec
->sh_size
;
13069 dwarf_size_type uncompressed_size
= 0;
13071 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13073 Elf_Internal_Chdr chdr
;
13074 unsigned int compression_header_size
;
13076 if (size
< (is_32bit_elf
13077 ? sizeof (Elf32_External_Chdr
)
13078 : sizeof (Elf64_External_Chdr
)))
13080 warn (_("compressed section %s is too small to contain a compression header"),
13085 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13087 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13089 warn (_("section '%s' has unsupported compress type: %d\n"),
13090 section
->name
, chdr
.ch_type
);
13093 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13095 warn (_("compressed section '%s' is corrupted\n"),
13099 uncompressed_size
= chdr
.ch_size
;
13100 start
+= compression_header_size
;
13101 size
-= compression_header_size
;
13103 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13105 /* Read the zlib header. In this case, it should be "ZLIB"
13106 followed by the uncompressed section size, 8 bytes in
13107 big-endian order. */
13108 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13109 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13110 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13111 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13112 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13113 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13114 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13115 uncompressed_size
+= start
[11];
13120 if (uncompressed_size
)
13122 if (uncompress_section_contents (&start
, uncompressed_size
,
13125 /* Free the compressed buffer, update the section buffer
13126 and the section size if uncompress is successful. */
13127 free (section
->start
);
13128 section
->start
= start
;
13132 error (_("Unable to decompress section %s\n"),
13133 printable_section_name (sec
));
13138 section
->size
= size
;
13141 if (section
->start
== NULL
)
13144 if (debug_displays
[debug
].relocate
)
13146 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13147 & section
->reloc_info
, & section
->num_relocs
))
13152 section
->reloc_info
= NULL
;
13153 section
->num_relocs
= 0;
13159 /* If this is not NULL, load_debug_section will only look for sections
13160 within the list of sections given here. */
13161 static unsigned int * section_subset
= NULL
;
13164 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13166 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13167 Elf_Internal_Shdr
* sec
;
13169 /* Locate the debug section. */
13170 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13172 section
->name
= section
->uncompressed_name
;
13175 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13177 section
->name
= section
->compressed_name
;
13182 /* If we're loading from a subset of sections, and we've loaded
13183 a section matching this name before, it's likely that it's a
13185 if (section_subset
!= NULL
)
13186 free_debug_section (debug
);
13188 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13192 free_debug_section (enum dwarf_section_display_enum debug
)
13194 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13196 if (section
->start
== NULL
)
13199 free ((char *) section
->start
);
13200 section
->start
= NULL
;
13201 section
->address
= 0;
13206 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13208 char * name
= SECTION_NAME (section
);
13209 const char * print_name
= printable_section_name (section
);
13210 bfd_size_type length
;
13211 bfd_boolean result
= TRUE
;
13214 length
= section
->sh_size
;
13217 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13220 if (section
->sh_type
== SHT_NOBITS
)
13222 /* There is no point in dumping the contents of a debugging section
13223 which has the NOBITS type - the bits in the file will be random.
13224 This can happen when a file containing a .eh_frame section is
13225 stripped with the --only-keep-debug command line option. */
13226 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13231 if (const_strneq (name
, ".gnu.linkonce.wi."))
13232 name
= ".debug_info";
13234 /* See if we know how to display the contents of this section. */
13235 for (i
= 0; i
< max
; i
++)
13236 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13237 || (i
== line
&& const_strneq (name
, ".debug_line."))
13238 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13240 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13241 int secondary
= (section
!= find_section (name
));
13244 free_debug_section ((enum dwarf_section_display_enum
) i
);
13246 if (i
== line
&& const_strneq (name
, ".debug_line."))
13248 else if (streq (sec
->uncompressed_name
, name
))
13249 sec
->name
= sec
->uncompressed_name
;
13251 sec
->name
= sec
->compressed_name
;
13252 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13255 /* If this debug section is part of a CU/TU set in a .dwp file,
13256 restrict load_debug_section to the sections in that set. */
13257 section_subset
= find_cu_tu_set (file
, shndx
);
13259 result
&= debug_displays
[i
].display (sec
, file
);
13261 section_subset
= NULL
;
13263 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13264 free_debug_section ((enum dwarf_section_display_enum
) i
);
13272 printf (_("Unrecognized debug section: %s\n"), print_name
);
13279 /* Set DUMP_SECTS for all sections where dumps were requested
13280 based on section name. */
13283 initialise_dumps_byname (void)
13285 struct dump_list_entry
* cur
;
13287 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13290 bfd_boolean any
= FALSE
;
13292 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13293 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13295 request_dump_bynumber (i
, cur
->type
);
13300 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13306 process_section_contents (FILE * file
)
13308 Elf_Internal_Shdr
* section
;
13310 bfd_boolean res
= TRUE
;
13315 initialise_dumps_byname ();
13317 for (i
= 0, section
= section_headers
;
13318 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13321 #ifdef SUPPORT_DISASSEMBLY
13322 if (dump_sects
[i
] & DISASS_DUMP
)
13323 disassemble_section (section
, file
);
13325 if (dump_sects
[i
] & HEX_DUMP
)
13327 if (! dump_section_as_bytes (section
, file
, FALSE
))
13331 if (dump_sects
[i
] & RELOC_DUMP
)
13333 if (! dump_section_as_bytes (section
, file
, TRUE
))
13337 if (dump_sects
[i
] & STRING_DUMP
)
13339 if (! dump_section_as_strings (section
, file
))
13343 if (dump_sects
[i
] & DEBUG_DUMP
)
13345 if (! display_debug_section (i
, section
, file
))
13350 /* Check to see if the user requested a
13351 dump of a section that does not exist. */
13352 while (i
< num_dump_sects
)
13356 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13366 process_mips_fpe_exception (int mask
)
13370 bfd_boolean first
= TRUE
;
13372 if (mask
& OEX_FPU_INEX
)
13373 fputs ("INEX", stdout
), first
= FALSE
;
13374 if (mask
& OEX_FPU_UFLO
)
13375 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13376 if (mask
& OEX_FPU_OFLO
)
13377 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13378 if (mask
& OEX_FPU_DIV0
)
13379 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13380 if (mask
& OEX_FPU_INVAL
)
13381 printf ("%sINVAL", first
? "" : "|");
13384 fputs ("0", stdout
);
13387 /* Display's the value of TAG at location P. If TAG is
13388 greater than 0 it is assumed to be an unknown tag, and
13389 a message is printed to this effect. Otherwise it is
13390 assumed that a message has already been printed.
13392 If the bottom bit of TAG is set it assumed to have a
13393 string value, otherwise it is assumed to have an integer
13396 Returns an updated P pointing to the first unread byte
13397 beyond the end of TAG's value.
13399 Reads at or beyond END will not be made. */
13401 static unsigned char *
13402 display_tag_value (signed int tag
,
13404 const unsigned char * const end
)
13409 printf (" Tag_unknown_%d: ", tag
);
13413 warn (_("<corrupt tag>\n"));
13417 /* PR 17531 file: 027-19978-0.004. */
13418 size_t maxlen
= (end
- p
) - 1;
13423 print_symbol ((int) maxlen
, (const char *) p
);
13424 p
+= strnlen ((char *) p
, maxlen
) + 1;
13428 printf (_("<corrupt string tag>"));
13429 p
= (unsigned char *) end
;
13437 val
= read_uleb128 (p
, &len
, end
);
13439 printf ("%ld (0x%lx)\n", val
, val
);
13446 /* ARM EABI attributes section. */
13451 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13453 const char ** table
;
13454 } arm_attr_public_tag
;
13456 static const char * arm_attr_tag_CPU_arch
[] =
13457 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13458 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13460 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13461 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13462 {"No", "Thumb-1", "Thumb-2", "Yes"};
13463 static const char * arm_attr_tag_FP_arch
[] =
13464 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13465 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13466 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13467 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13468 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13469 "NEON for ARMv8.1"};
13470 static const char * arm_attr_tag_PCS_config
[] =
13471 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13472 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13473 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13474 {"V6", "SB", "TLS", "Unused"};
13475 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13476 {"Absolute", "PC-relative", "SB-relative", "None"};
13477 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13478 {"Absolute", "PC-relative", "None"};
13479 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13480 {"None", "direct", "GOT-indirect"};
13481 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13482 {"None", "??? 1", "2", "??? 3", "4"};
13483 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13484 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13485 {"Unused", "Needed", "Sign only"};
13486 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13487 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13488 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13489 {"Unused", "Finite", "RTABI", "IEEE 754"};
13490 static const char * arm_attr_tag_ABI_enum_size
[] =
13491 {"Unused", "small", "int", "forced to int"};
13492 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13493 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13494 static const char * arm_attr_tag_ABI_VFP_args
[] =
13495 {"AAPCS", "VFP registers", "custom", "compatible"};
13496 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13497 {"AAPCS", "WMMX registers", "custom"};
13498 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13499 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13500 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13501 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13502 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13503 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13504 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13505 static const char * arm_attr_tag_FP_HP_extension
[] =
13506 {"Not Allowed", "Allowed"};
13507 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13508 {"None", "IEEE 754", "Alternative Format"};
13509 static const char * arm_attr_tag_DSP_extension
[] =
13510 {"Follow architecture", "Allowed"};
13511 static const char * arm_attr_tag_MPextension_use
[] =
13512 {"Not Allowed", "Allowed"};
13513 static const char * arm_attr_tag_DIV_use
[] =
13514 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13515 "Allowed in v7-A with integer division extension"};
13516 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13517 static const char * arm_attr_tag_Virtualization_use
[] =
13518 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13519 "TrustZone and Virtualization Extensions"};
13520 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13521 {"Not Allowed", "Allowed"};
13523 #define LOOKUP(id, name) \
13524 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13525 static arm_attr_public_tag arm_attr_public_tags
[] =
13527 {4, "CPU_raw_name", 1, NULL
},
13528 {5, "CPU_name", 1, NULL
},
13529 LOOKUP(6, CPU_arch
),
13530 {7, "CPU_arch_profile", 0, NULL
},
13531 LOOKUP(8, ARM_ISA_use
),
13532 LOOKUP(9, THUMB_ISA_use
),
13533 LOOKUP(10, FP_arch
),
13534 LOOKUP(11, WMMX_arch
),
13535 LOOKUP(12, Advanced_SIMD_arch
),
13536 LOOKUP(13, PCS_config
),
13537 LOOKUP(14, ABI_PCS_R9_use
),
13538 LOOKUP(15, ABI_PCS_RW_data
),
13539 LOOKUP(16, ABI_PCS_RO_data
),
13540 LOOKUP(17, ABI_PCS_GOT_use
),
13541 LOOKUP(18, ABI_PCS_wchar_t
),
13542 LOOKUP(19, ABI_FP_rounding
),
13543 LOOKUP(20, ABI_FP_denormal
),
13544 LOOKUP(21, ABI_FP_exceptions
),
13545 LOOKUP(22, ABI_FP_user_exceptions
),
13546 LOOKUP(23, ABI_FP_number_model
),
13547 {24, "ABI_align_needed", 0, NULL
},
13548 {25, "ABI_align_preserved", 0, NULL
},
13549 LOOKUP(26, ABI_enum_size
),
13550 LOOKUP(27, ABI_HardFP_use
),
13551 LOOKUP(28, ABI_VFP_args
),
13552 LOOKUP(29, ABI_WMMX_args
),
13553 LOOKUP(30, ABI_optimization_goals
),
13554 LOOKUP(31, ABI_FP_optimization_goals
),
13555 {32, "compatibility", 0, NULL
},
13556 LOOKUP(34, CPU_unaligned_access
),
13557 LOOKUP(36, FP_HP_extension
),
13558 LOOKUP(38, ABI_FP_16bit_format
),
13559 LOOKUP(42, MPextension_use
),
13560 LOOKUP(44, DIV_use
),
13561 LOOKUP(46, DSP_extension
),
13562 {64, "nodefaults", 0, NULL
},
13563 {65, "also_compatible_with", 0, NULL
},
13564 LOOKUP(66, T2EE_use
),
13565 {67, "conformance", 1, NULL
},
13566 LOOKUP(68, Virtualization_use
),
13567 LOOKUP(70, MPextension_use_legacy
)
13571 static unsigned char *
13572 display_arm_attribute (unsigned char * p
,
13573 const unsigned char * const end
)
13578 arm_attr_public_tag
* attr
;
13582 tag
= read_uleb128 (p
, &len
, end
);
13585 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13587 if (arm_attr_public_tags
[i
].tag
== tag
)
13589 attr
= &arm_attr_public_tags
[i
];
13596 printf (" Tag_%s: ", attr
->name
);
13597 switch (attr
->type
)
13602 case 7: /* Tag_CPU_arch_profile. */
13603 val
= read_uleb128 (p
, &len
, end
);
13607 case 0: printf (_("None\n")); break;
13608 case 'A': printf (_("Application\n")); break;
13609 case 'R': printf (_("Realtime\n")); break;
13610 case 'M': printf (_("Microcontroller\n")); break;
13611 case 'S': printf (_("Application or Realtime\n")); break;
13612 default: printf ("??? (%d)\n", val
); break;
13616 case 24: /* Tag_align_needed. */
13617 val
= read_uleb128 (p
, &len
, end
);
13621 case 0: printf (_("None\n")); break;
13622 case 1: printf (_("8-byte\n")); break;
13623 case 2: printf (_("4-byte\n")); break;
13624 case 3: printf ("??? 3\n"); break;
13627 printf (_("8-byte and up to %d-byte extended\n"),
13630 printf ("??? (%d)\n", val
);
13635 case 25: /* Tag_align_preserved. */
13636 val
= read_uleb128 (p
, &len
, end
);
13640 case 0: printf (_("None\n")); break;
13641 case 1: printf (_("8-byte, except leaf SP\n")); break;
13642 case 2: printf (_("8-byte\n")); break;
13643 case 3: printf ("??? 3\n"); break;
13646 printf (_("8-byte and up to %d-byte extended\n"),
13649 printf ("??? (%d)\n", val
);
13654 case 32: /* Tag_compatibility. */
13656 val
= read_uleb128 (p
, &len
, end
);
13658 printf (_("flag = %d, vendor = "), val
);
13661 size_t maxlen
= (end
- p
) - 1;
13663 print_symbol ((int) maxlen
, (const char *) p
);
13664 p
+= strnlen ((char *) p
, maxlen
) + 1;
13668 printf (_("<corrupt>"));
13669 p
= (unsigned char *) end
;
13675 case 64: /* Tag_nodefaults. */
13676 /* PR 17531: file: 001-505008-0.01. */
13679 printf (_("True\n"));
13682 case 65: /* Tag_also_compatible_with. */
13683 val
= read_uleb128 (p
, &len
, end
);
13685 if (val
== 6 /* Tag_CPU_arch. */)
13687 val
= read_uleb128 (p
, &len
, end
);
13689 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13690 printf ("??? (%d)\n", val
);
13692 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13696 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13701 printf (_("<unknown: %d>\n"), tag
);
13707 return display_tag_value (-1, p
, end
);
13709 return display_tag_value (0, p
, end
);
13712 assert (attr
->type
& 0x80);
13713 val
= read_uleb128 (p
, &len
, end
);
13715 type
= attr
->type
& 0x7f;
13717 printf ("??? (%d)\n", val
);
13719 printf ("%s\n", attr
->table
[val
]);
13724 return display_tag_value (tag
, p
, end
);
13727 static unsigned char *
13728 display_gnu_attribute (unsigned char * p
,
13729 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13730 const unsigned char * const end
)
13736 tag
= read_uleb128 (p
, &len
, end
);
13739 /* Tag_compatibility is the only generic GNU attribute defined at
13743 val
= read_uleb128 (p
, &len
, end
);
13746 printf (_("flag = %d, vendor = "), val
);
13749 printf (_("<corrupt>\n"));
13750 warn (_("corrupt vendor attribute\n"));
13756 size_t maxlen
= (end
- p
) - 1;
13758 print_symbol ((int) maxlen
, (const char *) p
);
13759 p
+= strnlen ((char *) p
, maxlen
) + 1;
13763 printf (_("<corrupt>"));
13764 p
= (unsigned char *) end
;
13771 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13772 return display_proc_gnu_attribute (p
, tag
, end
);
13774 return display_tag_value (tag
, p
, end
);
13777 static unsigned char *
13778 display_power_gnu_attribute (unsigned char * p
,
13780 const unsigned char * const end
)
13785 if (tag
== Tag_GNU_Power_ABI_FP
)
13787 val
= read_uleb128 (p
, &len
, end
);
13789 printf (" Tag_GNU_Power_ABI_FP: ");
13792 printf (_("<corrupt>\n"));
13797 printf ("(%#x), ", val
);
13802 printf (_("unspecified hard/soft float, "));
13805 printf (_("hard float, "));
13808 printf (_("soft float, "));
13811 printf (_("single-precision hard float, "));
13818 printf (_("unspecified long double\n"));
13821 printf (_("128-bit IBM long double\n"));
13824 printf (_("64-bit long double\n"));
13827 printf (_("128-bit IEEE long double\n"));
13833 if (tag
== Tag_GNU_Power_ABI_Vector
)
13835 val
= read_uleb128 (p
, &len
, end
);
13837 printf (" Tag_GNU_Power_ABI_Vector: ");
13840 printf (_("<corrupt>\n"));
13845 printf ("(%#x), ", val
);
13850 printf (_("unspecified\n"));
13853 printf (_("generic\n"));
13856 printf ("AltiVec\n");
13865 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13867 val
= read_uleb128 (p
, &len
, end
);
13869 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13872 printf (_("<corrupt>\n"));
13877 printf ("(%#x), ", val
);
13882 printf (_("unspecified\n"));
13885 printf ("r3/r4\n");
13888 printf (_("memory\n"));
13897 return display_tag_value (tag
& 1, p
, end
);
13900 static unsigned char *
13901 display_s390_gnu_attribute (unsigned char * p
,
13903 const unsigned char * const end
)
13908 if (tag
== Tag_GNU_S390_ABI_Vector
)
13910 val
= read_uleb128 (p
, &len
, end
);
13912 printf (" Tag_GNU_S390_ABI_Vector: ");
13917 printf (_("any\n"));
13920 printf (_("software\n"));
13923 printf (_("hardware\n"));
13926 printf ("??? (%d)\n", val
);
13932 return display_tag_value (tag
& 1, p
, end
);
13936 display_sparc_hwcaps (unsigned int mask
)
13940 bfd_boolean first
= TRUE
;
13942 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13943 fputs ("mul32", stdout
), first
= FALSE
;
13944 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13945 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
13946 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13947 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
13948 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13949 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
13950 if (mask
& ELF_SPARC_HWCAP_POPC
)
13951 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
13952 if (mask
& ELF_SPARC_HWCAP_VIS
)
13953 printf ("%svis", first
? "" : "|"), first
= FALSE
;
13954 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13955 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
13956 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13957 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
13958 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13959 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
13960 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13961 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
13962 if (mask
& ELF_SPARC_HWCAP_HPC
)
13963 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
13964 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13965 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
13966 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13967 printf ("%strans", first
? "" : "|"), first
= FALSE
;
13968 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13969 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
13970 if (mask
& ELF_SPARC_HWCAP_IMA
)
13971 printf ("%sima", first
? "" : "|"), first
= FALSE
;
13972 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13973 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
13976 fputc ('0', stdout
);
13977 fputc ('\n', stdout
);
13981 display_sparc_hwcaps2 (unsigned int mask
)
13985 bfd_boolean first
= TRUE
;
13987 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13988 fputs ("fjathplus", stdout
), first
= FALSE
;
13989 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13990 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
13991 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13992 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
13993 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13994 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
13995 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13996 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
13997 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13998 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
13999 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14000 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14001 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14002 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14003 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14004 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14005 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14006 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14007 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14008 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14011 fputc ('0', stdout
);
14012 fputc ('\n', stdout
);
14015 static unsigned char *
14016 display_sparc_gnu_attribute (unsigned char * p
,
14018 const unsigned char * const end
)
14023 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14025 val
= read_uleb128 (p
, &len
, end
);
14027 printf (" Tag_GNU_Sparc_HWCAPS: ");
14028 display_sparc_hwcaps (val
);
14031 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14033 val
= read_uleb128 (p
, &len
, end
);
14035 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14036 display_sparc_hwcaps2 (val
);
14040 return display_tag_value (tag
, p
, end
);
14044 print_mips_fp_abi_value (unsigned int val
)
14048 case Val_GNU_MIPS_ABI_FP_ANY
:
14049 printf (_("Hard or soft float\n"));
14051 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14052 printf (_("Hard float (double precision)\n"));
14054 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14055 printf (_("Hard float (single precision)\n"));
14057 case Val_GNU_MIPS_ABI_FP_SOFT
:
14058 printf (_("Soft float\n"));
14060 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14061 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14063 case Val_GNU_MIPS_ABI_FP_XX
:
14064 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14066 case Val_GNU_MIPS_ABI_FP_64
:
14067 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14069 case Val_GNU_MIPS_ABI_FP_64A
:
14070 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14072 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14073 printf (_("NaN 2008 compatibility\n"));
14076 printf ("??? (%d)\n", val
);
14081 static unsigned char *
14082 display_mips_gnu_attribute (unsigned char * p
,
14084 const unsigned char * const end
)
14086 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14091 val
= read_uleb128 (p
, &len
, end
);
14093 printf (" Tag_GNU_MIPS_ABI_FP: ");
14095 print_mips_fp_abi_value (val
);
14100 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14105 val
= read_uleb128 (p
, &len
, end
);
14107 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14111 case Val_GNU_MIPS_ABI_MSA_ANY
:
14112 printf (_("Any MSA or not\n"));
14114 case Val_GNU_MIPS_ABI_MSA_128
:
14115 printf (_("128-bit MSA\n"));
14118 printf ("??? (%d)\n", val
);
14124 return display_tag_value (tag
& 1, p
, end
);
14127 static unsigned char *
14128 display_tic6x_attribute (unsigned char * p
,
14129 const unsigned char * const end
)
14135 tag
= read_uleb128 (p
, &len
, end
);
14141 val
= read_uleb128 (p
, &len
, end
);
14143 printf (" Tag_ISA: ");
14147 case C6XABI_Tag_ISA_none
:
14148 printf (_("None\n"));
14150 case C6XABI_Tag_ISA_C62X
:
14153 case C6XABI_Tag_ISA_C67X
:
14156 case C6XABI_Tag_ISA_C67XP
:
14157 printf ("C67x+\n");
14159 case C6XABI_Tag_ISA_C64X
:
14162 case C6XABI_Tag_ISA_C64XP
:
14163 printf ("C64x+\n");
14165 case C6XABI_Tag_ISA_C674X
:
14166 printf ("C674x\n");
14169 printf ("??? (%d)\n", val
);
14174 case Tag_ABI_wchar_t
:
14175 val
= read_uleb128 (p
, &len
, end
);
14177 printf (" Tag_ABI_wchar_t: ");
14181 printf (_("Not used\n"));
14184 printf (_("2 bytes\n"));
14187 printf (_("4 bytes\n"));
14190 printf ("??? (%d)\n", val
);
14195 case Tag_ABI_stack_align_needed
:
14196 val
= read_uleb128 (p
, &len
, end
);
14198 printf (" Tag_ABI_stack_align_needed: ");
14202 printf (_("8-byte\n"));
14205 printf (_("16-byte\n"));
14208 printf ("??? (%d)\n", val
);
14213 case Tag_ABI_stack_align_preserved
:
14214 val
= read_uleb128 (p
, &len
, end
);
14216 printf (" Tag_ABI_stack_align_preserved: ");
14220 printf (_("8-byte\n"));
14223 printf (_("16-byte\n"));
14226 printf ("??? (%d)\n", val
);
14232 val
= read_uleb128 (p
, &len
, end
);
14234 printf (" Tag_ABI_DSBT: ");
14238 printf (_("DSBT addressing not used\n"));
14241 printf (_("DSBT addressing used\n"));
14244 printf ("??? (%d)\n", val
);
14250 val
= read_uleb128 (p
, &len
, end
);
14252 printf (" Tag_ABI_PID: ");
14256 printf (_("Data addressing position-dependent\n"));
14259 printf (_("Data addressing position-independent, GOT near DP\n"));
14262 printf (_("Data addressing position-independent, GOT far from DP\n"));
14265 printf ("??? (%d)\n", val
);
14271 val
= read_uleb128 (p
, &len
, end
);
14273 printf (" Tag_ABI_PIC: ");
14277 printf (_("Code addressing position-dependent\n"));
14280 printf (_("Code addressing position-independent\n"));
14283 printf ("??? (%d)\n", val
);
14288 case Tag_ABI_array_object_alignment
:
14289 val
= read_uleb128 (p
, &len
, end
);
14291 printf (" Tag_ABI_array_object_alignment: ");
14295 printf (_("8-byte\n"));
14298 printf (_("4-byte\n"));
14301 printf (_("16-byte\n"));
14304 printf ("??? (%d)\n", val
);
14309 case Tag_ABI_array_object_align_expected
:
14310 val
= read_uleb128 (p
, &len
, end
);
14312 printf (" Tag_ABI_array_object_align_expected: ");
14316 printf (_("8-byte\n"));
14319 printf (_("4-byte\n"));
14322 printf (_("16-byte\n"));
14325 printf ("??? (%d)\n", val
);
14330 case Tag_ABI_compatibility
:
14332 val
= read_uleb128 (p
, &len
, end
);
14334 printf (" Tag_ABI_compatibility: ");
14335 printf (_("flag = %d, vendor = "), val
);
14338 size_t maxlen
= (end
- p
) - 1;
14340 print_symbol ((int) maxlen
, (const char *) p
);
14341 p
+= strnlen ((char *) p
, maxlen
) + 1;
14345 printf (_("<corrupt>"));
14346 p
= (unsigned char *) end
;
14352 case Tag_ABI_conformance
:
14354 printf (" Tag_ABI_conformance: \"");
14357 size_t maxlen
= (end
- p
) - 1;
14359 print_symbol ((int) maxlen
, (const char *) p
);
14360 p
+= strnlen ((char *) p
, maxlen
) + 1;
14364 printf (_("<corrupt>"));
14365 p
= (unsigned char *) end
;
14372 return display_tag_value (tag
, p
, end
);
14376 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14378 unsigned long addr
= 0;
14379 size_t bytes
= end
- p
;
14386 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14388 printf (" 0x%8.8lx ", addr
);
14390 for (j
= 0; j
< 16; j
++)
14393 printf ("%2.2x", p
[j
]);
14401 for (j
= 0; j
< lbytes
; j
++)
14404 if (k
>= ' ' && k
< 0x7f)
14420 static unsigned char *
14421 display_msp430x_attribute (unsigned char * p
,
14422 const unsigned char * const end
)
14428 tag
= read_uleb128 (p
, & len
, end
);
14433 case OFBA_MSPABI_Tag_ISA
:
14434 val
= read_uleb128 (p
, &len
, end
);
14436 printf (" Tag_ISA: ");
14439 case 0: printf (_("None\n")); break;
14440 case 1: printf (_("MSP430\n")); break;
14441 case 2: printf (_("MSP430X\n")); break;
14442 default: printf ("??? (%d)\n", val
); break;
14446 case OFBA_MSPABI_Tag_Code_Model
:
14447 val
= read_uleb128 (p
, &len
, end
);
14449 printf (" Tag_Code_Model: ");
14452 case 0: printf (_("None\n")); break;
14453 case 1: printf (_("Small\n")); break;
14454 case 2: printf (_("Large\n")); break;
14455 default: printf ("??? (%d)\n", val
); break;
14459 case OFBA_MSPABI_Tag_Data_Model
:
14460 val
= read_uleb128 (p
, &len
, end
);
14462 printf (" Tag_Data_Model: ");
14465 case 0: printf (_("None\n")); break;
14466 case 1: printf (_("Small\n")); break;
14467 case 2: printf (_("Large\n")); break;
14468 case 3: printf (_("Restricted Large\n")); break;
14469 default: printf ("??? (%d)\n", val
); break;
14474 printf (_(" <unknown tag %d>: "), tag
);
14481 size_t maxlen
= (end
- p
) - 1;
14483 print_symbol ((int) maxlen
, (const char *) p
);
14484 p
+= strnlen ((char *) p
, maxlen
) + 1;
14488 printf (_("<corrupt>"));
14489 p
= (unsigned char *) end
;
14495 val
= read_uleb128 (p
, &len
, end
);
14497 printf ("%d (0x%x)\n", val
, val
);
14507 process_attributes (FILE * file
,
14508 const char * public_name
,
14509 unsigned int proc_type
,
14510 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14511 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14513 Elf_Internal_Shdr
* sect
;
14515 bfd_boolean res
= TRUE
;
14517 /* Find the section header so that we get the size. */
14518 for (i
= 0, sect
= section_headers
;
14519 i
< elf_header
.e_shnum
;
14522 unsigned char * contents
;
14525 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14528 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14529 sect
->sh_size
, _("attributes"));
14530 if (contents
== NULL
)
14537 /* The first character is the version of the attributes.
14538 Currently only version 1, (aka 'A') is recognised here. */
14541 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14546 bfd_vma section_len
;
14548 section_len
= sect
->sh_size
- 1;
14551 while (section_len
> 0)
14554 unsigned int namelen
;
14555 bfd_boolean public_section
;
14556 bfd_boolean gnu_section
;
14558 if (section_len
<= 4)
14560 error (_("Tag section ends prematurely\n"));
14564 attr_len
= byte_get (p
, 4);
14567 if (attr_len
> section_len
)
14569 error (_("Bad attribute length (%u > %u)\n"),
14570 (unsigned) attr_len
, (unsigned) section_len
);
14571 attr_len
= section_len
;
14574 /* PR 17531: file: 001-101425-0.004 */
14575 else if (attr_len
< 5)
14577 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14582 section_len
-= attr_len
;
14585 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14586 if (namelen
== 0 || namelen
>= attr_len
)
14588 error (_("Corrupt attribute section name\n"));
14593 printf (_("Attribute Section: "));
14594 print_symbol (INT_MAX
, (const char *) p
);
14597 if (public_name
&& streq ((char *) p
, public_name
))
14598 public_section
= TRUE
;
14600 public_section
= FALSE
;
14602 if (streq ((char *) p
, "gnu"))
14603 gnu_section
= TRUE
;
14605 gnu_section
= FALSE
;
14608 attr_len
-= namelen
;
14610 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14615 unsigned char * end
;
14617 /* PR binutils/17531: Safe handling of corrupt files. */
14620 error (_("Unused bytes at end of section\n"));
14627 size
= byte_get (p
, 4);
14628 if (size
> attr_len
)
14630 error (_("Bad subsection length (%u > %u)\n"),
14631 (unsigned) size
, (unsigned) attr_len
);
14635 /* PR binutils/17531: Safe handling of corrupt files. */
14638 error (_("Bad subsection length (%u < 6)\n"),
14646 end
= p
+ size
- 1;
14647 assert (end
<= contents
+ sect
->sh_size
);
14653 printf (_("File Attributes\n"));
14656 printf (_("Section Attributes:"));
14659 printf (_("Symbol Attributes:"));
14660 /* Fall through. */
14666 val
= read_uleb128 (p
, &j
, end
);
14670 printf (" %d", val
);
14675 printf (_("Unknown tag: %d\n"), tag
);
14676 public_section
= FALSE
;
14680 if (public_section
&& display_pub_attribute
!= NULL
)
14683 p
= display_pub_attribute (p
, end
);
14686 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14689 p
= display_gnu_attribute (p
,
14690 display_proc_gnu_attribute
,
14696 printf (_(" Unknown attribute:\n"));
14697 display_raw_attribute (p
, end
);
14712 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14713 Print the Address, Access and Initial fields of an entry at VMA ADDR
14714 and return the VMA of the next entry, or -1 if there was a problem.
14715 Does not read from DATA_END or beyond. */
14718 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14719 unsigned char * data_end
)
14722 print_vma (addr
, LONG_HEX
);
14724 if (addr
< pltgot
+ 0xfff0)
14725 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14727 printf ("%10s", "");
14730 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14734 unsigned char * from
= data
+ addr
- pltgot
;
14736 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14738 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14739 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14740 return (bfd_vma
) -1;
14744 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14745 print_vma (entry
, LONG_HEX
);
14748 return addr
+ (is_32bit_elf
? 4 : 8);
14751 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14752 PLTGOT. Print the Address and Initial fields of an entry at VMA
14753 ADDR and return the VMA of the next entry. */
14756 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14759 print_vma (addr
, LONG_HEX
);
14762 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14767 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14768 print_vma (entry
, LONG_HEX
);
14770 return addr
+ (is_32bit_elf
? 4 : 8);
14774 print_mips_ases (unsigned int mask
)
14776 if (mask
& AFL_ASE_DSP
)
14777 fputs ("\n\tDSP ASE", stdout
);
14778 if (mask
& AFL_ASE_DSPR2
)
14779 fputs ("\n\tDSP R2 ASE", stdout
);
14780 if (mask
& AFL_ASE_DSPR3
)
14781 fputs ("\n\tDSP R3 ASE", stdout
);
14782 if (mask
& AFL_ASE_EVA
)
14783 fputs ("\n\tEnhanced VA Scheme", stdout
);
14784 if (mask
& AFL_ASE_MCU
)
14785 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14786 if (mask
& AFL_ASE_MDMX
)
14787 fputs ("\n\tMDMX ASE", stdout
);
14788 if (mask
& AFL_ASE_MIPS3D
)
14789 fputs ("\n\tMIPS-3D ASE", stdout
);
14790 if (mask
& AFL_ASE_MT
)
14791 fputs ("\n\tMT ASE", stdout
);
14792 if (mask
& AFL_ASE_SMARTMIPS
)
14793 fputs ("\n\tSmartMIPS ASE", stdout
);
14794 if (mask
& AFL_ASE_VIRT
)
14795 fputs ("\n\tVZ ASE", stdout
);
14796 if (mask
& AFL_ASE_MSA
)
14797 fputs ("\n\tMSA ASE", stdout
);
14798 if (mask
& AFL_ASE_MIPS16
)
14799 fputs ("\n\tMIPS16 ASE", stdout
);
14800 if (mask
& AFL_ASE_MICROMIPS
)
14801 fputs ("\n\tMICROMIPS ASE", stdout
);
14802 if (mask
& AFL_ASE_XPA
)
14803 fputs ("\n\tXPA ASE", stdout
);
14805 fprintf (stdout
, "\n\t%s", _("None"));
14806 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14807 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14811 print_mips_isa_ext (unsigned int isa_ext
)
14816 fputs (_("None"), stdout
);
14819 fputs ("RMI XLR", stdout
);
14821 case AFL_EXT_OCTEON3
:
14822 fputs ("Cavium Networks Octeon3", stdout
);
14824 case AFL_EXT_OCTEON2
:
14825 fputs ("Cavium Networks Octeon2", stdout
);
14827 case AFL_EXT_OCTEONP
:
14828 fputs ("Cavium Networks OcteonP", stdout
);
14830 case AFL_EXT_LOONGSON_3A
:
14831 fputs ("Loongson 3A", stdout
);
14833 case AFL_EXT_OCTEON
:
14834 fputs ("Cavium Networks Octeon", stdout
);
14837 fputs ("Toshiba R5900", stdout
);
14840 fputs ("MIPS R4650", stdout
);
14843 fputs ("LSI R4010", stdout
);
14846 fputs ("NEC VR4100", stdout
);
14849 fputs ("Toshiba R3900", stdout
);
14851 case AFL_EXT_10000
:
14852 fputs ("MIPS R10000", stdout
);
14855 fputs ("Broadcom SB-1", stdout
);
14858 fputs ("NEC VR4111/VR4181", stdout
);
14861 fputs ("NEC VR4120", stdout
);
14864 fputs ("NEC VR5400", stdout
);
14867 fputs ("NEC VR5500", stdout
);
14869 case AFL_EXT_LOONGSON_2E
:
14870 fputs ("ST Microelectronics Loongson 2E", stdout
);
14872 case AFL_EXT_LOONGSON_2F
:
14873 fputs ("ST Microelectronics Loongson 2F", stdout
);
14876 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14881 get_mips_reg_size (int reg_size
)
14883 return (reg_size
== AFL_REG_NONE
) ? 0
14884 : (reg_size
== AFL_REG_32
) ? 32
14885 : (reg_size
== AFL_REG_64
) ? 64
14886 : (reg_size
== AFL_REG_128
) ? 128
14891 process_mips_specific (FILE * file
)
14893 Elf_Internal_Dyn
* entry
;
14894 Elf_Internal_Shdr
*sect
= NULL
;
14895 size_t liblist_offset
= 0;
14896 size_t liblistno
= 0;
14897 size_t conflictsno
= 0;
14898 size_t options_offset
= 0;
14899 size_t conflicts_offset
= 0;
14900 size_t pltrelsz
= 0;
14902 bfd_vma pltgot
= 0;
14903 bfd_vma mips_pltgot
= 0;
14904 bfd_vma jmprel
= 0;
14905 bfd_vma local_gotno
= 0;
14906 bfd_vma gotsym
= 0;
14907 bfd_vma symtabno
= 0;
14908 bfd_boolean res
= TRUE
;
14910 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14911 display_mips_gnu_attribute
))
14914 sect
= find_section (".MIPS.abiflags");
14918 Elf_External_ABIFlags_v0
*abiflags_ext
;
14919 Elf_Internal_ABIFlags_v0 abiflags_in
;
14921 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14923 error (_("Corrupt MIPS ABI Flags section.\n"));
14928 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14929 sect
->sh_size
, _("MIPS ABI Flags section"));
14932 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14933 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14934 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14935 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14936 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14937 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14938 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14939 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14940 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14941 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14942 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14944 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14945 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14946 if (abiflags_in
.isa_rev
> 1)
14947 printf ("r%d", abiflags_in
.isa_rev
);
14948 printf ("\nGPR size: %d",
14949 get_mips_reg_size (abiflags_in
.gpr_size
));
14950 printf ("\nCPR1 size: %d",
14951 get_mips_reg_size (abiflags_in
.cpr1_size
));
14952 printf ("\nCPR2 size: %d",
14953 get_mips_reg_size (abiflags_in
.cpr2_size
));
14954 fputs ("\nFP ABI: ", stdout
);
14955 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14956 fputs ("ISA Extension: ", stdout
);
14957 print_mips_isa_ext (abiflags_in
.isa_ext
);
14958 fputs ("\nASEs:", stdout
);
14959 print_mips_ases (abiflags_in
.ases
);
14960 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14961 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14962 fputc ('\n', stdout
);
14963 free (abiflags_ext
);
14968 /* We have a lot of special sections. Thanks SGI! */
14969 if (dynamic_section
== NULL
)
14970 /* No information available. */
14973 for (entry
= dynamic_section
;
14974 /* PR 17531 file: 012-50589-0.004. */
14975 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14977 switch (entry
->d_tag
)
14979 case DT_MIPS_LIBLIST
:
14981 = offset_from_vma (file
, entry
->d_un
.d_val
,
14982 liblistno
* sizeof (Elf32_External_Lib
));
14984 case DT_MIPS_LIBLISTNO
:
14985 liblistno
= entry
->d_un
.d_val
;
14987 case DT_MIPS_OPTIONS
:
14988 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14990 case DT_MIPS_CONFLICT
:
14992 = offset_from_vma (file
, entry
->d_un
.d_val
,
14993 conflictsno
* sizeof (Elf32_External_Conflict
));
14995 case DT_MIPS_CONFLICTNO
:
14996 conflictsno
= entry
->d_un
.d_val
;
14999 pltgot
= entry
->d_un
.d_ptr
;
15001 case DT_MIPS_LOCAL_GOTNO
:
15002 local_gotno
= entry
->d_un
.d_val
;
15004 case DT_MIPS_GOTSYM
:
15005 gotsym
= entry
->d_un
.d_val
;
15007 case DT_MIPS_SYMTABNO
:
15008 symtabno
= entry
->d_un
.d_val
;
15010 case DT_MIPS_PLTGOT
:
15011 mips_pltgot
= entry
->d_un
.d_ptr
;
15014 pltrel
= entry
->d_un
.d_val
;
15017 pltrelsz
= entry
->d_un
.d_val
;
15020 jmprel
= entry
->d_un
.d_ptr
;
15026 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15028 Elf32_External_Lib
* elib
;
15031 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15033 sizeof (Elf32_External_Lib
),
15034 _("liblist section data"));
15037 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15038 (unsigned long) liblistno
);
15039 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15042 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15049 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15050 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15051 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15052 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15053 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15055 tmp
= gmtime (&atime
);
15056 snprintf (timebuf
, sizeof (timebuf
),
15057 "%04u-%02u-%02uT%02u:%02u:%02u",
15058 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15059 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15061 printf ("%3lu: ", (unsigned long) cnt
);
15062 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15063 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15065 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15066 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15067 liblist
.l_version
);
15069 if (liblist
.l_flags
== 0)
15073 static const struct
15080 { " EXACT_MATCH", LL_EXACT_MATCH
},
15081 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15082 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15083 { " EXPORTS", LL_EXPORTS
},
15084 { " DELAY_LOAD", LL_DELAY_LOAD
},
15085 { " DELTA", LL_DELTA
}
15087 int flags
= liblist
.l_flags
;
15090 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15091 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15093 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15094 flags
^= l_flags_vals
[fcnt
].bit
;
15097 printf (" %#x", (unsigned int) flags
);
15109 if (options_offset
!= 0)
15111 Elf_External_Options
* eopt
;
15112 Elf_Internal_Options
* iopt
;
15113 Elf_Internal_Options
* option
;
15116 sect
= section_headers
;
15118 /* Find the section header so that we get the size. */
15119 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15120 /* PR 17533 file: 012-277276-0.004. */
15123 error (_("No MIPS_OPTIONS header found\n"));
15127 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15128 sect
->sh_size
, _("options"));
15131 iopt
= (Elf_Internal_Options
*)
15132 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15135 error (_("Out of memory allocating space for MIPS options\n"));
15142 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15144 Elf_External_Options
* eoption
;
15146 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15148 option
->kind
= BYTE_GET (eoption
->kind
);
15149 option
->size
= BYTE_GET (eoption
->size
);
15150 option
->section
= BYTE_GET (eoption
->section
);
15151 option
->info
= BYTE_GET (eoption
->info
);
15153 /* PR 17531: file: ffa0fa3b. */
15154 if (option
->size
< sizeof (* eopt
)
15155 || offset
+ option
->size
> sect
->sh_size
)
15157 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15160 offset
+= option
->size
;
15166 printf (_("\nSection '%s' contains %d entries:\n"),
15167 printable_section_name (sect
), cnt
);
15176 switch (option
->kind
)
15179 /* This shouldn't happen. */
15180 printf (" NULL %d %lx", option
->section
, option
->info
);
15183 printf (" REGINFO ");
15184 if (elf_header
.e_machine
== EM_MIPS
)
15187 Elf32_External_RegInfo
* ereg
;
15188 Elf32_RegInfo reginfo
;
15190 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15191 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15192 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15193 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15194 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15195 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15196 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15198 printf ("GPR %08lx GP 0x%lx\n",
15199 reginfo
.ri_gprmask
,
15200 (unsigned long) reginfo
.ri_gp_value
);
15201 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15202 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15203 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15208 Elf64_External_RegInfo
* ereg
;
15209 Elf64_Internal_RegInfo reginfo
;
15211 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15212 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15213 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15214 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15215 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15216 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15217 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15219 printf ("GPR %08lx GP 0x",
15220 reginfo
.ri_gprmask
);
15221 printf_vma (reginfo
.ri_gp_value
);
15224 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15225 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15226 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15230 case ODK_EXCEPTIONS
:
15231 fputs (" EXCEPTIONS fpe_min(", stdout
);
15232 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15233 fputs (") fpe_max(", stdout
);
15234 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15235 fputs (")", stdout
);
15237 if (option
->info
& OEX_PAGE0
)
15238 fputs (" PAGE0", stdout
);
15239 if (option
->info
& OEX_SMM
)
15240 fputs (" SMM", stdout
);
15241 if (option
->info
& OEX_FPDBUG
)
15242 fputs (" FPDBUG", stdout
);
15243 if (option
->info
& OEX_DISMISS
)
15244 fputs (" DISMISS", stdout
);
15247 fputs (" PAD ", stdout
);
15248 if (option
->info
& OPAD_PREFIX
)
15249 fputs (" PREFIX", stdout
);
15250 if (option
->info
& OPAD_POSTFIX
)
15251 fputs (" POSTFIX", stdout
);
15252 if (option
->info
& OPAD_SYMBOL
)
15253 fputs (" SYMBOL", stdout
);
15256 fputs (" HWPATCH ", stdout
);
15257 if (option
->info
& OHW_R4KEOP
)
15258 fputs (" R4KEOP", stdout
);
15259 if (option
->info
& OHW_R8KPFETCH
)
15260 fputs (" R8KPFETCH", stdout
);
15261 if (option
->info
& OHW_R5KEOP
)
15262 fputs (" R5KEOP", stdout
);
15263 if (option
->info
& OHW_R5KCVTL
)
15264 fputs (" R5KCVTL", stdout
);
15267 fputs (" FILL ", stdout
);
15268 /* XXX Print content of info word? */
15271 fputs (" TAGS ", stdout
);
15272 /* XXX Print content of info word? */
15275 fputs (" HWAND ", stdout
);
15276 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15277 fputs (" R4KEOP_CHECKED", stdout
);
15278 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15279 fputs (" R4KEOP_CLEAN", stdout
);
15282 fputs (" HWOR ", stdout
);
15283 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15284 fputs (" R4KEOP_CHECKED", stdout
);
15285 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15286 fputs (" R4KEOP_CLEAN", stdout
);
15289 printf (" GP_GROUP %#06lx self-contained %#06lx",
15290 option
->info
& OGP_GROUP
,
15291 (option
->info
& OGP_SELF
) >> 16);
15294 printf (" IDENT %#06lx self-contained %#06lx",
15295 option
->info
& OGP_GROUP
,
15296 (option
->info
& OGP_SELF
) >> 16);
15299 /* This shouldn't happen. */
15300 printf (" %3d ??? %d %lx",
15301 option
->kind
, option
->section
, option
->info
);
15305 len
= sizeof (* eopt
);
15306 while (len
< option
->size
)
15308 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15310 if (ISPRINT (datum
))
15311 printf ("%c", datum
);
15313 printf ("\\%03o", datum
);
15316 fputs ("\n", stdout
);
15318 offset
+= option
->size
;
15328 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15330 Elf32_Conflict
* iconf
;
15333 if (dynamic_symbols
== NULL
)
15335 error (_("conflict list found without a dynamic symbol table\n"));
15339 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15342 error (_("Out of memory allocating space for dynamic conflicts\n"));
15348 Elf32_External_Conflict
* econf32
;
15350 econf32
= (Elf32_External_Conflict
*)
15351 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15352 sizeof (* econf32
), _("conflict"));
15356 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15357 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15363 Elf64_External_Conflict
* econf64
;
15365 econf64
= (Elf64_External_Conflict
*)
15366 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15367 sizeof (* econf64
), _("conflict"));
15371 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15372 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15377 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15378 (unsigned long) conflictsno
);
15379 puts (_(" Num: Index Value Name"));
15381 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15383 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15385 if (iconf
[cnt
] >= num_dynamic_syms
)
15386 printf (_("<corrupt symbol index>"));
15389 Elf_Internal_Sym
* psym
;
15391 psym
= & dynamic_symbols
[iconf
[cnt
]];
15392 print_vma (psym
->st_value
, FULL_HEX
);
15394 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15395 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15397 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15405 if (pltgot
!= 0 && local_gotno
!= 0)
15407 bfd_vma ent
, local_end
, global_end
;
15409 unsigned char * data
;
15410 unsigned char * data_end
;
15414 addr_size
= (is_32bit_elf
? 4 : 8);
15415 local_end
= pltgot
+ local_gotno
* addr_size
;
15417 /* PR binutils/17533 file: 012-111227-0.004 */
15418 if (symtabno
< gotsym
)
15420 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15421 (unsigned long) gotsym
, (unsigned long) symtabno
);
15425 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15426 /* PR 17531: file: 54c91a34. */
15427 if (global_end
< local_end
)
15429 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15433 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15434 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15435 global_end
- pltgot
, 1,
15436 _("Global Offset Table data"));
15439 data_end
= data
+ (global_end
- pltgot
);
15441 printf (_("\nPrimary GOT:\n"));
15442 printf (_(" Canonical gp value: "));
15443 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15446 printf (_(" Reserved entries:\n"));
15447 printf (_(" %*s %10s %*s Purpose\n"),
15448 addr_size
* 2, _("Address"), _("Access"),
15449 addr_size
* 2, _("Initial"));
15450 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15451 printf (_(" Lazy resolver\n"));
15452 if (ent
== (bfd_vma
) -1)
15453 goto got_print_fail
;
15455 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15456 >> (addr_size
* 8 - 1)) != 0)
15458 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15459 printf (_(" Module pointer (GNU extension)\n"));
15460 if (ent
== (bfd_vma
) -1)
15461 goto got_print_fail
;
15465 if (ent
< local_end
)
15467 printf (_(" Local entries:\n"));
15468 printf (" %*s %10s %*s\n",
15469 addr_size
* 2, _("Address"), _("Access"),
15470 addr_size
* 2, _("Initial"));
15471 while (ent
< local_end
)
15473 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15475 if (ent
== (bfd_vma
) -1)
15476 goto got_print_fail
;
15481 if (gotsym
< symtabno
)
15485 printf (_(" Global entries:\n"));
15486 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15487 addr_size
* 2, _("Address"),
15489 addr_size
* 2, _("Initial"),
15490 addr_size
* 2, _("Sym.Val."),
15492 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15493 _("Ndx"), _("Name"));
15495 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15497 for (i
= gotsym
; i
< symtabno
; i
++)
15499 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15502 if (dynamic_symbols
== NULL
)
15503 printf (_("<no dynamic symbols>"));
15504 else if (i
< num_dynamic_syms
)
15506 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15508 print_vma (psym
->st_value
, LONG_HEX
);
15509 printf (" %-7s %3s ",
15510 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15511 get_symbol_index_type (psym
->st_shndx
));
15513 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15514 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15516 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15519 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15520 (unsigned long) i
);
15523 if (ent
== (bfd_vma
) -1)
15534 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15537 size_t offset
, rel_offset
;
15538 unsigned long count
, i
;
15539 unsigned char * data
;
15540 int addr_size
, sym_width
;
15541 Elf_Internal_Rela
* rels
;
15543 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15544 if (pltrel
== DT_RELA
)
15546 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15551 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15556 addr_size
= (is_32bit_elf
? 4 : 8);
15557 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15559 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15560 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15561 1, _("Procedure Linkage Table data"));
15565 printf ("\nPLT GOT:\n\n");
15566 printf (_(" Reserved entries:\n"));
15567 printf (_(" %*s %*s Purpose\n"),
15568 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15569 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15570 printf (_(" PLT lazy resolver\n"));
15571 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15572 printf (_(" Module pointer\n"));
15575 printf (_(" Entries:\n"));
15576 printf (" %*s %*s %*s %-7s %3s %s\n",
15577 addr_size
* 2, _("Address"),
15578 addr_size
* 2, _("Initial"),
15579 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15580 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15581 for (i
= 0; i
< count
; i
++)
15583 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15585 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15588 if (idx
>= num_dynamic_syms
)
15589 printf (_("<corrupt symbol index: %lu>"), idx
);
15592 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15594 print_vma (psym
->st_value
, LONG_HEX
);
15595 printf (" %-7s %3s ",
15596 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15597 get_symbol_index_type (psym
->st_shndx
));
15598 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15599 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15601 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15616 process_nds32_specific (FILE * file
)
15618 Elf_Internal_Shdr
*sect
= NULL
;
15620 sect
= find_section (".nds32_e_flags");
15623 unsigned int *flag
;
15625 printf ("\nNDS32 elf flags section:\n");
15626 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15627 sect
->sh_size
, _("NDS32 elf flags section"));
15632 switch ((*flag
) & 0x3)
15635 printf ("(VEC_SIZE):\tNo entry.\n");
15638 printf ("(VEC_SIZE):\t4 bytes\n");
15641 printf ("(VEC_SIZE):\t16 bytes\n");
15644 printf ("(VEC_SIZE):\treserved\n");
15653 process_gnu_liblist (FILE * file
)
15655 Elf_Internal_Shdr
* section
;
15656 Elf_Internal_Shdr
* string_sec
;
15657 Elf32_External_Lib
* elib
;
15659 size_t strtab_size
;
15662 bfd_boolean res
= TRUE
;
15667 for (i
= 0, section
= section_headers
;
15668 i
< elf_header
.e_shnum
;
15671 switch (section
->sh_type
)
15673 case SHT_GNU_LIBLIST
:
15674 if (section
->sh_link
>= elf_header
.e_shnum
)
15677 elib
= (Elf32_External_Lib
*)
15678 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15679 _("liblist section data"));
15687 string_sec
= section_headers
+ section
->sh_link
;
15688 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15689 string_sec
->sh_size
,
15690 _("liblist string table"));
15692 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15699 strtab_size
= string_sec
->sh_size
;
15701 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15702 printable_section_name (section
),
15703 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15705 puts (_(" Library Time Stamp Checksum Version Flags"));
15707 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15715 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15716 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15717 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15718 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15719 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15721 tmp
= gmtime (&atime
);
15722 snprintf (timebuf
, sizeof (timebuf
),
15723 "%04u-%02u-%02uT%02u:%02u:%02u",
15724 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15725 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15727 printf ("%3lu: ", (unsigned long) cnt
);
15729 printf ("%-20s", liblist
.l_name
< strtab_size
15730 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15732 printf ("%-20.20s", liblist
.l_name
< strtab_size
15733 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15734 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15735 liblist
.l_version
, liblist
.l_flags
);
15746 static const char *
15747 get_note_type (unsigned e_type
)
15749 static char buff
[64];
15751 if (elf_header
.e_type
== ET_CORE
)
15755 return _("NT_AUXV (auxiliary vector)");
15757 return _("NT_PRSTATUS (prstatus structure)");
15759 return _("NT_FPREGSET (floating point registers)");
15761 return _("NT_PRPSINFO (prpsinfo structure)");
15762 case NT_TASKSTRUCT
:
15763 return _("NT_TASKSTRUCT (task structure)");
15765 return _("NT_PRXFPREG (user_xfpregs structure)");
15767 return _("NT_PPC_VMX (ppc Altivec registers)");
15769 return _("NT_PPC_VSX (ppc VSX registers)");
15771 return _("NT_386_TLS (x86 TLS information)");
15772 case NT_386_IOPERM
:
15773 return _("NT_386_IOPERM (x86 I/O permissions)");
15774 case NT_X86_XSTATE
:
15775 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15776 case NT_S390_HIGH_GPRS
:
15777 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15778 case NT_S390_TIMER
:
15779 return _("NT_S390_TIMER (s390 timer register)");
15780 case NT_S390_TODCMP
:
15781 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15782 case NT_S390_TODPREG
:
15783 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15785 return _("NT_S390_CTRS (s390 control registers)");
15786 case NT_S390_PREFIX
:
15787 return _("NT_S390_PREFIX (s390 prefix register)");
15788 case NT_S390_LAST_BREAK
:
15789 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15790 case NT_S390_SYSTEM_CALL
:
15791 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15793 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15794 case NT_S390_VXRS_LOW
:
15795 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15796 case NT_S390_VXRS_HIGH
:
15797 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15799 return _("NT_ARM_VFP (arm VFP registers)");
15801 return _("NT_ARM_TLS (AArch TLS registers)");
15802 case NT_ARM_HW_BREAK
:
15803 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15804 case NT_ARM_HW_WATCH
:
15805 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15807 return _("NT_PSTATUS (pstatus structure)");
15809 return _("NT_FPREGS (floating point registers)");
15811 return _("NT_PSINFO (psinfo structure)");
15813 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15815 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15816 case NT_WIN32PSTATUS
:
15817 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15819 return _("NT_SIGINFO (siginfo_t data)");
15821 return _("NT_FILE (mapped files)");
15829 return _("NT_VERSION (version)");
15831 return _("NT_ARCH (architecture)");
15832 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
15833 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15834 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
15835 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15840 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15845 print_core_note (Elf_Internal_Note
*pnote
)
15847 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15848 bfd_vma count
, page_size
;
15849 unsigned char *descdata
, *filenames
, *descend
;
15851 if (pnote
->type
!= NT_FILE
)
15857 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15858 /* Still "successful". */
15863 if (pnote
->descsz
< 2 * addr_size
)
15865 error (_(" Malformed note - too short for header\n"));
15869 descdata
= (unsigned char *) pnote
->descdata
;
15870 descend
= descdata
+ pnote
->descsz
;
15872 if (descdata
[pnote
->descsz
- 1] != '\0')
15874 error (_(" Malformed note - does not end with \\0\n"));
15878 count
= byte_get (descdata
, addr_size
);
15879 descdata
+= addr_size
;
15881 page_size
= byte_get (descdata
, addr_size
);
15882 descdata
+= addr_size
;
15884 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15886 error (_(" Malformed note - too short for supplied file count\n"));
15890 printf (_(" Page size: "));
15891 print_vma (page_size
, DEC
);
15894 printf (_(" %*s%*s%*s\n"),
15895 (int) (2 + 2 * addr_size
), _("Start"),
15896 (int) (4 + 2 * addr_size
), _("End"),
15897 (int) (4 + 2 * addr_size
), _("Page Offset"));
15898 filenames
= descdata
+ count
* 3 * addr_size
;
15899 while (count
-- > 0)
15901 bfd_vma start
, end
, file_ofs
;
15903 if (filenames
== descend
)
15905 error (_(" Malformed note - filenames end too early\n"));
15909 start
= byte_get (descdata
, addr_size
);
15910 descdata
+= addr_size
;
15911 end
= byte_get (descdata
, addr_size
);
15912 descdata
+= addr_size
;
15913 file_ofs
= byte_get (descdata
, addr_size
);
15914 descdata
+= addr_size
;
15917 print_vma (start
, FULL_HEX
);
15919 print_vma (end
, FULL_HEX
);
15921 print_vma (file_ofs
, FULL_HEX
);
15922 printf ("\n %s\n", filenames
);
15924 filenames
+= 1 + strlen ((char *) filenames
);
15930 static const char *
15931 get_gnu_elf_note_type (unsigned e_type
)
15933 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15936 case NT_GNU_ABI_TAG
:
15937 return _("NT_GNU_ABI_TAG (ABI version tag)");
15939 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15940 case NT_GNU_BUILD_ID
:
15941 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15942 case NT_GNU_GOLD_VERSION
:
15943 return _("NT_GNU_GOLD_VERSION (gold version)");
15944 case NT_GNU_PROPERTY_TYPE_0
:
15945 return _("NT_GNU_PROPERTY_TYPE_0");
15946 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
15947 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15948 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
15949 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15952 static char buff
[64];
15954 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15961 decode_x86_isa (unsigned int bitmask
)
15965 unsigned int bit
= bitmask
& (- bitmask
);
15970 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
15971 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
15972 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
15973 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
15974 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
15975 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
15976 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
15977 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
15978 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
15979 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
15980 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
15981 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
15982 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
15983 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
15984 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
15985 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
15986 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
15987 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
15988 default: printf (_("<unknown: %x>"), bit
); break;
15996 print_gnu_property_note (Elf_Internal_Note
* pnote
)
15998 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
15999 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16000 unsigned int size
= is_32bit_elf
? 4 : 8;
16002 printf (_(" Properties: "));
16004 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16006 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16013 unsigned int type
= byte_get (ptr
, 4);
16014 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16018 if ((ptr
+ datasz
) > ptr_end
)
16020 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16025 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16027 if (elf_header
.e_machine
== EM_X86_64
16028 || elf_header
.e_machine
== EM_IAMCU
16029 || elf_header
.e_machine
== EM_386
)
16033 case GNU_PROPERTY_X86_ISA_1_USED
:
16034 printf ("x86 ISA used: ");
16036 printf (_("<corrupt length: %#x> "), datasz
);
16038 decode_x86_isa (byte_get (ptr
, 4));
16041 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16042 printf ("x86 ISA needed: ");
16044 printf (_("<corrupt length: %#x> "), datasz
);
16046 decode_x86_isa (byte_get (ptr
, 4));
16058 case GNU_PROPERTY_STACK_SIZE
:
16059 printf (_("stack size: "));
16060 if (datasz
!= size
)
16061 printf (_("<corrupt length: %#x> "), datasz
);
16063 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16066 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16067 printf ("no copy on protected ");
16069 printf (_("<corrupt length: %#x> "), datasz
);
16077 if (type
< GNU_PROPERTY_LOPROC
)
16078 printf (_("<unknown type %#x data: "), type
);
16079 else if (type
< GNU_PROPERTY_LOUSER
)
16080 printf (_("<procesor-specific type %#x data: "), type
);
16082 printf (_("<application-specific type %#x data: "), type
);
16083 for (j
= 0; j
< datasz
; ++j
)
16084 printf ("%02x ", ptr
[j
] & 0xff);
16088 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16089 if (ptr
== ptr_end
)
16099 if (ptr
> (ptr_end
- 8))
16101 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16110 print_gnu_note (Elf_Internal_Note
*pnote
)
16112 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16113 switch (pnote
->type
)
16115 case NT_GNU_BUILD_ID
:
16119 printf (_(" Build ID: "));
16120 for (i
= 0; i
< pnote
->descsz
; ++i
)
16121 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16126 case NT_GNU_ABI_TAG
:
16128 unsigned long os
, major
, minor
, subminor
;
16129 const char *osname
;
16131 /* PR 17531: file: 030-599401-0.004. */
16132 if (pnote
->descsz
< 16)
16134 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16138 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16139 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16140 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16141 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16145 case GNU_ABI_TAG_LINUX
:
16148 case GNU_ABI_TAG_HURD
:
16151 case GNU_ABI_TAG_SOLARIS
:
16152 osname
= "Solaris";
16154 case GNU_ABI_TAG_FREEBSD
:
16155 osname
= "FreeBSD";
16157 case GNU_ABI_TAG_NETBSD
:
16160 case GNU_ABI_TAG_SYLLABLE
:
16161 osname
= "Syllable";
16163 case GNU_ABI_TAG_NACL
:
16167 osname
= "Unknown";
16171 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16172 major
, minor
, subminor
);
16176 case NT_GNU_GOLD_VERSION
:
16180 printf (_(" Version: "));
16181 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16182 printf ("%c", pnote
->descdata
[i
]);
16189 unsigned long num_entries
, mask
;
16191 /* Hardware capabilities information. Word 0 is the number of entries.
16192 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16193 is a series of entries, where each entry is a single byte followed
16194 by a nul terminated string. The byte gives the bit number to test
16195 if enabled in the bitmask. */
16196 printf (_(" Hardware Capabilities: "));
16197 if (pnote
->descsz
< 8)
16199 error (_("<corrupt GNU_HWCAP>\n"));
16202 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16203 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16204 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16205 /* FIXME: Add code to display the entries... */
16209 case NT_GNU_PROPERTY_TYPE_0
:
16210 print_gnu_property_note (pnote
);
16214 /* Handle unrecognised types. An error message should have already been
16215 created by get_gnu_elf_note_type(), so all that we need to do is to
16216 display the data. */
16220 printf (_(" Description data: "));
16221 for (i
= 0; i
< pnote
->descsz
; ++i
)
16222 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16231 static const char *
16232 get_v850_elf_note_type (enum v850_notes n_type
)
16234 static char buff
[64];
16238 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16239 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16240 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16241 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16242 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16243 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16245 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16251 print_v850_note (Elf_Internal_Note
* pnote
)
16255 if (pnote
->descsz
!= 4)
16258 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16262 printf (_("not set\n"));
16266 switch (pnote
->type
)
16268 case V850_NOTE_ALIGNMENT
:
16271 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16272 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16276 case V850_NOTE_DATA_SIZE
:
16279 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16280 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16284 case V850_NOTE_FPU_INFO
:
16287 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16288 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16292 case V850_NOTE_MMU_INFO
:
16293 case V850_NOTE_CACHE_INFO
:
16294 case V850_NOTE_SIMD_INFO
:
16295 if (val
== EF_RH850_SIMD
)
16297 printf (_("yes\n"));
16303 /* An 'unknown note type' message will already have been displayed. */
16307 printf (_("unknown value: %x\n"), val
);
16312 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16314 unsigned int version
;
16316 switch (pnote
->type
)
16318 case NT_NETBSD_IDENT
:
16319 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16320 if ((version
/ 10000) % 100)
16321 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16322 version
, version
/ 100000000, (version
/ 1000000) % 100,
16323 (version
/ 10000) % 100 > 26 ? "Z" : "",
16324 'A' + (version
/ 10000) % 26);
16326 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16327 version
, version
/ 100000000, (version
/ 1000000) % 100,
16328 (version
/ 100) % 100);
16331 case NT_NETBSD_MARCH
:
16332 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16337 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16343 static const char *
16344 get_freebsd_elfcore_note_type (unsigned e_type
)
16348 case NT_FREEBSD_THRMISC
:
16349 return _("NT_THRMISC (thrmisc structure)");
16350 case NT_FREEBSD_PROCSTAT_PROC
:
16351 return _("NT_PROCSTAT_PROC (proc data)");
16352 case NT_FREEBSD_PROCSTAT_FILES
:
16353 return _("NT_PROCSTAT_FILES (files data)");
16354 case NT_FREEBSD_PROCSTAT_VMMAP
:
16355 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16356 case NT_FREEBSD_PROCSTAT_GROUPS
:
16357 return _("NT_PROCSTAT_GROUPS (groups data)");
16358 case NT_FREEBSD_PROCSTAT_UMASK
:
16359 return _("NT_PROCSTAT_UMASK (umask data)");
16360 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16361 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16362 case NT_FREEBSD_PROCSTAT_OSREL
:
16363 return _("NT_PROCSTAT_OSREL (osreldate data)");
16364 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16365 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16366 case NT_FREEBSD_PROCSTAT_AUXV
:
16367 return _("NT_PROCSTAT_AUXV (auxv data)");
16369 return get_note_type (e_type
);
16372 static const char *
16373 get_netbsd_elfcore_note_type (unsigned e_type
)
16375 static char buff
[64];
16377 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16379 /* NetBSD core "procinfo" structure. */
16380 return _("NetBSD procinfo structure");
16383 /* As of Jan 2002 there are no other machine-independent notes
16384 defined for NetBSD core files. If the note type is less
16385 than the start of the machine-dependent note types, we don't
16388 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16390 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16394 switch (elf_header
.e_machine
)
16396 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16397 and PT_GETFPREGS == mach+2. */
16402 case EM_SPARC32PLUS
:
16406 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16407 return _("PT_GETREGS (reg structure)");
16408 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16409 return _("PT_GETFPREGS (fpreg structure)");
16415 /* On all other arch's, PT_GETREGS == mach+1 and
16416 PT_GETFPREGS == mach+3. */
16420 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16421 return _("PT_GETREGS (reg structure)");
16422 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16423 return _("PT_GETFPREGS (fpreg structure)");
16429 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16430 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16434 static const char *
16435 get_stapsdt_note_type (unsigned e_type
)
16437 static char buff
[64];
16442 return _("NT_STAPSDT (SystemTap probe descriptors)");
16448 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16453 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16455 int addr_size
= is_32bit_elf
? 4 : 8;
16456 char *data
= pnote
->descdata
;
16457 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16458 bfd_vma pc
, base_addr
, semaphore
;
16459 char *provider
, *probe
, *arg_fmt
;
16461 pc
= byte_get ((unsigned char *) data
, addr_size
);
16463 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16465 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16469 data
+= strlen (data
) + 1;
16471 data
+= strlen (data
) + 1;
16473 data
+= strlen (data
) + 1;
16475 printf (_(" Provider: %s\n"), provider
);
16476 printf (_(" Name: %s\n"), probe
);
16477 printf (_(" Location: "));
16478 print_vma (pc
, FULL_HEX
);
16479 printf (_(", Base: "));
16480 print_vma (base_addr
, FULL_HEX
);
16481 printf (_(", Semaphore: "));
16482 print_vma (semaphore
, FULL_HEX
);
16484 printf (_(" Arguments: %s\n"), arg_fmt
);
16486 return data
== data_end
;
16489 static const char *
16490 get_ia64_vms_note_type (unsigned e_type
)
16492 static char buff
[64];
16497 return _("NT_VMS_MHD (module header)");
16499 return _("NT_VMS_LNM (language name)");
16501 return _("NT_VMS_SRC (source files)");
16503 return "NT_VMS_TITLE";
16505 return _("NT_VMS_EIDC (consistency check)");
16506 case NT_VMS_FPMODE
:
16507 return _("NT_VMS_FPMODE (FP mode)");
16508 case NT_VMS_LINKTIME
:
16509 return "NT_VMS_LINKTIME";
16510 case NT_VMS_IMGNAM
:
16511 return _("NT_VMS_IMGNAM (image name)");
16513 return _("NT_VMS_IMGID (image id)");
16514 case NT_VMS_LINKID
:
16515 return _("NT_VMS_LINKID (link id)");
16516 case NT_VMS_IMGBID
:
16517 return _("NT_VMS_IMGBID (build id)");
16518 case NT_VMS_GSTNAM
:
16519 return _("NT_VMS_GSTNAM (sym table name)");
16520 case NT_VMS_ORIG_DYN
:
16521 return "NT_VMS_ORIG_DYN";
16522 case NT_VMS_PATCHTIME
:
16523 return "NT_VMS_PATCHTIME";
16525 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16531 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16533 switch (pnote
->type
)
16536 if (pnote
->descsz
> 36)
16538 size_t l
= strlen (pnote
->descdata
+ 34);
16539 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16540 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16541 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16542 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16545 printf (_(" Invalid size\n"));
16548 printf (_(" Language: %s\n"), pnote
->descdata
);
16551 case NT_VMS_FPMODE
:
16552 printf (_(" Floating Point mode: "));
16553 printf ("0x%016" BFD_VMA_FMT
"x\n",
16554 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16556 case NT_VMS_LINKTIME
:
16557 printf (_(" Link time: "));
16559 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16562 case NT_VMS_PATCHTIME
:
16563 printf (_(" Patch time: "));
16565 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16568 case NT_VMS_ORIG_DYN
:
16569 printf (_(" Major id: %u, minor id: %u\n"),
16570 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16571 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16572 printf (_(" Last modified : "));
16574 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16575 printf (_("\n Link flags : "));
16576 printf ("0x%016" BFD_VMA_FMT
"x\n",
16577 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16578 printf (_(" Header flags: 0x%08x\n"),
16579 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16580 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16583 case NT_VMS_IMGNAM
:
16584 printf (_(" Image name: %s\n"), pnote
->descdata
);
16586 case NT_VMS_GSTNAM
:
16587 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16590 printf (_(" Image id: %s\n"), pnote
->descdata
);
16592 case NT_VMS_LINKID
:
16593 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16602 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
16604 Elf_Internal_Shdr
* section ATTRIBUTE_UNUSED
)
16606 static unsigned long global_offset
= 0;
16608 unsigned long strtab_size
= 0;
16609 char * strtab
= NULL
;
16610 Elf_Internal_Sym
* symtab
= NULL
;
16611 unsigned long nsyms
= 0;
16612 Elf_Internal_Shdr
* symsec
= NULL
;
16613 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
16615 if (pnote
->descsz
== 0)
16617 printf (_(" Applies from offset %#lx\n"), global_offset
);
16621 if (pnote
->descsz
!= desc_size
)
16623 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
16624 printf (_(" <invalid descsz>"));
16628 /* Load the symbols. */
16629 for (symsec
= section_headers
;
16630 symsec
< section_headers
+ elf_header
.e_shnum
;
16633 if (symsec
->sh_type
== SHT_SYMTAB
)
16635 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
16637 if (symsec
->sh_link
< elf_header
.e_shnum
)
16639 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
16641 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
16642 1, strtab_sec
->sh_size
,
16643 _("string table"));
16644 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
16649 printf (_(" Applies from offset"));
16651 for (i
= 0; i
< pnote
->descsz
; i
+= desc_size
)
16653 Elf_Internal_Sym
* saved_sym
= NULL
;
16654 Elf_Internal_Sym
* sym
;
16655 unsigned long offset
;
16657 offset
= byte_get ((unsigned char *) pnote
->descdata
+ i
, desc_size
);
16659 if (i
+ desc_size
== pnote
->descsz
)
16660 printf (_(" %#lx"), offset
);
16662 printf (_(" %#lx, "), offset
);
16664 if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
)
16665 global_offset
= offset
;
16667 if (symtab
== NULL
|| strtab
== NULL
)
16670 /* Find a symbol whose value matches offset. */
16671 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
16672 if (sym
->st_value
== offset
)
16674 if (sym
->st_name
< strtab_size
)
16676 if (strtab
[sym
->st_name
] == 0)
16679 if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
)
16681 /* For OPEN attributes we prefer GLOBAL symbols, if there
16682 is one that matches. But keep a record of a matching
16683 LOCAL symbol, just in case that is all that we can find. */
16684 if (ELF_ST_BIND (sym
->st_info
) == STB_LOCAL
)
16689 printf (_(" (file: %s)"), strtab
+ sym
->st_name
);
16691 else if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
16694 printf (_(" (function: %s)"), strtab
+ sym
->st_name
);
16699 if (sym
== symtab
+ nsyms
)
16702 printf (_(" (file: %s)"), strtab
+ saved_sym
->st_name
);
16704 printf (_(" (<symbol name unknown>)"));
16713 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
16716 char name_attribute
;
16717 char * expected_types
;
16718 const char * name
= pnote
->namedata
;
16722 if (name
== NULL
|| pnote
->namesz
< 2)
16724 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
16725 print_symbol (-20, _(" <corrupt name field>"));
16729 switch ((name_type
= * name
))
16731 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
16732 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
16733 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
16734 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
16735 printf ("%c", * name
);
16738 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
16739 print_symbol (-20, _("<unknown name type>"));
16747 switch ((name_attribute
= * name
))
16749 case GNU_BUILD_ATTRIBUTE_VERSION
:
16750 text
= _("<version>");
16751 expected_types
= "$";
16754 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
16755 text
= _("<stack prot>");
16756 expected_types
= "!+";
16759 case GNU_BUILD_ATTRIBUTE_RELRO
:
16760 text
= _("<relro>");
16761 expected_types
= "!+";
16764 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
16765 text
= _("<stack size>");
16766 expected_types
= "*";
16769 case GNU_BUILD_ATTRIBUTE_TOOL
:
16770 text
= _("<tool>");
16771 expected_types
= "$";
16774 case GNU_BUILD_ATTRIBUTE_ABI
:
16776 expected_types
= "$*";
16779 case GNU_BUILD_ATTRIBUTE_PIC
:
16781 expected_types
= "*";
16786 if (ISPRINT (* name
))
16788 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
16790 if (len
> left
&& ! do_wide
)
16792 printf ("%.*s ", len
, name
);
16798 error (_("unexpected character in name field\n"));
16799 print_symbol (- left
, _("<unknown attribute>"));
16802 expected_types
= "*$!+";
16808 printf ("%s", text
);
16809 left
-= strlen (text
);
16812 if (strchr (expected_types
, name_type
) == NULL
)
16813 warn (_("attribute does not have the expected type\n"));
16815 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
16817 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
16818 (unsigned long) pnote
->namesz
,
16819 (long) (name
- pnote
->namedata
));
16823 if (left
< 1 && ! do_wide
)
16828 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
16830 unsigned int bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
16831 unsigned long val
= 0;
16832 unsigned int shift
= 0;
16836 unsigned long byte
= (* name
++) & 0xff;
16838 val
|= byte
<< shift
;
16842 if (name_attribute
== GNU_BUILD_ATTRIBUTE_PIC
)
16844 char * pic_type
= NULL
;
16848 case 0: pic_type
= "static"; break;
16849 case 1: pic_type
= "pic"; break;
16850 case 2: pic_type
= "PIC"; break;
16851 case 3: pic_type
= "pie"; break;
16852 case 4: pic_type
= "PIE"; break;
16855 if (pic_type
!= NULL
)
16858 left
-= printf ("%s", pic_type
);
16860 left
-= printf ("%-.*s", left
, pic_type
);
16866 left
-= printf ("0x%lx", val
);
16868 left
-= printf ("0x%-.*lx", left
, val
);
16871 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
16872 left
-= print_symbol (- left
, name
);
16874 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
16875 left
-= print_symbol (- left
, "true");
16877 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
16878 left
-= print_symbol (- left
, "false");
16882 if (do_wide
&& left
> 0)
16883 printf ("%-*s", left
, " ");
16888 /* Note that by the ELF standard, the name field is already null byte
16889 terminated, and namesz includes the terminating null byte.
16890 I.E. the value of namesz for the name "FSF" is 4.
16892 If the value of namesz is zero, there is no name present. */
16895 process_note (Elf_Internal_Note
* pnote
,
16897 Elf_Internal_Shdr
* section
)
16899 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16902 if (pnote
->namesz
== 0)
16903 /* If there is no note name, then use the default set of
16904 note type strings. */
16905 nt
= get_note_type (pnote
->type
);
16907 else if (const_strneq (pnote
->namedata
, "GNU"))
16908 /* GNU-specific object file notes. */
16909 nt
= get_gnu_elf_note_type (pnote
->type
);
16911 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16912 /* FreeBSD-specific core file notes. */
16913 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16915 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16916 /* NetBSD-specific core file notes. */
16917 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
16919 else if (const_strneq (pnote
->namedata
, "NetBSD"))
16920 /* NetBSD-specific core file notes. */
16921 return process_netbsd_elf_note (pnote
);
16923 else if (strneq (pnote
->namedata
, "SPU/", 4))
16925 /* SPU-specific core file notes. */
16926 nt
= pnote
->namedata
+ 4;
16930 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16931 /* VMS/ia64-specific file notes. */
16932 nt
= get_ia64_vms_note_type (pnote
->type
);
16934 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16935 nt
= get_stapsdt_note_type (pnote
->type
);
16938 /* Don't recognize this note name; just use the default set of
16939 note type strings. */
16940 nt
= get_note_type (pnote
->type
);
16944 if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
16945 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
16946 print_gnu_build_attribute_name (pnote
);
16948 print_symbol (-20, name
);
16951 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
16953 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
16955 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16956 return print_ia64_vms_note (pnote
);
16957 else if (const_strneq (pnote
->namedata
, "GNU"))
16958 return print_gnu_note (pnote
);
16959 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16960 return print_stapsdt_note (pnote
);
16961 else if (const_strneq (pnote
->namedata
, "CORE"))
16962 return print_core_note (pnote
);
16963 else if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
16964 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
16965 return print_gnu_build_attribute_description (pnote
, file
, section
);
16971 printf (_(" description data: "));
16972 for (i
= 0; i
< pnote
->descsz
; i
++)
16973 printf ("%02x ", pnote
->descdata
[i
]);
16983 process_notes_at (FILE * file
,
16984 Elf_Internal_Shdr
* section
,
16988 Elf_External_Note
* pnotes
;
16989 Elf_External_Note
* external
;
16991 bfd_boolean res
= TRUE
;
16998 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17001 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17006 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17008 if (pnotes
== NULL
)
17014 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17016 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17017 (unsigned long) offset
, (unsigned long) length
);
17019 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17021 end
= (char *) pnotes
+ length
;
17022 while ((char *) external
< end
)
17024 Elf_Internal_Note inote
;
17027 char * temp
= NULL
;
17028 size_t data_remaining
= end
- (char *) external
;
17030 if (!is_ia64_vms ())
17032 /* PR binutils/15191
17033 Make sure that there is enough data to read. */
17034 min_notesz
= offsetof (Elf_External_Note
, name
);
17035 if (data_remaining
< min_notesz
)
17037 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17038 (int) data_remaining
);
17041 inote
.type
= BYTE_GET (external
->type
);
17042 inote
.namesz
= BYTE_GET (external
->namesz
);
17043 inote
.namedata
= external
->name
;
17044 inote
.descsz
= BYTE_GET (external
->descsz
);
17045 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17046 /* PR 17531: file: 3443835e. */
17047 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17049 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17050 inote
.namesz
, (long)(end
- inote
.namedata
));
17051 inote
.descdata
= inote
.namedata
;
17055 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17056 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17060 Elf64_External_VMS_Note
*vms_external
;
17062 /* PR binutils/15191
17063 Make sure that there is enough data to read. */
17064 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17065 if (data_remaining
< min_notesz
)
17067 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17068 (int) data_remaining
);
17072 vms_external
= (Elf64_External_VMS_Note
*) external
;
17073 inote
.type
= BYTE_GET (vms_external
->type
);
17074 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17075 inote
.namedata
= vms_external
->name
;
17076 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17077 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17078 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17079 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17082 if (inote
.descdata
< (char *) external
+ min_notesz
17083 || next
< (char *) external
+ min_notesz
17084 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17085 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17086 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17087 || data_remaining
< (size_t)(next
- (char *) external
))
17089 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17090 (unsigned long) ((char *) external
- (char *) pnotes
));
17091 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17092 inote
.type
, inote
.namesz
, inote
.descsz
);
17096 external
= (Elf_External_Note
*) next
;
17098 /* Verify that name is null terminated. It appears that at least
17099 one version of Linux (RedHat 6.0) generates corefiles that don't
17100 comply with the ELF spec by failing to include the null byte in
17102 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17104 temp
= (char *) malloc (inote
.namesz
+ 1);
17107 error (_("Out of memory allocating space for inote name\n"));
17112 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17113 temp
[inote
.namesz
] = 0;
17115 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17116 inote
.namedata
= temp
;
17119 if (! process_note (& inote
, file
, section
))
17135 process_corefile_note_segments (FILE * file
)
17137 Elf_Internal_Phdr
* segment
;
17139 bfd_boolean res
= TRUE
;
17141 if (! get_program_headers (file
))
17144 for (i
= 0, segment
= program_headers
;
17145 i
< elf_header
.e_phnum
;
17148 if (segment
->p_type
== PT_NOTE
)
17149 if (! process_notes_at (file
, NULL
,
17150 (bfd_vma
) segment
->p_offset
,
17151 (bfd_vma
) segment
->p_filesz
))
17159 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17161 Elf_External_Note
* pnotes
;
17162 Elf_External_Note
* external
;
17164 bfd_boolean res
= TRUE
;
17169 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17171 if (pnotes
== NULL
)
17175 end
= (char*) pnotes
+ length
;
17177 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17178 (unsigned long) offset
, (unsigned long) length
);
17180 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17182 Elf_External_Note
* next
;
17183 Elf_Internal_Note inote
;
17185 inote
.type
= BYTE_GET (external
->type
);
17186 inote
.namesz
= BYTE_GET (external
->namesz
);
17187 inote
.namedata
= external
->name
;
17188 inote
.descsz
= BYTE_GET (external
->descsz
);
17189 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17190 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17192 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17194 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17195 inote
.descdata
= inote
.namedata
;
17199 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17201 if ( ((char *) next
> end
)
17202 || ((char *) next
< (char *) pnotes
))
17204 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17205 (unsigned long) ((char *) external
- (char *) pnotes
));
17206 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17207 inote
.type
, inote
.namesz
, inote
.descsz
);
17213 /* Prevent out-of-bounds indexing. */
17214 if ( inote
.namedata
+ inote
.namesz
> end
17215 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17217 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17218 (unsigned long) ((char *) external
- (char *) pnotes
));
17219 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17220 inote
.type
, inote
.namesz
, inote
.descsz
);
17224 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17226 if (! print_v850_note (& inote
))
17229 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17230 inote
.namesz
, inote
.descsz
);
17240 process_note_sections (FILE * file
)
17242 Elf_Internal_Shdr
* section
;
17244 unsigned int n
= 0;
17245 bfd_boolean res
= TRUE
;
17247 for (i
= 0, section
= section_headers
;
17248 i
< elf_header
.e_shnum
&& section
!= NULL
;
17251 if (section
->sh_type
== SHT_NOTE
)
17253 if (! process_notes_at (file
, section
,
17254 (bfd_vma
) section
->sh_offset
,
17255 (bfd_vma
) section
->sh_size
))
17260 if (( elf_header
.e_machine
== EM_V800
17261 || elf_header
.e_machine
== EM_V850
17262 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17263 && section
->sh_type
== SHT_RENESAS_INFO
)
17265 if (! process_v850_notes (file
,
17266 (bfd_vma
) section
->sh_offset
,
17267 (bfd_vma
) section
->sh_size
))
17274 /* Try processing NOTE segments instead. */
17275 return process_corefile_note_segments (file
);
17281 process_notes (FILE * file
)
17283 /* If we have not been asked to display the notes then do nothing. */
17287 if (elf_header
.e_type
!= ET_CORE
)
17288 return process_note_sections (file
);
17290 /* No program headers means no NOTE segment. */
17291 if (elf_header
.e_phnum
> 0)
17292 return process_corefile_note_segments (file
);
17294 printf (_("No note segments present in the core file.\n"));
17298 static unsigned char *
17299 display_public_gnu_attributes (unsigned char * start
,
17300 const unsigned char * const end
)
17302 printf (_(" Unknown GNU attribute: %s\n"), start
);
17304 start
+= strnlen ((char *) start
, end
- start
);
17305 display_raw_attribute (start
, end
);
17307 return (unsigned char *) end
;
17310 static unsigned char *
17311 display_generic_attribute (unsigned char * start
,
17313 const unsigned char * const end
)
17316 return (unsigned char *) end
;
17318 return display_tag_value (tag
, start
, end
);
17322 process_arch_specific (FILE * file
)
17327 switch (elf_header
.e_machine
)
17330 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17331 display_arm_attribute
,
17332 display_generic_attribute
);
17335 case EM_MIPS_RS3_LE
:
17336 return process_mips_specific (file
);
17339 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17340 display_msp430x_attribute
,
17341 display_generic_attribute
);
17344 return process_nds32_specific (file
);
17348 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17349 display_power_gnu_attribute
);
17353 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17354 display_s390_gnu_attribute
);
17357 case EM_SPARC32PLUS
:
17359 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17360 display_sparc_gnu_attribute
);
17363 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17364 display_tic6x_attribute
,
17365 display_generic_attribute
);
17368 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17369 display_public_gnu_attributes
,
17370 display_generic_attribute
);
17375 get_file_header (FILE * file
)
17377 /* Read in the identity array. */
17378 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
17381 /* Determine how to read the rest of the header. */
17382 switch (elf_header
.e_ident
[EI_DATA
])
17387 byte_get
= byte_get_little_endian
;
17388 byte_put
= byte_put_little_endian
;
17391 byte_get
= byte_get_big_endian
;
17392 byte_put
= byte_put_big_endian
;
17396 /* For now we only support 32 bit and 64 bit ELF files. */
17397 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
17399 /* Read in the rest of the header. */
17402 Elf32_External_Ehdr ehdr32
;
17404 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
17407 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
17408 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
17409 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
17410 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
17411 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
17412 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
17413 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
17414 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
17415 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
17416 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
17417 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
17418 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
17419 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
17423 Elf64_External_Ehdr ehdr64
;
17425 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17426 we will not be able to cope with the 64bit data found in
17427 64 ELF files. Detect this now and abort before we start
17428 overwriting things. */
17429 if (sizeof (bfd_vma
) < 8)
17431 error (_("This instance of readelf has been built without support for a\n\
17432 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17436 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
17439 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
17440 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
17441 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
17442 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
17443 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
17444 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
17445 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
17446 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
17447 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
17448 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
17449 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
17450 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
17451 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
17454 if (elf_header
.e_shoff
)
17456 /* There may be some extensions in the first section header. Don't
17457 bomb if we can't read it. */
17459 get_32bit_section_headers (file
, TRUE
);
17461 get_64bit_section_headers (file
, TRUE
);
17467 /* Process one ELF object file according to the command line options.
17468 This file may actually be stored in an archive. The file is
17469 positioned at the start of the ELF object. Returns TRUE if no
17470 problems were encountered, FALSE otherwise. */
17473 process_object (char * file_name
, FILE * file
)
17476 bfd_boolean res
= TRUE
;
17478 if (! get_file_header (file
))
17480 error (_("%s: Failed to read file header\n"), file_name
);
17484 /* Initialise per file variables. */
17485 for (i
= ARRAY_SIZE (version_info
); i
--;)
17486 version_info
[i
] = 0;
17488 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
17489 dynamic_info
[i
] = 0;
17490 dynamic_info_DT_GNU_HASH
= 0;
17492 /* Process the file. */
17494 printf (_("\nFile: %s\n"), file_name
);
17496 /* Initialise the dump_sects array from the cmdline_dump_sects array.
17497 Note we do this even if cmdline_dump_sects is empty because we
17498 must make sure that the dump_sets array is zeroed out before each
17499 object file is processed. */
17500 if (num_dump_sects
> num_cmdline_dump_sects
)
17501 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
17503 if (num_cmdline_dump_sects
> 0)
17505 if (num_dump_sects
== 0)
17506 /* A sneaky way of allocating the dump_sects array. */
17507 request_dump_bynumber (num_cmdline_dump_sects
, 0);
17509 assert (num_dump_sects
>= num_cmdline_dump_sects
);
17510 memcpy (dump_sects
, cmdline_dump_sects
,
17511 num_cmdline_dump_sects
* sizeof (* dump_sects
));
17514 if (! process_file_header ())
17517 if (! process_section_headers (file
))
17519 /* Without loaded section headers we cannot process lots of things. */
17520 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
17522 if (! do_using_dynamic
)
17523 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
17526 if (! process_section_groups (file
))
17527 /* Without loaded section groups we cannot process unwind. */
17530 if (process_program_headers (file
))
17531 process_dynamic_section (file
);
17535 if (! process_relocs (file
))
17538 if (! process_unwind (file
))
17541 if (! process_symbol_table (file
))
17544 if (! process_syminfo (file
))
17547 if (! process_version_sections (file
))
17550 if (! process_section_contents (file
))
17553 if (! process_notes (file
))
17556 if (! process_gnu_liblist (file
))
17559 if (! process_arch_specific (file
))
17562 if (program_headers
)
17564 free (program_headers
);
17565 program_headers
= NULL
;
17568 if (section_headers
)
17570 free (section_headers
);
17571 section_headers
= NULL
;
17576 free (string_table
);
17577 string_table
= NULL
;
17578 string_table_length
= 0;
17581 if (dynamic_strings
)
17583 free (dynamic_strings
);
17584 dynamic_strings
= NULL
;
17585 dynamic_strings_length
= 0;
17588 if (dynamic_symbols
)
17590 free (dynamic_symbols
);
17591 dynamic_symbols
= NULL
;
17592 num_dynamic_syms
= 0;
17595 if (dynamic_syminfo
)
17597 free (dynamic_syminfo
);
17598 dynamic_syminfo
= NULL
;
17601 if (dynamic_section
)
17603 free (dynamic_section
);
17604 dynamic_section
= NULL
;
17607 if (section_headers_groups
)
17609 free (section_headers_groups
);
17610 section_headers_groups
= NULL
;
17613 if (section_groups
)
17615 struct group_list
* g
;
17616 struct group_list
* next
;
17618 for (i
= 0; i
< group_count
; i
++)
17620 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
17627 free (section_groups
);
17628 section_groups
= NULL
;
17631 free_debug_memory ();
17636 /* Process an ELF archive.
17637 On entry the file is positioned just after the ARMAG string.
17638 Returns TRUE upon success, FALSE otherwise. */
17641 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
17643 struct archive_info arch
;
17644 struct archive_info nested_arch
;
17646 bfd_boolean ret
= TRUE
;
17650 /* The ARCH structure is used to hold information about this archive. */
17651 arch
.file_name
= NULL
;
17653 arch
.index_array
= NULL
;
17654 arch
.sym_table
= NULL
;
17655 arch
.longnames
= NULL
;
17657 /* The NESTED_ARCH structure is used as a single-item cache of information
17658 about a nested archive (when members of a thin archive reside within
17659 another regular archive file). */
17660 nested_arch
.file_name
= NULL
;
17661 nested_arch
.file
= NULL
;
17662 nested_arch
.index_array
= NULL
;
17663 nested_arch
.sym_table
= NULL
;
17664 nested_arch
.longnames
= NULL
;
17666 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
17672 if (do_archive_index
)
17674 if (arch
.sym_table
== NULL
)
17675 error (_("%s: unable to dump the index as none was found\n"), file_name
);
17678 unsigned long i
, l
;
17679 unsigned long current_pos
;
17681 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17682 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
17683 current_pos
= ftell (file
);
17685 for (i
= l
= 0; i
< arch
.index_num
; i
++)
17687 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
17689 char * member_name
;
17691 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
17693 if (member_name
!= NULL
)
17695 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
17697 if (qualified_name
!= NULL
)
17699 printf (_("Contents of binary %s at offset "), qualified_name
);
17700 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
17702 free (qualified_name
);
17707 if (l
>= arch
.sym_size
)
17709 error (_("%s: end of the symbol table reached before the end of the index\n"),
17714 /* PR 17531: file: 0b6630b2. */
17715 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
17716 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
17719 if (arch
.uses_64bit_indicies
)
17724 if (l
< arch
.sym_size
)
17726 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17727 file_name
, arch
.sym_size
- l
);
17731 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
17733 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
17739 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
17740 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
17741 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
17742 && !do_section_groups
&& !do_dyn_syms
)
17744 ret
= TRUE
; /* Archive index only. */
17753 char * qualified_name
;
17755 /* Read the next archive header. */
17756 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
17758 error (_("%s: failed to seek to next archive header\n"), file_name
);
17761 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
17762 if (got
!= sizeof arch
.arhdr
)
17766 error (_("%s: failed to read archive header\n"), file_name
);
17770 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
17772 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
17777 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
17779 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
17780 if (archive_file_size
& 01)
17781 ++archive_file_size
;
17783 name
= get_archive_member_name (&arch
, &nested_arch
);
17786 error (_("%s: bad archive file name\n"), file_name
);
17790 namelen
= strlen (name
);
17792 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
17793 if (qualified_name
== NULL
)
17795 error (_("%s: bad archive file name\n"), file_name
);
17800 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
17802 /* This is a proxy for an external member of a thin archive. */
17803 FILE * member_file
;
17804 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
17806 if (member_file_name
== NULL
)
17812 member_file
= fopen (member_file_name
, "rb");
17813 if (member_file
== NULL
)
17815 error (_("Input file '%s' is not readable.\n"), member_file_name
);
17816 free (member_file_name
);
17821 archive_file_offset
= arch
.nested_member_origin
;
17823 if (! process_object (qualified_name
, member_file
))
17826 fclose (member_file
);
17827 free (member_file_name
);
17829 else if (is_thin_archive
)
17831 /* PR 15140: Allow for corrupt thin archives. */
17832 if (nested_arch
.file
== NULL
)
17834 error (_("%s: contains corrupt thin archive: %s\n"),
17840 /* This is a proxy for a member of a nested archive. */
17841 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
17843 /* The nested archive file will have been opened and setup by
17844 get_archive_member_name. */
17845 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17847 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17852 if (! process_object (qualified_name
, nested_arch
.file
))
17857 archive_file_offset
= arch
.next_arhdr_offset
;
17858 arch
.next_arhdr_offset
+= archive_file_size
;
17860 if (! process_object (qualified_name
, file
))
17864 if (dump_sects
!= NULL
)
17868 num_dump_sects
= 0;
17871 free (qualified_name
);
17875 if (nested_arch
.file
!= NULL
)
17876 fclose (nested_arch
.file
);
17877 release_archive (&nested_arch
);
17878 release_archive (&arch
);
17884 process_file (char * file_name
)
17887 struct stat statbuf
;
17888 char armag
[SARMAG
];
17889 bfd_boolean ret
= TRUE
;
17891 if (stat (file_name
, &statbuf
) < 0)
17893 if (errno
== ENOENT
)
17894 error (_("'%s': No such file\n"), file_name
);
17896 error (_("Could not locate '%s'. System error message: %s\n"),
17897 file_name
, strerror (errno
));
17901 if (! S_ISREG (statbuf
.st_mode
))
17903 error (_("'%s' is not an ordinary file\n"), file_name
);
17907 file
= fopen (file_name
, "rb");
17910 error (_("Input file '%s' is not readable.\n"), file_name
);
17914 if (fread (armag
, SARMAG
, 1, file
) != 1)
17916 error (_("%s: Failed to read file's magic number\n"), file_name
);
17921 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
17923 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
17925 if (! process_archive (file_name
, file
, FALSE
))
17928 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
17930 if ( ! process_archive (file_name
, file
, TRUE
))
17935 if (do_archive_index
)
17936 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17940 archive_file_size
= archive_file_offset
= 0;
17942 if (! process_object (file_name
, file
))
17947 current_file_size
= 0;
17952 #ifdef SUPPORT_DISASSEMBLY
17953 /* Needed by the i386 disassembler. For extra credit, someone could
17954 fix this so that we insert symbolic addresses here, esp for GOT/PLT
17958 print_address (unsigned int addr
, FILE * outfile
)
17960 fprintf (outfile
,"0x%8.8x", addr
);
17963 /* Needed by the i386 disassembler. */
17965 db_task_printsym (unsigned int addr
)
17967 print_address (addr
, stderr
);
17972 main (int argc
, char ** argv
)
17976 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17977 setlocale (LC_MESSAGES
, "");
17979 #if defined (HAVE_SETLOCALE)
17980 setlocale (LC_CTYPE
, "");
17982 bindtextdomain (PACKAGE
, LOCALEDIR
);
17983 textdomain (PACKAGE
);
17985 expandargv (&argc
, &argv
);
17987 parse_args (argc
, argv
);
17989 if (num_dump_sects
> 0)
17991 /* Make a copy of the dump_sects array. */
17992 cmdline_dump_sects
= (dump_type
*)
17993 malloc (num_dump_sects
* sizeof (* dump_sects
));
17994 if (cmdline_dump_sects
== NULL
)
17995 error (_("Out of memory allocating dump request table.\n"));
17998 memcpy (cmdline_dump_sects
, dump_sects
,
17999 num_dump_sects
* sizeof (* dump_sects
));
18000 num_cmdline_dump_sects
= num_dump_sects
;
18004 if (optind
< (argc
- 1))
18006 else if (optind
>= argc
)
18008 warn (_("Nothing to do.\n"));
18013 while (optind
< argc
)
18014 if (! process_file (argv
[optind
++]))
18017 if (dump_sects
!= NULL
)
18019 if (cmdline_dump_sects
!= NULL
)
18020 free (cmdline_dump_sects
);
18022 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;