1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2016 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/mmix.h"
128 #include "elf/mn10200.h"
129 #include "elf/mn10300.h"
130 #include "elf/moxie.h"
132 #include "elf/msp430.h"
133 #include "elf/nds32.h"
134 #include "elf/nios2.h"
135 #include "elf/or1k.h"
138 #include "elf/ppc64.h"
139 #include "elf/rl78.h"
141 #include "elf/s390.h"
142 #include "elf/score.h"
144 #include "elf/sparc.h"
146 #include "elf/tic6x.h"
147 #include "elf/tilegx.h"
148 #include "elf/tilepro.h"
149 #include "elf/v850.h"
151 #include "elf/visium.h"
152 #include "elf/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167 typedef struct elf_section_list
169 Elf_Internal_Shdr
* hdr
;
170 struct elf_section_list
* next
;
173 char * program_name
= "readelf";
174 static unsigned long archive_file_offset
;
175 static unsigned long archive_file_size
;
176 static bfd_size_type current_file_size
;
177 static unsigned long dynamic_addr
;
178 static bfd_size_type dynamic_size
;
179 static size_t dynamic_nent
;
180 static char * dynamic_strings
;
181 static unsigned long dynamic_strings_length
;
182 static char * string_table
;
183 static unsigned long string_table_length
;
184 static unsigned long num_dynamic_syms
;
185 static Elf_Internal_Sym
* dynamic_symbols
;
186 static Elf_Internal_Syminfo
* dynamic_syminfo
;
187 static unsigned long dynamic_syminfo_offset
;
188 static unsigned int dynamic_syminfo_nent
;
189 static char program_interpreter
[PATH_MAX
];
190 static bfd_vma dynamic_info
[DT_ENCODING
];
191 static bfd_vma dynamic_info_DT_GNU_HASH
;
192 static bfd_vma version_info
[16];
193 static Elf_Internal_Ehdr elf_header
;
194 static Elf_Internal_Shdr
* section_headers
;
195 static Elf_Internal_Phdr
* program_headers
;
196 static Elf_Internal_Dyn
* dynamic_section
;
197 static elf_section_list
* symtab_shndx_list
;
198 static int show_name
;
199 static int do_dynamic
;
201 static int do_dyn_syms
;
203 static int do_sections
;
204 static int do_section_groups
;
205 static int do_section_details
;
206 static int do_segments
;
207 static int do_unwind
;
208 static int do_using_dynamic
;
209 static int do_header
;
211 static int do_version
;
212 static int do_histogram
;
213 static int do_debugging
;
216 static int do_archive_index
;
217 static int is_32bit_elf
;
218 static int decompress_dumps
;
222 struct group_list
* next
;
223 unsigned int section_index
;
228 struct group_list
* root
;
229 unsigned int group_index
;
232 static size_t group_count
;
233 static struct group
* section_groups
;
234 static struct group
** section_headers_groups
;
237 /* Flag bits indicating particular types of dump. */
238 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
239 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
240 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
241 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
242 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
244 typedef unsigned char dump_type
;
246 /* A linked list of the section names for which dumps were requested. */
247 struct dump_list_entry
251 struct dump_list_entry
* next
;
253 static struct dump_list_entry
* dump_sects_byname
;
255 /* A dynamic array of flags indicating for which sections a dump
256 has been requested via command line switches. */
257 static dump_type
* cmdline_dump_sects
= NULL
;
258 static unsigned int num_cmdline_dump_sects
= 0;
260 /* A dynamic array of flags indicating for which sections a dump of
261 some kind has been requested. It is reset on a per-object file
262 basis and then initialised from the cmdline_dump_sects array,
263 the results of interpreting the -w switch, and the
264 dump_sects_byname list. */
265 static dump_type
* dump_sects
= NULL
;
266 static unsigned int num_dump_sects
= 0;
269 /* How to print a vma value. */
270 typedef enum print_mode
282 /* Versioned symbol info. */
283 enum versioned_symbol_info
290 static const char *get_symbol_version_string
291 (FILE *file
, int is_dynsym
, const char *strtab
,
292 unsigned long int strtab_size
, unsigned int si
,
293 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
294 unsigned short *vna_other
);
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. */
421 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
);
449 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
452 return printf ("%" BFD_VMA_FMT
"d", vma
);
455 return printf ("%" BFD_VMA_FMT
"u", vma
);
460 /* Display a symbol on stdout. Handles the display of control characters and
461 multibye characters (assuming the host environment supports them).
463 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
465 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
466 padding as necessary.
468 Returns the number of emitted characters. */
471 print_symbol (int width
, const char *symbol
)
473 bfd_boolean extra_padding
= FALSE
;
475 #ifdef HAVE_MBSTATE_T
482 /* Keep the width positive. This also helps. */
484 extra_padding
= TRUE
;
489 /* Set the remaining width to a very large value.
490 This simplifies the code below. */
491 width_remaining
= INT_MAX
;
493 width_remaining
= width
;
495 #ifdef HAVE_MBSTATE_T
496 /* Initialise the multibyte conversion state. */
497 memset (& state
, 0, sizeof (state
));
500 while (width_remaining
)
503 const char c
= *symbol
++;
508 /* Do not print control characters directly as they can affect terminal
509 settings. Such characters usually appear in the names generated
510 by the assembler for local labels. */
513 if (width_remaining
< 2)
516 printf ("^%c", c
+ 0x40);
517 width_remaining
-= 2;
520 else if (ISPRINT (c
))
528 #ifdef HAVE_MBSTATE_T
531 /* Let printf do the hard work of displaying multibyte characters. */
532 printf ("%.1s", symbol
- 1);
536 #ifdef HAVE_MBSTATE_T
537 /* Try to find out how many bytes made up the character that was
538 just printed. Advance the symbol pointer past the bytes that
540 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
544 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
549 if (extra_padding
&& num_printed
< width
)
551 /* Fill in the remaining spaces. */
552 printf ("%-*s", width
- num_printed
, " ");
559 /* Returns a pointer to a static buffer containing a printable version of
560 the given section's name. Like print_symbol, except that it does not try
561 to print multibyte characters, it just interprets them as hex values. */
564 printable_section_name (const Elf_Internal_Shdr
* sec
)
566 #define MAX_PRINT_SEC_NAME_LEN 128
567 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
568 const char * name
= SECTION_NAME (sec
);
569 char * buf
= sec_name_buf
;
571 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
573 while ((c
= * name
++) != 0)
584 else if (ISPRINT (c
))
591 static char hex
[17] = "0123456789ABCDEF";
596 * buf
++ = hex
[(c
& 0xf0) >> 4];
597 * buf
++ = hex
[c
& 0x0f];
611 printable_section_name_from_index (unsigned long ndx
)
613 if (ndx
>= elf_header
.e_shnum
)
614 return _("<corrupt>");
616 return printable_section_name (section_headers
+ ndx
);
619 /* Return a pointer to section NAME, or NULL if no such section exists. */
621 static Elf_Internal_Shdr
*
622 find_section (const char * name
)
626 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
627 if (streq (SECTION_NAME (section_headers
+ i
), name
))
628 return section_headers
+ i
;
633 /* Return a pointer to a section containing ADDR, or NULL if no such
636 static Elf_Internal_Shdr
*
637 find_section_by_address (bfd_vma addr
)
641 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
643 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
644 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
651 static Elf_Internal_Shdr
*
652 find_section_by_type (unsigned int type
)
656 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
658 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
659 if (sec
->sh_type
== type
)
666 /* Return a pointer to section NAME, or NULL if no such section exists,
667 restricted to the list of sections given in SET. */
669 static Elf_Internal_Shdr
*
670 find_section_in_set (const char * name
, unsigned int * set
)
676 while ((i
= *set
++) > 0)
677 if (streq (SECTION_NAME (section_headers
+ i
), name
))
678 return section_headers
+ i
;
681 return find_section (name
);
684 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
687 static inline unsigned long
688 read_uleb128 (unsigned char *data
,
689 unsigned int *length_return
,
690 const unsigned char * const end
)
692 return read_leb128 (data
, length_return
, FALSE
, end
);
695 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
696 This OS has so many departures from the ELF standard that we test it at
702 return elf_header
.e_machine
== EM_IA_64
703 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
706 /* Guess the relocation size commonly used by the specific machines. */
709 guess_is_rela (unsigned int e_machine
)
713 /* Targets that use REL relocations. */
728 /* Targets that use RELA relocations. */
732 case EM_ADAPTEVA_EPIPHANY
:
734 case EM_ALTERA_NIOS2
:
737 case EM_ARC_COMPACT2
:
757 case EM_LATTICEMICO32
:
766 case EM_CYGNUS_MN10200
:
768 case EM_CYGNUS_MN10300
:
802 case EM_MICROBLAZE_OLD
:
823 warn (_("Don't know about relocations on this machine architecture\n"));
829 slurp_rela_relocs (FILE * file
,
830 unsigned long rel_offset
,
831 unsigned long rel_size
,
832 Elf_Internal_Rela
** relasp
,
833 unsigned long * nrelasp
)
835 Elf_Internal_Rela
* relas
;
841 Elf32_External_Rela
* erelas
;
843 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
844 rel_size
, _("32-bit relocation data"));
848 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
850 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
851 sizeof (Elf_Internal_Rela
));
856 error (_("out of memory parsing relocs\n"));
860 for (i
= 0; i
< nrelas
; i
++)
862 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
863 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
864 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
871 Elf64_External_Rela
* erelas
;
873 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
874 rel_size
, _("64-bit relocation data"));
878 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
880 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
881 sizeof (Elf_Internal_Rela
));
886 error (_("out of memory parsing relocs\n"));
890 for (i
= 0; i
< nrelas
; i
++)
892 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
893 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
894 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
896 /* The #ifdef BFD64 below is to prevent a compile time
897 warning. We know that if we do not have a 64 bit data
898 type that we will never execute this code anyway. */
900 if (elf_header
.e_machine
== EM_MIPS
901 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
903 /* In little-endian objects, r_info isn't really a
904 64-bit little-endian value: it has a 32-bit
905 little-endian symbol index followed by four
906 individual byte fields. Reorder INFO
908 bfd_vma inf
= relas
[i
].r_info
;
909 inf
= (((inf
& 0xffffffff) << 32)
910 | ((inf
>> 56) & 0xff)
911 | ((inf
>> 40) & 0xff00)
912 | ((inf
>> 24) & 0xff0000)
913 | ((inf
>> 8) & 0xff000000));
914 relas
[i
].r_info
= inf
;
927 slurp_rel_relocs (FILE * file
,
928 unsigned long rel_offset
,
929 unsigned long rel_size
,
930 Elf_Internal_Rela
** relsp
,
931 unsigned long * nrelsp
)
933 Elf_Internal_Rela
* rels
;
939 Elf32_External_Rel
* erels
;
941 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
942 rel_size
, _("32-bit relocation data"));
946 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
948 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
953 error (_("out of memory parsing relocs\n"));
957 for (i
= 0; i
< nrels
; i
++)
959 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
960 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
961 rels
[i
].r_addend
= 0;
968 Elf64_External_Rel
* erels
;
970 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
971 rel_size
, _("64-bit relocation data"));
975 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
977 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
982 error (_("out of memory parsing relocs\n"));
986 for (i
= 0; i
< nrels
; i
++)
988 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
989 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
990 rels
[i
].r_addend
= 0;
992 /* The #ifdef BFD64 below is to prevent a compile time
993 warning. We know that if we do not have a 64 bit data
994 type that we will never execute this code anyway. */
996 if (elf_header
.e_machine
== EM_MIPS
997 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
999 /* In little-endian objects, r_info isn't really a
1000 64-bit little-endian value: it has a 32-bit
1001 little-endian symbol index followed by four
1002 individual byte fields. Reorder INFO
1004 bfd_vma inf
= rels
[i
].r_info
;
1005 inf
= (((inf
& 0xffffffff) << 32)
1006 | ((inf
>> 56) & 0xff)
1007 | ((inf
>> 40) & 0xff00)
1008 | ((inf
>> 24) & 0xff0000)
1009 | ((inf
>> 8) & 0xff000000));
1010 rels
[i
].r_info
= inf
;
1022 /* Returns the reloc type extracted from the reloc info field. */
1025 get_reloc_type (bfd_vma reloc_info
)
1028 return ELF32_R_TYPE (reloc_info
);
1030 switch (elf_header
.e_machine
)
1033 /* Note: We assume that reloc_info has already been adjusted for us. */
1034 return ELF64_MIPS_R_TYPE (reloc_info
);
1037 return ELF64_R_TYPE_ID (reloc_info
);
1040 return ELF64_R_TYPE (reloc_info
);
1044 /* Return the symbol index extracted from the reloc info field. */
1047 get_reloc_symindex (bfd_vma reloc_info
)
1049 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1052 static inline bfd_boolean
1053 uses_msp430x_relocs (void)
1056 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1057 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1058 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1059 /* TI compiler uses ELFOSABI_NONE. */
1060 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1063 /* Display the contents of the relocation data found at the specified
1067 dump_relocations (FILE * file
,
1068 unsigned long rel_offset
,
1069 unsigned long rel_size
,
1070 Elf_Internal_Sym
* symtab
,
1071 unsigned long nsyms
,
1073 unsigned long strtablen
,
1078 Elf_Internal_Rela
* rels
;
1080 if (is_rela
== UNKNOWN
)
1081 is_rela
= guess_is_rela (elf_header
.e_machine
);
1085 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1090 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1099 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1101 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1106 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1108 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1116 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1118 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1123 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1125 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1129 for (i
= 0; i
< rel_size
; i
++)
1134 bfd_vma symtab_index
;
1137 offset
= rels
[i
].r_offset
;
1138 inf
= rels
[i
].r_info
;
1140 type
= get_reloc_type (inf
);
1141 symtab_index
= get_reloc_symindex (inf
);
1145 printf ("%8.8lx %8.8lx ",
1146 (unsigned long) offset
& 0xffffffff,
1147 (unsigned long) inf
& 0xffffffff);
1151 #if BFD_HOST_64BIT_LONG
1153 ? "%16.16lx %16.16lx "
1154 : "%12.12lx %12.12lx ",
1156 #elif BFD_HOST_64BIT_LONG_LONG
1159 ? "%16.16llx %16.16llx "
1160 : "%12.12llx %12.12llx ",
1164 ? "%16.16I64x %16.16I64x "
1165 : "%12.12I64x %12.12I64x ",
1170 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1171 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1172 _bfd_int64_high (offset
),
1173 _bfd_int64_low (offset
),
1174 _bfd_int64_high (inf
),
1175 _bfd_int64_low (inf
));
1179 switch (elf_header
.e_machine
)
1186 rtype
= elf_aarch64_reloc_type (type
);
1190 case EM_CYGNUS_M32R
:
1191 rtype
= elf_m32r_reloc_type (type
);
1196 rtype
= elf_i386_reloc_type (type
);
1201 rtype
= elf_m68hc11_reloc_type (type
);
1205 rtype
= elf_m68k_reloc_type (type
);
1209 rtype
= elf_i960_reloc_type (type
);
1214 rtype
= elf_avr_reloc_type (type
);
1217 case EM_OLD_SPARCV9
:
1218 case EM_SPARC32PLUS
:
1221 rtype
= elf_sparc_reloc_type (type
);
1225 rtype
= elf_spu_reloc_type (type
);
1229 rtype
= v800_reloc_type (type
);
1232 case EM_CYGNUS_V850
:
1233 rtype
= v850_reloc_type (type
);
1237 case EM_CYGNUS_D10V
:
1238 rtype
= elf_d10v_reloc_type (type
);
1242 case EM_CYGNUS_D30V
:
1243 rtype
= elf_d30v_reloc_type (type
);
1247 rtype
= elf_dlx_reloc_type (type
);
1251 rtype
= elf_sh_reloc_type (type
);
1255 case EM_CYGNUS_MN10300
:
1256 rtype
= elf_mn10300_reloc_type (type
);
1260 case EM_CYGNUS_MN10200
:
1261 rtype
= elf_mn10200_reloc_type (type
);
1265 case EM_CYGNUS_FR30
:
1266 rtype
= elf_fr30_reloc_type (type
);
1270 rtype
= elf_frv_reloc_type (type
);
1274 rtype
= elf_ft32_reloc_type (type
);
1278 rtype
= elf_mcore_reloc_type (type
);
1282 rtype
= elf_mmix_reloc_type (type
);
1286 rtype
= elf_moxie_reloc_type (type
);
1290 if (uses_msp430x_relocs ())
1292 rtype
= elf_msp430x_reloc_type (type
);
1296 rtype
= elf_msp430_reloc_type (type
);
1300 rtype
= elf_nds32_reloc_type (type
);
1304 rtype
= elf_ppc_reloc_type (type
);
1308 rtype
= elf_ppc64_reloc_type (type
);
1312 case EM_MIPS_RS3_LE
:
1313 rtype
= elf_mips_reloc_type (type
);
1317 rtype
= elf_alpha_reloc_type (type
);
1321 rtype
= elf_arm_reloc_type (type
);
1325 case EM_ARC_COMPACT
:
1326 case EM_ARC_COMPACT2
:
1327 rtype
= elf_arc_reloc_type (type
);
1331 rtype
= elf_hppa_reloc_type (type
);
1337 rtype
= elf_h8_reloc_type (type
);
1341 rtype
= elf_or1k_reloc_type (type
);
1346 rtype
= elf_pj_reloc_type (type
);
1349 rtype
= elf_ia64_reloc_type (type
);
1353 rtype
= elf_cris_reloc_type (type
);
1357 rtype
= elf_i860_reloc_type (type
);
1363 rtype
= elf_x86_64_reloc_type (type
);
1367 rtype
= i370_reloc_type (type
);
1372 rtype
= elf_s390_reloc_type (type
);
1376 rtype
= elf_score_reloc_type (type
);
1380 rtype
= elf_xstormy16_reloc_type (type
);
1384 rtype
= elf_crx_reloc_type (type
);
1388 rtype
= elf_vax_reloc_type (type
);
1392 rtype
= elf_visium_reloc_type (type
);
1395 case EM_ADAPTEVA_EPIPHANY
:
1396 rtype
= elf_epiphany_reloc_type (type
);
1401 rtype
= elf_ip2k_reloc_type (type
);
1405 rtype
= elf_iq2000_reloc_type (type
);
1410 rtype
= elf_xtensa_reloc_type (type
);
1413 case EM_LATTICEMICO32
:
1414 rtype
= elf_lm32_reloc_type (type
);
1419 rtype
= elf_m32c_reloc_type (type
);
1423 rtype
= elf_mt_reloc_type (type
);
1427 rtype
= elf_bfin_reloc_type (type
);
1431 rtype
= elf_mep_reloc_type (type
);
1435 rtype
= elf_cr16_reloc_type (type
);
1439 case EM_MICROBLAZE_OLD
:
1440 rtype
= elf_microblaze_reloc_type (type
);
1444 rtype
= elf_rl78_reloc_type (type
);
1448 rtype
= elf_rx_reloc_type (type
);
1452 rtype
= elf_metag_reloc_type (type
);
1457 rtype
= elf_xc16x_reloc_type (type
);
1461 rtype
= elf_tic6x_reloc_type (type
);
1465 rtype
= elf_tilegx_reloc_type (type
);
1469 rtype
= elf_tilepro_reloc_type (type
);
1473 rtype
= elf_xgate_reloc_type (type
);
1476 case EM_ALTERA_NIOS2
:
1477 rtype
= elf_nios2_reloc_type (type
);
1482 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1484 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1486 if (elf_header
.e_machine
== EM_ALPHA
1488 && streq (rtype
, "R_ALPHA_LITUSE")
1491 switch (rels
[i
].r_addend
)
1493 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1494 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1495 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1496 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1497 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1498 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1499 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1500 default: rtype
= NULL
;
1503 printf (" (%s)", rtype
);
1507 printf (_("<unknown addend: %lx>"),
1508 (unsigned long) rels
[i
].r_addend
);
1511 else if (symtab_index
)
1513 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1514 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1517 Elf_Internal_Sym
* psym
;
1518 const char * version_string
;
1519 enum versioned_symbol_info sym_info
;
1520 unsigned short vna_other
;
1522 psym
= symtab
+ symtab_index
;
1525 = get_symbol_version_string (file
, is_dynsym
,
1534 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1538 unsigned int width
= is_32bit_elf
? 8 : 14;
1540 /* Relocations against GNU_IFUNC symbols do not use the value
1541 of the symbol as the address to relocate against. Instead
1542 they invoke the function named by the symbol and use its
1543 result as the address for relocation.
1545 To indicate this to the user, do not display the value of
1546 the symbol in the "Symbols's Value" field. Instead show
1547 its name followed by () as a hint that the symbol is
1551 || psym
->st_name
== 0
1552 || psym
->st_name
>= strtablen
)
1555 name
= strtab
+ psym
->st_name
;
1557 len
= print_symbol (width
, name
);
1559 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1561 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1565 print_vma (psym
->st_value
, LONG_HEX
);
1567 printf (is_32bit_elf
? " " : " ");
1570 if (psym
->st_name
== 0)
1572 const char * sec_name
= "<null>";
1575 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1577 if (psym
->st_shndx
< elf_header
.e_shnum
)
1578 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1579 else if (psym
->st_shndx
== SHN_ABS
)
1581 else if (psym
->st_shndx
== SHN_COMMON
)
1582 sec_name
= "COMMON";
1583 else if ((elf_header
.e_machine
== EM_MIPS
1584 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1585 || (elf_header
.e_machine
== EM_TI_C6000
1586 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1587 sec_name
= "SCOMMON";
1588 else if (elf_header
.e_machine
== EM_MIPS
1589 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1590 sec_name
= "SUNDEF";
1591 else if ((elf_header
.e_machine
== EM_X86_64
1592 || elf_header
.e_machine
== EM_L1OM
1593 || elf_header
.e_machine
== EM_K1OM
)
1594 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1595 sec_name
= "LARGE_COMMON";
1596 else if (elf_header
.e_machine
== EM_IA_64
1597 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1598 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1599 sec_name
= "ANSI_COM";
1600 else if (is_ia64_vms ()
1601 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1602 sec_name
= "VMS_SYMVEC";
1605 sprintf (name_buf
, "<section 0x%x>",
1606 (unsigned int) psym
->st_shndx
);
1607 sec_name
= name_buf
;
1610 print_symbol (22, sec_name
);
1612 else if (strtab
== NULL
)
1613 printf (_("<string table index: %3ld>"), psym
->st_name
);
1614 else if (psym
->st_name
>= strtablen
)
1615 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1618 print_symbol (22, strtab
+ psym
->st_name
);
1620 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1626 bfd_vma off
= rels
[i
].r_addend
;
1628 if ((bfd_signed_vma
) off
< 0)
1629 printf (" - %" BFD_VMA_FMT
"x", - off
);
1631 printf (" + %" BFD_VMA_FMT
"x", off
);
1637 bfd_vma off
= rels
[i
].r_addend
;
1639 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1640 if ((bfd_signed_vma
) off
< 0)
1641 printf ("-%" BFD_VMA_FMT
"x", - off
);
1643 printf ("%" BFD_VMA_FMT
"x", off
);
1646 if (elf_header
.e_machine
== EM_SPARCV9
1648 && streq (rtype
, "R_SPARC_OLO10"))
1649 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1654 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1656 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1657 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1658 const char * rtype2
= elf_mips_reloc_type (type2
);
1659 const char * rtype3
= elf_mips_reloc_type (type3
);
1661 printf (" Type2: ");
1664 printf (_("unrecognized: %-7lx"),
1665 (unsigned long) type2
& 0xffffffff);
1667 printf ("%-17.17s", rtype2
);
1669 printf ("\n Type3: ");
1672 printf (_("unrecognized: %-7lx"),
1673 (unsigned long) type3
& 0xffffffff);
1675 printf ("%-17.17s", rtype3
);
1686 get_mips_dynamic_type (unsigned long type
)
1690 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1691 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1692 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1693 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1694 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1695 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1696 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1697 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1698 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1699 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1700 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1701 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1702 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1703 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1704 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1705 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1706 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1707 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1708 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1709 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1710 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1711 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1712 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1713 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1714 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1715 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1716 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1717 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1718 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1719 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1720 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1721 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1722 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1723 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1724 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1725 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1726 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1727 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1728 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1729 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1730 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1731 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1732 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1733 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1734 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1735 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1742 get_sparc64_dynamic_type (unsigned long type
)
1746 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1753 get_ppc_dynamic_type (unsigned long type
)
1757 case DT_PPC_GOT
: return "PPC_GOT";
1758 case DT_PPC_OPT
: return "PPC_OPT";
1765 get_ppc64_dynamic_type (unsigned long type
)
1769 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1770 case DT_PPC64_OPD
: return "PPC64_OPD";
1771 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1772 case DT_PPC64_OPT
: return "PPC64_OPT";
1779 get_parisc_dynamic_type (unsigned long type
)
1783 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1784 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1785 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1786 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1787 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1788 case DT_HP_PREINIT
: return "HP_PREINIT";
1789 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1790 case DT_HP_NEEDED
: return "HP_NEEDED";
1791 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1792 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1793 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1794 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1795 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1796 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1797 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1798 case DT_HP_FILTERED
: return "HP_FILTERED";
1799 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1800 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1801 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1802 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1803 case DT_PLT
: return "PLT";
1804 case DT_PLT_SIZE
: return "PLT_SIZE";
1805 case DT_DLT
: return "DLT";
1806 case DT_DLT_SIZE
: return "DLT_SIZE";
1813 get_ia64_dynamic_type (unsigned long type
)
1817 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1818 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1819 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1820 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1821 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1822 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1823 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1824 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1825 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1826 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1827 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1828 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1829 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1830 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1831 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1832 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1833 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1834 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1835 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1836 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1837 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1838 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1839 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1840 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1841 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1842 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1843 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1844 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1845 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1846 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1847 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1854 get_solaris_section_type (unsigned long type
)
1858 case 0x6fffffee: return "SUNW_ancillary";
1859 case 0x6fffffef: return "SUNW_capchain";
1860 case 0x6ffffff0: return "SUNW_capinfo";
1861 case 0x6ffffff1: return "SUNW_symsort";
1862 case 0x6ffffff2: return "SUNW_tlssort";
1863 case 0x6ffffff3: return "SUNW_LDYNSYM";
1864 case 0x6ffffff4: return "SUNW_dof";
1865 case 0x6ffffff5: return "SUNW_cap";
1866 case 0x6ffffff6: return "SUNW_SIGNATURE";
1867 case 0x6ffffff7: return "SUNW_ANNOTATE";
1868 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1869 case 0x6ffffff9: return "SUNW_DEBUG";
1870 case 0x6ffffffa: return "SUNW_move";
1871 case 0x6ffffffb: return "SUNW_COMDAT";
1872 case 0x6ffffffc: return "SUNW_syminfo";
1873 case 0x6ffffffd: return "SUNW_verdef";
1874 case 0x6ffffffe: return "SUNW_verneed";
1875 case 0x6fffffff: return "SUNW_versym";
1876 case 0x70000000: return "SPARC_GOTDATA";
1877 default: return NULL
;
1882 get_alpha_dynamic_type (unsigned long type
)
1886 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1893 get_score_dynamic_type (unsigned long type
)
1897 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1898 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1899 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1900 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1901 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1902 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1909 get_tic6x_dynamic_type (unsigned long type
)
1913 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1914 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1915 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1916 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1917 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1918 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1925 get_nios2_dynamic_type (unsigned long type
)
1929 case DT_NIOS2_GP
: return "NIOS2_GP";
1936 get_solaris_dynamic_type (unsigned long type
)
1940 case 0x6000000d: return "SUNW_AUXILIARY";
1941 case 0x6000000e: return "SUNW_RTLDINF";
1942 case 0x6000000f: return "SUNW_FILTER";
1943 case 0x60000010: return "SUNW_CAP";
1944 case 0x60000011: return "SUNW_SYMTAB";
1945 case 0x60000012: return "SUNW_SYMSZ";
1946 case 0x60000013: return "SUNW_SORTENT";
1947 case 0x60000014: return "SUNW_SYMSORT";
1948 case 0x60000015: return "SUNW_SYMSORTSZ";
1949 case 0x60000016: return "SUNW_TLSSORT";
1950 case 0x60000017: return "SUNW_TLSSORTSZ";
1951 case 0x60000018: return "SUNW_CAPINFO";
1952 case 0x60000019: return "SUNW_STRPAD";
1953 case 0x6000001a: return "SUNW_CAPCHAIN";
1954 case 0x6000001b: return "SUNW_LDMACH";
1955 case 0x6000001d: return "SUNW_CAPCHAINENT";
1956 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1957 case 0x60000021: return "SUNW_PARENT";
1958 case 0x60000023: return "SUNW_ASLR";
1959 case 0x60000025: return "SUNW_RELAX";
1960 case 0x60000029: return "SUNW_NXHEAP";
1961 case 0x6000002b: return "SUNW_NXSTACK";
1963 case 0x70000001: return "SPARC_REGISTER";
1964 case 0x7ffffffd: return "AUXILIARY";
1965 case 0x7ffffffe: return "USED";
1966 case 0x7fffffff: return "FILTER";
1968 default: return NULL
;
1973 get_dynamic_type (unsigned long type
)
1975 static char buff
[64];
1979 case DT_NULL
: return "NULL";
1980 case DT_NEEDED
: return "NEEDED";
1981 case DT_PLTRELSZ
: return "PLTRELSZ";
1982 case DT_PLTGOT
: return "PLTGOT";
1983 case DT_HASH
: return "HASH";
1984 case DT_STRTAB
: return "STRTAB";
1985 case DT_SYMTAB
: return "SYMTAB";
1986 case DT_RELA
: return "RELA";
1987 case DT_RELASZ
: return "RELASZ";
1988 case DT_RELAENT
: return "RELAENT";
1989 case DT_STRSZ
: return "STRSZ";
1990 case DT_SYMENT
: return "SYMENT";
1991 case DT_INIT
: return "INIT";
1992 case DT_FINI
: return "FINI";
1993 case DT_SONAME
: return "SONAME";
1994 case DT_RPATH
: return "RPATH";
1995 case DT_SYMBOLIC
: return "SYMBOLIC";
1996 case DT_REL
: return "REL";
1997 case DT_RELSZ
: return "RELSZ";
1998 case DT_RELENT
: return "RELENT";
1999 case DT_PLTREL
: return "PLTREL";
2000 case DT_DEBUG
: return "DEBUG";
2001 case DT_TEXTREL
: return "TEXTREL";
2002 case DT_JMPREL
: return "JMPREL";
2003 case DT_BIND_NOW
: return "BIND_NOW";
2004 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2005 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2006 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2007 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2008 case DT_RUNPATH
: return "RUNPATH";
2009 case DT_FLAGS
: return "FLAGS";
2011 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2012 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2014 case DT_CHECKSUM
: return "CHECKSUM";
2015 case DT_PLTPADSZ
: return "PLTPADSZ";
2016 case DT_MOVEENT
: return "MOVEENT";
2017 case DT_MOVESZ
: return "MOVESZ";
2018 case DT_FEATURE
: return "FEATURE";
2019 case DT_POSFLAG_1
: return "POSFLAG_1";
2020 case DT_SYMINSZ
: return "SYMINSZ";
2021 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2023 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2024 case DT_CONFIG
: return "CONFIG";
2025 case DT_DEPAUDIT
: return "DEPAUDIT";
2026 case DT_AUDIT
: return "AUDIT";
2027 case DT_PLTPAD
: return "PLTPAD";
2028 case DT_MOVETAB
: return "MOVETAB";
2029 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2031 case DT_VERSYM
: return "VERSYM";
2033 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2034 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2035 case DT_RELACOUNT
: return "RELACOUNT";
2036 case DT_RELCOUNT
: return "RELCOUNT";
2037 case DT_FLAGS_1
: return "FLAGS_1";
2038 case DT_VERDEF
: return "VERDEF";
2039 case DT_VERDEFNUM
: return "VERDEFNUM";
2040 case DT_VERNEED
: return "VERNEED";
2041 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2043 case DT_AUXILIARY
: return "AUXILIARY";
2044 case DT_USED
: return "USED";
2045 case DT_FILTER
: return "FILTER";
2047 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2048 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2049 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2050 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2051 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2052 case DT_GNU_HASH
: return "GNU_HASH";
2055 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2057 const char * result
;
2059 switch (elf_header
.e_machine
)
2062 case EM_MIPS_RS3_LE
:
2063 result
= get_mips_dynamic_type (type
);
2066 result
= get_sparc64_dynamic_type (type
);
2069 result
= get_ppc_dynamic_type (type
);
2072 result
= get_ppc64_dynamic_type (type
);
2075 result
= get_ia64_dynamic_type (type
);
2078 result
= get_alpha_dynamic_type (type
);
2081 result
= get_score_dynamic_type (type
);
2084 result
= get_tic6x_dynamic_type (type
);
2086 case EM_ALTERA_NIOS2
:
2087 result
= get_nios2_dynamic_type (type
);
2090 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2091 result
= get_solaris_dynamic_type (type
);
2100 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2102 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2103 || (elf_header
.e_machine
== EM_PARISC
2104 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2106 const char * result
;
2108 switch (elf_header
.e_machine
)
2111 result
= get_parisc_dynamic_type (type
);
2114 result
= get_ia64_dynamic_type (type
);
2117 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2118 result
= get_solaris_dynamic_type (type
);
2127 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2131 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2138 get_file_type (unsigned e_type
)
2140 static char buff
[32];
2144 case ET_NONE
: return _("NONE (None)");
2145 case ET_REL
: return _("REL (Relocatable file)");
2146 case ET_EXEC
: return _("EXEC (Executable file)");
2147 case ET_DYN
: return _("DYN (Shared object file)");
2148 case ET_CORE
: return _("CORE (Core file)");
2151 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2152 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2153 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2154 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2156 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2162 get_machine_name (unsigned e_machine
)
2164 static char buff
[64]; /* XXX */
2168 case EM_NONE
: return _("None");
2169 case EM_AARCH64
: return "AArch64";
2170 case EM_M32
: return "WE32100";
2171 case EM_SPARC
: return "Sparc";
2172 case EM_SPU
: return "SPU";
2173 case EM_386
: return "Intel 80386";
2174 case EM_68K
: return "MC68000";
2175 case EM_88K
: return "MC88000";
2176 case EM_IAMCU
: return "Intel MCU";
2177 case EM_860
: return "Intel 80860";
2178 case EM_MIPS
: return "MIPS R3000";
2179 case EM_S370
: return "IBM System/370";
2180 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2181 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2182 case EM_PARISC
: return "HPPA";
2183 case EM_PPC_OLD
: return "Power PC (old)";
2184 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2185 case EM_960
: return "Intel 90860";
2186 case EM_PPC
: return "PowerPC";
2187 case EM_PPC64
: return "PowerPC64";
2188 case EM_FR20
: return "Fujitsu FR20";
2189 case EM_FT32
: return "FTDI FT32";
2190 case EM_RH32
: return "TRW RH32";
2191 case EM_MCORE
: return "MCORE";
2192 case EM_ARM
: return "ARM";
2193 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2194 case EM_SH
: return "Renesas / SuperH SH";
2195 case EM_SPARCV9
: return "Sparc v9";
2196 case EM_TRICORE
: return "Siemens Tricore";
2197 case EM_ARC
: return "ARC";
2198 case EM_ARC_COMPACT
: return "ARCompact";
2199 case EM_ARC_COMPACT2
: return "ARCv2";
2200 case EM_H8_300
: return "Renesas H8/300";
2201 case EM_H8_300H
: return "Renesas H8/300H";
2202 case EM_H8S
: return "Renesas H8S";
2203 case EM_H8_500
: return "Renesas H8/500";
2204 case EM_IA_64
: return "Intel IA-64";
2205 case EM_MIPS_X
: return "Stanford MIPS-X";
2206 case EM_COLDFIRE
: return "Motorola Coldfire";
2207 case EM_ALPHA
: return "Alpha";
2208 case EM_CYGNUS_D10V
:
2209 case EM_D10V
: return "d10v";
2210 case EM_CYGNUS_D30V
:
2211 case EM_D30V
: return "d30v";
2212 case EM_CYGNUS_M32R
:
2213 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2214 case EM_CYGNUS_V850
:
2215 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2216 case EM_V850
: return "Renesas V850";
2217 case EM_CYGNUS_MN10300
:
2218 case EM_MN10300
: return "mn10300";
2219 case EM_CYGNUS_MN10200
:
2220 case EM_MN10200
: return "mn10200";
2221 case EM_MOXIE
: return "Moxie";
2222 case EM_CYGNUS_FR30
:
2223 case EM_FR30
: return "Fujitsu FR30";
2224 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2226 case EM_PJ
: return "picoJava";
2227 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2228 case EM_PCP
: return "Siemens PCP";
2229 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2230 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2231 case EM_STARCORE
: return "Motorola Star*Core processor";
2232 case EM_ME16
: return "Toyota ME16 processor";
2233 case EM_ST100
: return "STMicroelectronics ST100 processor";
2234 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2235 case EM_PDSP
: return "Sony DSP processor";
2236 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2237 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2238 case EM_FX66
: return "Siemens FX66 microcontroller";
2239 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2240 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2241 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2242 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2243 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2244 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2245 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2246 case EM_SVX
: return "Silicon Graphics SVx";
2247 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2248 case EM_VAX
: return "Digital VAX";
2249 case EM_VISIUM
: return "CDS VISIUMcore processor";
2251 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2252 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2253 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2254 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2255 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2256 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2257 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2258 case EM_PRISM
: return "Vitesse Prism";
2259 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2260 case EM_L1OM
: return "Intel L1OM";
2261 case EM_K1OM
: return "Intel K1OM";
2263 case EM_S390
: return "IBM S/390";
2264 case EM_SCORE
: return "SUNPLUS S+Core";
2265 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2266 case EM_OR1K
: return "OpenRISC 1000";
2267 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2268 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2269 case EM_DLX
: return "OpenDLX";
2271 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2272 case EM_IQ2000
: return "Vitesse IQ2000";
2274 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2275 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2276 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2277 case EM_NS32K
: return "National Semiconductor 32000 series";
2278 case EM_TPC
: return "Tenor Network TPC processor";
2279 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2280 case EM_MAX
: return "MAX Processor";
2281 case EM_CR
: return "National Semiconductor CompactRISC";
2282 case EM_F2MC16
: return "Fujitsu F2MC16";
2283 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2284 case EM_LATTICEMICO32
: return "Lattice Mico32";
2286 case EM_M32C
: return "Renesas M32c";
2287 case EM_MT
: return "Morpho Techologies MT processor";
2288 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2289 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2290 case EM_SEP
: return "Sharp embedded microprocessor";
2291 case EM_ARCA
: return "Arca RISC microprocessor";
2292 case EM_UNICORE
: return "Unicore";
2293 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2294 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2295 case EM_NIOS32
: return "Altera Nios";
2296 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2298 case EM_XC16X
: return "Infineon Technologies xc16x";
2299 case EM_M16C
: return "Renesas M16C series microprocessors";
2300 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2301 case EM_CE
: return "Freescale Communication Engine RISC core";
2302 case EM_TSK3000
: return "Altium TSK3000 core";
2303 case EM_RS08
: return "Freescale RS08 embedded processor";
2304 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2305 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2306 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2307 case EM_SE_C17
: return "Seiko Epson C17 family";
2308 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2309 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2310 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2311 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2312 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2313 case EM_R32C
: return "Renesas R32C series microprocessors";
2314 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2315 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2316 case EM_8051
: return "Intel 8051 and variants";
2317 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2318 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2319 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2320 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2321 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2322 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2323 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2324 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2327 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2328 case EM_RL78
: return "Renesas RL78";
2329 case EM_RX
: return "Renesas RX";
2330 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2331 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2332 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2333 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2334 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2335 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2336 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2337 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2338 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2339 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2340 case EM_CUDA
: return "NVIDIA CUDA architecture";
2341 case EM_XGATE
: return "Motorola XGATE embedded processor";
2343 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2349 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2351 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2352 other compilers don't a specific architecture type in the e_flags, and
2353 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2354 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2357 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2358 but also sets a specific architecture type in the e_flags field.
2360 However, when decoding the flags we don't worry if we see an
2361 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2362 ARCEM architecture type. */
2364 switch (e_flags
& EF_ARC_MACH_MSK
)
2366 /* We only expect these to occur for EM_ARC_COMPACT2. */
2367 case EF_ARC_CPU_ARCV2EM
:
2368 strcat (buf
, ", ARC EM");
2370 case EF_ARC_CPU_ARCV2HS
:
2371 strcat (buf
, ", ARC HS");
2374 /* We only expect these to occur for EM_ARC_COMPACT. */
2375 case E_ARC_MACH_ARC600
:
2376 strcat (buf
, ", ARC600");
2378 case E_ARC_MACH_ARC601
:
2379 strcat (buf
, ", ARC601");
2381 case E_ARC_MACH_ARC700
:
2382 strcat (buf
, ", ARC700");
2385 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2386 new ELF with new architecture being read by an old version of
2387 readelf, or (c) An ELF built with non-GNU compiler that does not
2388 set the architecture in the e_flags. */
2390 if (e_machine
== EM_ARC_COMPACT
)
2391 strcat (buf
, ", Unknown ARCompact");
2393 strcat (buf
, ", Unknown ARC");
2397 switch (e_flags
& EF_ARC_OSABI_MSK
)
2399 case E_ARC_OSABI_ORIG
:
2400 strcat (buf
, ", (ABI:legacy)");
2402 case E_ARC_OSABI_V2
:
2403 strcat (buf
, ", (ABI:v2)");
2405 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2406 case E_ARC_OSABI_V3
:
2407 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2410 strcat (buf
, ", unrecognised ARC OSABI flag");
2416 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2421 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2422 e_flags
&= ~ EF_ARM_EABIMASK
;
2424 /* Handle "generic" ARM flags. */
2425 if (e_flags
& EF_ARM_RELEXEC
)
2427 strcat (buf
, ", relocatable executable");
2428 e_flags
&= ~ EF_ARM_RELEXEC
;
2431 /* Now handle EABI specific flags. */
2435 strcat (buf
, ", <unrecognized EABI>");
2440 case EF_ARM_EABI_VER1
:
2441 strcat (buf
, ", Version1 EABI");
2446 /* Process flags one bit at a time. */
2447 flag
= e_flags
& - e_flags
;
2452 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2453 strcat (buf
, ", sorted symbol tables");
2463 case EF_ARM_EABI_VER2
:
2464 strcat (buf
, ", Version2 EABI");
2469 /* Process flags one bit at a time. */
2470 flag
= e_flags
& - e_flags
;
2475 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2476 strcat (buf
, ", sorted symbol tables");
2479 case EF_ARM_DYNSYMSUSESEGIDX
:
2480 strcat (buf
, ", dynamic symbols use segment index");
2483 case EF_ARM_MAPSYMSFIRST
:
2484 strcat (buf
, ", mapping symbols precede others");
2494 case EF_ARM_EABI_VER3
:
2495 strcat (buf
, ", Version3 EABI");
2498 case EF_ARM_EABI_VER4
:
2499 strcat (buf
, ", Version4 EABI");
2504 /* Process flags one bit at a time. */
2505 flag
= e_flags
& - e_flags
;
2511 strcat (buf
, ", BE8");
2515 strcat (buf
, ", LE8");
2526 case EF_ARM_EABI_VER5
:
2527 strcat (buf
, ", Version5 EABI");
2532 /* Process flags one bit at a time. */
2533 flag
= e_flags
& - e_flags
;
2539 strcat (buf
, ", BE8");
2543 strcat (buf
, ", LE8");
2546 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2547 strcat (buf
, ", soft-float ABI");
2550 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2551 strcat (buf
, ", hard-float ABI");
2561 case EF_ARM_EABI_UNKNOWN
:
2562 strcat (buf
, ", GNU EABI");
2567 /* Process flags one bit at a time. */
2568 flag
= e_flags
& - e_flags
;
2573 case EF_ARM_INTERWORK
:
2574 strcat (buf
, ", interworking enabled");
2577 case EF_ARM_APCS_26
:
2578 strcat (buf
, ", uses APCS/26");
2581 case EF_ARM_APCS_FLOAT
:
2582 strcat (buf
, ", uses APCS/float");
2586 strcat (buf
, ", position independent");
2590 strcat (buf
, ", 8 bit structure alignment");
2593 case EF_ARM_NEW_ABI
:
2594 strcat (buf
, ", uses new ABI");
2597 case EF_ARM_OLD_ABI
:
2598 strcat (buf
, ", uses old ABI");
2601 case EF_ARM_SOFT_FLOAT
:
2602 strcat (buf
, ", software FP");
2605 case EF_ARM_VFP_FLOAT
:
2606 strcat (buf
, ", VFP");
2609 case EF_ARM_MAVERICK_FLOAT
:
2610 strcat (buf
, ", Maverick FP");
2621 strcat (buf
,_(", <unknown>"));
2625 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2627 --size
; /* Leave space for null terminator. */
2629 switch (e_flags
& EF_AVR_MACH
)
2631 case E_AVR_MACH_AVR1
:
2632 strncat (buf
, ", avr:1", size
);
2634 case E_AVR_MACH_AVR2
:
2635 strncat (buf
, ", avr:2", size
);
2637 case E_AVR_MACH_AVR25
:
2638 strncat (buf
, ", avr:25", size
);
2640 case E_AVR_MACH_AVR3
:
2641 strncat (buf
, ", avr:3", size
);
2643 case E_AVR_MACH_AVR31
:
2644 strncat (buf
, ", avr:31", size
);
2646 case E_AVR_MACH_AVR35
:
2647 strncat (buf
, ", avr:35", size
);
2649 case E_AVR_MACH_AVR4
:
2650 strncat (buf
, ", avr:4", size
);
2652 case E_AVR_MACH_AVR5
:
2653 strncat (buf
, ", avr:5", size
);
2655 case E_AVR_MACH_AVR51
:
2656 strncat (buf
, ", avr:51", size
);
2658 case E_AVR_MACH_AVR6
:
2659 strncat (buf
, ", avr:6", size
);
2661 case E_AVR_MACH_AVRTINY
:
2662 strncat (buf
, ", avr:100", size
);
2664 case E_AVR_MACH_XMEGA1
:
2665 strncat (buf
, ", avr:101", size
);
2667 case E_AVR_MACH_XMEGA2
:
2668 strncat (buf
, ", avr:102", size
);
2670 case E_AVR_MACH_XMEGA3
:
2671 strncat (buf
, ", avr:103", size
);
2673 case E_AVR_MACH_XMEGA4
:
2674 strncat (buf
, ", avr:104", size
);
2676 case E_AVR_MACH_XMEGA5
:
2677 strncat (buf
, ", avr:105", size
);
2679 case E_AVR_MACH_XMEGA6
:
2680 strncat (buf
, ", avr:106", size
);
2682 case E_AVR_MACH_XMEGA7
:
2683 strncat (buf
, ", avr:107", size
);
2686 strncat (buf
, ", avr:<unknown>", size
);
2690 size
-= strlen (buf
);
2691 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2692 strncat (buf
, ", link-relax", size
);
2696 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2705 static const char *ABI_STRINGS
[] =
2707 "ABI v0", /* use r5 as return register; only used in N1213HC */
2708 "ABI v1", /* use r0 as return register */
2709 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2710 "ABI v2fp", /* for FPU */
2714 static const char *VER_STRINGS
[] =
2716 "Andes ELF V1.3 or older",
2720 static const char *ARCH_STRINGS
[] =
2729 abi
= EF_NDS_ABI
& e_flags
;
2730 arch
= EF_NDS_ARCH
& e_flags
;
2731 config
= EF_NDS_INST
& e_flags
;
2732 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2734 memset (buf
, 0, size
);
2741 case E_NDS_ABI_V2FP
:
2742 case E_NDS_ABI_AABI
:
2743 case E_NDS_ABI_V2FP_PLUS
:
2744 /* In case there are holes in the array. */
2745 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2749 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2755 case E_NDS32_ELF_VER_1_2
:
2756 case E_NDS32_ELF_VER_1_3
:
2757 case E_NDS32_ELF_VER_1_4
:
2758 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2762 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2766 if (E_NDS_ABI_V0
== abi
)
2768 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2769 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2770 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2771 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2777 case E_NDS_ARCH_STAR_V1_0
:
2778 case E_NDS_ARCH_STAR_V2_0
:
2779 case E_NDS_ARCH_STAR_V3_0
:
2780 case E_NDS_ARCH_STAR_V3_M
:
2781 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2785 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2786 /* ARCH version determines how the e_flags are interpreted.
2787 If it is unknown, we cannot proceed. */
2791 /* Newer ABI; Now handle architecture specific flags. */
2792 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2794 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2795 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2797 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2798 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2800 if (config
& E_NDS32_HAS_DIV_INST
)
2801 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2803 if (config
& E_NDS32_HAS_16BIT_INST
)
2804 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2808 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2810 if (version
<= E_NDS32_ELF_VER_1_3
)
2811 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2813 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2816 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2817 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2819 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2820 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2822 if (config
& E_NDS32_HAS_16BIT_INST
)
2824 if (version
<= E_NDS32_ELF_VER_1_3
)
2825 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2827 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2831 if (config
& E_NDS32_HAS_EXT_INST
)
2832 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2834 if (config
& E_NDS32_HAS_EXT2_INST
)
2835 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2837 if (config
& E_NDS32_HAS_FPU_INST
)
2840 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2843 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2846 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2849 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2852 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2857 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2859 case E_NDS32_FPU_REG_8SP_4DP
:
2860 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2862 case E_NDS32_FPU_REG_16SP_8DP
:
2863 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2865 case E_NDS32_FPU_REG_32SP_16DP
:
2866 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2868 case E_NDS32_FPU_REG_32SP_32DP
:
2869 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2874 if (config
& E_NDS32_HAS_AUDIO_INST
)
2875 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2877 if (config
& E_NDS32_HAS_STRING_INST
)
2878 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2880 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2881 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2883 if (config
& E_NDS32_HAS_VIDEO_INST
)
2885 if (version
<= E_NDS32_ELF_VER_1_3
)
2886 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2888 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2891 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2892 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2894 if (config
& E_NDS32_HAS_L2C_INST
)
2895 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2899 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2901 static char buf
[1024];
2912 case EM_ARC_COMPACT2
:
2913 case EM_ARC_COMPACT
:
2914 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
2918 decode_ARM_machine_flags (e_flags
, buf
);
2922 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2926 if (e_flags
& EF_BFIN_PIC
)
2927 strcat (buf
, ", PIC");
2929 if (e_flags
& EF_BFIN_FDPIC
)
2930 strcat (buf
, ", FDPIC");
2932 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2933 strcat (buf
, ", code in L1");
2935 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2936 strcat (buf
, ", data in L1");
2941 switch (e_flags
& EF_FRV_CPU_MASK
)
2943 case EF_FRV_CPU_GENERIC
:
2947 strcat (buf
, ", fr???");
2950 case EF_FRV_CPU_FR300
:
2951 strcat (buf
, ", fr300");
2954 case EF_FRV_CPU_FR400
:
2955 strcat (buf
, ", fr400");
2957 case EF_FRV_CPU_FR405
:
2958 strcat (buf
, ", fr405");
2961 case EF_FRV_CPU_FR450
:
2962 strcat (buf
, ", fr450");
2965 case EF_FRV_CPU_FR500
:
2966 strcat (buf
, ", fr500");
2968 case EF_FRV_CPU_FR550
:
2969 strcat (buf
, ", fr550");
2972 case EF_FRV_CPU_SIMPLE
:
2973 strcat (buf
, ", simple");
2975 case EF_FRV_CPU_TOMCAT
:
2976 strcat (buf
, ", tomcat");
2982 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2983 strcat (buf
, ", m68000");
2984 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2985 strcat (buf
, ", cpu32");
2986 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2987 strcat (buf
, ", fido_a");
2990 char const * isa
= _("unknown");
2991 char const * mac
= _("unknown mac");
2992 char const * additional
= NULL
;
2994 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2996 case EF_M68K_CF_ISA_A_NODIV
:
2998 additional
= ", nodiv";
3000 case EF_M68K_CF_ISA_A
:
3003 case EF_M68K_CF_ISA_A_PLUS
:
3006 case EF_M68K_CF_ISA_B_NOUSP
:
3008 additional
= ", nousp";
3010 case EF_M68K_CF_ISA_B
:
3013 case EF_M68K_CF_ISA_C
:
3016 case EF_M68K_CF_ISA_C_NODIV
:
3018 additional
= ", nodiv";
3021 strcat (buf
, ", cf, isa ");
3024 strcat (buf
, additional
);
3025 if (e_flags
& EF_M68K_CF_FLOAT
)
3026 strcat (buf
, ", float");
3027 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3032 case EF_M68K_CF_MAC
:
3035 case EF_M68K_CF_EMAC
:
3038 case EF_M68K_CF_EMAC_B
:
3051 switch (e_flags
& EF_MEP_CPU_MASK
)
3053 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3054 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3055 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3056 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3057 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3058 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3059 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3062 switch (e_flags
& EF_MEP_COP_MASK
)
3064 case EF_MEP_COP_NONE
: break;
3065 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3066 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3067 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3068 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3069 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3072 if (e_flags
& EF_MEP_LIBRARY
)
3073 strcat (buf
, ", Built for Library");
3075 if (e_flags
& EF_MEP_INDEX_MASK
)
3076 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3077 e_flags
& EF_MEP_INDEX_MASK
);
3079 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3080 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3081 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3085 if (e_flags
& EF_PPC_EMB
)
3086 strcat (buf
, ", emb");
3088 if (e_flags
& EF_PPC_RELOCATABLE
)
3089 strcat (buf
, _(", relocatable"));
3091 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3092 strcat (buf
, _(", relocatable-lib"));
3096 if (e_flags
& EF_PPC64_ABI
)
3098 char abi
[] = ", abiv0";
3100 abi
[6] += e_flags
& EF_PPC64_ABI
;
3106 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3107 strcat (buf
, ", RH850 ABI");
3109 if (e_flags
& EF_V800_850E3
)
3110 strcat (buf
, ", V3 architecture");
3112 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3113 strcat (buf
, ", FPU not used");
3115 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3116 strcat (buf
, ", regmode: COMMON");
3118 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3119 strcat (buf
, ", r4 not used");
3121 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3122 strcat (buf
, ", r30 not used");
3124 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3125 strcat (buf
, ", r5 not used");
3127 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3128 strcat (buf
, ", r2 not used");
3130 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3132 switch (e_flags
& - e_flags
)
3134 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3135 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3136 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3137 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3138 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3139 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3140 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3141 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3142 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3143 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3144 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3145 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3152 case EM_CYGNUS_V850
:
3153 switch (e_flags
& EF_V850_ARCH
)
3155 case E_V850E3V5_ARCH
:
3156 strcat (buf
, ", v850e3v5");
3158 case E_V850E2V3_ARCH
:
3159 strcat (buf
, ", v850e2v3");
3162 strcat (buf
, ", v850e2");
3165 strcat (buf
, ", v850e1");
3168 strcat (buf
, ", v850e");
3171 strcat (buf
, ", v850");
3174 strcat (buf
, _(", unknown v850 architecture variant"));
3180 case EM_CYGNUS_M32R
:
3181 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3182 strcat (buf
, ", m32r");
3186 case EM_MIPS_RS3_LE
:
3187 if (e_flags
& EF_MIPS_NOREORDER
)
3188 strcat (buf
, ", noreorder");
3190 if (e_flags
& EF_MIPS_PIC
)
3191 strcat (buf
, ", pic");
3193 if (e_flags
& EF_MIPS_CPIC
)
3194 strcat (buf
, ", cpic");
3196 if (e_flags
& EF_MIPS_UCODE
)
3197 strcat (buf
, ", ugen_reserved");
3199 if (e_flags
& EF_MIPS_ABI2
)
3200 strcat (buf
, ", abi2");
3202 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3203 strcat (buf
, ", odk first");
3205 if (e_flags
& EF_MIPS_32BITMODE
)
3206 strcat (buf
, ", 32bitmode");
3208 if (e_flags
& EF_MIPS_NAN2008
)
3209 strcat (buf
, ", nan2008");
3211 if (e_flags
& EF_MIPS_FP64
)
3212 strcat (buf
, ", fp64");
3214 switch ((e_flags
& EF_MIPS_MACH
))
3216 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3217 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3218 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3219 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3220 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3221 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3222 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3223 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3224 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3225 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3226 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3227 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3228 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3229 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3230 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3231 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3232 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3234 /* We simply ignore the field in this case to avoid confusion:
3235 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3238 default: strcat (buf
, _(", unknown CPU")); break;
3241 switch ((e_flags
& EF_MIPS_ABI
))
3243 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3244 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3245 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3246 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3248 /* We simply ignore the field in this case to avoid confusion:
3249 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3250 This means it is likely to be an o32 file, but not for
3253 default: strcat (buf
, _(", unknown ABI")); break;
3256 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3257 strcat (buf
, ", mdmx");
3259 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3260 strcat (buf
, ", mips16");
3262 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3263 strcat (buf
, ", micromips");
3265 switch ((e_flags
& EF_MIPS_ARCH
))
3267 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3268 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3269 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3270 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3271 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3272 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3273 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3274 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3275 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3276 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3277 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3278 default: strcat (buf
, _(", unknown ISA")); break;
3283 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3287 switch ((e_flags
& EF_SH_MACH_MASK
))
3289 case EF_SH1
: strcat (buf
, ", sh1"); break;
3290 case EF_SH2
: strcat (buf
, ", sh2"); break;
3291 case EF_SH3
: strcat (buf
, ", sh3"); break;
3292 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3293 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3294 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3295 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3296 case EF_SH4
: strcat (buf
, ", sh4"); break;
3297 case EF_SH5
: strcat (buf
, ", sh5"); break;
3298 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3299 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3300 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3301 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3302 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3303 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3304 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3305 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3306 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3307 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3308 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3309 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3310 default: strcat (buf
, _(", unknown ISA")); break;
3313 if (e_flags
& EF_SH_PIC
)
3314 strcat (buf
, ", pic");
3316 if (e_flags
& EF_SH_FDPIC
)
3317 strcat (buf
, ", fdpic");
3321 if (e_flags
& EF_OR1K_NODELAY
)
3322 strcat (buf
, ", no delay");
3326 if (e_flags
& EF_SPARC_32PLUS
)
3327 strcat (buf
, ", v8+");
3329 if (e_flags
& EF_SPARC_SUN_US1
)
3330 strcat (buf
, ", ultrasparcI");
3332 if (e_flags
& EF_SPARC_SUN_US3
)
3333 strcat (buf
, ", ultrasparcIII");
3335 if (e_flags
& EF_SPARC_HAL_R1
)
3336 strcat (buf
, ", halr1");
3338 if (e_flags
& EF_SPARC_LEDATA
)
3339 strcat (buf
, ", ledata");
3341 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3342 strcat (buf
, ", tso");
3344 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3345 strcat (buf
, ", pso");
3347 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3348 strcat (buf
, ", rmo");
3352 switch (e_flags
& EF_PARISC_ARCH
)
3354 case EFA_PARISC_1_0
:
3355 strcpy (buf
, ", PA-RISC 1.0");
3357 case EFA_PARISC_1_1
:
3358 strcpy (buf
, ", PA-RISC 1.1");
3360 case EFA_PARISC_2_0
:
3361 strcpy (buf
, ", PA-RISC 2.0");
3366 if (e_flags
& EF_PARISC_TRAPNIL
)
3367 strcat (buf
, ", trapnil");
3368 if (e_flags
& EF_PARISC_EXT
)
3369 strcat (buf
, ", ext");
3370 if (e_flags
& EF_PARISC_LSB
)
3371 strcat (buf
, ", lsb");
3372 if (e_flags
& EF_PARISC_WIDE
)
3373 strcat (buf
, ", wide");
3374 if (e_flags
& EF_PARISC_NO_KABP
)
3375 strcat (buf
, ", no kabp");
3376 if (e_flags
& EF_PARISC_LAZYSWAP
)
3377 strcat (buf
, ", lazyswap");
3382 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3383 strcat (buf
, ", new calling convention");
3385 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3386 strcat (buf
, ", gnu calling convention");
3390 if ((e_flags
& EF_IA_64_ABI64
))
3391 strcat (buf
, ", 64-bit");
3393 strcat (buf
, ", 32-bit");
3394 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3395 strcat (buf
, ", reduced fp model");
3396 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3397 strcat (buf
, ", no function descriptors, constant gp");
3398 else if ((e_flags
& EF_IA_64_CONS_GP
))
3399 strcat (buf
, ", constant gp");
3400 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3401 strcat (buf
, ", absolute");
3402 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3404 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3405 strcat (buf
, ", vms_linkages");
3406 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3408 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3410 case EF_IA_64_VMS_COMCOD_WARNING
:
3411 strcat (buf
, ", warning");
3413 case EF_IA_64_VMS_COMCOD_ERROR
:
3414 strcat (buf
, ", error");
3416 case EF_IA_64_VMS_COMCOD_ABORT
:
3417 strcat (buf
, ", abort");
3420 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3421 e_flags
& EF_IA_64_VMS_COMCOD
);
3422 strcat (buf
, ", <unknown>");
3428 if ((e_flags
& EF_VAX_NONPIC
))
3429 strcat (buf
, ", non-PIC");
3430 if ((e_flags
& EF_VAX_DFLOAT
))
3431 strcat (buf
, ", D-Float");
3432 if ((e_flags
& EF_VAX_GFLOAT
))
3433 strcat (buf
, ", G-Float");
3437 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3438 strcat (buf
, ", mcm");
3439 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3440 strcat (buf
, ", mcm24");
3441 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3442 strcat (buf
, ", gr6");
3446 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3448 case E_FLAG_RL78_ANY_CPU
: break;
3449 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3450 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3451 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3453 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3454 strcat (buf
, ", 64-bit doubles");
3458 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3459 strcat (buf
, ", 64-bit doubles");
3460 if (e_flags
& E_FLAG_RX_DSP
)
3461 strcat (buf
, ", dsp");
3462 if (e_flags
& E_FLAG_RX_PID
)
3463 strcat (buf
, ", pid");
3464 if (e_flags
& E_FLAG_RX_ABI
)
3465 strcat (buf
, ", RX ABI");
3466 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3467 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3468 ? ", uses String instructions" : ", bans String instructions");
3469 if (e_flags
& E_FLAG_RX_V2
)
3470 strcat (buf
, ", V2");
3474 if (e_flags
& EF_S390_HIGH_GPRS
)
3475 strcat (buf
, ", highgprs");
3479 if ((e_flags
& EF_C6000_REL
))
3480 strcat (buf
, ", relocatable module");
3484 strcat (buf
, _(": architecture variant: "));
3485 switch (e_flags
& EF_MSP430_MACH
)
3487 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3488 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3489 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3490 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3491 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3492 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3493 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3494 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3495 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3496 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3497 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3498 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3499 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3500 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3501 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3503 strcat (buf
, _(": unknown")); break;
3506 if (e_flags
& ~ EF_MSP430_MACH
)
3507 strcat (buf
, _(": unknown extra flag bits also present"));
3515 get_osabi_name (unsigned int osabi
)
3517 static char buff
[32];
3521 case ELFOSABI_NONE
: return "UNIX - System V";
3522 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3523 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3524 case ELFOSABI_GNU
: return "UNIX - GNU";
3525 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3526 case ELFOSABI_AIX
: return "UNIX - AIX";
3527 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3528 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3529 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3530 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3531 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3532 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3533 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3534 case ELFOSABI_AROS
: return "AROS";
3535 case ELFOSABI_FENIXOS
: return "FenixOS";
3538 switch (elf_header
.e_machine
)
3543 case ELFOSABI_ARM
: return "ARM";
3554 case ELFOSABI_STANDALONE
: return _("Standalone App");
3563 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3564 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3573 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3579 get_aarch64_segment_type (unsigned long type
)
3583 case PT_AARCH64_ARCHEXT
:
3584 return "AARCH64_ARCHEXT";
3593 get_arm_segment_type (unsigned long type
)
3607 get_mips_segment_type (unsigned long type
)
3611 case PT_MIPS_REGINFO
:
3613 case PT_MIPS_RTPROC
:
3615 case PT_MIPS_OPTIONS
:
3617 case PT_MIPS_ABIFLAGS
:
3627 get_parisc_segment_type (unsigned long type
)
3631 case PT_HP_TLS
: return "HP_TLS";
3632 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3633 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3634 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3635 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3636 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3637 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3638 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3639 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3640 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3641 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3642 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3643 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3644 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3645 case PT_HP_STACK
: return "HP_STACK";
3646 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3647 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3648 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3649 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3658 get_ia64_segment_type (unsigned long type
)
3662 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3663 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3664 case PT_HP_TLS
: return "HP_TLS";
3665 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3666 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3667 case PT_IA_64_HP_STACK
: return "HP_STACK";
3676 get_tic6x_segment_type (unsigned long type
)
3680 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3689 get_solaris_segment_type (unsigned long type
)
3693 case 0x6464e550: return "PT_SUNW_UNWIND";
3694 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3695 case 0x6ffffff7: return "PT_LOSUNW";
3696 case 0x6ffffffa: return "PT_SUNWBSS";
3697 case 0x6ffffffb: return "PT_SUNWSTACK";
3698 case 0x6ffffffc: return "PT_SUNWDTRACE";
3699 case 0x6ffffffd: return "PT_SUNWCAP";
3700 case 0x6fffffff: return "PT_HISUNW";
3701 default: return NULL
;
3706 get_segment_type (unsigned long p_type
)
3708 static char buff
[32];
3712 case PT_NULL
: return "NULL";
3713 case PT_LOAD
: return "LOAD";
3714 case PT_DYNAMIC
: return "DYNAMIC";
3715 case PT_INTERP
: return "INTERP";
3716 case PT_NOTE
: return "NOTE";
3717 case PT_SHLIB
: return "SHLIB";
3718 case PT_PHDR
: return "PHDR";
3719 case PT_TLS
: return "TLS";
3721 case PT_GNU_EH_FRAME
:
3722 return "GNU_EH_FRAME";
3723 case PT_GNU_STACK
: return "GNU_STACK";
3724 case PT_GNU_RELRO
: return "GNU_RELRO";
3727 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3729 const char * result
;
3731 switch (elf_header
.e_machine
)
3734 result
= get_aarch64_segment_type (p_type
);
3737 result
= get_arm_segment_type (p_type
);
3740 case EM_MIPS_RS3_LE
:
3741 result
= get_mips_segment_type (p_type
);
3744 result
= get_parisc_segment_type (p_type
);
3747 result
= get_ia64_segment_type (p_type
);
3750 result
= get_tic6x_segment_type (p_type
);
3760 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3762 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3764 const char * result
;
3766 switch (elf_header
.e_machine
)
3769 result
= get_parisc_segment_type (p_type
);
3772 result
= get_ia64_segment_type (p_type
);
3775 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3776 result
= get_solaris_segment_type (p_type
);
3785 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3788 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3795 get_mips_section_type_name (unsigned int sh_type
)
3799 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3800 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3801 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3802 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3803 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3804 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3805 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3806 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3807 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3808 case SHT_MIPS_RELD
: return "MIPS_RELD";
3809 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3810 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3811 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3812 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3813 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3814 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3815 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3816 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3817 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3818 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3819 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3820 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3821 case SHT_MIPS_LINE
: return "MIPS_LINE";
3822 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3823 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3824 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3825 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3826 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3827 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3828 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3829 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3830 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3831 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3832 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3833 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3834 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3835 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3836 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3837 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3838 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3846 get_parisc_section_type_name (unsigned int sh_type
)
3850 case SHT_PARISC_EXT
: return "PARISC_EXT";
3851 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3852 case SHT_PARISC_DOC
: return "PARISC_DOC";
3853 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3854 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3855 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3856 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3864 get_ia64_section_type_name (unsigned int sh_type
)
3866 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3867 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3868 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3872 case SHT_IA_64_EXT
: return "IA_64_EXT";
3873 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3874 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3875 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3876 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3877 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3878 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3879 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3880 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3881 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3889 get_x86_64_section_type_name (unsigned int sh_type
)
3893 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3901 get_aarch64_section_type_name (unsigned int sh_type
)
3905 case SHT_AARCH64_ATTRIBUTES
:
3906 return "AARCH64_ATTRIBUTES";
3914 get_arm_section_type_name (unsigned int sh_type
)
3918 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3919 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3920 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3921 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3922 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3930 get_tic6x_section_type_name (unsigned int sh_type
)
3934 case SHT_C6000_UNWIND
:
3935 return "C6000_UNWIND";
3936 case SHT_C6000_PREEMPTMAP
:
3937 return "C6000_PREEMPTMAP";
3938 case SHT_C6000_ATTRIBUTES
:
3939 return "C6000_ATTRIBUTES";
3944 case SHT_TI_HANDLER
:
3945 return "TI_HANDLER";
3946 case SHT_TI_INITINFO
:
3947 return "TI_INITINFO";
3948 case SHT_TI_PHATTRS
:
3949 return "TI_PHATTRS";
3957 get_msp430x_section_type_name (unsigned int sh_type
)
3961 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3962 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3963 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3964 default: return NULL
;
3969 get_v850_section_type_name (unsigned int sh_type
)
3973 case SHT_V850_SCOMMON
: return "V850 Small Common";
3974 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3975 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3976 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3977 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3978 default: return NULL
;
3983 get_section_type_name (unsigned int sh_type
)
3985 static char buff
[32];
3986 const char * result
;
3990 case SHT_NULL
: return "NULL";
3991 case SHT_PROGBITS
: return "PROGBITS";
3992 case SHT_SYMTAB
: return "SYMTAB";
3993 case SHT_STRTAB
: return "STRTAB";
3994 case SHT_RELA
: return "RELA";
3995 case SHT_HASH
: return "HASH";
3996 case SHT_DYNAMIC
: return "DYNAMIC";
3997 case SHT_NOTE
: return "NOTE";
3998 case SHT_NOBITS
: return "NOBITS";
3999 case SHT_REL
: return "REL";
4000 case SHT_SHLIB
: return "SHLIB";
4001 case SHT_DYNSYM
: return "DYNSYM";
4002 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4003 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4004 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4005 case SHT_GNU_HASH
: return "GNU_HASH";
4006 case SHT_GROUP
: return "GROUP";
4007 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4008 case SHT_GNU_verdef
: return "VERDEF";
4009 case SHT_GNU_verneed
: return "VERNEED";
4010 case SHT_GNU_versym
: return "VERSYM";
4011 case 0x6ffffff0: return "VERSYM";
4012 case 0x6ffffffc: return "VERDEF";
4013 case 0x7ffffffd: return "AUXILIARY";
4014 case 0x7fffffff: return "FILTER";
4015 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4018 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4020 switch (elf_header
.e_machine
)
4023 case EM_MIPS_RS3_LE
:
4024 result
= get_mips_section_type_name (sh_type
);
4027 result
= get_parisc_section_type_name (sh_type
);
4030 result
= get_ia64_section_type_name (sh_type
);
4035 result
= get_x86_64_section_type_name (sh_type
);
4038 result
= get_aarch64_section_type_name (sh_type
);
4041 result
= get_arm_section_type_name (sh_type
);
4044 result
= get_tic6x_section_type_name (sh_type
);
4047 result
= get_msp430x_section_type_name (sh_type
);
4051 case EM_CYGNUS_V850
:
4052 result
= get_v850_section_type_name (sh_type
);
4062 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4064 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4066 switch (elf_header
.e_machine
)
4069 result
= get_ia64_section_type_name (sh_type
);
4072 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4073 result
= get_solaris_section_type (sh_type
);
4082 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4084 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4086 switch (elf_header
.e_machine
)
4090 case EM_CYGNUS_V850
:
4091 result
= get_v850_section_type_name (sh_type
);
4101 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4104 /* This message is probably going to be displayed in a 15
4105 character wide field, so put the hex value first. */
4106 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4112 #define OPTION_DEBUG_DUMP 512
4113 #define OPTION_DYN_SYMS 513
4114 #define OPTION_DWARF_DEPTH 514
4115 #define OPTION_DWARF_START 515
4116 #define OPTION_DWARF_CHECK 516
4118 static struct option options
[] =
4120 {"all", no_argument
, 0, 'a'},
4121 {"file-header", no_argument
, 0, 'h'},
4122 {"program-headers", no_argument
, 0, 'l'},
4123 {"headers", no_argument
, 0, 'e'},
4124 {"histogram", no_argument
, 0, 'I'},
4125 {"segments", no_argument
, 0, 'l'},
4126 {"sections", no_argument
, 0, 'S'},
4127 {"section-headers", no_argument
, 0, 'S'},
4128 {"section-groups", no_argument
, 0, 'g'},
4129 {"section-details", no_argument
, 0, 't'},
4130 {"full-section-name",no_argument
, 0, 'N'},
4131 {"symbols", no_argument
, 0, 's'},
4132 {"syms", no_argument
, 0, 's'},
4133 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4134 {"relocs", no_argument
, 0, 'r'},
4135 {"notes", no_argument
, 0, 'n'},
4136 {"dynamic", no_argument
, 0, 'd'},
4137 {"arch-specific", no_argument
, 0, 'A'},
4138 {"version-info", no_argument
, 0, 'V'},
4139 {"use-dynamic", no_argument
, 0, 'D'},
4140 {"unwind", no_argument
, 0, 'u'},
4141 {"archive-index", no_argument
, 0, 'c'},
4142 {"hex-dump", required_argument
, 0, 'x'},
4143 {"relocated-dump", required_argument
, 0, 'R'},
4144 {"string-dump", required_argument
, 0, 'p'},
4145 {"decompress", no_argument
, 0, 'z'},
4146 #ifdef SUPPORT_DISASSEMBLY
4147 {"instruction-dump", required_argument
, 0, 'i'},
4149 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4151 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4152 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4153 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4155 {"version", no_argument
, 0, 'v'},
4156 {"wide", no_argument
, 0, 'W'},
4157 {"help", no_argument
, 0, 'H'},
4158 {0, no_argument
, 0, 0}
4162 usage (FILE * stream
)
4164 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4165 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4166 fprintf (stream
, _(" Options are:\n\
4167 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4168 -h --file-header Display the ELF file header\n\
4169 -l --program-headers Display the program headers\n\
4170 --segments An alias for --program-headers\n\
4171 -S --section-headers Display the sections' header\n\
4172 --sections An alias for --section-headers\n\
4173 -g --section-groups Display the section groups\n\
4174 -t --section-details Display the section details\n\
4175 -e --headers Equivalent to: -h -l -S\n\
4176 -s --syms Display the symbol table\n\
4177 --symbols An alias for --syms\n\
4178 --dyn-syms Display the dynamic symbol table\n\
4179 -n --notes Display the core notes (if present)\n\
4180 -r --relocs Display the relocations (if present)\n\
4181 -u --unwind Display the unwind info (if present)\n\
4182 -d --dynamic Display the dynamic section (if present)\n\
4183 -V --version-info Display the version sections (if present)\n\
4184 -A --arch-specific Display architecture specific information (if any)\n\
4185 -c --archive-index Display the symbol/file index in an archive\n\
4186 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4187 -x --hex-dump=<number|name>\n\
4188 Dump the contents of section <number|name> as bytes\n\
4189 -p --string-dump=<number|name>\n\
4190 Dump the contents of section <number|name> as strings\n\
4191 -R --relocated-dump=<number|name>\n\
4192 Dump the contents of section <number|name> as relocated bytes\n\
4193 -z --decompress Decompress section before dumping it\n\
4194 -w[lLiaprmfFsoRt] or\n\
4195 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4196 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4197 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4199 Display the contents of DWARF2 debug sections\n"));
4200 fprintf (stream
, _("\
4201 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4202 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4204 #ifdef SUPPORT_DISASSEMBLY
4205 fprintf (stream
, _("\
4206 -i --instruction-dump=<number|name>\n\
4207 Disassemble the contents of section <number|name>\n"));
4209 fprintf (stream
, _("\
4210 -I --histogram Display histogram of bucket list lengths\n\
4211 -W --wide Allow output width to exceed 80 characters\n\
4212 @<file> Read options from <file>\n\
4213 -H --help Display this information\n\
4214 -v --version Display the version number of readelf\n"));
4216 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4217 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4219 exit (stream
== stdout
? 0 : 1);
4222 /* Record the fact that the user wants the contents of section number
4223 SECTION to be displayed using the method(s) encoded as flags bits
4224 in TYPE. Note, TYPE can be zero if we are creating the array for
4228 request_dump_bynumber (unsigned int section
, dump_type type
)
4230 if (section
>= num_dump_sects
)
4232 dump_type
* new_dump_sects
;
4234 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4235 sizeof (* dump_sects
));
4237 if (new_dump_sects
== NULL
)
4238 error (_("Out of memory allocating dump request table.\n"));
4241 /* Copy current flag settings. */
4242 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4246 dump_sects
= new_dump_sects
;
4247 num_dump_sects
= section
+ 1;
4252 dump_sects
[section
] |= type
;
4257 /* Request a dump by section name. */
4260 request_dump_byname (const char * section
, dump_type type
)
4262 struct dump_list_entry
* new_request
;
4264 new_request
= (struct dump_list_entry
*)
4265 malloc (sizeof (struct dump_list_entry
));
4267 error (_("Out of memory allocating dump request table.\n"));
4269 new_request
->name
= strdup (section
);
4270 if (!new_request
->name
)
4271 error (_("Out of memory allocating dump request table.\n"));
4273 new_request
->type
= type
;
4275 new_request
->next
= dump_sects_byname
;
4276 dump_sects_byname
= new_request
;
4280 request_dump (dump_type type
)
4286 section
= strtoul (optarg
, & cp
, 0);
4288 if (! *cp
&& section
>= 0)
4289 request_dump_bynumber (section
, type
);
4291 request_dump_byname (optarg
, type
);
4296 parse_args (int argc
, char ** argv
)
4303 while ((c
= getopt_long
4304 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4322 do_section_groups
++;
4330 do_section_groups
++;
4335 do_section_details
++;
4379 request_dump (HEX_DUMP
);
4382 request_dump (STRING_DUMP
);
4385 request_dump (RELOC_DUMP
);
4395 dwarf_select_sections_all ();
4400 dwarf_select_sections_by_letters (optarg
);
4403 case OPTION_DEBUG_DUMP
:
4410 dwarf_select_sections_by_names (optarg
);
4413 case OPTION_DWARF_DEPTH
:
4417 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4420 case OPTION_DWARF_START
:
4424 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4427 case OPTION_DWARF_CHECK
:
4430 case OPTION_DYN_SYMS
:
4433 #ifdef SUPPORT_DISASSEMBLY
4435 request_dump (DISASS_DUMP
);
4439 print_version (program_name
);
4448 /* xgettext:c-format */
4449 error (_("Invalid option '-%c'\n"), c
);
4456 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4457 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4458 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4459 && !do_section_groups
&& !do_archive_index
4465 get_elf_class (unsigned int elf_class
)
4467 static char buff
[32];
4471 case ELFCLASSNONE
: return _("none");
4472 case ELFCLASS32
: return "ELF32";
4473 case ELFCLASS64
: return "ELF64";
4475 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4481 get_data_encoding (unsigned int encoding
)
4483 static char buff
[32];
4487 case ELFDATANONE
: return _("none");
4488 case ELFDATA2LSB
: return _("2's complement, little endian");
4489 case ELFDATA2MSB
: return _("2's complement, big endian");
4491 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4496 /* Decode the data held in 'elf_header'. */
4499 process_file_header (void)
4501 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4502 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4503 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4504 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4507 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4511 init_dwarf_regnames (elf_header
.e_machine
);
4517 printf (_("ELF Header:\n"));
4518 printf (_(" Magic: "));
4519 for (i
= 0; i
< EI_NIDENT
; i
++)
4520 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4522 printf (_(" Class: %s\n"),
4523 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4524 printf (_(" Data: %s\n"),
4525 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4526 printf (_(" Version: %d %s\n"),
4527 elf_header
.e_ident
[EI_VERSION
],
4528 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4530 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4531 ? _("<unknown: %lx>")
4533 printf (_(" OS/ABI: %s\n"),
4534 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4535 printf (_(" ABI Version: %d\n"),
4536 elf_header
.e_ident
[EI_ABIVERSION
]);
4537 printf (_(" Type: %s\n"),
4538 get_file_type (elf_header
.e_type
));
4539 printf (_(" Machine: %s\n"),
4540 get_machine_name (elf_header
.e_machine
));
4541 printf (_(" Version: 0x%lx\n"),
4542 (unsigned long) elf_header
.e_version
);
4544 printf (_(" Entry point address: "));
4545 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4546 printf (_("\n Start of program headers: "));
4547 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4548 printf (_(" (bytes into file)\n Start of section headers: "));
4549 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4550 printf (_(" (bytes into file)\n"));
4552 printf (_(" Flags: 0x%lx%s\n"),
4553 (unsigned long) elf_header
.e_flags
,
4554 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4555 printf (_(" Size of this header: %ld (bytes)\n"),
4556 (long) elf_header
.e_ehsize
);
4557 printf (_(" Size of program headers: %ld (bytes)\n"),
4558 (long) elf_header
.e_phentsize
);
4559 printf (_(" Number of program headers: %ld"),
4560 (long) elf_header
.e_phnum
);
4561 if (section_headers
!= NULL
4562 && elf_header
.e_phnum
== PN_XNUM
4563 && section_headers
[0].sh_info
!= 0)
4564 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4565 putc ('\n', stdout
);
4566 printf (_(" Size of section headers: %ld (bytes)\n"),
4567 (long) elf_header
.e_shentsize
);
4568 printf (_(" Number of section headers: %ld"),
4569 (long) elf_header
.e_shnum
);
4570 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4571 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4572 putc ('\n', stdout
);
4573 printf (_(" Section header string table index: %ld"),
4574 (long) elf_header
.e_shstrndx
);
4575 if (section_headers
!= NULL
4576 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4577 printf (" (%u)", section_headers
[0].sh_link
);
4578 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4579 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4580 printf (_(" <corrupt: out of range>"));
4581 putc ('\n', stdout
);
4584 if (section_headers
!= NULL
)
4586 if (elf_header
.e_phnum
== PN_XNUM
4587 && section_headers
[0].sh_info
!= 0)
4588 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4589 if (elf_header
.e_shnum
== SHN_UNDEF
)
4590 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4591 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4592 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4593 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4594 elf_header
.e_shstrndx
= SHN_UNDEF
;
4595 free (section_headers
);
4596 section_headers
= NULL
;
4603 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4605 Elf32_External_Phdr
* phdrs
;
4606 Elf32_External_Phdr
* external
;
4607 Elf_Internal_Phdr
* internal
;
4609 unsigned int size
= elf_header
.e_phentsize
;
4610 unsigned int num
= elf_header
.e_phnum
;
4612 /* PR binutils/17531: Cope with unexpected section header sizes. */
4613 if (size
== 0 || num
== 0)
4615 if (size
< sizeof * phdrs
)
4617 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4620 if (size
> sizeof * phdrs
)
4621 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4623 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4624 size
, num
, _("program headers"));
4628 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4629 i
< elf_header
.e_phnum
;
4630 i
++, internal
++, external
++)
4632 internal
->p_type
= BYTE_GET (external
->p_type
);
4633 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4634 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4635 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4636 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4637 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4638 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4639 internal
->p_align
= BYTE_GET (external
->p_align
);
4647 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4649 Elf64_External_Phdr
* phdrs
;
4650 Elf64_External_Phdr
* external
;
4651 Elf_Internal_Phdr
* internal
;
4653 unsigned int size
= elf_header
.e_phentsize
;
4654 unsigned int num
= elf_header
.e_phnum
;
4656 /* PR binutils/17531: Cope with unexpected section header sizes. */
4657 if (size
== 0 || num
== 0)
4659 if (size
< sizeof * phdrs
)
4661 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4664 if (size
> sizeof * phdrs
)
4665 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4667 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4668 size
, num
, _("program headers"));
4672 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4673 i
< elf_header
.e_phnum
;
4674 i
++, internal
++, external
++)
4676 internal
->p_type
= BYTE_GET (external
->p_type
);
4677 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4678 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4679 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4680 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4681 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4682 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4683 internal
->p_align
= BYTE_GET (external
->p_align
);
4690 /* Returns 1 if the program headers were read into `program_headers'. */
4693 get_program_headers (FILE * file
)
4695 Elf_Internal_Phdr
* phdrs
;
4697 /* Check cache of prior read. */
4698 if (program_headers
!= NULL
)
4701 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4702 sizeof (Elf_Internal_Phdr
));
4706 error (_("Out of memory reading %u program headers\n"),
4707 elf_header
.e_phnum
);
4712 ? get_32bit_program_headers (file
, phdrs
)
4713 : get_64bit_program_headers (file
, phdrs
))
4715 program_headers
= phdrs
;
4723 /* Returns 1 if the program headers were loaded. */
4726 process_program_headers (FILE * file
)
4728 Elf_Internal_Phdr
* segment
;
4731 if (elf_header
.e_phnum
== 0)
4733 /* PR binutils/12467. */
4734 if (elf_header
.e_phoff
!= 0)
4735 warn (_("possibly corrupt ELF header - it has a non-zero program"
4736 " header offset, but no program headers\n"));
4737 else if (do_segments
)
4738 printf (_("\nThere are no program headers in this file.\n"));
4742 if (do_segments
&& !do_header
)
4744 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4745 printf (_("Entry point "));
4746 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4747 printf (_("\nThere are %d program headers, starting at offset "),
4748 elf_header
.e_phnum
);
4749 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4753 if (! get_program_headers (file
))
4758 if (elf_header
.e_phnum
> 1)
4759 printf (_("\nProgram Headers:\n"));
4761 printf (_("\nProgram Headers:\n"));
4765 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4768 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4772 (_(" Type Offset VirtAddr PhysAddr\n"));
4774 (_(" FileSiz MemSiz Flags Align\n"));
4781 for (i
= 0, segment
= program_headers
;
4782 i
< elf_header
.e_phnum
;
4787 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4791 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4792 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4793 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4794 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4795 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4797 (segment
->p_flags
& PF_R
? 'R' : ' '),
4798 (segment
->p_flags
& PF_W
? 'W' : ' '),
4799 (segment
->p_flags
& PF_X
? 'E' : ' '));
4800 printf ("%#lx", (unsigned long) segment
->p_align
);
4804 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4805 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4808 print_vma (segment
->p_offset
, FULL_HEX
);
4812 print_vma (segment
->p_vaddr
, FULL_HEX
);
4814 print_vma (segment
->p_paddr
, FULL_HEX
);
4817 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4818 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4821 print_vma (segment
->p_filesz
, FULL_HEX
);
4825 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4826 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4829 print_vma (segment
->p_memsz
, FULL_HEX
);
4833 (segment
->p_flags
& PF_R
? 'R' : ' '),
4834 (segment
->p_flags
& PF_W
? 'W' : ' '),
4835 (segment
->p_flags
& PF_X
? 'E' : ' '));
4837 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4838 printf ("%#lx", (unsigned long) segment
->p_align
);
4841 print_vma (segment
->p_align
, PREFIX_HEX
);
4846 print_vma (segment
->p_offset
, FULL_HEX
);
4848 print_vma (segment
->p_vaddr
, FULL_HEX
);
4850 print_vma (segment
->p_paddr
, FULL_HEX
);
4852 print_vma (segment
->p_filesz
, FULL_HEX
);
4854 print_vma (segment
->p_memsz
, FULL_HEX
);
4856 (segment
->p_flags
& PF_R
? 'R' : ' '),
4857 (segment
->p_flags
& PF_W
? 'W' : ' '),
4858 (segment
->p_flags
& PF_X
? 'E' : ' '));
4859 print_vma (segment
->p_align
, HEX
);
4864 putc ('\n', stdout
);
4866 switch (segment
->p_type
)
4870 error (_("more than one dynamic segment\n"));
4872 /* By default, assume that the .dynamic section is the first
4873 section in the DYNAMIC segment. */
4874 dynamic_addr
= segment
->p_offset
;
4875 dynamic_size
= segment
->p_filesz
;
4876 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4877 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4879 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4880 dynamic_addr
= dynamic_size
= 0;
4883 /* Try to locate the .dynamic section. If there is
4884 a section header table, we can easily locate it. */
4885 if (section_headers
!= NULL
)
4887 Elf_Internal_Shdr
* sec
;
4889 sec
= find_section (".dynamic");
4890 if (sec
== NULL
|| sec
->sh_size
== 0)
4892 /* A corresponding .dynamic section is expected, but on
4893 IA-64/OpenVMS it is OK for it to be missing. */
4894 if (!is_ia64_vms ())
4895 error (_("no .dynamic section in the dynamic segment\n"));
4899 if (sec
->sh_type
== SHT_NOBITS
)
4905 dynamic_addr
= sec
->sh_offset
;
4906 dynamic_size
= sec
->sh_size
;
4908 if (dynamic_addr
< segment
->p_offset
4909 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4910 warn (_("the .dynamic section is not contained"
4911 " within the dynamic segment\n"));
4912 else if (dynamic_addr
> segment
->p_offset
)
4913 warn (_("the .dynamic section is not the first section"
4914 " in the dynamic segment.\n"));
4919 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4921 error (_("Unable to find program interpreter name\n"));
4925 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4927 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4928 error (_("Internal error: failed to create format string to display program interpreter\n"));
4930 program_interpreter
[0] = 0;
4931 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4932 error (_("Unable to read program interpreter name\n"));
4935 printf (_(" [Requesting program interpreter: %s]\n"),
4936 program_interpreter
);
4942 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4944 printf (_("\n Section to Segment mapping:\n"));
4945 printf (_(" Segment Sections...\n"));
4947 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4950 Elf_Internal_Shdr
* section
;
4952 segment
= program_headers
+ i
;
4953 section
= section_headers
+ 1;
4955 printf (" %2.2d ", i
);
4957 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4959 if (!ELF_TBSS_SPECIAL (section
, segment
)
4960 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4961 printf ("%s ", printable_section_name (section
));
4972 /* Find the file offset corresponding to VMA by using the program headers. */
4975 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4977 Elf_Internal_Phdr
* seg
;
4979 if (! get_program_headers (file
))
4981 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4985 for (seg
= program_headers
;
4986 seg
< program_headers
+ elf_header
.e_phnum
;
4989 if (seg
->p_type
!= PT_LOAD
)
4992 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4993 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4994 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4997 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4998 (unsigned long) vma
);
5003 /* Allocate memory and load the sections headers into the global pointer
5004 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5005 generate any error messages if the load fails. */
5008 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5010 Elf32_External_Shdr
* shdrs
;
5011 Elf_Internal_Shdr
* internal
;
5013 unsigned int size
= elf_header
.e_shentsize
;
5014 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5016 /* PR binutils/17531: Cope with unexpected section header sizes. */
5017 if (size
== 0 || num
== 0)
5019 if (size
< sizeof * shdrs
)
5022 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5025 if (!probe
&& size
> sizeof * shdrs
)
5026 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5028 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5030 probe
? NULL
: _("section headers"));
5034 if (section_headers
!= NULL
)
5035 free (section_headers
);
5036 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5037 sizeof (Elf_Internal_Shdr
));
5038 if (section_headers
== NULL
)
5041 error (_("Out of memory reading %u section headers\n"), num
);
5045 for (i
= 0, internal
= section_headers
;
5049 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5050 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5051 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5052 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5053 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5054 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5055 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5056 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5057 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5058 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5059 if (!probe
&& internal
->sh_link
> num
)
5060 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5061 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5062 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5070 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5072 Elf64_External_Shdr
* shdrs
;
5073 Elf_Internal_Shdr
* internal
;
5075 unsigned int size
= elf_header
.e_shentsize
;
5076 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5078 /* PR binutils/17531: Cope with unexpected section header sizes. */
5079 if (size
== 0 || num
== 0)
5081 if (size
< sizeof * shdrs
)
5084 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5087 if (! probe
&& size
> sizeof * shdrs
)
5088 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5090 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5092 probe
? NULL
: _("section headers"));
5096 if (section_headers
!= NULL
)
5097 free (section_headers
);
5098 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5099 sizeof (Elf_Internal_Shdr
));
5100 if (section_headers
== NULL
)
5103 error (_("Out of memory reading %u section headers\n"), num
);
5107 for (i
= 0, internal
= section_headers
;
5111 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5112 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5113 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5114 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5115 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5116 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5117 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5118 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5119 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5120 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5121 if (!probe
&& internal
->sh_link
> num
)
5122 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5123 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5124 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5131 static Elf_Internal_Sym
*
5132 get_32bit_elf_symbols (FILE * file
,
5133 Elf_Internal_Shdr
* section
,
5134 unsigned long * num_syms_return
)
5136 unsigned long number
= 0;
5137 Elf32_External_Sym
* esyms
= NULL
;
5138 Elf_External_Sym_Shndx
* shndx
= NULL
;
5139 Elf_Internal_Sym
* isyms
= NULL
;
5140 Elf_Internal_Sym
* psym
;
5143 if (section
->sh_size
== 0)
5145 if (num_syms_return
!= NULL
)
5146 * num_syms_return
= 0;
5150 /* Run some sanity checks first. */
5151 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5153 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5154 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5158 if (section
->sh_size
> current_file_size
)
5160 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5161 printable_section_name (section
), (unsigned long) section
->sh_size
);
5165 number
= section
->sh_size
/ section
->sh_entsize
;
5167 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5169 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5170 (unsigned long) section
->sh_size
,
5171 printable_section_name (section
),
5172 (unsigned long) section
->sh_entsize
);
5176 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5177 section
->sh_size
, _("symbols"));
5182 elf_section_list
* entry
;
5185 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5186 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5188 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5189 entry
->hdr
->sh_offset
,
5190 1, entry
->hdr
->sh_size
,
5191 _("symbol table section indicies"));
5194 /* PR17531: file: heap-buffer-overflow */
5195 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5197 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5198 printable_section_name (entry
->hdr
),
5199 (unsigned long) entry
->hdr
->sh_size
,
5200 (unsigned long) section
->sh_size
);
5206 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5210 error (_("Out of memory reading %lu symbols\n"),
5211 (unsigned long) number
);
5215 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5217 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5218 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5219 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5220 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5221 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5223 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5224 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5225 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5226 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5227 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5236 if (num_syms_return
!= NULL
)
5237 * num_syms_return
= isyms
== NULL
? 0 : number
;
5242 static Elf_Internal_Sym
*
5243 get_64bit_elf_symbols (FILE * file
,
5244 Elf_Internal_Shdr
* section
,
5245 unsigned long * num_syms_return
)
5247 unsigned long number
= 0;
5248 Elf64_External_Sym
* esyms
= NULL
;
5249 Elf_External_Sym_Shndx
* shndx
= NULL
;
5250 Elf_Internal_Sym
* isyms
= NULL
;
5251 Elf_Internal_Sym
* psym
;
5254 if (section
->sh_size
== 0)
5256 if (num_syms_return
!= NULL
)
5257 * num_syms_return
= 0;
5261 /* Run some sanity checks first. */
5262 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5264 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5265 printable_section_name (section
),
5266 (unsigned long) section
->sh_entsize
);
5270 if (section
->sh_size
> current_file_size
)
5272 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5273 printable_section_name (section
),
5274 (unsigned long) section
->sh_size
);
5278 number
= section
->sh_size
/ section
->sh_entsize
;
5280 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5282 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5283 (unsigned long) section
->sh_size
,
5284 printable_section_name (section
),
5285 (unsigned long) section
->sh_entsize
);
5289 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5290 section
->sh_size
, _("symbols"));
5295 elf_section_list
* entry
;
5298 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5299 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5301 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5302 entry
->hdr
->sh_offset
,
5303 1, entry
->hdr
->sh_size
,
5304 _("symbol table section indicies"));
5307 /* PR17531: file: heap-buffer-overflow */
5308 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5310 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5311 printable_section_name (entry
->hdr
),
5312 (unsigned long) entry
->hdr
->sh_size
,
5313 (unsigned long) section
->sh_size
);
5319 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5323 error (_("Out of memory reading %lu symbols\n"),
5324 (unsigned long) number
);
5328 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5330 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5331 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5332 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5333 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5335 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5337 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5338 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5339 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5341 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5342 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5351 if (num_syms_return
!= NULL
)
5352 * num_syms_return
= isyms
== NULL
? 0 : number
;
5358 get_elf_section_flags (bfd_vma sh_flags
)
5360 static char buff
[1024];
5362 int field_size
= is_32bit_elf
? 8 : 16;
5364 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5365 bfd_vma os_flags
= 0;
5366 bfd_vma proc_flags
= 0;
5367 bfd_vma unknown_flags
= 0;
5375 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5376 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5377 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5378 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5379 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5380 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5381 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5382 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5383 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5384 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5385 /* IA-64 specific. */
5386 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5387 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5388 /* IA-64 OpenVMS specific. */
5389 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5390 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5391 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5392 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5393 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5394 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5396 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5397 /* SPARC specific. */
5398 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5399 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5401 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5402 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5403 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5406 if (do_section_details
)
5408 sprintf (buff
, "[%*.*lx]: ",
5409 field_size
, field_size
, (unsigned long) sh_flags
);
5410 p
+= field_size
+ 4;
5417 flag
= sh_flags
& - sh_flags
;
5420 if (do_section_details
)
5424 case SHF_WRITE
: sindex
= 0; break;
5425 case SHF_ALLOC
: sindex
= 1; break;
5426 case SHF_EXECINSTR
: sindex
= 2; break;
5427 case SHF_MERGE
: sindex
= 3; break;
5428 case SHF_STRINGS
: sindex
= 4; break;
5429 case SHF_INFO_LINK
: sindex
= 5; break;
5430 case SHF_LINK_ORDER
: sindex
= 6; break;
5431 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5432 case SHF_GROUP
: sindex
= 8; break;
5433 case SHF_TLS
: sindex
= 9; break;
5434 case SHF_EXCLUDE
: sindex
= 18; break;
5435 case SHF_COMPRESSED
: sindex
= 20; break;
5439 switch (elf_header
.e_machine
)
5442 if (flag
== SHF_IA_64_SHORT
)
5444 else if (flag
== SHF_IA_64_NORECOV
)
5447 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5450 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5451 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5452 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5453 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5454 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5455 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5466 case EM_OLD_SPARCV9
:
5467 case EM_SPARC32PLUS
:
5470 if (flag
== SHF_ORDERED
)
5477 case SHF_ENTRYSECT
: sindex
= 21; break;
5478 case SHF_ARM_PURECODE
: sindex
= 22; break;
5479 case SHF_COMDEF
: sindex
= 23; break;
5491 if (p
!= buff
+ field_size
+ 4)
5493 if (size
< (10 + 2))
5495 warn (_("Internal error: not enough buffer room for section flag info"));
5496 return _("<unknown>");
5503 size
-= flags
[sindex
].len
;
5504 p
= stpcpy (p
, flags
[sindex
].str
);
5506 else if (flag
& SHF_MASKOS
)
5508 else if (flag
& SHF_MASKPROC
)
5511 unknown_flags
|= flag
;
5517 case SHF_WRITE
: *p
= 'W'; break;
5518 case SHF_ALLOC
: *p
= 'A'; break;
5519 case SHF_EXECINSTR
: *p
= 'X'; break;
5520 case SHF_MERGE
: *p
= 'M'; break;
5521 case SHF_STRINGS
: *p
= 'S'; break;
5522 case SHF_INFO_LINK
: *p
= 'I'; break;
5523 case SHF_LINK_ORDER
: *p
= 'L'; break;
5524 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5525 case SHF_GROUP
: *p
= 'G'; break;
5526 case SHF_TLS
: *p
= 'T'; break;
5527 case SHF_EXCLUDE
: *p
= 'E'; break;
5528 case SHF_COMPRESSED
: *p
= 'C'; break;
5531 if ((elf_header
.e_machine
== EM_X86_64
5532 || elf_header
.e_machine
== EM_L1OM
5533 || elf_header
.e_machine
== EM_K1OM
)
5534 && flag
== SHF_X86_64_LARGE
)
5536 else if (elf_header
.e_machine
== EM_ARM
5537 && flag
== SHF_ARM_PURECODE
)
5539 else if (flag
& SHF_MASKOS
)
5542 sh_flags
&= ~ SHF_MASKOS
;
5544 else if (flag
& SHF_MASKPROC
)
5547 sh_flags
&= ~ SHF_MASKPROC
;
5557 if (do_section_details
)
5561 size
-= 5 + field_size
;
5562 if (p
!= buff
+ field_size
+ 4)
5566 warn (_("Internal error: not enough buffer room for section flag info"));
5567 return _("<unknown>");
5573 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5574 (unsigned long) os_flags
);
5575 p
+= 5 + field_size
;
5579 size
-= 7 + field_size
;
5580 if (p
!= buff
+ field_size
+ 4)
5584 warn (_("Internal error: not enough buffer room for section flag info"));
5585 return _("<unknown>");
5591 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5592 (unsigned long) proc_flags
);
5593 p
+= 7 + field_size
;
5597 size
-= 10 + field_size
;
5598 if (p
!= buff
+ field_size
+ 4)
5602 warn (_("Internal error: not enough buffer room for section flag info"));
5603 return _("<unknown>");
5609 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5610 (unsigned long) unknown_flags
);
5611 p
+= 10 + field_size
;
5620 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5624 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5626 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5627 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5628 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5629 return sizeof (*echdr
);
5633 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5635 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5636 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5637 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5638 return sizeof (*echdr
);
5643 process_section_headers (FILE * file
)
5645 Elf_Internal_Shdr
* section
;
5648 section_headers
= NULL
;
5650 if (elf_header
.e_shnum
== 0)
5652 /* PR binutils/12467. */
5653 if (elf_header
.e_shoff
!= 0)
5654 warn (_("possibly corrupt ELF file header - it has a non-zero"
5655 " section header offset, but no section headers\n"));
5656 else if (do_sections
)
5657 printf (_("\nThere are no sections in this file.\n"));
5662 if (do_sections
&& !do_header
)
5663 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5664 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5668 if (! get_32bit_section_headers (file
, FALSE
))
5671 else if (! get_64bit_section_headers (file
, FALSE
))
5674 /* Read in the string table, so that we have names to display. */
5675 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5676 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5678 section
= section_headers
+ elf_header
.e_shstrndx
;
5680 if (section
->sh_size
!= 0)
5682 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5683 1, section
->sh_size
,
5686 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5690 /* Scan the sections for the dynamic symbol table
5691 and dynamic string table and debug sections. */
5692 dynamic_symbols
= NULL
;
5693 dynamic_strings
= NULL
;
5694 dynamic_syminfo
= NULL
;
5695 symtab_shndx_list
= NULL
;
5697 eh_addr_size
= is_32bit_elf
? 4 : 8;
5698 switch (elf_header
.e_machine
)
5701 case EM_MIPS_RS3_LE
:
5702 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5703 FDE addresses. However, the ABI also has a semi-official ILP32
5704 variant for which the normal FDE address size rules apply.
5706 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5707 section, where XX is the size of longs in bits. Unfortunately,
5708 earlier compilers provided no way of distinguishing ILP32 objects
5709 from LP64 objects, so if there's any doubt, we should assume that
5710 the official LP64 form is being used. */
5711 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5712 && find_section (".gcc_compiled_long32") == NULL
)
5718 switch (elf_header
.e_flags
& EF_H8_MACH
)
5720 case E_H8_MACH_H8300
:
5721 case E_H8_MACH_H8300HN
:
5722 case E_H8_MACH_H8300SN
:
5723 case E_H8_MACH_H8300SXN
:
5726 case E_H8_MACH_H8300H
:
5727 case E_H8_MACH_H8300S
:
5728 case E_H8_MACH_H8300SX
:
5736 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5738 case EF_M32C_CPU_M16C
:
5745 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5748 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5749 if (section->sh_entsize != expected_entsize) \
5752 sprintf_vma (buf, section->sh_entsize); \
5753 /* Note: coded this way so that there is a single string for \
5755 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5756 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5757 (unsigned) expected_entsize); \
5758 section->sh_entsize = expected_entsize; \
5763 #define CHECK_ENTSIZE(section, i, type) \
5764 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5765 sizeof (Elf64_External_##type))
5767 for (i
= 0, section
= section_headers
;
5768 i
< elf_header
.e_shnum
;
5771 char * name
= SECTION_NAME (section
);
5773 if (section
->sh_type
== SHT_DYNSYM
)
5775 if (dynamic_symbols
!= NULL
)
5777 error (_("File contains multiple dynamic symbol tables\n"));
5781 CHECK_ENTSIZE (section
, i
, Sym
);
5782 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5784 else if (section
->sh_type
== SHT_STRTAB
5785 && streq (name
, ".dynstr"))
5787 if (dynamic_strings
!= NULL
)
5789 error (_("File contains multiple dynamic string tables\n"));
5793 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5794 1, section
->sh_size
,
5795 _("dynamic strings"));
5796 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5798 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5800 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5801 entry
->hdr
= section
;
5802 entry
->next
= symtab_shndx_list
;
5803 symtab_shndx_list
= entry
;
5805 else if (section
->sh_type
== SHT_SYMTAB
)
5806 CHECK_ENTSIZE (section
, i
, Sym
);
5807 else if (section
->sh_type
== SHT_GROUP
)
5808 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5809 else if (section
->sh_type
== SHT_REL
)
5810 CHECK_ENTSIZE (section
, i
, Rel
);
5811 else if (section
->sh_type
== SHT_RELA
)
5812 CHECK_ENTSIZE (section
, i
, Rela
);
5813 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5814 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5815 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5816 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5817 || do_debug_addr
|| do_debug_cu_index
)
5818 && (const_strneq (name
, ".debug_")
5819 || const_strneq (name
, ".zdebug_")))
5822 name
+= sizeof (".zdebug_") - 1;
5824 name
+= sizeof (".debug_") - 1;
5827 || (do_debug_info
&& const_strneq (name
, "info"))
5828 || (do_debug_info
&& const_strneq (name
, "types"))
5829 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5830 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5831 || (do_debug_lines
&& const_strneq (name
, "line."))
5832 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5833 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5834 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5835 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5836 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5837 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5838 || (do_debug_frames
&& const_strneq (name
, "frame"))
5839 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5840 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5841 || (do_debug_str
&& const_strneq (name
, "str"))
5842 || (do_debug_loc
&& const_strneq (name
, "loc"))
5843 || (do_debug_addr
&& const_strneq (name
, "addr"))
5844 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5845 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5847 request_dump_bynumber (i
, DEBUG_DUMP
);
5849 /* Linkonce section to be combined with .debug_info at link time. */
5850 else if ((do_debugging
|| do_debug_info
)
5851 && const_strneq (name
, ".gnu.linkonce.wi."))
5852 request_dump_bynumber (i
, DEBUG_DUMP
);
5853 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5854 request_dump_bynumber (i
, DEBUG_DUMP
);
5855 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5856 request_dump_bynumber (i
, DEBUG_DUMP
);
5857 /* Trace sections for Itanium VMS. */
5858 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5859 || do_trace_aranges
)
5860 && const_strneq (name
, ".trace_"))
5862 name
+= sizeof (".trace_") - 1;
5865 || (do_trace_info
&& streq (name
, "info"))
5866 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5867 || (do_trace_aranges
&& streq (name
, "aranges"))
5869 request_dump_bynumber (i
, DEBUG_DUMP
);
5876 if (elf_header
.e_shnum
> 1)
5877 printf (_("\nSection Headers:\n"));
5879 printf (_("\nSection Header:\n"));
5883 if (do_section_details
)
5885 printf (_(" [Nr] Name\n"));
5886 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5890 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5894 if (do_section_details
)
5896 printf (_(" [Nr] Name\n"));
5897 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5901 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5905 if (do_section_details
)
5907 printf (_(" [Nr] Name\n"));
5908 printf (_(" Type Address Offset Link\n"));
5909 printf (_(" Size EntSize Info Align\n"));
5913 printf (_(" [Nr] Name Type Address Offset\n"));
5914 printf (_(" Size EntSize Flags Link Info Align\n"));
5918 if (do_section_details
)
5919 printf (_(" Flags\n"));
5921 for (i
= 0, section
= section_headers
;
5922 i
< elf_header
.e_shnum
;
5925 printf (" [%2u] ", i
);
5926 if (do_section_details
)
5927 printf ("%s\n ", printable_section_name (section
));
5929 print_symbol (-17, SECTION_NAME (section
));
5931 printf (do_wide
? " %-15s " : " %-15.15s ",
5932 get_section_type_name (section
->sh_type
));
5936 const char * link_too_big
= NULL
;
5938 print_vma (section
->sh_addr
, LONG_HEX
);
5940 printf ( " %6.6lx %6.6lx %2.2lx",
5941 (unsigned long) section
->sh_offset
,
5942 (unsigned long) section
->sh_size
,
5943 (unsigned long) section
->sh_entsize
);
5945 if (do_section_details
)
5946 fputs (" ", stdout
);
5948 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5950 if (section
->sh_link
>= elf_header
.e_shnum
)
5953 /* The sh_link value is out of range. Normally this indicates
5954 an error but it can have special values in Solaris binaries. */
5955 switch (elf_header
.e_machine
)
5962 case EM_OLD_SPARCV9
:
5963 case EM_SPARC32PLUS
:
5966 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5967 link_too_big
= "BEFORE";
5968 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5969 link_too_big
= "AFTER";
5976 if (do_section_details
)
5978 if (link_too_big
!= NULL
&& * link_too_big
)
5979 printf ("<%s> ", link_too_big
);
5981 printf ("%2u ", section
->sh_link
);
5982 printf ("%3u %2lu\n", section
->sh_info
,
5983 (unsigned long) section
->sh_addralign
);
5986 printf ("%2u %3u %2lu\n",
5989 (unsigned long) section
->sh_addralign
);
5991 if (link_too_big
&& ! * link_too_big
)
5992 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5993 i
, section
->sh_link
);
5997 print_vma (section
->sh_addr
, LONG_HEX
);
5999 if ((long) section
->sh_offset
== section
->sh_offset
)
6000 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6004 print_vma (section
->sh_offset
, LONG_HEX
);
6007 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6008 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6012 print_vma (section
->sh_size
, LONG_HEX
);
6015 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6016 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6020 print_vma (section
->sh_entsize
, LONG_HEX
);
6023 if (do_section_details
)
6024 fputs (" ", stdout
);
6026 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6028 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6030 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6031 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6034 print_vma (section
->sh_addralign
, DEC
);
6038 else if (do_section_details
)
6040 printf (" %-15.15s ",
6041 get_section_type_name (section
->sh_type
));
6042 print_vma (section
->sh_addr
, LONG_HEX
);
6043 if ((long) section
->sh_offset
== section
->sh_offset
)
6044 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6048 print_vma (section
->sh_offset
, LONG_HEX
);
6050 printf (" %u\n ", section
->sh_link
);
6051 print_vma (section
->sh_size
, LONG_HEX
);
6053 print_vma (section
->sh_entsize
, LONG_HEX
);
6055 printf (" %-16u %lu\n",
6057 (unsigned long) section
->sh_addralign
);
6062 print_vma (section
->sh_addr
, LONG_HEX
);
6063 if ((long) section
->sh_offset
== section
->sh_offset
)
6064 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6068 print_vma (section
->sh_offset
, LONG_HEX
);
6071 print_vma (section
->sh_size
, LONG_HEX
);
6073 print_vma (section
->sh_entsize
, LONG_HEX
);
6075 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6077 printf (" %2u %3u %lu\n",
6080 (unsigned long) section
->sh_addralign
);
6083 if (do_section_details
)
6085 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6086 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6088 /* Minimum section size is 12 bytes for 32-bit compression
6089 header + 12 bytes for compressed data header. */
6090 unsigned char buf
[24];
6092 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6093 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6094 sizeof (buf
), _("compression header")))
6096 Elf_Internal_Chdr chdr
;
6098 (void) get_compression_header (&chdr
, buf
);
6100 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6103 printf (_(" [<unknown>: 0x%x], "),
6105 print_vma (chdr
.ch_size
, LONG_HEX
);
6106 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6112 if (!do_section_details
)
6114 /* The ordering of the letters shown here matches the ordering of the
6115 corresponding SHF_xxx values, and hence the order in which these
6116 letters will be displayed to the user. */
6117 printf (_("Key to Flags:\n\
6118 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6119 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6120 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6121 if (elf_header
.e_machine
== EM_X86_64
6122 || elf_header
.e_machine
== EM_L1OM
6123 || elf_header
.e_machine
== EM_K1OM
)
6124 printf (_("l (large), "));
6125 else if (elf_header
.e_machine
== EM_ARM
)
6126 printf (_("y (purecode), "));
6127 printf ("p (processor specific)\n");
6134 get_group_flags (unsigned int flags
)
6136 static char buff
[32];
6146 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
6153 process_section_groups (FILE * file
)
6155 Elf_Internal_Shdr
* section
;
6157 struct group
* group
;
6158 Elf_Internal_Shdr
* symtab_sec
;
6159 Elf_Internal_Shdr
* strtab_sec
;
6160 Elf_Internal_Sym
* symtab
;
6161 unsigned long num_syms
;
6165 /* Don't process section groups unless needed. */
6166 if (!do_unwind
&& !do_section_groups
)
6169 if (elf_header
.e_shnum
== 0)
6171 if (do_section_groups
)
6172 printf (_("\nThere are no sections to group in this file.\n"));
6177 if (section_headers
== NULL
)
6179 error (_("Section headers are not available!\n"));
6180 /* PR 13622: This can happen with a corrupt ELF header. */
6184 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6185 sizeof (struct group
*));
6187 if (section_headers_groups
== NULL
)
6189 error (_("Out of memory reading %u section group headers\n"),
6190 elf_header
.e_shnum
);
6194 /* Scan the sections for the group section. */
6196 for (i
= 0, section
= section_headers
;
6197 i
< elf_header
.e_shnum
;
6199 if (section
->sh_type
== SHT_GROUP
)
6202 if (group_count
== 0)
6204 if (do_section_groups
)
6205 printf (_("\nThere are no section groups in this file.\n"));
6210 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6212 if (section_groups
== NULL
)
6214 error (_("Out of memory reading %lu groups\n"),
6215 (unsigned long) group_count
);
6225 for (i
= 0, section
= section_headers
, group
= section_groups
;
6226 i
< elf_header
.e_shnum
;
6229 if (section
->sh_type
== SHT_GROUP
)
6231 const char * name
= printable_section_name (section
);
6232 const char * group_name
;
6233 unsigned char * start
;
6234 unsigned char * indices
;
6235 unsigned int entry
, j
, size
;
6236 Elf_Internal_Shdr
* sec
;
6237 Elf_Internal_Sym
* sym
;
6239 /* Get the symbol table. */
6240 if (section
->sh_link
>= elf_header
.e_shnum
6241 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6244 error (_("Bad sh_link in group section `%s'\n"), name
);
6248 if (symtab_sec
!= sec
)
6253 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6258 error (_("Corrupt header in group section `%s'\n"), name
);
6262 if (section
->sh_info
>= num_syms
)
6264 error (_("Bad sh_info in group section `%s'\n"), name
);
6268 sym
= symtab
+ section
->sh_info
;
6270 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6272 if (sym
->st_shndx
== 0
6273 || sym
->st_shndx
>= elf_header
.e_shnum
)
6275 error (_("Bad sh_info in group section `%s'\n"), name
);
6279 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6288 /* Get the string table. */
6289 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6298 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6304 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6305 1, strtab_sec
->sh_size
,
6307 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6309 group_name
= sym
->st_name
< strtab_size
6310 ? strtab
+ sym
->st_name
: _("<corrupt>");
6313 /* PR 17531: file: loop. */
6314 if (section
->sh_entsize
> section
->sh_size
)
6316 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6317 printable_section_name (section
),
6318 (unsigned long) section
->sh_entsize
,
6319 (unsigned long) section
->sh_size
);
6323 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6324 1, section
->sh_size
,
6330 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6331 entry
= byte_get (indices
, 4);
6334 if (do_section_groups
)
6336 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6337 get_group_flags (entry
), i
, name
, group_name
, size
);
6339 printf (_(" [Index] Name\n"));
6342 group
->group_index
= i
;
6344 for (j
= 0; j
< size
; j
++)
6346 struct group_list
* g
;
6348 entry
= byte_get (indices
, 4);
6351 if (entry
>= elf_header
.e_shnum
)
6353 static unsigned num_group_errors
= 0;
6355 if (num_group_errors
++ < 10)
6357 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6358 entry
, i
, elf_header
.e_shnum
- 1);
6359 if (num_group_errors
== 10)
6360 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6365 if (section_headers_groups
[entry
] != NULL
)
6369 static unsigned num_errs
= 0;
6371 if (num_errs
++ < 10)
6373 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6375 section_headers_groups
[entry
]->group_index
);
6377 warn (_("Further error messages about already contained group sections suppressed\n"));
6383 /* Intel C/C++ compiler may put section 0 in a
6384 section group. We just warn it the first time
6385 and ignore it afterwards. */
6386 static int warned
= 0;
6389 error (_("section 0 in group section [%5u]\n"),
6390 section_headers_groups
[entry
]->group_index
);
6396 section_headers_groups
[entry
] = group
;
6398 if (do_section_groups
)
6400 sec
= section_headers
+ entry
;
6401 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6404 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6405 g
->section_index
= entry
;
6406 g
->next
= group
->root
;
6424 /* Data used to display dynamic fixups. */
6426 struct ia64_vms_dynfixup
6428 bfd_vma needed_ident
; /* Library ident number. */
6429 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6430 bfd_vma fixup_needed
; /* Index of the library. */
6431 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6432 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6435 /* Data used to display dynamic relocations. */
6437 struct ia64_vms_dynimgrela
6439 bfd_vma img_rela_cnt
; /* Number of relocations. */
6440 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6443 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6447 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6448 const char *strtab
, unsigned int strtab_sz
)
6450 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6452 const char *lib_name
;
6454 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6455 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6456 _("dynamic section image fixups"));
6460 if (fixup
->needed
< strtab_sz
)
6461 lib_name
= strtab
+ fixup
->needed
;
6464 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6465 (unsigned long) fixup
->needed
);
6468 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6469 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6471 (_("Seg Offset Type SymVec DataType\n"));
6473 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6478 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6479 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6480 type
= BYTE_GET (imfs
[i
].type
);
6481 rtype
= elf_ia64_reloc_type (type
);
6483 printf (" 0x%08x ", type
);
6485 printf (" %-32s ", rtype
);
6486 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6487 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6493 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6496 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6498 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6501 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6502 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6503 _("dynamic section image relocations"));
6507 printf (_("\nImage relocs\n"));
6509 (_("Seg Offset Type Addend Seg Sym Off\n"));
6511 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6516 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6517 printf ("%08" BFD_VMA_FMT
"x ",
6518 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6519 type
= BYTE_GET (imrs
[i
].type
);
6520 rtype
= elf_ia64_reloc_type (type
);
6522 printf ("0x%08x ", type
);
6524 printf ("%-31s ", rtype
);
6525 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6526 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6527 printf ("%08" BFD_VMA_FMT
"x\n",
6528 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6534 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6537 process_ia64_vms_dynamic_relocs (FILE *file
)
6539 struct ia64_vms_dynfixup fixup
;
6540 struct ia64_vms_dynimgrela imgrela
;
6541 Elf_Internal_Dyn
*entry
;
6543 bfd_vma strtab_off
= 0;
6544 bfd_vma strtab_sz
= 0;
6545 char *strtab
= NULL
;
6547 memset (&fixup
, 0, sizeof (fixup
));
6548 memset (&imgrela
, 0, sizeof (imgrela
));
6550 /* Note: the order of the entries is specified by the OpenVMS specs. */
6551 for (entry
= dynamic_section
;
6552 entry
< dynamic_section
+ dynamic_nent
;
6555 switch (entry
->d_tag
)
6557 case DT_IA_64_VMS_STRTAB_OFFSET
:
6558 strtab_off
= entry
->d_un
.d_val
;
6561 strtab_sz
= entry
->d_un
.d_val
;
6563 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6564 1, strtab_sz
, _("dynamic string section"));
6567 case DT_IA_64_VMS_NEEDED_IDENT
:
6568 fixup
.needed_ident
= entry
->d_un
.d_val
;
6571 fixup
.needed
= entry
->d_un
.d_val
;
6573 case DT_IA_64_VMS_FIXUP_NEEDED
:
6574 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6576 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6577 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6579 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6580 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6582 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6585 case DT_IA_64_VMS_IMG_RELA_CNT
:
6586 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6588 case DT_IA_64_VMS_IMG_RELA_OFF
:
6589 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6591 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6611 } dynamic_relocations
[] =
6613 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6614 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6615 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6618 /* Process the reloc section. */
6621 process_relocs (FILE * file
)
6623 unsigned long rel_size
;
6624 unsigned long rel_offset
;
6630 if (do_using_dynamic
)
6634 int has_dynamic_reloc
;
6637 has_dynamic_reloc
= 0;
6639 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6641 is_rela
= dynamic_relocations
[i
].rela
;
6642 name
= dynamic_relocations
[i
].name
;
6643 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6644 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6646 has_dynamic_reloc
|= rel_size
;
6648 if (is_rela
== UNKNOWN
)
6650 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6651 switch (dynamic_info
[DT_PLTREL
])
6665 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6666 name
, rel_offset
, rel_size
);
6668 dump_relocations (file
,
6669 offset_from_vma (file
, rel_offset
, rel_size
),
6671 dynamic_symbols
, num_dynamic_syms
,
6672 dynamic_strings
, dynamic_strings_length
,
6678 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6680 if (! has_dynamic_reloc
)
6681 printf (_("\nThere are no dynamic relocations in this file.\n"));
6685 Elf_Internal_Shdr
* section
;
6689 for (i
= 0, section
= section_headers
;
6690 i
< elf_header
.e_shnum
;
6693 if ( section
->sh_type
!= SHT_RELA
6694 && section
->sh_type
!= SHT_REL
)
6697 rel_offset
= section
->sh_offset
;
6698 rel_size
= section
->sh_size
;
6702 Elf_Internal_Shdr
* strsec
;
6705 printf (_("\nRelocation section "));
6707 if (string_table
== NULL
)
6708 printf ("%d", section
->sh_name
);
6710 printf ("'%s'", printable_section_name (section
));
6712 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6713 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6715 is_rela
= section
->sh_type
== SHT_RELA
;
6717 if (section
->sh_link
!= 0
6718 && section
->sh_link
< elf_header
.e_shnum
)
6720 Elf_Internal_Shdr
* symsec
;
6721 Elf_Internal_Sym
* symtab
;
6722 unsigned long nsyms
;
6723 unsigned long strtablen
= 0;
6724 char * strtab
= NULL
;
6726 symsec
= section_headers
+ section
->sh_link
;
6727 if (symsec
->sh_type
!= SHT_SYMTAB
6728 && symsec
->sh_type
!= SHT_DYNSYM
)
6731 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6736 if (symsec
->sh_link
!= 0
6737 && symsec
->sh_link
< elf_header
.e_shnum
)
6739 strsec
= section_headers
+ symsec
->sh_link
;
6741 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6744 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6747 dump_relocations (file
, rel_offset
, rel_size
,
6748 symtab
, nsyms
, strtab
, strtablen
,
6750 symsec
->sh_type
== SHT_DYNSYM
);
6756 dump_relocations (file
, rel_offset
, rel_size
,
6757 NULL
, 0, NULL
, 0, is_rela
, 0);
6764 printf (_("\nThere are no relocations in this file.\n"));
6770 /* An absolute address consists of a section and an offset. If the
6771 section is NULL, the offset itself is the address, otherwise, the
6772 address equals to LOAD_ADDRESS(section) + offset. */
6776 unsigned short section
;
6780 #define ABSADDR(a) \
6782 ? section_headers [(a).section].sh_addr + (a).offset \
6785 /* Find the nearest symbol at or below ADDR. Returns the symbol
6786 name, if found, and the offset from the symbol to ADDR. */
6789 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6790 unsigned long nsyms
,
6791 const char * strtab
,
6792 unsigned long strtab_size
,
6793 struct absaddr addr
,
6794 const char ** symname
,
6797 bfd_vma dist
= 0x100000;
6798 Elf_Internal_Sym
* sym
;
6799 Elf_Internal_Sym
* beg
;
6800 Elf_Internal_Sym
* end
;
6801 Elf_Internal_Sym
* best
= NULL
;
6803 REMOVE_ARCH_BITS (addr
.offset
);
6805 end
= symtab
+ nsyms
;
6811 sym
= beg
+ (end
- beg
) / 2;
6813 value
= sym
->st_value
;
6814 REMOVE_ARCH_BITS (value
);
6816 if (sym
->st_name
!= 0
6817 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6818 && addr
.offset
>= value
6819 && addr
.offset
- value
< dist
)
6822 dist
= addr
.offset
- value
;
6827 if (addr
.offset
< value
)
6835 *symname
= (best
->st_name
>= strtab_size
6836 ? _("<corrupt>") : strtab
+ best
->st_name
);
6842 *offset
= addr
.offset
;
6846 symcmp (const void *p
, const void *q
)
6848 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6849 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6851 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6854 /* Process the unwind section. */
6856 #include "unwind-ia64.h"
6858 struct ia64_unw_table_entry
6860 struct absaddr start
;
6862 struct absaddr info
;
6865 struct ia64_unw_aux_info
6867 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6868 unsigned long table_len
; /* Length of unwind table. */
6869 unsigned char * info
; /* Unwind info. */
6870 unsigned long info_size
; /* Size of unwind info. */
6871 bfd_vma info_addr
; /* Starting address of unwind info. */
6872 bfd_vma seg_base
; /* Starting address of segment. */
6873 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6874 unsigned long nsyms
; /* Number of symbols. */
6875 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6876 unsigned long nfuns
; /* Number of entries in funtab. */
6877 char * strtab
; /* The string table. */
6878 unsigned long strtab_size
; /* Size of string table. */
6882 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6884 struct ia64_unw_table_entry
* tp
;
6885 unsigned long j
, nfuns
;
6888 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6889 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6890 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6891 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6893 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6895 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6899 const unsigned char * dp
;
6900 const unsigned char * head
;
6901 const unsigned char * end
;
6902 const char * procname
;
6904 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6905 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6907 fputs ("\n<", stdout
);
6911 fputs (procname
, stdout
);
6914 printf ("+%lx", (unsigned long) offset
);
6917 fputs (">: [", stdout
);
6918 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6919 fputc ('-', stdout
);
6920 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6921 printf ("], info at +0x%lx\n",
6922 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6924 /* PR 17531: file: 86232b32. */
6925 if (aux
->info
== NULL
)
6928 /* PR 17531: file: 0997b4d1. */
6929 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6931 warn (_("Invalid offset %lx in table entry %ld\n"),
6932 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6936 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6937 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6939 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6940 (unsigned) UNW_VER (stamp
),
6941 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6942 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6943 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6944 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6946 if (UNW_VER (stamp
) != 1)
6948 printf (_("\tUnknown version.\n"));
6953 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6954 /* PR 17531: file: 16ceda89. */
6955 if (end
> aux
->info
+ aux
->info_size
)
6956 end
= aux
->info
+ aux
->info_size
;
6957 for (dp
= head
+ 8; dp
< end
;)
6958 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
6965 slurp_ia64_unwind_table (FILE * file
,
6966 struct ia64_unw_aux_info
* aux
,
6967 Elf_Internal_Shdr
* sec
)
6969 unsigned long size
, nrelas
, i
;
6970 Elf_Internal_Phdr
* seg
;
6971 struct ia64_unw_table_entry
* tep
;
6972 Elf_Internal_Shdr
* relsec
;
6973 Elf_Internal_Rela
* rela
;
6974 Elf_Internal_Rela
* rp
;
6975 unsigned char * table
;
6977 Elf_Internal_Sym
* sym
;
6978 const char * relname
;
6982 /* First, find the starting address of the segment that includes
6985 if (elf_header
.e_phnum
)
6987 if (! get_program_headers (file
))
6990 for (seg
= program_headers
;
6991 seg
< program_headers
+ elf_header
.e_phnum
;
6994 if (seg
->p_type
!= PT_LOAD
)
6997 if (sec
->sh_addr
>= seg
->p_vaddr
6998 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7000 aux
->seg_base
= seg
->p_vaddr
;
7006 /* Second, build the unwind table from the contents of the unwind section: */
7007 size
= sec
->sh_size
;
7008 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7013 aux
->table_len
= size
/ (3 * eh_addr_size
);
7014 aux
->table
= (struct ia64_unw_table_entry
*)
7015 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7018 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7020 tep
->start
.section
= SHN_UNDEF
;
7021 tep
->end
.section
= SHN_UNDEF
;
7022 tep
->info
.section
= SHN_UNDEF
;
7023 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7024 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7025 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7026 tep
->start
.offset
+= aux
->seg_base
;
7027 tep
->end
.offset
+= aux
->seg_base
;
7028 tep
->info
.offset
+= aux
->seg_base
;
7032 /* Third, apply any relocations to the unwind table: */
7033 for (relsec
= section_headers
;
7034 relsec
< section_headers
+ elf_header
.e_shnum
;
7037 if (relsec
->sh_type
!= SHT_RELA
7038 || relsec
->sh_info
>= elf_header
.e_shnum
7039 || section_headers
+ relsec
->sh_info
!= sec
)
7042 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7051 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7053 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7054 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7056 /* PR 17531: file: 9fa67536. */
7057 if (relname
== NULL
)
7059 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7063 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7065 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7069 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7071 /* PR 17531: file: 5bc8d9bf. */
7072 if (i
>= aux
->table_len
)
7074 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7078 switch (rp
->r_offset
/ eh_addr_size
% 3)
7081 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7082 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7085 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7086 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7089 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7090 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7104 ia64_process_unwind (FILE * file
)
7106 Elf_Internal_Shdr
* sec
;
7107 Elf_Internal_Shdr
* unwsec
= NULL
;
7108 Elf_Internal_Shdr
* strsec
;
7109 unsigned long i
, unwcount
= 0, unwstart
= 0;
7110 struct ia64_unw_aux_info aux
;
7112 memset (& aux
, 0, sizeof (aux
));
7114 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7116 if (sec
->sh_type
== SHT_SYMTAB
7117 && sec
->sh_link
< elf_header
.e_shnum
)
7119 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7121 strsec
= section_headers
+ sec
->sh_link
;
7122 if (aux
.strtab
!= NULL
)
7124 error (_("Multiple auxillary string tables encountered\n"));
7127 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7130 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7132 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7137 printf (_("\nThere are no unwind sections in this file.\n"));
7139 while (unwcount
-- > 0)
7144 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7145 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7146 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7151 /* We have already counted the number of SHT_IA64_UNWIND
7152 sections so the loop above should never fail. */
7153 assert (unwsec
!= NULL
);
7156 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7158 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7160 /* We need to find which section group it is in. */
7161 struct group_list
* g
;
7163 if (section_headers_groups
== NULL
7164 || section_headers_groups
[i
] == NULL
)
7165 i
= elf_header
.e_shnum
;
7168 g
= section_headers_groups
[i
]->root
;
7170 for (; g
!= NULL
; g
= g
->next
)
7172 sec
= section_headers
+ g
->section_index
;
7174 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7179 i
= elf_header
.e_shnum
;
7182 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7184 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7185 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7186 suffix
= SECTION_NAME (unwsec
) + len
;
7187 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7189 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7190 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7195 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7196 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7197 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7198 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7200 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7201 suffix
= SECTION_NAME (unwsec
) + len
;
7202 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7204 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7205 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7209 if (i
== elf_header
.e_shnum
)
7211 printf (_("\nCould not find unwind info section for "));
7213 if (string_table
== NULL
)
7214 printf ("%d", unwsec
->sh_name
);
7216 printf ("'%s'", printable_section_name (unwsec
));
7220 aux
.info_addr
= sec
->sh_addr
;
7221 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7224 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7226 printf (_("\nUnwind section "));
7228 if (string_table
== NULL
)
7229 printf ("%d", unwsec
->sh_name
);
7231 printf ("'%s'", printable_section_name (unwsec
));
7233 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7234 (unsigned long) unwsec
->sh_offset
,
7235 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7237 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7238 && aux
.table_len
> 0)
7239 dump_ia64_unwind (& aux
);
7242 free ((char *) aux
.table
);
7244 free ((char *) aux
.info
);
7253 free ((char *) aux
.strtab
);
7256 struct hppa_unw_table_entry
7258 struct absaddr start
;
7260 unsigned int Cannot_unwind
:1; /* 0 */
7261 unsigned int Millicode
:1; /* 1 */
7262 unsigned int Millicode_save_sr0
:1; /* 2 */
7263 unsigned int Region_description
:2; /* 3..4 */
7264 unsigned int reserved1
:1; /* 5 */
7265 unsigned int Entry_SR
:1; /* 6 */
7266 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7267 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7268 unsigned int Args_stored
:1; /* 16 */
7269 unsigned int Variable_Frame
:1; /* 17 */
7270 unsigned int Separate_Package_Body
:1; /* 18 */
7271 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7272 unsigned int Stack_Overflow_Check
:1; /* 20 */
7273 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7274 unsigned int Ada_Region
:1; /* 22 */
7275 unsigned int cxx_info
:1; /* 23 */
7276 unsigned int cxx_try_catch
:1; /* 24 */
7277 unsigned int sched_entry_seq
:1; /* 25 */
7278 unsigned int reserved2
:1; /* 26 */
7279 unsigned int Save_SP
:1; /* 27 */
7280 unsigned int Save_RP
:1; /* 28 */
7281 unsigned int Save_MRP_in_frame
:1; /* 29 */
7282 unsigned int extn_ptr_defined
:1; /* 30 */
7283 unsigned int Cleanup_defined
:1; /* 31 */
7285 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7286 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7287 unsigned int Large_frame
:1; /* 2 */
7288 unsigned int Pseudo_SP_Set
:1; /* 3 */
7289 unsigned int reserved4
:1; /* 4 */
7290 unsigned int Total_frame_size
:27; /* 5..31 */
7293 struct hppa_unw_aux_info
7295 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7296 unsigned long table_len
; /* Length of unwind table. */
7297 bfd_vma seg_base
; /* Starting address of segment. */
7298 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7299 unsigned long nsyms
; /* Number of symbols. */
7300 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7301 unsigned long nfuns
; /* Number of entries in funtab. */
7302 char * strtab
; /* The string table. */
7303 unsigned long strtab_size
; /* Size of string table. */
7307 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7309 struct hppa_unw_table_entry
* tp
;
7310 unsigned long j
, nfuns
;
7312 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7313 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7314 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7315 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7317 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7319 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7322 const char * procname
;
7324 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7325 aux
->strtab_size
, tp
->start
, &procname
,
7328 fputs ("\n<", stdout
);
7332 fputs (procname
, stdout
);
7335 printf ("+%lx", (unsigned long) offset
);
7338 fputs (">: [", stdout
);
7339 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7340 fputc ('-', stdout
);
7341 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7344 #define PF(_m) if (tp->_m) printf (#_m " ");
7345 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7348 PF(Millicode_save_sr0
);
7349 /* PV(Region_description); */
7355 PF(Separate_Package_Body
);
7356 PF(Frame_Extension_Millicode
);
7357 PF(Stack_Overflow_Check
);
7358 PF(Two_Instruction_SP_Increment
);
7362 PF(sched_entry_seq
);
7365 PF(Save_MRP_in_frame
);
7366 PF(extn_ptr_defined
);
7367 PF(Cleanup_defined
);
7368 PF(MPE_XL_interrupt_marker
);
7369 PF(HP_UX_interrupt_marker
);
7372 PV(Total_frame_size
);
7383 slurp_hppa_unwind_table (FILE * file
,
7384 struct hppa_unw_aux_info
* aux
,
7385 Elf_Internal_Shdr
* sec
)
7387 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7388 Elf_Internal_Phdr
* seg
;
7389 struct hppa_unw_table_entry
* tep
;
7390 Elf_Internal_Shdr
* relsec
;
7391 Elf_Internal_Rela
* rela
;
7392 Elf_Internal_Rela
* rp
;
7393 unsigned char * table
;
7395 Elf_Internal_Sym
* sym
;
7396 const char * relname
;
7398 /* First, find the starting address of the segment that includes
7401 if (elf_header
.e_phnum
)
7403 if (! get_program_headers (file
))
7406 for (seg
= program_headers
;
7407 seg
< program_headers
+ elf_header
.e_phnum
;
7410 if (seg
->p_type
!= PT_LOAD
)
7413 if (sec
->sh_addr
>= seg
->p_vaddr
7414 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7416 aux
->seg_base
= seg
->p_vaddr
;
7422 /* Second, build the unwind table from the contents of the unwind
7424 size
= sec
->sh_size
;
7425 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7431 nentries
= size
/ unw_ent_size
;
7432 size
= unw_ent_size
* nentries
;
7434 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7435 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7437 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7439 unsigned int tmp1
, tmp2
;
7441 tep
->start
.section
= SHN_UNDEF
;
7442 tep
->end
.section
= SHN_UNDEF
;
7444 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7445 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7446 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7447 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7449 tep
->start
.offset
+= aux
->seg_base
;
7450 tep
->end
.offset
+= aux
->seg_base
;
7452 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7453 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7454 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7455 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7456 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7457 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7458 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7459 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7460 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7461 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7462 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7463 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7464 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7465 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7466 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7467 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7468 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7469 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7470 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7471 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7472 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7473 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7474 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7475 tep
->Cleanup_defined
= tmp1
& 0x1;
7477 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7478 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7479 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7480 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7481 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7482 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7486 /* Third, apply any relocations to the unwind table. */
7487 for (relsec
= section_headers
;
7488 relsec
< section_headers
+ elf_header
.e_shnum
;
7491 if (relsec
->sh_type
!= SHT_RELA
7492 || relsec
->sh_info
>= elf_header
.e_shnum
7493 || section_headers
+ relsec
->sh_info
!= sec
)
7496 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7500 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7502 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7503 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7505 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7506 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7508 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7512 i
= rp
->r_offset
/ unw_ent_size
;
7514 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7517 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7518 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7521 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7522 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7532 aux
->table_len
= nentries
;
7538 hppa_process_unwind (FILE * file
)
7540 struct hppa_unw_aux_info aux
;
7541 Elf_Internal_Shdr
* unwsec
= NULL
;
7542 Elf_Internal_Shdr
* strsec
;
7543 Elf_Internal_Shdr
* sec
;
7546 if (string_table
== NULL
)
7549 memset (& aux
, 0, sizeof (aux
));
7551 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7553 if (sec
->sh_type
== SHT_SYMTAB
7554 && sec
->sh_link
< elf_header
.e_shnum
)
7556 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7558 strsec
= section_headers
+ sec
->sh_link
;
7559 if (aux
.strtab
!= NULL
)
7561 error (_("Multiple auxillary string tables encountered\n"));
7564 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7567 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7569 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7574 printf (_("\nThere are no unwind sections in this file.\n"));
7576 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7578 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7580 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7581 printable_section_name (sec
),
7582 (unsigned long) sec
->sh_offset
,
7583 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7585 slurp_hppa_unwind_table (file
, &aux
, sec
);
7586 if (aux
.table_len
> 0)
7587 dump_hppa_unwind (&aux
);
7590 free ((char *) aux
.table
);
7598 free ((char *) aux
.strtab
);
7603 unsigned char * data
; /* The unwind data. */
7604 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7605 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7606 unsigned long nrelas
; /* The number of relocations. */
7607 unsigned int rel_type
; /* REL or RELA ? */
7608 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7611 struct arm_unw_aux_info
7613 FILE * file
; /* The file containing the unwind sections. */
7614 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7615 unsigned long nsyms
; /* Number of symbols. */
7616 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7617 unsigned long nfuns
; /* Number of these symbols. */
7618 char * strtab
; /* The file's string table. */
7619 unsigned long strtab_size
; /* Size of string table. */
7623 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7624 bfd_vma fn
, struct absaddr addr
)
7626 const char *procname
;
7629 if (addr
.section
== SHN_UNDEF
)
7632 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7633 aux
->strtab_size
, addr
, &procname
,
7636 print_vma (fn
, PREFIX_HEX
);
7640 fputs (" <", stdout
);
7641 fputs (procname
, stdout
);
7644 printf ("+0x%lx", (unsigned long) sym_offset
);
7645 fputc ('>', stdout
);
7652 arm_free_section (struct arm_section
*arm_sec
)
7654 if (arm_sec
->data
!= NULL
)
7655 free (arm_sec
->data
);
7657 if (arm_sec
->rela
!= NULL
)
7658 free (arm_sec
->rela
);
7661 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7662 cached section and install SEC instead.
7663 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7664 and return its valued in * WORDP, relocating if necessary.
7665 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7666 relocation's offset in ADDR.
7667 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7668 into the string table of the symbol associated with the reloc. If no
7669 reloc was applied store -1 there.
7670 5) Return TRUE upon success, FALSE otherwise. */
7673 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7674 struct arm_section
* arm_sec
,
7675 Elf_Internal_Shdr
* sec
,
7676 bfd_vma word_offset
,
7677 unsigned int * wordp
,
7678 struct absaddr
* addr
,
7681 Elf_Internal_Rela
*rp
;
7682 Elf_Internal_Sym
*sym
;
7683 const char * relname
;
7685 bfd_boolean wrapped
;
7687 if (sec
== NULL
|| arm_sec
== NULL
)
7690 addr
->section
= SHN_UNDEF
;
7693 if (sym_name
!= NULL
)
7694 *sym_name
= (bfd_vma
) -1;
7696 /* If necessary, update the section cache. */
7697 if (sec
!= arm_sec
->sec
)
7699 Elf_Internal_Shdr
*relsec
;
7701 arm_free_section (arm_sec
);
7704 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7705 sec
->sh_size
, _("unwind data"));
7706 arm_sec
->rela
= NULL
;
7707 arm_sec
->nrelas
= 0;
7709 for (relsec
= section_headers
;
7710 relsec
< section_headers
+ elf_header
.e_shnum
;
7713 if (relsec
->sh_info
>= elf_header
.e_shnum
7714 || section_headers
+ relsec
->sh_info
!= sec
7715 /* PR 15745: Check the section type as well. */
7716 || (relsec
->sh_type
!= SHT_REL
7717 && relsec
->sh_type
!= SHT_RELA
))
7720 arm_sec
->rel_type
= relsec
->sh_type
;
7721 if (relsec
->sh_type
== SHT_REL
)
7723 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7725 & arm_sec
->rela
, & arm_sec
->nrelas
))
7728 else /* relsec->sh_type == SHT_RELA */
7730 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7732 & arm_sec
->rela
, & arm_sec
->nrelas
))
7738 arm_sec
->next_rela
= arm_sec
->rela
;
7741 /* If there is no unwind data we can do nothing. */
7742 if (arm_sec
->data
== NULL
)
7745 /* If the offset is invalid then fail. */
7746 if (word_offset
> (sec
->sh_size
- 4)
7748 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7749 || ((bfd_signed_vma
) word_offset
) < 0)
7752 /* Get the word at the required offset. */
7753 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7755 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7756 if (arm_sec
->rela
== NULL
)
7762 /* Look through the relocs to find the one that applies to the provided offset. */
7764 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7766 bfd_vma prelval
, offset
;
7768 if (rp
->r_offset
> word_offset
&& !wrapped
)
7773 if (rp
->r_offset
> word_offset
)
7776 if (rp
->r_offset
& 3)
7778 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7779 (unsigned long) rp
->r_offset
);
7783 if (rp
->r_offset
< word_offset
)
7786 /* PR 17531: file: 027-161405-0.004 */
7787 if (aux
->symtab
== NULL
)
7790 if (arm_sec
->rel_type
== SHT_REL
)
7792 offset
= word
& 0x7fffffff;
7793 if (offset
& 0x40000000)
7794 offset
|= ~ (bfd_vma
) 0x7fffffff;
7796 else if (arm_sec
->rel_type
== SHT_RELA
)
7797 offset
= rp
->r_addend
;
7800 error (_("Unknown section relocation type %d encountered\n"),
7805 /* PR 17531 file: 027-1241568-0.004. */
7806 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7808 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7809 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7813 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7814 offset
+= sym
->st_value
;
7815 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7817 /* Check that we are processing the expected reloc type. */
7818 if (elf_header
.e_machine
== EM_ARM
)
7820 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7821 if (relname
== NULL
)
7823 warn (_("Skipping unknown ARM relocation type: %d\n"),
7824 (int) ELF32_R_TYPE (rp
->r_info
));
7828 if (streq (relname
, "R_ARM_NONE"))
7831 if (! streq (relname
, "R_ARM_PREL31"))
7833 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7837 else if (elf_header
.e_machine
== EM_TI_C6000
)
7839 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7840 if (relname
== NULL
)
7842 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7843 (int) ELF32_R_TYPE (rp
->r_info
));
7847 if (streq (relname
, "R_C6000_NONE"))
7850 if (! streq (relname
, "R_C6000_PREL31"))
7852 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7860 /* This function currently only supports ARM and TI unwinders. */
7861 warn (_("Only TI and ARM unwinders are currently supported\n"));
7865 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7866 addr
->section
= sym
->st_shndx
;
7867 addr
->offset
= offset
;
7870 * sym_name
= sym
->st_name
;
7875 arm_sec
->next_rela
= rp
;
7880 static const char *tic6x_unwind_regnames
[16] =
7882 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7883 "A14", "A13", "A12", "A11", "A10",
7884 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7888 decode_tic6x_unwind_regmask (unsigned int mask
)
7892 for (i
= 12; mask
; mask
>>= 1, i
--)
7896 fputs (tic6x_unwind_regnames
[i
], stdout
);
7898 fputs (", ", stdout
);
7904 if (remaining == 0 && more_words) \
7907 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7908 data_offset, & word, & addr, NULL)) \
7914 #define GET_OP(OP) \
7919 (OP) = word >> 24; \
7924 printf (_("[Truncated opcode]\n")); \
7927 printf ("0x%02x ", OP)
7930 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7932 unsigned int remaining
,
7933 unsigned int more_words
,
7934 bfd_vma data_offset
,
7935 Elf_Internal_Shdr
* data_sec
,
7936 struct arm_section
* data_arm_sec
)
7938 struct absaddr addr
;
7940 /* Decode the unwinding instructions. */
7943 unsigned int op
, op2
;
7952 printf (" 0x%02x ", op
);
7954 if ((op
& 0xc0) == 0x00)
7956 int offset
= ((op
& 0x3f) << 2) + 4;
7958 printf (" vsp = vsp + %d", offset
);
7960 else if ((op
& 0xc0) == 0x40)
7962 int offset
= ((op
& 0x3f) << 2) + 4;
7964 printf (" vsp = vsp - %d", offset
);
7966 else if ((op
& 0xf0) == 0x80)
7969 if (op
== 0x80 && op2
== 0)
7970 printf (_("Refuse to unwind"));
7973 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7978 for (i
= 0; i
< 12; i
++)
7979 if (mask
& (1 << i
))
7985 printf ("r%d", 4 + i
);
7990 else if ((op
& 0xf0) == 0x90)
7992 if (op
== 0x9d || op
== 0x9f)
7993 printf (_(" [Reserved]"));
7995 printf (" vsp = r%d", op
& 0x0f);
7997 else if ((op
& 0xf0) == 0xa0)
7999 int end
= 4 + (op
& 0x07);
8004 for (i
= 4; i
<= end
; i
++)
8020 else if (op
== 0xb0)
8021 printf (_(" finish"));
8022 else if (op
== 0xb1)
8025 if (op2
== 0 || (op2
& 0xf0) != 0)
8026 printf (_("[Spare]"));
8029 unsigned int mask
= op2
& 0x0f;
8034 for (i
= 0; i
< 12; i
++)
8035 if (mask
& (1 << i
))
8046 else if (op
== 0xb2)
8048 unsigned char buf
[9];
8049 unsigned int i
, len
;
8050 unsigned long offset
;
8052 for (i
= 0; i
< sizeof (buf
); i
++)
8055 if ((buf
[i
] & 0x80) == 0)
8058 if (i
== sizeof (buf
))
8059 printf (_("corrupt change to vsp"));
8062 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8063 assert (len
== i
+ 1);
8064 offset
= offset
* 4 + 0x204;
8065 printf ("vsp = vsp + %ld", offset
);
8068 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8070 unsigned int first
, last
;
8077 printf ("pop {D%d", first
);
8079 printf ("-D%d", first
+ last
);
8082 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8084 unsigned int count
= op
& 0x07;
8088 printf ("-D%d", 8 + count
);
8091 else if (op
>= 0xc0 && op
<= 0xc5)
8093 unsigned int count
= op
& 0x07;
8095 printf (" pop {wR10");
8097 printf ("-wR%d", 10 + count
);
8100 else if (op
== 0xc6)
8102 unsigned int first
, last
;
8107 printf ("pop {wR%d", first
);
8109 printf ("-wR%d", first
+ last
);
8112 else if (op
== 0xc7)
8115 if (op2
== 0 || (op2
& 0xf0) != 0)
8116 printf (_("[Spare]"));
8119 unsigned int mask
= op2
& 0x0f;
8124 for (i
= 0; i
< 4; i
++)
8125 if (mask
& (1 << i
))
8131 printf ("wCGR%d", i
);
8137 printf (_(" [unsupported opcode]"));
8143 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8145 unsigned int remaining
,
8146 unsigned int more_words
,
8147 bfd_vma data_offset
,
8148 Elf_Internal_Shdr
* data_sec
,
8149 struct arm_section
* data_arm_sec
)
8151 struct absaddr addr
;
8153 /* Decode the unwinding instructions. */
8156 unsigned int op
, op2
;
8165 printf (" 0x%02x ", op
);
8167 if ((op
& 0xc0) == 0x00)
8169 int offset
= ((op
& 0x3f) << 3) + 8;
8170 printf (" sp = sp + %d", offset
);
8172 else if ((op
& 0xc0) == 0x80)
8175 if (op
== 0x80 && op2
== 0)
8176 printf (_("Refuse to unwind"));
8179 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8181 printf ("pop compact {");
8185 decode_tic6x_unwind_regmask (mask
);
8189 else if ((op
& 0xf0) == 0xc0)
8197 unsigned int offset
;
8201 /* Scan entire instruction first so that GET_OP output is not
8202 interleaved with disassembly. */
8204 for (i
= 0; nregs
< (op
& 0xf); i
++)
8210 regpos
[nregs
].offset
= i
* 2;
8211 regpos
[nregs
].reg
= reg
;
8218 regpos
[nregs
].offset
= i
* 2 + 1;
8219 regpos
[nregs
].reg
= reg
;
8224 printf (_("pop frame {"));
8226 for (i
= i
* 2; i
> 0; i
--)
8228 if (regpos
[reg
].offset
== i
- 1)
8230 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8237 fputs (name
, stdout
);
8244 else if (op
== 0xd0)
8245 printf (" MOV FP, SP");
8246 else if (op
== 0xd1)
8247 printf (" __c6xabi_pop_rts");
8248 else if (op
== 0xd2)
8250 unsigned char buf
[9];
8251 unsigned int i
, len
;
8252 unsigned long offset
;
8254 for (i
= 0; i
< sizeof (buf
); i
++)
8257 if ((buf
[i
] & 0x80) == 0)
8260 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8261 if (i
== sizeof (buf
))
8263 printf ("<corrupt sp adjust>\n");
8264 warn (_("Corrupt stack pointer adjustment detected\n"));
8268 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8269 assert (len
== i
+ 1);
8270 offset
= offset
* 8 + 0x408;
8271 printf (_("sp = sp + %ld"), offset
);
8273 else if ((op
& 0xf0) == 0xe0)
8275 if ((op
& 0x0f) == 7)
8278 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8282 printf (_(" [unsupported opcode]"));
8289 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8293 offset
= word
& 0x7fffffff;
8294 if (offset
& 0x40000000)
8295 offset
|= ~ (bfd_vma
) 0x7fffffff;
8297 if (elf_header
.e_machine
== EM_TI_C6000
)
8300 return offset
+ where
;
8304 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8306 unsigned int remaining
,
8307 bfd_vma data_offset
,
8308 Elf_Internal_Shdr
* data_sec
,
8309 struct arm_section
* data_arm_sec
)
8312 unsigned int more_words
= 0;
8313 struct absaddr addr
;
8314 bfd_vma sym_name
= (bfd_vma
) -1;
8318 /* Fetch the first word.
8319 Note - when decoding an object file the address extracted
8320 here will always be 0. So we also pass in the sym_name
8321 parameter so that we can find the symbol associated with
8322 the personality routine. */
8323 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8324 & word
, & addr
, & sym_name
))
8330 if ((word
& 0x80000000) == 0)
8332 /* Expand prel31 for personality routine. */
8334 const char *procname
;
8336 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8337 printf (_(" Personality routine: "));
8339 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8340 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8342 procname
= aux
->strtab
+ sym_name
;
8343 print_vma (fn
, PREFIX_HEX
);
8346 fputs (" <", stdout
);
8347 fputs (procname
, stdout
);
8348 fputc ('>', stdout
);
8352 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8353 fputc ('\n', stdout
);
8355 /* The GCC personality routines use the standard compact
8356 encoding, starting with one byte giving the number of
8358 if (procname
!= NULL
8359 && (const_strneq (procname
, "__gcc_personality_v0")
8360 || const_strneq (procname
, "__gxx_personality_v0")
8361 || const_strneq (procname
, "__gcj_personality_v0")
8362 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8369 printf (_(" [Truncated data]\n"));
8372 more_words
= word
>> 24;
8382 /* ARM EHABI Section 6.3:
8384 An exception-handling table entry for the compact model looks like:
8388 1 0 index Data for personalityRoutine[index] */
8390 if (elf_header
.e_machine
== EM_ARM
8391 && (word
& 0x70000000))
8392 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8394 per_index
= (word
>> 24) & 0x7f;
8395 printf (_(" Compact model index: %d\n"), per_index
);
8402 else if (per_index
< 3)
8404 more_words
= (word
>> 16) & 0xff;
8410 switch (elf_header
.e_machine
)
8415 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8416 data_offset
, data_sec
, data_arm_sec
);
8420 warn (_("Unknown ARM compact model index encountered\n"));
8421 printf (_(" [reserved]\n"));
8428 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8429 data_offset
, data_sec
, data_arm_sec
);
8431 else if (per_index
< 5)
8433 if (((word
>> 17) & 0x7f) == 0x7f)
8434 printf (_(" Restore stack from frame pointer\n"));
8436 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8437 printf (_(" Registers restored: "));
8439 printf (" (compact) ");
8440 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8442 printf (_(" Return register: %s\n"),
8443 tic6x_unwind_regnames
[word
& 0xf]);
8446 printf (_(" [reserved (%d)]\n"), per_index
);
8450 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8451 elf_header
.e_machine
);
8454 /* Decode the descriptors. Not implemented. */
8458 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8460 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8461 unsigned int i
, exidx_len
;
8462 unsigned long j
, nfuns
;
8464 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8465 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8466 exidx_len
= exidx_sec
->sh_size
/ 8;
8468 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8469 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8470 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8471 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8473 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8475 for (i
= 0; i
< exidx_len
; i
++)
8477 unsigned int exidx_fn
, exidx_entry
;
8478 struct absaddr fn_addr
, entry_addr
;
8481 fputc ('\n', stdout
);
8483 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8484 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8485 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8486 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8489 arm_free_section (& exidx_arm_sec
);
8490 arm_free_section (& extab_arm_sec
);
8494 /* ARM EHABI, Section 5:
8495 An index table entry consists of 2 words.
8496 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8497 if (exidx_fn
& 0x80000000)
8498 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8500 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8502 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8503 fputs (": ", stdout
);
8505 if (exidx_entry
== 1)
8507 print_vma (exidx_entry
, PREFIX_HEX
);
8508 fputs (" [cantunwind]\n", stdout
);
8510 else if (exidx_entry
& 0x80000000)
8512 print_vma (exidx_entry
, PREFIX_HEX
);
8513 fputc ('\n', stdout
);
8514 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8518 bfd_vma table
, table_offset
= 0;
8519 Elf_Internal_Shdr
*table_sec
;
8521 fputs ("@", stdout
);
8522 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8523 print_vma (table
, PREFIX_HEX
);
8526 /* Locate the matching .ARM.extab. */
8527 if (entry_addr
.section
!= SHN_UNDEF
8528 && entry_addr
.section
< elf_header
.e_shnum
)
8530 table_sec
= section_headers
+ entry_addr
.section
;
8531 table_offset
= entry_addr
.offset
;
8533 if (table_offset
> table_sec
->sh_size
8534 || ((bfd_signed_vma
) table_offset
) < 0)
8536 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8537 (unsigned long) table_offset
,
8538 printable_section_name (table_sec
));
8544 table_sec
= find_section_by_address (table
);
8545 if (table_sec
!= NULL
)
8546 table_offset
= table
- table_sec
->sh_addr
;
8548 if (table_sec
== NULL
)
8550 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8551 (unsigned long) table
);
8554 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8562 arm_free_section (&exidx_arm_sec
);
8563 arm_free_section (&extab_arm_sec
);
8566 /* Used for both ARM and C6X unwinding tables. */
8569 arm_process_unwind (FILE *file
)
8571 struct arm_unw_aux_info aux
;
8572 Elf_Internal_Shdr
*unwsec
= NULL
;
8573 Elf_Internal_Shdr
*strsec
;
8574 Elf_Internal_Shdr
*sec
;
8576 unsigned int sec_type
;
8578 switch (elf_header
.e_machine
)
8581 sec_type
= SHT_ARM_EXIDX
;
8585 sec_type
= SHT_C6000_UNWIND
;
8589 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8590 elf_header
.e_machine
);
8594 if (string_table
== NULL
)
8597 memset (& aux
, 0, sizeof (aux
));
8600 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8602 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8604 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8606 strsec
= section_headers
+ sec
->sh_link
;
8608 /* PR binutils/17531 file: 011-12666-0.004. */
8609 if (aux
.strtab
!= NULL
)
8611 error (_("Multiple string tables found in file.\n"));
8614 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8615 1, strsec
->sh_size
, _("string table"));
8616 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8618 else if (sec
->sh_type
== sec_type
)
8623 printf (_("\nThere are no unwind sections in this file.\n"));
8625 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8627 if (sec
->sh_type
== sec_type
)
8629 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8630 printable_section_name (sec
),
8631 (unsigned long) sec
->sh_offset
,
8632 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8634 dump_arm_unwind (&aux
, sec
);
8641 free ((char *) aux
.strtab
);
8645 process_unwind (FILE * file
)
8647 struct unwind_handler
8650 void (* handler
)(FILE *);
8653 { EM_ARM
, arm_process_unwind
},
8654 { EM_IA_64
, ia64_process_unwind
},
8655 { EM_PARISC
, hppa_process_unwind
},
8656 { EM_TI_C6000
, arm_process_unwind
},
8664 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8665 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8667 handlers
[i
].handler (file
);
8671 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8672 get_machine_name (elf_header
.e_machine
));
8676 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8678 switch (entry
->d_tag
)
8681 if (entry
->d_un
.d_val
== 0)
8685 static const char * opts
[] =
8687 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8688 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8689 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8690 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8696 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8697 if (entry
->d_un
.d_val
& (1 << cnt
))
8699 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8705 case DT_MIPS_IVERSION
:
8706 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8707 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8711 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8712 /* Note: coded this way so that there is a single string for translation. */
8713 printf (_("<corrupt: %s>"), buf
);
8717 case DT_MIPS_TIME_STAMP
:
8721 time_t atime
= entry
->d_un
.d_val
;
8723 tmp
= gmtime (&atime
);
8724 /* PR 17531: file: 6accc532. */
8726 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8728 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8729 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8730 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8731 printf (_("Time Stamp: %s"), timebuf
);
8735 case DT_MIPS_RLD_VERSION
:
8736 case DT_MIPS_LOCAL_GOTNO
:
8737 case DT_MIPS_CONFLICTNO
:
8738 case DT_MIPS_LIBLISTNO
:
8739 case DT_MIPS_SYMTABNO
:
8740 case DT_MIPS_UNREFEXTNO
:
8741 case DT_MIPS_HIPAGENO
:
8742 case DT_MIPS_DELTA_CLASS_NO
:
8743 case DT_MIPS_DELTA_INSTANCE_NO
:
8744 case DT_MIPS_DELTA_RELOC_NO
:
8745 case DT_MIPS_DELTA_SYM_NO
:
8746 case DT_MIPS_DELTA_CLASSSYM_NO
:
8747 case DT_MIPS_COMPACT_SIZE
:
8748 print_vma (entry
->d_un
.d_val
, DEC
);
8752 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8758 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8760 switch (entry
->d_tag
)
8762 case DT_HP_DLD_FLAGS
:
8771 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8772 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8773 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8774 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8775 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8776 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8777 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8778 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8779 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8780 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8781 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8782 { DT_HP_GST
, "HP_GST" },
8783 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8784 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8785 { DT_HP_NODELETE
, "HP_NODELETE" },
8786 { DT_HP_GROUP
, "HP_GROUP" },
8787 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8791 bfd_vma val
= entry
->d_un
.d_val
;
8793 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8794 if (val
& flags
[cnt
].bit
)
8798 fputs (flags
[cnt
].str
, stdout
);
8800 val
^= flags
[cnt
].bit
;
8803 if (val
!= 0 || first
)
8807 print_vma (val
, HEX
);
8813 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8821 /* VMS vs Unix time offset and factor. */
8823 #define VMS_EPOCH_OFFSET 35067168000000000LL
8824 #define VMS_GRANULARITY_FACTOR 10000000
8826 /* Display a VMS time in a human readable format. */
8829 print_vms_time (bfd_int64_t vmstime
)
8834 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8835 tm
= gmtime (&unxtime
);
8836 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8837 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8838 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8843 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8845 switch (entry
->d_tag
)
8847 case DT_IA_64_PLT_RESERVE
:
8848 /* First 3 slots reserved. */
8849 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8851 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8854 case DT_IA_64_VMS_LINKTIME
:
8856 print_vms_time (entry
->d_un
.d_val
);
8860 case DT_IA_64_VMS_LNKFLAGS
:
8861 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8862 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8863 printf (" CALL_DEBUG");
8864 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8865 printf (" NOP0BUFS");
8866 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8867 printf (" P0IMAGE");
8868 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8869 printf (" MKTHREADS");
8870 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8871 printf (" UPCALLS");
8872 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8874 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8875 printf (" INITIALIZE");
8876 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8878 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8879 printf (" EXE_INIT");
8880 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8881 printf (" TBK_IN_IMG");
8882 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8883 printf (" DBG_IN_IMG");
8884 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8885 printf (" TBK_IN_DSF");
8886 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8887 printf (" DBG_IN_DSF");
8888 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8889 printf (" SIGNATURES");
8890 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8891 printf (" REL_SEG_OFF");
8895 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8902 get_32bit_dynamic_section (FILE * file
)
8904 Elf32_External_Dyn
* edyn
;
8905 Elf32_External_Dyn
* ext
;
8906 Elf_Internal_Dyn
* entry
;
8908 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8909 dynamic_size
, _("dynamic section"));
8913 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8914 might not have the luxury of section headers. Look for the DT_NULL
8915 terminator to determine the number of entries. */
8916 for (ext
= edyn
, dynamic_nent
= 0;
8917 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8921 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8925 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8927 if (dynamic_section
== NULL
)
8929 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8930 (unsigned long) dynamic_nent
);
8935 for (ext
= edyn
, entry
= dynamic_section
;
8936 entry
< dynamic_section
+ dynamic_nent
;
8939 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8940 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8949 get_64bit_dynamic_section (FILE * file
)
8951 Elf64_External_Dyn
* edyn
;
8952 Elf64_External_Dyn
* ext
;
8953 Elf_Internal_Dyn
* entry
;
8955 /* Read in the data. */
8956 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8957 dynamic_size
, _("dynamic section"));
8961 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8962 might not have the luxury of section headers. Look for the DT_NULL
8963 terminator to determine the number of entries. */
8964 for (ext
= edyn
, dynamic_nent
= 0;
8965 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8966 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8970 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8974 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8976 if (dynamic_section
== NULL
)
8978 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8979 (unsigned long) dynamic_nent
);
8984 /* Convert from external to internal formats. */
8985 for (ext
= edyn
, entry
= dynamic_section
;
8986 entry
< dynamic_section
+ dynamic_nent
;
8989 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8990 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8999 print_dynamic_flags (bfd_vma flags
)
9007 flag
= flags
& - flags
;
9017 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9018 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9019 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9020 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9021 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9022 default: fputs (_("unknown"), stdout
); break;
9028 /* Parse and display the contents of the dynamic section. */
9031 process_dynamic_section (FILE * file
)
9033 Elf_Internal_Dyn
* entry
;
9035 if (dynamic_size
== 0)
9038 printf (_("\nThere is no dynamic section in this file.\n"));
9045 if (! get_32bit_dynamic_section (file
))
9048 else if (! get_64bit_dynamic_section (file
))
9051 /* Find the appropriate symbol table. */
9052 if (dynamic_symbols
== NULL
)
9054 for (entry
= dynamic_section
;
9055 entry
< dynamic_section
+ dynamic_nent
;
9058 Elf_Internal_Shdr section
;
9060 if (entry
->d_tag
!= DT_SYMTAB
)
9063 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9065 /* Since we do not know how big the symbol table is,
9066 we default to reading in the entire file (!) and
9067 processing that. This is overkill, I know, but it
9069 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9071 if (archive_file_offset
!= 0)
9072 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9075 if (fseek (file
, 0, SEEK_END
))
9076 error (_("Unable to seek to end of file!\n"));
9078 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9082 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9084 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9085 section
.sh_name
= string_table_length
;
9087 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9088 if (num_dynamic_syms
< 1)
9090 error (_("Unable to determine the number of symbols to load\n"));
9096 /* Similarly find a string table. */
9097 if (dynamic_strings
== NULL
)
9099 for (entry
= dynamic_section
;
9100 entry
< dynamic_section
+ dynamic_nent
;
9103 unsigned long offset
;
9106 if (entry
->d_tag
!= DT_STRTAB
)
9109 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9111 /* Since we do not know how big the string table is,
9112 we default to reading in the entire file (!) and
9113 processing that. This is overkill, I know, but it
9116 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9118 if (archive_file_offset
!= 0)
9119 str_tab_len
= archive_file_size
- offset
;
9122 if (fseek (file
, 0, SEEK_END
))
9123 error (_("Unable to seek to end of file\n"));
9124 str_tab_len
= ftell (file
) - offset
;
9127 if (str_tab_len
< 1)
9130 (_("Unable to determine the length of the dynamic string table\n"));
9134 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9136 _("dynamic string table"));
9137 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9142 /* And find the syminfo section if available. */
9143 if (dynamic_syminfo
== NULL
)
9145 unsigned long syminsz
= 0;
9147 for (entry
= dynamic_section
;
9148 entry
< dynamic_section
+ dynamic_nent
;
9151 if (entry
->d_tag
== DT_SYMINENT
)
9153 /* Note: these braces are necessary to avoid a syntax
9154 error from the SunOS4 C compiler. */
9155 /* PR binutils/17531: A corrupt file can trigger this test.
9156 So do not use an assert, instead generate an error message. */
9157 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9158 error (_("Bad value (%d) for SYMINENT entry\n"),
9159 (int) entry
->d_un
.d_val
);
9161 else if (entry
->d_tag
== DT_SYMINSZ
)
9162 syminsz
= entry
->d_un
.d_val
;
9163 else if (entry
->d_tag
== DT_SYMINFO
)
9164 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9168 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9170 Elf_External_Syminfo
* extsyminfo
;
9171 Elf_External_Syminfo
* extsym
;
9172 Elf_Internal_Syminfo
* syminfo
;
9174 /* There is a syminfo section. Read the data. */
9175 extsyminfo
= (Elf_External_Syminfo
*)
9176 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9177 _("symbol information"));
9181 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9182 if (dynamic_syminfo
== NULL
)
9184 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9185 (unsigned long) syminsz
);
9189 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9190 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9191 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9192 ++syminfo
, ++extsym
)
9194 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9195 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9202 if (do_dynamic
&& dynamic_addr
)
9203 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9204 dynamic_addr
, (unsigned long) dynamic_nent
);
9206 printf (_(" Tag Type Name/Value\n"));
9208 for (entry
= dynamic_section
;
9209 entry
< dynamic_section
+ dynamic_nent
;
9217 print_vma (entry
->d_tag
, FULL_HEX
);
9218 dtype
= get_dynamic_type (entry
->d_tag
);
9219 printf (" (%s)%*s", dtype
,
9220 ((is_32bit_elf
? 27 : 19)
9221 - (int) strlen (dtype
)),
9225 switch (entry
->d_tag
)
9229 print_dynamic_flags (entry
->d_un
.d_val
);
9239 switch (entry
->d_tag
)
9242 printf (_("Auxiliary library"));
9246 printf (_("Filter library"));
9250 printf (_("Configuration file"));
9254 printf (_("Dependency audit library"));
9258 printf (_("Audit library"));
9262 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9263 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9267 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9276 printf (_("Flags:"));
9278 if (entry
->d_un
.d_val
== 0)
9279 printf (_(" None\n"));
9282 unsigned long int val
= entry
->d_un
.d_val
;
9284 if (val
& DTF_1_PARINIT
)
9286 printf (" PARINIT");
9287 val
^= DTF_1_PARINIT
;
9289 if (val
& DTF_1_CONFEXP
)
9291 printf (" CONFEXP");
9292 val
^= DTF_1_CONFEXP
;
9295 printf (" %lx", val
);
9304 printf (_("Flags:"));
9306 if (entry
->d_un
.d_val
== 0)
9307 printf (_(" None\n"));
9310 unsigned long int val
= entry
->d_un
.d_val
;
9312 if (val
& DF_P1_LAZYLOAD
)
9314 printf (" LAZYLOAD");
9315 val
^= DF_P1_LAZYLOAD
;
9317 if (val
& DF_P1_GROUPPERM
)
9319 printf (" GROUPPERM");
9320 val
^= DF_P1_GROUPPERM
;
9323 printf (" %lx", val
);
9332 printf (_("Flags:"));
9333 if (entry
->d_un
.d_val
== 0)
9334 printf (_(" None\n"));
9337 unsigned long int val
= entry
->d_un
.d_val
;
9344 if (val
& DF_1_GLOBAL
)
9349 if (val
& DF_1_GROUP
)
9354 if (val
& DF_1_NODELETE
)
9356 printf (" NODELETE");
9357 val
^= DF_1_NODELETE
;
9359 if (val
& DF_1_LOADFLTR
)
9361 printf (" LOADFLTR");
9362 val
^= DF_1_LOADFLTR
;
9364 if (val
& DF_1_INITFIRST
)
9366 printf (" INITFIRST");
9367 val
^= DF_1_INITFIRST
;
9369 if (val
& DF_1_NOOPEN
)
9374 if (val
& DF_1_ORIGIN
)
9379 if (val
& DF_1_DIRECT
)
9384 if (val
& DF_1_TRANS
)
9389 if (val
& DF_1_INTERPOSE
)
9391 printf (" INTERPOSE");
9392 val
^= DF_1_INTERPOSE
;
9394 if (val
& DF_1_NODEFLIB
)
9396 printf (" NODEFLIB");
9397 val
^= DF_1_NODEFLIB
;
9399 if (val
& DF_1_NODUMP
)
9404 if (val
& DF_1_CONFALT
)
9406 printf (" CONFALT");
9407 val
^= DF_1_CONFALT
;
9409 if (val
& DF_1_ENDFILTEE
)
9411 printf (" ENDFILTEE");
9412 val
^= DF_1_ENDFILTEE
;
9414 if (val
& DF_1_DISPRELDNE
)
9416 printf (" DISPRELDNE");
9417 val
^= DF_1_DISPRELDNE
;
9419 if (val
& DF_1_DISPRELPND
)
9421 printf (" DISPRELPND");
9422 val
^= DF_1_DISPRELPND
;
9424 if (val
& DF_1_NODIRECT
)
9426 printf (" NODIRECT");
9427 val
^= DF_1_NODIRECT
;
9429 if (val
& DF_1_IGNMULDEF
)
9431 printf (" IGNMULDEF");
9432 val
^= DF_1_IGNMULDEF
;
9434 if (val
& DF_1_NOKSYMS
)
9436 printf (" NOKSYMS");
9437 val
^= DF_1_NOKSYMS
;
9439 if (val
& DF_1_NOHDR
)
9444 if (val
& DF_1_EDITED
)
9449 if (val
& DF_1_NORELOC
)
9451 printf (" NORELOC");
9452 val
^= DF_1_NORELOC
;
9454 if (val
& DF_1_SYMINTPOSE
)
9456 printf (" SYMINTPOSE");
9457 val
^= DF_1_SYMINTPOSE
;
9459 if (val
& DF_1_GLOBAUDIT
)
9461 printf (" GLOBAUDIT");
9462 val
^= DF_1_GLOBAUDIT
;
9464 if (val
& DF_1_SINGLETON
)
9466 printf (" SINGLETON");
9467 val
^= DF_1_SINGLETON
;
9469 if (val
& DF_1_STUB
)
9480 printf (" %lx", val
);
9487 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9489 puts (get_dynamic_type (entry
->d_un
.d_val
));
9509 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9515 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9516 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9522 switch (entry
->d_tag
)
9525 printf (_("Shared library: [%s]"), name
);
9527 if (streq (name
, program_interpreter
))
9528 printf (_(" program interpreter"));
9532 printf (_("Library soname: [%s]"), name
);
9536 printf (_("Library rpath: [%s]"), name
);
9540 printf (_("Library runpath: [%s]"), name
);
9544 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9549 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9562 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9566 case DT_INIT_ARRAYSZ
:
9567 case DT_FINI_ARRAYSZ
:
9568 case DT_GNU_CONFLICTSZ
:
9569 case DT_GNU_LIBLISTSZ
:
9572 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9573 printf (_(" (bytes)\n"));
9583 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9596 if (entry
->d_tag
== DT_USED
9597 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9599 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9603 printf (_("Not needed object: [%s]\n"), name
);
9608 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9614 /* The value of this entry is ignored. */
9619 case DT_GNU_PRELINKED
:
9623 time_t atime
= entry
->d_un
.d_val
;
9625 tmp
= gmtime (&atime
);
9626 /* PR 17533 file: 041-1244816-0.004. */
9628 printf (_("<corrupt time val: %lx"),
9629 (unsigned long) atime
);
9631 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9632 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9633 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9639 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9642 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9648 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9649 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9654 switch (elf_header
.e_machine
)
9657 case EM_MIPS_RS3_LE
:
9658 dynamic_section_mips_val (entry
);
9661 dynamic_section_parisc_val (entry
);
9664 dynamic_section_ia64_val (entry
);
9667 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9679 get_ver_flags (unsigned int flags
)
9681 static char buff
[32];
9688 if (flags
& VER_FLG_BASE
)
9689 strcat (buff
, "BASE ");
9691 if (flags
& VER_FLG_WEAK
)
9693 if (flags
& VER_FLG_BASE
)
9694 strcat (buff
, "| ");
9696 strcat (buff
, "WEAK ");
9699 if (flags
& VER_FLG_INFO
)
9701 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9702 strcat (buff
, "| ");
9704 strcat (buff
, "INFO ");
9707 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9708 strcat (buff
, _("| <unknown>"));
9713 /* Display the contents of the version sections. */
9716 process_version_sections (FILE * file
)
9718 Elf_Internal_Shdr
* section
;
9725 for (i
= 0, section
= section_headers
;
9726 i
< elf_header
.e_shnum
;
9729 switch (section
->sh_type
)
9731 case SHT_GNU_verdef
:
9733 Elf_External_Verdef
* edefs
;
9740 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9741 printable_section_name (section
),
9744 printf (_(" Addr: 0x"));
9745 printf_vma (section
->sh_addr
);
9746 printf (_(" Offset: %#08lx Link: %u (%s)"),
9747 (unsigned long) section
->sh_offset
, section
->sh_link
,
9748 printable_section_name_from_index (section
->sh_link
));
9750 edefs
= (Elf_External_Verdef
*)
9751 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9752 _("version definition section"));
9755 endbuf
= (char *) edefs
+ section
->sh_size
;
9757 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9760 Elf_External_Verdef
* edef
;
9761 Elf_Internal_Verdef ent
;
9762 Elf_External_Verdaux
* eaux
;
9763 Elf_Internal_Verdaux aux
;
9767 /* Check for very large indicies. */
9768 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9771 vstart
= ((char *) edefs
) + idx
;
9772 if (vstart
+ sizeof (*edef
) > endbuf
)
9775 edef
= (Elf_External_Verdef
*) vstart
;
9777 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9778 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9779 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9780 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9781 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9782 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9783 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9785 printf (_(" %#06x: Rev: %d Flags: %s"),
9786 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9788 printf (_(" Index: %d Cnt: %d "),
9789 ent
.vd_ndx
, ent
.vd_cnt
);
9791 /* Check for overflow. */
9792 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9795 vstart
+= ent
.vd_aux
;
9797 eaux
= (Elf_External_Verdaux
*) vstart
;
9799 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9800 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9802 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9803 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9805 printf (_("Name index: %ld\n"), aux
.vda_name
);
9807 isum
= idx
+ ent
.vd_aux
;
9809 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9811 /* Check for overflow. */
9812 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9815 isum
+= aux
.vda_next
;
9816 vstart
+= aux
.vda_next
;
9818 eaux
= (Elf_External_Verdaux
*) vstart
;
9819 if (vstart
+ sizeof (*eaux
) > endbuf
)
9822 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9823 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9825 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9826 printf (_(" %#06x: Parent %d: %s\n"),
9827 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9829 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9830 isum
, j
, aux
.vda_name
);
9834 printf (_(" Version def aux past end of section\n"));
9836 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9837 if (idx
+ ent
.vd_next
<= idx
)
9843 if (cnt
< section
->sh_info
)
9844 printf (_(" Version definition past end of section\n"));
9850 case SHT_GNU_verneed
:
9852 Elf_External_Verneed
* eneed
;
9859 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9860 printable_section_name (section
), section
->sh_info
);
9862 printf (_(" Addr: 0x"));
9863 printf_vma (section
->sh_addr
);
9864 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9865 (unsigned long) section
->sh_offset
, section
->sh_link
,
9866 printable_section_name_from_index (section
->sh_link
));
9868 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9869 section
->sh_offset
, 1,
9871 _("Version Needs section"));
9874 endbuf
= (char *) eneed
+ section
->sh_size
;
9876 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9878 Elf_External_Verneed
* entry
;
9879 Elf_Internal_Verneed ent
;
9884 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9887 vstart
= ((char *) eneed
) + idx
;
9888 if (vstart
+ sizeof (*entry
) > endbuf
)
9891 entry
= (Elf_External_Verneed
*) vstart
;
9893 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9894 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9895 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9896 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9897 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9899 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9901 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9902 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9904 printf (_(" File: %lx"), ent
.vn_file
);
9906 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9908 /* Check for overflow. */
9909 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9911 vstart
+= ent
.vn_aux
;
9913 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9915 Elf_External_Vernaux
* eaux
;
9916 Elf_Internal_Vernaux aux
;
9918 if (vstart
+ sizeof (*eaux
) > endbuf
)
9920 eaux
= (Elf_External_Vernaux
*) vstart
;
9922 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9923 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9924 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9925 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9926 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9928 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9929 printf (_(" %#06x: Name: %s"),
9930 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9932 printf (_(" %#06x: Name index: %lx"),
9933 isum
, aux
.vna_name
);
9935 printf (_(" Flags: %s Version: %d\n"),
9936 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9938 /* Check for overflow. */
9939 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9940 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9942 warn (_("Invalid vna_next field of %lx\n"),
9947 isum
+= aux
.vna_next
;
9948 vstart
+= aux
.vna_next
;
9952 warn (_("Missing Version Needs auxillary information\n"));
9954 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9956 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9957 cnt
= section
->sh_info
;
9963 if (cnt
< section
->sh_info
)
9964 warn (_("Missing Version Needs information\n"));
9970 case SHT_GNU_versym
:
9972 Elf_Internal_Shdr
* link_section
;
9975 unsigned char * edata
;
9976 unsigned short * data
;
9978 Elf_Internal_Sym
* symbols
;
9979 Elf_Internal_Shdr
* string_sec
;
9980 unsigned long num_syms
;
9983 if (section
->sh_link
>= elf_header
.e_shnum
)
9986 link_section
= section_headers
+ section
->sh_link
;
9987 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9989 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9994 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9995 if (symbols
== NULL
)
9998 string_sec
= section_headers
+ link_section
->sh_link
;
10000 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10001 string_sec
->sh_size
,
10002 _("version string table"));
10009 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10010 printable_section_name (section
), (unsigned long) total
);
10012 printf (_(" Addr: "));
10013 printf_vma (section
->sh_addr
);
10014 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10015 (unsigned long) section
->sh_offset
, section
->sh_link
,
10016 printable_section_name (link_section
));
10018 off
= offset_from_vma (file
,
10019 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10020 total
* sizeof (short));
10021 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10023 _("version symbol data"));
10031 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10033 for (cnt
= total
; cnt
--;)
10034 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10039 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10043 char *invalid
= _("*invalid*");
10045 printf (" %03x:", cnt
);
10047 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10048 switch (data
[cnt
+ j
])
10051 fputs (_(" 0 (*local*) "), stdout
);
10055 fputs (_(" 1 (*global*) "), stdout
);
10059 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10060 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10062 /* If this index value is greater than the size of the symbols
10063 array, break to avoid an out-of-bounds read. */
10064 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10066 warn (_("invalid index into symbol array\n"));
10071 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10073 Elf_Internal_Verneed ivn
;
10074 unsigned long offset
;
10076 offset
= offset_from_vma
10077 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10078 sizeof (Elf_External_Verneed
));
10082 Elf_Internal_Vernaux ivna
;
10083 Elf_External_Verneed evn
;
10084 Elf_External_Vernaux evna
;
10085 unsigned long a_off
;
10087 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10088 _("version need")) == NULL
)
10091 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10092 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10094 a_off
= offset
+ ivn
.vn_aux
;
10098 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10099 1, _("version need aux (2)")) == NULL
)
10102 ivna
.vna_other
= 0;
10106 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10107 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10110 a_off
+= ivna
.vna_next
;
10112 while (ivna
.vna_other
!= data
[cnt
+ j
]
10113 && ivna
.vna_next
!= 0);
10115 if (ivna
.vna_other
== data
[cnt
+ j
])
10117 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10119 if (ivna
.vna_name
>= string_sec
->sh_size
)
10122 name
= strtab
+ ivna
.vna_name
;
10126 offset
+= ivn
.vn_next
;
10128 while (ivn
.vn_next
);
10131 if (data
[cnt
+ j
] != 0x8001
10132 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10134 Elf_Internal_Verdef ivd
;
10135 Elf_External_Verdef evd
;
10136 unsigned long offset
;
10138 offset
= offset_from_vma
10139 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10144 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10145 _("version def")) == NULL
)
10148 /* PR 17531: file: 046-1082287-0.004. */
10149 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10154 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10155 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10158 offset
+= ivd
.vd_next
;
10160 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10161 && ivd
.vd_next
!= 0);
10163 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10165 Elf_External_Verdaux evda
;
10166 Elf_Internal_Verdaux ivda
;
10168 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10170 if (get_data (&evda
, file
,
10171 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10173 _("version def aux")) == NULL
)
10176 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10178 if (ivda
.vda_name
>= string_sec
->sh_size
)
10180 else if (name
!= NULL
&& name
!= invalid
)
10181 name
= _("*both*");
10183 name
= strtab
+ ivda
.vda_name
;
10187 nn
+= printf ("(%s%-*s",
10189 12 - (int) strlen (name
),
10193 printf ("%*c", 18 - nn
, ' ');
10211 printf (_("\nNo version information found in this file.\n"));
10216 static const char *
10217 get_symbol_binding (unsigned int binding
)
10219 static char buff
[32];
10223 case STB_LOCAL
: return "LOCAL";
10224 case STB_GLOBAL
: return "GLOBAL";
10225 case STB_WEAK
: return "WEAK";
10227 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10228 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10230 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10232 if (binding
== STB_GNU_UNIQUE
10233 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10234 /* GNU is still using the default value 0. */
10235 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10237 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10240 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10245 static const char *
10246 get_symbol_type (unsigned int type
)
10248 static char buff
[32];
10252 case STT_NOTYPE
: return "NOTYPE";
10253 case STT_OBJECT
: return "OBJECT";
10254 case STT_FUNC
: return "FUNC";
10255 case STT_SECTION
: return "SECTION";
10256 case STT_FILE
: return "FILE";
10257 case STT_COMMON
: return "COMMON";
10258 case STT_TLS
: return "TLS";
10259 case STT_RELC
: return "RELC";
10260 case STT_SRELC
: return "SRELC";
10262 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10264 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10265 return "THUMB_FUNC";
10267 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10270 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10271 return "PARISC_MILLI";
10273 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10275 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10277 if (elf_header
.e_machine
== EM_PARISC
)
10279 if (type
== STT_HP_OPAQUE
)
10280 return "HP_OPAQUE";
10281 if (type
== STT_HP_STUB
)
10285 if (type
== STT_GNU_IFUNC
10286 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10287 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10288 /* GNU is still using the default value 0. */
10289 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10292 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10295 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10300 static const char *
10301 get_symbol_visibility (unsigned int visibility
)
10303 switch (visibility
)
10305 case STV_DEFAULT
: return "DEFAULT";
10306 case STV_INTERNAL
: return "INTERNAL";
10307 case STV_HIDDEN
: return "HIDDEN";
10308 case STV_PROTECTED
: return "PROTECTED";
10310 error (_("Unrecognized visibility value: %u"), visibility
);
10311 return _("<unknown>");
10315 static const char *
10316 get_solaris_symbol_visibility (unsigned int visibility
)
10318 switch (visibility
)
10320 case 4: return "EXPORTED";
10321 case 5: return "SINGLETON";
10322 case 6: return "ELIMINATE";
10323 default: return get_symbol_visibility (visibility
);
10327 static const char *
10328 get_mips_symbol_other (unsigned int other
)
10338 case STO_MICROMIPS
:
10339 return "MICROMIPS";
10340 case STO_MICROMIPS
| STO_MIPS_PIC
:
10341 return "MICROMIPS, MIPS PIC";
10349 static const char *
10350 get_ia64_symbol_other (unsigned int other
)
10352 if (is_ia64_vms ())
10354 static char res
[32];
10358 /* Function types is for images and .STB files only. */
10359 switch (elf_header
.e_type
)
10363 switch (VMS_ST_FUNC_TYPE (other
))
10365 case VMS_SFT_CODE_ADDR
:
10366 strcat (res
, " CA");
10368 case VMS_SFT_SYMV_IDX
:
10369 strcat (res
, " VEC");
10372 strcat (res
, " FD");
10374 case VMS_SFT_RESERVE
:
10375 strcat (res
, " RSV");
10378 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10379 VMS_ST_FUNC_TYPE (other
));
10380 strcat (res
, " <unknown>");
10387 switch (VMS_ST_LINKAGE (other
))
10389 case VMS_STL_IGNORE
:
10390 strcat (res
, " IGN");
10392 case VMS_STL_RESERVE
:
10393 strcat (res
, " RSV");
10396 strcat (res
, " STD");
10399 strcat (res
, " LNK");
10402 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10403 VMS_ST_LINKAGE (other
));
10404 strcat (res
, " <unknown>");
10416 static const char *
10417 get_ppc64_symbol_other (unsigned int other
)
10419 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10421 static char buf
[32];
10422 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10423 PPC64_LOCAL_ENTRY_OFFSET (other
));
10429 static const char *
10430 get_symbol_other (unsigned int other
)
10432 const char * result
= NULL
;
10433 static char buff
[32];
10438 switch (elf_header
.e_machine
)
10441 result
= get_mips_symbol_other (other
);
10444 result
= get_ia64_symbol_other (other
);
10447 result
= get_ppc64_symbol_other (other
);
10457 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10461 static const char *
10462 get_symbol_index_type (unsigned int type
)
10464 static char buff
[32];
10468 case SHN_UNDEF
: return "UND";
10469 case SHN_ABS
: return "ABS";
10470 case SHN_COMMON
: return "COM";
10472 if (type
== SHN_IA_64_ANSI_COMMON
10473 && elf_header
.e_machine
== EM_IA_64
10474 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10476 else if ((elf_header
.e_machine
== EM_X86_64
10477 || elf_header
.e_machine
== EM_L1OM
10478 || elf_header
.e_machine
== EM_K1OM
)
10479 && type
== SHN_X86_64_LCOMMON
)
10480 return "LARGE_COM";
10481 else if ((type
== SHN_MIPS_SCOMMON
10482 && elf_header
.e_machine
== EM_MIPS
)
10483 || (type
== SHN_TIC6X_SCOMMON
10484 && elf_header
.e_machine
== EM_TI_C6000
))
10486 else if (type
== SHN_MIPS_SUNDEFINED
10487 && elf_header
.e_machine
== EM_MIPS
)
10489 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10490 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10491 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10492 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10493 else if (type
>= SHN_LORESERVE
)
10494 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10495 else if (type
>= elf_header
.e_shnum
)
10496 sprintf (buff
, _("bad section index[%3d]"), type
);
10498 sprintf (buff
, "%3d", type
);
10506 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10508 unsigned char * e_data
;
10511 /* If the size_t type is smaller than the bfd_size_type, eg because
10512 you are building a 32-bit tool on a 64-bit host, then make sure
10513 that when (number) is cast to (size_t) no information is lost. */
10514 if (sizeof (size_t) < sizeof (bfd_size_type
)
10515 && (bfd_size_type
) ((size_t) number
) != number
)
10517 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10518 " elements of size %u\n"),
10523 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10524 attempting to allocate memory when the read is bound to fail. */
10525 if (ent_size
* number
> current_file_size
)
10527 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10532 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10533 if (e_data
== NULL
)
10535 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10540 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10542 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10543 number
* ent_size
);
10548 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10549 if (i_data
== NULL
)
10551 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10552 " dynamic entries\n"),
10559 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10567 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10569 Elf_Internal_Sym
* psym
;
10572 n
= print_vma (si
, DEC_5
);
10574 fputs (&" "[n
], stdout
);
10575 printf (" %3lu: ", hn
);
10577 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10579 printf (_("<No info available for dynamic symbol number %lu>\n"),
10580 (unsigned long) si
);
10584 psym
= dynamic_symbols
+ si
;
10585 print_vma (psym
->st_value
, LONG_HEX
);
10587 print_vma (psym
->st_size
, DEC_5
);
10589 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10590 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10592 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10593 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10596 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10598 printf (" %-7s", get_symbol_visibility (vis
));
10599 /* Check to see if any other bits in the st_other field are set.
10600 Note - displaying this information disrupts the layout of the
10601 table being generated, but for the moment this case is very
10603 if (psym
->st_other
^ vis
)
10604 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10607 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10608 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10609 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10611 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10615 static const char *
10616 get_symbol_version_string (FILE *file
, int is_dynsym
,
10617 const char *strtab
,
10618 unsigned long int strtab_size
,
10619 unsigned int si
, Elf_Internal_Sym
*psym
,
10620 enum versioned_symbol_info
*sym_info
,
10621 unsigned short *vna_other
)
10623 unsigned char data
[2];
10624 unsigned short vers_data
;
10625 unsigned long offset
;
10628 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10631 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10632 sizeof data
+ si
* sizeof (vers_data
));
10634 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10635 sizeof (data
), 1, _("version data")) == NULL
)
10638 vers_data
= byte_get (data
, 2);
10640 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10643 /* Usually we'd only see verdef for defined symbols, and verneed for
10644 undefined symbols. However, symbols defined by the linker in
10645 .dynbss for variables copied from a shared library in order to
10646 avoid text relocations are defined yet have verneed. We could
10647 use a heuristic to detect the special case, for example, check
10648 for verneed first on symbols defined in SHT_NOBITS sections, but
10649 it is simpler and more reliable to just look for both verdef and
10650 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10652 if (psym
->st_shndx
!= SHN_UNDEF
10653 && vers_data
!= 0x8001
10654 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10656 Elf_Internal_Verdef ivd
;
10657 Elf_Internal_Verdaux ivda
;
10658 Elf_External_Verdaux evda
;
10661 off
= offset_from_vma (file
,
10662 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10663 sizeof (Elf_External_Verdef
));
10667 Elf_External_Verdef evd
;
10669 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10670 _("version def")) == NULL
)
10678 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10679 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10680 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10683 off
+= ivd
.vd_next
;
10685 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10687 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10689 off
-= ivd
.vd_next
;
10692 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10693 _("version def aux")) != NULL
)
10695 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10697 if (psym
->st_name
!= ivda
.vda_name
)
10699 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10700 ? symbol_hidden
: symbol_public
);
10701 return (ivda
.vda_name
< strtab_size
10702 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10708 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10710 Elf_External_Verneed evn
;
10711 Elf_Internal_Verneed ivn
;
10712 Elf_Internal_Vernaux ivna
;
10714 offset
= offset_from_vma (file
,
10715 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10719 unsigned long vna_off
;
10721 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10722 _("version need")) == NULL
)
10725 ivna
.vna_other
= 0;
10730 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10731 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10733 vna_off
= offset
+ ivn
.vn_aux
;
10737 Elf_External_Vernaux evna
;
10739 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10740 _("version need aux (3)")) == NULL
)
10743 ivna
.vna_other
= 0;
10748 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10749 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10750 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10753 vna_off
+= ivna
.vna_next
;
10755 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10757 if (ivna
.vna_other
== vers_data
)
10760 offset
+= ivn
.vn_next
;
10762 while (ivn
.vn_next
!= 0);
10764 if (ivna
.vna_other
== vers_data
)
10766 *sym_info
= symbol_undefined
;
10767 *vna_other
= ivna
.vna_other
;
10768 return (ivna
.vna_name
< strtab_size
10769 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
10775 /* Dump the symbol table. */
10777 process_symbol_table (FILE * file
)
10779 Elf_Internal_Shdr
* section
;
10780 bfd_size_type nbuckets
= 0;
10781 bfd_size_type nchains
= 0;
10782 bfd_vma
* buckets
= NULL
;
10783 bfd_vma
* chains
= NULL
;
10784 bfd_vma ngnubuckets
= 0;
10785 bfd_vma
* gnubuckets
= NULL
;
10786 bfd_vma
* gnuchains
= NULL
;
10787 bfd_vma gnusymidx
= 0;
10788 bfd_size_type ngnuchains
= 0;
10790 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10793 if (dynamic_info
[DT_HASH
]
10795 || (do_using_dynamic
10797 && dynamic_strings
!= NULL
)))
10799 unsigned char nb
[8];
10800 unsigned char nc
[8];
10801 unsigned int hash_ent_size
= 4;
10803 if ((elf_header
.e_machine
== EM_ALPHA
10804 || elf_header
.e_machine
== EM_S390
10805 || elf_header
.e_machine
== EM_S390_OLD
)
10806 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10810 (archive_file_offset
10811 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10812 sizeof nb
+ sizeof nc
)),
10815 error (_("Unable to seek to start of dynamic information\n"));
10819 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10821 error (_("Failed to read in number of buckets\n"));
10825 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10827 error (_("Failed to read in number of chains\n"));
10831 nbuckets
= byte_get (nb
, hash_ent_size
);
10832 nchains
= byte_get (nc
, hash_ent_size
);
10834 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10835 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10838 if (buckets
== NULL
|| chains
== NULL
)
10840 if (do_using_dynamic
)
10851 if (dynamic_info_DT_GNU_HASH
10853 || (do_using_dynamic
10855 && dynamic_strings
!= NULL
)))
10857 unsigned char nb
[16];
10858 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10859 bfd_vma buckets_vma
;
10862 (archive_file_offset
10863 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10867 error (_("Unable to seek to start of dynamic information\n"));
10871 if (fread (nb
, 16, 1, file
) != 1)
10873 error (_("Failed to read in number of buckets\n"));
10877 ngnubuckets
= byte_get (nb
, 4);
10878 gnusymidx
= byte_get (nb
+ 4, 4);
10879 bitmaskwords
= byte_get (nb
+ 8, 4);
10880 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10882 buckets_vma
+= bitmaskwords
* 4;
10884 buckets_vma
+= bitmaskwords
* 8;
10887 (archive_file_offset
10888 + offset_from_vma (file
, buckets_vma
, 4)),
10891 error (_("Unable to seek to start of dynamic information\n"));
10895 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10897 if (gnubuckets
== NULL
)
10900 for (i
= 0; i
< ngnubuckets
; i
++)
10901 if (gnubuckets
[i
] != 0)
10903 if (gnubuckets
[i
] < gnusymidx
)
10906 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10907 maxchain
= gnubuckets
[i
];
10910 if (maxchain
== 0xffffffff)
10913 maxchain
-= gnusymidx
;
10916 (archive_file_offset
10917 + offset_from_vma (file
, buckets_vma
10918 + 4 * (ngnubuckets
+ maxchain
), 4)),
10921 error (_("Unable to seek to start of dynamic information\n"));
10927 if (fread (nb
, 4, 1, file
) != 1)
10929 error (_("Failed to determine last chain length\n"));
10933 if (maxchain
+ 1 == 0)
10938 while ((byte_get (nb
, 4) & 1) == 0);
10941 (archive_file_offset
10942 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10945 error (_("Unable to seek to start of dynamic information\n"));
10949 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10950 ngnuchains
= maxchain
;
10953 if (gnuchains
== NULL
)
10958 if (do_using_dynamic
)
10963 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10965 && do_using_dynamic
10966 && dynamic_strings
!= NULL
10967 && dynamic_symbols
!= NULL
)
10971 if (dynamic_info
[DT_HASH
])
10975 printf (_("\nSymbol table for image:\n"));
10977 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10979 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10981 for (hn
= 0; hn
< nbuckets
; hn
++)
10986 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10987 print_dynamic_symbol (si
, hn
);
10991 if (dynamic_info_DT_GNU_HASH
)
10993 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10995 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10997 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10999 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11000 if (gnubuckets
[hn
] != 0)
11002 bfd_vma si
= gnubuckets
[hn
];
11003 bfd_vma off
= si
- gnusymidx
;
11007 print_dynamic_symbol (si
, hn
);
11010 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11014 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11015 && section_headers
!= NULL
)
11019 for (i
= 0, section
= section_headers
;
11020 i
< elf_header
.e_shnum
;
11024 char * strtab
= NULL
;
11025 unsigned long int strtab_size
= 0;
11026 Elf_Internal_Sym
* symtab
;
11027 Elf_Internal_Sym
* psym
;
11028 unsigned long num_syms
;
11030 if ((section
->sh_type
!= SHT_SYMTAB
11031 && section
->sh_type
!= SHT_DYNSYM
)
11033 && section
->sh_type
== SHT_SYMTAB
))
11036 if (section
->sh_entsize
== 0)
11038 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11039 printable_section_name (section
));
11043 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11044 printable_section_name (section
),
11045 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11048 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11050 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11052 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11053 if (symtab
== NULL
)
11056 if (section
->sh_link
== elf_header
.e_shstrndx
)
11058 strtab
= string_table
;
11059 strtab_size
= string_table_length
;
11061 else if (section
->sh_link
< elf_header
.e_shnum
)
11063 Elf_Internal_Shdr
* string_sec
;
11065 string_sec
= section_headers
+ section
->sh_link
;
11067 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11068 1, string_sec
->sh_size
,
11069 _("string table"));
11070 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11073 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11075 const char *version_string
;
11076 enum versioned_symbol_info sym_info
;
11077 unsigned short vna_other
;
11079 printf ("%6d: ", si
);
11080 print_vma (psym
->st_value
, LONG_HEX
);
11082 print_vma (psym
->st_size
, DEC_5
);
11083 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11084 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11085 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11086 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11089 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11091 printf (" %-7s", get_symbol_visibility (vis
));
11092 /* Check to see if any other bits in the st_other field are set.
11093 Note - displaying this information disrupts the layout of the
11094 table being generated, but for the moment this case is very rare. */
11095 if (psym
->st_other
^ vis
)
11096 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11098 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11099 print_symbol (25, psym
->st_name
< strtab_size
11100 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11103 = get_symbol_version_string (file
,
11104 section
->sh_type
== SHT_DYNSYM
,
11105 strtab
, strtab_size
, si
,
11106 psym
, &sym_info
, &vna_other
);
11107 if (version_string
)
11109 if (sym_info
== symbol_undefined
)
11110 printf ("@%s (%d)", version_string
, vna_other
);
11112 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11120 if (strtab
!= string_table
)
11126 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11128 if (do_histogram
&& buckets
!= NULL
)
11130 unsigned long * lengths
;
11131 unsigned long * counts
;
11134 unsigned long maxlength
= 0;
11135 unsigned long nzero_counts
= 0;
11136 unsigned long nsyms
= 0;
11137 unsigned long chained
;
11139 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11140 (unsigned long) nbuckets
);
11142 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11143 if (lengths
== NULL
)
11145 error (_("Out of memory allocating space for histogram buckets\n"));
11149 printf (_(" Length Number %% of total Coverage\n"));
11150 for (hn
= 0; hn
< nbuckets
; ++hn
)
11152 for (si
= buckets
[hn
], chained
= 0;
11153 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11154 si
= chains
[si
], ++chained
)
11157 if (maxlength
< ++lengths
[hn
])
11161 /* PR binutils/17531: A corrupt binary could contain broken
11162 histogram data. Do not go into an infinite loop trying
11164 if (chained
> nchains
)
11166 error (_("histogram chain is corrupt\n"));
11171 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11172 if (counts
== NULL
)
11175 error (_("Out of memory allocating space for histogram counts\n"));
11179 for (hn
= 0; hn
< nbuckets
; ++hn
)
11180 ++counts
[lengths
[hn
]];
11185 printf (" 0 %-10lu (%5.1f%%)\n",
11186 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11187 for (i
= 1; i
<= maxlength
; ++i
)
11189 nzero_counts
+= counts
[i
] * i
;
11190 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11191 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11192 (nzero_counts
* 100.0) / nsyms
);
11200 if (buckets
!= NULL
)
11206 if (do_histogram
&& gnubuckets
!= NULL
)
11208 unsigned long * lengths
;
11209 unsigned long * counts
;
11211 unsigned long maxlength
= 0;
11212 unsigned long nzero_counts
= 0;
11213 unsigned long nsyms
= 0;
11215 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11216 (unsigned long) ngnubuckets
);
11218 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11219 if (lengths
== NULL
)
11221 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11225 printf (_(" Length Number %% of total Coverage\n"));
11227 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11228 if (gnubuckets
[hn
] != 0)
11230 bfd_vma off
, length
= 1;
11232 for (off
= gnubuckets
[hn
] - gnusymidx
;
11233 /* PR 17531 file: 010-77222-0.004. */
11234 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11237 lengths
[hn
] = length
;
11238 if (length
> maxlength
)
11239 maxlength
= length
;
11243 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11244 if (counts
== NULL
)
11247 error (_("Out of memory allocating space for gnu histogram counts\n"));
11251 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11252 ++counts
[lengths
[hn
]];
11254 if (ngnubuckets
> 0)
11257 printf (" 0 %-10lu (%5.1f%%)\n",
11258 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11259 for (j
= 1; j
<= maxlength
; ++j
)
11261 nzero_counts
+= counts
[j
] * j
;
11262 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11263 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11264 (nzero_counts
* 100.0) / nsyms
);
11278 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11282 if (dynamic_syminfo
== NULL
11284 /* No syminfo, this is ok. */
11287 /* There better should be a dynamic symbol section. */
11288 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11292 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11293 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11295 printf (_(" Num: Name BoundTo Flags\n"));
11296 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11298 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11300 printf ("%4d: ", i
);
11301 if (i
>= num_dynamic_syms
)
11302 printf (_("<corrupt index>"));
11303 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11304 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11306 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11309 switch (dynamic_syminfo
[i
].si_boundto
)
11311 case SYMINFO_BT_SELF
:
11312 fputs ("SELF ", stdout
);
11314 case SYMINFO_BT_PARENT
:
11315 fputs ("PARENT ", stdout
);
11318 if (dynamic_syminfo
[i
].si_boundto
> 0
11319 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11320 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11322 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11326 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11330 if (flags
& SYMINFO_FLG_DIRECT
)
11331 printf (" DIRECT");
11332 if (flags
& SYMINFO_FLG_PASSTHRU
)
11333 printf (" PASSTHRU");
11334 if (flags
& SYMINFO_FLG_COPY
)
11336 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11337 printf (" LAZYLOAD");
11345 /* Check to see if the given reloc needs to be handled in a target specific
11346 manner. If so then process the reloc and return TRUE otherwise return
11350 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11351 unsigned char * start
,
11352 Elf_Internal_Sym
* symtab
)
11354 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11356 switch (elf_header
.e_machine
)
11359 case EM_MSP430_OLD
:
11361 static Elf_Internal_Sym
* saved_sym
= NULL
;
11363 switch (reloc_type
)
11365 case 10: /* R_MSP430_SYM_DIFF */
11366 if (uses_msp430x_relocs ())
11368 case 21: /* R_MSP430X_SYM_DIFF */
11369 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11372 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11373 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11374 goto handle_sym_diff
;
11376 case 5: /* R_MSP430_16_BYTE */
11377 case 9: /* R_MSP430_8 */
11378 if (uses_msp430x_relocs ())
11380 goto handle_sym_diff
;
11382 case 2: /* R_MSP430_ABS16 */
11383 case 15: /* R_MSP430X_ABS16 */
11384 if (! uses_msp430x_relocs ())
11386 goto handle_sym_diff
;
11389 if (saved_sym
!= NULL
)
11393 value
= reloc
->r_addend
11394 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11395 - saved_sym
->st_value
);
11397 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11405 if (saved_sym
!= NULL
)
11406 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11413 case EM_CYGNUS_MN10300
:
11415 static Elf_Internal_Sym
* saved_sym
= NULL
;
11417 switch (reloc_type
)
11419 case 34: /* R_MN10300_ALIGN */
11421 case 33: /* R_MN10300_SYM_DIFF */
11422 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11424 case 1: /* R_MN10300_32 */
11425 case 2: /* R_MN10300_16 */
11426 if (saved_sym
!= NULL
)
11430 value
= reloc
->r_addend
11431 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11432 - saved_sym
->st_value
);
11434 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11441 if (saved_sym
!= NULL
)
11442 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11450 static bfd_vma saved_sym1
= 0;
11451 static bfd_vma saved_sym2
= 0;
11452 static bfd_vma value
;
11454 switch (reloc_type
)
11456 case 0x80: /* R_RL78_SYM. */
11457 saved_sym1
= saved_sym2
;
11458 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11459 saved_sym2
+= reloc
->r_addend
;
11462 case 0x83: /* R_RL78_OPsub. */
11463 value
= saved_sym1
- saved_sym2
;
11464 saved_sym2
= saved_sym1
= 0;
11468 case 0x41: /* R_RL78_ABS32. */
11469 byte_put (start
+ reloc
->r_offset
, value
, 4);
11473 case 0x43: /* R_RL78_ABS16. */
11474 byte_put (start
+ reloc
->r_offset
, value
, 2);
11488 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11489 DWARF debug sections. This is a target specific test. Note - we do not
11490 go through the whole including-target-headers-multiple-times route, (as
11491 we have already done with <elf/h8.h>) because this would become very
11492 messy and even then this function would have to contain target specific
11493 information (the names of the relocs instead of their numeric values).
11494 FIXME: This is not the correct way to solve this problem. The proper way
11495 is to have target specific reloc sizing and typing functions created by
11496 the reloc-macros.h header, in the same way that it already creates the
11497 reloc naming functions. */
11500 is_32bit_abs_reloc (unsigned int reloc_type
)
11502 /* Please keep this table alpha-sorted for ease of visual lookup. */
11503 switch (elf_header
.e_machine
)
11507 return reloc_type
== 1; /* R_386_32. */
11509 return reloc_type
== 1; /* R_68K_32. */
11511 return reloc_type
== 1; /* R_860_32. */
11513 return reloc_type
== 2; /* R_960_32. */
11515 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11516 case EM_ADAPTEVA_EPIPHANY
:
11517 return reloc_type
== 3;
11519 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11521 return reloc_type
== 1; /* R_ARC_32. */
11522 case EM_ARC_COMPACT
:
11523 case EM_ARC_COMPACT2
:
11524 return reloc_type
== 4; /* R_ARC_32. */
11526 return reloc_type
== 2; /* R_ARM_ABS32 */
11529 return reloc_type
== 1;
11531 return reloc_type
== 0x12; /* R_byte4_data. */
11533 return reloc_type
== 3; /* R_CRIS_32. */
11535 return reloc_type
== 3; /* R_CR16_NUM32. */
11537 return reloc_type
== 15; /* R_CRX_NUM32. */
11538 case EM_CYGNUS_FRV
:
11539 return reloc_type
== 1;
11540 case EM_CYGNUS_D10V
:
11542 return reloc_type
== 6; /* R_D10V_32. */
11543 case EM_CYGNUS_D30V
:
11545 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11547 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11548 case EM_CYGNUS_FR30
:
11550 return reloc_type
== 3; /* R_FR30_32. */
11552 return reloc_type
== 1; /* R_FT32_32. */
11556 return reloc_type
== 1; /* R_H8_DIR32. */
11558 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11559 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11562 return reloc_type
== 2; /* R_IP2K_32. */
11564 return reloc_type
== 2; /* R_IQ2000_32. */
11565 case EM_LATTICEMICO32
:
11566 return reloc_type
== 3; /* R_LM32_32. */
11569 return reloc_type
== 3; /* R_M32C_32. */
11571 return reloc_type
== 34; /* R_M32R_32_RELA. */
11574 return reloc_type
== 6; /* R_M68HC11_32. */
11576 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11577 case EM_CYGNUS_MEP
:
11578 return reloc_type
== 4; /* R_MEP_32. */
11580 return reloc_type
== 2; /* R_METAG_ADDR32. */
11581 case EM_MICROBLAZE
:
11582 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11584 return reloc_type
== 2; /* R_MIPS_32. */
11586 return reloc_type
== 4; /* R_MMIX_32. */
11587 case EM_CYGNUS_MN10200
:
11589 return reloc_type
== 1; /* R_MN10200_32. */
11590 case EM_CYGNUS_MN10300
:
11592 return reloc_type
== 1; /* R_MN10300_32. */
11594 return reloc_type
== 1; /* R_MOXIE_32. */
11595 case EM_MSP430_OLD
:
11597 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11599 return reloc_type
== 2; /* R_MT_32. */
11601 return reloc_type
== 20; /* R_NDS32_RELA. */
11602 case EM_ALTERA_NIOS2
:
11603 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11605 return reloc_type
== 1; /* R_NIOS_32. */
11607 return reloc_type
== 1; /* R_OR1K_32. */
11609 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11610 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11613 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11615 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11617 return reloc_type
== 1; /* R_PPC_ADDR32. */
11619 return reloc_type
== 1; /* R_RL78_DIR32. */
11621 return reloc_type
== 1; /* R_RX_DIR32. */
11623 return reloc_type
== 1; /* R_I370_ADDR31. */
11626 return reloc_type
== 4; /* R_S390_32. */
11628 return reloc_type
== 8; /* R_SCORE_ABS32. */
11630 return reloc_type
== 1; /* R_SH_DIR32. */
11631 case EM_SPARC32PLUS
:
11634 return reloc_type
== 3 /* R_SPARC_32. */
11635 || reloc_type
== 23; /* R_SPARC_UA32. */
11637 return reloc_type
== 6; /* R_SPU_ADDR32 */
11639 return reloc_type
== 1; /* R_C6000_ABS32. */
11641 return reloc_type
== 2; /* R_TILEGX_32. */
11643 return reloc_type
== 1; /* R_TILEPRO_32. */
11644 case EM_CYGNUS_V850
:
11646 return reloc_type
== 6; /* R_V850_ABS32. */
11648 return reloc_type
== 0x33; /* R_V810_WORD. */
11650 return reloc_type
== 1; /* R_VAX_32. */
11652 return reloc_type
== 3; /* R_VISIUM_32. */
11656 return reloc_type
== 10; /* R_X86_64_32. */
11659 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11661 return reloc_type
== 4; /* R_XGATE_32. */
11663 return reloc_type
== 1; /* R_XSTROMY16_32. */
11664 case EM_XTENSA_OLD
:
11666 return reloc_type
== 1; /* R_XTENSA_32. */
11669 static unsigned int prev_warn
= 0;
11671 /* Avoid repeating the same warning multiple times. */
11672 if (prev_warn
!= elf_header
.e_machine
)
11673 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11674 elf_header
.e_machine
);
11675 prev_warn
= elf_header
.e_machine
;
11681 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11682 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11685 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11687 switch (elf_header
.e_machine
)
11688 /* Please keep this table alpha-sorted for ease of visual lookup. */
11692 return reloc_type
== 2; /* R_386_PC32. */
11694 return reloc_type
== 4; /* R_68K_PC32. */
11696 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11697 case EM_ADAPTEVA_EPIPHANY
:
11698 return reloc_type
== 6;
11700 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11701 case EM_ARC_COMPACT
:
11702 case EM_ARC_COMPACT2
:
11703 return reloc_type
== 49; /* R_ARC_32_PCREL. */
11705 return reloc_type
== 3; /* R_ARM_REL32 */
11708 return reloc_type
== 36; /* R_AVR_32_PCREL. */
11709 case EM_MICROBLAZE
:
11710 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11712 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11714 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11716 return reloc_type
== 26; /* R_PPC_REL32. */
11718 return reloc_type
== 26; /* R_PPC64_REL32. */
11721 return reloc_type
== 5; /* R_390_PC32. */
11723 return reloc_type
== 2; /* R_SH_REL32. */
11724 case EM_SPARC32PLUS
:
11727 return reloc_type
== 6; /* R_SPARC_DISP32. */
11729 return reloc_type
== 13; /* R_SPU_REL32. */
11731 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11733 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11735 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11739 return reloc_type
== 2; /* R_X86_64_PC32. */
11740 case EM_XTENSA_OLD
:
11742 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11744 /* Do not abort or issue an error message here. Not all targets use
11745 pc-relative 32-bit relocs in their DWARF debug information and we
11746 have already tested for target coverage in is_32bit_abs_reloc. A
11747 more helpful warning message will be generated by apply_relocations
11748 anyway, so just return. */
11753 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11754 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11757 is_64bit_abs_reloc (unsigned int reloc_type
)
11759 switch (elf_header
.e_machine
)
11762 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11764 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11766 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11768 return reloc_type
== 80; /* R_PARISC_DIR64. */
11770 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11771 case EM_SPARC32PLUS
:
11774 return reloc_type
== 54; /* R_SPARC_UA64. */
11778 return reloc_type
== 1; /* R_X86_64_64. */
11781 return reloc_type
== 22; /* R_S390_64. */
11783 return reloc_type
== 1; /* R_TILEGX_64. */
11785 return reloc_type
== 18; /* R_MIPS_64. */
11791 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11792 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11795 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11797 switch (elf_header
.e_machine
)
11800 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11802 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11804 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11806 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11808 return reloc_type
== 44; /* R_PPC64_REL64. */
11809 case EM_SPARC32PLUS
:
11812 return reloc_type
== 46; /* R_SPARC_DISP64. */
11816 return reloc_type
== 24; /* R_X86_64_PC64. */
11819 return reloc_type
== 23; /* R_S390_PC64. */
11821 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11827 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11828 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11831 is_24bit_abs_reloc (unsigned int reloc_type
)
11833 switch (elf_header
.e_machine
)
11835 case EM_CYGNUS_MN10200
:
11837 return reloc_type
== 4; /* R_MN10200_24. */
11839 return reloc_type
== 5; /* R_FT32_20. */
11845 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11846 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11849 is_16bit_abs_reloc (unsigned int reloc_type
)
11851 /* Please keep this table alpha-sorted for ease of visual lookup. */
11852 switch (elf_header
.e_machine
)
11855 case EM_ARC_COMPACT
:
11856 case EM_ARC_COMPACT2
:
11857 return reloc_type
== 2; /* R_ARC_16. */
11858 case EM_ADAPTEVA_EPIPHANY
:
11859 return reloc_type
== 5;
11862 return reloc_type
== 4; /* R_AVR_16. */
11863 case EM_CYGNUS_D10V
:
11865 return reloc_type
== 3; /* R_D10V_16. */
11869 return reloc_type
== R_H8_DIR16
;
11872 return reloc_type
== 1; /* R_IP2K_16. */
11875 return reloc_type
== 1; /* R_M32C_16 */
11876 case EM_CYGNUS_MN10200
:
11878 return reloc_type
== 2; /* R_MN10200_16. */
11879 case EM_CYGNUS_MN10300
:
11881 return reloc_type
== 2; /* R_MN10300_16. */
11883 if (uses_msp430x_relocs ())
11884 return reloc_type
== 2; /* R_MSP430_ABS16. */
11885 case EM_MSP430_OLD
:
11886 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11888 return reloc_type
== 19; /* R_NDS32_RELA. */
11889 case EM_ALTERA_NIOS2
:
11890 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11892 return reloc_type
== 9; /* R_NIOS_16. */
11894 return reloc_type
== 2; /* R_OR1K_16. */
11896 return reloc_type
== 2; /* R_C6000_ABS16. */
11898 return reloc_type
== 2; /* R_VISIUM_16. */
11901 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11903 return reloc_type
== 3; /* R_XGATE_16. */
11909 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11910 relocation entries (possibly formerly used for SHT_GROUP sections). */
11913 is_none_reloc (unsigned int reloc_type
)
11915 switch (elf_header
.e_machine
)
11917 case EM_386
: /* R_386_NONE. */
11918 case EM_68K
: /* R_68K_NONE. */
11919 case EM_ADAPTEVA_EPIPHANY
:
11920 case EM_ALPHA
: /* R_ALPHA_NONE. */
11921 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11922 case EM_ARC
: /* R_ARC_NONE. */
11923 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
11924 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
11925 case EM_ARM
: /* R_ARM_NONE. */
11926 case EM_C166
: /* R_XC16X_NONE. */
11927 case EM_CRIS
: /* R_CRIS_NONE. */
11928 case EM_FT32
: /* R_FT32_NONE. */
11929 case EM_IA_64
: /* R_IA64_NONE. */
11930 case EM_K1OM
: /* R_X86_64_NONE. */
11931 case EM_L1OM
: /* R_X86_64_NONE. */
11932 case EM_M32R
: /* R_M32R_NONE. */
11933 case EM_MIPS
: /* R_MIPS_NONE. */
11934 case EM_MN10300
: /* R_MN10300_NONE. */
11935 case EM_MOXIE
: /* R_MOXIE_NONE. */
11936 case EM_NIOS32
: /* R_NIOS_NONE. */
11937 case EM_OR1K
: /* R_OR1K_NONE. */
11938 case EM_PARISC
: /* R_PARISC_NONE. */
11939 case EM_PPC64
: /* R_PPC64_NONE. */
11940 case EM_PPC
: /* R_PPC_NONE. */
11941 case EM_S390
: /* R_390_NONE. */
11943 case EM_SH
: /* R_SH_NONE. */
11944 case EM_SPARC32PLUS
:
11945 case EM_SPARC
: /* R_SPARC_NONE. */
11947 case EM_TILEGX
: /* R_TILEGX_NONE. */
11948 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11949 case EM_TI_C6000
:/* R_C6000_NONE. */
11950 case EM_X86_64
: /* R_X86_64_NONE. */
11952 return reloc_type
== 0;
11955 return reloc_type
== 0 || reloc_type
== 256;
11958 return (reloc_type
== 0 /* R_AVR_NONE. */
11959 || reloc_type
== 30 /* R_AVR_DIFF8. */
11960 || reloc_type
== 31 /* R_AVR_DIFF16. */
11961 || reloc_type
== 32 /* R_AVR_DIFF32. */);
11963 return reloc_type
== 3; /* R_METAG_NONE. */
11965 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11966 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11967 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11968 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11969 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11970 case EM_XTENSA_OLD
:
11972 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11973 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11974 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11975 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11980 /* Returns TRUE if there is a relocation against
11981 section NAME at OFFSET bytes. */
11984 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
11986 Elf_Internal_Rela
* relocs
;
11987 Elf_Internal_Rela
* rp
;
11989 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
11992 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
11994 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
11995 if (rp
->r_offset
== offset
)
12001 /* Apply relocations to a section.
12002 Note: So far support has been added only for those relocations
12003 which can be found in debug sections.
12004 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12005 loaded relocs. It is then the caller's responsibility to free them.
12006 FIXME: Add support for more relocations ? */
12009 apply_relocations (void * file
,
12010 const Elf_Internal_Shdr
* section
,
12011 unsigned char * start
,
12012 bfd_size_type size
,
12013 void ** relocs_return
,
12014 unsigned long * num_relocs_return
)
12016 Elf_Internal_Shdr
* relsec
;
12017 unsigned char * end
= start
+ size
;
12019 if (relocs_return
!= NULL
)
12021 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12022 * num_relocs_return
= 0;
12025 if (elf_header
.e_type
!= ET_REL
)
12028 /* Find the reloc section associated with the section. */
12029 for (relsec
= section_headers
;
12030 relsec
< section_headers
+ elf_header
.e_shnum
;
12033 bfd_boolean is_rela
;
12034 unsigned long num_relocs
;
12035 Elf_Internal_Rela
* relocs
;
12036 Elf_Internal_Rela
* rp
;
12037 Elf_Internal_Shdr
* symsec
;
12038 Elf_Internal_Sym
* symtab
;
12039 unsigned long num_syms
;
12040 Elf_Internal_Sym
* sym
;
12042 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12043 || relsec
->sh_info
>= elf_header
.e_shnum
12044 || section_headers
+ relsec
->sh_info
!= section
12045 || relsec
->sh_size
== 0
12046 || relsec
->sh_link
>= elf_header
.e_shnum
)
12049 is_rela
= relsec
->sh_type
== SHT_RELA
;
12053 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12054 relsec
->sh_size
, & relocs
, & num_relocs
))
12059 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12060 relsec
->sh_size
, & relocs
, & num_relocs
))
12064 /* SH uses RELA but uses in place value instead of the addend field. */
12065 if (elf_header
.e_machine
== EM_SH
)
12068 symsec
= section_headers
+ relsec
->sh_link
;
12069 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12071 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12074 unsigned int reloc_type
;
12075 unsigned int reloc_size
;
12076 unsigned char * rloc
;
12077 unsigned long sym_index
;
12079 reloc_type
= get_reloc_type (rp
->r_info
);
12081 if (target_specific_reloc_handling (rp
, start
, symtab
))
12083 else if (is_none_reloc (reloc_type
))
12085 else if (is_32bit_abs_reloc (reloc_type
)
12086 || is_32bit_pcrel_reloc (reloc_type
))
12088 else if (is_64bit_abs_reloc (reloc_type
)
12089 || is_64bit_pcrel_reloc (reloc_type
))
12091 else if (is_24bit_abs_reloc (reloc_type
))
12093 else if (is_16bit_abs_reloc (reloc_type
))
12097 static unsigned int prev_reloc
= 0;
12098 if (reloc_type
!= prev_reloc
)
12099 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12100 reloc_type
, printable_section_name (section
));
12101 prev_reloc
= reloc_type
;
12105 rloc
= start
+ rp
->r_offset
;
12106 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12108 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12109 (unsigned long) rp
->r_offset
,
12110 printable_section_name (section
));
12114 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12115 if (sym_index
>= num_syms
)
12117 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12118 sym_index
, printable_section_name (section
));
12121 sym
= symtab
+ sym_index
;
12123 /* If the reloc has a symbol associated with it,
12124 make sure that it is of an appropriate type.
12126 Relocations against symbols without type can happen.
12127 Gcc -feliminate-dwarf2-dups may generate symbols
12128 without type for debug info.
12130 Icc generates relocations against function symbols
12131 instead of local labels.
12133 Relocations against object symbols can happen, eg when
12134 referencing a global array. For an example of this see
12135 the _clz.o binary in libgcc.a. */
12137 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12138 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12140 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12141 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12142 (long int)(rp
- relocs
),
12143 printable_section_name (relsec
));
12149 addend
+= rp
->r_addend
;
12150 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12151 partial_inplace. */
12153 || (elf_header
.e_machine
== EM_XTENSA
12154 && reloc_type
== 1)
12155 || ((elf_header
.e_machine
== EM_PJ
12156 || elf_header
.e_machine
== EM_PJ_OLD
)
12157 && reloc_type
== 1)
12158 || ((elf_header
.e_machine
== EM_D30V
12159 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12160 && reloc_type
== 12))
12161 addend
+= byte_get (rloc
, reloc_size
);
12163 if (is_32bit_pcrel_reloc (reloc_type
)
12164 || is_64bit_pcrel_reloc (reloc_type
))
12166 /* On HPPA, all pc-relative relocations are biased by 8. */
12167 if (elf_header
.e_machine
== EM_PARISC
)
12169 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12173 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12180 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12181 * num_relocs_return
= num_relocs
;
12190 #ifdef SUPPORT_DISASSEMBLY
12192 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12194 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12196 /* FIXME: XXX -- to be done --- XXX */
12202 /* Reads in the contents of SECTION from FILE, returning a pointer
12203 to a malloc'ed buffer or NULL if something went wrong. */
12206 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12208 bfd_size_type num_bytes
;
12210 num_bytes
= section
->sh_size
;
12212 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12214 printf (_("\nSection '%s' has no data to dump.\n"),
12215 printable_section_name (section
));
12219 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12220 _("section contents"));
12223 /* Uncompresses a section that was compressed using zlib, in place. */
12226 uncompress_section_contents (unsigned char **buffer
,
12227 dwarf_size_type uncompressed_size
,
12228 dwarf_size_type
*size
)
12230 dwarf_size_type compressed_size
= *size
;
12231 unsigned char * compressed_buffer
= *buffer
;
12232 unsigned char * uncompressed_buffer
;
12236 /* It is possible the section consists of several compressed
12237 buffers concatenated together, so we uncompress in a loop. */
12238 /* PR 18313: The state field in the z_stream structure is supposed
12239 to be invisible to the user (ie us), but some compilers will
12240 still complain about it being used without initialisation. So
12241 we first zero the entire z_stream structure and then set the fields
12243 memset (& strm
, 0, sizeof strm
);
12244 strm
.avail_in
= compressed_size
;
12245 strm
.next_in
= (Bytef
*) compressed_buffer
;
12246 strm
.avail_out
= uncompressed_size
;
12247 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12249 rc
= inflateInit (& strm
);
12250 while (strm
.avail_in
> 0)
12254 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12255 + (uncompressed_size
- strm
.avail_out
));
12256 rc
= inflate (&strm
, Z_FINISH
);
12257 if (rc
!= Z_STREAM_END
)
12259 rc
= inflateReset (& strm
);
12261 rc
= inflateEnd (& strm
);
12263 || strm
.avail_out
!= 0)
12266 *buffer
= uncompressed_buffer
;
12267 *size
= uncompressed_size
;
12271 free (uncompressed_buffer
);
12272 /* Indicate decompression failure. */
12278 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12280 Elf_Internal_Shdr
* relsec
;
12281 bfd_size_type num_bytes
;
12282 unsigned char * data
;
12283 unsigned char * end
;
12284 unsigned char * real_start
;
12285 unsigned char * start
;
12286 bfd_boolean some_strings_shown
;
12288 real_start
= start
= (unsigned char *) get_section_contents (section
,
12292 num_bytes
= section
->sh_size
;
12294 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12296 if (decompress_dumps
)
12298 dwarf_size_type new_size
= num_bytes
;
12299 dwarf_size_type uncompressed_size
= 0;
12301 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12303 Elf_Internal_Chdr chdr
;
12304 unsigned int compression_header_size
12305 = get_compression_header (& chdr
, (unsigned char *) start
);
12307 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12309 warn (_("section '%s' has unsupported compress type: %d\n"),
12310 printable_section_name (section
), chdr
.ch_type
);
12313 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12315 warn (_("compressed section '%s' is corrupted\n"),
12316 printable_section_name (section
));
12319 uncompressed_size
= chdr
.ch_size
;
12320 start
+= compression_header_size
;
12321 new_size
-= compression_header_size
;
12323 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12325 /* Read the zlib header. In this case, it should be "ZLIB"
12326 followed by the uncompressed section size, 8 bytes in
12327 big-endian order. */
12328 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12329 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12330 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12331 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12332 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12333 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12334 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12335 uncompressed_size
+= start
[11];
12340 if (uncompressed_size
12341 && uncompress_section_contents (& start
,
12342 uncompressed_size
, & new_size
))
12343 num_bytes
= new_size
;
12346 /* If the section being dumped has relocations against it the user might
12347 be expecting these relocations to have been applied. Check for this
12348 case and issue a warning message in order to avoid confusion.
12349 FIXME: Maybe we ought to have an option that dumps a section with
12350 relocs applied ? */
12351 for (relsec
= section_headers
;
12352 relsec
< section_headers
+ elf_header
.e_shnum
;
12355 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12356 || relsec
->sh_info
>= elf_header
.e_shnum
12357 || section_headers
+ relsec
->sh_info
!= section
12358 || relsec
->sh_size
== 0
12359 || relsec
->sh_link
>= elf_header
.e_shnum
)
12362 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12367 end
= start
+ num_bytes
;
12368 some_strings_shown
= FALSE
;
12372 while (!ISPRINT (* data
))
12373 if (++ data
>= end
)
12378 size_t maxlen
= end
- data
;
12381 /* PR 11128: Use two separate invocations in order to work
12382 around bugs in the Solaris 8 implementation of printf. */
12383 printf (" [%6tx] ", data
- start
);
12385 printf (" [%6Ix] ", (size_t) (data
- start
));
12389 print_symbol ((int) maxlen
, (const char *) data
);
12391 data
+= strnlen ((const char *) data
, maxlen
);
12395 printf (_("<corrupt>\n"));
12398 some_strings_shown
= TRUE
;
12402 if (! some_strings_shown
)
12403 printf (_(" No strings found in this section."));
12411 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12413 bfd_boolean relocate
)
12415 Elf_Internal_Shdr
* relsec
;
12416 bfd_size_type bytes
;
12417 bfd_size_type section_size
;
12419 unsigned char * data
;
12420 unsigned char * real_start
;
12421 unsigned char * start
;
12423 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12426 section_size
= section
->sh_size
;
12428 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12430 if (decompress_dumps
)
12432 dwarf_size_type new_size
= section_size
;
12433 dwarf_size_type uncompressed_size
= 0;
12435 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12437 Elf_Internal_Chdr chdr
;
12438 unsigned int compression_header_size
12439 = get_compression_header (& chdr
, start
);
12441 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12443 warn (_("section '%s' has unsupported compress type: %d\n"),
12444 printable_section_name (section
), chdr
.ch_type
);
12447 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12449 warn (_("compressed section '%s' is corrupted\n"),
12450 printable_section_name (section
));
12453 uncompressed_size
= chdr
.ch_size
;
12454 start
+= compression_header_size
;
12455 new_size
-= compression_header_size
;
12457 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12459 /* Read the zlib header. In this case, it should be "ZLIB"
12460 followed by the uncompressed section size, 8 bytes in
12461 big-endian order. */
12462 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12463 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12464 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12465 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12466 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12467 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12468 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12469 uncompressed_size
+= start
[11];
12474 if (uncompressed_size
12475 && uncompress_section_contents (& start
, uncompressed_size
,
12477 section_size
= new_size
;
12482 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12486 /* If the section being dumped has relocations against it the user might
12487 be expecting these relocations to have been applied. Check for this
12488 case and issue a warning message in order to avoid confusion.
12489 FIXME: Maybe we ought to have an option that dumps a section with
12490 relocs applied ? */
12491 for (relsec
= section_headers
;
12492 relsec
< section_headers
+ elf_header
.e_shnum
;
12495 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12496 || relsec
->sh_info
>= elf_header
.e_shnum
12497 || section_headers
+ relsec
->sh_info
!= section
12498 || relsec
->sh_size
== 0
12499 || relsec
->sh_link
>= elf_header
.e_shnum
)
12502 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12507 addr
= section
->sh_addr
;
12508 bytes
= section_size
;
12517 lbytes
= (bytes
> 16 ? 16 : bytes
);
12519 printf (" 0x%8.8lx ", (unsigned long) addr
);
12521 for (j
= 0; j
< 16; j
++)
12524 printf ("%2.2x", data
[j
]);
12532 for (j
= 0; j
< lbytes
; j
++)
12535 if (k
>= ' ' && k
< 0x7f)
12554 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12555 const Elf_Internal_Shdr
* sec
, void * file
)
12557 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12560 /* If it is already loaded, do nothing. */
12561 if (section
->start
!= NULL
)
12564 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12565 section
->address
= sec
->sh_addr
;
12566 section
->user_data
= NULL
;
12567 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12569 sec
->sh_size
, buf
);
12570 if (section
->start
== NULL
)
12574 unsigned char *start
= section
->start
;
12575 dwarf_size_type size
= sec
->sh_size
;
12576 dwarf_size_type uncompressed_size
= 0;
12578 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12580 Elf_Internal_Chdr chdr
;
12581 unsigned int compression_header_size
;
12583 if (size
< sizeof chdr
)
12585 warn (_("compressed section %s is too small to contain a compression header"),
12590 compression_header_size
= get_compression_header (&chdr
, start
);
12592 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12594 warn (_("section '%s' has unsupported compress type: %d\n"),
12595 section
->name
, chdr
.ch_type
);
12598 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12600 warn (_("compressed section '%s' is corrupted\n"),
12604 uncompressed_size
= chdr
.ch_size
;
12605 start
+= compression_header_size
;
12606 size
-= compression_header_size
;
12608 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12610 /* Read the zlib header. In this case, it should be "ZLIB"
12611 followed by the uncompressed section size, 8 bytes in
12612 big-endian order. */
12613 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12614 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12615 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12616 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12617 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12618 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12619 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12620 uncompressed_size
+= start
[11];
12625 if (uncompressed_size
12626 && uncompress_section_contents (&start
, uncompressed_size
,
12629 /* Free the compressed buffer, update the section buffer
12630 and the section size if uncompress is successful. */
12631 free (section
->start
);
12632 section
->start
= start
;
12634 section
->size
= size
;
12637 if (section
->start
== NULL
)
12640 if (debug_displays
[debug
].relocate
)
12641 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12642 & section
->reloc_info
, & section
->num_relocs
);
12645 section
->reloc_info
= NULL
;
12646 section
->num_relocs
= 0;
12652 /* If this is not NULL, load_debug_section will only look for sections
12653 within the list of sections given here. */
12654 unsigned int *section_subset
= NULL
;
12657 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12659 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12660 Elf_Internal_Shdr
* sec
;
12662 /* Locate the debug section. */
12663 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12665 section
->name
= section
->uncompressed_name
;
12668 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12670 section
->name
= section
->compressed_name
;
12675 /* If we're loading from a subset of sections, and we've loaded
12676 a section matching this name before, it's likely that it's a
12678 if (section_subset
!= NULL
)
12679 free_debug_section (debug
);
12681 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12685 free_debug_section (enum dwarf_section_display_enum debug
)
12687 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12689 if (section
->start
== NULL
)
12692 free ((char *) section
->start
);
12693 section
->start
= NULL
;
12694 section
->address
= 0;
12699 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12701 char * name
= SECTION_NAME (section
);
12702 const char * print_name
= printable_section_name (section
);
12703 bfd_size_type length
;
12707 length
= section
->sh_size
;
12710 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12713 if (section
->sh_type
== SHT_NOBITS
)
12715 /* There is no point in dumping the contents of a debugging section
12716 which has the NOBITS type - the bits in the file will be random.
12717 This can happen when a file containing a .eh_frame section is
12718 stripped with the --only-keep-debug command line option. */
12719 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12724 if (const_strneq (name
, ".gnu.linkonce.wi."))
12725 name
= ".debug_info";
12727 /* See if we know how to display the contents of this section. */
12728 for (i
= 0; i
< max
; i
++)
12729 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12730 || (i
== line
&& const_strneq (name
, ".debug_line."))
12731 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12733 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12734 int secondary
= (section
!= find_section (name
));
12737 free_debug_section ((enum dwarf_section_display_enum
) i
);
12739 if (i
== line
&& const_strneq (name
, ".debug_line."))
12741 else if (streq (sec
->uncompressed_name
, name
))
12742 sec
->name
= sec
->uncompressed_name
;
12744 sec
->name
= sec
->compressed_name
;
12745 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12748 /* If this debug section is part of a CU/TU set in a .dwp file,
12749 restrict load_debug_section to the sections in that set. */
12750 section_subset
= find_cu_tu_set (file
, shndx
);
12752 result
&= debug_displays
[i
].display (sec
, file
);
12754 section_subset
= NULL
;
12756 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12757 free_debug_section ((enum dwarf_section_display_enum
) i
);
12765 printf (_("Unrecognized debug section: %s\n"), print_name
);
12772 /* Set DUMP_SECTS for all sections where dumps were requested
12773 based on section name. */
12776 initialise_dumps_byname (void)
12778 struct dump_list_entry
* cur
;
12780 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12785 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12786 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12788 request_dump_bynumber (i
, cur
->type
);
12793 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12799 process_section_contents (FILE * file
)
12801 Elf_Internal_Shdr
* section
;
12807 initialise_dumps_byname ();
12809 for (i
= 0, section
= section_headers
;
12810 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12813 #ifdef SUPPORT_DISASSEMBLY
12814 if (dump_sects
[i
] & DISASS_DUMP
)
12815 disassemble_section (section
, file
);
12817 if (dump_sects
[i
] & HEX_DUMP
)
12818 dump_section_as_bytes (section
, file
, FALSE
);
12820 if (dump_sects
[i
] & RELOC_DUMP
)
12821 dump_section_as_bytes (section
, file
, TRUE
);
12823 if (dump_sects
[i
] & STRING_DUMP
)
12824 dump_section_as_strings (section
, file
);
12826 if (dump_sects
[i
] & DEBUG_DUMP
)
12827 display_debug_section (i
, section
, file
);
12830 /* Check to see if the user requested a
12831 dump of a section that does not exist. */
12832 while (i
++ < num_dump_sects
)
12834 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12838 process_mips_fpe_exception (int mask
)
12843 if (mask
& OEX_FPU_INEX
)
12844 fputs ("INEX", stdout
), first
= 0;
12845 if (mask
& OEX_FPU_UFLO
)
12846 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12847 if (mask
& OEX_FPU_OFLO
)
12848 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12849 if (mask
& OEX_FPU_DIV0
)
12850 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12851 if (mask
& OEX_FPU_INVAL
)
12852 printf ("%sINVAL", first
? "" : "|");
12855 fputs ("0", stdout
);
12858 /* Display's the value of TAG at location P. If TAG is
12859 greater than 0 it is assumed to be an unknown tag, and
12860 a message is printed to this effect. Otherwise it is
12861 assumed that a message has already been printed.
12863 If the bottom bit of TAG is set it assumed to have a
12864 string value, otherwise it is assumed to have an integer
12867 Returns an updated P pointing to the first unread byte
12868 beyond the end of TAG's value.
12870 Reads at or beyond END will not be made. */
12872 static unsigned char *
12873 display_tag_value (int tag
,
12875 const unsigned char * const end
)
12880 printf (" Tag_unknown_%d: ", tag
);
12884 warn (_("<corrupt tag>\n"));
12888 /* PR 17531 file: 027-19978-0.004. */
12889 size_t maxlen
= (end
- p
) - 1;
12894 print_symbol ((int) maxlen
, (const char *) p
);
12895 p
+= strnlen ((char *) p
, maxlen
) + 1;
12899 printf (_("<corrupt string tag>"));
12900 p
= (unsigned char *) end
;
12908 val
= read_uleb128 (p
, &len
, end
);
12910 printf ("%ld (0x%lx)\n", val
, val
);
12917 /* ARM EABI attributes section. */
12922 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12924 const char ** table
;
12925 } arm_attr_public_tag
;
12927 static const char * arm_attr_tag_CPU_arch
[] =
12928 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12929 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12931 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12932 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12933 {"No", "Thumb-1", "Thumb-2", "Yes"};
12934 static const char * arm_attr_tag_FP_arch
[] =
12935 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12936 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12937 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12938 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12939 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
12940 "NEON for ARMv8.1"};
12941 static const char * arm_attr_tag_PCS_config
[] =
12942 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12943 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12944 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12945 {"V6", "SB", "TLS", "Unused"};
12946 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12947 {"Absolute", "PC-relative", "SB-relative", "None"};
12948 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12949 {"Absolute", "PC-relative", "None"};
12950 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12951 {"None", "direct", "GOT-indirect"};
12952 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12953 {"None", "??? 1", "2", "??? 3", "4"};
12954 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12955 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12956 {"Unused", "Needed", "Sign only"};
12957 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12958 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12959 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12960 {"Unused", "Finite", "RTABI", "IEEE 754"};
12961 static const char * arm_attr_tag_ABI_enum_size
[] =
12962 {"Unused", "small", "int", "forced to int"};
12963 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12964 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12965 static const char * arm_attr_tag_ABI_VFP_args
[] =
12966 {"AAPCS", "VFP registers", "custom", "compatible"};
12967 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12968 {"AAPCS", "WMMX registers", "custom"};
12969 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12970 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12971 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12972 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12973 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12974 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12975 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12976 static const char * arm_attr_tag_FP_HP_extension
[] =
12977 {"Not Allowed", "Allowed"};
12978 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12979 {"None", "IEEE 754", "Alternative Format"};
12980 static const char * arm_attr_tag_DSP_extension
[] =
12981 {"Follow architecture", "Allowed"};
12982 static const char * arm_attr_tag_MPextension_use
[] =
12983 {"Not Allowed", "Allowed"};
12984 static const char * arm_attr_tag_DIV_use
[] =
12985 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12986 "Allowed in v7-A with integer division extension"};
12987 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12988 static const char * arm_attr_tag_Virtualization_use
[] =
12989 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12990 "TrustZone and Virtualization Extensions"};
12991 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12992 {"Not Allowed", "Allowed"};
12994 #define LOOKUP(id, name) \
12995 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12996 static arm_attr_public_tag arm_attr_public_tags
[] =
12998 {4, "CPU_raw_name", 1, NULL
},
12999 {5, "CPU_name", 1, NULL
},
13000 LOOKUP(6, CPU_arch
),
13001 {7, "CPU_arch_profile", 0, NULL
},
13002 LOOKUP(8, ARM_ISA_use
),
13003 LOOKUP(9, THUMB_ISA_use
),
13004 LOOKUP(10, FP_arch
),
13005 LOOKUP(11, WMMX_arch
),
13006 LOOKUP(12, Advanced_SIMD_arch
),
13007 LOOKUP(13, PCS_config
),
13008 LOOKUP(14, ABI_PCS_R9_use
),
13009 LOOKUP(15, ABI_PCS_RW_data
),
13010 LOOKUP(16, ABI_PCS_RO_data
),
13011 LOOKUP(17, ABI_PCS_GOT_use
),
13012 LOOKUP(18, ABI_PCS_wchar_t
),
13013 LOOKUP(19, ABI_FP_rounding
),
13014 LOOKUP(20, ABI_FP_denormal
),
13015 LOOKUP(21, ABI_FP_exceptions
),
13016 LOOKUP(22, ABI_FP_user_exceptions
),
13017 LOOKUP(23, ABI_FP_number_model
),
13018 {24, "ABI_align_needed", 0, NULL
},
13019 {25, "ABI_align_preserved", 0, NULL
},
13020 LOOKUP(26, ABI_enum_size
),
13021 LOOKUP(27, ABI_HardFP_use
),
13022 LOOKUP(28, ABI_VFP_args
),
13023 LOOKUP(29, ABI_WMMX_args
),
13024 LOOKUP(30, ABI_optimization_goals
),
13025 LOOKUP(31, ABI_FP_optimization_goals
),
13026 {32, "compatibility", 0, NULL
},
13027 LOOKUP(34, CPU_unaligned_access
),
13028 LOOKUP(36, FP_HP_extension
),
13029 LOOKUP(38, ABI_FP_16bit_format
),
13030 LOOKUP(42, MPextension_use
),
13031 LOOKUP(44, DIV_use
),
13032 LOOKUP(46, DSP_extension
),
13033 {64, "nodefaults", 0, NULL
},
13034 {65, "also_compatible_with", 0, NULL
},
13035 LOOKUP(66, T2EE_use
),
13036 {67, "conformance", 1, NULL
},
13037 LOOKUP(68, Virtualization_use
),
13038 LOOKUP(70, MPextension_use_legacy
)
13042 static unsigned char *
13043 display_arm_attribute (unsigned char * p
,
13044 const unsigned char * const end
)
13049 arm_attr_public_tag
* attr
;
13053 tag
= read_uleb128 (p
, &len
, end
);
13056 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13058 if (arm_attr_public_tags
[i
].tag
== tag
)
13060 attr
= &arm_attr_public_tags
[i
];
13067 printf (" Tag_%s: ", attr
->name
);
13068 switch (attr
->type
)
13073 case 7: /* Tag_CPU_arch_profile. */
13074 val
= read_uleb128 (p
, &len
, end
);
13078 case 0: printf (_("None\n")); break;
13079 case 'A': printf (_("Application\n")); break;
13080 case 'R': printf (_("Realtime\n")); break;
13081 case 'M': printf (_("Microcontroller\n")); break;
13082 case 'S': printf (_("Application or Realtime\n")); break;
13083 default: printf ("??? (%d)\n", val
); break;
13087 case 24: /* Tag_align_needed. */
13088 val
= read_uleb128 (p
, &len
, end
);
13092 case 0: printf (_("None\n")); break;
13093 case 1: printf (_("8-byte\n")); break;
13094 case 2: printf (_("4-byte\n")); break;
13095 case 3: printf ("??? 3\n"); break;
13098 printf (_("8-byte and up to %d-byte extended\n"),
13101 printf ("??? (%d)\n", val
);
13106 case 25: /* Tag_align_preserved. */
13107 val
= read_uleb128 (p
, &len
, end
);
13111 case 0: printf (_("None\n")); break;
13112 case 1: printf (_("8-byte, except leaf SP\n")); break;
13113 case 2: printf (_("8-byte\n")); break;
13114 case 3: printf ("??? 3\n"); break;
13117 printf (_("8-byte and up to %d-byte extended\n"),
13120 printf ("??? (%d)\n", val
);
13125 case 32: /* Tag_compatibility. */
13127 val
= read_uleb128 (p
, &len
, end
);
13129 printf (_("flag = %d, vendor = "), val
);
13132 size_t maxlen
= (end
- p
) - 1;
13134 print_symbol ((int) maxlen
, (const char *) p
);
13135 p
+= strnlen ((char *) p
, maxlen
) + 1;
13139 printf (_("<corrupt>"));
13140 p
= (unsigned char *) end
;
13146 case 64: /* Tag_nodefaults. */
13147 /* PR 17531: file: 001-505008-0.01. */
13150 printf (_("True\n"));
13153 case 65: /* Tag_also_compatible_with. */
13154 val
= read_uleb128 (p
, &len
, end
);
13156 if (val
== 6 /* Tag_CPU_arch. */)
13158 val
= read_uleb128 (p
, &len
, end
);
13160 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13161 printf ("??? (%d)\n", val
);
13163 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13167 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13172 printf (_("<unknown: %d>\n"), tag
);
13178 return display_tag_value (-1, p
, end
);
13180 return display_tag_value (0, p
, end
);
13183 assert (attr
->type
& 0x80);
13184 val
= read_uleb128 (p
, &len
, end
);
13186 type
= attr
->type
& 0x7f;
13188 printf ("??? (%d)\n", val
);
13190 printf ("%s\n", attr
->table
[val
]);
13195 return display_tag_value (tag
, p
, end
);
13198 static unsigned char *
13199 display_gnu_attribute (unsigned char * p
,
13200 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13201 const unsigned char * const end
)
13207 tag
= read_uleb128 (p
, &len
, end
);
13210 /* Tag_compatibility is the only generic GNU attribute defined at
13214 val
= read_uleb128 (p
, &len
, end
);
13217 printf (_("flag = %d, vendor = "), val
);
13220 printf (_("<corrupt>\n"));
13221 warn (_("corrupt vendor attribute\n"));
13227 size_t maxlen
= (end
- p
) - 1;
13229 print_symbol ((int) maxlen
, (const char *) p
);
13230 p
+= strnlen ((char *) p
, maxlen
) + 1;
13234 printf (_("<corrupt>"));
13235 p
= (unsigned char *) end
;
13242 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13243 return display_proc_gnu_attribute (p
, tag
, end
);
13245 return display_tag_value (tag
, p
, end
);
13248 static unsigned char *
13249 display_power_gnu_attribute (unsigned char * p
,
13251 const unsigned char * const end
)
13256 if (tag
== Tag_GNU_Power_ABI_FP
)
13258 val
= read_uleb128 (p
, &len
, end
);
13260 printf (" Tag_GNU_Power_ABI_FP: ");
13265 printf (_("Hard or soft float\n"));
13268 printf (_("Hard float\n"));
13271 printf (_("Soft float\n"));
13274 printf (_("Single-precision hard float\n"));
13277 printf ("??? (%d)\n", val
);
13283 if (tag
== Tag_GNU_Power_ABI_Vector
)
13285 val
= read_uleb128 (p
, &len
, end
);
13287 printf (" Tag_GNU_Power_ABI_Vector: ");
13291 printf (_("Any\n"));
13294 printf (_("Generic\n"));
13297 printf ("AltiVec\n");
13303 printf ("??? (%d)\n", val
);
13309 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13313 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13317 val
= read_uleb128 (p
, &len
, end
);
13319 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13323 printf (_("Any\n"));
13326 printf ("r3/r4\n");
13329 printf (_("Memory\n"));
13332 printf ("??? (%d)\n", val
);
13338 return display_tag_value (tag
& 1, p
, end
);
13341 static unsigned char *
13342 display_s390_gnu_attribute (unsigned char * p
,
13344 const unsigned char * const end
)
13349 if (tag
== Tag_GNU_S390_ABI_Vector
)
13351 val
= read_uleb128 (p
, &len
, end
);
13353 printf (" Tag_GNU_S390_ABI_Vector: ");
13358 printf (_("any\n"));
13361 printf (_("software\n"));
13364 printf (_("hardware\n"));
13367 printf ("??? (%d)\n", val
);
13373 return display_tag_value (tag
& 1, p
, end
);
13377 display_sparc_hwcaps (int mask
)
13383 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13384 fputs ("mul32", stdout
), first
= 0;
13385 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13386 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13387 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13388 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13389 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13390 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13391 if (mask
& ELF_SPARC_HWCAP_POPC
)
13392 printf ("%spopc", first
? "" : "|"), first
= 0;
13393 if (mask
& ELF_SPARC_HWCAP_VIS
)
13394 printf ("%svis", first
? "" : "|"), first
= 0;
13395 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13396 printf ("%svis2", first
? "" : "|"), first
= 0;
13397 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13398 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13399 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13400 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13401 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13402 printf ("%svis3", first
? "" : "|"), first
= 0;
13403 if (mask
& ELF_SPARC_HWCAP_HPC
)
13404 printf ("%shpc", first
? "" : "|"), first
= 0;
13405 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13406 printf ("%srandom", first
? "" : "|"), first
= 0;
13407 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13408 printf ("%strans", first
? "" : "|"), first
= 0;
13409 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13410 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13411 if (mask
& ELF_SPARC_HWCAP_IMA
)
13412 printf ("%sima", first
? "" : "|"), first
= 0;
13413 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13414 printf ("%scspare", first
? "" : "|"), first
= 0;
13417 fputc ('0', stdout
);
13418 fputc ('\n', stdout
);
13422 display_sparc_hwcaps2 (int mask
)
13428 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13429 fputs ("fjathplus", stdout
), first
= 0;
13430 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13431 printf ("%svis3b", first
? "" : "|"), first
= 0;
13432 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13433 printf ("%sadp", first
? "" : "|"), first
= 0;
13434 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13435 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13436 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13437 printf ("%smwait", first
? "" : "|"), first
= 0;
13438 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13439 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13440 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13441 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13442 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13443 printf ("%snsec", first
? "" : "|"), first
= 0;
13444 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13445 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13446 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13447 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13448 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13449 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13452 fputc ('0', stdout
);
13453 fputc ('\n', stdout
);
13456 static unsigned char *
13457 display_sparc_gnu_attribute (unsigned char * p
,
13459 const unsigned char * const end
)
13464 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13466 val
= read_uleb128 (p
, &len
, end
);
13468 printf (" Tag_GNU_Sparc_HWCAPS: ");
13469 display_sparc_hwcaps (val
);
13472 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13474 val
= read_uleb128 (p
, &len
, end
);
13476 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13477 display_sparc_hwcaps2 (val
);
13481 return display_tag_value (tag
, p
, end
);
13485 print_mips_fp_abi_value (int val
)
13489 case Val_GNU_MIPS_ABI_FP_ANY
:
13490 printf (_("Hard or soft float\n"));
13492 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13493 printf (_("Hard float (double precision)\n"));
13495 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13496 printf (_("Hard float (single precision)\n"));
13498 case Val_GNU_MIPS_ABI_FP_SOFT
:
13499 printf (_("Soft float\n"));
13501 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13502 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13504 case Val_GNU_MIPS_ABI_FP_XX
:
13505 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13507 case Val_GNU_MIPS_ABI_FP_64
:
13508 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13510 case Val_GNU_MIPS_ABI_FP_64A
:
13511 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13513 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13514 printf (_("NaN 2008 compatibility\n"));
13517 printf ("??? (%d)\n", val
);
13522 static unsigned char *
13523 display_mips_gnu_attribute (unsigned char * p
,
13525 const unsigned char * const end
)
13527 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13532 val
= read_uleb128 (p
, &len
, end
);
13534 printf (" Tag_GNU_MIPS_ABI_FP: ");
13536 print_mips_fp_abi_value (val
);
13541 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13546 val
= read_uleb128 (p
, &len
, end
);
13548 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13552 case Val_GNU_MIPS_ABI_MSA_ANY
:
13553 printf (_("Any MSA or not\n"));
13555 case Val_GNU_MIPS_ABI_MSA_128
:
13556 printf (_("128-bit MSA\n"));
13559 printf ("??? (%d)\n", val
);
13565 return display_tag_value (tag
& 1, p
, end
);
13568 static unsigned char *
13569 display_tic6x_attribute (unsigned char * p
,
13570 const unsigned char * const end
)
13576 tag
= read_uleb128 (p
, &len
, end
);
13582 val
= read_uleb128 (p
, &len
, end
);
13584 printf (" Tag_ISA: ");
13588 case C6XABI_Tag_ISA_none
:
13589 printf (_("None\n"));
13591 case C6XABI_Tag_ISA_C62X
:
13594 case C6XABI_Tag_ISA_C67X
:
13597 case C6XABI_Tag_ISA_C67XP
:
13598 printf ("C67x+\n");
13600 case C6XABI_Tag_ISA_C64X
:
13603 case C6XABI_Tag_ISA_C64XP
:
13604 printf ("C64x+\n");
13606 case C6XABI_Tag_ISA_C674X
:
13607 printf ("C674x\n");
13610 printf ("??? (%d)\n", val
);
13615 case Tag_ABI_wchar_t
:
13616 val
= read_uleb128 (p
, &len
, end
);
13618 printf (" Tag_ABI_wchar_t: ");
13622 printf (_("Not used\n"));
13625 printf (_("2 bytes\n"));
13628 printf (_("4 bytes\n"));
13631 printf ("??? (%d)\n", val
);
13636 case Tag_ABI_stack_align_needed
:
13637 val
= read_uleb128 (p
, &len
, end
);
13639 printf (" Tag_ABI_stack_align_needed: ");
13643 printf (_("8-byte\n"));
13646 printf (_("16-byte\n"));
13649 printf ("??? (%d)\n", val
);
13654 case Tag_ABI_stack_align_preserved
:
13655 val
= read_uleb128 (p
, &len
, end
);
13657 printf (" Tag_ABI_stack_align_preserved: ");
13661 printf (_("8-byte\n"));
13664 printf (_("16-byte\n"));
13667 printf ("??? (%d)\n", val
);
13673 val
= read_uleb128 (p
, &len
, end
);
13675 printf (" Tag_ABI_DSBT: ");
13679 printf (_("DSBT addressing not used\n"));
13682 printf (_("DSBT addressing used\n"));
13685 printf ("??? (%d)\n", val
);
13691 val
= read_uleb128 (p
, &len
, end
);
13693 printf (" Tag_ABI_PID: ");
13697 printf (_("Data addressing position-dependent\n"));
13700 printf (_("Data addressing position-independent, GOT near DP\n"));
13703 printf (_("Data addressing position-independent, GOT far from DP\n"));
13706 printf ("??? (%d)\n", val
);
13712 val
= read_uleb128 (p
, &len
, end
);
13714 printf (" Tag_ABI_PIC: ");
13718 printf (_("Code addressing position-dependent\n"));
13721 printf (_("Code addressing position-independent\n"));
13724 printf ("??? (%d)\n", val
);
13729 case Tag_ABI_array_object_alignment
:
13730 val
= read_uleb128 (p
, &len
, end
);
13732 printf (" Tag_ABI_array_object_alignment: ");
13736 printf (_("8-byte\n"));
13739 printf (_("4-byte\n"));
13742 printf (_("16-byte\n"));
13745 printf ("??? (%d)\n", val
);
13750 case Tag_ABI_array_object_align_expected
:
13751 val
= read_uleb128 (p
, &len
, end
);
13753 printf (" Tag_ABI_array_object_align_expected: ");
13757 printf (_("8-byte\n"));
13760 printf (_("4-byte\n"));
13763 printf (_("16-byte\n"));
13766 printf ("??? (%d)\n", val
);
13771 case Tag_ABI_compatibility
:
13773 val
= read_uleb128 (p
, &len
, end
);
13775 printf (" Tag_ABI_compatibility: ");
13776 printf (_("flag = %d, vendor = "), val
);
13779 size_t maxlen
= (end
- p
) - 1;
13781 print_symbol ((int) maxlen
, (const char *) p
);
13782 p
+= strnlen ((char *) p
, maxlen
) + 1;
13786 printf (_("<corrupt>"));
13787 p
= (unsigned char *) end
;
13793 case Tag_ABI_conformance
:
13795 printf (" Tag_ABI_conformance: \"");
13798 size_t maxlen
= (end
- p
) - 1;
13800 print_symbol ((int) maxlen
, (const char *) p
);
13801 p
+= strnlen ((char *) p
, maxlen
) + 1;
13805 printf (_("<corrupt>"));
13806 p
= (unsigned char *) end
;
13813 return display_tag_value (tag
, p
, end
);
13817 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13819 unsigned long addr
= 0;
13820 size_t bytes
= end
- p
;
13827 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13829 printf (" 0x%8.8lx ", addr
);
13831 for (j
= 0; j
< 16; j
++)
13834 printf ("%2.2x", p
[j
]);
13842 for (j
= 0; j
< lbytes
; j
++)
13845 if (k
>= ' ' && k
< 0x7f)
13861 static unsigned char *
13862 display_msp430x_attribute (unsigned char * p
,
13863 const unsigned char * const end
)
13869 tag
= read_uleb128 (p
, & len
, end
);
13874 case OFBA_MSPABI_Tag_ISA
:
13875 val
= read_uleb128 (p
, &len
, end
);
13877 printf (" Tag_ISA: ");
13880 case 0: printf (_("None\n")); break;
13881 case 1: printf (_("MSP430\n")); break;
13882 case 2: printf (_("MSP430X\n")); break;
13883 default: printf ("??? (%d)\n", val
); break;
13887 case OFBA_MSPABI_Tag_Code_Model
:
13888 val
= read_uleb128 (p
, &len
, end
);
13890 printf (" Tag_Code_Model: ");
13893 case 0: printf (_("None\n")); break;
13894 case 1: printf (_("Small\n")); break;
13895 case 2: printf (_("Large\n")); break;
13896 default: printf ("??? (%d)\n", val
); break;
13900 case OFBA_MSPABI_Tag_Data_Model
:
13901 val
= read_uleb128 (p
, &len
, end
);
13903 printf (" Tag_Data_Model: ");
13906 case 0: printf (_("None\n")); break;
13907 case 1: printf (_("Small\n")); break;
13908 case 2: printf (_("Large\n")); break;
13909 case 3: printf (_("Restricted Large\n")); break;
13910 default: printf ("??? (%d)\n", val
); break;
13915 printf (_(" <unknown tag %d>: "), tag
);
13922 size_t maxlen
= (end
- p
) - 1;
13924 print_symbol ((int) maxlen
, (const char *) p
);
13925 p
+= strnlen ((char *) p
, maxlen
) + 1;
13929 printf (_("<corrupt>"));
13930 p
= (unsigned char *) end
;
13936 val
= read_uleb128 (p
, &len
, end
);
13938 printf ("%d (0x%x)\n", val
, val
);
13948 process_attributes (FILE * file
,
13949 const char * public_name
,
13950 unsigned int proc_type
,
13951 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13952 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13954 Elf_Internal_Shdr
* sect
;
13957 /* Find the section header so that we get the size. */
13958 for (i
= 0, sect
= section_headers
;
13959 i
< elf_header
.e_shnum
;
13962 unsigned char * contents
;
13965 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13968 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13969 sect
->sh_size
, _("attributes"));
13970 if (contents
== NULL
)
13976 bfd_vma section_len
;
13978 section_len
= sect
->sh_size
- 1;
13981 while (section_len
> 0)
13984 unsigned int namelen
;
13985 bfd_boolean public_section
;
13986 bfd_boolean gnu_section
;
13988 if (section_len
<= 4)
13990 error (_("Tag section ends prematurely\n"));
13993 attr_len
= byte_get (p
, 4);
13996 if (attr_len
> section_len
)
13998 error (_("Bad attribute length (%u > %u)\n"),
13999 (unsigned) attr_len
, (unsigned) section_len
);
14000 attr_len
= section_len
;
14002 /* PR 17531: file: 001-101425-0.004 */
14003 else if (attr_len
< 5)
14005 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14009 section_len
-= attr_len
;
14012 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14013 if (namelen
== 0 || namelen
>= attr_len
)
14015 error (_("Corrupt attribute section name\n"));
14019 printf (_("Attribute Section: "));
14020 print_symbol (INT_MAX
, (const char *) p
);
14023 if (public_name
&& streq ((char *) p
, public_name
))
14024 public_section
= TRUE
;
14026 public_section
= FALSE
;
14028 if (streq ((char *) p
, "gnu"))
14029 gnu_section
= TRUE
;
14031 gnu_section
= FALSE
;
14034 attr_len
-= namelen
;
14036 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14041 unsigned char * end
;
14043 /* PR binutils/17531: Safe handling of corrupt files. */
14046 error (_("Unused bytes at end of section\n"));
14052 size
= byte_get (p
, 4);
14053 if (size
> attr_len
)
14055 error (_("Bad subsection length (%u > %u)\n"),
14056 (unsigned) size
, (unsigned) attr_len
);
14059 /* PR binutils/17531: Safe handling of corrupt files. */
14062 error (_("Bad subsection length (%u < 6)\n"),
14069 end
= p
+ size
- 1;
14070 assert (end
<= contents
+ sect
->sh_size
);
14076 printf (_("File Attributes\n"));
14079 printf (_("Section Attributes:"));
14082 printf (_("Symbol Attributes:"));
14088 val
= read_uleb128 (p
, &j
, end
);
14092 printf (" %d", val
);
14097 printf (_("Unknown tag: %d\n"), tag
);
14098 public_section
= FALSE
;
14102 if (public_section
&& display_pub_attribute
!= NULL
)
14105 p
= display_pub_attribute (p
, end
);
14108 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14111 p
= display_gnu_attribute (p
,
14112 display_proc_gnu_attribute
,
14118 printf (_(" Unknown attribute:\n"));
14119 display_raw_attribute (p
, end
);
14128 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
14136 process_arm_specific (FILE * file
)
14138 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
14139 display_arm_attribute
, NULL
);
14143 process_power_specific (FILE * file
)
14145 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14146 display_power_gnu_attribute
);
14150 process_s390_specific (FILE * file
)
14152 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14153 display_s390_gnu_attribute
);
14157 process_sparc_specific (FILE * file
)
14159 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14160 display_sparc_gnu_attribute
);
14164 process_tic6x_specific (FILE * file
)
14166 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
14167 display_tic6x_attribute
, NULL
);
14171 process_msp430x_specific (FILE * file
)
14173 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
14174 display_msp430x_attribute
, NULL
);
14177 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14178 Print the Address, Access and Initial fields of an entry at VMA ADDR
14179 and return the VMA of the next entry, or -1 if there was a problem.
14180 Does not read from DATA_END or beyond. */
14183 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14184 unsigned char * data_end
)
14187 print_vma (addr
, LONG_HEX
);
14189 if (addr
< pltgot
+ 0xfff0)
14190 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14192 printf ("%10s", "");
14195 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14199 unsigned char * from
= data
+ addr
- pltgot
;
14201 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14203 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14204 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14205 return (bfd_vma
) -1;
14209 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14210 print_vma (entry
, LONG_HEX
);
14213 return addr
+ (is_32bit_elf
? 4 : 8);
14216 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14217 PLTGOT. Print the Address and Initial fields of an entry at VMA
14218 ADDR and return the VMA of the next entry. */
14221 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14224 print_vma (addr
, LONG_HEX
);
14227 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14232 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14233 print_vma (entry
, LONG_HEX
);
14235 return addr
+ (is_32bit_elf
? 4 : 8);
14239 print_mips_ases (unsigned int mask
)
14241 if (mask
& AFL_ASE_DSP
)
14242 fputs ("\n\tDSP ASE", stdout
);
14243 if (mask
& AFL_ASE_DSPR2
)
14244 fputs ("\n\tDSP R2 ASE", stdout
);
14245 if (mask
& AFL_ASE_DSPR3
)
14246 fputs ("\n\tDSP R3 ASE", stdout
);
14247 if (mask
& AFL_ASE_EVA
)
14248 fputs ("\n\tEnhanced VA Scheme", stdout
);
14249 if (mask
& AFL_ASE_MCU
)
14250 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14251 if (mask
& AFL_ASE_MDMX
)
14252 fputs ("\n\tMDMX ASE", stdout
);
14253 if (mask
& AFL_ASE_MIPS3D
)
14254 fputs ("\n\tMIPS-3D ASE", stdout
);
14255 if (mask
& AFL_ASE_MT
)
14256 fputs ("\n\tMT ASE", stdout
);
14257 if (mask
& AFL_ASE_SMARTMIPS
)
14258 fputs ("\n\tSmartMIPS ASE", stdout
);
14259 if (mask
& AFL_ASE_VIRT
)
14260 fputs ("\n\tVZ ASE", stdout
);
14261 if (mask
& AFL_ASE_MSA
)
14262 fputs ("\n\tMSA ASE", stdout
);
14263 if (mask
& AFL_ASE_MIPS16
)
14264 fputs ("\n\tMIPS16 ASE", stdout
);
14265 if (mask
& AFL_ASE_MICROMIPS
)
14266 fputs ("\n\tMICROMIPS ASE", stdout
);
14267 if (mask
& AFL_ASE_XPA
)
14268 fputs ("\n\tXPA ASE", stdout
);
14270 fprintf (stdout
, "\n\t%s", _("None"));
14271 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14272 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14276 print_mips_isa_ext (unsigned int isa_ext
)
14281 fputs (_("None"), stdout
);
14284 fputs ("RMI XLR", stdout
);
14286 case AFL_EXT_OCTEON3
:
14287 fputs ("Cavium Networks Octeon3", stdout
);
14289 case AFL_EXT_OCTEON2
:
14290 fputs ("Cavium Networks Octeon2", stdout
);
14292 case AFL_EXT_OCTEONP
:
14293 fputs ("Cavium Networks OcteonP", stdout
);
14295 case AFL_EXT_LOONGSON_3A
:
14296 fputs ("Loongson 3A", stdout
);
14298 case AFL_EXT_OCTEON
:
14299 fputs ("Cavium Networks Octeon", stdout
);
14302 fputs ("Toshiba R5900", stdout
);
14305 fputs ("MIPS R4650", stdout
);
14308 fputs ("LSI R4010", stdout
);
14311 fputs ("NEC VR4100", stdout
);
14314 fputs ("Toshiba R3900", stdout
);
14316 case AFL_EXT_10000
:
14317 fputs ("MIPS R10000", stdout
);
14320 fputs ("Broadcom SB-1", stdout
);
14323 fputs ("NEC VR4111/VR4181", stdout
);
14326 fputs ("NEC VR4120", stdout
);
14329 fputs ("NEC VR5400", stdout
);
14332 fputs ("NEC VR5500", stdout
);
14334 case AFL_EXT_LOONGSON_2E
:
14335 fputs ("ST Microelectronics Loongson 2E", stdout
);
14337 case AFL_EXT_LOONGSON_2F
:
14338 fputs ("ST Microelectronics Loongson 2F", stdout
);
14341 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14346 get_mips_reg_size (int reg_size
)
14348 return (reg_size
== AFL_REG_NONE
) ? 0
14349 : (reg_size
== AFL_REG_32
) ? 32
14350 : (reg_size
== AFL_REG_64
) ? 64
14351 : (reg_size
== AFL_REG_128
) ? 128
14356 process_mips_specific (FILE * file
)
14358 Elf_Internal_Dyn
* entry
;
14359 Elf_Internal_Shdr
*sect
= NULL
;
14360 size_t liblist_offset
= 0;
14361 size_t liblistno
= 0;
14362 size_t conflictsno
= 0;
14363 size_t options_offset
= 0;
14364 size_t conflicts_offset
= 0;
14365 size_t pltrelsz
= 0;
14367 bfd_vma pltgot
= 0;
14368 bfd_vma mips_pltgot
= 0;
14369 bfd_vma jmprel
= 0;
14370 bfd_vma local_gotno
= 0;
14371 bfd_vma gotsym
= 0;
14372 bfd_vma symtabno
= 0;
14374 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14375 display_mips_gnu_attribute
);
14377 sect
= find_section (".MIPS.abiflags");
14381 Elf_External_ABIFlags_v0
*abiflags_ext
;
14382 Elf_Internal_ABIFlags_v0 abiflags_in
;
14384 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14385 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14388 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14389 sect
->sh_size
, _("MIPS ABI Flags section"));
14392 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14393 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14394 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14395 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14396 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14397 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14398 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14399 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14400 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14401 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14402 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14404 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14405 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14406 if (abiflags_in
.isa_rev
> 1)
14407 printf ("r%d", abiflags_in
.isa_rev
);
14408 printf ("\nGPR size: %d",
14409 get_mips_reg_size (abiflags_in
.gpr_size
));
14410 printf ("\nCPR1 size: %d",
14411 get_mips_reg_size (abiflags_in
.cpr1_size
));
14412 printf ("\nCPR2 size: %d",
14413 get_mips_reg_size (abiflags_in
.cpr2_size
));
14414 fputs ("\nFP ABI: ", stdout
);
14415 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14416 fputs ("ISA Extension: ", stdout
);
14417 print_mips_isa_ext (abiflags_in
.isa_ext
);
14418 fputs ("\nASEs:", stdout
);
14419 print_mips_ases (abiflags_in
.ases
);
14420 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14421 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14422 fputc ('\n', stdout
);
14423 free (abiflags_ext
);
14428 /* We have a lot of special sections. Thanks SGI! */
14429 if (dynamic_section
== NULL
)
14430 /* No information available. */
14433 for (entry
= dynamic_section
;
14434 /* PR 17531 file: 012-50589-0.004. */
14435 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14437 switch (entry
->d_tag
)
14439 case DT_MIPS_LIBLIST
:
14441 = offset_from_vma (file
, entry
->d_un
.d_val
,
14442 liblistno
* sizeof (Elf32_External_Lib
));
14444 case DT_MIPS_LIBLISTNO
:
14445 liblistno
= entry
->d_un
.d_val
;
14447 case DT_MIPS_OPTIONS
:
14448 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14450 case DT_MIPS_CONFLICT
:
14452 = offset_from_vma (file
, entry
->d_un
.d_val
,
14453 conflictsno
* sizeof (Elf32_External_Conflict
));
14455 case DT_MIPS_CONFLICTNO
:
14456 conflictsno
= entry
->d_un
.d_val
;
14459 pltgot
= entry
->d_un
.d_ptr
;
14461 case DT_MIPS_LOCAL_GOTNO
:
14462 local_gotno
= entry
->d_un
.d_val
;
14464 case DT_MIPS_GOTSYM
:
14465 gotsym
= entry
->d_un
.d_val
;
14467 case DT_MIPS_SYMTABNO
:
14468 symtabno
= entry
->d_un
.d_val
;
14470 case DT_MIPS_PLTGOT
:
14471 mips_pltgot
= entry
->d_un
.d_ptr
;
14474 pltrel
= entry
->d_un
.d_val
;
14477 pltrelsz
= entry
->d_un
.d_val
;
14480 jmprel
= entry
->d_un
.d_ptr
;
14486 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14488 Elf32_External_Lib
* elib
;
14491 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14493 sizeof (Elf32_External_Lib
),
14494 _("liblist section data"));
14497 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14498 (unsigned long) liblistno
);
14499 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14502 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14509 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14510 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14511 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14512 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14513 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14515 tmp
= gmtime (&atime
);
14516 snprintf (timebuf
, sizeof (timebuf
),
14517 "%04u-%02u-%02uT%02u:%02u:%02u",
14518 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14519 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14521 printf ("%3lu: ", (unsigned long) cnt
);
14522 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14523 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14525 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14526 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14527 liblist
.l_version
);
14529 if (liblist
.l_flags
== 0)
14533 static const struct
14540 { " EXACT_MATCH", LL_EXACT_MATCH
},
14541 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14542 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14543 { " EXPORTS", LL_EXPORTS
},
14544 { " DELAY_LOAD", LL_DELAY_LOAD
},
14545 { " DELTA", LL_DELTA
}
14547 int flags
= liblist
.l_flags
;
14550 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14551 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14553 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14554 flags
^= l_flags_vals
[fcnt
].bit
;
14557 printf (" %#x", (unsigned int) flags
);
14567 if (options_offset
!= 0)
14569 Elf_External_Options
* eopt
;
14570 Elf_Internal_Options
* iopt
;
14571 Elf_Internal_Options
* option
;
14574 sect
= section_headers
;
14576 /* Find the section header so that we get the size. */
14577 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14578 /* PR 17533 file: 012-277276-0.004. */
14581 error (_("No MIPS_OPTIONS header found\n"));
14585 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14586 sect
->sh_size
, _("options"));
14589 iopt
= (Elf_Internal_Options
*)
14590 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14593 error (_("Out of memory allocatinf space for MIPS options\n"));
14600 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14602 Elf_External_Options
* eoption
;
14604 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14606 option
->kind
= BYTE_GET (eoption
->kind
);
14607 option
->size
= BYTE_GET (eoption
->size
);
14608 option
->section
= BYTE_GET (eoption
->section
);
14609 option
->info
= BYTE_GET (eoption
->info
);
14611 /* PR 17531: file: ffa0fa3b. */
14612 if (option
->size
< sizeof (* eopt
)
14613 || offset
+ option
->size
> sect
->sh_size
)
14615 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14618 offset
+= option
->size
;
14624 printf (_("\nSection '%s' contains %d entries:\n"),
14625 printable_section_name (sect
), cnt
);
14634 switch (option
->kind
)
14637 /* This shouldn't happen. */
14638 printf (" NULL %d %lx", option
->section
, option
->info
);
14641 printf (" REGINFO ");
14642 if (elf_header
.e_machine
== EM_MIPS
)
14645 Elf32_External_RegInfo
* ereg
;
14646 Elf32_RegInfo reginfo
;
14648 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14649 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14650 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14651 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14652 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14653 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14654 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14656 printf ("GPR %08lx GP 0x%lx\n",
14657 reginfo
.ri_gprmask
,
14658 (unsigned long) reginfo
.ri_gp_value
);
14659 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14660 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14661 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14666 Elf64_External_RegInfo
* ereg
;
14667 Elf64_Internal_RegInfo reginfo
;
14669 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14670 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14671 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14672 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14673 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14674 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14675 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14677 printf ("GPR %08lx GP 0x",
14678 reginfo
.ri_gprmask
);
14679 printf_vma (reginfo
.ri_gp_value
);
14682 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14683 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14684 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14688 case ODK_EXCEPTIONS
:
14689 fputs (" EXCEPTIONS fpe_min(", stdout
);
14690 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14691 fputs (") fpe_max(", stdout
);
14692 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14693 fputs (")", stdout
);
14695 if (option
->info
& OEX_PAGE0
)
14696 fputs (" PAGE0", stdout
);
14697 if (option
->info
& OEX_SMM
)
14698 fputs (" SMM", stdout
);
14699 if (option
->info
& OEX_FPDBUG
)
14700 fputs (" FPDBUG", stdout
);
14701 if (option
->info
& OEX_DISMISS
)
14702 fputs (" DISMISS", stdout
);
14705 fputs (" PAD ", stdout
);
14706 if (option
->info
& OPAD_PREFIX
)
14707 fputs (" PREFIX", stdout
);
14708 if (option
->info
& OPAD_POSTFIX
)
14709 fputs (" POSTFIX", stdout
);
14710 if (option
->info
& OPAD_SYMBOL
)
14711 fputs (" SYMBOL", stdout
);
14714 fputs (" HWPATCH ", stdout
);
14715 if (option
->info
& OHW_R4KEOP
)
14716 fputs (" R4KEOP", stdout
);
14717 if (option
->info
& OHW_R8KPFETCH
)
14718 fputs (" R8KPFETCH", stdout
);
14719 if (option
->info
& OHW_R5KEOP
)
14720 fputs (" R5KEOP", stdout
);
14721 if (option
->info
& OHW_R5KCVTL
)
14722 fputs (" R5KCVTL", stdout
);
14725 fputs (" FILL ", stdout
);
14726 /* XXX Print content of info word? */
14729 fputs (" TAGS ", stdout
);
14730 /* XXX Print content of info word? */
14733 fputs (" HWAND ", stdout
);
14734 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14735 fputs (" R4KEOP_CHECKED", stdout
);
14736 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14737 fputs (" R4KEOP_CLEAN", stdout
);
14740 fputs (" HWOR ", stdout
);
14741 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14742 fputs (" R4KEOP_CHECKED", stdout
);
14743 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14744 fputs (" R4KEOP_CLEAN", stdout
);
14747 printf (" GP_GROUP %#06lx self-contained %#06lx",
14748 option
->info
& OGP_GROUP
,
14749 (option
->info
& OGP_SELF
) >> 16);
14752 printf (" IDENT %#06lx self-contained %#06lx",
14753 option
->info
& OGP_GROUP
,
14754 (option
->info
& OGP_SELF
) >> 16);
14757 /* This shouldn't happen. */
14758 printf (" %3d ??? %d %lx",
14759 option
->kind
, option
->section
, option
->info
);
14763 len
= sizeof (* eopt
);
14764 while (len
< option
->size
)
14766 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14768 if (ISPRINT (datum
))
14769 printf ("%c", datum
);
14771 printf ("\\%03o", datum
);
14774 fputs ("\n", stdout
);
14776 offset
+= option
->size
;
14784 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14786 Elf32_Conflict
* iconf
;
14789 if (dynamic_symbols
== NULL
)
14791 error (_("conflict list found without a dynamic symbol table\n"));
14795 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14798 error (_("Out of memory allocating space for dynamic conflicts\n"));
14804 Elf32_External_Conflict
* econf32
;
14806 econf32
= (Elf32_External_Conflict
*)
14807 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14808 sizeof (* econf32
), _("conflict"));
14812 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14813 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14819 Elf64_External_Conflict
* econf64
;
14821 econf64
= (Elf64_External_Conflict
*)
14822 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14823 sizeof (* econf64
), _("conflict"));
14827 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14828 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14833 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14834 (unsigned long) conflictsno
);
14835 puts (_(" Num: Index Value Name"));
14837 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14839 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14841 if (iconf
[cnt
] >= num_dynamic_syms
)
14842 printf (_("<corrupt symbol index>"));
14845 Elf_Internal_Sym
* psym
;
14847 psym
= & dynamic_symbols
[iconf
[cnt
]];
14848 print_vma (psym
->st_value
, FULL_HEX
);
14850 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14851 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14853 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14861 if (pltgot
!= 0 && local_gotno
!= 0)
14863 bfd_vma ent
, local_end
, global_end
;
14865 unsigned char * data
;
14866 unsigned char * data_end
;
14870 addr_size
= (is_32bit_elf
? 4 : 8);
14871 local_end
= pltgot
+ local_gotno
* addr_size
;
14873 /* PR binutils/17533 file: 012-111227-0.004 */
14874 if (symtabno
< gotsym
)
14876 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14877 (unsigned long) gotsym
, (unsigned long) symtabno
);
14881 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14882 /* PR 17531: file: 54c91a34. */
14883 if (global_end
< local_end
)
14885 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14889 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14890 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14891 global_end
- pltgot
, 1,
14892 _("Global Offset Table data"));
14895 data_end
= data
+ (global_end
- pltgot
);
14897 printf (_("\nPrimary GOT:\n"));
14898 printf (_(" Canonical gp value: "));
14899 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14902 printf (_(" Reserved entries:\n"));
14903 printf (_(" %*s %10s %*s Purpose\n"),
14904 addr_size
* 2, _("Address"), _("Access"),
14905 addr_size
* 2, _("Initial"));
14906 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14907 printf (_(" Lazy resolver\n"));
14908 if (ent
== (bfd_vma
) -1)
14909 goto got_print_fail
;
14911 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14912 >> (addr_size
* 8 - 1)) != 0)
14914 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14915 printf (_(" Module pointer (GNU extension)\n"));
14916 if (ent
== (bfd_vma
) -1)
14917 goto got_print_fail
;
14921 if (ent
< local_end
)
14923 printf (_(" Local entries:\n"));
14924 printf (" %*s %10s %*s\n",
14925 addr_size
* 2, _("Address"), _("Access"),
14926 addr_size
* 2, _("Initial"));
14927 while (ent
< local_end
)
14929 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14931 if (ent
== (bfd_vma
) -1)
14932 goto got_print_fail
;
14937 if (gotsym
< symtabno
)
14941 printf (_(" Global entries:\n"));
14942 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14943 addr_size
* 2, _("Address"),
14945 addr_size
* 2, _("Initial"),
14946 addr_size
* 2, _("Sym.Val."),
14948 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14949 _("Ndx"), _("Name"));
14951 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14953 for (i
= gotsym
; i
< symtabno
; i
++)
14955 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14958 if (dynamic_symbols
== NULL
)
14959 printf (_("<no dynamic symbols>"));
14960 else if (i
< num_dynamic_syms
)
14962 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14964 print_vma (psym
->st_value
, LONG_HEX
);
14965 printf (" %-7s %3s ",
14966 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14967 get_symbol_index_type (psym
->st_shndx
));
14969 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14970 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14972 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14975 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14976 (unsigned long) i
);
14979 if (ent
== (bfd_vma
) -1)
14990 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14993 size_t offset
, rel_offset
;
14994 unsigned long count
, i
;
14995 unsigned char * data
;
14996 int addr_size
, sym_width
;
14997 Elf_Internal_Rela
* rels
;
14999 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15000 if (pltrel
== DT_RELA
)
15002 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15007 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15012 addr_size
= (is_32bit_elf
? 4 : 8);
15013 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15015 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15016 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15017 1, _("Procedure Linkage Table data"));
15021 printf ("\nPLT GOT:\n\n");
15022 printf (_(" Reserved entries:\n"));
15023 printf (_(" %*s %*s Purpose\n"),
15024 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15025 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15026 printf (_(" PLT lazy resolver\n"));
15027 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15028 printf (_(" Module pointer\n"));
15031 printf (_(" Entries:\n"));
15032 printf (" %*s %*s %*s %-7s %3s %s\n",
15033 addr_size
* 2, _("Address"),
15034 addr_size
* 2, _("Initial"),
15035 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15036 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15037 for (i
= 0; i
< count
; i
++)
15039 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15041 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15044 if (idx
>= num_dynamic_syms
)
15045 printf (_("<corrupt symbol index: %lu>"), idx
);
15048 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15050 print_vma (psym
->st_value
, LONG_HEX
);
15051 printf (" %-7s %3s ",
15052 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15053 get_symbol_index_type (psym
->st_shndx
));
15054 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15055 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15057 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15072 process_nds32_specific (FILE * file
)
15074 Elf_Internal_Shdr
*sect
= NULL
;
15076 sect
= find_section (".nds32_e_flags");
15079 unsigned int *flag
;
15081 printf ("\nNDS32 elf flags section:\n");
15082 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15083 sect
->sh_size
, _("NDS32 elf flags section"));
15085 switch ((*flag
) & 0x3)
15088 printf ("(VEC_SIZE):\tNo entry.\n");
15091 printf ("(VEC_SIZE):\t4 bytes\n");
15094 printf ("(VEC_SIZE):\t16 bytes\n");
15097 printf ("(VEC_SIZE):\treserved\n");
15106 process_gnu_liblist (FILE * file
)
15108 Elf_Internal_Shdr
* section
;
15109 Elf_Internal_Shdr
* string_sec
;
15110 Elf32_External_Lib
* elib
;
15112 size_t strtab_size
;
15119 for (i
= 0, section
= section_headers
;
15120 i
< elf_header
.e_shnum
;
15123 switch (section
->sh_type
)
15125 case SHT_GNU_LIBLIST
:
15126 if (section
->sh_link
>= elf_header
.e_shnum
)
15129 elib
= (Elf32_External_Lib
*)
15130 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15131 _("liblist section data"));
15135 string_sec
= section_headers
+ section
->sh_link
;
15137 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15138 string_sec
->sh_size
,
15139 _("liblist string table"));
15141 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15147 strtab_size
= string_sec
->sh_size
;
15149 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15150 printable_section_name (section
),
15151 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15153 puts (_(" Library Time Stamp Checksum Version Flags"));
15155 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15163 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15164 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15165 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15166 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15167 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15169 tmp
= gmtime (&atime
);
15170 snprintf (timebuf
, sizeof (timebuf
),
15171 "%04u-%02u-%02uT%02u:%02u:%02u",
15172 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15173 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15175 printf ("%3lu: ", (unsigned long) cnt
);
15177 printf ("%-20s", liblist
.l_name
< strtab_size
15178 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15180 printf ("%-20.20s", liblist
.l_name
< strtab_size
15181 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15182 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15183 liblist
.l_version
, liblist
.l_flags
);
15194 static const char *
15195 get_note_type (unsigned e_type
)
15197 static char buff
[64];
15199 if (elf_header
.e_type
== ET_CORE
)
15203 return _("NT_AUXV (auxiliary vector)");
15205 return _("NT_PRSTATUS (prstatus structure)");
15207 return _("NT_FPREGSET (floating point registers)");
15209 return _("NT_PRPSINFO (prpsinfo structure)");
15210 case NT_TASKSTRUCT
:
15211 return _("NT_TASKSTRUCT (task structure)");
15213 return _("NT_PRXFPREG (user_xfpregs structure)");
15215 return _("NT_PPC_VMX (ppc Altivec registers)");
15217 return _("NT_PPC_VSX (ppc VSX registers)");
15219 return _("NT_386_TLS (x86 TLS information)");
15220 case NT_386_IOPERM
:
15221 return _("NT_386_IOPERM (x86 I/O permissions)");
15222 case NT_X86_XSTATE
:
15223 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15224 case NT_S390_HIGH_GPRS
:
15225 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15226 case NT_S390_TIMER
:
15227 return _("NT_S390_TIMER (s390 timer register)");
15228 case NT_S390_TODCMP
:
15229 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15230 case NT_S390_TODPREG
:
15231 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15233 return _("NT_S390_CTRS (s390 control registers)");
15234 case NT_S390_PREFIX
:
15235 return _("NT_S390_PREFIX (s390 prefix register)");
15236 case NT_S390_LAST_BREAK
:
15237 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15238 case NT_S390_SYSTEM_CALL
:
15239 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15241 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15242 case NT_S390_VXRS_LOW
:
15243 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15244 case NT_S390_VXRS_HIGH
:
15245 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15247 return _("NT_ARM_VFP (arm VFP registers)");
15249 return _("NT_ARM_TLS (AArch TLS registers)");
15250 case NT_ARM_HW_BREAK
:
15251 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15252 case NT_ARM_HW_WATCH
:
15253 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15255 return _("NT_PSTATUS (pstatus structure)");
15257 return _("NT_FPREGS (floating point registers)");
15259 return _("NT_PSINFO (psinfo structure)");
15261 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15263 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15264 case NT_WIN32PSTATUS
:
15265 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15267 return _("NT_SIGINFO (siginfo_t data)");
15269 return _("NT_FILE (mapped files)");
15277 return _("NT_VERSION (version)");
15279 return _("NT_ARCH (architecture)");
15284 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15289 print_core_note (Elf_Internal_Note
*pnote
)
15291 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15292 bfd_vma count
, page_size
;
15293 unsigned char *descdata
, *filenames
, *descend
;
15295 if (pnote
->type
!= NT_FILE
)
15301 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15302 /* Still "successful". */
15307 if (pnote
->descsz
< 2 * addr_size
)
15309 printf (_(" Malformed note - too short for header\n"));
15313 descdata
= (unsigned char *) pnote
->descdata
;
15314 descend
= descdata
+ pnote
->descsz
;
15316 if (descdata
[pnote
->descsz
- 1] != '\0')
15318 printf (_(" Malformed note - does not end with \\0\n"));
15322 count
= byte_get (descdata
, addr_size
);
15323 descdata
+= addr_size
;
15325 page_size
= byte_get (descdata
, addr_size
);
15326 descdata
+= addr_size
;
15328 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15330 printf (_(" Malformed note - too short for supplied file count\n"));
15334 printf (_(" Page size: "));
15335 print_vma (page_size
, DEC
);
15338 printf (_(" %*s%*s%*s\n"),
15339 (int) (2 + 2 * addr_size
), _("Start"),
15340 (int) (4 + 2 * addr_size
), _("End"),
15341 (int) (4 + 2 * addr_size
), _("Page Offset"));
15342 filenames
= descdata
+ count
* 3 * addr_size
;
15343 while (count
-- > 0)
15345 bfd_vma start
, end
, file_ofs
;
15347 if (filenames
== descend
)
15349 printf (_(" Malformed note - filenames end too early\n"));
15353 start
= byte_get (descdata
, addr_size
);
15354 descdata
+= addr_size
;
15355 end
= byte_get (descdata
, addr_size
);
15356 descdata
+= addr_size
;
15357 file_ofs
= byte_get (descdata
, addr_size
);
15358 descdata
+= addr_size
;
15361 print_vma (start
, FULL_HEX
);
15363 print_vma (end
, FULL_HEX
);
15365 print_vma (file_ofs
, FULL_HEX
);
15366 printf ("\n %s\n", filenames
);
15368 filenames
+= 1 + strlen ((char *) filenames
);
15374 static const char *
15375 get_gnu_elf_note_type (unsigned e_type
)
15377 static char buff
[64];
15381 case NT_GNU_ABI_TAG
:
15382 return _("NT_GNU_ABI_TAG (ABI version tag)");
15384 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15385 case NT_GNU_BUILD_ID
:
15386 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15387 case NT_GNU_GOLD_VERSION
:
15388 return _("NT_GNU_GOLD_VERSION (gold version)");
15393 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15398 print_gnu_note (Elf_Internal_Note
*pnote
)
15400 switch (pnote
->type
)
15402 case NT_GNU_BUILD_ID
:
15406 printf (_(" Build ID: "));
15407 for (i
= 0; i
< pnote
->descsz
; ++i
)
15408 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15413 case NT_GNU_ABI_TAG
:
15415 unsigned long os
, major
, minor
, subminor
;
15416 const char *osname
;
15418 /* PR 17531: file: 030-599401-0.004. */
15419 if (pnote
->descsz
< 16)
15421 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15425 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15426 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15427 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15428 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15432 case GNU_ABI_TAG_LINUX
:
15435 case GNU_ABI_TAG_HURD
:
15438 case GNU_ABI_TAG_SOLARIS
:
15439 osname
= "Solaris";
15441 case GNU_ABI_TAG_FREEBSD
:
15442 osname
= "FreeBSD";
15444 case GNU_ABI_TAG_NETBSD
:
15447 case GNU_ABI_TAG_SYLLABLE
:
15448 osname
= "Syllable";
15450 case GNU_ABI_TAG_NACL
:
15454 osname
= "Unknown";
15458 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15459 major
, minor
, subminor
);
15463 case NT_GNU_GOLD_VERSION
:
15467 printf (_(" Version: "));
15468 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15469 printf ("%c", pnote
->descdata
[i
]);
15478 static const char *
15479 get_v850_elf_note_type (enum v850_notes n_type
)
15481 static char buff
[64];
15485 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15486 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15487 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15488 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15489 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15490 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15492 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15498 print_v850_note (Elf_Internal_Note
* pnote
)
15502 if (pnote
->descsz
!= 4)
15504 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15508 printf (_("not set\n"));
15512 switch (pnote
->type
)
15514 case V850_NOTE_ALIGNMENT
:
15517 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15518 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15522 case V850_NOTE_DATA_SIZE
:
15525 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15526 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15530 case V850_NOTE_FPU_INFO
:
15533 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15534 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15538 case V850_NOTE_MMU_INFO
:
15539 case V850_NOTE_CACHE_INFO
:
15540 case V850_NOTE_SIMD_INFO
:
15541 if (val
== EF_RH850_SIMD
)
15543 printf (_("yes\n"));
15549 /* An 'unknown note type' message will already have been displayed. */
15553 printf (_("unknown value: %x\n"), val
);
15558 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15560 unsigned int version
;
15562 switch (pnote
->type
)
15564 case NT_NETBSD_IDENT
:
15565 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15566 if ((version
/ 10000) % 100)
15567 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15568 version
, version
/ 100000000, (version
/ 1000000) % 100,
15569 (version
/ 10000) % 100 > 26 ? "Z" : "",
15570 'A' + (version
/ 10000) % 26);
15572 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15573 version
, version
/ 100000000, (version
/ 1000000) % 100,
15574 (version
/ 100) % 100);
15577 case NT_NETBSD_MARCH
:
15578 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15586 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15591 static const char *
15592 get_freebsd_elfcore_note_type (unsigned e_type
)
15596 case NT_FREEBSD_THRMISC
:
15597 return _("NT_THRMISC (thrmisc structure)");
15598 case NT_FREEBSD_PROCSTAT_PROC
:
15599 return _("NT_PROCSTAT_PROC (proc data)");
15600 case NT_FREEBSD_PROCSTAT_FILES
:
15601 return _("NT_PROCSTAT_FILES (files data)");
15602 case NT_FREEBSD_PROCSTAT_VMMAP
:
15603 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15604 case NT_FREEBSD_PROCSTAT_GROUPS
:
15605 return _("NT_PROCSTAT_GROUPS (groups data)");
15606 case NT_FREEBSD_PROCSTAT_UMASK
:
15607 return _("NT_PROCSTAT_UMASK (umask data)");
15608 case NT_FREEBSD_PROCSTAT_RLIMIT
:
15609 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15610 case NT_FREEBSD_PROCSTAT_OSREL
:
15611 return _("NT_PROCSTAT_OSREL (osreldate data)");
15612 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
15613 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15614 case NT_FREEBSD_PROCSTAT_AUXV
:
15615 return _("NT_PROCSTAT_AUXV (auxv data)");
15617 return get_note_type (e_type
);
15620 static const char *
15621 get_netbsd_elfcore_note_type (unsigned e_type
)
15623 static char buff
[64];
15625 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15627 /* NetBSD core "procinfo" structure. */
15628 return _("NetBSD procinfo structure");
15631 /* As of Jan 2002 there are no other machine-independent notes
15632 defined for NetBSD core files. If the note type is less
15633 than the start of the machine-dependent note types, we don't
15636 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15638 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15642 switch (elf_header
.e_machine
)
15644 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15645 and PT_GETFPREGS == mach+2. */
15650 case EM_SPARC32PLUS
:
15654 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15655 return _("PT_GETREGS (reg structure)");
15656 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15657 return _("PT_GETFPREGS (fpreg structure)");
15663 /* On all other arch's, PT_GETREGS == mach+1 and
15664 PT_GETFPREGS == mach+3. */
15668 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15669 return _("PT_GETREGS (reg structure)");
15670 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15671 return _("PT_GETFPREGS (fpreg structure)");
15677 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15678 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15682 static const char *
15683 get_stapsdt_note_type (unsigned e_type
)
15685 static char buff
[64];
15690 return _("NT_STAPSDT (SystemTap probe descriptors)");
15696 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15701 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15703 int addr_size
= is_32bit_elf
? 4 : 8;
15704 char *data
= pnote
->descdata
;
15705 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15706 bfd_vma pc
, base_addr
, semaphore
;
15707 char *provider
, *probe
, *arg_fmt
;
15709 pc
= byte_get ((unsigned char *) data
, addr_size
);
15711 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15713 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15717 data
+= strlen (data
) + 1;
15719 data
+= strlen (data
) + 1;
15721 data
+= strlen (data
) + 1;
15723 printf (_(" Provider: %s\n"), provider
);
15724 printf (_(" Name: %s\n"), probe
);
15725 printf (_(" Location: "));
15726 print_vma (pc
, FULL_HEX
);
15727 printf (_(", Base: "));
15728 print_vma (base_addr
, FULL_HEX
);
15729 printf (_(", Semaphore: "));
15730 print_vma (semaphore
, FULL_HEX
);
15732 printf (_(" Arguments: %s\n"), arg_fmt
);
15734 return data
== data_end
;
15737 static const char *
15738 get_ia64_vms_note_type (unsigned e_type
)
15740 static char buff
[64];
15745 return _("NT_VMS_MHD (module header)");
15747 return _("NT_VMS_LNM (language name)");
15749 return _("NT_VMS_SRC (source files)");
15751 return "NT_VMS_TITLE";
15753 return _("NT_VMS_EIDC (consistency check)");
15754 case NT_VMS_FPMODE
:
15755 return _("NT_VMS_FPMODE (FP mode)");
15756 case NT_VMS_LINKTIME
:
15757 return "NT_VMS_LINKTIME";
15758 case NT_VMS_IMGNAM
:
15759 return _("NT_VMS_IMGNAM (image name)");
15761 return _("NT_VMS_IMGID (image id)");
15762 case NT_VMS_LINKID
:
15763 return _("NT_VMS_LINKID (link id)");
15764 case NT_VMS_IMGBID
:
15765 return _("NT_VMS_IMGBID (build id)");
15766 case NT_VMS_GSTNAM
:
15767 return _("NT_VMS_GSTNAM (sym table name)");
15768 case NT_VMS_ORIG_DYN
:
15769 return "NT_VMS_ORIG_DYN";
15770 case NT_VMS_PATCHTIME
:
15771 return "NT_VMS_PATCHTIME";
15773 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15779 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15781 switch (pnote
->type
)
15784 if (pnote
->descsz
> 36)
15786 size_t l
= strlen (pnote
->descdata
+ 34);
15787 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15788 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15789 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15790 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15793 printf (_(" Invalid size\n"));
15796 printf (_(" Language: %s\n"), pnote
->descdata
);
15799 case NT_VMS_FPMODE
:
15800 printf (_(" Floating Point mode: "));
15801 printf ("0x%016" BFD_VMA_FMT
"x\n",
15802 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15804 case NT_VMS_LINKTIME
:
15805 printf (_(" Link time: "));
15807 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15810 case NT_VMS_PATCHTIME
:
15811 printf (_(" Patch time: "));
15813 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15816 case NT_VMS_ORIG_DYN
:
15817 printf (_(" Major id: %u, minor id: %u\n"),
15818 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15819 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15820 printf (_(" Last modified : "));
15822 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15823 printf (_("\n Link flags : "));
15824 printf ("0x%016" BFD_VMA_FMT
"x\n",
15825 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15826 printf (_(" Header flags: 0x%08x\n"),
15827 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15828 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15831 case NT_VMS_IMGNAM
:
15832 printf (_(" Image name: %s\n"), pnote
->descdata
);
15834 case NT_VMS_GSTNAM
:
15835 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15838 printf (_(" Image id: %s\n"), pnote
->descdata
);
15840 case NT_VMS_LINKID
:
15841 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15849 /* Note that by the ELF standard, the name field is already null byte
15850 terminated, and namesz includes the terminating null byte.
15851 I.E. the value of namesz for the name "FSF" is 4.
15853 If the value of namesz is zero, there is no name present. */
15855 process_note (Elf_Internal_Note
* pnote
)
15857 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15860 if (pnote
->namesz
== 0)
15861 /* If there is no note name, then use the default set of
15862 note type strings. */
15863 nt
= get_note_type (pnote
->type
);
15865 else if (const_strneq (pnote
->namedata
, "GNU"))
15866 /* GNU-specific object file notes. */
15867 nt
= get_gnu_elf_note_type (pnote
->type
);
15869 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
15870 /* FreeBSD-specific core file notes. */
15871 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
15873 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15874 /* NetBSD-specific core file notes. */
15875 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15877 else if (const_strneq (pnote
->namedata
, "NetBSD"))
15878 /* NetBSD-specific core file notes. */
15879 return process_netbsd_elf_note (pnote
);
15881 else if (strneq (pnote
->namedata
, "SPU/", 4))
15883 /* SPU-specific core file notes. */
15884 nt
= pnote
->namedata
+ 4;
15888 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15889 /* VMS/ia64-specific file notes. */
15890 nt
= get_ia64_vms_note_type (pnote
->type
);
15892 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15893 nt
= get_stapsdt_note_type (pnote
->type
);
15896 /* Don't recognize this note name; just use the default set of
15897 note type strings. */
15898 nt
= get_note_type (pnote
->type
);
15900 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15902 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15903 return print_ia64_vms_note (pnote
);
15904 else if (const_strneq (pnote
->namedata
, "GNU"))
15905 return print_gnu_note (pnote
);
15906 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15907 return print_stapsdt_note (pnote
);
15908 else if (const_strneq (pnote
->namedata
, "CORE"))
15909 return print_core_note (pnote
);
15916 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15918 Elf_External_Note
* pnotes
;
15919 Elf_External_Note
* external
;
15926 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15928 if (pnotes
== NULL
)
15933 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15934 (unsigned long) offset
, (unsigned long) length
);
15935 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15937 end
= (char *) pnotes
+ length
;
15938 while ((char *) external
< end
)
15940 Elf_Internal_Note inote
;
15943 char * temp
= NULL
;
15944 size_t data_remaining
= end
- (char *) external
;
15946 if (!is_ia64_vms ())
15948 /* PR binutils/15191
15949 Make sure that there is enough data to read. */
15950 min_notesz
= offsetof (Elf_External_Note
, name
);
15951 if (data_remaining
< min_notesz
)
15953 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15954 (int) data_remaining
);
15957 inote
.type
= BYTE_GET (external
->type
);
15958 inote
.namesz
= BYTE_GET (external
->namesz
);
15959 inote
.namedata
= external
->name
;
15960 inote
.descsz
= BYTE_GET (external
->descsz
);
15961 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15962 /* PR 17531: file: 3443835e. */
15963 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15965 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15966 inote
.descdata
= inote
.namedata
;
15970 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15971 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15975 Elf64_External_VMS_Note
*vms_external
;
15977 /* PR binutils/15191
15978 Make sure that there is enough data to read. */
15979 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15980 if (data_remaining
< min_notesz
)
15982 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15983 (int) data_remaining
);
15987 vms_external
= (Elf64_External_VMS_Note
*) external
;
15988 inote
.type
= BYTE_GET (vms_external
->type
);
15989 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15990 inote
.namedata
= vms_external
->name
;
15991 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15992 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15993 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15994 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15997 if (inote
.descdata
< (char *) external
+ min_notesz
15998 || next
< (char *) external
+ min_notesz
15999 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16000 || inote
.namedata
+ inote
.namesz
< inote
.namedata
16001 || inote
.descdata
+ inote
.descsz
< inote
.descdata
16002 || data_remaining
< (size_t)(next
- (char *) external
))
16004 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
16005 (unsigned long) ((char *) external
- (char *) pnotes
));
16006 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
16007 inote
.type
, inote
.namesz
, inote
.descsz
);
16011 external
= (Elf_External_Note
*) next
;
16013 /* Verify that name is null terminated. It appears that at least
16014 one version of Linux (RedHat 6.0) generates corefiles that don't
16015 comply with the ELF spec by failing to include the null byte in
16017 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
16019 temp
= (char *) malloc (inote
.namesz
+ 1);
16022 error (_("Out of memory allocating space for inote name\n"));
16027 strncpy (temp
, inote
.namedata
, inote
.namesz
);
16028 temp
[inote
.namesz
] = 0;
16030 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16031 inote
.namedata
= temp
;
16034 res
&= process_note (& inote
);
16049 process_corefile_note_segments (FILE * file
)
16051 Elf_Internal_Phdr
* segment
;
16055 if (! get_program_headers (file
))
16058 for (i
= 0, segment
= program_headers
;
16059 i
< elf_header
.e_phnum
;
16062 if (segment
->p_type
== PT_NOTE
)
16063 res
&= process_corefile_note_segment (file
,
16064 (bfd_vma
) segment
->p_offset
,
16065 (bfd_vma
) segment
->p_filesz
);
16072 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
16074 Elf_External_Note
* pnotes
;
16075 Elf_External_Note
* external
;
16082 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16084 if (pnotes
== NULL
)
16088 end
= (char*) pnotes
+ length
;
16090 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16091 (unsigned long) offset
, (unsigned long) length
);
16093 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
16095 Elf_External_Note
* next
;
16096 Elf_Internal_Note inote
;
16098 inote
.type
= BYTE_GET (external
->type
);
16099 inote
.namesz
= BYTE_GET (external
->namesz
);
16100 inote
.namedata
= external
->name
;
16101 inote
.descsz
= BYTE_GET (external
->descsz
);
16102 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16103 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16105 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
16107 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16108 inote
.descdata
= inote
.namedata
;
16112 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
16114 if ( ((char *) next
> end
)
16115 || ((char *) next
< (char *) pnotes
))
16117 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16118 (unsigned long) ((char *) external
- (char *) pnotes
));
16119 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16120 inote
.type
, inote
.namesz
, inote
.descsz
);
16126 /* Prevent out-of-bounds indexing. */
16127 if ( inote
.namedata
+ inote
.namesz
> end
16128 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
16130 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16131 (unsigned long) ((char *) external
- (char *) pnotes
));
16132 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16133 inote
.type
, inote
.namesz
, inote
.descsz
);
16137 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
16139 if (! print_v850_note (& inote
))
16142 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16143 inote
.namesz
, inote
.descsz
);
16153 process_note_sections (FILE * file
)
16155 Elf_Internal_Shdr
* section
;
16160 for (i
= 0, section
= section_headers
;
16161 i
< elf_header
.e_shnum
&& section
!= NULL
;
16164 if (section
->sh_type
== SHT_NOTE
)
16166 res
&= process_corefile_note_segment (file
,
16167 (bfd_vma
) section
->sh_offset
,
16168 (bfd_vma
) section
->sh_size
);
16172 if (( elf_header
.e_machine
== EM_V800
16173 || elf_header
.e_machine
== EM_V850
16174 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16175 && section
->sh_type
== SHT_RENESAS_INFO
)
16177 res
&= process_v850_notes (file
,
16178 (bfd_vma
) section
->sh_offset
,
16179 (bfd_vma
) section
->sh_size
);
16185 /* Try processing NOTE segments instead. */
16186 return process_corefile_note_segments (file
);
16192 process_notes (FILE * file
)
16194 /* If we have not been asked to display the notes then do nothing. */
16198 if (elf_header
.e_type
!= ET_CORE
)
16199 return process_note_sections (file
);
16201 /* No program headers means no NOTE segment. */
16202 if (elf_header
.e_phnum
> 0)
16203 return process_corefile_note_segments (file
);
16205 printf (_("No note segments present in the core file.\n"));
16210 process_arch_specific (FILE * file
)
16215 switch (elf_header
.e_machine
)
16218 return process_arm_specific (file
);
16220 case EM_MIPS_RS3_LE
:
16221 return process_mips_specific (file
);
16224 return process_nds32_specific (file
);
16227 return process_power_specific (file
);
16231 return process_s390_specific (file
);
16234 case EM_SPARC32PLUS
:
16236 return process_sparc_specific (file
);
16239 return process_tic6x_specific (file
);
16242 return process_msp430x_specific (file
);
16250 get_file_header (FILE * file
)
16252 /* Read in the identity array. */
16253 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16256 /* Determine how to read the rest of the header. */
16257 switch (elf_header
.e_ident
[EI_DATA
])
16259 default: /* fall through */
16260 case ELFDATANONE
: /* fall through */
16262 byte_get
= byte_get_little_endian
;
16263 byte_put
= byte_put_little_endian
;
16266 byte_get
= byte_get_big_endian
;
16267 byte_put
= byte_put_big_endian
;
16271 /* For now we only support 32 bit and 64 bit ELF files. */
16272 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16274 /* Read in the rest of the header. */
16277 Elf32_External_Ehdr ehdr32
;
16279 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16282 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16283 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16284 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16285 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16286 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16287 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16288 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16289 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16290 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16291 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16292 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16293 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16294 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16298 Elf64_External_Ehdr ehdr64
;
16300 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16301 we will not be able to cope with the 64bit data found in
16302 64 ELF files. Detect this now and abort before we start
16303 overwriting things. */
16304 if (sizeof (bfd_vma
) < 8)
16306 error (_("This instance of readelf has been built without support for a\n\
16307 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16311 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16314 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16315 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16316 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16317 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16318 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16319 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16320 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16321 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16322 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16323 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16324 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16325 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16326 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16329 if (elf_header
.e_shoff
)
16331 /* There may be some extensions in the first section header. Don't
16332 bomb if we can't read it. */
16334 get_32bit_section_headers (file
, TRUE
);
16336 get_64bit_section_headers (file
, TRUE
);
16342 /* Process one ELF object file according to the command line options.
16343 This file may actually be stored in an archive. The file is
16344 positioned at the start of the ELF object. */
16347 process_object (char * file_name
, FILE * file
)
16351 if (! get_file_header (file
))
16353 error (_("%s: Failed to read file header\n"), file_name
);
16357 /* Initialise per file variables. */
16358 for (i
= ARRAY_SIZE (version_info
); i
--;)
16359 version_info
[i
] = 0;
16361 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16362 dynamic_info
[i
] = 0;
16363 dynamic_info_DT_GNU_HASH
= 0;
16365 /* Process the file. */
16367 printf (_("\nFile: %s\n"), file_name
);
16369 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16370 Note we do this even if cmdline_dump_sects is empty because we
16371 must make sure that the dump_sets array is zeroed out before each
16372 object file is processed. */
16373 if (num_dump_sects
> num_cmdline_dump_sects
)
16374 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16376 if (num_cmdline_dump_sects
> 0)
16378 if (num_dump_sects
== 0)
16379 /* A sneaky way of allocating the dump_sects array. */
16380 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16382 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16383 memcpy (dump_sects
, cmdline_dump_sects
,
16384 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16387 if (! process_file_header ())
16390 if (! process_section_headers (file
))
16392 /* Without loaded section headers we cannot process lots of
16394 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16396 if (! do_using_dynamic
)
16397 do_syms
= do_dyn_syms
= do_reloc
= 0;
16400 if (! process_section_groups (file
))
16402 /* Without loaded section groups we cannot process unwind. */
16406 if (process_program_headers (file
))
16407 process_dynamic_section (file
);
16409 process_relocs (file
);
16411 process_unwind (file
);
16413 process_symbol_table (file
);
16415 process_syminfo (file
);
16417 process_version_sections (file
);
16419 process_section_contents (file
);
16421 process_notes (file
);
16423 process_gnu_liblist (file
);
16425 process_arch_specific (file
);
16427 if (program_headers
)
16429 free (program_headers
);
16430 program_headers
= NULL
;
16433 if (section_headers
)
16435 free (section_headers
);
16436 section_headers
= NULL
;
16441 free (string_table
);
16442 string_table
= NULL
;
16443 string_table_length
= 0;
16446 if (dynamic_strings
)
16448 free (dynamic_strings
);
16449 dynamic_strings
= NULL
;
16450 dynamic_strings_length
= 0;
16453 if (dynamic_symbols
)
16455 free (dynamic_symbols
);
16456 dynamic_symbols
= NULL
;
16457 num_dynamic_syms
= 0;
16460 if (dynamic_syminfo
)
16462 free (dynamic_syminfo
);
16463 dynamic_syminfo
= NULL
;
16466 if (dynamic_section
)
16468 free (dynamic_section
);
16469 dynamic_section
= NULL
;
16472 if (section_headers_groups
)
16474 free (section_headers_groups
);
16475 section_headers_groups
= NULL
;
16478 if (section_groups
)
16480 struct group_list
* g
;
16481 struct group_list
* next
;
16483 for (i
= 0; i
< group_count
; i
++)
16485 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16492 free (section_groups
);
16493 section_groups
= NULL
;
16496 free_debug_memory ();
16501 /* Process an ELF archive.
16502 On entry the file is positioned just after the ARMAG string. */
16505 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16507 struct archive_info arch
;
16508 struct archive_info nested_arch
;
16514 /* The ARCH structure is used to hold information about this archive. */
16515 arch
.file_name
= NULL
;
16517 arch
.index_array
= NULL
;
16518 arch
.sym_table
= NULL
;
16519 arch
.longnames
= NULL
;
16521 /* The NESTED_ARCH structure is used as a single-item cache of information
16522 about a nested archive (when members of a thin archive reside within
16523 another regular archive file). */
16524 nested_arch
.file_name
= NULL
;
16525 nested_arch
.file
= NULL
;
16526 nested_arch
.index_array
= NULL
;
16527 nested_arch
.sym_table
= NULL
;
16528 nested_arch
.longnames
= NULL
;
16530 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16536 if (do_archive_index
)
16538 if (arch
.sym_table
== NULL
)
16539 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16542 unsigned long i
, l
;
16543 unsigned long current_pos
;
16545 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16546 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16547 current_pos
= ftell (file
);
16549 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16551 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16553 char * member_name
;
16555 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16557 if (member_name
!= NULL
)
16559 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16561 if (qualified_name
!= NULL
)
16563 printf (_("Contents of binary %s at offset "), qualified_name
);
16564 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16566 free (qualified_name
);
16571 if (l
>= arch
.sym_size
)
16573 error (_("%s: end of the symbol table reached before the end of the index\n"),
16577 /* PR 17531: file: 0b6630b2. */
16578 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16579 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16582 if (arch
.uses_64bit_indicies
)
16587 if (l
< arch
.sym_size
)
16588 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16589 file_name
, arch
.sym_size
- l
);
16591 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16593 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16599 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16600 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16601 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16602 && !do_section_groups
&& !do_dyn_syms
)
16604 ret
= 0; /* Archive index only. */
16615 char * qualified_name
;
16617 /* Read the next archive header. */
16618 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16620 error (_("%s: failed to seek to next archive header\n"), file_name
);
16623 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16624 if (got
!= sizeof arch
.arhdr
)
16628 error (_("%s: failed to read archive header\n"), file_name
);
16632 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16634 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16639 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16641 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16642 if (archive_file_size
& 01)
16643 ++archive_file_size
;
16645 name
= get_archive_member_name (&arch
, &nested_arch
);
16648 error (_("%s: bad archive file name\n"), file_name
);
16652 namelen
= strlen (name
);
16654 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16655 if (qualified_name
== NULL
)
16657 error (_("%s: bad archive file name\n"), file_name
);
16662 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16664 /* This is a proxy for an external member of a thin archive. */
16665 FILE * member_file
;
16666 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16667 if (member_file_name
== NULL
)
16673 member_file
= fopen (member_file_name
, "rb");
16674 if (member_file
== NULL
)
16676 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16677 free (member_file_name
);
16682 archive_file_offset
= arch
.nested_member_origin
;
16684 ret
|= process_object (qualified_name
, member_file
);
16686 fclose (member_file
);
16687 free (member_file_name
);
16689 else if (is_thin_archive
)
16691 /* PR 15140: Allow for corrupt thin archives. */
16692 if (nested_arch
.file
== NULL
)
16694 error (_("%s: contains corrupt thin archive: %s\n"),
16700 /* This is a proxy for a member of a nested archive. */
16701 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16703 /* The nested archive file will have been opened and setup by
16704 get_archive_member_name. */
16705 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16707 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16712 ret
|= process_object (qualified_name
, nested_arch
.file
);
16716 archive_file_offset
= arch
.next_arhdr_offset
;
16717 arch
.next_arhdr_offset
+= archive_file_size
;
16719 ret
|= process_object (qualified_name
, file
);
16722 if (dump_sects
!= NULL
)
16726 num_dump_sects
= 0;
16729 free (qualified_name
);
16733 if (nested_arch
.file
!= NULL
)
16734 fclose (nested_arch
.file
);
16735 release_archive (&nested_arch
);
16736 release_archive (&arch
);
16742 process_file (char * file_name
)
16745 struct stat statbuf
;
16746 char armag
[SARMAG
];
16749 if (stat (file_name
, &statbuf
) < 0)
16751 if (errno
== ENOENT
)
16752 error (_("'%s': No such file\n"), file_name
);
16754 error (_("Could not locate '%s'. System error message: %s\n"),
16755 file_name
, strerror (errno
));
16759 if (! S_ISREG (statbuf
.st_mode
))
16761 error (_("'%s' is not an ordinary file\n"), file_name
);
16765 file
= fopen (file_name
, "rb");
16768 error (_("Input file '%s' is not readable.\n"), file_name
);
16772 if (fread (armag
, SARMAG
, 1, file
) != 1)
16774 error (_("%s: Failed to read file's magic number\n"), file_name
);
16779 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16781 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16782 ret
= process_archive (file_name
, file
, FALSE
);
16783 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16784 ret
= process_archive (file_name
, file
, TRUE
);
16787 if (do_archive_index
)
16788 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16792 archive_file_size
= archive_file_offset
= 0;
16793 ret
= process_object (file_name
, file
);
16798 current_file_size
= 0;
16802 #ifdef SUPPORT_DISASSEMBLY
16803 /* Needed by the i386 disassembler. For extra credit, someone could
16804 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16808 print_address (unsigned int addr
, FILE * outfile
)
16810 fprintf (outfile
,"0x%8.8x", addr
);
16813 /* Needed by the i386 disassembler. */
16815 db_task_printsym (unsigned int addr
)
16817 print_address (addr
, stderr
);
16822 main (int argc
, char ** argv
)
16826 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16827 setlocale (LC_MESSAGES
, "");
16829 #if defined (HAVE_SETLOCALE)
16830 setlocale (LC_CTYPE
, "");
16832 bindtextdomain (PACKAGE
, LOCALEDIR
);
16833 textdomain (PACKAGE
);
16835 expandargv (&argc
, &argv
);
16837 parse_args (argc
, argv
);
16839 if (num_dump_sects
> 0)
16841 /* Make a copy of the dump_sects array. */
16842 cmdline_dump_sects
= (dump_type
*)
16843 malloc (num_dump_sects
* sizeof (* dump_sects
));
16844 if (cmdline_dump_sects
== NULL
)
16845 error (_("Out of memory allocating dump request table.\n"));
16848 memcpy (cmdline_dump_sects
, dump_sects
,
16849 num_dump_sects
* sizeof (* dump_sects
));
16850 num_cmdline_dump_sects
= num_dump_sects
;
16854 if (optind
< (argc
- 1))
16856 else if (optind
>= argc
)
16858 warn (_("Nothing to do.\n"));
16863 while (optind
< argc
)
16864 err
|= process_file (argv
[optind
++]);
16866 if (dump_sects
!= NULL
)
16868 if (cmdline_dump_sects
!= NULL
)
16869 free (cmdline_dump_sects
);