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
;
5001 /* Try to locate the .dynamic section. If there is
5002 a section header table, we can easily locate it. */
5003 if (section_headers
!= NULL
)
5005 Elf_Internal_Shdr
* sec
;
5007 sec
= find_section (".dynamic");
5008 if (sec
== NULL
|| sec
->sh_size
== 0)
5010 /* A corresponding .dynamic section is expected, but on
5011 IA-64/OpenVMS it is OK for it to be missing. */
5012 if (!is_ia64_vms ())
5013 error (_("no .dynamic section in the dynamic segment\n"));
5017 if (sec
->sh_type
== SHT_NOBITS
)
5023 dynamic_addr
= sec
->sh_offset
;
5024 dynamic_size
= sec
->sh_size
;
5026 if (dynamic_addr
< segment
->p_offset
5027 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5028 warn (_("the .dynamic section is not contained"
5029 " within the dynamic segment\n"));
5030 else if (dynamic_addr
> segment
->p_offset
)
5031 warn (_("the .dynamic section is not the first section"
5032 " in the dynamic segment.\n"));
5035 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5036 segment. Check this after matching against the section headers
5037 so we don't warn on debuginfo file (which have NOBITS .dynamic
5039 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5041 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5042 dynamic_addr
= dynamic_size
= 0;
5047 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5049 error (_("Unable to find program interpreter name\n"));
5053 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5055 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5056 error (_("Internal error: failed to create format string to display program interpreter\n"));
5058 program_interpreter
[0] = 0;
5059 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5060 error (_("Unable to read program interpreter name\n"));
5063 printf (_(" [Requesting program interpreter: %s]\n"),
5064 program_interpreter
);
5070 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5072 printf (_("\n Section to Segment mapping:\n"));
5073 printf (_(" Segment Sections...\n"));
5075 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5078 Elf_Internal_Shdr
* section
;
5080 segment
= program_headers
+ i
;
5081 section
= section_headers
+ 1;
5083 printf (" %2.2d ", i
);
5085 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5087 if (!ELF_TBSS_SPECIAL (section
, segment
)
5088 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5089 printf ("%s ", printable_section_name (section
));
5100 /* Find the file offset corresponding to VMA by using the program headers. */
5103 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5105 Elf_Internal_Phdr
* seg
;
5107 if (! get_program_headers (file
))
5109 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5113 for (seg
= program_headers
;
5114 seg
< program_headers
+ elf_header
.e_phnum
;
5117 if (seg
->p_type
!= PT_LOAD
)
5120 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5121 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5122 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5125 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5126 (unsigned long) vma
);
5131 /* Allocate memory and load the sections headers into the global pointer
5132 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5133 generate any error messages if the load fails. */
5136 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5138 Elf32_External_Shdr
* shdrs
;
5139 Elf_Internal_Shdr
* internal
;
5141 unsigned int size
= elf_header
.e_shentsize
;
5142 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5144 /* PR binutils/17531: Cope with unexpected section header sizes. */
5145 if (size
== 0 || num
== 0)
5147 if (size
< sizeof * shdrs
)
5150 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5153 if (!probe
&& size
> sizeof * shdrs
)
5154 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5156 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5158 probe
? NULL
: _("section headers"));
5162 if (section_headers
!= NULL
)
5163 free (section_headers
);
5164 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5165 sizeof (Elf_Internal_Shdr
));
5166 if (section_headers
== NULL
)
5169 error (_("Out of memory reading %u section headers\n"), num
);
5173 for (i
= 0, internal
= section_headers
;
5177 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5178 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5179 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5180 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5181 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5182 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5183 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5184 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5185 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5186 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5187 if (!probe
&& internal
->sh_link
> num
)
5188 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5189 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5190 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5198 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5200 Elf64_External_Shdr
* shdrs
;
5201 Elf_Internal_Shdr
* internal
;
5203 unsigned int size
= elf_header
.e_shentsize
;
5204 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5206 /* PR binutils/17531: Cope with unexpected section header sizes. */
5207 if (size
== 0 || num
== 0)
5209 if (size
< sizeof * shdrs
)
5212 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5215 if (! probe
&& size
> sizeof * shdrs
)
5216 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5218 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5220 probe
? NULL
: _("section headers"));
5224 if (section_headers
!= NULL
)
5225 free (section_headers
);
5226 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5227 sizeof (Elf_Internal_Shdr
));
5228 if (section_headers
== NULL
)
5231 error (_("Out of memory reading %u section headers\n"), num
);
5235 for (i
= 0, internal
= section_headers
;
5239 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5240 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5241 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5242 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5243 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5244 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5245 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5246 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5247 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5248 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5249 if (!probe
&& internal
->sh_link
> num
)
5250 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5251 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5252 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5259 static Elf_Internal_Sym
*
5260 get_32bit_elf_symbols (FILE * file
,
5261 Elf_Internal_Shdr
* section
,
5262 unsigned long * num_syms_return
)
5264 unsigned long number
= 0;
5265 Elf32_External_Sym
* esyms
= NULL
;
5266 Elf_External_Sym_Shndx
* shndx
= NULL
;
5267 Elf_Internal_Sym
* isyms
= NULL
;
5268 Elf_Internal_Sym
* psym
;
5271 if (section
->sh_size
== 0)
5273 if (num_syms_return
!= NULL
)
5274 * num_syms_return
= 0;
5278 /* Run some sanity checks first. */
5279 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5281 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5282 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5286 if (section
->sh_size
> current_file_size
)
5288 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5289 printable_section_name (section
), (unsigned long) section
->sh_size
);
5293 number
= section
->sh_size
/ section
->sh_entsize
;
5295 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5297 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5298 (unsigned long) section
->sh_size
,
5299 printable_section_name (section
),
5300 (unsigned long) section
->sh_entsize
);
5304 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5305 section
->sh_size
, _("symbols"));
5310 elf_section_list
* entry
;
5313 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5314 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5316 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5317 entry
->hdr
->sh_offset
,
5318 1, entry
->hdr
->sh_size
,
5319 _("symbol table section indicies"));
5322 /* PR17531: file: heap-buffer-overflow */
5323 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5325 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5326 printable_section_name (entry
->hdr
),
5327 (unsigned long) entry
->hdr
->sh_size
,
5328 (unsigned long) section
->sh_size
);
5334 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5338 error (_("Out of memory reading %lu symbols\n"),
5339 (unsigned long) number
);
5343 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5345 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5346 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5347 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5348 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5349 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5351 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5352 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5353 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5354 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5355 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5364 if (num_syms_return
!= NULL
)
5365 * num_syms_return
= isyms
== NULL
? 0 : number
;
5370 static Elf_Internal_Sym
*
5371 get_64bit_elf_symbols (FILE * file
,
5372 Elf_Internal_Shdr
* section
,
5373 unsigned long * num_syms_return
)
5375 unsigned long number
= 0;
5376 Elf64_External_Sym
* esyms
= NULL
;
5377 Elf_External_Sym_Shndx
* shndx
= NULL
;
5378 Elf_Internal_Sym
* isyms
= NULL
;
5379 Elf_Internal_Sym
* psym
;
5382 if (section
->sh_size
== 0)
5384 if (num_syms_return
!= NULL
)
5385 * num_syms_return
= 0;
5389 /* Run some sanity checks first. */
5390 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5392 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5393 printable_section_name (section
),
5394 (unsigned long) section
->sh_entsize
);
5398 if (section
->sh_size
> current_file_size
)
5400 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5401 printable_section_name (section
),
5402 (unsigned long) section
->sh_size
);
5406 number
= section
->sh_size
/ section
->sh_entsize
;
5408 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5410 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5411 (unsigned long) section
->sh_size
,
5412 printable_section_name (section
),
5413 (unsigned long) section
->sh_entsize
);
5417 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5418 section
->sh_size
, _("symbols"));
5423 elf_section_list
* entry
;
5426 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5427 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5429 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5430 entry
->hdr
->sh_offset
,
5431 1, entry
->hdr
->sh_size
,
5432 _("symbol table section indicies"));
5435 /* PR17531: file: heap-buffer-overflow */
5436 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5438 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5439 printable_section_name (entry
->hdr
),
5440 (unsigned long) entry
->hdr
->sh_size
,
5441 (unsigned long) section
->sh_size
);
5447 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5451 error (_("Out of memory reading %lu symbols\n"),
5452 (unsigned long) number
);
5456 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5458 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5459 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5460 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5461 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5463 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5465 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5466 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5467 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5469 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5470 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5479 if (num_syms_return
!= NULL
)
5480 * num_syms_return
= isyms
== NULL
? 0 : number
;
5486 get_elf_section_flags (bfd_vma sh_flags
)
5488 static char buff
[1024];
5490 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5492 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5493 bfd_vma os_flags
= 0;
5494 bfd_vma proc_flags
= 0;
5495 bfd_vma unknown_flags
= 0;
5503 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5504 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5505 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5506 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5507 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5508 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5509 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5510 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5511 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5512 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5513 /* IA-64 specific. */
5514 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5515 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5516 /* IA-64 OpenVMS specific. */
5517 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5518 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5519 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5520 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5521 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5522 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5524 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5525 /* SPARC specific. */
5526 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5527 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5529 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5530 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5531 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5534 if (do_section_details
)
5536 sprintf (buff
, "[%*.*lx]: ",
5537 field_size
, field_size
, (unsigned long) sh_flags
);
5538 p
+= field_size
+ 4;
5545 flag
= sh_flags
& - sh_flags
;
5548 if (do_section_details
)
5552 case SHF_WRITE
: sindex
= 0; break;
5553 case SHF_ALLOC
: sindex
= 1; break;
5554 case SHF_EXECINSTR
: sindex
= 2; break;
5555 case SHF_MERGE
: sindex
= 3; break;
5556 case SHF_STRINGS
: sindex
= 4; break;
5557 case SHF_INFO_LINK
: sindex
= 5; break;
5558 case SHF_LINK_ORDER
: sindex
= 6; break;
5559 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5560 case SHF_GROUP
: sindex
= 8; break;
5561 case SHF_TLS
: sindex
= 9; break;
5562 case SHF_EXCLUDE
: sindex
= 18; break;
5563 case SHF_COMPRESSED
: sindex
= 20; break;
5567 switch (elf_header
.e_machine
)
5570 if (flag
== SHF_IA_64_SHORT
)
5572 else if (flag
== SHF_IA_64_NORECOV
)
5575 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5578 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5579 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5580 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5581 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5582 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5583 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5594 case EM_OLD_SPARCV9
:
5595 case EM_SPARC32PLUS
:
5598 if (flag
== SHF_ORDERED
)
5605 case SHF_ENTRYSECT
: sindex
= 21; break;
5606 case SHF_ARM_PURECODE
: sindex
= 22; break;
5607 case SHF_COMDEF
: sindex
= 23; break;
5619 if (p
!= buff
+ field_size
+ 4)
5621 if (size
< (10 + 2))
5623 warn (_("Internal error: not enough buffer room for section flag info"));
5624 return _("<unknown>");
5631 size
-= flags
[sindex
].len
;
5632 p
= stpcpy (p
, flags
[sindex
].str
);
5634 else if (flag
& SHF_MASKOS
)
5636 else if (flag
& SHF_MASKPROC
)
5639 unknown_flags
|= flag
;
5645 case SHF_WRITE
: *p
= 'W'; break;
5646 case SHF_ALLOC
: *p
= 'A'; break;
5647 case SHF_EXECINSTR
: *p
= 'X'; break;
5648 case SHF_MERGE
: *p
= 'M'; break;
5649 case SHF_STRINGS
: *p
= 'S'; break;
5650 case SHF_INFO_LINK
: *p
= 'I'; break;
5651 case SHF_LINK_ORDER
: *p
= 'L'; break;
5652 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5653 case SHF_GROUP
: *p
= 'G'; break;
5654 case SHF_TLS
: *p
= 'T'; break;
5655 case SHF_EXCLUDE
: *p
= 'E'; break;
5656 case SHF_COMPRESSED
: *p
= 'C'; break;
5659 if ((elf_header
.e_machine
== EM_X86_64
5660 || elf_header
.e_machine
== EM_L1OM
5661 || elf_header
.e_machine
== EM_K1OM
)
5662 && flag
== SHF_X86_64_LARGE
)
5664 else if (elf_header
.e_machine
== EM_ARM
5665 && flag
== SHF_ARM_PURECODE
)
5667 else if (flag
& SHF_MASKOS
)
5670 sh_flags
&= ~ SHF_MASKOS
;
5672 else if (flag
& SHF_MASKPROC
)
5675 sh_flags
&= ~ SHF_MASKPROC
;
5685 if (do_section_details
)
5689 size
-= 5 + field_size
;
5690 if (p
!= buff
+ field_size
+ 4)
5694 warn (_("Internal error: not enough buffer room for section flag info"));
5695 return _("<unknown>");
5701 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5702 (unsigned long) os_flags
);
5703 p
+= 5 + field_size
;
5707 size
-= 7 + field_size
;
5708 if (p
!= buff
+ field_size
+ 4)
5712 warn (_("Internal error: not enough buffer room for section flag info"));
5713 return _("<unknown>");
5719 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5720 (unsigned long) proc_flags
);
5721 p
+= 7 + field_size
;
5725 size
-= 10 + field_size
;
5726 if (p
!= buff
+ field_size
+ 4)
5730 warn (_("Internal error: not enough buffer room for section flag info"));
5731 return _("<unknown>");
5737 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5738 (unsigned long) unknown_flags
);
5739 p
+= 10 + field_size
;
5748 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5752 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5754 if (size
< sizeof (* echdr
))
5756 error (_("Compressed section is too small even for a compression header\n"));
5760 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5761 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5762 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5763 return sizeof (*echdr
);
5767 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5769 if (size
< sizeof (* echdr
))
5771 error (_("Compressed section is too small even for a compression header\n"));
5775 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5776 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5777 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5778 return sizeof (*echdr
);
5783 process_section_headers (FILE * file
)
5785 Elf_Internal_Shdr
* section
;
5788 section_headers
= NULL
;
5790 if (elf_header
.e_shnum
== 0)
5792 /* PR binutils/12467. */
5793 if (elf_header
.e_shoff
!= 0)
5795 warn (_("possibly corrupt ELF file header - it has a non-zero"
5796 " section header offset, but no section headers\n"));
5799 else if (do_sections
)
5800 printf (_("\nThere are no sections in this file.\n"));
5805 if (do_sections
&& !do_header
)
5806 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5807 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5811 if (! get_32bit_section_headers (file
, FALSE
))
5816 if (! get_64bit_section_headers (file
, FALSE
))
5820 /* Read in the string table, so that we have names to display. */
5821 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5822 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5824 section
= section_headers
+ elf_header
.e_shstrndx
;
5826 if (section
->sh_size
!= 0)
5828 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5829 1, section
->sh_size
,
5832 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5836 /* Scan the sections for the dynamic symbol table
5837 and dynamic string table and debug sections. */
5838 dynamic_symbols
= NULL
;
5839 dynamic_strings
= NULL
;
5840 dynamic_syminfo
= NULL
;
5841 symtab_shndx_list
= NULL
;
5843 eh_addr_size
= is_32bit_elf
? 4 : 8;
5844 switch (elf_header
.e_machine
)
5847 case EM_MIPS_RS3_LE
:
5848 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5849 FDE addresses. However, the ABI also has a semi-official ILP32
5850 variant for which the normal FDE address size rules apply.
5852 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5853 section, where XX is the size of longs in bits. Unfortunately,
5854 earlier compilers provided no way of distinguishing ILP32 objects
5855 from LP64 objects, so if there's any doubt, we should assume that
5856 the official LP64 form is being used. */
5857 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5858 && find_section (".gcc_compiled_long32") == NULL
)
5864 switch (elf_header
.e_flags
& EF_H8_MACH
)
5866 case E_H8_MACH_H8300
:
5867 case E_H8_MACH_H8300HN
:
5868 case E_H8_MACH_H8300SN
:
5869 case E_H8_MACH_H8300SXN
:
5872 case E_H8_MACH_H8300H
:
5873 case E_H8_MACH_H8300S
:
5874 case E_H8_MACH_H8300SX
:
5882 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5884 case EF_M32C_CPU_M16C
:
5891 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5894 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5895 if (section->sh_entsize != expected_entsize) \
5898 sprintf_vma (buf, section->sh_entsize); \
5899 /* Note: coded this way so that there is a single string for \
5901 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5902 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5903 (unsigned) expected_entsize); \
5904 section->sh_entsize = expected_entsize; \
5909 #define CHECK_ENTSIZE(section, i, type) \
5910 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5911 sizeof (Elf64_External_##type))
5913 for (i
= 0, section
= section_headers
;
5914 i
< elf_header
.e_shnum
;
5917 char * name
= SECTION_NAME (section
);
5919 if (section
->sh_type
== SHT_DYNSYM
)
5921 if (dynamic_symbols
!= NULL
)
5923 error (_("File contains multiple dynamic symbol tables\n"));
5927 CHECK_ENTSIZE (section
, i
, Sym
);
5928 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5930 else if (section
->sh_type
== SHT_STRTAB
5931 && streq (name
, ".dynstr"))
5933 if (dynamic_strings
!= NULL
)
5935 error (_("File contains multiple dynamic string tables\n"));
5939 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5940 1, section
->sh_size
,
5941 _("dynamic strings"));
5942 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5944 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5946 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5947 entry
->hdr
= section
;
5948 entry
->next
= symtab_shndx_list
;
5949 symtab_shndx_list
= entry
;
5951 else if (section
->sh_type
== SHT_SYMTAB
)
5952 CHECK_ENTSIZE (section
, i
, Sym
);
5953 else if (section
->sh_type
== SHT_GROUP
)
5954 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5955 else if (section
->sh_type
== SHT_REL
)
5956 CHECK_ENTSIZE (section
, i
, Rel
);
5957 else if (section
->sh_type
== SHT_RELA
)
5958 CHECK_ENTSIZE (section
, i
, Rela
);
5959 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5960 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5961 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5962 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5963 || do_debug_addr
|| do_debug_cu_index
)
5964 && (const_strneq (name
, ".debug_")
5965 || const_strneq (name
, ".zdebug_")))
5968 name
+= sizeof (".zdebug_") - 1;
5970 name
+= sizeof (".debug_") - 1;
5973 || (do_debug_info
&& const_strneq (name
, "info"))
5974 || (do_debug_info
&& const_strneq (name
, "types"))
5975 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5976 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5977 || (do_debug_lines
&& const_strneq (name
, "line."))
5978 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5979 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5980 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5981 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5982 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5983 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5984 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
5985 || (do_debug_frames
&& const_strneq (name
, "frame"))
5986 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5987 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5988 || (do_debug_str
&& const_strneq (name
, "str"))
5989 || (do_debug_loc
&& const_strneq (name
, "loc"))
5990 || (do_debug_loc
&& const_strneq (name
, "loclists"))
5991 || (do_debug_addr
&& const_strneq (name
, "addr"))
5992 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5993 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5995 request_dump_bynumber (i
, DEBUG_DUMP
);
5997 /* Linkonce section to be combined with .debug_info at link time. */
5998 else if ((do_debugging
|| do_debug_info
)
5999 && const_strneq (name
, ".gnu.linkonce.wi."))
6000 request_dump_bynumber (i
, DEBUG_DUMP
);
6001 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6002 request_dump_bynumber (i
, DEBUG_DUMP
);
6003 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
6004 request_dump_bynumber (i
, DEBUG_DUMP
);
6005 /* Trace sections for Itanium VMS. */
6006 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6007 || do_trace_aranges
)
6008 && const_strneq (name
, ".trace_"))
6010 name
+= sizeof (".trace_") - 1;
6013 || (do_trace_info
&& streq (name
, "info"))
6014 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6015 || (do_trace_aranges
&& streq (name
, "aranges"))
6017 request_dump_bynumber (i
, DEBUG_DUMP
);
6024 if (elf_header
.e_shnum
> 1)
6025 printf (_("\nSection Headers:\n"));
6027 printf (_("\nSection Header:\n"));
6031 if (do_section_details
)
6033 printf (_(" [Nr] Name\n"));
6034 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6038 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6042 if (do_section_details
)
6044 printf (_(" [Nr] Name\n"));
6045 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6049 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6053 if (do_section_details
)
6055 printf (_(" [Nr] Name\n"));
6056 printf (_(" Type Address Offset Link\n"));
6057 printf (_(" Size EntSize Info Align\n"));
6061 printf (_(" [Nr] Name Type Address Offset\n"));
6062 printf (_(" Size EntSize Flags Link Info Align\n"));
6066 if (do_section_details
)
6067 printf (_(" Flags\n"));
6069 for (i
= 0, section
= section_headers
;
6070 i
< elf_header
.e_shnum
;
6073 /* Run some sanity checks on the section header. */
6075 /* Check the sh_link field. */
6076 switch (section
->sh_type
)
6078 case SHT_SYMTAB_SHNDX
:
6082 case SHT_GNU_versym
:
6085 if (section
->sh_link
< 1
6086 || section
->sh_link
>= elf_header
.e_shnum
6087 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6088 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6089 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6090 i
, section
->sh_link
);
6096 case SHT_GNU_verneed
:
6097 case SHT_GNU_verdef
:
6098 case SHT_GNU_LIBLIST
:
6099 if (section
->sh_link
< 1
6100 || section
->sh_link
>= elf_header
.e_shnum
6101 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6102 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6103 i
, section
->sh_link
);
6106 case SHT_INIT_ARRAY
:
6107 case SHT_FINI_ARRAY
:
6108 case SHT_PREINIT_ARRAY
:
6109 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6110 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6111 i
, section
->sh_link
);
6115 /* FIXME: Add support for target specific section types. */
6116 #if 0 /* Currently we do not check other section types as there are too
6117 many special cases. Stab sections for example have a type
6118 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6120 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6121 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6122 i
, section
->sh_link
);
6127 /* Check the sh_info field. */
6128 switch (section
->sh_type
)
6132 if (section
->sh_info
< 1
6133 || section
->sh_info
>= elf_header
.e_shnum
6134 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6135 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6136 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6137 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6138 /* FIXME: Are other section types valid ? */
6139 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6141 if (section
->sh_info
== 0
6142 && (streq (SECTION_NAME (section
), ".rel.dyn")
6143 || streq (SECTION_NAME (section
), ".rela.dyn")))
6144 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6145 of zero. The relocations in these sections may apply
6146 to many different sections. */
6149 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6150 i
, section
->sh_info
);
6156 case SHT_SYMTAB_SHNDX
:
6157 case SHT_INIT_ARRAY
:
6158 case SHT_FINI_ARRAY
:
6159 case SHT_PREINIT_ARRAY
:
6160 if (section
->sh_info
!= 0)
6161 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6162 i
, section
->sh_info
);
6168 /* A symbol index - we assume that it is valid. */
6172 /* FIXME: Add support for target specific section types. */
6173 if (section
->sh_type
== SHT_NOBITS
)
6174 /* NOBITS section headers with non-zero sh_info fields can be
6175 created when a binary is stripped of everything but its debug
6176 information. The stripped sections have their headers
6177 preserved but their types set to SHT_NOBITS. So do not check
6178 this type of section. */
6180 else if (section
->sh_flags
& SHF_INFO_LINK
)
6182 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6183 warn (_("[%2u]: Expected link to another section in info field"), i
);
6185 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6186 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6187 i
, section
->sh_info
);
6191 printf (" [%2u] ", i
);
6192 if (do_section_details
)
6193 printf ("%s\n ", printable_section_name (section
));
6195 print_symbol (-17, SECTION_NAME (section
));
6197 printf (do_wide
? " %-15s " : " %-15.15s ",
6198 get_section_type_name (section
->sh_type
));
6202 const char * link_too_big
= NULL
;
6204 print_vma (section
->sh_addr
, LONG_HEX
);
6206 printf ( " %6.6lx %6.6lx %2.2lx",
6207 (unsigned long) section
->sh_offset
,
6208 (unsigned long) section
->sh_size
,
6209 (unsigned long) section
->sh_entsize
);
6211 if (do_section_details
)
6212 fputs (" ", stdout
);
6214 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6216 if (section
->sh_link
>= elf_header
.e_shnum
)
6219 /* The sh_link value is out of range. Normally this indicates
6220 an error but it can have special values in Solaris binaries. */
6221 switch (elf_header
.e_machine
)
6228 case EM_OLD_SPARCV9
:
6229 case EM_SPARC32PLUS
:
6232 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6233 link_too_big
= "BEFORE";
6234 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6235 link_too_big
= "AFTER";
6242 if (do_section_details
)
6244 if (link_too_big
!= NULL
&& * link_too_big
)
6245 printf ("<%s> ", link_too_big
);
6247 printf ("%2u ", section
->sh_link
);
6248 printf ("%3u %2lu\n", section
->sh_info
,
6249 (unsigned long) section
->sh_addralign
);
6252 printf ("%2u %3u %2lu\n",
6255 (unsigned long) section
->sh_addralign
);
6257 if (link_too_big
&& ! * link_too_big
)
6258 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6259 i
, section
->sh_link
);
6263 print_vma (section
->sh_addr
, LONG_HEX
);
6265 if ((long) section
->sh_offset
== section
->sh_offset
)
6266 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6270 print_vma (section
->sh_offset
, LONG_HEX
);
6273 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6274 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6278 print_vma (section
->sh_size
, LONG_HEX
);
6281 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6282 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6286 print_vma (section
->sh_entsize
, LONG_HEX
);
6289 if (do_section_details
)
6290 fputs (" ", stdout
);
6292 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6294 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6296 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6297 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6300 print_vma (section
->sh_addralign
, DEC
);
6304 else if (do_section_details
)
6306 printf (" %-15.15s ",
6307 get_section_type_name (section
->sh_type
));
6308 print_vma (section
->sh_addr
, LONG_HEX
);
6309 if ((long) section
->sh_offset
== section
->sh_offset
)
6310 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6314 print_vma (section
->sh_offset
, LONG_HEX
);
6316 printf (" %u\n ", section
->sh_link
);
6317 print_vma (section
->sh_size
, LONG_HEX
);
6319 print_vma (section
->sh_entsize
, LONG_HEX
);
6321 printf (" %-16u %lu\n",
6323 (unsigned long) section
->sh_addralign
);
6328 print_vma (section
->sh_addr
, LONG_HEX
);
6329 if ((long) section
->sh_offset
== section
->sh_offset
)
6330 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6334 print_vma (section
->sh_offset
, LONG_HEX
);
6337 print_vma (section
->sh_size
, LONG_HEX
);
6339 print_vma (section
->sh_entsize
, LONG_HEX
);
6341 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6343 printf (" %2u %3u %lu\n",
6346 (unsigned long) section
->sh_addralign
);
6349 if (do_section_details
)
6351 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6352 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6354 /* Minimum section size is 12 bytes for 32-bit compression
6355 header + 12 bytes for compressed data header. */
6356 unsigned char buf
[24];
6358 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6359 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6360 sizeof (buf
), _("compression header")))
6362 Elf_Internal_Chdr chdr
;
6364 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6366 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6369 printf (_(" [<unknown>: 0x%x], "),
6371 print_vma (chdr
.ch_size
, LONG_HEX
);
6372 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6378 if (!do_section_details
)
6380 /* The ordering of the letters shown here matches the ordering of the
6381 corresponding SHF_xxx values, and hence the order in which these
6382 letters will be displayed to the user. */
6383 printf (_("Key to Flags:\n\
6384 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6385 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6386 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6387 if (elf_header
.e_machine
== EM_X86_64
6388 || elf_header
.e_machine
== EM_L1OM
6389 || elf_header
.e_machine
== EM_K1OM
)
6390 printf (_("l (large), "));
6391 else if (elf_header
.e_machine
== EM_ARM
)
6392 printf (_("y (purecode), "));
6393 printf ("p (processor specific)\n");
6400 get_group_flags (unsigned int flags
)
6402 static char buff
[128];
6406 else if (flags
== GRP_COMDAT
)
6409 snprintf (buff
, 14, _("[0x%x: "), flags
);
6411 flags
&= ~ GRP_COMDAT
;
6412 if (flags
& GRP_MASKOS
)
6414 strcat (buff
, "<OS specific>");
6415 flags
&= ~ GRP_MASKOS
;
6418 if (flags
& GRP_MASKPROC
)
6420 strcat (buff
, "<PROC specific>");
6421 flags
&= ~ GRP_MASKPROC
;
6425 strcat (buff
, "<unknown>");
6432 process_section_groups (FILE * file
)
6434 Elf_Internal_Shdr
* section
;
6436 struct group
* group
;
6437 Elf_Internal_Shdr
* symtab_sec
;
6438 Elf_Internal_Shdr
* strtab_sec
;
6439 Elf_Internal_Sym
* symtab
;
6440 unsigned long num_syms
;
6444 /* Don't process section groups unless needed. */
6445 if (!do_unwind
&& !do_section_groups
)
6448 if (elf_header
.e_shnum
== 0)
6450 if (do_section_groups
)
6451 printf (_("\nThere are no sections to group in this file.\n"));
6456 if (section_headers
== NULL
)
6458 error (_("Section headers are not available!\n"));
6459 /* PR 13622: This can happen with a corrupt ELF header. */
6463 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6464 sizeof (struct group
*));
6466 if (section_headers_groups
== NULL
)
6468 error (_("Out of memory reading %u section group headers\n"),
6469 elf_header
.e_shnum
);
6473 /* Scan the sections for the group section. */
6475 for (i
= 0, section
= section_headers
;
6476 i
< elf_header
.e_shnum
;
6478 if (section
->sh_type
== SHT_GROUP
)
6481 if (group_count
== 0)
6483 if (do_section_groups
)
6484 printf (_("\nThere are no section groups in this file.\n"));
6489 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6491 if (section_groups
== NULL
)
6493 error (_("Out of memory reading %lu groups\n"),
6494 (unsigned long) group_count
);
6504 for (i
= 0, section
= section_headers
, group
= section_groups
;
6505 i
< elf_header
.e_shnum
;
6508 if (section
->sh_type
== SHT_GROUP
)
6510 const char * name
= printable_section_name (section
);
6511 const char * group_name
;
6512 unsigned char * start
;
6513 unsigned char * indices
;
6514 unsigned int entry
, j
, size
;
6515 Elf_Internal_Shdr
* sec
;
6516 Elf_Internal_Sym
* sym
;
6518 /* Get the symbol table. */
6519 if (section
->sh_link
>= elf_header
.e_shnum
6520 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6523 error (_("Bad sh_link in group section `%s'\n"), name
);
6527 if (symtab_sec
!= sec
)
6532 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6537 error (_("Corrupt header in group section `%s'\n"), name
);
6541 if (section
->sh_info
>= num_syms
)
6543 error (_("Bad sh_info in group section `%s'\n"), name
);
6547 sym
= symtab
+ section
->sh_info
;
6549 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6551 if (sym
->st_shndx
== 0
6552 || sym
->st_shndx
>= elf_header
.e_shnum
)
6554 error (_("Bad sh_info in group section `%s'\n"), name
);
6558 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6567 /* Get the string table. */
6568 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6577 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6583 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6584 1, strtab_sec
->sh_size
,
6586 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6588 group_name
= sym
->st_name
< strtab_size
6589 ? strtab
+ sym
->st_name
: _("<corrupt>");
6592 /* PR 17531: file: loop. */
6593 if (section
->sh_entsize
> section
->sh_size
)
6595 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6596 printable_section_name (section
),
6597 (unsigned long) section
->sh_entsize
,
6598 (unsigned long) section
->sh_size
);
6602 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6603 1, section
->sh_size
,
6609 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6610 entry
= byte_get (indices
, 4);
6613 if (do_section_groups
)
6615 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6616 get_group_flags (entry
), i
, name
, group_name
, size
);
6618 printf (_(" [Index] Name\n"));
6621 group
->group_index
= i
;
6623 for (j
= 0; j
< size
; j
++)
6625 struct group_list
* g
;
6627 entry
= byte_get (indices
, 4);
6630 if (entry
>= elf_header
.e_shnum
)
6632 static unsigned num_group_errors
= 0;
6634 if (num_group_errors
++ < 10)
6636 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6637 entry
, i
, elf_header
.e_shnum
- 1);
6638 if (num_group_errors
== 10)
6639 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6644 if (section_headers_groups
[entry
] != NULL
)
6648 static unsigned num_errs
= 0;
6650 if (num_errs
++ < 10)
6652 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6654 section_headers_groups
[entry
]->group_index
);
6656 warn (_("Further error messages about already contained group sections suppressed\n"));
6662 /* Intel C/C++ compiler may put section 0 in a
6663 section group. We just warn it the first time
6664 and ignore it afterwards. */
6665 static bfd_boolean warned
= FALSE
;
6668 error (_("section 0 in group section [%5u]\n"),
6669 section_headers_groups
[entry
]->group_index
);
6675 section_headers_groups
[entry
] = group
;
6677 if (do_section_groups
)
6679 sec
= section_headers
+ entry
;
6680 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6683 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6684 g
->section_index
= entry
;
6685 g
->next
= group
->root
;
6703 /* Data used to display dynamic fixups. */
6705 struct ia64_vms_dynfixup
6707 bfd_vma needed_ident
; /* Library ident number. */
6708 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6709 bfd_vma fixup_needed
; /* Index of the library. */
6710 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6711 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6714 /* Data used to display dynamic relocations. */
6716 struct ia64_vms_dynimgrela
6718 bfd_vma img_rela_cnt
; /* Number of relocations. */
6719 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6722 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6726 dump_ia64_vms_dynamic_fixups (FILE * file
,
6727 struct ia64_vms_dynfixup
* fixup
,
6728 const char * strtab
,
6729 unsigned int strtab_sz
)
6731 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6733 const char * lib_name
;
6735 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6736 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6737 _("dynamic section image fixups"));
6741 if (fixup
->needed
< strtab_sz
)
6742 lib_name
= strtab
+ fixup
->needed
;
6745 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6746 (unsigned long) fixup
->needed
);
6749 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6750 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6752 (_("Seg Offset Type SymVec DataType\n"));
6754 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6759 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6760 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6761 type
= BYTE_GET (imfs
[i
].type
);
6762 rtype
= elf_ia64_reloc_type (type
);
6764 printf (" 0x%08x ", type
);
6766 printf (" %-32s ", rtype
);
6767 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6768 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6775 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6778 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6780 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6783 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6784 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6785 _("dynamic section image relocations"));
6789 printf (_("\nImage relocs\n"));
6791 (_("Seg Offset Type Addend Seg Sym Off\n"));
6793 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6798 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6799 printf ("%08" BFD_VMA_FMT
"x ",
6800 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6801 type
= BYTE_GET (imrs
[i
].type
);
6802 rtype
= elf_ia64_reloc_type (type
);
6804 printf ("0x%08x ", type
);
6806 printf ("%-31s ", rtype
);
6807 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6808 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6809 printf ("%08" BFD_VMA_FMT
"x\n",
6810 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6817 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6820 process_ia64_vms_dynamic_relocs (FILE *file
)
6822 struct ia64_vms_dynfixup fixup
;
6823 struct ia64_vms_dynimgrela imgrela
;
6824 Elf_Internal_Dyn
*entry
;
6825 bfd_vma strtab_off
= 0;
6826 bfd_vma strtab_sz
= 0;
6827 char *strtab
= NULL
;
6828 bfd_boolean res
= TRUE
;
6830 memset (&fixup
, 0, sizeof (fixup
));
6831 memset (&imgrela
, 0, sizeof (imgrela
));
6833 /* Note: the order of the entries is specified by the OpenVMS specs. */
6834 for (entry
= dynamic_section
;
6835 entry
< dynamic_section
+ dynamic_nent
;
6838 switch (entry
->d_tag
)
6840 case DT_IA_64_VMS_STRTAB_OFFSET
:
6841 strtab_off
= entry
->d_un
.d_val
;
6844 strtab_sz
= entry
->d_un
.d_val
;
6846 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6847 1, strtab_sz
, _("dynamic string section"));
6850 case DT_IA_64_VMS_NEEDED_IDENT
:
6851 fixup
.needed_ident
= entry
->d_un
.d_val
;
6854 fixup
.needed
= entry
->d_un
.d_val
;
6856 case DT_IA_64_VMS_FIXUP_NEEDED
:
6857 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6859 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6860 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6862 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6863 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6864 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6867 case DT_IA_64_VMS_IMG_RELA_CNT
:
6868 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6870 case DT_IA_64_VMS_IMG_RELA_OFF
:
6871 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6872 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6894 dynamic_relocations
[] =
6896 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6897 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6898 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6901 /* Process the reloc section. */
6904 process_relocs (FILE * file
)
6906 unsigned long rel_size
;
6907 unsigned long rel_offset
;
6912 if (do_using_dynamic
)
6916 bfd_boolean has_dynamic_reloc
;
6919 has_dynamic_reloc
= FALSE
;
6921 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6923 is_rela
= dynamic_relocations
[i
].rela
;
6924 name
= dynamic_relocations
[i
].name
;
6925 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6926 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6929 has_dynamic_reloc
= TRUE
;
6931 if (is_rela
== UNKNOWN
)
6933 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6934 switch (dynamic_info
[DT_PLTREL
])
6948 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6949 name
, rel_offset
, rel_size
);
6951 dump_relocations (file
,
6952 offset_from_vma (file
, rel_offset
, rel_size
),
6954 dynamic_symbols
, num_dynamic_syms
,
6955 dynamic_strings
, dynamic_strings_length
,
6956 is_rela
, TRUE
/* is_dynamic */);
6961 if (process_ia64_vms_dynamic_relocs (file
))
6962 has_dynamic_reloc
= TRUE
;
6964 if (! has_dynamic_reloc
)
6965 printf (_("\nThere are no dynamic relocations in this file.\n"));
6969 Elf_Internal_Shdr
* section
;
6971 bfd_boolean found
= FALSE
;
6973 for (i
= 0, section
= section_headers
;
6974 i
< elf_header
.e_shnum
;
6977 if ( section
->sh_type
!= SHT_RELA
6978 && section
->sh_type
!= SHT_REL
)
6981 rel_offset
= section
->sh_offset
;
6982 rel_size
= section
->sh_size
;
6986 Elf_Internal_Shdr
* strsec
;
6989 printf (_("\nRelocation section "));
6991 if (string_table
== NULL
)
6992 printf ("%d", section
->sh_name
);
6994 printf ("'%s'", printable_section_name (section
));
6996 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6997 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6999 is_rela
= section
->sh_type
== SHT_RELA
;
7001 if (section
->sh_link
!= 0
7002 && section
->sh_link
< elf_header
.e_shnum
)
7004 Elf_Internal_Shdr
* symsec
;
7005 Elf_Internal_Sym
* symtab
;
7006 unsigned long nsyms
;
7007 unsigned long strtablen
= 0;
7008 char * strtab
= NULL
;
7010 symsec
= section_headers
+ section
->sh_link
;
7011 if (symsec
->sh_type
!= SHT_SYMTAB
7012 && symsec
->sh_type
!= SHT_DYNSYM
)
7015 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7020 if (symsec
->sh_link
!= 0
7021 && symsec
->sh_link
< elf_header
.e_shnum
)
7023 strsec
= section_headers
+ symsec
->sh_link
;
7025 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7028 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7031 dump_relocations (file
, rel_offset
, rel_size
,
7032 symtab
, nsyms
, strtab
, strtablen
,
7034 symsec
->sh_type
== SHT_DYNSYM
);
7040 dump_relocations (file
, rel_offset
, rel_size
,
7041 NULL
, 0, NULL
, 0, is_rela
,
7042 FALSE
/* is_dynamic */);
7049 printf (_("\nThere are no relocations in this file.\n"));
7055 /* An absolute address consists of a section and an offset. If the
7056 section is NULL, the offset itself is the address, otherwise, the
7057 address equals to LOAD_ADDRESS(section) + offset. */
7061 unsigned short section
;
7065 #define ABSADDR(a) \
7067 ? section_headers [(a).section].sh_addr + (a).offset \
7070 /* Find the nearest symbol at or below ADDR. Returns the symbol
7071 name, if found, and the offset from the symbol to ADDR. */
7074 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7075 unsigned long nsyms
,
7076 const char * strtab
,
7077 unsigned long strtab_size
,
7078 struct absaddr addr
,
7079 const char ** symname
,
7082 bfd_vma dist
= 0x100000;
7083 Elf_Internal_Sym
* sym
;
7084 Elf_Internal_Sym
* beg
;
7085 Elf_Internal_Sym
* end
;
7086 Elf_Internal_Sym
* best
= NULL
;
7088 REMOVE_ARCH_BITS (addr
.offset
);
7090 end
= symtab
+ nsyms
;
7096 sym
= beg
+ (end
- beg
) / 2;
7098 value
= sym
->st_value
;
7099 REMOVE_ARCH_BITS (value
);
7101 if (sym
->st_name
!= 0
7102 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7103 && addr
.offset
>= value
7104 && addr
.offset
- value
< dist
)
7107 dist
= addr
.offset
- value
;
7112 if (addr
.offset
< value
)
7120 *symname
= (best
->st_name
>= strtab_size
7121 ? _("<corrupt>") : strtab
+ best
->st_name
);
7127 *offset
= addr
.offset
;
7130 static /* signed */ int
7131 symcmp (const void *p
, const void *q
)
7133 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7134 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7136 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7139 /* Process the unwind section. */
7141 #include "unwind-ia64.h"
7143 struct ia64_unw_table_entry
7145 struct absaddr start
;
7147 struct absaddr info
;
7150 struct ia64_unw_aux_info
7152 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7153 unsigned long table_len
; /* Length of unwind table. */
7154 unsigned char * info
; /* Unwind info. */
7155 unsigned long info_size
; /* Size of unwind info. */
7156 bfd_vma info_addr
; /* Starting address of unwind info. */
7157 bfd_vma seg_base
; /* Starting address of segment. */
7158 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7159 unsigned long nsyms
; /* Number of symbols. */
7160 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7161 unsigned long nfuns
; /* Number of entries in funtab. */
7162 char * strtab
; /* The string table. */
7163 unsigned long strtab_size
; /* Size of string table. */
7167 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7169 struct ia64_unw_table_entry
* tp
;
7170 unsigned long j
, nfuns
;
7172 bfd_boolean res
= TRUE
;
7174 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7175 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7176 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7177 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7179 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7181 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7185 const unsigned char * dp
;
7186 const unsigned char * head
;
7187 const unsigned char * end
;
7188 const char * procname
;
7190 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7191 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7193 fputs ("\n<", stdout
);
7197 fputs (procname
, stdout
);
7200 printf ("+%lx", (unsigned long) offset
);
7203 fputs (">: [", stdout
);
7204 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7205 fputc ('-', stdout
);
7206 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7207 printf ("], info at +0x%lx\n",
7208 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7210 /* PR 17531: file: 86232b32. */
7211 if (aux
->info
== NULL
)
7214 /* PR 17531: file: 0997b4d1. */
7215 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7217 warn (_("Invalid offset %lx in table entry %ld\n"),
7218 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7223 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7224 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7226 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7227 (unsigned) UNW_VER (stamp
),
7228 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7229 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7230 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7231 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7233 if (UNW_VER (stamp
) != 1)
7235 printf (_("\tUnknown version.\n"));
7240 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7241 /* PR 17531: file: 16ceda89. */
7242 if (end
> aux
->info
+ aux
->info_size
)
7243 end
= aux
->info
+ aux
->info_size
;
7244 for (dp
= head
+ 8; dp
< end
;)
7245 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7254 slurp_ia64_unwind_table (FILE * file
,
7255 struct ia64_unw_aux_info
* aux
,
7256 Elf_Internal_Shdr
* sec
)
7258 unsigned long size
, nrelas
, i
;
7259 Elf_Internal_Phdr
* seg
;
7260 struct ia64_unw_table_entry
* tep
;
7261 Elf_Internal_Shdr
* relsec
;
7262 Elf_Internal_Rela
* rela
;
7263 Elf_Internal_Rela
* rp
;
7264 unsigned char * table
;
7266 Elf_Internal_Sym
* sym
;
7267 const char * relname
;
7271 /* First, find the starting address of the segment that includes
7274 if (elf_header
.e_phnum
)
7276 if (! get_program_headers (file
))
7279 for (seg
= program_headers
;
7280 seg
< program_headers
+ elf_header
.e_phnum
;
7283 if (seg
->p_type
!= PT_LOAD
)
7286 if (sec
->sh_addr
>= seg
->p_vaddr
7287 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7289 aux
->seg_base
= seg
->p_vaddr
;
7295 /* Second, build the unwind table from the contents of the unwind section: */
7296 size
= sec
->sh_size
;
7297 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7302 aux
->table_len
= size
/ (3 * eh_addr_size
);
7303 aux
->table
= (struct ia64_unw_table_entry
*)
7304 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7307 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7309 tep
->start
.section
= SHN_UNDEF
;
7310 tep
->end
.section
= SHN_UNDEF
;
7311 tep
->info
.section
= SHN_UNDEF
;
7312 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7313 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7314 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7315 tep
->start
.offset
+= aux
->seg_base
;
7316 tep
->end
.offset
+= aux
->seg_base
;
7317 tep
->info
.offset
+= aux
->seg_base
;
7321 /* Third, apply any relocations to the unwind table: */
7322 for (relsec
= section_headers
;
7323 relsec
< section_headers
+ elf_header
.e_shnum
;
7326 if (relsec
->sh_type
!= SHT_RELA
7327 || relsec
->sh_info
>= elf_header
.e_shnum
7328 || section_headers
+ relsec
->sh_info
!= sec
)
7331 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7340 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7342 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7343 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7345 /* PR 17531: file: 9fa67536. */
7346 if (relname
== NULL
)
7348 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7352 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7354 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7358 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7360 /* PR 17531: file: 5bc8d9bf. */
7361 if (i
>= aux
->table_len
)
7363 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7367 switch (rp
->r_offset
/ eh_addr_size
% 3)
7370 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7371 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7374 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7375 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7378 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7379 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7393 ia64_process_unwind (FILE * file
)
7395 Elf_Internal_Shdr
* sec
;
7396 Elf_Internal_Shdr
* unwsec
= NULL
;
7397 Elf_Internal_Shdr
* strsec
;
7398 unsigned long i
, unwcount
= 0, unwstart
= 0;
7399 struct ia64_unw_aux_info aux
;
7400 bfd_boolean res
= TRUE
;
7402 memset (& aux
, 0, sizeof (aux
));
7404 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7406 if (sec
->sh_type
== SHT_SYMTAB
7407 && sec
->sh_link
< elf_header
.e_shnum
)
7409 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7411 strsec
= section_headers
+ sec
->sh_link
;
7412 if (aux
.strtab
!= NULL
)
7414 error (_("Multiple auxillary string tables encountered\n"));
7418 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7421 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7423 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7428 printf (_("\nThere are no unwind sections in this file.\n"));
7430 while (unwcount
-- > 0)
7435 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7436 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7437 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7442 /* We have already counted the number of SHT_IA64_UNWIND
7443 sections so the loop above should never fail. */
7444 assert (unwsec
!= NULL
);
7447 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7449 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7451 /* We need to find which section group it is in. */
7452 struct group_list
* g
;
7454 if (section_headers_groups
== NULL
7455 || section_headers_groups
[i
] == NULL
)
7456 i
= elf_header
.e_shnum
;
7459 g
= section_headers_groups
[i
]->root
;
7461 for (; g
!= NULL
; g
= g
->next
)
7463 sec
= section_headers
+ g
->section_index
;
7465 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7470 i
= elf_header
.e_shnum
;
7473 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7475 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7476 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7477 suffix
= SECTION_NAME (unwsec
) + len
;
7478 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7480 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7481 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7486 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7487 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7488 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7489 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7491 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7492 suffix
= SECTION_NAME (unwsec
) + len
;
7493 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7495 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7496 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7500 if (i
== elf_header
.e_shnum
)
7502 printf (_("\nCould not find unwind info section for "));
7504 if (string_table
== NULL
)
7505 printf ("%d", unwsec
->sh_name
);
7507 printf ("'%s'", printable_section_name (unwsec
));
7511 aux
.info_addr
= sec
->sh_addr
;
7512 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7515 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7517 printf (_("\nUnwind section "));
7519 if (string_table
== NULL
)
7520 printf ("%d", unwsec
->sh_name
);
7522 printf ("'%s'", printable_section_name (unwsec
));
7524 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7525 (unsigned long) unwsec
->sh_offset
,
7526 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7528 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7529 && aux
.table_len
> 0)
7530 dump_ia64_unwind (& aux
);
7533 free ((char *) aux
.table
);
7535 free ((char *) aux
.info
);
7544 free ((char *) aux
.strtab
);
7549 struct hppa_unw_table_entry
7551 struct absaddr start
;
7553 unsigned int Cannot_unwind
:1; /* 0 */
7554 unsigned int Millicode
:1; /* 1 */
7555 unsigned int Millicode_save_sr0
:1; /* 2 */
7556 unsigned int Region_description
:2; /* 3..4 */
7557 unsigned int reserved1
:1; /* 5 */
7558 unsigned int Entry_SR
:1; /* 6 */
7559 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7560 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7561 unsigned int Args_stored
:1; /* 16 */
7562 unsigned int Variable_Frame
:1; /* 17 */
7563 unsigned int Separate_Package_Body
:1; /* 18 */
7564 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7565 unsigned int Stack_Overflow_Check
:1; /* 20 */
7566 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7567 unsigned int Ada_Region
:1; /* 22 */
7568 unsigned int cxx_info
:1; /* 23 */
7569 unsigned int cxx_try_catch
:1; /* 24 */
7570 unsigned int sched_entry_seq
:1; /* 25 */
7571 unsigned int reserved2
:1; /* 26 */
7572 unsigned int Save_SP
:1; /* 27 */
7573 unsigned int Save_RP
:1; /* 28 */
7574 unsigned int Save_MRP_in_frame
:1; /* 29 */
7575 unsigned int extn_ptr_defined
:1; /* 30 */
7576 unsigned int Cleanup_defined
:1; /* 31 */
7578 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7579 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7580 unsigned int Large_frame
:1; /* 2 */
7581 unsigned int Pseudo_SP_Set
:1; /* 3 */
7582 unsigned int reserved4
:1; /* 4 */
7583 unsigned int Total_frame_size
:27; /* 5..31 */
7586 struct hppa_unw_aux_info
7588 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7589 unsigned long table_len
; /* Length of unwind table. */
7590 bfd_vma seg_base
; /* Starting address of segment. */
7591 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7592 unsigned long nsyms
; /* Number of symbols. */
7593 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7594 unsigned long nfuns
; /* Number of entries in funtab. */
7595 char * strtab
; /* The string table. */
7596 unsigned long strtab_size
; /* Size of string table. */
7600 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7602 struct hppa_unw_table_entry
* tp
;
7603 unsigned long j
, nfuns
;
7604 bfd_boolean res
= TRUE
;
7606 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7607 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7608 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7609 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7611 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7613 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7616 const char * procname
;
7618 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7619 aux
->strtab_size
, tp
->start
, &procname
,
7622 fputs ("\n<", stdout
);
7626 fputs (procname
, stdout
);
7629 printf ("+%lx", (unsigned long) offset
);
7632 fputs (">: [", stdout
);
7633 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7634 fputc ('-', stdout
);
7635 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7638 #define PF(_m) if (tp->_m) printf (#_m " ");
7639 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7642 PF(Millicode_save_sr0
);
7643 /* PV(Region_description); */
7649 PF(Separate_Package_Body
);
7650 PF(Frame_Extension_Millicode
);
7651 PF(Stack_Overflow_Check
);
7652 PF(Two_Instruction_SP_Increment
);
7656 PF(sched_entry_seq
);
7659 PF(Save_MRP_in_frame
);
7660 PF(extn_ptr_defined
);
7661 PF(Cleanup_defined
);
7662 PF(MPE_XL_interrupt_marker
);
7663 PF(HP_UX_interrupt_marker
);
7666 PV(Total_frame_size
);
7679 slurp_hppa_unwind_table (FILE * file
,
7680 struct hppa_unw_aux_info
* aux
,
7681 Elf_Internal_Shdr
* sec
)
7683 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7684 Elf_Internal_Phdr
* seg
;
7685 struct hppa_unw_table_entry
* tep
;
7686 Elf_Internal_Shdr
* relsec
;
7687 Elf_Internal_Rela
* rela
;
7688 Elf_Internal_Rela
* rp
;
7689 unsigned char * table
;
7691 Elf_Internal_Sym
* sym
;
7692 const char * relname
;
7694 /* First, find the starting address of the segment that includes
7696 if (elf_header
.e_phnum
)
7698 if (! get_program_headers (file
))
7701 for (seg
= program_headers
;
7702 seg
< program_headers
+ elf_header
.e_phnum
;
7705 if (seg
->p_type
!= PT_LOAD
)
7708 if (sec
->sh_addr
>= seg
->p_vaddr
7709 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7711 aux
->seg_base
= seg
->p_vaddr
;
7717 /* Second, build the unwind table from the contents of the unwind
7719 size
= sec
->sh_size
;
7720 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7726 nentries
= size
/ unw_ent_size
;
7727 size
= unw_ent_size
* nentries
;
7729 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7730 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7732 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7734 unsigned int tmp1
, tmp2
;
7736 tep
->start
.section
= SHN_UNDEF
;
7737 tep
->end
.section
= SHN_UNDEF
;
7739 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7740 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7741 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7742 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7744 tep
->start
.offset
+= aux
->seg_base
;
7745 tep
->end
.offset
+= aux
->seg_base
;
7747 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7748 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7749 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7750 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7751 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7752 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7753 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7754 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7755 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7756 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7757 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7758 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7759 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7760 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7761 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7762 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7763 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7764 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7765 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7766 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7767 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7768 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7769 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7770 tep
->Cleanup_defined
= tmp1
& 0x1;
7772 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7773 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7774 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7775 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7776 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7777 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7781 /* Third, apply any relocations to the unwind table. */
7782 for (relsec
= section_headers
;
7783 relsec
< section_headers
+ elf_header
.e_shnum
;
7786 if (relsec
->sh_type
!= SHT_RELA
7787 || relsec
->sh_info
>= elf_header
.e_shnum
7788 || section_headers
+ relsec
->sh_info
!= sec
)
7791 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7795 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7797 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7798 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7800 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7801 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7803 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7807 i
= rp
->r_offset
/ unw_ent_size
;
7809 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7812 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7813 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7816 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7817 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7827 aux
->table_len
= nentries
;
7833 hppa_process_unwind (FILE * file
)
7835 struct hppa_unw_aux_info aux
;
7836 Elf_Internal_Shdr
* unwsec
= NULL
;
7837 Elf_Internal_Shdr
* strsec
;
7838 Elf_Internal_Shdr
* sec
;
7840 bfd_boolean res
= TRUE
;
7842 if (string_table
== NULL
)
7845 memset (& aux
, 0, sizeof (aux
));
7847 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7849 if (sec
->sh_type
== SHT_SYMTAB
7850 && sec
->sh_link
< elf_header
.e_shnum
)
7852 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7854 strsec
= section_headers
+ sec
->sh_link
;
7855 if (aux
.strtab
!= NULL
)
7857 error (_("Multiple auxillary string tables encountered\n"));
7861 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7864 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7866 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7871 printf (_("\nThere are no unwind sections in this file.\n"));
7873 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7875 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7877 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7878 printable_section_name (sec
),
7879 (unsigned long) sec
->sh_offset
,
7880 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7882 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7885 if (aux
.table_len
> 0)
7887 if (! dump_hppa_unwind (&aux
))
7892 free ((char *) aux
.table
);
7900 free ((char *) aux
.strtab
);
7907 unsigned char * data
; /* The unwind data. */
7908 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7909 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7910 unsigned long nrelas
; /* The number of relocations. */
7911 unsigned int rel_type
; /* REL or RELA ? */
7912 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7915 struct arm_unw_aux_info
7917 FILE * file
; /* The file containing the unwind sections. */
7918 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7919 unsigned long nsyms
; /* Number of symbols. */
7920 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7921 unsigned long nfuns
; /* Number of these symbols. */
7922 char * strtab
; /* The file's string table. */
7923 unsigned long strtab_size
; /* Size of string table. */
7927 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7928 bfd_vma fn
, struct absaddr addr
)
7930 const char *procname
;
7933 if (addr
.section
== SHN_UNDEF
)
7936 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7937 aux
->strtab_size
, addr
, &procname
,
7940 print_vma (fn
, PREFIX_HEX
);
7944 fputs (" <", stdout
);
7945 fputs (procname
, stdout
);
7948 printf ("+0x%lx", (unsigned long) sym_offset
);
7949 fputc ('>', stdout
);
7956 arm_free_section (struct arm_section
*arm_sec
)
7958 if (arm_sec
->data
!= NULL
)
7959 free (arm_sec
->data
);
7961 if (arm_sec
->rela
!= NULL
)
7962 free (arm_sec
->rela
);
7965 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7966 cached section and install SEC instead.
7967 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7968 and return its valued in * WORDP, relocating if necessary.
7969 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7970 relocation's offset in ADDR.
7971 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7972 into the string table of the symbol associated with the reloc. If no
7973 reloc was applied store -1 there.
7974 5) Return TRUE upon success, FALSE otherwise. */
7977 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7978 struct arm_section
* arm_sec
,
7979 Elf_Internal_Shdr
* sec
,
7980 bfd_vma word_offset
,
7981 unsigned int * wordp
,
7982 struct absaddr
* addr
,
7985 Elf_Internal_Rela
*rp
;
7986 Elf_Internal_Sym
*sym
;
7987 const char * relname
;
7989 bfd_boolean wrapped
;
7991 if (sec
== NULL
|| arm_sec
== NULL
)
7994 addr
->section
= SHN_UNDEF
;
7997 if (sym_name
!= NULL
)
7998 *sym_name
= (bfd_vma
) -1;
8000 /* If necessary, update the section cache. */
8001 if (sec
!= arm_sec
->sec
)
8003 Elf_Internal_Shdr
*relsec
;
8005 arm_free_section (arm_sec
);
8008 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8009 sec
->sh_size
, _("unwind data"));
8010 arm_sec
->rela
= NULL
;
8011 arm_sec
->nrelas
= 0;
8013 for (relsec
= section_headers
;
8014 relsec
< section_headers
+ elf_header
.e_shnum
;
8017 if (relsec
->sh_info
>= elf_header
.e_shnum
8018 || section_headers
+ relsec
->sh_info
!= sec
8019 /* PR 15745: Check the section type as well. */
8020 || (relsec
->sh_type
!= SHT_REL
8021 && relsec
->sh_type
!= SHT_RELA
))
8024 arm_sec
->rel_type
= relsec
->sh_type
;
8025 if (relsec
->sh_type
== SHT_REL
)
8027 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8029 & arm_sec
->rela
, & arm_sec
->nrelas
))
8032 else /* relsec->sh_type == SHT_RELA */
8034 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8036 & arm_sec
->rela
, & arm_sec
->nrelas
))
8042 arm_sec
->next_rela
= arm_sec
->rela
;
8045 /* If there is no unwind data we can do nothing. */
8046 if (arm_sec
->data
== NULL
)
8049 /* If the offset is invalid then fail. */
8050 if (word_offset
> (sec
->sh_size
- 4)
8052 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
8053 || ((bfd_signed_vma
) word_offset
) < 0)
8056 /* Get the word at the required offset. */
8057 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8059 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8060 if (arm_sec
->rela
== NULL
)
8066 /* Look through the relocs to find the one that applies to the provided offset. */
8068 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8070 bfd_vma prelval
, offset
;
8072 if (rp
->r_offset
> word_offset
&& !wrapped
)
8077 if (rp
->r_offset
> word_offset
)
8080 if (rp
->r_offset
& 3)
8082 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8083 (unsigned long) rp
->r_offset
);
8087 if (rp
->r_offset
< word_offset
)
8090 /* PR 17531: file: 027-161405-0.004 */
8091 if (aux
->symtab
== NULL
)
8094 if (arm_sec
->rel_type
== SHT_REL
)
8096 offset
= word
& 0x7fffffff;
8097 if (offset
& 0x40000000)
8098 offset
|= ~ (bfd_vma
) 0x7fffffff;
8100 else if (arm_sec
->rel_type
== SHT_RELA
)
8101 offset
= rp
->r_addend
;
8104 error (_("Unknown section relocation type %d encountered\n"),
8109 /* PR 17531 file: 027-1241568-0.004. */
8110 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8112 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8113 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8117 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8118 offset
+= sym
->st_value
;
8119 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8121 /* Check that we are processing the expected reloc type. */
8122 if (elf_header
.e_machine
== EM_ARM
)
8124 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8125 if (relname
== NULL
)
8127 warn (_("Skipping unknown ARM relocation type: %d\n"),
8128 (int) ELF32_R_TYPE (rp
->r_info
));
8132 if (streq (relname
, "R_ARM_NONE"))
8135 if (! streq (relname
, "R_ARM_PREL31"))
8137 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8141 else if (elf_header
.e_machine
== EM_TI_C6000
)
8143 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8144 if (relname
== NULL
)
8146 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8147 (int) ELF32_R_TYPE (rp
->r_info
));
8151 if (streq (relname
, "R_C6000_NONE"))
8154 if (! streq (relname
, "R_C6000_PREL31"))
8156 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8164 /* This function currently only supports ARM and TI unwinders. */
8165 warn (_("Only TI and ARM unwinders are currently supported\n"));
8169 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8170 addr
->section
= sym
->st_shndx
;
8171 addr
->offset
= offset
;
8174 * sym_name
= sym
->st_name
;
8179 arm_sec
->next_rela
= rp
;
8184 static const char *tic6x_unwind_regnames
[16] =
8186 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8187 "A14", "A13", "A12", "A11", "A10",
8188 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8192 decode_tic6x_unwind_regmask (unsigned int mask
)
8196 for (i
= 12; mask
; mask
>>= 1, i
--)
8200 fputs (tic6x_unwind_regnames
[i
], stdout
);
8202 fputs (", ", stdout
);
8208 if (remaining == 0 && more_words) \
8211 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8212 data_offset, & word, & addr, NULL)) \
8218 #define GET_OP(OP) \
8223 (OP) = word >> 24; \
8228 printf (_("[Truncated opcode]\n")); \
8231 printf ("0x%02x ", OP)
8234 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8236 unsigned int remaining
,
8237 unsigned int more_words
,
8238 bfd_vma data_offset
,
8239 Elf_Internal_Shdr
* data_sec
,
8240 struct arm_section
* data_arm_sec
)
8242 struct absaddr addr
;
8243 bfd_boolean res
= TRUE
;
8245 /* Decode the unwinding instructions. */
8248 unsigned int op
, op2
;
8257 printf (" 0x%02x ", op
);
8259 if ((op
& 0xc0) == 0x00)
8261 int offset
= ((op
& 0x3f) << 2) + 4;
8263 printf (" vsp = vsp + %d", offset
);
8265 else if ((op
& 0xc0) == 0x40)
8267 int offset
= ((op
& 0x3f) << 2) + 4;
8269 printf (" vsp = vsp - %d", offset
);
8271 else if ((op
& 0xf0) == 0x80)
8274 if (op
== 0x80 && op2
== 0)
8275 printf (_("Refuse to unwind"));
8278 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8279 bfd_boolean first
= TRUE
;
8283 for (i
= 0; i
< 12; i
++)
8284 if (mask
& (1 << i
))
8290 printf ("r%d", 4 + i
);
8295 else if ((op
& 0xf0) == 0x90)
8297 if (op
== 0x9d || op
== 0x9f)
8298 printf (_(" [Reserved]"));
8300 printf (" vsp = r%d", op
& 0x0f);
8302 else if ((op
& 0xf0) == 0xa0)
8304 int end
= 4 + (op
& 0x07);
8305 bfd_boolean first
= TRUE
;
8309 for (i
= 4; i
<= end
; i
++)
8325 else if (op
== 0xb0)
8326 printf (_(" finish"));
8327 else if (op
== 0xb1)
8330 if (op2
== 0 || (op2
& 0xf0) != 0)
8331 printf (_("[Spare]"));
8334 unsigned int mask
= op2
& 0x0f;
8335 bfd_boolean first
= TRUE
;
8339 for (i
= 0; i
< 12; i
++)
8340 if (mask
& (1 << i
))
8351 else if (op
== 0xb2)
8353 unsigned char buf
[9];
8354 unsigned int i
, len
;
8355 unsigned long offset
;
8357 for (i
= 0; i
< sizeof (buf
); i
++)
8360 if ((buf
[i
] & 0x80) == 0)
8363 if (i
== sizeof (buf
))
8365 error (_("corrupt change to vsp"));
8370 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8371 assert (len
== i
+ 1);
8372 offset
= offset
* 4 + 0x204;
8373 printf ("vsp = vsp + %ld", offset
);
8376 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8378 unsigned int first
, last
;
8385 printf ("pop {D%d", first
);
8387 printf ("-D%d", first
+ last
);
8390 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8392 unsigned int count
= op
& 0x07;
8396 printf ("-D%d", 8 + count
);
8399 else if (op
>= 0xc0 && op
<= 0xc5)
8401 unsigned int count
= op
& 0x07;
8403 printf (" pop {wR10");
8405 printf ("-wR%d", 10 + count
);
8408 else if (op
== 0xc6)
8410 unsigned int first
, last
;
8415 printf ("pop {wR%d", first
);
8417 printf ("-wR%d", first
+ last
);
8420 else if (op
== 0xc7)
8423 if (op2
== 0 || (op2
& 0xf0) != 0)
8424 printf (_("[Spare]"));
8427 unsigned int mask
= op2
& 0x0f;
8428 bfd_boolean first
= TRUE
;
8432 for (i
= 0; i
< 4; i
++)
8433 if (mask
& (1 << i
))
8439 printf ("wCGR%d", i
);
8446 printf (_(" [unsupported opcode]"));
8457 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8459 unsigned int remaining
,
8460 unsigned int more_words
,
8461 bfd_vma data_offset
,
8462 Elf_Internal_Shdr
* data_sec
,
8463 struct arm_section
* data_arm_sec
)
8465 struct absaddr addr
;
8467 /* Decode the unwinding instructions. */
8470 unsigned int op
, op2
;
8479 printf (" 0x%02x ", op
);
8481 if ((op
& 0xc0) == 0x00)
8483 int offset
= ((op
& 0x3f) << 3) + 8;
8484 printf (" sp = sp + %d", offset
);
8486 else if ((op
& 0xc0) == 0x80)
8489 if (op
== 0x80 && op2
== 0)
8490 printf (_("Refuse to unwind"));
8493 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8495 printf ("pop compact {");
8499 decode_tic6x_unwind_regmask (mask
);
8503 else if ((op
& 0xf0) == 0xc0)
8511 unsigned int offset
;
8515 /* Scan entire instruction first so that GET_OP output is not
8516 interleaved with disassembly. */
8518 for (i
= 0; nregs
< (op
& 0xf); i
++)
8524 regpos
[nregs
].offset
= i
* 2;
8525 regpos
[nregs
].reg
= reg
;
8532 regpos
[nregs
].offset
= i
* 2 + 1;
8533 regpos
[nregs
].reg
= reg
;
8538 printf (_("pop frame {"));
8540 for (i
= i
* 2; i
> 0; i
--)
8542 if (regpos
[reg
].offset
== i
- 1)
8544 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8551 fputs (name
, stdout
);
8558 else if (op
== 0xd0)
8559 printf (" MOV FP, SP");
8560 else if (op
== 0xd1)
8561 printf (" __c6xabi_pop_rts");
8562 else if (op
== 0xd2)
8564 unsigned char buf
[9];
8565 unsigned int i
, len
;
8566 unsigned long offset
;
8568 for (i
= 0; i
< sizeof (buf
); i
++)
8571 if ((buf
[i
] & 0x80) == 0)
8574 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8575 if (i
== sizeof (buf
))
8577 warn (_("Corrupt stack pointer adjustment detected\n"));
8581 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8582 assert (len
== i
+ 1);
8583 offset
= offset
* 8 + 0x408;
8584 printf (_("sp = sp + %ld"), offset
);
8586 else if ((op
& 0xf0) == 0xe0)
8588 if ((op
& 0x0f) == 7)
8591 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8595 printf (_(" [unsupported opcode]"));
8604 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8608 offset
= word
& 0x7fffffff;
8609 if (offset
& 0x40000000)
8610 offset
|= ~ (bfd_vma
) 0x7fffffff;
8612 if (elf_header
.e_machine
== EM_TI_C6000
)
8615 return offset
+ where
;
8619 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8621 unsigned int remaining
,
8622 bfd_vma data_offset
,
8623 Elf_Internal_Shdr
* data_sec
,
8624 struct arm_section
* data_arm_sec
)
8627 unsigned int more_words
= 0;
8628 struct absaddr addr
;
8629 bfd_vma sym_name
= (bfd_vma
) -1;
8630 bfd_boolean res
= FALSE
;
8634 /* Fetch the first word.
8635 Note - when decoding an object file the address extracted
8636 here will always be 0. So we also pass in the sym_name
8637 parameter so that we can find the symbol associated with
8638 the personality routine. */
8639 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8640 & word
, & addr
, & sym_name
))
8646 if ((word
& 0x80000000) == 0)
8648 /* Expand prel31 for personality routine. */
8650 const char *procname
;
8652 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8653 printf (_(" Personality routine: "));
8655 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8656 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8658 procname
= aux
->strtab
+ sym_name
;
8659 print_vma (fn
, PREFIX_HEX
);
8662 fputs (" <", stdout
);
8663 fputs (procname
, stdout
);
8664 fputc ('>', stdout
);
8668 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8669 fputc ('\n', stdout
);
8671 /* The GCC personality routines use the standard compact
8672 encoding, starting with one byte giving the number of
8674 if (procname
!= NULL
8675 && (const_strneq (procname
, "__gcc_personality_v0")
8676 || const_strneq (procname
, "__gxx_personality_v0")
8677 || const_strneq (procname
, "__gcj_personality_v0")
8678 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8685 printf (_(" [Truncated data]\n"));
8688 more_words
= word
>> 24;
8698 /* ARM EHABI Section 6.3:
8700 An exception-handling table entry for the compact model looks like:
8704 1 0 index Data for personalityRoutine[index] */
8706 if (elf_header
.e_machine
== EM_ARM
8707 && (word
& 0x70000000))
8709 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8713 per_index
= (word
>> 24) & 0x7f;
8714 printf (_(" Compact model index: %d\n"), per_index
);
8721 else if (per_index
< 3)
8723 more_words
= (word
>> 16) & 0xff;
8729 switch (elf_header
.e_machine
)
8734 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8735 data_offset
, data_sec
, data_arm_sec
))
8740 warn (_("Unknown ARM compact model index encountered\n"));
8741 printf (_(" [reserved]\n"));
8749 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8750 data_offset
, data_sec
, data_arm_sec
))
8753 else if (per_index
< 5)
8755 if (((word
>> 17) & 0x7f) == 0x7f)
8756 printf (_(" Restore stack from frame pointer\n"));
8758 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8759 printf (_(" Registers restored: "));
8761 printf (" (compact) ");
8762 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8764 printf (_(" Return register: %s\n"),
8765 tic6x_unwind_regnames
[word
& 0xf]);
8768 printf (_(" [reserved (%d)]\n"), per_index
);
8772 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8773 elf_header
.e_machine
);
8777 /* Decode the descriptors. Not implemented. */
8783 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8785 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8786 unsigned int i
, exidx_len
;
8787 unsigned long j
, nfuns
;
8788 bfd_boolean res
= TRUE
;
8790 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8791 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8792 exidx_len
= exidx_sec
->sh_size
/ 8;
8794 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8795 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8796 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8797 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8799 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8801 for (i
= 0; i
< exidx_len
; i
++)
8803 unsigned int exidx_fn
, exidx_entry
;
8804 struct absaddr fn_addr
, entry_addr
;
8807 fputc ('\n', stdout
);
8809 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8810 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8811 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8812 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8815 arm_free_section (& exidx_arm_sec
);
8816 arm_free_section (& extab_arm_sec
);
8820 /* ARM EHABI, Section 5:
8821 An index table entry consists of 2 words.
8822 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8823 if (exidx_fn
& 0x80000000)
8825 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8829 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8831 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8832 fputs (": ", stdout
);
8834 if (exidx_entry
== 1)
8836 print_vma (exidx_entry
, PREFIX_HEX
);
8837 fputs (" [cantunwind]\n", stdout
);
8839 else if (exidx_entry
& 0x80000000)
8841 print_vma (exidx_entry
, PREFIX_HEX
);
8842 fputc ('\n', stdout
);
8843 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8847 bfd_vma table
, table_offset
= 0;
8848 Elf_Internal_Shdr
*table_sec
;
8850 fputs ("@", stdout
);
8851 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8852 print_vma (table
, PREFIX_HEX
);
8855 /* Locate the matching .ARM.extab. */
8856 if (entry_addr
.section
!= SHN_UNDEF
8857 && entry_addr
.section
< elf_header
.e_shnum
)
8859 table_sec
= section_headers
+ entry_addr
.section
;
8860 table_offset
= entry_addr
.offset
;
8862 if (table_offset
> table_sec
->sh_size
8863 || ((bfd_signed_vma
) table_offset
) < 0)
8865 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8866 (unsigned long) table_offset
,
8867 printable_section_name (table_sec
));
8874 table_sec
= find_section_by_address (table
);
8875 if (table_sec
!= NULL
)
8876 table_offset
= table
- table_sec
->sh_addr
;
8879 if (table_sec
== NULL
)
8881 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8882 (unsigned long) table
);
8887 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8896 arm_free_section (&exidx_arm_sec
);
8897 arm_free_section (&extab_arm_sec
);
8902 /* Used for both ARM and C6X unwinding tables. */
8905 arm_process_unwind (FILE *file
)
8907 struct arm_unw_aux_info aux
;
8908 Elf_Internal_Shdr
*unwsec
= NULL
;
8909 Elf_Internal_Shdr
*strsec
;
8910 Elf_Internal_Shdr
*sec
;
8912 unsigned int sec_type
;
8913 bfd_boolean res
= TRUE
;
8915 switch (elf_header
.e_machine
)
8918 sec_type
= SHT_ARM_EXIDX
;
8922 sec_type
= SHT_C6000_UNWIND
;
8926 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8927 elf_header
.e_machine
);
8931 if (string_table
== NULL
)
8934 memset (& aux
, 0, sizeof (aux
));
8937 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8939 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8941 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8943 strsec
= section_headers
+ sec
->sh_link
;
8945 /* PR binutils/17531 file: 011-12666-0.004. */
8946 if (aux
.strtab
!= NULL
)
8948 error (_("Multiple string tables found in file.\n"));
8952 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8953 1, strsec
->sh_size
, _("string table"));
8954 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8956 else if (sec
->sh_type
== sec_type
)
8961 printf (_("\nThere are no unwind sections in this file.\n"));
8963 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8965 if (sec
->sh_type
== sec_type
)
8967 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8968 printable_section_name (sec
),
8969 (unsigned long) sec
->sh_offset
,
8970 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8972 if (! dump_arm_unwind (&aux
, sec
))
8980 free ((char *) aux
.strtab
);
8986 process_unwind (FILE * file
)
8988 struct unwind_handler
8990 unsigned int machtype
;
8991 bfd_boolean (* handler
)(FILE *);
8994 { EM_ARM
, arm_process_unwind
},
8995 { EM_IA_64
, ia64_process_unwind
},
8996 { EM_PARISC
, hppa_process_unwind
},
8997 { EM_TI_C6000
, arm_process_unwind
},
9005 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9006 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9007 return handlers
[i
].handler (file
);
9009 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9010 get_machine_name (elf_header
.e_machine
));
9015 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9017 switch (entry
->d_tag
)
9020 if (entry
->d_un
.d_val
== 0)
9024 static const char * opts
[] =
9026 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9027 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9028 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9029 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9033 bfd_boolean first
= TRUE
;
9035 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9036 if (entry
->d_un
.d_val
& (1 << cnt
))
9038 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9044 case DT_MIPS_IVERSION
:
9045 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9046 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9050 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9051 /* Note: coded this way so that there is a single string for translation. */
9052 printf (_("<corrupt: %s>"), buf
);
9056 case DT_MIPS_TIME_STAMP
:
9060 time_t atime
= entry
->d_un
.d_val
;
9062 tmp
= gmtime (&atime
);
9063 /* PR 17531: file: 6accc532. */
9065 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9067 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9068 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9069 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9070 printf (_("Time Stamp: %s"), timebuf
);
9074 case DT_MIPS_RLD_VERSION
:
9075 case DT_MIPS_LOCAL_GOTNO
:
9076 case DT_MIPS_CONFLICTNO
:
9077 case DT_MIPS_LIBLISTNO
:
9078 case DT_MIPS_SYMTABNO
:
9079 case DT_MIPS_UNREFEXTNO
:
9080 case DT_MIPS_HIPAGENO
:
9081 case DT_MIPS_DELTA_CLASS_NO
:
9082 case DT_MIPS_DELTA_INSTANCE_NO
:
9083 case DT_MIPS_DELTA_RELOC_NO
:
9084 case DT_MIPS_DELTA_SYM_NO
:
9085 case DT_MIPS_DELTA_CLASSSYM_NO
:
9086 case DT_MIPS_COMPACT_SIZE
:
9087 print_vma (entry
->d_un
.d_val
, DEC
);
9091 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9097 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9099 switch (entry
->d_tag
)
9101 case DT_HP_DLD_FLAGS
:
9110 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9111 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9112 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9113 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9114 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9115 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9116 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9117 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9118 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9119 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9120 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9121 { DT_HP_GST
, "HP_GST" },
9122 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9123 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9124 { DT_HP_NODELETE
, "HP_NODELETE" },
9125 { DT_HP_GROUP
, "HP_GROUP" },
9126 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9128 bfd_boolean first
= TRUE
;
9130 bfd_vma val
= entry
->d_un
.d_val
;
9132 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9133 if (val
& flags
[cnt
].bit
)
9137 fputs (flags
[cnt
].str
, stdout
);
9139 val
^= flags
[cnt
].bit
;
9142 if (val
!= 0 || first
)
9146 print_vma (val
, HEX
);
9152 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9160 /* VMS vs Unix time offset and factor. */
9162 #define VMS_EPOCH_OFFSET 35067168000000000LL
9163 #define VMS_GRANULARITY_FACTOR 10000000
9165 /* Display a VMS time in a human readable format. */
9168 print_vms_time (bfd_int64_t vmstime
)
9173 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9174 tm
= gmtime (&unxtime
);
9175 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9176 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9177 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9182 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9184 switch (entry
->d_tag
)
9186 case DT_IA_64_PLT_RESERVE
:
9187 /* First 3 slots reserved. */
9188 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9190 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9193 case DT_IA_64_VMS_LINKTIME
:
9195 print_vms_time (entry
->d_un
.d_val
);
9199 case DT_IA_64_VMS_LNKFLAGS
:
9200 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9201 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9202 printf (" CALL_DEBUG");
9203 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9204 printf (" NOP0BUFS");
9205 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9206 printf (" P0IMAGE");
9207 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9208 printf (" MKTHREADS");
9209 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9210 printf (" UPCALLS");
9211 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9213 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9214 printf (" INITIALIZE");
9215 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9217 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9218 printf (" EXE_INIT");
9219 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9220 printf (" TBK_IN_IMG");
9221 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9222 printf (" DBG_IN_IMG");
9223 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9224 printf (" TBK_IN_DSF");
9225 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9226 printf (" DBG_IN_DSF");
9227 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9228 printf (" SIGNATURES");
9229 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9230 printf (" REL_SEG_OFF");
9234 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9241 get_32bit_dynamic_section (FILE * file
)
9243 Elf32_External_Dyn
* edyn
;
9244 Elf32_External_Dyn
* ext
;
9245 Elf_Internal_Dyn
* entry
;
9247 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9248 dynamic_size
, _("dynamic section"));
9252 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9253 might not have the luxury of section headers. Look for the DT_NULL
9254 terminator to determine the number of entries. */
9255 for (ext
= edyn
, dynamic_nent
= 0;
9256 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9260 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9264 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9266 if (dynamic_section
== NULL
)
9268 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9269 (unsigned long) dynamic_nent
);
9274 for (ext
= edyn
, entry
= dynamic_section
;
9275 entry
< dynamic_section
+ dynamic_nent
;
9278 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9279 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9288 get_64bit_dynamic_section (FILE * file
)
9290 Elf64_External_Dyn
* edyn
;
9291 Elf64_External_Dyn
* ext
;
9292 Elf_Internal_Dyn
* entry
;
9294 /* Read in the data. */
9295 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9296 dynamic_size
, _("dynamic section"));
9300 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9301 might not have the luxury of section headers. Look for the DT_NULL
9302 terminator to determine the number of entries. */
9303 for (ext
= edyn
, dynamic_nent
= 0;
9304 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9305 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9309 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9313 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9315 if (dynamic_section
== NULL
)
9317 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9318 (unsigned long) dynamic_nent
);
9323 /* Convert from external to internal formats. */
9324 for (ext
= edyn
, entry
= dynamic_section
;
9325 entry
< dynamic_section
+ dynamic_nent
;
9328 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9329 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9338 print_dynamic_flags (bfd_vma flags
)
9340 bfd_boolean first
= TRUE
;
9346 flag
= flags
& - flags
;
9356 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9357 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9358 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9359 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9360 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9361 default: fputs (_("unknown"), stdout
); break;
9367 /* Parse and display the contents of the dynamic section. */
9370 process_dynamic_section (FILE * file
)
9372 Elf_Internal_Dyn
* entry
;
9374 if (dynamic_size
== 0)
9377 printf (_("\nThere is no dynamic section in this file.\n"));
9384 if (! get_32bit_dynamic_section (file
))
9389 if (! get_64bit_dynamic_section (file
))
9393 /* Find the appropriate symbol table. */
9394 if (dynamic_symbols
== NULL
)
9396 for (entry
= dynamic_section
;
9397 entry
< dynamic_section
+ dynamic_nent
;
9400 Elf_Internal_Shdr section
;
9402 if (entry
->d_tag
!= DT_SYMTAB
)
9405 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9407 /* Since we do not know how big the symbol table is,
9408 we default to reading in the entire file (!) and
9409 processing that. This is overkill, I know, but it
9411 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9413 if (archive_file_offset
!= 0)
9414 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9417 if (fseek (file
, 0, SEEK_END
))
9418 error (_("Unable to seek to end of file!\n"));
9420 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9424 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9426 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9427 section
.sh_name
= string_table_length
;
9429 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9430 if (num_dynamic_syms
< 1)
9432 error (_("Unable to determine the number of symbols to load\n"));
9438 /* Similarly find a string table. */
9439 if (dynamic_strings
== NULL
)
9441 for (entry
= dynamic_section
;
9442 entry
< dynamic_section
+ dynamic_nent
;
9445 unsigned long offset
;
9448 if (entry
->d_tag
!= DT_STRTAB
)
9451 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9453 /* Since we do not know how big the string table is,
9454 we default to reading in the entire file (!) and
9455 processing that. This is overkill, I know, but it
9458 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9460 if (archive_file_offset
!= 0)
9461 str_tab_len
= archive_file_size
- offset
;
9464 if (fseek (file
, 0, SEEK_END
))
9465 error (_("Unable to seek to end of file\n"));
9466 str_tab_len
= ftell (file
) - offset
;
9469 if (str_tab_len
< 1)
9472 (_("Unable to determine the length of the dynamic string table\n"));
9476 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9478 _("dynamic string table"));
9479 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9484 /* And find the syminfo section if available. */
9485 if (dynamic_syminfo
== NULL
)
9487 unsigned long syminsz
= 0;
9489 for (entry
= dynamic_section
;
9490 entry
< dynamic_section
+ dynamic_nent
;
9493 if (entry
->d_tag
== DT_SYMINENT
)
9495 /* Note: these braces are necessary to avoid a syntax
9496 error from the SunOS4 C compiler. */
9497 /* PR binutils/17531: A corrupt file can trigger this test.
9498 So do not use an assert, instead generate an error message. */
9499 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9500 error (_("Bad value (%d) for SYMINENT entry\n"),
9501 (int) entry
->d_un
.d_val
);
9503 else if (entry
->d_tag
== DT_SYMINSZ
)
9504 syminsz
= entry
->d_un
.d_val
;
9505 else if (entry
->d_tag
== DT_SYMINFO
)
9506 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9510 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9512 Elf_External_Syminfo
* extsyminfo
;
9513 Elf_External_Syminfo
* extsym
;
9514 Elf_Internal_Syminfo
* syminfo
;
9516 /* There is a syminfo section. Read the data. */
9517 extsyminfo
= (Elf_External_Syminfo
*)
9518 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9519 _("symbol information"));
9523 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9524 if (dynamic_syminfo
== NULL
)
9526 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9527 (unsigned long) syminsz
);
9531 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9532 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9533 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9534 ++syminfo
, ++extsym
)
9536 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9537 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9544 if (do_dynamic
&& dynamic_addr
)
9545 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9546 dynamic_addr
, (unsigned long) dynamic_nent
);
9548 printf (_(" Tag Type Name/Value\n"));
9550 for (entry
= dynamic_section
;
9551 entry
< dynamic_section
+ dynamic_nent
;
9559 print_vma (entry
->d_tag
, FULL_HEX
);
9560 dtype
= get_dynamic_type (entry
->d_tag
);
9561 printf (" (%s)%*s", dtype
,
9562 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9565 switch (entry
->d_tag
)
9569 print_dynamic_flags (entry
->d_un
.d_val
);
9579 switch (entry
->d_tag
)
9582 printf (_("Auxiliary library"));
9586 printf (_("Filter library"));
9590 printf (_("Configuration file"));
9594 printf (_("Dependency audit library"));
9598 printf (_("Audit library"));
9602 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9603 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9607 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9616 printf (_("Flags:"));
9618 if (entry
->d_un
.d_val
== 0)
9619 printf (_(" None\n"));
9622 unsigned long int val
= entry
->d_un
.d_val
;
9624 if (val
& DTF_1_PARINIT
)
9626 printf (" PARINIT");
9627 val
^= DTF_1_PARINIT
;
9629 if (val
& DTF_1_CONFEXP
)
9631 printf (" CONFEXP");
9632 val
^= DTF_1_CONFEXP
;
9635 printf (" %lx", val
);
9644 printf (_("Flags:"));
9646 if (entry
->d_un
.d_val
== 0)
9647 printf (_(" None\n"));
9650 unsigned long int val
= entry
->d_un
.d_val
;
9652 if (val
& DF_P1_LAZYLOAD
)
9654 printf (" LAZYLOAD");
9655 val
^= DF_P1_LAZYLOAD
;
9657 if (val
& DF_P1_GROUPPERM
)
9659 printf (" GROUPPERM");
9660 val
^= DF_P1_GROUPPERM
;
9663 printf (" %lx", val
);
9672 printf (_("Flags:"));
9673 if (entry
->d_un
.d_val
== 0)
9674 printf (_(" None\n"));
9677 unsigned long int val
= entry
->d_un
.d_val
;
9684 if (val
& DF_1_GLOBAL
)
9689 if (val
& DF_1_GROUP
)
9694 if (val
& DF_1_NODELETE
)
9696 printf (" NODELETE");
9697 val
^= DF_1_NODELETE
;
9699 if (val
& DF_1_LOADFLTR
)
9701 printf (" LOADFLTR");
9702 val
^= DF_1_LOADFLTR
;
9704 if (val
& DF_1_INITFIRST
)
9706 printf (" INITFIRST");
9707 val
^= DF_1_INITFIRST
;
9709 if (val
& DF_1_NOOPEN
)
9714 if (val
& DF_1_ORIGIN
)
9719 if (val
& DF_1_DIRECT
)
9724 if (val
& DF_1_TRANS
)
9729 if (val
& DF_1_INTERPOSE
)
9731 printf (" INTERPOSE");
9732 val
^= DF_1_INTERPOSE
;
9734 if (val
& DF_1_NODEFLIB
)
9736 printf (" NODEFLIB");
9737 val
^= DF_1_NODEFLIB
;
9739 if (val
& DF_1_NODUMP
)
9744 if (val
& DF_1_CONFALT
)
9746 printf (" CONFALT");
9747 val
^= DF_1_CONFALT
;
9749 if (val
& DF_1_ENDFILTEE
)
9751 printf (" ENDFILTEE");
9752 val
^= DF_1_ENDFILTEE
;
9754 if (val
& DF_1_DISPRELDNE
)
9756 printf (" DISPRELDNE");
9757 val
^= DF_1_DISPRELDNE
;
9759 if (val
& DF_1_DISPRELPND
)
9761 printf (" DISPRELPND");
9762 val
^= DF_1_DISPRELPND
;
9764 if (val
& DF_1_NODIRECT
)
9766 printf (" NODIRECT");
9767 val
^= DF_1_NODIRECT
;
9769 if (val
& DF_1_IGNMULDEF
)
9771 printf (" IGNMULDEF");
9772 val
^= DF_1_IGNMULDEF
;
9774 if (val
& DF_1_NOKSYMS
)
9776 printf (" NOKSYMS");
9777 val
^= DF_1_NOKSYMS
;
9779 if (val
& DF_1_NOHDR
)
9784 if (val
& DF_1_EDITED
)
9789 if (val
& DF_1_NORELOC
)
9791 printf (" NORELOC");
9792 val
^= DF_1_NORELOC
;
9794 if (val
& DF_1_SYMINTPOSE
)
9796 printf (" SYMINTPOSE");
9797 val
^= DF_1_SYMINTPOSE
;
9799 if (val
& DF_1_GLOBAUDIT
)
9801 printf (" GLOBAUDIT");
9802 val
^= DF_1_GLOBAUDIT
;
9804 if (val
& DF_1_SINGLETON
)
9806 printf (" SINGLETON");
9807 val
^= DF_1_SINGLETON
;
9809 if (val
& DF_1_STUB
)
9820 printf (" %lx", val
);
9827 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9829 puts (get_dynamic_type (entry
->d_un
.d_val
));
9849 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9855 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9856 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9862 switch (entry
->d_tag
)
9865 printf (_("Shared library: [%s]"), name
);
9867 if (streq (name
, program_interpreter
))
9868 printf (_(" program interpreter"));
9872 printf (_("Library soname: [%s]"), name
);
9876 printf (_("Library rpath: [%s]"), name
);
9880 printf (_("Library runpath: [%s]"), name
);
9884 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9889 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9902 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9907 case DT_INIT_ARRAYSZ
:
9908 case DT_FINI_ARRAYSZ
:
9909 case DT_GNU_CONFLICTSZ
:
9910 case DT_GNU_LIBLISTSZ
:
9913 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9914 printf (_(" (bytes)\n"));
9924 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9937 if (entry
->d_tag
== DT_USED
9938 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9940 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9944 printf (_("Not needed object: [%s]\n"), name
);
9949 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9955 /* The value of this entry is ignored. */
9960 case DT_GNU_PRELINKED
:
9964 time_t atime
= entry
->d_un
.d_val
;
9966 tmp
= gmtime (&atime
);
9967 /* PR 17533 file: 041-1244816-0.004. */
9969 printf (_("<corrupt time val: %lx"),
9970 (unsigned long) atime
);
9972 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9973 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9974 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9980 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9983 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9989 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9990 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9995 switch (elf_header
.e_machine
)
9998 case EM_MIPS_RS3_LE
:
9999 dynamic_section_mips_val (entry
);
10002 dynamic_section_parisc_val (entry
);
10005 dynamic_section_ia64_val (entry
);
10008 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10020 get_ver_flags (unsigned int flags
)
10022 static char buff
[32];
10029 if (flags
& VER_FLG_BASE
)
10030 strcat (buff
, "BASE");
10032 if (flags
& VER_FLG_WEAK
)
10034 if (flags
& VER_FLG_BASE
)
10035 strcat (buff
, " | ");
10037 strcat (buff
, "WEAK");
10040 if (flags
& VER_FLG_INFO
)
10042 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10043 strcat (buff
, " | ");
10045 strcat (buff
, "INFO");
10048 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10050 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10051 strcat (buff
, " | ");
10053 strcat (buff
, _("<unknown>"));
10059 /* Display the contents of the version sections. */
10062 process_version_sections (FILE * file
)
10064 Elf_Internal_Shdr
* section
;
10066 bfd_boolean found
= FALSE
;
10071 for (i
= 0, section
= section_headers
;
10072 i
< elf_header
.e_shnum
;
10075 switch (section
->sh_type
)
10077 case SHT_GNU_verdef
:
10079 Elf_External_Verdef
* edefs
;
10087 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10088 printable_section_name (section
),
10091 printf (_(" Addr: 0x"));
10092 printf_vma (section
->sh_addr
);
10093 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10094 (unsigned long) section
->sh_offset
, section
->sh_link
,
10095 printable_section_name_from_index (section
->sh_link
));
10097 edefs
= (Elf_External_Verdef
*)
10098 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10099 _("version definition section"));
10102 endbuf
= (char *) edefs
+ section
->sh_size
;
10104 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10105 end
= (section
->sh_info
< section
->sh_size
10106 ? section
->sh_info
: section
->sh_size
);
10107 for (idx
= cnt
= 0; cnt
< end
; ++cnt
)
10110 Elf_External_Verdef
* edef
;
10111 Elf_Internal_Verdef ent
;
10112 Elf_External_Verdaux
* eaux
;
10113 Elf_Internal_Verdaux aux
;
10117 /* Check for very large indices. */
10118 if (idx
> (size_t) (endbuf
- (char *) edefs
))
10121 vstart
= ((char *) edefs
) + idx
;
10122 if (vstart
+ sizeof (*edef
) > endbuf
)
10125 edef
= (Elf_External_Verdef
*) vstart
;
10127 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10128 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10129 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10130 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10131 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10132 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10133 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10135 printf (_(" %#06x: Rev: %d Flags: %s"),
10136 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10138 printf (_(" Index: %d Cnt: %d "),
10139 ent
.vd_ndx
, ent
.vd_cnt
);
10141 /* Check for overflow. */
10142 if (ent
.vd_aux
+ sizeof (* eaux
) > (size_t) (endbuf
- vstart
))
10145 vstart
+= ent
.vd_aux
;
10147 eaux
= (Elf_External_Verdaux
*) vstart
;
10149 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10150 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10152 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10153 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10155 printf (_("Name index: %ld\n"), aux
.vda_name
);
10157 isum
= idx
+ ent
.vd_aux
;
10159 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10161 /* Check for overflow. */
10162 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10165 isum
+= aux
.vda_next
;
10166 vstart
+= aux
.vda_next
;
10168 eaux
= (Elf_External_Verdaux
*) vstart
;
10169 if (vstart
+ sizeof (*eaux
) > endbuf
)
10172 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10173 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10175 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10176 printf (_(" %#06x: Parent %d: %s\n"),
10177 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10179 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10180 isum
, j
, aux
.vda_name
);
10183 if (j
< ent
.vd_cnt
)
10184 printf (_(" Version def aux past end of section\n"));
10187 file: id:000001,src:000172+005151,op:splice,rep:2. */
10188 if (idx
+ ent
.vd_next
< idx
)
10191 idx
+= ent
.vd_next
;
10194 if (cnt
< section
->sh_info
)
10195 printf (_(" Version definition past end of section\n"));
10201 case SHT_GNU_verneed
:
10203 Elf_External_Verneed
* eneed
;
10210 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10211 printable_section_name (section
), section
->sh_info
);
10213 printf (_(" Addr: 0x"));
10214 printf_vma (section
->sh_addr
);
10215 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10216 (unsigned long) section
->sh_offset
, section
->sh_link
,
10217 printable_section_name_from_index (section
->sh_link
));
10219 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10220 section
->sh_offset
, 1,
10222 _("Version Needs section"));
10225 endbuf
= (char *) eneed
+ section
->sh_size
;
10227 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10229 Elf_External_Verneed
* entry
;
10230 Elf_Internal_Verneed ent
;
10235 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10238 vstart
= ((char *) eneed
) + idx
;
10239 if (vstart
+ sizeof (*entry
) > endbuf
)
10242 entry
= (Elf_External_Verneed
*) vstart
;
10244 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10245 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10246 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10247 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10248 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10250 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10252 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10253 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10255 printf (_(" File: %lx"), ent
.vn_file
);
10257 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10259 /* Check for overflow. */
10260 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10262 vstart
+= ent
.vn_aux
;
10264 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10266 Elf_External_Vernaux
* eaux
;
10267 Elf_Internal_Vernaux aux
;
10269 if (vstart
+ sizeof (*eaux
) > endbuf
)
10271 eaux
= (Elf_External_Vernaux
*) vstart
;
10273 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10274 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10275 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10276 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10277 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10279 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10280 printf (_(" %#06x: Name: %s"),
10281 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10283 printf (_(" %#06x: Name index: %lx"),
10284 isum
, aux
.vna_name
);
10286 printf (_(" Flags: %s Version: %d\n"),
10287 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10289 /* Check for overflow. */
10290 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10291 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10293 warn (_("Invalid vna_next field of %lx\n"),
10298 isum
+= aux
.vna_next
;
10299 vstart
+= aux
.vna_next
;
10302 if (j
< ent
.vn_cnt
)
10303 warn (_("Missing Version Needs auxillary information\n"));
10305 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10307 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10308 cnt
= section
->sh_info
;
10311 idx
+= ent
.vn_next
;
10314 if (cnt
< section
->sh_info
)
10315 warn (_("Missing Version Needs information\n"));
10321 case SHT_GNU_versym
:
10323 Elf_Internal_Shdr
* link_section
;
10326 unsigned char * edata
;
10327 unsigned short * data
;
10329 Elf_Internal_Sym
* symbols
;
10330 Elf_Internal_Shdr
* string_sec
;
10331 unsigned long num_syms
;
10334 if (section
->sh_link
>= elf_header
.e_shnum
)
10337 link_section
= section_headers
+ section
->sh_link
;
10338 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10340 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10345 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10346 if (symbols
== NULL
)
10349 string_sec
= section_headers
+ link_section
->sh_link
;
10351 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10352 string_sec
->sh_size
,
10353 _("version string table"));
10360 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10361 printable_section_name (section
), (unsigned long) total
);
10363 printf (_(" Addr: "));
10364 printf_vma (section
->sh_addr
);
10365 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10366 (unsigned long) section
->sh_offset
, section
->sh_link
,
10367 printable_section_name (link_section
));
10369 off
= offset_from_vma (file
,
10370 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10371 total
* sizeof (short));
10372 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10374 _("version symbol data"));
10382 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10384 for (cnt
= total
; cnt
--;)
10385 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10390 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10394 char *invalid
= _("*invalid*");
10396 printf (" %03x:", cnt
);
10398 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10399 switch (data
[cnt
+ j
])
10402 fputs (_(" 0 (*local*) "), stdout
);
10406 fputs (_(" 1 (*global*) "), stdout
);
10410 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10411 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10413 /* If this index value is greater than the size of the symbols
10414 array, break to avoid an out-of-bounds read. */
10415 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10417 warn (_("invalid index into symbol array\n"));
10422 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10424 Elf_Internal_Verneed ivn
;
10425 unsigned long offset
;
10427 offset
= offset_from_vma
10428 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10429 sizeof (Elf_External_Verneed
));
10433 Elf_Internal_Vernaux ivna
;
10434 Elf_External_Verneed evn
;
10435 Elf_External_Vernaux evna
;
10436 unsigned long a_off
;
10438 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10439 _("version need")) == NULL
)
10442 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10443 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10445 a_off
= offset
+ ivn
.vn_aux
;
10449 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10450 1, _("version need aux (2)")) == NULL
)
10453 ivna
.vna_other
= 0;
10457 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10458 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10461 a_off
+= ivna
.vna_next
;
10463 while (ivna
.vna_other
!= data
[cnt
+ j
]
10464 && ivna
.vna_next
!= 0);
10466 if (ivna
.vna_other
== data
[cnt
+ j
])
10468 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10470 if (ivna
.vna_name
>= string_sec
->sh_size
)
10473 name
= strtab
+ ivna
.vna_name
;
10477 offset
+= ivn
.vn_next
;
10479 while (ivn
.vn_next
);
10482 if (data
[cnt
+ j
] != 0x8001
10483 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10485 Elf_Internal_Verdef ivd
;
10486 Elf_External_Verdef evd
;
10487 unsigned long offset
;
10489 offset
= offset_from_vma
10490 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10495 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10496 _("version def")) == NULL
)
10499 /* PR 17531: file: 046-1082287-0.004. */
10500 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10505 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10506 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10509 offset
+= ivd
.vd_next
;
10511 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10512 && ivd
.vd_next
!= 0);
10514 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10516 Elf_External_Verdaux evda
;
10517 Elf_Internal_Verdaux ivda
;
10519 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10521 if (get_data (&evda
, file
,
10522 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10524 _("version def aux")) == NULL
)
10527 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10529 if (ivda
.vda_name
>= string_sec
->sh_size
)
10531 else if (name
!= NULL
&& name
!= invalid
)
10532 name
= _("*both*");
10534 name
= strtab
+ ivda
.vda_name
;
10538 nn
+= printf ("(%s%-*s",
10540 12 - (int) strlen (name
),
10544 printf ("%*c", 18 - nn
, ' ');
10562 printf (_("\nNo version information found in this file.\n"));
10567 static const char *
10568 get_symbol_binding (unsigned int binding
)
10570 static char buff
[32];
10574 case STB_LOCAL
: return "LOCAL";
10575 case STB_GLOBAL
: return "GLOBAL";
10576 case STB_WEAK
: return "WEAK";
10578 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10579 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10581 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10583 if (binding
== STB_GNU_UNIQUE
10584 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10585 /* GNU is still using the default value 0. */
10586 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10588 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10591 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10596 static const char *
10597 get_symbol_type (unsigned int type
)
10599 static char buff
[32];
10603 case STT_NOTYPE
: return "NOTYPE";
10604 case STT_OBJECT
: return "OBJECT";
10605 case STT_FUNC
: return "FUNC";
10606 case STT_SECTION
: return "SECTION";
10607 case STT_FILE
: return "FILE";
10608 case STT_COMMON
: return "COMMON";
10609 case STT_TLS
: return "TLS";
10610 case STT_RELC
: return "RELC";
10611 case STT_SRELC
: return "SRELC";
10613 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10615 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10616 return "THUMB_FUNC";
10618 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10621 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10622 return "PARISC_MILLI";
10624 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10626 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10628 if (elf_header
.e_machine
== EM_PARISC
)
10630 if (type
== STT_HP_OPAQUE
)
10631 return "HP_OPAQUE";
10632 if (type
== STT_HP_STUB
)
10636 if (type
== STT_GNU_IFUNC
10637 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10638 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10639 /* GNU is still using the default value 0. */
10640 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10643 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10646 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10651 static const char *
10652 get_symbol_visibility (unsigned int visibility
)
10654 switch (visibility
)
10656 case STV_DEFAULT
: return "DEFAULT";
10657 case STV_INTERNAL
: return "INTERNAL";
10658 case STV_HIDDEN
: return "HIDDEN";
10659 case STV_PROTECTED
: return "PROTECTED";
10661 error (_("Unrecognized visibility value: %u"), visibility
);
10662 return _("<unknown>");
10666 static const char *
10667 get_solaris_symbol_visibility (unsigned int visibility
)
10669 switch (visibility
)
10671 case 4: return "EXPORTED";
10672 case 5: return "SINGLETON";
10673 case 6: return "ELIMINATE";
10674 default: return get_symbol_visibility (visibility
);
10678 static const char *
10679 get_mips_symbol_other (unsigned int other
)
10683 case STO_OPTIONAL
: return "OPTIONAL";
10684 case STO_MIPS_PLT
: return "MIPS PLT";
10685 case STO_MIPS_PIC
: return "MIPS PIC";
10686 case STO_MICROMIPS
: return "MICROMIPS";
10687 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10688 case STO_MIPS16
: return "MIPS16";
10689 default: return NULL
;
10693 static const char *
10694 get_ia64_symbol_other (unsigned int other
)
10696 if (is_ia64_vms ())
10698 static char res
[32];
10702 /* Function types is for images and .STB files only. */
10703 switch (elf_header
.e_type
)
10707 switch (VMS_ST_FUNC_TYPE (other
))
10709 case VMS_SFT_CODE_ADDR
:
10710 strcat (res
, " CA");
10712 case VMS_SFT_SYMV_IDX
:
10713 strcat (res
, " VEC");
10716 strcat (res
, " FD");
10718 case VMS_SFT_RESERVE
:
10719 strcat (res
, " RSV");
10722 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10723 VMS_ST_FUNC_TYPE (other
));
10724 strcat (res
, " <unknown>");
10731 switch (VMS_ST_LINKAGE (other
))
10733 case VMS_STL_IGNORE
:
10734 strcat (res
, " IGN");
10736 case VMS_STL_RESERVE
:
10737 strcat (res
, " RSV");
10740 strcat (res
, " STD");
10743 strcat (res
, " LNK");
10746 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10747 VMS_ST_LINKAGE (other
));
10748 strcat (res
, " <unknown>");
10760 static const char *
10761 get_ppc64_symbol_other (unsigned int other
)
10763 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10765 static char buf
[32];
10766 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10767 PPC64_LOCAL_ENTRY_OFFSET (other
));
10773 static const char *
10774 get_symbol_other (unsigned int other
)
10776 const char * result
= NULL
;
10777 static char buff
[32];
10782 switch (elf_header
.e_machine
)
10785 result
= get_mips_symbol_other (other
);
10788 result
= get_ia64_symbol_other (other
);
10791 result
= get_ppc64_symbol_other (other
);
10801 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10805 static const char *
10806 get_symbol_index_type (unsigned int type
)
10808 static char buff
[32];
10812 case SHN_UNDEF
: return "UND";
10813 case SHN_ABS
: return "ABS";
10814 case SHN_COMMON
: return "COM";
10816 if (type
== SHN_IA_64_ANSI_COMMON
10817 && elf_header
.e_machine
== EM_IA_64
10818 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10820 else if ((elf_header
.e_machine
== EM_X86_64
10821 || elf_header
.e_machine
== EM_L1OM
10822 || elf_header
.e_machine
== EM_K1OM
)
10823 && type
== SHN_X86_64_LCOMMON
)
10824 return "LARGE_COM";
10825 else if ((type
== SHN_MIPS_SCOMMON
10826 && elf_header
.e_machine
== EM_MIPS
)
10827 || (type
== SHN_TIC6X_SCOMMON
10828 && elf_header
.e_machine
== EM_TI_C6000
))
10830 else if (type
== SHN_MIPS_SUNDEFINED
10831 && elf_header
.e_machine
== EM_MIPS
)
10833 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10834 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10835 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10836 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10837 else if (type
>= SHN_LORESERVE
)
10838 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10839 else if (type
>= elf_header
.e_shnum
)
10840 sprintf (buff
, _("bad section index[%3d]"), type
);
10842 sprintf (buff
, "%3d", type
);
10850 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10852 unsigned char * e_data
;
10855 /* If the size_t type is smaller than the bfd_size_type, eg because
10856 you are building a 32-bit tool on a 64-bit host, then make sure
10857 that when (number) is cast to (size_t) no information is lost. */
10858 if (sizeof (size_t) < sizeof (bfd_size_type
)
10859 && (bfd_size_type
) ((size_t) number
) != number
)
10861 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10862 " elements of size %u\n"),
10867 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10868 attempting to allocate memory when the read is bound to fail. */
10869 if (ent_size
* number
> current_file_size
)
10871 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10876 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10877 if (e_data
== NULL
)
10879 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10884 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10886 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10887 number
* ent_size
);
10892 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10893 if (i_data
== NULL
)
10895 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10896 " dynamic entries\n"),
10903 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10911 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10913 Elf_Internal_Sym
* psym
;
10916 n
= print_vma (si
, DEC_5
);
10918 fputs (&" "[n
], stdout
);
10919 printf (" %3lu: ", hn
);
10921 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10923 printf (_("<No info available for dynamic symbol number %lu>\n"),
10924 (unsigned long) si
);
10928 psym
= dynamic_symbols
+ si
;
10929 print_vma (psym
->st_value
, LONG_HEX
);
10931 print_vma (psym
->st_size
, DEC_5
);
10933 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10934 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10936 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10937 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10940 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10942 printf (" %-7s", get_symbol_visibility (vis
));
10943 /* Check to see if any other bits in the st_other field are set.
10944 Note - displaying this information disrupts the layout of the
10945 table being generated, but for the moment this case is very
10947 if (psym
->st_other
^ vis
)
10948 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10951 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10952 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10953 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10955 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10959 static const char *
10960 get_symbol_version_string (FILE * file
,
10961 bfd_boolean is_dynsym
,
10962 const char * strtab
,
10963 unsigned long int strtab_size
,
10965 Elf_Internal_Sym
* psym
,
10966 enum versioned_symbol_info
* sym_info
,
10967 unsigned short * vna_other
)
10969 unsigned char data
[2];
10970 unsigned short vers_data
;
10971 unsigned long offset
;
10974 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10977 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10978 sizeof data
+ si
* sizeof (vers_data
));
10980 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10981 sizeof (data
), 1, _("version data")) == NULL
)
10984 vers_data
= byte_get (data
, 2);
10986 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10989 /* Usually we'd only see verdef for defined symbols, and verneed for
10990 undefined symbols. However, symbols defined by the linker in
10991 .dynbss for variables copied from a shared library in order to
10992 avoid text relocations are defined yet have verneed. We could
10993 use a heuristic to detect the special case, for example, check
10994 for verneed first on symbols defined in SHT_NOBITS sections, but
10995 it is simpler and more reliable to just look for both verdef and
10996 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10998 if (psym
->st_shndx
!= SHN_UNDEF
10999 && vers_data
!= 0x8001
11000 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11002 Elf_Internal_Verdef ivd
;
11003 Elf_Internal_Verdaux ivda
;
11004 Elf_External_Verdaux evda
;
11007 off
= offset_from_vma (file
,
11008 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11009 sizeof (Elf_External_Verdef
));
11013 Elf_External_Verdef evd
;
11015 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11016 _("version def")) == NULL
)
11024 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11025 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11026 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11029 off
+= ivd
.vd_next
;
11031 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11033 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11035 off
-= ivd
.vd_next
;
11038 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11039 _("version def aux")) != NULL
)
11041 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11043 if (psym
->st_name
!= ivda
.vda_name
)
11045 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11046 ? symbol_hidden
: symbol_public
);
11047 return (ivda
.vda_name
< strtab_size
11048 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11054 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11056 Elf_External_Verneed evn
;
11057 Elf_Internal_Verneed ivn
;
11058 Elf_Internal_Vernaux ivna
;
11060 offset
= offset_from_vma (file
,
11061 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11065 unsigned long vna_off
;
11067 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11068 _("version need")) == NULL
)
11071 ivna
.vna_other
= 0;
11076 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11077 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11079 vna_off
= offset
+ ivn
.vn_aux
;
11083 Elf_External_Vernaux evna
;
11085 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11086 _("version need aux (3)")) == NULL
)
11089 ivna
.vna_other
= 0;
11094 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11095 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11096 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11099 vna_off
+= ivna
.vna_next
;
11101 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11103 if (ivna
.vna_other
== vers_data
)
11106 offset
+= ivn
.vn_next
;
11108 while (ivn
.vn_next
!= 0);
11110 if (ivna
.vna_other
== vers_data
)
11112 *sym_info
= symbol_undefined
;
11113 *vna_other
= ivna
.vna_other
;
11114 return (ivna
.vna_name
< strtab_size
11115 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11121 /* Dump the symbol table. */
11123 process_symbol_table (FILE * file
)
11125 Elf_Internal_Shdr
* section
;
11126 bfd_size_type nbuckets
= 0;
11127 bfd_size_type nchains
= 0;
11128 bfd_vma
* buckets
= NULL
;
11129 bfd_vma
* chains
= NULL
;
11130 bfd_vma ngnubuckets
= 0;
11131 bfd_vma
* gnubuckets
= NULL
;
11132 bfd_vma
* gnuchains
= NULL
;
11133 bfd_vma gnusymidx
= 0;
11134 bfd_size_type ngnuchains
= 0;
11136 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11139 if (dynamic_info
[DT_HASH
]
11141 || (do_using_dynamic
11143 && dynamic_strings
!= NULL
)))
11145 unsigned char nb
[8];
11146 unsigned char nc
[8];
11147 unsigned int hash_ent_size
= 4;
11149 if ((elf_header
.e_machine
== EM_ALPHA
11150 || elf_header
.e_machine
== EM_S390
11151 || elf_header
.e_machine
== EM_S390_OLD
)
11152 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11156 (archive_file_offset
11157 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11158 sizeof nb
+ sizeof nc
)),
11161 error (_("Unable to seek to start of dynamic information\n"));
11165 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11167 error (_("Failed to read in number of buckets\n"));
11171 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11173 error (_("Failed to read in number of chains\n"));
11177 nbuckets
= byte_get (nb
, hash_ent_size
);
11178 nchains
= byte_get (nc
, hash_ent_size
);
11180 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11181 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11184 if (buckets
== NULL
|| chains
== NULL
)
11186 if (do_using_dynamic
)
11197 if (dynamic_info_DT_GNU_HASH
11199 || (do_using_dynamic
11201 && dynamic_strings
!= NULL
)))
11203 unsigned char nb
[16];
11204 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11205 bfd_vma buckets_vma
;
11208 (archive_file_offset
11209 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11213 error (_("Unable to seek to start of dynamic information\n"));
11217 if (fread (nb
, 16, 1, file
) != 1)
11219 error (_("Failed to read in number of buckets\n"));
11223 ngnubuckets
= byte_get (nb
, 4);
11224 gnusymidx
= byte_get (nb
+ 4, 4);
11225 bitmaskwords
= byte_get (nb
+ 8, 4);
11226 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11228 buckets_vma
+= bitmaskwords
* 4;
11230 buckets_vma
+= bitmaskwords
* 8;
11233 (archive_file_offset
11234 + offset_from_vma (file
, buckets_vma
, 4)),
11237 error (_("Unable to seek to start of dynamic information\n"));
11241 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11243 if (gnubuckets
== NULL
)
11246 for (i
= 0; i
< ngnubuckets
; i
++)
11247 if (gnubuckets
[i
] != 0)
11249 if (gnubuckets
[i
] < gnusymidx
)
11252 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11253 maxchain
= gnubuckets
[i
];
11256 if (maxchain
== 0xffffffff)
11259 maxchain
-= gnusymidx
;
11262 (archive_file_offset
11263 + offset_from_vma (file
, buckets_vma
11264 + 4 * (ngnubuckets
+ maxchain
), 4)),
11267 error (_("Unable to seek to start of dynamic information\n"));
11273 if (fread (nb
, 4, 1, file
) != 1)
11275 error (_("Failed to determine last chain length\n"));
11279 if (maxchain
+ 1 == 0)
11284 while ((byte_get (nb
, 4) & 1) == 0);
11287 (archive_file_offset
11288 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11291 error (_("Unable to seek to start of dynamic information\n"));
11295 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11296 ngnuchains
= maxchain
;
11299 if (gnuchains
== NULL
)
11304 if (do_using_dynamic
)
11309 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11311 && do_using_dynamic
11312 && dynamic_strings
!= NULL
11313 && dynamic_symbols
!= NULL
)
11317 if (dynamic_info
[DT_HASH
])
11321 printf (_("\nSymbol table for image:\n"));
11323 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11325 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11327 for (hn
= 0; hn
< nbuckets
; hn
++)
11332 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11333 print_dynamic_symbol (si
, hn
);
11337 if (dynamic_info_DT_GNU_HASH
)
11339 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11341 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11343 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11345 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11346 if (gnubuckets
[hn
] != 0)
11348 bfd_vma si
= gnubuckets
[hn
];
11349 bfd_vma off
= si
- gnusymidx
;
11353 print_dynamic_symbol (si
, hn
);
11356 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11360 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11361 && section_headers
!= NULL
)
11365 for (i
= 0, section
= section_headers
;
11366 i
< elf_header
.e_shnum
;
11370 char * strtab
= NULL
;
11371 unsigned long int strtab_size
= 0;
11372 Elf_Internal_Sym
* symtab
;
11373 Elf_Internal_Sym
* psym
;
11374 unsigned long num_syms
;
11376 if ((section
->sh_type
!= SHT_SYMTAB
11377 && section
->sh_type
!= SHT_DYNSYM
)
11379 && section
->sh_type
== SHT_SYMTAB
))
11382 if (section
->sh_entsize
== 0)
11384 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11385 printable_section_name (section
));
11389 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11390 printable_section_name (section
),
11391 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11394 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11396 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11398 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11399 if (symtab
== NULL
)
11402 if (section
->sh_link
== elf_header
.e_shstrndx
)
11404 strtab
= string_table
;
11405 strtab_size
= string_table_length
;
11407 else if (section
->sh_link
< elf_header
.e_shnum
)
11409 Elf_Internal_Shdr
* string_sec
;
11411 string_sec
= section_headers
+ section
->sh_link
;
11413 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11414 1, string_sec
->sh_size
,
11415 _("string table"));
11416 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11419 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11421 const char *version_string
;
11422 enum versioned_symbol_info sym_info
;
11423 unsigned short vna_other
;
11425 printf ("%6d: ", si
);
11426 print_vma (psym
->st_value
, LONG_HEX
);
11428 print_vma (psym
->st_size
, DEC_5
);
11429 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11430 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11431 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11432 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11435 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11437 printf (" %-7s", get_symbol_visibility (vis
));
11438 /* Check to see if any other bits in the st_other field are set.
11439 Note - displaying this information disrupts the layout of the
11440 table being generated, but for the moment this case is very rare. */
11441 if (psym
->st_other
^ vis
)
11442 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11444 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11445 print_symbol (25, psym
->st_name
< strtab_size
11446 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11449 = get_symbol_version_string (file
,
11450 section
->sh_type
== SHT_DYNSYM
,
11451 strtab
, strtab_size
, si
,
11452 psym
, &sym_info
, &vna_other
);
11453 if (version_string
)
11455 if (sym_info
== symbol_undefined
)
11456 printf ("@%s (%d)", version_string
, vna_other
);
11458 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11464 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11465 && si
>= section
->sh_info
11466 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11467 && elf_header
.e_machine
!= EM_MIPS
11468 /* Solaris binaries have been found to violate this requirement as
11469 well. Not sure if this is a bug or an ABI requirement. */
11470 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11471 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11472 si
, printable_section_name (section
), section
->sh_info
);
11476 if (strtab
!= string_table
)
11482 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11484 if (do_histogram
&& buckets
!= NULL
)
11486 unsigned long * lengths
;
11487 unsigned long * counts
;
11490 unsigned long maxlength
= 0;
11491 unsigned long nzero_counts
= 0;
11492 unsigned long nsyms
= 0;
11493 unsigned long chained
;
11495 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11496 (unsigned long) nbuckets
);
11498 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11499 if (lengths
== NULL
)
11501 error (_("Out of memory allocating space for histogram buckets\n"));
11505 printf (_(" Length Number %% of total Coverage\n"));
11506 for (hn
= 0; hn
< nbuckets
; ++hn
)
11508 for (si
= buckets
[hn
], chained
= 0;
11509 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11510 si
= chains
[si
], ++chained
)
11513 if (maxlength
< ++lengths
[hn
])
11517 /* PR binutils/17531: A corrupt binary could contain broken
11518 histogram data. Do not go into an infinite loop trying
11520 if (chained
> nchains
)
11522 error (_("histogram chain is corrupt\n"));
11527 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11528 if (counts
== NULL
)
11531 error (_("Out of memory allocating space for histogram counts\n"));
11535 for (hn
= 0; hn
< nbuckets
; ++hn
)
11536 ++counts
[lengths
[hn
]];
11541 printf (" 0 %-10lu (%5.1f%%)\n",
11542 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11543 for (i
= 1; i
<= maxlength
; ++i
)
11545 nzero_counts
+= counts
[i
] * i
;
11546 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11547 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11548 (nzero_counts
* 100.0) / nsyms
);
11556 if (buckets
!= NULL
)
11562 if (do_histogram
&& gnubuckets
!= NULL
)
11564 unsigned long * lengths
;
11565 unsigned long * counts
;
11567 unsigned long maxlength
= 0;
11568 unsigned long nzero_counts
= 0;
11569 unsigned long nsyms
= 0;
11571 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11572 (unsigned long) ngnubuckets
);
11574 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11575 if (lengths
== NULL
)
11577 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11581 printf (_(" Length Number %% of total Coverage\n"));
11583 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11584 if (gnubuckets
[hn
] != 0)
11586 bfd_vma off
, length
= 1;
11588 for (off
= gnubuckets
[hn
] - gnusymidx
;
11589 /* PR 17531 file: 010-77222-0.004. */
11590 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11593 lengths
[hn
] = length
;
11594 if (length
> maxlength
)
11595 maxlength
= length
;
11599 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11600 if (counts
== NULL
)
11603 error (_("Out of memory allocating space for gnu histogram counts\n"));
11607 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11608 ++counts
[lengths
[hn
]];
11610 if (ngnubuckets
> 0)
11613 printf (" 0 %-10lu (%5.1f%%)\n",
11614 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11615 for (j
= 1; j
<= maxlength
; ++j
)
11617 nzero_counts
+= counts
[j
] * j
;
11618 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11619 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11620 (nzero_counts
* 100.0) / nsyms
);
11634 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11638 if (dynamic_syminfo
== NULL
11640 /* No syminfo, this is ok. */
11643 /* There better should be a dynamic symbol section. */
11644 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11648 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11649 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11651 printf (_(" Num: Name BoundTo Flags\n"));
11652 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11654 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11656 printf ("%4d: ", i
);
11657 if (i
>= num_dynamic_syms
)
11658 printf (_("<corrupt index>"));
11659 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11660 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11662 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11665 switch (dynamic_syminfo
[i
].si_boundto
)
11667 case SYMINFO_BT_SELF
:
11668 fputs ("SELF ", stdout
);
11670 case SYMINFO_BT_PARENT
:
11671 fputs ("PARENT ", stdout
);
11674 if (dynamic_syminfo
[i
].si_boundto
> 0
11675 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11676 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11678 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11682 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11686 if (flags
& SYMINFO_FLG_DIRECT
)
11687 printf (" DIRECT");
11688 if (flags
& SYMINFO_FLG_PASSTHRU
)
11689 printf (" PASSTHRU");
11690 if (flags
& SYMINFO_FLG_COPY
)
11692 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11693 printf (" LAZYLOAD");
11701 #define IN_RANGE(START,END,ADDR,OFF) \
11702 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11704 /* Check to see if the given reloc needs to be handled in a target specific
11705 manner. If so then process the reloc and return TRUE otherwise return
11708 If called with reloc == NULL, then this is a signal that reloc processing
11709 for the current section has finished, and any saved state should be
11713 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11714 unsigned char * start
,
11715 unsigned char * end
,
11716 Elf_Internal_Sym
* symtab
,
11717 unsigned long num_syms
)
11719 unsigned int reloc_type
= 0;
11720 unsigned long sym_index
= 0;
11724 reloc_type
= get_reloc_type (reloc
->r_info
);
11725 sym_index
= get_reloc_symindex (reloc
->r_info
);
11728 switch (elf_header
.e_machine
)
11731 case EM_MSP430_OLD
:
11733 static Elf_Internal_Sym
* saved_sym
= NULL
;
11741 switch (reloc_type
)
11743 case 10: /* R_MSP430_SYM_DIFF */
11744 if (uses_msp430x_relocs ())
11746 /* Fall through. */
11747 case 21: /* R_MSP430X_SYM_DIFF */
11749 if (sym_index
>= num_syms
)
11750 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11753 saved_sym
= symtab
+ sym_index
;
11756 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11757 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11758 goto handle_sym_diff
;
11760 case 5: /* R_MSP430_16_BYTE */
11761 case 9: /* R_MSP430_8 */
11762 if (uses_msp430x_relocs ())
11764 goto handle_sym_diff
;
11766 case 2: /* R_MSP430_ABS16 */
11767 case 15: /* R_MSP430X_ABS16 */
11768 if (! uses_msp430x_relocs ())
11770 goto handle_sym_diff
;
11773 if (saved_sym
!= NULL
)
11775 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11778 if (sym_index
>= num_syms
)
11779 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11783 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11784 - saved_sym
->st_value
);
11786 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11787 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11790 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11791 (long) reloc
->r_offset
);
11800 if (saved_sym
!= NULL
)
11801 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11808 case EM_CYGNUS_MN10300
:
11810 static Elf_Internal_Sym
* saved_sym
= NULL
;
11818 switch (reloc_type
)
11820 case 34: /* R_MN10300_ALIGN */
11822 case 33: /* R_MN10300_SYM_DIFF */
11823 if (sym_index
>= num_syms
)
11824 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11827 saved_sym
= symtab
+ sym_index
;
11830 case 1: /* R_MN10300_32 */
11831 case 2: /* R_MN10300_16 */
11832 if (saved_sym
!= NULL
)
11834 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11837 if (sym_index
>= num_syms
)
11838 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11842 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11843 - saved_sym
->st_value
);
11845 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11846 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11848 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11849 (long) reloc
->r_offset
);
11857 if (saved_sym
!= NULL
)
11858 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11866 static bfd_vma saved_sym1
= 0;
11867 static bfd_vma saved_sym2
= 0;
11868 static bfd_vma value
;
11872 saved_sym1
= saved_sym2
= 0;
11876 switch (reloc_type
)
11878 case 0x80: /* R_RL78_SYM. */
11879 saved_sym1
= saved_sym2
;
11880 if (sym_index
>= num_syms
)
11881 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11885 saved_sym2
= symtab
[sym_index
].st_value
;
11886 saved_sym2
+= reloc
->r_addend
;
11890 case 0x83: /* R_RL78_OPsub. */
11891 value
= saved_sym1
- saved_sym2
;
11892 saved_sym2
= saved_sym1
= 0;
11896 case 0x41: /* R_RL78_ABS32. */
11897 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11898 byte_put (start
+ reloc
->r_offset
, value
, 4);
11900 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11901 (long) reloc
->r_offset
);
11905 case 0x43: /* R_RL78_ABS16. */
11906 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
11907 byte_put (start
+ reloc
->r_offset
, value
, 2);
11909 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11910 (long) reloc
->r_offset
);
11924 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11925 DWARF debug sections. This is a target specific test. Note - we do not
11926 go through the whole including-target-headers-multiple-times route, (as
11927 we have already done with <elf/h8.h>) because this would become very
11928 messy and even then this function would have to contain target specific
11929 information (the names of the relocs instead of their numeric values).
11930 FIXME: This is not the correct way to solve this problem. The proper way
11931 is to have target specific reloc sizing and typing functions created by
11932 the reloc-macros.h header, in the same way that it already creates the
11933 reloc naming functions. */
11936 is_32bit_abs_reloc (unsigned int reloc_type
)
11938 /* Please keep this table alpha-sorted for ease of visual lookup. */
11939 switch (elf_header
.e_machine
)
11943 return reloc_type
== 1; /* R_386_32. */
11945 return reloc_type
== 1; /* R_68K_32. */
11947 return reloc_type
== 1; /* R_860_32. */
11949 return reloc_type
== 2; /* R_960_32. */
11951 return (reloc_type
== 258
11952 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11953 case EM_ADAPTEVA_EPIPHANY
:
11954 return reloc_type
== 3;
11956 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11958 return reloc_type
== 1; /* R_ARC_32. */
11959 case EM_ARC_COMPACT
:
11960 case EM_ARC_COMPACT2
:
11961 return reloc_type
== 4; /* R_ARC_32. */
11963 return reloc_type
== 2; /* R_ARM_ABS32 */
11966 return reloc_type
== 1;
11968 return reloc_type
== 0x12; /* R_byte4_data. */
11970 return reloc_type
== 3; /* R_CRIS_32. */
11972 return reloc_type
== 3; /* R_CR16_NUM32. */
11974 return reloc_type
== 15; /* R_CRX_NUM32. */
11975 case EM_CYGNUS_FRV
:
11976 return reloc_type
== 1;
11977 case EM_CYGNUS_D10V
:
11979 return reloc_type
== 6; /* R_D10V_32. */
11980 case EM_CYGNUS_D30V
:
11982 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11984 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11985 case EM_CYGNUS_FR30
:
11987 return reloc_type
== 3; /* R_FR30_32. */
11989 return reloc_type
== 1; /* R_FT32_32. */
11993 return reloc_type
== 1; /* R_H8_DIR32. */
11995 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11996 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11999 return reloc_type
== 2; /* R_IP2K_32. */
12001 return reloc_type
== 2; /* R_IQ2000_32. */
12002 case EM_LATTICEMICO32
:
12003 return reloc_type
== 3; /* R_LM32_32. */
12006 return reloc_type
== 3; /* R_M32C_32. */
12008 return reloc_type
== 34; /* R_M32R_32_RELA. */
12011 return reloc_type
== 6; /* R_M68HC11_32. */
12013 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12014 case EM_CYGNUS_MEP
:
12015 return reloc_type
== 4; /* R_MEP_32. */
12017 return reloc_type
== 2; /* R_METAG_ADDR32. */
12018 case EM_MICROBLAZE
:
12019 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12021 return reloc_type
== 2; /* R_MIPS_32. */
12023 return reloc_type
== 4; /* R_MMIX_32. */
12024 case EM_CYGNUS_MN10200
:
12026 return reloc_type
== 1; /* R_MN10200_32. */
12027 case EM_CYGNUS_MN10300
:
12029 return reloc_type
== 1; /* R_MN10300_32. */
12031 return reloc_type
== 1; /* R_MOXIE_32. */
12032 case EM_MSP430_OLD
:
12034 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12036 return reloc_type
== 2; /* R_MT_32. */
12038 return reloc_type
== 20; /* R_NDS32_RELA. */
12039 case EM_ALTERA_NIOS2
:
12040 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12042 return reloc_type
== 1; /* R_NIOS_32. */
12044 return reloc_type
== 1; /* R_OR1K_32. */
12046 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12047 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12050 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12052 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12054 return reloc_type
== 1; /* R_PPC_ADDR32. */
12056 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12058 return reloc_type
== 1; /* R_RISCV_32. */
12060 return reloc_type
== 1; /* R_RL78_DIR32. */
12062 return reloc_type
== 1; /* R_RX_DIR32. */
12064 return reloc_type
== 1; /* R_I370_ADDR31. */
12067 return reloc_type
== 4; /* R_S390_32. */
12069 return reloc_type
== 8; /* R_SCORE_ABS32. */
12071 return reloc_type
== 1; /* R_SH_DIR32. */
12072 case EM_SPARC32PLUS
:
12075 return reloc_type
== 3 /* R_SPARC_32. */
12076 || reloc_type
== 23; /* R_SPARC_UA32. */
12078 return reloc_type
== 6; /* R_SPU_ADDR32 */
12080 return reloc_type
== 1; /* R_C6000_ABS32. */
12082 return reloc_type
== 2; /* R_TILEGX_32. */
12084 return reloc_type
== 1; /* R_TILEPRO_32. */
12085 case EM_CYGNUS_V850
:
12087 return reloc_type
== 6; /* R_V850_ABS32. */
12089 return reloc_type
== 0x33; /* R_V810_WORD. */
12091 return reloc_type
== 1; /* R_VAX_32. */
12093 return reloc_type
== 3; /* R_VISIUM_32. */
12097 return reloc_type
== 10; /* R_X86_64_32. */
12100 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12102 return reloc_type
== 4; /* R_XGATE_32. */
12104 return reloc_type
== 1; /* R_XSTROMY16_32. */
12105 case EM_XTENSA_OLD
:
12107 return reloc_type
== 1; /* R_XTENSA_32. */
12110 static unsigned int prev_warn
= 0;
12112 /* Avoid repeating the same warning multiple times. */
12113 if (prev_warn
!= elf_header
.e_machine
)
12114 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12115 elf_header
.e_machine
);
12116 prev_warn
= elf_header
.e_machine
;
12122 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12123 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12126 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12128 switch (elf_header
.e_machine
)
12129 /* Please keep this table alpha-sorted for ease of visual lookup. */
12133 return reloc_type
== 2; /* R_386_PC32. */
12135 return reloc_type
== 4; /* R_68K_PC32. */
12137 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12138 case EM_ADAPTEVA_EPIPHANY
:
12139 return reloc_type
== 6;
12141 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12142 case EM_ARC_COMPACT
:
12143 case EM_ARC_COMPACT2
:
12144 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12146 return reloc_type
== 3; /* R_ARM_REL32 */
12149 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12150 case EM_MICROBLAZE
:
12151 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12153 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12155 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12157 return reloc_type
== 26; /* R_PPC_REL32. */
12159 return reloc_type
== 26; /* R_PPC64_REL32. */
12162 return reloc_type
== 5; /* R_390_PC32. */
12164 return reloc_type
== 2; /* R_SH_REL32. */
12165 case EM_SPARC32PLUS
:
12168 return reloc_type
== 6; /* R_SPARC_DISP32. */
12170 return reloc_type
== 13; /* R_SPU_REL32. */
12172 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12174 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12176 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12180 return reloc_type
== 2; /* R_X86_64_PC32. */
12181 case EM_XTENSA_OLD
:
12183 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12185 /* Do not abort or issue an error message here. Not all targets use
12186 pc-relative 32-bit relocs in their DWARF debug information and we
12187 have already tested for target coverage in is_32bit_abs_reloc. A
12188 more helpful warning message will be generated by apply_relocations
12189 anyway, so just return. */
12194 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12195 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12198 is_64bit_abs_reloc (unsigned int reloc_type
)
12200 switch (elf_header
.e_machine
)
12203 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12205 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12207 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
12209 return reloc_type
== 80; /* R_PARISC_DIR64. */
12211 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12213 return reloc_type
== 2; /* R_RISCV_64. */
12214 case EM_SPARC32PLUS
:
12217 return reloc_type
== 54; /* R_SPARC_UA64. */
12221 return reloc_type
== 1; /* R_X86_64_64. */
12224 return reloc_type
== 22; /* R_S390_64. */
12226 return reloc_type
== 1; /* R_TILEGX_64. */
12228 return reloc_type
== 18; /* R_MIPS_64. */
12234 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12235 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12238 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12240 switch (elf_header
.e_machine
)
12243 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12245 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12247 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
12249 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12251 return reloc_type
== 44; /* R_PPC64_REL64. */
12252 case EM_SPARC32PLUS
:
12255 return reloc_type
== 46; /* R_SPARC_DISP64. */
12259 return reloc_type
== 24; /* R_X86_64_PC64. */
12262 return reloc_type
== 23; /* R_S390_PC64. */
12264 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12270 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12271 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12274 is_24bit_abs_reloc (unsigned int reloc_type
)
12276 switch (elf_header
.e_machine
)
12278 case EM_CYGNUS_MN10200
:
12280 return reloc_type
== 4; /* R_MN10200_24. */
12282 return reloc_type
== 5; /* R_FT32_20. */
12288 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12289 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12292 is_16bit_abs_reloc (unsigned int reloc_type
)
12294 /* Please keep this table alpha-sorted for ease of visual lookup. */
12295 switch (elf_header
.e_machine
)
12298 case EM_ARC_COMPACT
:
12299 case EM_ARC_COMPACT2
:
12300 return reloc_type
== 2; /* R_ARC_16. */
12301 case EM_ADAPTEVA_EPIPHANY
:
12302 return reloc_type
== 5;
12305 return reloc_type
== 4; /* R_AVR_16. */
12306 case EM_CYGNUS_D10V
:
12308 return reloc_type
== 3; /* R_D10V_16. */
12312 return reloc_type
== R_H8_DIR16
;
12315 return reloc_type
== 1; /* R_IP2K_16. */
12318 return reloc_type
== 1; /* R_M32C_16 */
12319 case EM_CYGNUS_MN10200
:
12321 return reloc_type
== 2; /* R_MN10200_16. */
12322 case EM_CYGNUS_MN10300
:
12324 return reloc_type
== 2; /* R_MN10300_16. */
12326 if (uses_msp430x_relocs ())
12327 return reloc_type
== 2; /* R_MSP430_ABS16. */
12328 /* Fall through. */
12329 case EM_MSP430_OLD
:
12330 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12332 return reloc_type
== 19; /* R_NDS32_RELA. */
12333 case EM_ALTERA_NIOS2
:
12334 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12336 return reloc_type
== 9; /* R_NIOS_16. */
12338 return reloc_type
== 2; /* R_OR1K_16. */
12340 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12342 return reloc_type
== 2; /* R_C6000_ABS16. */
12344 return reloc_type
== 2; /* R_VISIUM_16. */
12347 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12349 return reloc_type
== 3; /* R_XGATE_16. */
12355 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12356 relocation entries (possibly formerly used for SHT_GROUP sections). */
12359 is_none_reloc (unsigned int reloc_type
)
12361 switch (elf_header
.e_machine
)
12363 case EM_386
: /* R_386_NONE. */
12364 case EM_68K
: /* R_68K_NONE. */
12365 case EM_ADAPTEVA_EPIPHANY
:
12366 case EM_ALPHA
: /* R_ALPHA_NONE. */
12367 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12368 case EM_ARC
: /* R_ARC_NONE. */
12369 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12370 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12371 case EM_ARM
: /* R_ARM_NONE. */
12372 case EM_C166
: /* R_XC16X_NONE. */
12373 case EM_CRIS
: /* R_CRIS_NONE. */
12374 case EM_FT32
: /* R_FT32_NONE. */
12375 case EM_IA_64
: /* R_IA64_NONE. */
12376 case EM_K1OM
: /* R_X86_64_NONE. */
12377 case EM_L1OM
: /* R_X86_64_NONE. */
12378 case EM_M32R
: /* R_M32R_NONE. */
12379 case EM_MIPS
: /* R_MIPS_NONE. */
12380 case EM_MN10300
: /* R_MN10300_NONE. */
12381 case EM_MOXIE
: /* R_MOXIE_NONE. */
12382 case EM_NIOS32
: /* R_NIOS_NONE. */
12383 case EM_OR1K
: /* R_OR1K_NONE. */
12384 case EM_PARISC
: /* R_PARISC_NONE. */
12385 case EM_PPC64
: /* R_PPC64_NONE. */
12386 case EM_PPC
: /* R_PPC_NONE. */
12387 case EM_RISCV
: /* R_RISCV_NONE. */
12388 case EM_S390
: /* R_390_NONE. */
12390 case EM_SH
: /* R_SH_NONE. */
12391 case EM_SPARC32PLUS
:
12392 case EM_SPARC
: /* R_SPARC_NONE. */
12394 case EM_TILEGX
: /* R_TILEGX_NONE. */
12395 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12396 case EM_TI_C6000
:/* R_C6000_NONE. */
12397 case EM_X86_64
: /* R_X86_64_NONE. */
12399 return reloc_type
== 0;
12402 return reloc_type
== 0 || reloc_type
== 256;
12405 return (reloc_type
== 0 /* R_AVR_NONE. */
12406 || reloc_type
== 30 /* R_AVR_DIFF8. */
12407 || reloc_type
== 31 /* R_AVR_DIFF16. */
12408 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12410 return reloc_type
== 3; /* R_METAG_NONE. */
12412 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12413 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12414 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12415 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12416 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12418 return (reloc_type
== 0 /* R_PRU_NONE. */
12419 || reloc_type
== 65 /* R_PRU_DIFF8. */
12420 || reloc_type
== 66 /* R_PRU_DIFF16. */
12421 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12422 case EM_XTENSA_OLD
:
12424 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12425 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12426 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12427 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12432 /* Returns TRUE if there is a relocation against
12433 section NAME at OFFSET bytes. */
12436 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12438 Elf_Internal_Rela
* relocs
;
12439 Elf_Internal_Rela
* rp
;
12441 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12444 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12446 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12447 if (rp
->r_offset
== offset
)
12453 /* Apply relocations to a section.
12454 Returns TRUE upon success, FALSE otherwise.
12455 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12456 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12457 will be set to the number of relocs loaded.
12459 Note: So far support has been added only for those relocations
12460 which can be found in debug sections. FIXME: Add support for
12461 more relocations ? */
12464 apply_relocations (void * file
,
12465 const Elf_Internal_Shdr
* section
,
12466 unsigned char * start
,
12467 bfd_size_type size
,
12468 void ** relocs_return
,
12469 unsigned long * num_relocs_return
)
12471 Elf_Internal_Shdr
* relsec
;
12472 unsigned char * end
= start
+ size
;
12473 bfd_boolean res
= TRUE
;
12475 if (relocs_return
!= NULL
)
12477 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12478 * num_relocs_return
= 0;
12481 if (elf_header
.e_type
!= ET_REL
)
12482 /* No relocs to apply. */
12485 /* Find the reloc section associated with the section. */
12486 for (relsec
= section_headers
;
12487 relsec
< section_headers
+ elf_header
.e_shnum
;
12490 bfd_boolean is_rela
;
12491 unsigned long num_relocs
;
12492 Elf_Internal_Rela
* relocs
;
12493 Elf_Internal_Rela
* rp
;
12494 Elf_Internal_Shdr
* symsec
;
12495 Elf_Internal_Sym
* symtab
;
12496 unsigned long num_syms
;
12497 Elf_Internal_Sym
* sym
;
12499 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12500 || relsec
->sh_info
>= elf_header
.e_shnum
12501 || section_headers
+ relsec
->sh_info
!= section
12502 || relsec
->sh_size
== 0
12503 || relsec
->sh_link
>= elf_header
.e_shnum
)
12506 is_rela
= relsec
->sh_type
== SHT_RELA
;
12510 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12511 relsec
->sh_size
, & relocs
, & num_relocs
))
12516 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12517 relsec
->sh_size
, & relocs
, & num_relocs
))
12521 /* SH uses RELA but uses in place value instead of the addend field. */
12522 if (elf_header
.e_machine
== EM_SH
)
12525 symsec
= section_headers
+ relsec
->sh_link
;
12526 if (symsec
->sh_type
!= SHT_SYMTAB
12527 && symsec
->sh_type
!= SHT_DYNSYM
)
12529 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12531 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12534 unsigned int reloc_type
;
12535 unsigned int reloc_size
;
12536 unsigned char * rloc
;
12537 unsigned long sym_index
;
12539 reloc_type
= get_reloc_type (rp
->r_info
);
12541 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12543 else if (is_none_reloc (reloc_type
))
12545 else if (is_32bit_abs_reloc (reloc_type
)
12546 || is_32bit_pcrel_reloc (reloc_type
))
12548 else if (is_64bit_abs_reloc (reloc_type
)
12549 || is_64bit_pcrel_reloc (reloc_type
))
12551 else if (is_24bit_abs_reloc (reloc_type
))
12553 else if (is_16bit_abs_reloc (reloc_type
))
12557 static unsigned int prev_reloc
= 0;
12558 if (reloc_type
!= prev_reloc
)
12559 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12560 reloc_type
, printable_section_name (section
));
12561 prev_reloc
= reloc_type
;
12566 rloc
= start
+ rp
->r_offset
;
12567 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12569 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12570 (unsigned long) rp
->r_offset
,
12571 printable_section_name (section
));
12576 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12577 if (sym_index
>= num_syms
)
12579 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12580 sym_index
, printable_section_name (section
));
12584 sym
= symtab
+ sym_index
;
12586 /* If the reloc has a symbol associated with it,
12587 make sure that it is of an appropriate type.
12589 Relocations against symbols without type can happen.
12590 Gcc -feliminate-dwarf2-dups may generate symbols
12591 without type for debug info.
12593 Icc generates relocations against function symbols
12594 instead of local labels.
12596 Relocations against object symbols can happen, eg when
12597 referencing a global array. For an example of this see
12598 the _clz.o binary in libgcc.a. */
12600 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12601 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12603 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12604 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12605 (long int)(rp
- relocs
),
12606 printable_section_name (relsec
));
12613 addend
+= rp
->r_addend
;
12614 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12615 partial_inplace. */
12617 || (elf_header
.e_machine
== EM_XTENSA
12618 && reloc_type
== 1)
12619 || ((elf_header
.e_machine
== EM_PJ
12620 || elf_header
.e_machine
== EM_PJ_OLD
)
12621 && reloc_type
== 1)
12622 || ((elf_header
.e_machine
== EM_D30V
12623 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12624 && reloc_type
== 12))
12625 addend
+= byte_get (rloc
, reloc_size
);
12627 if (is_32bit_pcrel_reloc (reloc_type
)
12628 || is_64bit_pcrel_reloc (reloc_type
))
12630 /* On HPPA, all pc-relative relocations are biased by 8. */
12631 if (elf_header
.e_machine
== EM_PARISC
)
12633 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12637 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12641 /* Let the target specific reloc processing code know that
12642 we have finished with these relocs. */
12643 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12647 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12648 * num_relocs_return
= num_relocs
;
12659 #ifdef SUPPORT_DISASSEMBLY
12661 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12663 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12665 /* FIXME: XXX -- to be done --- XXX */
12671 /* Reads in the contents of SECTION from FILE, returning a pointer
12672 to a malloc'ed buffer or NULL if something went wrong. */
12675 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12677 bfd_size_type num_bytes
;
12679 num_bytes
= section
->sh_size
;
12681 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12683 printf (_("\nSection '%s' has no data to dump.\n"),
12684 printable_section_name (section
));
12688 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12689 _("section contents"));
12692 /* Uncompresses a section that was compressed using zlib, in place. */
12695 uncompress_section_contents (unsigned char **buffer
,
12696 dwarf_size_type uncompressed_size
,
12697 dwarf_size_type
*size
)
12699 dwarf_size_type compressed_size
= *size
;
12700 unsigned char * compressed_buffer
= *buffer
;
12701 unsigned char * uncompressed_buffer
;
12705 /* It is possible the section consists of several compressed
12706 buffers concatenated together, so we uncompress in a loop. */
12707 /* PR 18313: The state field in the z_stream structure is supposed
12708 to be invisible to the user (ie us), but some compilers will
12709 still complain about it being used without initialisation. So
12710 we first zero the entire z_stream structure and then set the fields
12712 memset (& strm
, 0, sizeof strm
);
12713 strm
.avail_in
= compressed_size
;
12714 strm
.next_in
= (Bytef
*) compressed_buffer
;
12715 strm
.avail_out
= uncompressed_size
;
12716 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12718 rc
= inflateInit (& strm
);
12719 while (strm
.avail_in
> 0)
12723 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12724 + (uncompressed_size
- strm
.avail_out
));
12725 rc
= inflate (&strm
, Z_FINISH
);
12726 if (rc
!= Z_STREAM_END
)
12728 rc
= inflateReset (& strm
);
12730 rc
= inflateEnd (& strm
);
12732 || strm
.avail_out
!= 0)
12735 *buffer
= uncompressed_buffer
;
12736 *size
= uncompressed_size
;
12740 free (uncompressed_buffer
);
12741 /* Indicate decompression failure. */
12747 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12749 Elf_Internal_Shdr
* relsec
;
12750 bfd_size_type num_bytes
;
12751 unsigned char * data
;
12752 unsigned char * end
;
12753 unsigned char * real_start
;
12754 unsigned char * start
;
12755 bfd_boolean some_strings_shown
;
12757 real_start
= start
= (unsigned char *) get_section_contents (section
,
12761 num_bytes
= section
->sh_size
;
12763 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12765 if (decompress_dumps
)
12767 dwarf_size_type new_size
= num_bytes
;
12768 dwarf_size_type uncompressed_size
= 0;
12770 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12772 Elf_Internal_Chdr chdr
;
12773 unsigned int compression_header_size
12774 = get_compression_header (& chdr
, (unsigned char *) start
,
12777 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12779 warn (_("section '%s' has unsupported compress type: %d\n"),
12780 printable_section_name (section
), chdr
.ch_type
);
12783 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12785 warn (_("compressed section '%s' is corrupted\n"),
12786 printable_section_name (section
));
12789 uncompressed_size
= chdr
.ch_size
;
12790 start
+= compression_header_size
;
12791 new_size
-= compression_header_size
;
12793 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12795 /* Read the zlib header. In this case, it should be "ZLIB"
12796 followed by the uncompressed section size, 8 bytes in
12797 big-endian order. */
12798 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12799 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12800 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12801 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12802 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12803 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12804 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12805 uncompressed_size
+= start
[11];
12810 if (uncompressed_size
)
12812 if (uncompress_section_contents (& start
,
12813 uncompressed_size
, & new_size
))
12814 num_bytes
= new_size
;
12817 error (_("Unable to decompress section %s\n"),
12818 printable_section_name (section
));
12823 start
= real_start
;
12826 /* If the section being dumped has relocations against it the user might
12827 be expecting these relocations to have been applied. Check for this
12828 case and issue a warning message in order to avoid confusion.
12829 FIXME: Maybe we ought to have an option that dumps a section with
12830 relocs applied ? */
12831 for (relsec
= section_headers
;
12832 relsec
< section_headers
+ elf_header
.e_shnum
;
12835 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12836 || relsec
->sh_info
>= elf_header
.e_shnum
12837 || section_headers
+ relsec
->sh_info
!= section
12838 || relsec
->sh_size
== 0
12839 || relsec
->sh_link
>= elf_header
.e_shnum
)
12842 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12847 end
= start
+ num_bytes
;
12848 some_strings_shown
= FALSE
;
12852 while (!ISPRINT (* data
))
12853 if (++ data
>= end
)
12858 size_t maxlen
= end
- data
;
12861 /* PR 11128: Use two separate invocations in order to work
12862 around bugs in the Solaris 8 implementation of printf. */
12863 printf (" [%6tx] ", data
- start
);
12865 printf (" [%6Ix] ", (size_t) (data
- start
));
12869 print_symbol ((int) maxlen
, (const char *) data
);
12871 data
+= strnlen ((const char *) data
, maxlen
);
12875 printf (_("<corrupt>\n"));
12878 some_strings_shown
= TRUE
;
12882 if (! some_strings_shown
)
12883 printf (_(" No strings found in this section."));
12892 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12894 bfd_boolean relocate
)
12896 Elf_Internal_Shdr
* relsec
;
12897 bfd_size_type bytes
;
12898 bfd_size_type section_size
;
12900 unsigned char * data
;
12901 unsigned char * real_start
;
12902 unsigned char * start
;
12904 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12908 section_size
= section
->sh_size
;
12910 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12912 if (decompress_dumps
)
12914 dwarf_size_type new_size
= section_size
;
12915 dwarf_size_type uncompressed_size
= 0;
12917 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12919 Elf_Internal_Chdr chdr
;
12920 unsigned int compression_header_size
12921 = get_compression_header (& chdr
, start
, section_size
);
12923 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12925 warn (_("section '%s' has unsupported compress type: %d\n"),
12926 printable_section_name (section
), chdr
.ch_type
);
12929 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12931 warn (_("compressed section '%s' is corrupted\n"),
12932 printable_section_name (section
));
12935 uncompressed_size
= chdr
.ch_size
;
12936 start
+= compression_header_size
;
12937 new_size
-= compression_header_size
;
12939 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12941 /* Read the zlib header. In this case, it should be "ZLIB"
12942 followed by the uncompressed section size, 8 bytes in
12943 big-endian order. */
12944 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12945 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12946 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12947 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12948 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12949 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12950 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12951 uncompressed_size
+= start
[11];
12956 if (uncompressed_size
)
12958 if (uncompress_section_contents (& start
, uncompressed_size
,
12961 section_size
= new_size
;
12965 error (_("Unable to decompress section %s\n"),
12966 printable_section_name (section
));
12967 /* FIXME: Print the section anyway ? */
12972 start
= real_start
;
12977 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
12982 /* If the section being dumped has relocations against it the user might
12983 be expecting these relocations to have been applied. Check for this
12984 case and issue a warning message in order to avoid confusion.
12985 FIXME: Maybe we ought to have an option that dumps a section with
12986 relocs applied ? */
12987 for (relsec
= section_headers
;
12988 relsec
< section_headers
+ elf_header
.e_shnum
;
12991 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12992 || relsec
->sh_info
>= elf_header
.e_shnum
12993 || section_headers
+ relsec
->sh_info
!= section
12994 || relsec
->sh_size
== 0
12995 || relsec
->sh_link
>= elf_header
.e_shnum
)
12998 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13003 addr
= section
->sh_addr
;
13004 bytes
= section_size
;
13013 lbytes
= (bytes
> 16 ? 16 : bytes
);
13015 printf (" 0x%8.8lx ", (unsigned long) addr
);
13017 for (j
= 0; j
< 16; j
++)
13020 printf ("%2.2x", data
[j
]);
13028 for (j
= 0; j
< lbytes
; j
++)
13031 if (k
>= ' ' && k
< 0x7f)
13051 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13052 const Elf_Internal_Shdr
* sec
, void * file
)
13054 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13057 /* If it is already loaded, do nothing. */
13058 if (section
->start
!= NULL
)
13061 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13062 section
->address
= sec
->sh_addr
;
13063 section
->user_data
= NULL
;
13064 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13066 sec
->sh_size
, buf
);
13067 if (section
->start
== NULL
)
13071 unsigned char *start
= section
->start
;
13072 dwarf_size_type size
= sec
->sh_size
;
13073 dwarf_size_type uncompressed_size
= 0;
13075 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13077 Elf_Internal_Chdr chdr
;
13078 unsigned int compression_header_size
;
13080 if (size
< (is_32bit_elf
13081 ? sizeof (Elf32_External_Chdr
)
13082 : sizeof (Elf64_External_Chdr
)))
13084 warn (_("compressed section %s is too small to contain a compression header"),
13089 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13091 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13093 warn (_("section '%s' has unsupported compress type: %d\n"),
13094 section
->name
, chdr
.ch_type
);
13097 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13099 warn (_("compressed section '%s' is corrupted\n"),
13103 uncompressed_size
= chdr
.ch_size
;
13104 start
+= compression_header_size
;
13105 size
-= compression_header_size
;
13107 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13109 /* Read the zlib header. In this case, it should be "ZLIB"
13110 followed by the uncompressed section size, 8 bytes in
13111 big-endian order. */
13112 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13113 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13114 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13115 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13116 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13117 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13118 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13119 uncompressed_size
+= start
[11];
13124 if (uncompressed_size
)
13126 if (uncompress_section_contents (&start
, uncompressed_size
,
13129 /* Free the compressed buffer, update the section buffer
13130 and the section size if uncompress is successful. */
13131 free (section
->start
);
13132 section
->start
= start
;
13136 error (_("Unable to decompress section %s\n"),
13137 printable_section_name (sec
));
13142 section
->size
= size
;
13145 if (section
->start
== NULL
)
13148 if (debug_displays
[debug
].relocate
)
13150 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13151 & section
->reloc_info
, & section
->num_relocs
))
13156 section
->reloc_info
= NULL
;
13157 section
->num_relocs
= 0;
13163 /* If this is not NULL, load_debug_section will only look for sections
13164 within the list of sections given here. */
13165 static unsigned int * section_subset
= NULL
;
13168 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13170 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13171 Elf_Internal_Shdr
* sec
;
13173 /* Locate the debug section. */
13174 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13176 section
->name
= section
->uncompressed_name
;
13179 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13181 section
->name
= section
->compressed_name
;
13186 /* If we're loading from a subset of sections, and we've loaded
13187 a section matching this name before, it's likely that it's a
13189 if (section_subset
!= NULL
)
13190 free_debug_section (debug
);
13192 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13196 free_debug_section (enum dwarf_section_display_enum debug
)
13198 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13200 if (section
->start
== NULL
)
13203 free ((char *) section
->start
);
13204 section
->start
= NULL
;
13205 section
->address
= 0;
13210 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13212 char * name
= SECTION_NAME (section
);
13213 const char * print_name
= printable_section_name (section
);
13214 bfd_size_type length
;
13215 bfd_boolean result
= TRUE
;
13218 length
= section
->sh_size
;
13221 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13224 if (section
->sh_type
== SHT_NOBITS
)
13226 /* There is no point in dumping the contents of a debugging section
13227 which has the NOBITS type - the bits in the file will be random.
13228 This can happen when a file containing a .eh_frame section is
13229 stripped with the --only-keep-debug command line option. */
13230 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13235 if (const_strneq (name
, ".gnu.linkonce.wi."))
13236 name
= ".debug_info";
13238 /* See if we know how to display the contents of this section. */
13239 for (i
= 0; i
< max
; i
++)
13240 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13241 || (i
== line
&& const_strneq (name
, ".debug_line."))
13242 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13244 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13245 int secondary
= (section
!= find_section (name
));
13248 free_debug_section ((enum dwarf_section_display_enum
) i
);
13250 if (i
== line
&& const_strneq (name
, ".debug_line."))
13252 else if (streq (sec
->uncompressed_name
, name
))
13253 sec
->name
= sec
->uncompressed_name
;
13255 sec
->name
= sec
->compressed_name
;
13256 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13259 /* If this debug section is part of a CU/TU set in a .dwp file,
13260 restrict load_debug_section to the sections in that set. */
13261 section_subset
= find_cu_tu_set (file
, shndx
);
13263 result
&= debug_displays
[i
].display (sec
, file
);
13265 section_subset
= NULL
;
13267 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13268 free_debug_section ((enum dwarf_section_display_enum
) i
);
13276 printf (_("Unrecognized debug section: %s\n"), print_name
);
13283 /* Set DUMP_SECTS for all sections where dumps were requested
13284 based on section name. */
13287 initialise_dumps_byname (void)
13289 struct dump_list_entry
* cur
;
13291 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13294 bfd_boolean any
= FALSE
;
13296 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13297 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13299 request_dump_bynumber (i
, cur
->type
);
13304 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13310 process_section_contents (FILE * file
)
13312 Elf_Internal_Shdr
* section
;
13314 bfd_boolean res
= TRUE
;
13319 initialise_dumps_byname ();
13321 for (i
= 0, section
= section_headers
;
13322 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13325 #ifdef SUPPORT_DISASSEMBLY
13326 if (dump_sects
[i
] & DISASS_DUMP
)
13327 disassemble_section (section
, file
);
13329 if (dump_sects
[i
] & HEX_DUMP
)
13331 if (! dump_section_as_bytes (section
, file
, FALSE
))
13335 if (dump_sects
[i
] & RELOC_DUMP
)
13337 if (! dump_section_as_bytes (section
, file
, TRUE
))
13341 if (dump_sects
[i
] & STRING_DUMP
)
13343 if (! dump_section_as_strings (section
, file
))
13347 if (dump_sects
[i
] & DEBUG_DUMP
)
13349 if (! display_debug_section (i
, section
, file
))
13354 /* Check to see if the user requested a
13355 dump of a section that does not exist. */
13356 while (i
< num_dump_sects
)
13360 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13370 process_mips_fpe_exception (int mask
)
13374 bfd_boolean first
= TRUE
;
13376 if (mask
& OEX_FPU_INEX
)
13377 fputs ("INEX", stdout
), first
= FALSE
;
13378 if (mask
& OEX_FPU_UFLO
)
13379 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13380 if (mask
& OEX_FPU_OFLO
)
13381 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13382 if (mask
& OEX_FPU_DIV0
)
13383 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13384 if (mask
& OEX_FPU_INVAL
)
13385 printf ("%sINVAL", first
? "" : "|");
13388 fputs ("0", stdout
);
13391 /* Display's the value of TAG at location P. If TAG is
13392 greater than 0 it is assumed to be an unknown tag, and
13393 a message is printed to this effect. Otherwise it is
13394 assumed that a message has already been printed.
13396 If the bottom bit of TAG is set it assumed to have a
13397 string value, otherwise it is assumed to have an integer
13400 Returns an updated P pointing to the first unread byte
13401 beyond the end of TAG's value.
13403 Reads at or beyond END will not be made. */
13405 static unsigned char *
13406 display_tag_value (signed int tag
,
13408 const unsigned char * const end
)
13413 printf (" Tag_unknown_%d: ", tag
);
13417 warn (_("<corrupt tag>\n"));
13421 /* PR 17531 file: 027-19978-0.004. */
13422 size_t maxlen
= (end
- p
) - 1;
13427 print_symbol ((int) maxlen
, (const char *) p
);
13428 p
+= strnlen ((char *) p
, maxlen
) + 1;
13432 printf (_("<corrupt string tag>"));
13433 p
= (unsigned char *) end
;
13441 val
= read_uleb128 (p
, &len
, end
);
13443 printf ("%ld (0x%lx)\n", val
, val
);
13450 /* ARM EABI attributes section. */
13455 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13457 const char ** table
;
13458 } arm_attr_public_tag
;
13460 static const char * arm_attr_tag_CPU_arch
[] =
13461 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13462 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13464 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13465 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13466 {"No", "Thumb-1", "Thumb-2", "Yes"};
13467 static const char * arm_attr_tag_FP_arch
[] =
13468 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13469 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13470 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13471 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13472 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13473 "NEON for ARMv8.1"};
13474 static const char * arm_attr_tag_PCS_config
[] =
13475 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13476 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13477 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13478 {"V6", "SB", "TLS", "Unused"};
13479 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13480 {"Absolute", "PC-relative", "SB-relative", "None"};
13481 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13482 {"Absolute", "PC-relative", "None"};
13483 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13484 {"None", "direct", "GOT-indirect"};
13485 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13486 {"None", "??? 1", "2", "??? 3", "4"};
13487 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13488 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13489 {"Unused", "Needed", "Sign only"};
13490 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13491 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13492 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13493 {"Unused", "Finite", "RTABI", "IEEE 754"};
13494 static const char * arm_attr_tag_ABI_enum_size
[] =
13495 {"Unused", "small", "int", "forced to int"};
13496 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13497 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13498 static const char * arm_attr_tag_ABI_VFP_args
[] =
13499 {"AAPCS", "VFP registers", "custom", "compatible"};
13500 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13501 {"AAPCS", "WMMX registers", "custom"};
13502 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13503 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13504 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13505 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13506 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13507 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13508 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13509 static const char * arm_attr_tag_FP_HP_extension
[] =
13510 {"Not Allowed", "Allowed"};
13511 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13512 {"None", "IEEE 754", "Alternative Format"};
13513 static const char * arm_attr_tag_DSP_extension
[] =
13514 {"Follow architecture", "Allowed"};
13515 static const char * arm_attr_tag_MPextension_use
[] =
13516 {"Not Allowed", "Allowed"};
13517 static const char * arm_attr_tag_DIV_use
[] =
13518 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13519 "Allowed in v7-A with integer division extension"};
13520 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13521 static const char * arm_attr_tag_Virtualization_use
[] =
13522 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13523 "TrustZone and Virtualization Extensions"};
13524 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13525 {"Not Allowed", "Allowed"};
13527 #define LOOKUP(id, name) \
13528 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13529 static arm_attr_public_tag arm_attr_public_tags
[] =
13531 {4, "CPU_raw_name", 1, NULL
},
13532 {5, "CPU_name", 1, NULL
},
13533 LOOKUP(6, CPU_arch
),
13534 {7, "CPU_arch_profile", 0, NULL
},
13535 LOOKUP(8, ARM_ISA_use
),
13536 LOOKUP(9, THUMB_ISA_use
),
13537 LOOKUP(10, FP_arch
),
13538 LOOKUP(11, WMMX_arch
),
13539 LOOKUP(12, Advanced_SIMD_arch
),
13540 LOOKUP(13, PCS_config
),
13541 LOOKUP(14, ABI_PCS_R9_use
),
13542 LOOKUP(15, ABI_PCS_RW_data
),
13543 LOOKUP(16, ABI_PCS_RO_data
),
13544 LOOKUP(17, ABI_PCS_GOT_use
),
13545 LOOKUP(18, ABI_PCS_wchar_t
),
13546 LOOKUP(19, ABI_FP_rounding
),
13547 LOOKUP(20, ABI_FP_denormal
),
13548 LOOKUP(21, ABI_FP_exceptions
),
13549 LOOKUP(22, ABI_FP_user_exceptions
),
13550 LOOKUP(23, ABI_FP_number_model
),
13551 {24, "ABI_align_needed", 0, NULL
},
13552 {25, "ABI_align_preserved", 0, NULL
},
13553 LOOKUP(26, ABI_enum_size
),
13554 LOOKUP(27, ABI_HardFP_use
),
13555 LOOKUP(28, ABI_VFP_args
),
13556 LOOKUP(29, ABI_WMMX_args
),
13557 LOOKUP(30, ABI_optimization_goals
),
13558 LOOKUP(31, ABI_FP_optimization_goals
),
13559 {32, "compatibility", 0, NULL
},
13560 LOOKUP(34, CPU_unaligned_access
),
13561 LOOKUP(36, FP_HP_extension
),
13562 LOOKUP(38, ABI_FP_16bit_format
),
13563 LOOKUP(42, MPextension_use
),
13564 LOOKUP(44, DIV_use
),
13565 LOOKUP(46, DSP_extension
),
13566 {64, "nodefaults", 0, NULL
},
13567 {65, "also_compatible_with", 0, NULL
},
13568 LOOKUP(66, T2EE_use
),
13569 {67, "conformance", 1, NULL
},
13570 LOOKUP(68, Virtualization_use
),
13571 LOOKUP(70, MPextension_use_legacy
)
13575 static unsigned char *
13576 display_arm_attribute (unsigned char * p
,
13577 const unsigned char * const end
)
13582 arm_attr_public_tag
* attr
;
13586 tag
= read_uleb128 (p
, &len
, end
);
13589 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13591 if (arm_attr_public_tags
[i
].tag
== tag
)
13593 attr
= &arm_attr_public_tags
[i
];
13600 printf (" Tag_%s: ", attr
->name
);
13601 switch (attr
->type
)
13606 case 7: /* Tag_CPU_arch_profile. */
13607 val
= read_uleb128 (p
, &len
, end
);
13611 case 0: printf (_("None\n")); break;
13612 case 'A': printf (_("Application\n")); break;
13613 case 'R': printf (_("Realtime\n")); break;
13614 case 'M': printf (_("Microcontroller\n")); break;
13615 case 'S': printf (_("Application or Realtime\n")); break;
13616 default: printf ("??? (%d)\n", val
); break;
13620 case 24: /* Tag_align_needed. */
13621 val
= read_uleb128 (p
, &len
, end
);
13625 case 0: printf (_("None\n")); break;
13626 case 1: printf (_("8-byte\n")); break;
13627 case 2: printf (_("4-byte\n")); break;
13628 case 3: printf ("??? 3\n"); break;
13631 printf (_("8-byte and up to %d-byte extended\n"),
13634 printf ("??? (%d)\n", val
);
13639 case 25: /* Tag_align_preserved. */
13640 val
= read_uleb128 (p
, &len
, end
);
13644 case 0: printf (_("None\n")); break;
13645 case 1: printf (_("8-byte, except leaf SP\n")); break;
13646 case 2: printf (_("8-byte\n")); break;
13647 case 3: printf ("??? 3\n"); break;
13650 printf (_("8-byte and up to %d-byte extended\n"),
13653 printf ("??? (%d)\n", val
);
13658 case 32: /* Tag_compatibility. */
13660 val
= read_uleb128 (p
, &len
, end
);
13662 printf (_("flag = %d, vendor = "), val
);
13665 size_t maxlen
= (end
- p
) - 1;
13667 print_symbol ((int) maxlen
, (const char *) p
);
13668 p
+= strnlen ((char *) p
, maxlen
) + 1;
13672 printf (_("<corrupt>"));
13673 p
= (unsigned char *) end
;
13679 case 64: /* Tag_nodefaults. */
13680 /* PR 17531: file: 001-505008-0.01. */
13683 printf (_("True\n"));
13686 case 65: /* Tag_also_compatible_with. */
13687 val
= read_uleb128 (p
, &len
, end
);
13689 if (val
== 6 /* Tag_CPU_arch. */)
13691 val
= read_uleb128 (p
, &len
, end
);
13693 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13694 printf ("??? (%d)\n", val
);
13696 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13700 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13705 printf (_("<unknown: %d>\n"), tag
);
13711 return display_tag_value (-1, p
, end
);
13713 return display_tag_value (0, p
, end
);
13716 assert (attr
->type
& 0x80);
13717 val
= read_uleb128 (p
, &len
, end
);
13719 type
= attr
->type
& 0x7f;
13721 printf ("??? (%d)\n", val
);
13723 printf ("%s\n", attr
->table
[val
]);
13728 return display_tag_value (tag
, p
, end
);
13731 static unsigned char *
13732 display_gnu_attribute (unsigned char * p
,
13733 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
13734 const unsigned char * const end
)
13740 tag
= read_uleb128 (p
, &len
, end
);
13743 /* Tag_compatibility is the only generic GNU attribute defined at
13747 val
= read_uleb128 (p
, &len
, end
);
13750 printf (_("flag = %d, vendor = "), val
);
13753 printf (_("<corrupt>\n"));
13754 warn (_("corrupt vendor attribute\n"));
13760 size_t maxlen
= (end
- p
) - 1;
13762 print_symbol ((int) maxlen
, (const char *) p
);
13763 p
+= strnlen ((char *) p
, maxlen
) + 1;
13767 printf (_("<corrupt>"));
13768 p
= (unsigned char *) end
;
13775 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13776 return display_proc_gnu_attribute (p
, tag
, end
);
13778 return display_tag_value (tag
, p
, end
);
13781 static unsigned char *
13782 display_power_gnu_attribute (unsigned char * p
,
13784 const unsigned char * const end
)
13789 if (tag
== Tag_GNU_Power_ABI_FP
)
13791 val
= read_uleb128 (p
, &len
, end
);
13793 printf (" Tag_GNU_Power_ABI_FP: ");
13796 printf (_("<corrupt>\n"));
13801 printf ("(%#x), ", val
);
13806 printf (_("unspecified hard/soft float, "));
13809 printf (_("hard float, "));
13812 printf (_("soft float, "));
13815 printf (_("single-precision hard float, "));
13822 printf (_("unspecified long double\n"));
13825 printf (_("128-bit IBM long double\n"));
13828 printf (_("64-bit long double\n"));
13831 printf (_("128-bit IEEE long double\n"));
13837 if (tag
== Tag_GNU_Power_ABI_Vector
)
13839 val
= read_uleb128 (p
, &len
, end
);
13841 printf (" Tag_GNU_Power_ABI_Vector: ");
13844 printf (_("<corrupt>\n"));
13849 printf ("(%#x), ", val
);
13854 printf (_("unspecified\n"));
13857 printf (_("generic\n"));
13860 printf ("AltiVec\n");
13869 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13871 val
= read_uleb128 (p
, &len
, end
);
13873 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13876 printf (_("<corrupt>\n"));
13881 printf ("(%#x), ", val
);
13886 printf (_("unspecified\n"));
13889 printf ("r3/r4\n");
13892 printf (_("memory\n"));
13901 return display_tag_value (tag
& 1, p
, end
);
13904 static unsigned char *
13905 display_s390_gnu_attribute (unsigned char * p
,
13907 const unsigned char * const end
)
13912 if (tag
== Tag_GNU_S390_ABI_Vector
)
13914 val
= read_uleb128 (p
, &len
, end
);
13916 printf (" Tag_GNU_S390_ABI_Vector: ");
13921 printf (_("any\n"));
13924 printf (_("software\n"));
13927 printf (_("hardware\n"));
13930 printf ("??? (%d)\n", val
);
13936 return display_tag_value (tag
& 1, p
, end
);
13940 display_sparc_hwcaps (unsigned int mask
)
13944 bfd_boolean first
= TRUE
;
13946 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13947 fputs ("mul32", stdout
), first
= FALSE
;
13948 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13949 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
13950 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13951 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
13952 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13953 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
13954 if (mask
& ELF_SPARC_HWCAP_POPC
)
13955 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
13956 if (mask
& ELF_SPARC_HWCAP_VIS
)
13957 printf ("%svis", first
? "" : "|"), first
= FALSE
;
13958 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13959 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
13960 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13961 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
13962 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13963 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
13964 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13965 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
13966 if (mask
& ELF_SPARC_HWCAP_HPC
)
13967 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
13968 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13969 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
13970 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13971 printf ("%strans", first
? "" : "|"), first
= FALSE
;
13972 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13973 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
13974 if (mask
& ELF_SPARC_HWCAP_IMA
)
13975 printf ("%sima", first
? "" : "|"), first
= FALSE
;
13976 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13977 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
13980 fputc ('0', stdout
);
13981 fputc ('\n', stdout
);
13985 display_sparc_hwcaps2 (unsigned int mask
)
13989 bfd_boolean first
= TRUE
;
13991 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13992 fputs ("fjathplus", stdout
), first
= FALSE
;
13993 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13994 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
13995 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13996 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
13997 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13998 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
13999 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14000 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14001 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14002 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14003 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14004 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14005 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14006 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14007 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14008 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14009 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14010 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14011 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14012 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14015 fputc ('0', stdout
);
14016 fputc ('\n', stdout
);
14019 static unsigned char *
14020 display_sparc_gnu_attribute (unsigned char * p
,
14022 const unsigned char * const end
)
14027 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14029 val
= read_uleb128 (p
, &len
, end
);
14031 printf (" Tag_GNU_Sparc_HWCAPS: ");
14032 display_sparc_hwcaps (val
);
14035 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14037 val
= read_uleb128 (p
, &len
, end
);
14039 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14040 display_sparc_hwcaps2 (val
);
14044 return display_tag_value (tag
, p
, end
);
14048 print_mips_fp_abi_value (unsigned int val
)
14052 case Val_GNU_MIPS_ABI_FP_ANY
:
14053 printf (_("Hard or soft float\n"));
14055 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14056 printf (_("Hard float (double precision)\n"));
14058 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14059 printf (_("Hard float (single precision)\n"));
14061 case Val_GNU_MIPS_ABI_FP_SOFT
:
14062 printf (_("Soft float\n"));
14064 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14065 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14067 case Val_GNU_MIPS_ABI_FP_XX
:
14068 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14070 case Val_GNU_MIPS_ABI_FP_64
:
14071 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14073 case Val_GNU_MIPS_ABI_FP_64A
:
14074 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14076 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14077 printf (_("NaN 2008 compatibility\n"));
14080 printf ("??? (%d)\n", val
);
14085 static unsigned char *
14086 display_mips_gnu_attribute (unsigned char * p
,
14088 const unsigned char * const end
)
14090 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14095 val
= read_uleb128 (p
, &len
, end
);
14097 printf (" Tag_GNU_MIPS_ABI_FP: ");
14099 print_mips_fp_abi_value (val
);
14104 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14109 val
= read_uleb128 (p
, &len
, end
);
14111 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14115 case Val_GNU_MIPS_ABI_MSA_ANY
:
14116 printf (_("Any MSA or not\n"));
14118 case Val_GNU_MIPS_ABI_MSA_128
:
14119 printf (_("128-bit MSA\n"));
14122 printf ("??? (%d)\n", val
);
14128 return display_tag_value (tag
& 1, p
, end
);
14131 static unsigned char *
14132 display_tic6x_attribute (unsigned char * p
,
14133 const unsigned char * const end
)
14139 tag
= read_uleb128 (p
, &len
, end
);
14145 val
= read_uleb128 (p
, &len
, end
);
14147 printf (" Tag_ISA: ");
14151 case C6XABI_Tag_ISA_none
:
14152 printf (_("None\n"));
14154 case C6XABI_Tag_ISA_C62X
:
14157 case C6XABI_Tag_ISA_C67X
:
14160 case C6XABI_Tag_ISA_C67XP
:
14161 printf ("C67x+\n");
14163 case C6XABI_Tag_ISA_C64X
:
14166 case C6XABI_Tag_ISA_C64XP
:
14167 printf ("C64x+\n");
14169 case C6XABI_Tag_ISA_C674X
:
14170 printf ("C674x\n");
14173 printf ("??? (%d)\n", val
);
14178 case Tag_ABI_wchar_t
:
14179 val
= read_uleb128 (p
, &len
, end
);
14181 printf (" Tag_ABI_wchar_t: ");
14185 printf (_("Not used\n"));
14188 printf (_("2 bytes\n"));
14191 printf (_("4 bytes\n"));
14194 printf ("??? (%d)\n", val
);
14199 case Tag_ABI_stack_align_needed
:
14200 val
= read_uleb128 (p
, &len
, end
);
14202 printf (" Tag_ABI_stack_align_needed: ");
14206 printf (_("8-byte\n"));
14209 printf (_("16-byte\n"));
14212 printf ("??? (%d)\n", val
);
14217 case Tag_ABI_stack_align_preserved
:
14218 val
= read_uleb128 (p
, &len
, end
);
14220 printf (" Tag_ABI_stack_align_preserved: ");
14224 printf (_("8-byte\n"));
14227 printf (_("16-byte\n"));
14230 printf ("??? (%d)\n", val
);
14236 val
= read_uleb128 (p
, &len
, end
);
14238 printf (" Tag_ABI_DSBT: ");
14242 printf (_("DSBT addressing not used\n"));
14245 printf (_("DSBT addressing used\n"));
14248 printf ("??? (%d)\n", val
);
14254 val
= read_uleb128 (p
, &len
, end
);
14256 printf (" Tag_ABI_PID: ");
14260 printf (_("Data addressing position-dependent\n"));
14263 printf (_("Data addressing position-independent, GOT near DP\n"));
14266 printf (_("Data addressing position-independent, GOT far from DP\n"));
14269 printf ("??? (%d)\n", val
);
14275 val
= read_uleb128 (p
, &len
, end
);
14277 printf (" Tag_ABI_PIC: ");
14281 printf (_("Code addressing position-dependent\n"));
14284 printf (_("Code addressing position-independent\n"));
14287 printf ("??? (%d)\n", val
);
14292 case Tag_ABI_array_object_alignment
:
14293 val
= read_uleb128 (p
, &len
, end
);
14295 printf (" Tag_ABI_array_object_alignment: ");
14299 printf (_("8-byte\n"));
14302 printf (_("4-byte\n"));
14305 printf (_("16-byte\n"));
14308 printf ("??? (%d)\n", val
);
14313 case Tag_ABI_array_object_align_expected
:
14314 val
= read_uleb128 (p
, &len
, end
);
14316 printf (" Tag_ABI_array_object_align_expected: ");
14320 printf (_("8-byte\n"));
14323 printf (_("4-byte\n"));
14326 printf (_("16-byte\n"));
14329 printf ("??? (%d)\n", val
);
14334 case Tag_ABI_compatibility
:
14336 val
= read_uleb128 (p
, &len
, end
);
14338 printf (" Tag_ABI_compatibility: ");
14339 printf (_("flag = %d, vendor = "), val
);
14342 size_t maxlen
= (end
- p
) - 1;
14344 print_symbol ((int) maxlen
, (const char *) p
);
14345 p
+= strnlen ((char *) p
, maxlen
) + 1;
14349 printf (_("<corrupt>"));
14350 p
= (unsigned char *) end
;
14356 case Tag_ABI_conformance
:
14358 printf (" Tag_ABI_conformance: \"");
14361 size_t maxlen
= (end
- p
) - 1;
14363 print_symbol ((int) maxlen
, (const char *) p
);
14364 p
+= strnlen ((char *) p
, maxlen
) + 1;
14368 printf (_("<corrupt>"));
14369 p
= (unsigned char *) end
;
14376 return display_tag_value (tag
, p
, end
);
14380 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14382 unsigned long addr
= 0;
14383 size_t bytes
= end
- p
;
14390 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14392 printf (" 0x%8.8lx ", addr
);
14394 for (j
= 0; j
< 16; j
++)
14397 printf ("%2.2x", p
[j
]);
14405 for (j
= 0; j
< lbytes
; j
++)
14408 if (k
>= ' ' && k
< 0x7f)
14424 static unsigned char *
14425 display_msp430x_attribute (unsigned char * p
,
14426 const unsigned char * const end
)
14432 tag
= read_uleb128 (p
, & len
, end
);
14437 case OFBA_MSPABI_Tag_ISA
:
14438 val
= read_uleb128 (p
, &len
, end
);
14440 printf (" Tag_ISA: ");
14443 case 0: printf (_("None\n")); break;
14444 case 1: printf (_("MSP430\n")); break;
14445 case 2: printf (_("MSP430X\n")); break;
14446 default: printf ("??? (%d)\n", val
); break;
14450 case OFBA_MSPABI_Tag_Code_Model
:
14451 val
= read_uleb128 (p
, &len
, end
);
14453 printf (" Tag_Code_Model: ");
14456 case 0: printf (_("None\n")); break;
14457 case 1: printf (_("Small\n")); break;
14458 case 2: printf (_("Large\n")); break;
14459 default: printf ("??? (%d)\n", val
); break;
14463 case OFBA_MSPABI_Tag_Data_Model
:
14464 val
= read_uleb128 (p
, &len
, end
);
14466 printf (" Tag_Data_Model: ");
14469 case 0: printf (_("None\n")); break;
14470 case 1: printf (_("Small\n")); break;
14471 case 2: printf (_("Large\n")); break;
14472 case 3: printf (_("Restricted Large\n")); break;
14473 default: printf ("??? (%d)\n", val
); break;
14478 printf (_(" <unknown tag %d>: "), tag
);
14485 size_t maxlen
= (end
- p
) - 1;
14487 print_symbol ((int) maxlen
, (const char *) p
);
14488 p
+= strnlen ((char *) p
, maxlen
) + 1;
14492 printf (_("<corrupt>"));
14493 p
= (unsigned char *) end
;
14499 val
= read_uleb128 (p
, &len
, end
);
14501 printf ("%d (0x%x)\n", val
, val
);
14511 process_attributes (FILE * file
,
14512 const char * public_name
,
14513 unsigned int proc_type
,
14514 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14515 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14517 Elf_Internal_Shdr
* sect
;
14519 bfd_boolean res
= TRUE
;
14521 /* Find the section header so that we get the size. */
14522 for (i
= 0, sect
= section_headers
;
14523 i
< elf_header
.e_shnum
;
14526 unsigned char * contents
;
14529 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14532 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14533 sect
->sh_size
, _("attributes"));
14534 if (contents
== NULL
)
14541 /* The first character is the version of the attributes.
14542 Currently only version 1, (aka 'A') is recognised here. */
14545 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14550 bfd_vma section_len
;
14552 section_len
= sect
->sh_size
- 1;
14555 while (section_len
> 0)
14558 unsigned int namelen
;
14559 bfd_boolean public_section
;
14560 bfd_boolean gnu_section
;
14562 if (section_len
<= 4)
14564 error (_("Tag section ends prematurely\n"));
14568 attr_len
= byte_get (p
, 4);
14571 if (attr_len
> section_len
)
14573 error (_("Bad attribute length (%u > %u)\n"),
14574 (unsigned) attr_len
, (unsigned) section_len
);
14575 attr_len
= section_len
;
14578 /* PR 17531: file: 001-101425-0.004 */
14579 else if (attr_len
< 5)
14581 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14586 section_len
-= attr_len
;
14589 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14590 if (namelen
== 0 || namelen
>= attr_len
)
14592 error (_("Corrupt attribute section name\n"));
14597 printf (_("Attribute Section: "));
14598 print_symbol (INT_MAX
, (const char *) p
);
14601 if (public_name
&& streq ((char *) p
, public_name
))
14602 public_section
= TRUE
;
14604 public_section
= FALSE
;
14606 if (streq ((char *) p
, "gnu"))
14607 gnu_section
= TRUE
;
14609 gnu_section
= FALSE
;
14612 attr_len
-= namelen
;
14614 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14619 unsigned char * end
;
14621 /* PR binutils/17531: Safe handling of corrupt files. */
14624 error (_("Unused bytes at end of section\n"));
14631 size
= byte_get (p
, 4);
14632 if (size
> attr_len
)
14634 error (_("Bad subsection length (%u > %u)\n"),
14635 (unsigned) size
, (unsigned) attr_len
);
14639 /* PR binutils/17531: Safe handling of corrupt files. */
14642 error (_("Bad subsection length (%u < 6)\n"),
14650 end
= p
+ size
- 1;
14651 assert (end
<= contents
+ sect
->sh_size
);
14657 printf (_("File Attributes\n"));
14660 printf (_("Section Attributes:"));
14663 printf (_("Symbol Attributes:"));
14664 /* Fall through. */
14670 val
= read_uleb128 (p
, &j
, end
);
14674 printf (" %d", val
);
14679 printf (_("Unknown tag: %d\n"), tag
);
14680 public_section
= FALSE
;
14684 if (public_section
&& display_pub_attribute
!= NULL
)
14687 p
= display_pub_attribute (p
, end
);
14690 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14693 p
= display_gnu_attribute (p
,
14694 display_proc_gnu_attribute
,
14700 printf (_(" Unknown attribute:\n"));
14701 display_raw_attribute (p
, end
);
14716 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14717 Print the Address, Access and Initial fields of an entry at VMA ADDR
14718 and return the VMA of the next entry, or -1 if there was a problem.
14719 Does not read from DATA_END or beyond. */
14722 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14723 unsigned char * data_end
)
14726 print_vma (addr
, LONG_HEX
);
14728 if (addr
< pltgot
+ 0xfff0)
14729 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14731 printf ("%10s", "");
14734 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14738 unsigned char * from
= data
+ addr
- pltgot
;
14740 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14742 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14743 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14744 return (bfd_vma
) -1;
14748 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14749 print_vma (entry
, LONG_HEX
);
14752 return addr
+ (is_32bit_elf
? 4 : 8);
14755 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14756 PLTGOT. Print the Address and Initial fields of an entry at VMA
14757 ADDR and return the VMA of the next entry. */
14760 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14763 print_vma (addr
, LONG_HEX
);
14766 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14771 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14772 print_vma (entry
, LONG_HEX
);
14774 return addr
+ (is_32bit_elf
? 4 : 8);
14778 print_mips_ases (unsigned int mask
)
14780 if (mask
& AFL_ASE_DSP
)
14781 fputs ("\n\tDSP ASE", stdout
);
14782 if (mask
& AFL_ASE_DSPR2
)
14783 fputs ("\n\tDSP R2 ASE", stdout
);
14784 if (mask
& AFL_ASE_DSPR3
)
14785 fputs ("\n\tDSP R3 ASE", stdout
);
14786 if (mask
& AFL_ASE_EVA
)
14787 fputs ("\n\tEnhanced VA Scheme", stdout
);
14788 if (mask
& AFL_ASE_MCU
)
14789 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14790 if (mask
& AFL_ASE_MDMX
)
14791 fputs ("\n\tMDMX ASE", stdout
);
14792 if (mask
& AFL_ASE_MIPS3D
)
14793 fputs ("\n\tMIPS-3D ASE", stdout
);
14794 if (mask
& AFL_ASE_MT
)
14795 fputs ("\n\tMT ASE", stdout
);
14796 if (mask
& AFL_ASE_SMARTMIPS
)
14797 fputs ("\n\tSmartMIPS ASE", stdout
);
14798 if (mask
& AFL_ASE_VIRT
)
14799 fputs ("\n\tVZ ASE", stdout
);
14800 if (mask
& AFL_ASE_MSA
)
14801 fputs ("\n\tMSA ASE", stdout
);
14802 if (mask
& AFL_ASE_MIPS16
)
14803 fputs ("\n\tMIPS16 ASE", stdout
);
14804 if (mask
& AFL_ASE_MICROMIPS
)
14805 fputs ("\n\tMICROMIPS ASE", stdout
);
14806 if (mask
& AFL_ASE_XPA
)
14807 fputs ("\n\tXPA ASE", stdout
);
14809 fprintf (stdout
, "\n\t%s", _("None"));
14810 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14811 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14815 print_mips_isa_ext (unsigned int isa_ext
)
14820 fputs (_("None"), stdout
);
14823 fputs ("RMI XLR", stdout
);
14825 case AFL_EXT_OCTEON3
:
14826 fputs ("Cavium Networks Octeon3", stdout
);
14828 case AFL_EXT_OCTEON2
:
14829 fputs ("Cavium Networks Octeon2", stdout
);
14831 case AFL_EXT_OCTEONP
:
14832 fputs ("Cavium Networks OcteonP", stdout
);
14834 case AFL_EXT_LOONGSON_3A
:
14835 fputs ("Loongson 3A", stdout
);
14837 case AFL_EXT_OCTEON
:
14838 fputs ("Cavium Networks Octeon", stdout
);
14841 fputs ("Toshiba R5900", stdout
);
14844 fputs ("MIPS R4650", stdout
);
14847 fputs ("LSI R4010", stdout
);
14850 fputs ("NEC VR4100", stdout
);
14853 fputs ("Toshiba R3900", stdout
);
14855 case AFL_EXT_10000
:
14856 fputs ("MIPS R10000", stdout
);
14859 fputs ("Broadcom SB-1", stdout
);
14862 fputs ("NEC VR4111/VR4181", stdout
);
14865 fputs ("NEC VR4120", stdout
);
14868 fputs ("NEC VR5400", stdout
);
14871 fputs ("NEC VR5500", stdout
);
14873 case AFL_EXT_LOONGSON_2E
:
14874 fputs ("ST Microelectronics Loongson 2E", stdout
);
14876 case AFL_EXT_LOONGSON_2F
:
14877 fputs ("ST Microelectronics Loongson 2F", stdout
);
14880 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14885 get_mips_reg_size (int reg_size
)
14887 return (reg_size
== AFL_REG_NONE
) ? 0
14888 : (reg_size
== AFL_REG_32
) ? 32
14889 : (reg_size
== AFL_REG_64
) ? 64
14890 : (reg_size
== AFL_REG_128
) ? 128
14895 process_mips_specific (FILE * file
)
14897 Elf_Internal_Dyn
* entry
;
14898 Elf_Internal_Shdr
*sect
= NULL
;
14899 size_t liblist_offset
= 0;
14900 size_t liblistno
= 0;
14901 size_t conflictsno
= 0;
14902 size_t options_offset
= 0;
14903 size_t conflicts_offset
= 0;
14904 size_t pltrelsz
= 0;
14906 bfd_vma pltgot
= 0;
14907 bfd_vma mips_pltgot
= 0;
14908 bfd_vma jmprel
= 0;
14909 bfd_vma local_gotno
= 0;
14910 bfd_vma gotsym
= 0;
14911 bfd_vma symtabno
= 0;
14912 bfd_boolean res
= TRUE
;
14914 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14915 display_mips_gnu_attribute
))
14918 sect
= find_section (".MIPS.abiflags");
14922 Elf_External_ABIFlags_v0
*abiflags_ext
;
14923 Elf_Internal_ABIFlags_v0 abiflags_in
;
14925 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14927 error (_("Corrupt MIPS ABI Flags section.\n"));
14932 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14933 sect
->sh_size
, _("MIPS ABI Flags section"));
14936 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14937 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14938 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14939 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14940 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14941 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14942 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14943 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14944 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14945 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14946 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14948 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14949 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14950 if (abiflags_in
.isa_rev
> 1)
14951 printf ("r%d", abiflags_in
.isa_rev
);
14952 printf ("\nGPR size: %d",
14953 get_mips_reg_size (abiflags_in
.gpr_size
));
14954 printf ("\nCPR1 size: %d",
14955 get_mips_reg_size (abiflags_in
.cpr1_size
));
14956 printf ("\nCPR2 size: %d",
14957 get_mips_reg_size (abiflags_in
.cpr2_size
));
14958 fputs ("\nFP ABI: ", stdout
);
14959 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14960 fputs ("ISA Extension: ", stdout
);
14961 print_mips_isa_ext (abiflags_in
.isa_ext
);
14962 fputs ("\nASEs:", stdout
);
14963 print_mips_ases (abiflags_in
.ases
);
14964 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14965 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14966 fputc ('\n', stdout
);
14967 free (abiflags_ext
);
14972 /* We have a lot of special sections. Thanks SGI! */
14973 if (dynamic_section
== NULL
)
14974 /* No information available. */
14977 for (entry
= dynamic_section
;
14978 /* PR 17531 file: 012-50589-0.004. */
14979 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14981 switch (entry
->d_tag
)
14983 case DT_MIPS_LIBLIST
:
14985 = offset_from_vma (file
, entry
->d_un
.d_val
,
14986 liblistno
* sizeof (Elf32_External_Lib
));
14988 case DT_MIPS_LIBLISTNO
:
14989 liblistno
= entry
->d_un
.d_val
;
14991 case DT_MIPS_OPTIONS
:
14992 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14994 case DT_MIPS_CONFLICT
:
14996 = offset_from_vma (file
, entry
->d_un
.d_val
,
14997 conflictsno
* sizeof (Elf32_External_Conflict
));
14999 case DT_MIPS_CONFLICTNO
:
15000 conflictsno
= entry
->d_un
.d_val
;
15003 pltgot
= entry
->d_un
.d_ptr
;
15005 case DT_MIPS_LOCAL_GOTNO
:
15006 local_gotno
= entry
->d_un
.d_val
;
15008 case DT_MIPS_GOTSYM
:
15009 gotsym
= entry
->d_un
.d_val
;
15011 case DT_MIPS_SYMTABNO
:
15012 symtabno
= entry
->d_un
.d_val
;
15014 case DT_MIPS_PLTGOT
:
15015 mips_pltgot
= entry
->d_un
.d_ptr
;
15018 pltrel
= entry
->d_un
.d_val
;
15021 pltrelsz
= entry
->d_un
.d_val
;
15024 jmprel
= entry
->d_un
.d_ptr
;
15030 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15032 Elf32_External_Lib
* elib
;
15035 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15037 sizeof (Elf32_External_Lib
),
15038 _("liblist section data"));
15041 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15042 (unsigned long) liblistno
);
15043 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15046 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15053 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15054 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15055 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15056 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15057 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15059 tmp
= gmtime (&atime
);
15060 snprintf (timebuf
, sizeof (timebuf
),
15061 "%04u-%02u-%02uT%02u:%02u:%02u",
15062 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15063 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15065 printf ("%3lu: ", (unsigned long) cnt
);
15066 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15067 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15069 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15070 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15071 liblist
.l_version
);
15073 if (liblist
.l_flags
== 0)
15077 static const struct
15084 { " EXACT_MATCH", LL_EXACT_MATCH
},
15085 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15086 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15087 { " EXPORTS", LL_EXPORTS
},
15088 { " DELAY_LOAD", LL_DELAY_LOAD
},
15089 { " DELTA", LL_DELTA
}
15091 int flags
= liblist
.l_flags
;
15094 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15095 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15097 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15098 flags
^= l_flags_vals
[fcnt
].bit
;
15101 printf (" %#x", (unsigned int) flags
);
15113 if (options_offset
!= 0)
15115 Elf_External_Options
* eopt
;
15116 Elf_Internal_Options
* iopt
;
15117 Elf_Internal_Options
* option
;
15120 sect
= section_headers
;
15122 /* Find the section header so that we get the size. */
15123 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15124 /* PR 17533 file: 012-277276-0.004. */
15127 error (_("No MIPS_OPTIONS header found\n"));
15131 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15132 sect
->sh_size
, _("options"));
15135 iopt
= (Elf_Internal_Options
*)
15136 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15139 error (_("Out of memory allocating space for MIPS options\n"));
15146 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15148 Elf_External_Options
* eoption
;
15150 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15152 option
->kind
= BYTE_GET (eoption
->kind
);
15153 option
->size
= BYTE_GET (eoption
->size
);
15154 option
->section
= BYTE_GET (eoption
->section
);
15155 option
->info
= BYTE_GET (eoption
->info
);
15157 /* PR 17531: file: ffa0fa3b. */
15158 if (option
->size
< sizeof (* eopt
)
15159 || offset
+ option
->size
> sect
->sh_size
)
15161 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15164 offset
+= option
->size
;
15170 printf (_("\nSection '%s' contains %d entries:\n"),
15171 printable_section_name (sect
), cnt
);
15180 switch (option
->kind
)
15183 /* This shouldn't happen. */
15184 printf (" NULL %d %lx", option
->section
, option
->info
);
15187 printf (" REGINFO ");
15188 if (elf_header
.e_machine
== EM_MIPS
)
15191 Elf32_External_RegInfo
* ereg
;
15192 Elf32_RegInfo reginfo
;
15194 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15195 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15196 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15197 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15198 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15199 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15200 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15202 printf ("GPR %08lx GP 0x%lx\n",
15203 reginfo
.ri_gprmask
,
15204 (unsigned long) reginfo
.ri_gp_value
);
15205 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15206 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15207 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15212 Elf64_External_RegInfo
* ereg
;
15213 Elf64_Internal_RegInfo reginfo
;
15215 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15216 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15217 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15218 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15219 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15220 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15221 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15223 printf ("GPR %08lx GP 0x",
15224 reginfo
.ri_gprmask
);
15225 printf_vma (reginfo
.ri_gp_value
);
15228 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15229 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15230 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15234 case ODK_EXCEPTIONS
:
15235 fputs (" EXCEPTIONS fpe_min(", stdout
);
15236 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15237 fputs (") fpe_max(", stdout
);
15238 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15239 fputs (")", stdout
);
15241 if (option
->info
& OEX_PAGE0
)
15242 fputs (" PAGE0", stdout
);
15243 if (option
->info
& OEX_SMM
)
15244 fputs (" SMM", stdout
);
15245 if (option
->info
& OEX_FPDBUG
)
15246 fputs (" FPDBUG", stdout
);
15247 if (option
->info
& OEX_DISMISS
)
15248 fputs (" DISMISS", stdout
);
15251 fputs (" PAD ", stdout
);
15252 if (option
->info
& OPAD_PREFIX
)
15253 fputs (" PREFIX", stdout
);
15254 if (option
->info
& OPAD_POSTFIX
)
15255 fputs (" POSTFIX", stdout
);
15256 if (option
->info
& OPAD_SYMBOL
)
15257 fputs (" SYMBOL", stdout
);
15260 fputs (" HWPATCH ", stdout
);
15261 if (option
->info
& OHW_R4KEOP
)
15262 fputs (" R4KEOP", stdout
);
15263 if (option
->info
& OHW_R8KPFETCH
)
15264 fputs (" R8KPFETCH", stdout
);
15265 if (option
->info
& OHW_R5KEOP
)
15266 fputs (" R5KEOP", stdout
);
15267 if (option
->info
& OHW_R5KCVTL
)
15268 fputs (" R5KCVTL", stdout
);
15271 fputs (" FILL ", stdout
);
15272 /* XXX Print content of info word? */
15275 fputs (" TAGS ", stdout
);
15276 /* XXX Print content of info word? */
15279 fputs (" HWAND ", stdout
);
15280 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15281 fputs (" R4KEOP_CHECKED", stdout
);
15282 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15283 fputs (" R4KEOP_CLEAN", stdout
);
15286 fputs (" HWOR ", stdout
);
15287 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15288 fputs (" R4KEOP_CHECKED", stdout
);
15289 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15290 fputs (" R4KEOP_CLEAN", stdout
);
15293 printf (" GP_GROUP %#06lx self-contained %#06lx",
15294 option
->info
& OGP_GROUP
,
15295 (option
->info
& OGP_SELF
) >> 16);
15298 printf (" IDENT %#06lx self-contained %#06lx",
15299 option
->info
& OGP_GROUP
,
15300 (option
->info
& OGP_SELF
) >> 16);
15303 /* This shouldn't happen. */
15304 printf (" %3d ??? %d %lx",
15305 option
->kind
, option
->section
, option
->info
);
15309 len
= sizeof (* eopt
);
15310 while (len
< option
->size
)
15312 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15314 if (ISPRINT (datum
))
15315 printf ("%c", datum
);
15317 printf ("\\%03o", datum
);
15320 fputs ("\n", stdout
);
15322 offset
+= option
->size
;
15332 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15334 Elf32_Conflict
* iconf
;
15337 if (dynamic_symbols
== NULL
)
15339 error (_("conflict list found without a dynamic symbol table\n"));
15343 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15346 error (_("Out of memory allocating space for dynamic conflicts\n"));
15352 Elf32_External_Conflict
* econf32
;
15354 econf32
= (Elf32_External_Conflict
*)
15355 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15356 sizeof (* econf32
), _("conflict"));
15360 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15361 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15367 Elf64_External_Conflict
* econf64
;
15369 econf64
= (Elf64_External_Conflict
*)
15370 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15371 sizeof (* econf64
), _("conflict"));
15375 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15376 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15381 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15382 (unsigned long) conflictsno
);
15383 puts (_(" Num: Index Value Name"));
15385 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15387 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15389 if (iconf
[cnt
] >= num_dynamic_syms
)
15390 printf (_("<corrupt symbol index>"));
15393 Elf_Internal_Sym
* psym
;
15395 psym
= & dynamic_symbols
[iconf
[cnt
]];
15396 print_vma (psym
->st_value
, FULL_HEX
);
15398 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15399 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15401 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15409 if (pltgot
!= 0 && local_gotno
!= 0)
15411 bfd_vma ent
, local_end
, global_end
;
15413 unsigned char * data
;
15414 unsigned char * data_end
;
15418 addr_size
= (is_32bit_elf
? 4 : 8);
15419 local_end
= pltgot
+ local_gotno
* addr_size
;
15421 /* PR binutils/17533 file: 012-111227-0.004 */
15422 if (symtabno
< gotsym
)
15424 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15425 (unsigned long) gotsym
, (unsigned long) symtabno
);
15429 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15430 /* PR 17531: file: 54c91a34. */
15431 if (global_end
< local_end
)
15433 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15437 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15438 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15439 global_end
- pltgot
, 1,
15440 _("Global Offset Table data"));
15443 data_end
= data
+ (global_end
- pltgot
);
15445 printf (_("\nPrimary GOT:\n"));
15446 printf (_(" Canonical gp value: "));
15447 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15450 printf (_(" Reserved entries:\n"));
15451 printf (_(" %*s %10s %*s Purpose\n"),
15452 addr_size
* 2, _("Address"), _("Access"),
15453 addr_size
* 2, _("Initial"));
15454 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15455 printf (_(" Lazy resolver\n"));
15456 if (ent
== (bfd_vma
) -1)
15457 goto got_print_fail
;
15459 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15460 >> (addr_size
* 8 - 1)) != 0)
15462 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15463 printf (_(" Module pointer (GNU extension)\n"));
15464 if (ent
== (bfd_vma
) -1)
15465 goto got_print_fail
;
15469 if (ent
< local_end
)
15471 printf (_(" Local entries:\n"));
15472 printf (" %*s %10s %*s\n",
15473 addr_size
* 2, _("Address"), _("Access"),
15474 addr_size
* 2, _("Initial"));
15475 while (ent
< local_end
)
15477 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15479 if (ent
== (bfd_vma
) -1)
15480 goto got_print_fail
;
15485 if (gotsym
< symtabno
)
15489 printf (_(" Global entries:\n"));
15490 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15491 addr_size
* 2, _("Address"),
15493 addr_size
* 2, _("Initial"),
15494 addr_size
* 2, _("Sym.Val."),
15496 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15497 _("Ndx"), _("Name"));
15499 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15501 for (i
= gotsym
; i
< symtabno
; i
++)
15503 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15506 if (dynamic_symbols
== NULL
)
15507 printf (_("<no dynamic symbols>"));
15508 else if (i
< num_dynamic_syms
)
15510 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15512 print_vma (psym
->st_value
, LONG_HEX
);
15513 printf (" %-7s %3s ",
15514 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15515 get_symbol_index_type (psym
->st_shndx
));
15517 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15518 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15520 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15523 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15524 (unsigned long) i
);
15527 if (ent
== (bfd_vma
) -1)
15538 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15541 size_t offset
, rel_offset
;
15542 unsigned long count
, i
;
15543 unsigned char * data
;
15544 int addr_size
, sym_width
;
15545 Elf_Internal_Rela
* rels
;
15547 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15548 if (pltrel
== DT_RELA
)
15550 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15555 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15560 addr_size
= (is_32bit_elf
? 4 : 8);
15561 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15563 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15564 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15565 1, _("Procedure Linkage Table data"));
15569 printf ("\nPLT GOT:\n\n");
15570 printf (_(" Reserved entries:\n"));
15571 printf (_(" %*s %*s Purpose\n"),
15572 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15573 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15574 printf (_(" PLT lazy resolver\n"));
15575 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15576 printf (_(" Module pointer\n"));
15579 printf (_(" Entries:\n"));
15580 printf (" %*s %*s %*s %-7s %3s %s\n",
15581 addr_size
* 2, _("Address"),
15582 addr_size
* 2, _("Initial"),
15583 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15584 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15585 for (i
= 0; i
< count
; i
++)
15587 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15589 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15592 if (idx
>= num_dynamic_syms
)
15593 printf (_("<corrupt symbol index: %lu>"), idx
);
15596 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15598 print_vma (psym
->st_value
, LONG_HEX
);
15599 printf (" %-7s %3s ",
15600 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15601 get_symbol_index_type (psym
->st_shndx
));
15602 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15603 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15605 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15620 process_nds32_specific (FILE * file
)
15622 Elf_Internal_Shdr
*sect
= NULL
;
15624 sect
= find_section (".nds32_e_flags");
15627 unsigned int *flag
;
15629 printf ("\nNDS32 elf flags section:\n");
15630 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15631 sect
->sh_size
, _("NDS32 elf flags section"));
15636 switch ((*flag
) & 0x3)
15639 printf ("(VEC_SIZE):\tNo entry.\n");
15642 printf ("(VEC_SIZE):\t4 bytes\n");
15645 printf ("(VEC_SIZE):\t16 bytes\n");
15648 printf ("(VEC_SIZE):\treserved\n");
15657 process_gnu_liblist (FILE * file
)
15659 Elf_Internal_Shdr
* section
;
15660 Elf_Internal_Shdr
* string_sec
;
15661 Elf32_External_Lib
* elib
;
15663 size_t strtab_size
;
15666 bfd_boolean res
= TRUE
;
15671 for (i
= 0, section
= section_headers
;
15672 i
< elf_header
.e_shnum
;
15675 switch (section
->sh_type
)
15677 case SHT_GNU_LIBLIST
:
15678 if (section
->sh_link
>= elf_header
.e_shnum
)
15681 elib
= (Elf32_External_Lib
*)
15682 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15683 _("liblist section data"));
15691 string_sec
= section_headers
+ section
->sh_link
;
15692 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15693 string_sec
->sh_size
,
15694 _("liblist string table"));
15696 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15703 strtab_size
= string_sec
->sh_size
;
15705 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15706 printable_section_name (section
),
15707 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15709 puts (_(" Library Time Stamp Checksum Version Flags"));
15711 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15719 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15720 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15721 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15722 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15723 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15725 tmp
= gmtime (&atime
);
15726 snprintf (timebuf
, sizeof (timebuf
),
15727 "%04u-%02u-%02uT%02u:%02u:%02u",
15728 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15729 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15731 printf ("%3lu: ", (unsigned long) cnt
);
15733 printf ("%-20s", liblist
.l_name
< strtab_size
15734 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15736 printf ("%-20.20s", liblist
.l_name
< strtab_size
15737 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15738 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15739 liblist
.l_version
, liblist
.l_flags
);
15750 static const char *
15751 get_note_type (unsigned e_type
)
15753 static char buff
[64];
15755 if (elf_header
.e_type
== ET_CORE
)
15759 return _("NT_AUXV (auxiliary vector)");
15761 return _("NT_PRSTATUS (prstatus structure)");
15763 return _("NT_FPREGSET (floating point registers)");
15765 return _("NT_PRPSINFO (prpsinfo structure)");
15766 case NT_TASKSTRUCT
:
15767 return _("NT_TASKSTRUCT (task structure)");
15769 return _("NT_PRXFPREG (user_xfpregs structure)");
15771 return _("NT_PPC_VMX (ppc Altivec registers)");
15773 return _("NT_PPC_VSX (ppc VSX registers)");
15775 return _("NT_386_TLS (x86 TLS information)");
15776 case NT_386_IOPERM
:
15777 return _("NT_386_IOPERM (x86 I/O permissions)");
15778 case NT_X86_XSTATE
:
15779 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15780 case NT_S390_HIGH_GPRS
:
15781 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15782 case NT_S390_TIMER
:
15783 return _("NT_S390_TIMER (s390 timer register)");
15784 case NT_S390_TODCMP
:
15785 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15786 case NT_S390_TODPREG
:
15787 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15789 return _("NT_S390_CTRS (s390 control registers)");
15790 case NT_S390_PREFIX
:
15791 return _("NT_S390_PREFIX (s390 prefix register)");
15792 case NT_S390_LAST_BREAK
:
15793 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15794 case NT_S390_SYSTEM_CALL
:
15795 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15797 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15798 case NT_S390_VXRS_LOW
:
15799 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15800 case NT_S390_VXRS_HIGH
:
15801 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15803 return _("NT_ARM_VFP (arm VFP registers)");
15805 return _("NT_ARM_TLS (AArch TLS registers)");
15806 case NT_ARM_HW_BREAK
:
15807 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15808 case NT_ARM_HW_WATCH
:
15809 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15811 return _("NT_PSTATUS (pstatus structure)");
15813 return _("NT_FPREGS (floating point registers)");
15815 return _("NT_PSINFO (psinfo structure)");
15817 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15819 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15820 case NT_WIN32PSTATUS
:
15821 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15823 return _("NT_SIGINFO (siginfo_t data)");
15825 return _("NT_FILE (mapped files)");
15833 return _("NT_VERSION (version)");
15835 return _("NT_ARCH (architecture)");
15836 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
15837 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15838 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
15839 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15844 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15849 print_core_note (Elf_Internal_Note
*pnote
)
15851 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15852 bfd_vma count
, page_size
;
15853 unsigned char *descdata
, *filenames
, *descend
;
15855 if (pnote
->type
!= NT_FILE
)
15861 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15862 /* Still "successful". */
15867 if (pnote
->descsz
< 2 * addr_size
)
15869 error (_(" Malformed note - too short for header\n"));
15873 descdata
= (unsigned char *) pnote
->descdata
;
15874 descend
= descdata
+ pnote
->descsz
;
15876 if (descdata
[pnote
->descsz
- 1] != '\0')
15878 error (_(" Malformed note - does not end with \\0\n"));
15882 count
= byte_get (descdata
, addr_size
);
15883 descdata
+= addr_size
;
15885 page_size
= byte_get (descdata
, addr_size
);
15886 descdata
+= addr_size
;
15888 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15890 error (_(" Malformed note - too short for supplied file count\n"));
15894 printf (_(" Page size: "));
15895 print_vma (page_size
, DEC
);
15898 printf (_(" %*s%*s%*s\n"),
15899 (int) (2 + 2 * addr_size
), _("Start"),
15900 (int) (4 + 2 * addr_size
), _("End"),
15901 (int) (4 + 2 * addr_size
), _("Page Offset"));
15902 filenames
= descdata
+ count
* 3 * addr_size
;
15903 while (count
-- > 0)
15905 bfd_vma start
, end
, file_ofs
;
15907 if (filenames
== descend
)
15909 error (_(" Malformed note - filenames end too early\n"));
15913 start
= byte_get (descdata
, addr_size
);
15914 descdata
+= addr_size
;
15915 end
= byte_get (descdata
, addr_size
);
15916 descdata
+= addr_size
;
15917 file_ofs
= byte_get (descdata
, addr_size
);
15918 descdata
+= addr_size
;
15921 print_vma (start
, FULL_HEX
);
15923 print_vma (end
, FULL_HEX
);
15925 print_vma (file_ofs
, FULL_HEX
);
15926 printf ("\n %s\n", filenames
);
15928 filenames
+= 1 + strlen ((char *) filenames
);
15934 static const char *
15935 get_gnu_elf_note_type (unsigned e_type
)
15937 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15940 case NT_GNU_ABI_TAG
:
15941 return _("NT_GNU_ABI_TAG (ABI version tag)");
15943 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15944 case NT_GNU_BUILD_ID
:
15945 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15946 case NT_GNU_GOLD_VERSION
:
15947 return _("NT_GNU_GOLD_VERSION (gold version)");
15948 case NT_GNU_PROPERTY_TYPE_0
:
15949 return _("NT_GNU_PROPERTY_TYPE_0");
15950 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
15951 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15952 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
15953 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15956 static char buff
[64];
15958 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15965 decode_x86_isa (unsigned int bitmask
)
15969 unsigned int bit
= bitmask
& (- bitmask
);
15974 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
15975 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
15976 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
15977 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
15978 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
15979 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
15980 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
15981 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
15982 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
15983 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
15984 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
15985 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
15986 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
15987 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
15988 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
15989 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
15990 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
15991 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
15992 default: printf (_("<unknown: %x>"), bit
); break;
16000 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16002 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16003 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16004 unsigned int size
= is_32bit_elf
? 4 : 8;
16006 printf (_(" Properties: "));
16008 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16010 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16017 unsigned int type
= byte_get (ptr
, 4);
16018 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16022 if ((ptr
+ datasz
) > ptr_end
)
16024 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16029 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16031 if (elf_header
.e_machine
== EM_X86_64
16032 || elf_header
.e_machine
== EM_IAMCU
16033 || elf_header
.e_machine
== EM_386
)
16037 case GNU_PROPERTY_X86_ISA_1_USED
:
16038 printf ("x86 ISA used: ");
16040 printf (_("<corrupt length: %#x> "), datasz
);
16042 decode_x86_isa (byte_get (ptr
, 4));
16045 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16046 printf ("x86 ISA needed: ");
16048 printf (_("<corrupt length: %#x> "), datasz
);
16050 decode_x86_isa (byte_get (ptr
, 4));
16062 case GNU_PROPERTY_STACK_SIZE
:
16063 printf (_("stack size: "));
16064 if (datasz
!= size
)
16065 printf (_("<corrupt length: %#x> "), datasz
);
16067 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16070 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16071 printf ("no copy on protected ");
16073 printf (_("<corrupt length: %#x> "), datasz
);
16081 if (type
< GNU_PROPERTY_LOPROC
)
16082 printf (_("<unknown type %#x data: "), type
);
16083 else if (type
< GNU_PROPERTY_LOUSER
)
16084 printf (_("<procesor-specific type %#x data: "), type
);
16086 printf (_("<application-specific type %#x data: "), type
);
16087 for (j
= 0; j
< datasz
; ++j
)
16088 printf ("%02x ", ptr
[j
] & 0xff);
16092 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16093 if (ptr
== ptr_end
)
16103 if (ptr
> (ptr_end
- 8))
16105 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16114 print_gnu_note (Elf_Internal_Note
*pnote
)
16116 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16117 switch (pnote
->type
)
16119 case NT_GNU_BUILD_ID
:
16123 printf (_(" Build ID: "));
16124 for (i
= 0; i
< pnote
->descsz
; ++i
)
16125 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16130 case NT_GNU_ABI_TAG
:
16132 unsigned long os
, major
, minor
, subminor
;
16133 const char *osname
;
16135 /* PR 17531: file: 030-599401-0.004. */
16136 if (pnote
->descsz
< 16)
16138 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16142 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16143 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16144 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16145 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16149 case GNU_ABI_TAG_LINUX
:
16152 case GNU_ABI_TAG_HURD
:
16155 case GNU_ABI_TAG_SOLARIS
:
16156 osname
= "Solaris";
16158 case GNU_ABI_TAG_FREEBSD
:
16159 osname
= "FreeBSD";
16161 case GNU_ABI_TAG_NETBSD
:
16164 case GNU_ABI_TAG_SYLLABLE
:
16165 osname
= "Syllable";
16167 case GNU_ABI_TAG_NACL
:
16171 osname
= "Unknown";
16175 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16176 major
, minor
, subminor
);
16180 case NT_GNU_GOLD_VERSION
:
16184 printf (_(" Version: "));
16185 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16186 printf ("%c", pnote
->descdata
[i
]);
16193 unsigned long num_entries
, mask
;
16195 /* Hardware capabilities information. Word 0 is the number of entries.
16196 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16197 is a series of entries, where each entry is a single byte followed
16198 by a nul terminated string. The byte gives the bit number to test
16199 if enabled in the bitmask. */
16200 printf (_(" Hardware Capabilities: "));
16201 if (pnote
->descsz
< 8)
16203 error (_("<corrupt GNU_HWCAP>\n"));
16206 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16207 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16208 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16209 /* FIXME: Add code to display the entries... */
16213 case NT_GNU_PROPERTY_TYPE_0
:
16214 print_gnu_property_note (pnote
);
16218 /* Handle unrecognised types. An error message should have already been
16219 created by get_gnu_elf_note_type(), so all that we need to do is to
16220 display the data. */
16224 printf (_(" Description data: "));
16225 for (i
= 0; i
< pnote
->descsz
; ++i
)
16226 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16235 static const char *
16236 get_v850_elf_note_type (enum v850_notes n_type
)
16238 static char buff
[64];
16242 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16243 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16244 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16245 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16246 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16247 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16249 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16255 print_v850_note (Elf_Internal_Note
* pnote
)
16259 if (pnote
->descsz
!= 4)
16262 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16266 printf (_("not set\n"));
16270 switch (pnote
->type
)
16272 case V850_NOTE_ALIGNMENT
:
16275 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16276 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16280 case V850_NOTE_DATA_SIZE
:
16283 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16284 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16288 case V850_NOTE_FPU_INFO
:
16291 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16292 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16296 case V850_NOTE_MMU_INFO
:
16297 case V850_NOTE_CACHE_INFO
:
16298 case V850_NOTE_SIMD_INFO
:
16299 if (val
== EF_RH850_SIMD
)
16301 printf (_("yes\n"));
16307 /* An 'unknown note type' message will already have been displayed. */
16311 printf (_("unknown value: %x\n"), val
);
16316 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16318 unsigned int version
;
16320 switch (pnote
->type
)
16322 case NT_NETBSD_IDENT
:
16323 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16324 if ((version
/ 10000) % 100)
16325 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16326 version
, version
/ 100000000, (version
/ 1000000) % 100,
16327 (version
/ 10000) % 100 > 26 ? "Z" : "",
16328 'A' + (version
/ 10000) % 26);
16330 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16331 version
, version
/ 100000000, (version
/ 1000000) % 100,
16332 (version
/ 100) % 100);
16335 case NT_NETBSD_MARCH
:
16336 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16341 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16347 static const char *
16348 get_freebsd_elfcore_note_type (unsigned e_type
)
16352 case NT_FREEBSD_THRMISC
:
16353 return _("NT_THRMISC (thrmisc structure)");
16354 case NT_FREEBSD_PROCSTAT_PROC
:
16355 return _("NT_PROCSTAT_PROC (proc data)");
16356 case NT_FREEBSD_PROCSTAT_FILES
:
16357 return _("NT_PROCSTAT_FILES (files data)");
16358 case NT_FREEBSD_PROCSTAT_VMMAP
:
16359 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16360 case NT_FREEBSD_PROCSTAT_GROUPS
:
16361 return _("NT_PROCSTAT_GROUPS (groups data)");
16362 case NT_FREEBSD_PROCSTAT_UMASK
:
16363 return _("NT_PROCSTAT_UMASK (umask data)");
16364 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16365 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16366 case NT_FREEBSD_PROCSTAT_OSREL
:
16367 return _("NT_PROCSTAT_OSREL (osreldate data)");
16368 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16369 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16370 case NT_FREEBSD_PROCSTAT_AUXV
:
16371 return _("NT_PROCSTAT_AUXV (auxv data)");
16373 return get_note_type (e_type
);
16376 static const char *
16377 get_netbsd_elfcore_note_type (unsigned e_type
)
16379 static char buff
[64];
16381 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16383 /* NetBSD core "procinfo" structure. */
16384 return _("NetBSD procinfo structure");
16387 /* As of Jan 2002 there are no other machine-independent notes
16388 defined for NetBSD core files. If the note type is less
16389 than the start of the machine-dependent note types, we don't
16392 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16394 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16398 switch (elf_header
.e_machine
)
16400 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16401 and PT_GETFPREGS == mach+2. */
16406 case EM_SPARC32PLUS
:
16410 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16411 return _("PT_GETREGS (reg structure)");
16412 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16413 return _("PT_GETFPREGS (fpreg structure)");
16419 /* On all other arch's, PT_GETREGS == mach+1 and
16420 PT_GETFPREGS == mach+3. */
16424 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16425 return _("PT_GETREGS (reg structure)");
16426 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16427 return _("PT_GETFPREGS (fpreg structure)");
16433 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16434 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16438 static const char *
16439 get_stapsdt_note_type (unsigned e_type
)
16441 static char buff
[64];
16446 return _("NT_STAPSDT (SystemTap probe descriptors)");
16452 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16457 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16459 int addr_size
= is_32bit_elf
? 4 : 8;
16460 char *data
= pnote
->descdata
;
16461 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16462 bfd_vma pc
, base_addr
, semaphore
;
16463 char *provider
, *probe
, *arg_fmt
;
16465 pc
= byte_get ((unsigned char *) data
, addr_size
);
16467 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16469 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16473 data
+= strlen (data
) + 1;
16475 data
+= strlen (data
) + 1;
16477 data
+= strlen (data
) + 1;
16479 printf (_(" Provider: %s\n"), provider
);
16480 printf (_(" Name: %s\n"), probe
);
16481 printf (_(" Location: "));
16482 print_vma (pc
, FULL_HEX
);
16483 printf (_(", Base: "));
16484 print_vma (base_addr
, FULL_HEX
);
16485 printf (_(", Semaphore: "));
16486 print_vma (semaphore
, FULL_HEX
);
16488 printf (_(" Arguments: %s\n"), arg_fmt
);
16490 return data
== data_end
;
16493 static const char *
16494 get_ia64_vms_note_type (unsigned e_type
)
16496 static char buff
[64];
16501 return _("NT_VMS_MHD (module header)");
16503 return _("NT_VMS_LNM (language name)");
16505 return _("NT_VMS_SRC (source files)");
16507 return "NT_VMS_TITLE";
16509 return _("NT_VMS_EIDC (consistency check)");
16510 case NT_VMS_FPMODE
:
16511 return _("NT_VMS_FPMODE (FP mode)");
16512 case NT_VMS_LINKTIME
:
16513 return "NT_VMS_LINKTIME";
16514 case NT_VMS_IMGNAM
:
16515 return _("NT_VMS_IMGNAM (image name)");
16517 return _("NT_VMS_IMGID (image id)");
16518 case NT_VMS_LINKID
:
16519 return _("NT_VMS_LINKID (link id)");
16520 case NT_VMS_IMGBID
:
16521 return _("NT_VMS_IMGBID (build id)");
16522 case NT_VMS_GSTNAM
:
16523 return _("NT_VMS_GSTNAM (sym table name)");
16524 case NT_VMS_ORIG_DYN
:
16525 return "NT_VMS_ORIG_DYN";
16526 case NT_VMS_PATCHTIME
:
16527 return "NT_VMS_PATCHTIME";
16529 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16535 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
16537 switch (pnote
->type
)
16540 if (pnote
->descsz
> 36)
16542 size_t l
= strlen (pnote
->descdata
+ 34);
16543 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
16544 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
16545 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
16546 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
16549 printf (_(" Invalid size\n"));
16552 printf (_(" Language: %s\n"), pnote
->descdata
);
16555 case NT_VMS_FPMODE
:
16556 printf (_(" Floating Point mode: "));
16557 printf ("0x%016" BFD_VMA_FMT
"x\n",
16558 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16560 case NT_VMS_LINKTIME
:
16561 printf (_(" Link time: "));
16563 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16566 case NT_VMS_PATCHTIME
:
16567 printf (_(" Patch time: "));
16569 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
16572 case NT_VMS_ORIG_DYN
:
16573 printf (_(" Major id: %u, minor id: %u\n"),
16574 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
16575 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
16576 printf (_(" Last modified : "));
16578 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
16579 printf (_("\n Link flags : "));
16580 printf ("0x%016" BFD_VMA_FMT
"x\n",
16581 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
16582 printf (_(" Header flags: 0x%08x\n"),
16583 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
16584 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
16587 case NT_VMS_IMGNAM
:
16588 printf (_(" Image name: %s\n"), pnote
->descdata
);
16590 case NT_VMS_GSTNAM
:
16591 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
16594 printf (_(" Image id: %s\n"), pnote
->descdata
);
16596 case NT_VMS_LINKID
:
16597 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16605 /* Print the name of the symbol associated with a build attribute
16606 that is attached to address OFFSET. */
16609 print_symbol_for_build_attribute (FILE * file
,
16610 unsigned long offset
,
16611 bfd_boolean is_open_attr
)
16613 static FILE * saved_file
= NULL
;
16614 static char * strtab
;
16615 static unsigned long strtablen
;
16616 static Elf_Internal_Sym
* symtab
;
16617 static unsigned long nsyms
;
16618 Elf_Internal_Sym
* saved_sym
= NULL
;
16619 Elf_Internal_Sym
* sym
;
16621 if (saved_file
== NULL
|| file
!= saved_file
)
16623 Elf_Internal_Shdr
* symsec
;
16625 /* Load the symbol and string sections. */
16626 for (symsec
= section_headers
;
16627 symsec
< section_headers
+ elf_header
.e_shnum
;
16630 if (symsec
->sh_type
== SHT_SYMTAB
)
16632 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
16634 if (symsec
->sh_link
< elf_header
.e_shnum
)
16636 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
16638 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
16639 1, strtab_sec
->sh_size
,
16640 _("string table"));
16641 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
16648 if (symtab
== NULL
|| strtab
== NULL
)
16654 /* Find a symbol whose value matches offset. */
16655 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
16656 if (sym
->st_value
== offset
)
16658 if (sym
->st_name
>= strtablen
)
16659 /* Huh ? This should not happen. */
16662 if (strtab
[sym
->st_name
] == 0)
16667 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
16668 and FILE or OBJECT symbols over NOTYPE symbols. We skip
16669 FUNC symbols entirely. */
16670 switch (ELF_ST_TYPE (sym
->st_info
))
16674 /* We can stop searching now. */
16675 sym
= symtab
+ nsyms
;
16683 /* Ignore function symbols. */
16690 switch (ELF_ST_BIND (sym
->st_info
))
16693 if (saved_sym
== NULL
16694 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
16699 if (saved_sym
== NULL
)
16709 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
16717 printf (" (%s: %s)\n",
16718 is_open_attr
? _("file") : _("func"),
16719 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
16724 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
16727 static unsigned long global_offset
= 0;
16728 unsigned long offset
;
16729 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
16730 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
16732 if (pnote
->descsz
== 0)
16736 printf (_(" Applies from offset %#lx\n"), global_offset
);
16741 printf (_(" Applies to func at %#lx"), global_offset
);
16742 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
16746 if (pnote
->descsz
!= desc_size
)
16748 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
16749 printf (_(" <invalid descsz>"));
16753 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
16757 printf (_(" Applies from offset %#lx"), offset
);
16758 global_offset
= offset
;
16762 printf (_(" Applies to func at %#lx"), offset
);
16765 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
16769 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
16772 char name_attribute
;
16773 char * expected_types
;
16774 const char * name
= pnote
->namedata
;
16778 if (name
== NULL
|| pnote
->namesz
< 2)
16780 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
16781 print_symbol (-20, _(" <corrupt name field>"));
16785 switch ((name_type
= * name
))
16787 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
16788 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
16789 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
16790 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
16791 printf ("%c", * name
);
16794 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
16795 print_symbol (-20, _("<unknown name type>"));
16803 switch ((name_attribute
= * name
))
16805 case GNU_BUILD_ATTRIBUTE_VERSION
:
16806 text
= _("<version>");
16807 expected_types
= "$";
16810 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
16811 text
= _("<stack prot>");
16812 expected_types
= "!+*";
16815 case GNU_BUILD_ATTRIBUTE_RELRO
:
16816 text
= _("<relro>");
16817 expected_types
= "!+";
16820 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
16821 text
= _("<stack size>");
16822 expected_types
= "*";
16825 case GNU_BUILD_ATTRIBUTE_TOOL
:
16826 text
= _("<tool>");
16827 expected_types
= "$";
16830 case GNU_BUILD_ATTRIBUTE_ABI
:
16832 expected_types
= "$*";
16835 case GNU_BUILD_ATTRIBUTE_PIC
:
16837 expected_types
= "*";
16840 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
16841 text
= _("<short enum>");
16842 expected_types
= "!+";
16847 if (ISPRINT (* name
))
16849 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
16851 if (len
> left
&& ! do_wide
)
16853 printf ("%.*s:", len
, name
);
16859 error (_("unexpected character in name field\n"));
16860 print_symbol (- left
, _("<unknown attribute>"));
16863 expected_types
= "*$!+";
16869 printf ("%s", text
);
16870 left
-= strlen (text
);
16873 if (strchr (expected_types
, name_type
) == NULL
)
16874 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
16876 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
16878 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
16879 (unsigned long) pnote
->namesz
,
16880 (long) (name
- pnote
->namedata
));
16884 if (left
< 1 && ! do_wide
)
16889 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
16891 unsigned int bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
16892 unsigned long val
= 0;
16893 unsigned int shift
= 0;
16894 char * decoded
= NULL
;
16898 unsigned long byte
= (* name
++) & 0xff;
16900 val
|= byte
<< shift
;
16904 switch (name_attribute
)
16906 case GNU_BUILD_ATTRIBUTE_PIC
:
16909 case 0: decoded
= "static"; break;
16910 case 1: decoded
= "pic"; break;
16911 case 2: decoded
= "PIC"; break;
16912 case 3: decoded
= "pie"; break;
16913 case 4: decoded
= "PIE"; break;
16917 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
16920 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
16921 case 0: decoded
= "off"; break;
16922 case 1: decoded
= "on"; break;
16923 case 2: decoded
= "all"; break;
16924 case 3: decoded
= "strong"; break;
16925 case 4: decoded
= "explicit"; break;
16933 if (decoded
!= NULL
)
16934 print_symbol (-left
, decoded
);
16938 left
-= printf ("0x%lx", val
);
16940 left
-= printf ("0x%-.*lx", left
, val
);
16944 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
16945 left
-= print_symbol (- left
, name
);
16947 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
16948 left
-= print_symbol (- left
, "true");
16950 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
16951 left
-= print_symbol (- left
, "false");
16955 if (do_wide
&& left
> 0)
16956 printf ("%-*s", left
, " ");
16961 /* Note that by the ELF standard, the name field is already null byte
16962 terminated, and namesz includes the terminating null byte.
16963 I.E. the value of namesz for the name "FSF" is 4.
16965 If the value of namesz is zero, there is no name present. */
16968 process_note (Elf_Internal_Note
* pnote
,
16971 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16974 if (pnote
->namesz
== 0)
16975 /* If there is no note name, then use the default set of
16976 note type strings. */
16977 nt
= get_note_type (pnote
->type
);
16979 else if (const_strneq (pnote
->namedata
, "GNU"))
16980 /* GNU-specific object file notes. */
16981 nt
= get_gnu_elf_note_type (pnote
->type
);
16983 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16984 /* FreeBSD-specific core file notes. */
16985 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16987 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16988 /* NetBSD-specific core file notes. */
16989 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
16991 else if (const_strneq (pnote
->namedata
, "NetBSD"))
16992 /* NetBSD-specific core file notes. */
16993 return process_netbsd_elf_note (pnote
);
16995 else if (strneq (pnote
->namedata
, "SPU/", 4))
16997 /* SPU-specific core file notes. */
16998 nt
= pnote
->namedata
+ 4;
17002 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17003 /* VMS/ia64-specific file notes. */
17004 nt
= get_ia64_vms_note_type (pnote
->type
);
17006 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17007 nt
= get_stapsdt_note_type (pnote
->type
);
17010 /* Don't recognize this note name; just use the default set of
17011 note type strings. */
17012 nt
= get_note_type (pnote
->type
);
17016 if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17017 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17018 print_gnu_build_attribute_name (pnote
);
17020 print_symbol (-20, name
);
17023 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17025 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17027 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17028 return print_ia64_vms_note (pnote
);
17029 else if (const_strneq (pnote
->namedata
, "GNU"))
17030 return print_gnu_note (pnote
);
17031 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17032 return print_stapsdt_note (pnote
);
17033 else if (const_strneq (pnote
->namedata
, "CORE"))
17034 return print_core_note (pnote
);
17035 else if (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17036 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
)
17037 return print_gnu_build_attribute_description (pnote
, file
);
17043 printf (_(" description data: "));
17044 for (i
= 0; i
< pnote
->descsz
; i
++)
17045 printf ("%02x ", pnote
->descdata
[i
]);
17055 process_notes_at (FILE * file
,
17056 Elf_Internal_Shdr
* section
,
17060 Elf_External_Note
* pnotes
;
17061 Elf_External_Note
* external
;
17063 bfd_boolean res
= TRUE
;
17070 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17073 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17078 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17080 if (pnotes
== NULL
)
17086 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17088 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17089 (unsigned long) offset
, (unsigned long) length
);
17091 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17093 end
= (char *) pnotes
+ length
;
17094 while ((char *) external
< end
)
17096 Elf_Internal_Note inote
;
17099 char * temp
= NULL
;
17100 size_t data_remaining
= end
- (char *) external
;
17102 if (!is_ia64_vms ())
17104 /* PR binutils/15191
17105 Make sure that there is enough data to read. */
17106 min_notesz
= offsetof (Elf_External_Note
, name
);
17107 if (data_remaining
< min_notesz
)
17109 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17110 (int) data_remaining
);
17113 inote
.type
= BYTE_GET (external
->type
);
17114 inote
.namesz
= BYTE_GET (external
->namesz
);
17115 inote
.namedata
= external
->name
;
17116 inote
.descsz
= BYTE_GET (external
->descsz
);
17117 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17118 /* PR 17531: file: 3443835e. */
17119 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17121 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17122 inote
.namesz
, (long)(end
- inote
.namedata
));
17123 inote
.descdata
= inote
.namedata
;
17127 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17128 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17132 Elf64_External_VMS_Note
*vms_external
;
17134 /* PR binutils/15191
17135 Make sure that there is enough data to read. */
17136 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17137 if (data_remaining
< min_notesz
)
17139 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17140 (int) data_remaining
);
17144 vms_external
= (Elf64_External_VMS_Note
*) external
;
17145 inote
.type
= BYTE_GET (vms_external
->type
);
17146 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17147 inote
.namedata
= vms_external
->name
;
17148 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17149 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17150 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17151 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17154 if (inote
.descdata
< (char *) external
+ min_notesz
17155 || next
< (char *) external
+ min_notesz
17156 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17157 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17158 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17159 || data_remaining
< (size_t)(next
- (char *) external
))
17161 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17162 (unsigned long) ((char *) external
- (char *) pnotes
));
17163 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17164 inote
.type
, inote
.namesz
, inote
.descsz
);
17168 external
= (Elf_External_Note
*) next
;
17170 /* Verify that name is null terminated. It appears that at least
17171 one version of Linux (RedHat 6.0) generates corefiles that don't
17172 comply with the ELF spec by failing to include the null byte in
17174 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17176 temp
= (char *) malloc (inote
.namesz
+ 1);
17179 error (_("Out of memory allocating space for inote name\n"));
17184 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17185 temp
[inote
.namesz
] = 0;
17187 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17188 inote
.namedata
= temp
;
17191 if (! process_note (& inote
, file
))
17207 process_corefile_note_segments (FILE * file
)
17209 Elf_Internal_Phdr
* segment
;
17211 bfd_boolean res
= TRUE
;
17213 if (! get_program_headers (file
))
17216 for (i
= 0, segment
= program_headers
;
17217 i
< elf_header
.e_phnum
;
17220 if (segment
->p_type
== PT_NOTE
)
17221 if (! process_notes_at (file
, NULL
,
17222 (bfd_vma
) segment
->p_offset
,
17223 (bfd_vma
) segment
->p_filesz
))
17231 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17233 Elf_External_Note
* pnotes
;
17234 Elf_External_Note
* external
;
17236 bfd_boolean res
= TRUE
;
17241 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17243 if (pnotes
== NULL
)
17247 end
= (char*) pnotes
+ length
;
17249 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17250 (unsigned long) offset
, (unsigned long) length
);
17252 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17254 Elf_External_Note
* next
;
17255 Elf_Internal_Note inote
;
17257 inote
.type
= BYTE_GET (external
->type
);
17258 inote
.namesz
= BYTE_GET (external
->namesz
);
17259 inote
.namedata
= external
->name
;
17260 inote
.descsz
= BYTE_GET (external
->descsz
);
17261 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17262 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17264 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17266 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17267 inote
.descdata
= inote
.namedata
;
17271 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17273 if ( ((char *) next
> end
)
17274 || ((char *) next
< (char *) pnotes
))
17276 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17277 (unsigned long) ((char *) external
- (char *) pnotes
));
17278 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17279 inote
.type
, inote
.namesz
, inote
.descsz
);
17285 /* Prevent out-of-bounds indexing. */
17286 if ( inote
.namedata
+ inote
.namesz
> end
17287 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17289 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17290 (unsigned long) ((char *) external
- (char *) pnotes
));
17291 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17292 inote
.type
, inote
.namesz
, inote
.descsz
);
17296 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17298 if (! print_v850_note (& inote
))
17301 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17302 inote
.namesz
, inote
.descsz
);
17312 process_note_sections (FILE * file
)
17314 Elf_Internal_Shdr
* section
;
17316 unsigned int n
= 0;
17317 bfd_boolean res
= TRUE
;
17319 for (i
= 0, section
= section_headers
;
17320 i
< elf_header
.e_shnum
&& section
!= NULL
;
17323 if (section
->sh_type
== SHT_NOTE
)
17325 if (! process_notes_at (file
, section
,
17326 (bfd_vma
) section
->sh_offset
,
17327 (bfd_vma
) section
->sh_size
))
17332 if (( elf_header
.e_machine
== EM_V800
17333 || elf_header
.e_machine
== EM_V850
17334 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17335 && section
->sh_type
== SHT_RENESAS_INFO
)
17337 if (! process_v850_notes (file
,
17338 (bfd_vma
) section
->sh_offset
,
17339 (bfd_vma
) section
->sh_size
))
17346 /* Try processing NOTE segments instead. */
17347 return process_corefile_note_segments (file
);
17353 process_notes (FILE * file
)
17355 /* If we have not been asked to display the notes then do nothing. */
17359 if (elf_header
.e_type
!= ET_CORE
)
17360 return process_note_sections (file
);
17362 /* No program headers means no NOTE segment. */
17363 if (elf_header
.e_phnum
> 0)
17364 return process_corefile_note_segments (file
);
17366 printf (_("No note segments present in the core file.\n"));
17370 static unsigned char *
17371 display_public_gnu_attributes (unsigned char * start
,
17372 const unsigned char * const end
)
17374 printf (_(" Unknown GNU attribute: %s\n"), start
);
17376 start
+= strnlen ((char *) start
, end
- start
);
17377 display_raw_attribute (start
, end
);
17379 return (unsigned char *) end
;
17382 static unsigned char *
17383 display_generic_attribute (unsigned char * start
,
17385 const unsigned char * const end
)
17388 return (unsigned char *) end
;
17390 return display_tag_value (tag
, start
, end
);
17394 process_arch_specific (FILE * file
)
17399 switch (elf_header
.e_machine
)
17402 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17403 display_arm_attribute
,
17404 display_generic_attribute
);
17407 case EM_MIPS_RS3_LE
:
17408 return process_mips_specific (file
);
17411 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17412 display_msp430x_attribute
,
17413 display_generic_attribute
);
17416 return process_nds32_specific (file
);
17420 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17421 display_power_gnu_attribute
);
17425 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17426 display_s390_gnu_attribute
);
17429 case EM_SPARC32PLUS
:
17431 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17432 display_sparc_gnu_attribute
);
17435 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17436 display_tic6x_attribute
,
17437 display_generic_attribute
);
17440 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17441 display_public_gnu_attributes
,
17442 display_generic_attribute
);
17447 get_file_header (FILE * file
)
17449 /* Read in the identity array. */
17450 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
17453 /* Determine how to read the rest of the header. */
17454 switch (elf_header
.e_ident
[EI_DATA
])
17459 byte_get
= byte_get_little_endian
;
17460 byte_put
= byte_put_little_endian
;
17463 byte_get
= byte_get_big_endian
;
17464 byte_put
= byte_put_big_endian
;
17468 /* For now we only support 32 bit and 64 bit ELF files. */
17469 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
17471 /* Read in the rest of the header. */
17474 Elf32_External_Ehdr ehdr32
;
17476 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
17479 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
17480 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
17481 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
17482 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
17483 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
17484 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
17485 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
17486 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
17487 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
17488 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
17489 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
17490 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
17491 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
17495 Elf64_External_Ehdr ehdr64
;
17497 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17498 we will not be able to cope with the 64bit data found in
17499 64 ELF files. Detect this now and abort before we start
17500 overwriting things. */
17501 if (sizeof (bfd_vma
) < 8)
17503 error (_("This instance of readelf has been built without support for a\n\
17504 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17508 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
17511 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
17512 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
17513 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
17514 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
17515 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
17516 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
17517 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
17518 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
17519 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
17520 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
17521 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
17522 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
17523 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
17526 if (elf_header
.e_shoff
)
17528 /* There may be some extensions in the first section header. Don't
17529 bomb if we can't read it. */
17531 get_32bit_section_headers (file
, TRUE
);
17533 get_64bit_section_headers (file
, TRUE
);
17539 /* Process one ELF object file according to the command line options.
17540 This file may actually be stored in an archive. The file is
17541 positioned at the start of the ELF object. Returns TRUE if no
17542 problems were encountered, FALSE otherwise. */
17545 process_object (char * file_name
, FILE * file
)
17548 bfd_boolean res
= TRUE
;
17550 if (! get_file_header (file
))
17552 error (_("%s: Failed to read file header\n"), file_name
);
17556 /* Initialise per file variables. */
17557 for (i
= ARRAY_SIZE (version_info
); i
--;)
17558 version_info
[i
] = 0;
17560 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
17561 dynamic_info
[i
] = 0;
17562 dynamic_info_DT_GNU_HASH
= 0;
17564 /* Process the file. */
17566 printf (_("\nFile: %s\n"), file_name
);
17568 /* Initialise the dump_sects array from the cmdline_dump_sects array.
17569 Note we do this even if cmdline_dump_sects is empty because we
17570 must make sure that the dump_sets array is zeroed out before each
17571 object file is processed. */
17572 if (num_dump_sects
> num_cmdline_dump_sects
)
17573 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
17575 if (num_cmdline_dump_sects
> 0)
17577 if (num_dump_sects
== 0)
17578 /* A sneaky way of allocating the dump_sects array. */
17579 request_dump_bynumber (num_cmdline_dump_sects
, 0);
17581 assert (num_dump_sects
>= num_cmdline_dump_sects
);
17582 memcpy (dump_sects
, cmdline_dump_sects
,
17583 num_cmdline_dump_sects
* sizeof (* dump_sects
));
17586 if (! process_file_header ())
17589 if (! process_section_headers (file
))
17591 /* Without loaded section headers we cannot process lots of things. */
17592 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
17594 if (! do_using_dynamic
)
17595 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
17598 if (! process_section_groups (file
))
17599 /* Without loaded section groups we cannot process unwind. */
17602 if (process_program_headers (file
))
17603 process_dynamic_section (file
);
17607 if (! process_relocs (file
))
17610 if (! process_unwind (file
))
17613 if (! process_symbol_table (file
))
17616 if (! process_syminfo (file
))
17619 if (! process_version_sections (file
))
17622 if (! process_section_contents (file
))
17625 if (! process_notes (file
))
17628 if (! process_gnu_liblist (file
))
17631 if (! process_arch_specific (file
))
17634 if (program_headers
)
17636 free (program_headers
);
17637 program_headers
= NULL
;
17640 if (section_headers
)
17642 free (section_headers
);
17643 section_headers
= NULL
;
17648 free (string_table
);
17649 string_table
= NULL
;
17650 string_table_length
= 0;
17653 if (dynamic_strings
)
17655 free (dynamic_strings
);
17656 dynamic_strings
= NULL
;
17657 dynamic_strings_length
= 0;
17660 if (dynamic_symbols
)
17662 free (dynamic_symbols
);
17663 dynamic_symbols
= NULL
;
17664 num_dynamic_syms
= 0;
17667 if (dynamic_syminfo
)
17669 free (dynamic_syminfo
);
17670 dynamic_syminfo
= NULL
;
17673 if (dynamic_section
)
17675 free (dynamic_section
);
17676 dynamic_section
= NULL
;
17679 if (section_headers_groups
)
17681 free (section_headers_groups
);
17682 section_headers_groups
= NULL
;
17685 if (section_groups
)
17687 struct group_list
* g
;
17688 struct group_list
* next
;
17690 for (i
= 0; i
< group_count
; i
++)
17692 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
17699 free (section_groups
);
17700 section_groups
= NULL
;
17703 free_debug_memory ();
17708 /* Process an ELF archive.
17709 On entry the file is positioned just after the ARMAG string.
17710 Returns TRUE upon success, FALSE otherwise. */
17713 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
17715 struct archive_info arch
;
17716 struct archive_info nested_arch
;
17718 bfd_boolean ret
= TRUE
;
17722 /* The ARCH structure is used to hold information about this archive. */
17723 arch
.file_name
= NULL
;
17725 arch
.index_array
= NULL
;
17726 arch
.sym_table
= NULL
;
17727 arch
.longnames
= NULL
;
17729 /* The NESTED_ARCH structure is used as a single-item cache of information
17730 about a nested archive (when members of a thin archive reside within
17731 another regular archive file). */
17732 nested_arch
.file_name
= NULL
;
17733 nested_arch
.file
= NULL
;
17734 nested_arch
.index_array
= NULL
;
17735 nested_arch
.sym_table
= NULL
;
17736 nested_arch
.longnames
= NULL
;
17738 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
17744 if (do_archive_index
)
17746 if (arch
.sym_table
== NULL
)
17747 error (_("%s: unable to dump the index as none was found\n"), file_name
);
17750 unsigned long i
, l
;
17751 unsigned long current_pos
;
17753 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17754 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
17755 current_pos
= ftell (file
);
17757 for (i
= l
= 0; i
< arch
.index_num
; i
++)
17759 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
17761 char * member_name
;
17763 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
17765 if (member_name
!= NULL
)
17767 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
17769 if (qualified_name
!= NULL
)
17771 printf (_("Contents of binary %s at offset "), qualified_name
);
17772 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
17774 free (qualified_name
);
17779 if (l
>= arch
.sym_size
)
17781 error (_("%s: end of the symbol table reached before the end of the index\n"),
17786 /* PR 17531: file: 0b6630b2. */
17787 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
17788 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
17791 if (arch
.uses_64bit_indicies
)
17796 if (l
< arch
.sym_size
)
17798 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17799 file_name
, arch
.sym_size
- l
);
17803 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
17805 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
17811 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
17812 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
17813 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
17814 && !do_section_groups
&& !do_dyn_syms
)
17816 ret
= TRUE
; /* Archive index only. */
17825 char * qualified_name
;
17827 /* Read the next archive header. */
17828 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
17830 error (_("%s: failed to seek to next archive header\n"), file_name
);
17833 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
17834 if (got
!= sizeof arch
.arhdr
)
17838 error (_("%s: failed to read archive header\n"), file_name
);
17842 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
17844 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
17849 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
17851 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
17852 if (archive_file_size
& 01)
17853 ++archive_file_size
;
17855 name
= get_archive_member_name (&arch
, &nested_arch
);
17858 error (_("%s: bad archive file name\n"), file_name
);
17862 namelen
= strlen (name
);
17864 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
17865 if (qualified_name
== NULL
)
17867 error (_("%s: bad archive file name\n"), file_name
);
17872 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
17874 /* This is a proxy for an external member of a thin archive. */
17875 FILE * member_file
;
17876 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
17878 if (member_file_name
== NULL
)
17884 member_file
= fopen (member_file_name
, "rb");
17885 if (member_file
== NULL
)
17887 error (_("Input file '%s' is not readable.\n"), member_file_name
);
17888 free (member_file_name
);
17893 archive_file_offset
= arch
.nested_member_origin
;
17895 if (! process_object (qualified_name
, member_file
))
17898 fclose (member_file
);
17899 free (member_file_name
);
17901 else if (is_thin_archive
)
17903 /* PR 15140: Allow for corrupt thin archives. */
17904 if (nested_arch
.file
== NULL
)
17906 error (_("%s: contains corrupt thin archive: %s\n"),
17912 /* This is a proxy for a member of a nested archive. */
17913 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
17915 /* The nested archive file will have been opened and setup by
17916 get_archive_member_name. */
17917 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
17919 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
17924 if (! process_object (qualified_name
, nested_arch
.file
))
17929 archive_file_offset
= arch
.next_arhdr_offset
;
17930 arch
.next_arhdr_offset
+= archive_file_size
;
17932 if (! process_object (qualified_name
, file
))
17936 if (dump_sects
!= NULL
)
17940 num_dump_sects
= 0;
17943 free (qualified_name
);
17947 if (nested_arch
.file
!= NULL
)
17948 fclose (nested_arch
.file
);
17949 release_archive (&nested_arch
);
17950 release_archive (&arch
);
17956 process_file (char * file_name
)
17959 struct stat statbuf
;
17960 char armag
[SARMAG
];
17961 bfd_boolean ret
= TRUE
;
17963 if (stat (file_name
, &statbuf
) < 0)
17965 if (errno
== ENOENT
)
17966 error (_("'%s': No such file\n"), file_name
);
17968 error (_("Could not locate '%s'. System error message: %s\n"),
17969 file_name
, strerror (errno
));
17973 if (! S_ISREG (statbuf
.st_mode
))
17975 error (_("'%s' is not an ordinary file\n"), file_name
);
17979 file
= fopen (file_name
, "rb");
17982 error (_("Input file '%s' is not readable.\n"), file_name
);
17986 if (fread (armag
, SARMAG
, 1, file
) != 1)
17988 error (_("%s: Failed to read file's magic number\n"), file_name
);
17993 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
17995 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
17997 if (! process_archive (file_name
, file
, FALSE
))
18000 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18002 if ( ! process_archive (file_name
, file
, TRUE
))
18007 if (do_archive_index
)
18008 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18012 archive_file_size
= archive_file_offset
= 0;
18014 if (! process_object (file_name
, file
))
18019 current_file_size
= 0;
18024 #ifdef SUPPORT_DISASSEMBLY
18025 /* Needed by the i386 disassembler. For extra credit, someone could
18026 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18030 print_address (unsigned int addr
, FILE * outfile
)
18032 fprintf (outfile
,"0x%8.8x", addr
);
18035 /* Needed by the i386 disassembler. */
18037 db_task_printsym (unsigned int addr
)
18039 print_address (addr
, stderr
);
18044 main (int argc
, char ** argv
)
18048 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18049 setlocale (LC_MESSAGES
, "");
18051 #if defined (HAVE_SETLOCALE)
18052 setlocale (LC_CTYPE
, "");
18054 bindtextdomain (PACKAGE
, LOCALEDIR
);
18055 textdomain (PACKAGE
);
18057 expandargv (&argc
, &argv
);
18059 parse_args (argc
, argv
);
18061 if (num_dump_sects
> 0)
18063 /* Make a copy of the dump_sects array. */
18064 cmdline_dump_sects
= (dump_type
*)
18065 malloc (num_dump_sects
* sizeof (* dump_sects
));
18066 if (cmdline_dump_sects
== NULL
)
18067 error (_("Out of memory allocating dump request table.\n"));
18070 memcpy (cmdline_dump_sects
, dump_sects
,
18071 num_dump_sects
* sizeof (* dump_sects
));
18072 num_cmdline_dump_sects
= num_dump_sects
;
18076 if (optind
< (argc
- 1))
18078 else if (optind
>= argc
)
18080 warn (_("Nothing to do.\n"));
18085 while (optind
< argc
)
18086 if (! process_file (argv
[optind
++]))
18089 if (dump_sects
!= NULL
)
18091 if (cmdline_dump_sects
!= NULL
)
18092 free (cmdline_dump_sects
);
18094 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;