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");
2384 case E_ARC_MACH_NPS400
:
2385 strcat (buf
, ", NPS400");
2388 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2389 new ELF with new architecture being read by an old version of
2390 readelf, or (c) An ELF built with non-GNU compiler that does not
2391 set the architecture in the e_flags. */
2393 if (e_machine
== EM_ARC_COMPACT
)
2394 strcat (buf
, ", Unknown ARCompact");
2396 strcat (buf
, ", Unknown ARC");
2400 switch (e_flags
& EF_ARC_OSABI_MSK
)
2402 case E_ARC_OSABI_ORIG
:
2403 strcat (buf
, ", (ABI:legacy)");
2405 case E_ARC_OSABI_V2
:
2406 strcat (buf
, ", (ABI:v2)");
2408 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2409 case E_ARC_OSABI_V3
:
2410 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2413 strcat (buf
, ", unrecognised ARC OSABI flag");
2419 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2424 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2425 e_flags
&= ~ EF_ARM_EABIMASK
;
2427 /* Handle "generic" ARM flags. */
2428 if (e_flags
& EF_ARM_RELEXEC
)
2430 strcat (buf
, ", relocatable executable");
2431 e_flags
&= ~ EF_ARM_RELEXEC
;
2434 /* Now handle EABI specific flags. */
2438 strcat (buf
, ", <unrecognized EABI>");
2443 case EF_ARM_EABI_VER1
:
2444 strcat (buf
, ", Version1 EABI");
2449 /* Process flags one bit at a time. */
2450 flag
= e_flags
& - e_flags
;
2455 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2456 strcat (buf
, ", sorted symbol tables");
2466 case EF_ARM_EABI_VER2
:
2467 strcat (buf
, ", Version2 EABI");
2472 /* Process flags one bit at a time. */
2473 flag
= e_flags
& - e_flags
;
2478 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2479 strcat (buf
, ", sorted symbol tables");
2482 case EF_ARM_DYNSYMSUSESEGIDX
:
2483 strcat (buf
, ", dynamic symbols use segment index");
2486 case EF_ARM_MAPSYMSFIRST
:
2487 strcat (buf
, ", mapping symbols precede others");
2497 case EF_ARM_EABI_VER3
:
2498 strcat (buf
, ", Version3 EABI");
2501 case EF_ARM_EABI_VER4
:
2502 strcat (buf
, ", Version4 EABI");
2507 /* Process flags one bit at a time. */
2508 flag
= e_flags
& - e_flags
;
2514 strcat (buf
, ", BE8");
2518 strcat (buf
, ", LE8");
2529 case EF_ARM_EABI_VER5
:
2530 strcat (buf
, ", Version5 EABI");
2535 /* Process flags one bit at a time. */
2536 flag
= e_flags
& - e_flags
;
2542 strcat (buf
, ", BE8");
2546 strcat (buf
, ", LE8");
2549 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2550 strcat (buf
, ", soft-float ABI");
2553 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2554 strcat (buf
, ", hard-float ABI");
2564 case EF_ARM_EABI_UNKNOWN
:
2565 strcat (buf
, ", GNU EABI");
2570 /* Process flags one bit at a time. */
2571 flag
= e_flags
& - e_flags
;
2576 case EF_ARM_INTERWORK
:
2577 strcat (buf
, ", interworking enabled");
2580 case EF_ARM_APCS_26
:
2581 strcat (buf
, ", uses APCS/26");
2584 case EF_ARM_APCS_FLOAT
:
2585 strcat (buf
, ", uses APCS/float");
2589 strcat (buf
, ", position independent");
2593 strcat (buf
, ", 8 bit structure alignment");
2596 case EF_ARM_NEW_ABI
:
2597 strcat (buf
, ", uses new ABI");
2600 case EF_ARM_OLD_ABI
:
2601 strcat (buf
, ", uses old ABI");
2604 case EF_ARM_SOFT_FLOAT
:
2605 strcat (buf
, ", software FP");
2608 case EF_ARM_VFP_FLOAT
:
2609 strcat (buf
, ", VFP");
2612 case EF_ARM_MAVERICK_FLOAT
:
2613 strcat (buf
, ", Maverick FP");
2624 strcat (buf
,_(", <unknown>"));
2628 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2630 --size
; /* Leave space for null terminator. */
2632 switch (e_flags
& EF_AVR_MACH
)
2634 case E_AVR_MACH_AVR1
:
2635 strncat (buf
, ", avr:1", size
);
2637 case E_AVR_MACH_AVR2
:
2638 strncat (buf
, ", avr:2", size
);
2640 case E_AVR_MACH_AVR25
:
2641 strncat (buf
, ", avr:25", size
);
2643 case E_AVR_MACH_AVR3
:
2644 strncat (buf
, ", avr:3", size
);
2646 case E_AVR_MACH_AVR31
:
2647 strncat (buf
, ", avr:31", size
);
2649 case E_AVR_MACH_AVR35
:
2650 strncat (buf
, ", avr:35", size
);
2652 case E_AVR_MACH_AVR4
:
2653 strncat (buf
, ", avr:4", size
);
2655 case E_AVR_MACH_AVR5
:
2656 strncat (buf
, ", avr:5", size
);
2658 case E_AVR_MACH_AVR51
:
2659 strncat (buf
, ", avr:51", size
);
2661 case E_AVR_MACH_AVR6
:
2662 strncat (buf
, ", avr:6", size
);
2664 case E_AVR_MACH_AVRTINY
:
2665 strncat (buf
, ", avr:100", size
);
2667 case E_AVR_MACH_XMEGA1
:
2668 strncat (buf
, ", avr:101", size
);
2670 case E_AVR_MACH_XMEGA2
:
2671 strncat (buf
, ", avr:102", size
);
2673 case E_AVR_MACH_XMEGA3
:
2674 strncat (buf
, ", avr:103", size
);
2676 case E_AVR_MACH_XMEGA4
:
2677 strncat (buf
, ", avr:104", size
);
2679 case E_AVR_MACH_XMEGA5
:
2680 strncat (buf
, ", avr:105", size
);
2682 case E_AVR_MACH_XMEGA6
:
2683 strncat (buf
, ", avr:106", size
);
2685 case E_AVR_MACH_XMEGA7
:
2686 strncat (buf
, ", avr:107", size
);
2689 strncat (buf
, ", avr:<unknown>", size
);
2693 size
-= strlen (buf
);
2694 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2695 strncat (buf
, ", link-relax", size
);
2699 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2708 static const char *ABI_STRINGS
[] =
2710 "ABI v0", /* use r5 as return register; only used in N1213HC */
2711 "ABI v1", /* use r0 as return register */
2712 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2713 "ABI v2fp", /* for FPU */
2717 static const char *VER_STRINGS
[] =
2719 "Andes ELF V1.3 or older",
2723 static const char *ARCH_STRINGS
[] =
2732 abi
= EF_NDS_ABI
& e_flags
;
2733 arch
= EF_NDS_ARCH
& e_flags
;
2734 config
= EF_NDS_INST
& e_flags
;
2735 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2737 memset (buf
, 0, size
);
2744 case E_NDS_ABI_V2FP
:
2745 case E_NDS_ABI_AABI
:
2746 case E_NDS_ABI_V2FP_PLUS
:
2747 /* In case there are holes in the array. */
2748 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2752 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2758 case E_NDS32_ELF_VER_1_2
:
2759 case E_NDS32_ELF_VER_1_3
:
2760 case E_NDS32_ELF_VER_1_4
:
2761 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2765 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2769 if (E_NDS_ABI_V0
== abi
)
2771 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2772 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2773 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2774 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2780 case E_NDS_ARCH_STAR_V1_0
:
2781 case E_NDS_ARCH_STAR_V2_0
:
2782 case E_NDS_ARCH_STAR_V3_0
:
2783 case E_NDS_ARCH_STAR_V3_M
:
2784 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2788 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2789 /* ARCH version determines how the e_flags are interpreted.
2790 If it is unknown, we cannot proceed. */
2794 /* Newer ABI; Now handle architecture specific flags. */
2795 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2797 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2798 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2800 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2801 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2803 if (config
& E_NDS32_HAS_DIV_INST
)
2804 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2806 if (config
& E_NDS32_HAS_16BIT_INST
)
2807 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2811 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2813 if (version
<= E_NDS32_ELF_VER_1_3
)
2814 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2816 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2819 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2820 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2822 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2823 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2825 if (config
& E_NDS32_HAS_16BIT_INST
)
2827 if (version
<= E_NDS32_ELF_VER_1_3
)
2828 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2830 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2834 if (config
& E_NDS32_HAS_EXT_INST
)
2835 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2837 if (config
& E_NDS32_HAS_EXT2_INST
)
2838 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2840 if (config
& E_NDS32_HAS_FPU_INST
)
2843 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2846 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2849 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2852 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2855 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2860 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2862 case E_NDS32_FPU_REG_8SP_4DP
:
2863 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2865 case E_NDS32_FPU_REG_16SP_8DP
:
2866 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2868 case E_NDS32_FPU_REG_32SP_16DP
:
2869 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2871 case E_NDS32_FPU_REG_32SP_32DP
:
2872 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2877 if (config
& E_NDS32_HAS_AUDIO_INST
)
2878 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2880 if (config
& E_NDS32_HAS_STRING_INST
)
2881 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2883 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2884 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2886 if (config
& E_NDS32_HAS_VIDEO_INST
)
2888 if (version
<= E_NDS32_ELF_VER_1_3
)
2889 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2891 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2894 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2895 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2897 if (config
& E_NDS32_HAS_L2C_INST
)
2898 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2902 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2904 static char buf
[1024];
2915 case EM_ARC_COMPACT2
:
2916 case EM_ARC_COMPACT
:
2917 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
2921 decode_ARM_machine_flags (e_flags
, buf
);
2925 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2929 if (e_flags
& EF_BFIN_PIC
)
2930 strcat (buf
, ", PIC");
2932 if (e_flags
& EF_BFIN_FDPIC
)
2933 strcat (buf
, ", FDPIC");
2935 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2936 strcat (buf
, ", code in L1");
2938 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2939 strcat (buf
, ", data in L1");
2944 switch (e_flags
& EF_FRV_CPU_MASK
)
2946 case EF_FRV_CPU_GENERIC
:
2950 strcat (buf
, ", fr???");
2953 case EF_FRV_CPU_FR300
:
2954 strcat (buf
, ", fr300");
2957 case EF_FRV_CPU_FR400
:
2958 strcat (buf
, ", fr400");
2960 case EF_FRV_CPU_FR405
:
2961 strcat (buf
, ", fr405");
2964 case EF_FRV_CPU_FR450
:
2965 strcat (buf
, ", fr450");
2968 case EF_FRV_CPU_FR500
:
2969 strcat (buf
, ", fr500");
2971 case EF_FRV_CPU_FR550
:
2972 strcat (buf
, ", fr550");
2975 case EF_FRV_CPU_SIMPLE
:
2976 strcat (buf
, ", simple");
2978 case EF_FRV_CPU_TOMCAT
:
2979 strcat (buf
, ", tomcat");
2985 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2986 strcat (buf
, ", m68000");
2987 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2988 strcat (buf
, ", cpu32");
2989 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2990 strcat (buf
, ", fido_a");
2993 char const * isa
= _("unknown");
2994 char const * mac
= _("unknown mac");
2995 char const * additional
= NULL
;
2997 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2999 case EF_M68K_CF_ISA_A_NODIV
:
3001 additional
= ", nodiv";
3003 case EF_M68K_CF_ISA_A
:
3006 case EF_M68K_CF_ISA_A_PLUS
:
3009 case EF_M68K_CF_ISA_B_NOUSP
:
3011 additional
= ", nousp";
3013 case EF_M68K_CF_ISA_B
:
3016 case EF_M68K_CF_ISA_C
:
3019 case EF_M68K_CF_ISA_C_NODIV
:
3021 additional
= ", nodiv";
3024 strcat (buf
, ", cf, isa ");
3027 strcat (buf
, additional
);
3028 if (e_flags
& EF_M68K_CF_FLOAT
)
3029 strcat (buf
, ", float");
3030 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3035 case EF_M68K_CF_MAC
:
3038 case EF_M68K_CF_EMAC
:
3041 case EF_M68K_CF_EMAC_B
:
3054 switch (e_flags
& EF_MEP_CPU_MASK
)
3056 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3057 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3058 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3059 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3060 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3061 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3062 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3065 switch (e_flags
& EF_MEP_COP_MASK
)
3067 case EF_MEP_COP_NONE
: break;
3068 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3069 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3070 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3071 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3072 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3075 if (e_flags
& EF_MEP_LIBRARY
)
3076 strcat (buf
, ", Built for Library");
3078 if (e_flags
& EF_MEP_INDEX_MASK
)
3079 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3080 e_flags
& EF_MEP_INDEX_MASK
);
3082 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3083 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3084 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3088 if (e_flags
& EF_PPC_EMB
)
3089 strcat (buf
, ", emb");
3091 if (e_flags
& EF_PPC_RELOCATABLE
)
3092 strcat (buf
, _(", relocatable"));
3094 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3095 strcat (buf
, _(", relocatable-lib"));
3099 if (e_flags
& EF_PPC64_ABI
)
3101 char abi
[] = ", abiv0";
3103 abi
[6] += e_flags
& EF_PPC64_ABI
;
3109 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3110 strcat (buf
, ", RH850 ABI");
3112 if (e_flags
& EF_V800_850E3
)
3113 strcat (buf
, ", V3 architecture");
3115 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3116 strcat (buf
, ", FPU not used");
3118 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3119 strcat (buf
, ", regmode: COMMON");
3121 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3122 strcat (buf
, ", r4 not used");
3124 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3125 strcat (buf
, ", r30 not used");
3127 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3128 strcat (buf
, ", r5 not used");
3130 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3131 strcat (buf
, ", r2 not used");
3133 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3135 switch (e_flags
& - e_flags
)
3137 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3138 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3139 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3140 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3141 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3142 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3143 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3144 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3145 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3146 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3147 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3148 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3155 case EM_CYGNUS_V850
:
3156 switch (e_flags
& EF_V850_ARCH
)
3158 case E_V850E3V5_ARCH
:
3159 strcat (buf
, ", v850e3v5");
3161 case E_V850E2V3_ARCH
:
3162 strcat (buf
, ", v850e2v3");
3165 strcat (buf
, ", v850e2");
3168 strcat (buf
, ", v850e1");
3171 strcat (buf
, ", v850e");
3174 strcat (buf
, ", v850");
3177 strcat (buf
, _(", unknown v850 architecture variant"));
3183 case EM_CYGNUS_M32R
:
3184 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3185 strcat (buf
, ", m32r");
3189 case EM_MIPS_RS3_LE
:
3190 if (e_flags
& EF_MIPS_NOREORDER
)
3191 strcat (buf
, ", noreorder");
3193 if (e_flags
& EF_MIPS_PIC
)
3194 strcat (buf
, ", pic");
3196 if (e_flags
& EF_MIPS_CPIC
)
3197 strcat (buf
, ", cpic");
3199 if (e_flags
& EF_MIPS_UCODE
)
3200 strcat (buf
, ", ugen_reserved");
3202 if (e_flags
& EF_MIPS_ABI2
)
3203 strcat (buf
, ", abi2");
3205 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3206 strcat (buf
, ", odk first");
3208 if (e_flags
& EF_MIPS_32BITMODE
)
3209 strcat (buf
, ", 32bitmode");
3211 if (e_flags
& EF_MIPS_NAN2008
)
3212 strcat (buf
, ", nan2008");
3214 if (e_flags
& EF_MIPS_FP64
)
3215 strcat (buf
, ", fp64");
3217 switch ((e_flags
& EF_MIPS_MACH
))
3219 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3220 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3221 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3222 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3223 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3224 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3225 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3226 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3227 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3228 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3229 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3230 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3231 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3232 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3233 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3234 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3235 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3237 /* We simply ignore the field in this case to avoid confusion:
3238 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3241 default: strcat (buf
, _(", unknown CPU")); break;
3244 switch ((e_flags
& EF_MIPS_ABI
))
3246 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3247 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3248 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3249 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3251 /* We simply ignore the field in this case to avoid confusion:
3252 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3253 This means it is likely to be an o32 file, but not for
3256 default: strcat (buf
, _(", unknown ABI")); break;
3259 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3260 strcat (buf
, ", mdmx");
3262 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3263 strcat (buf
, ", mips16");
3265 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3266 strcat (buf
, ", micromips");
3268 switch ((e_flags
& EF_MIPS_ARCH
))
3270 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3271 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3272 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3273 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3274 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3275 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3276 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3277 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3278 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3279 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3280 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3281 default: strcat (buf
, _(", unknown ISA")); break;
3286 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3290 switch ((e_flags
& EF_SH_MACH_MASK
))
3292 case EF_SH1
: strcat (buf
, ", sh1"); break;
3293 case EF_SH2
: strcat (buf
, ", sh2"); break;
3294 case EF_SH3
: strcat (buf
, ", sh3"); break;
3295 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3296 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3297 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3298 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3299 case EF_SH4
: strcat (buf
, ", sh4"); break;
3300 case EF_SH5
: strcat (buf
, ", sh5"); break;
3301 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3302 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3303 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3304 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3305 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3306 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3307 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3308 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3309 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3310 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3311 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3312 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3313 default: strcat (buf
, _(", unknown ISA")); break;
3316 if (e_flags
& EF_SH_PIC
)
3317 strcat (buf
, ", pic");
3319 if (e_flags
& EF_SH_FDPIC
)
3320 strcat (buf
, ", fdpic");
3324 if (e_flags
& EF_OR1K_NODELAY
)
3325 strcat (buf
, ", no delay");
3329 if (e_flags
& EF_SPARC_32PLUS
)
3330 strcat (buf
, ", v8+");
3332 if (e_flags
& EF_SPARC_SUN_US1
)
3333 strcat (buf
, ", ultrasparcI");
3335 if (e_flags
& EF_SPARC_SUN_US3
)
3336 strcat (buf
, ", ultrasparcIII");
3338 if (e_flags
& EF_SPARC_HAL_R1
)
3339 strcat (buf
, ", halr1");
3341 if (e_flags
& EF_SPARC_LEDATA
)
3342 strcat (buf
, ", ledata");
3344 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3345 strcat (buf
, ", tso");
3347 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3348 strcat (buf
, ", pso");
3350 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3351 strcat (buf
, ", rmo");
3355 switch (e_flags
& EF_PARISC_ARCH
)
3357 case EFA_PARISC_1_0
:
3358 strcpy (buf
, ", PA-RISC 1.0");
3360 case EFA_PARISC_1_1
:
3361 strcpy (buf
, ", PA-RISC 1.1");
3363 case EFA_PARISC_2_0
:
3364 strcpy (buf
, ", PA-RISC 2.0");
3369 if (e_flags
& EF_PARISC_TRAPNIL
)
3370 strcat (buf
, ", trapnil");
3371 if (e_flags
& EF_PARISC_EXT
)
3372 strcat (buf
, ", ext");
3373 if (e_flags
& EF_PARISC_LSB
)
3374 strcat (buf
, ", lsb");
3375 if (e_flags
& EF_PARISC_WIDE
)
3376 strcat (buf
, ", wide");
3377 if (e_flags
& EF_PARISC_NO_KABP
)
3378 strcat (buf
, ", no kabp");
3379 if (e_flags
& EF_PARISC_LAZYSWAP
)
3380 strcat (buf
, ", lazyswap");
3385 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3386 strcat (buf
, ", new calling convention");
3388 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3389 strcat (buf
, ", gnu calling convention");
3393 if ((e_flags
& EF_IA_64_ABI64
))
3394 strcat (buf
, ", 64-bit");
3396 strcat (buf
, ", 32-bit");
3397 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3398 strcat (buf
, ", reduced fp model");
3399 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3400 strcat (buf
, ", no function descriptors, constant gp");
3401 else if ((e_flags
& EF_IA_64_CONS_GP
))
3402 strcat (buf
, ", constant gp");
3403 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3404 strcat (buf
, ", absolute");
3405 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3407 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3408 strcat (buf
, ", vms_linkages");
3409 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3411 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3413 case EF_IA_64_VMS_COMCOD_WARNING
:
3414 strcat (buf
, ", warning");
3416 case EF_IA_64_VMS_COMCOD_ERROR
:
3417 strcat (buf
, ", error");
3419 case EF_IA_64_VMS_COMCOD_ABORT
:
3420 strcat (buf
, ", abort");
3423 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3424 e_flags
& EF_IA_64_VMS_COMCOD
);
3425 strcat (buf
, ", <unknown>");
3431 if ((e_flags
& EF_VAX_NONPIC
))
3432 strcat (buf
, ", non-PIC");
3433 if ((e_flags
& EF_VAX_DFLOAT
))
3434 strcat (buf
, ", D-Float");
3435 if ((e_flags
& EF_VAX_GFLOAT
))
3436 strcat (buf
, ", G-Float");
3440 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3441 strcat (buf
, ", mcm");
3442 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3443 strcat (buf
, ", mcm24");
3444 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3445 strcat (buf
, ", gr6");
3449 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3451 case E_FLAG_RL78_ANY_CPU
: break;
3452 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3453 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3454 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3456 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3457 strcat (buf
, ", 64-bit doubles");
3461 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3462 strcat (buf
, ", 64-bit doubles");
3463 if (e_flags
& E_FLAG_RX_DSP
)
3464 strcat (buf
, ", dsp");
3465 if (e_flags
& E_FLAG_RX_PID
)
3466 strcat (buf
, ", pid");
3467 if (e_flags
& E_FLAG_RX_ABI
)
3468 strcat (buf
, ", RX ABI");
3469 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3470 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3471 ? ", uses String instructions" : ", bans String instructions");
3472 if (e_flags
& E_FLAG_RX_V2
)
3473 strcat (buf
, ", V2");
3477 if (e_flags
& EF_S390_HIGH_GPRS
)
3478 strcat (buf
, ", highgprs");
3482 if ((e_flags
& EF_C6000_REL
))
3483 strcat (buf
, ", relocatable module");
3487 strcat (buf
, _(": architecture variant: "));
3488 switch (e_flags
& EF_MSP430_MACH
)
3490 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3491 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3492 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3493 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3494 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3495 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3496 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3497 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3498 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3499 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3500 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3501 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3502 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3503 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3504 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3506 strcat (buf
, _(": unknown")); break;
3509 if (e_flags
& ~ EF_MSP430_MACH
)
3510 strcat (buf
, _(": unknown extra flag bits also present"));
3518 get_osabi_name (unsigned int osabi
)
3520 static char buff
[32];
3524 case ELFOSABI_NONE
: return "UNIX - System V";
3525 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3526 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3527 case ELFOSABI_GNU
: return "UNIX - GNU";
3528 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3529 case ELFOSABI_AIX
: return "UNIX - AIX";
3530 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3531 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3532 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3533 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3534 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3535 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3536 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3537 case ELFOSABI_AROS
: return "AROS";
3538 case ELFOSABI_FENIXOS
: return "FenixOS";
3541 switch (elf_header
.e_machine
)
3546 case ELFOSABI_ARM
: return "ARM";
3557 case ELFOSABI_STANDALONE
: return _("Standalone App");
3566 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3567 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3576 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3582 get_aarch64_segment_type (unsigned long type
)
3586 case PT_AARCH64_ARCHEXT
:
3587 return "AARCH64_ARCHEXT";
3596 get_arm_segment_type (unsigned long type
)
3610 get_mips_segment_type (unsigned long type
)
3614 case PT_MIPS_REGINFO
:
3616 case PT_MIPS_RTPROC
:
3618 case PT_MIPS_OPTIONS
:
3620 case PT_MIPS_ABIFLAGS
:
3630 get_parisc_segment_type (unsigned long type
)
3634 case PT_HP_TLS
: return "HP_TLS";
3635 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3636 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3637 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3638 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3639 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3640 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3641 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3642 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3643 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3644 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3645 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3646 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3647 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3648 case PT_HP_STACK
: return "HP_STACK";
3649 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3650 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3651 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3652 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3661 get_ia64_segment_type (unsigned long type
)
3665 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3666 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3667 case PT_HP_TLS
: return "HP_TLS";
3668 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3669 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3670 case PT_IA_64_HP_STACK
: return "HP_STACK";
3679 get_tic6x_segment_type (unsigned long type
)
3683 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3692 get_solaris_segment_type (unsigned long type
)
3696 case 0x6464e550: return "PT_SUNW_UNWIND";
3697 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3698 case 0x6ffffff7: return "PT_LOSUNW";
3699 case 0x6ffffffa: return "PT_SUNWBSS";
3700 case 0x6ffffffb: return "PT_SUNWSTACK";
3701 case 0x6ffffffc: return "PT_SUNWDTRACE";
3702 case 0x6ffffffd: return "PT_SUNWCAP";
3703 case 0x6fffffff: return "PT_HISUNW";
3704 default: return NULL
;
3709 get_segment_type (unsigned long p_type
)
3711 static char buff
[32];
3715 case PT_NULL
: return "NULL";
3716 case PT_LOAD
: return "LOAD";
3717 case PT_DYNAMIC
: return "DYNAMIC";
3718 case PT_INTERP
: return "INTERP";
3719 case PT_NOTE
: return "NOTE";
3720 case PT_SHLIB
: return "SHLIB";
3721 case PT_PHDR
: return "PHDR";
3722 case PT_TLS
: return "TLS";
3724 case PT_GNU_EH_FRAME
:
3725 return "GNU_EH_FRAME";
3726 case PT_GNU_STACK
: return "GNU_STACK";
3727 case PT_GNU_RELRO
: return "GNU_RELRO";
3730 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3732 const char * result
;
3734 switch (elf_header
.e_machine
)
3737 result
= get_aarch64_segment_type (p_type
);
3740 result
= get_arm_segment_type (p_type
);
3743 case EM_MIPS_RS3_LE
:
3744 result
= get_mips_segment_type (p_type
);
3747 result
= get_parisc_segment_type (p_type
);
3750 result
= get_ia64_segment_type (p_type
);
3753 result
= get_tic6x_segment_type (p_type
);
3763 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3765 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3767 const char * result
;
3769 switch (elf_header
.e_machine
)
3772 result
= get_parisc_segment_type (p_type
);
3775 result
= get_ia64_segment_type (p_type
);
3778 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3779 result
= get_solaris_segment_type (p_type
);
3788 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3791 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3798 get_mips_section_type_name (unsigned int sh_type
)
3802 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3803 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3804 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3805 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3806 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3807 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3808 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3809 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3810 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3811 case SHT_MIPS_RELD
: return "MIPS_RELD";
3812 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3813 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3814 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3815 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3816 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3817 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3818 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3819 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3820 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3821 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3822 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3823 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3824 case SHT_MIPS_LINE
: return "MIPS_LINE";
3825 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3826 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3827 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3828 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3829 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3830 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3831 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3832 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3833 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3834 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3835 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3836 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3837 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3838 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3839 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3840 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3841 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3849 get_parisc_section_type_name (unsigned int sh_type
)
3853 case SHT_PARISC_EXT
: return "PARISC_EXT";
3854 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3855 case SHT_PARISC_DOC
: return "PARISC_DOC";
3856 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3857 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3858 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3859 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3867 get_ia64_section_type_name (unsigned int sh_type
)
3869 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3870 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3871 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3875 case SHT_IA_64_EXT
: return "IA_64_EXT";
3876 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3877 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3878 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3879 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3880 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3881 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3882 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3883 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3884 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3892 get_x86_64_section_type_name (unsigned int sh_type
)
3896 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3904 get_aarch64_section_type_name (unsigned int sh_type
)
3908 case SHT_AARCH64_ATTRIBUTES
:
3909 return "AARCH64_ATTRIBUTES";
3917 get_arm_section_type_name (unsigned int sh_type
)
3921 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3922 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3923 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3924 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3925 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3933 get_tic6x_section_type_name (unsigned int sh_type
)
3937 case SHT_C6000_UNWIND
:
3938 return "C6000_UNWIND";
3939 case SHT_C6000_PREEMPTMAP
:
3940 return "C6000_PREEMPTMAP";
3941 case SHT_C6000_ATTRIBUTES
:
3942 return "C6000_ATTRIBUTES";
3947 case SHT_TI_HANDLER
:
3948 return "TI_HANDLER";
3949 case SHT_TI_INITINFO
:
3950 return "TI_INITINFO";
3951 case SHT_TI_PHATTRS
:
3952 return "TI_PHATTRS";
3960 get_msp430x_section_type_name (unsigned int sh_type
)
3964 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3965 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3966 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3967 default: return NULL
;
3972 get_v850_section_type_name (unsigned int sh_type
)
3976 case SHT_V850_SCOMMON
: return "V850 Small Common";
3977 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3978 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3979 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3980 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3981 default: return NULL
;
3986 get_section_type_name (unsigned int sh_type
)
3988 static char buff
[32];
3989 const char * result
;
3993 case SHT_NULL
: return "NULL";
3994 case SHT_PROGBITS
: return "PROGBITS";
3995 case SHT_SYMTAB
: return "SYMTAB";
3996 case SHT_STRTAB
: return "STRTAB";
3997 case SHT_RELA
: return "RELA";
3998 case SHT_HASH
: return "HASH";
3999 case SHT_DYNAMIC
: return "DYNAMIC";
4000 case SHT_NOTE
: return "NOTE";
4001 case SHT_NOBITS
: return "NOBITS";
4002 case SHT_REL
: return "REL";
4003 case SHT_SHLIB
: return "SHLIB";
4004 case SHT_DYNSYM
: return "DYNSYM";
4005 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4006 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4007 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4008 case SHT_GNU_HASH
: return "GNU_HASH";
4009 case SHT_GROUP
: return "GROUP";
4010 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4011 case SHT_GNU_verdef
: return "VERDEF";
4012 case SHT_GNU_verneed
: return "VERNEED";
4013 case SHT_GNU_versym
: return "VERSYM";
4014 case 0x6ffffff0: return "VERSYM";
4015 case 0x6ffffffc: return "VERDEF";
4016 case 0x7ffffffd: return "AUXILIARY";
4017 case 0x7fffffff: return "FILTER";
4018 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4021 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4023 switch (elf_header
.e_machine
)
4026 case EM_MIPS_RS3_LE
:
4027 result
= get_mips_section_type_name (sh_type
);
4030 result
= get_parisc_section_type_name (sh_type
);
4033 result
= get_ia64_section_type_name (sh_type
);
4038 result
= get_x86_64_section_type_name (sh_type
);
4041 result
= get_aarch64_section_type_name (sh_type
);
4044 result
= get_arm_section_type_name (sh_type
);
4047 result
= get_tic6x_section_type_name (sh_type
);
4050 result
= get_msp430x_section_type_name (sh_type
);
4054 case EM_CYGNUS_V850
:
4055 result
= get_v850_section_type_name (sh_type
);
4065 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4067 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4069 switch (elf_header
.e_machine
)
4072 result
= get_ia64_section_type_name (sh_type
);
4075 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4076 result
= get_solaris_section_type (sh_type
);
4085 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4087 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4089 switch (elf_header
.e_machine
)
4093 case EM_CYGNUS_V850
:
4094 result
= get_v850_section_type_name (sh_type
);
4104 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4107 /* This message is probably going to be displayed in a 15
4108 character wide field, so put the hex value first. */
4109 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4115 #define OPTION_DEBUG_DUMP 512
4116 #define OPTION_DYN_SYMS 513
4117 #define OPTION_DWARF_DEPTH 514
4118 #define OPTION_DWARF_START 515
4119 #define OPTION_DWARF_CHECK 516
4121 static struct option options
[] =
4123 {"all", no_argument
, 0, 'a'},
4124 {"file-header", no_argument
, 0, 'h'},
4125 {"program-headers", no_argument
, 0, 'l'},
4126 {"headers", no_argument
, 0, 'e'},
4127 {"histogram", no_argument
, 0, 'I'},
4128 {"segments", no_argument
, 0, 'l'},
4129 {"sections", no_argument
, 0, 'S'},
4130 {"section-headers", no_argument
, 0, 'S'},
4131 {"section-groups", no_argument
, 0, 'g'},
4132 {"section-details", no_argument
, 0, 't'},
4133 {"full-section-name",no_argument
, 0, 'N'},
4134 {"symbols", no_argument
, 0, 's'},
4135 {"syms", no_argument
, 0, 's'},
4136 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4137 {"relocs", no_argument
, 0, 'r'},
4138 {"notes", no_argument
, 0, 'n'},
4139 {"dynamic", no_argument
, 0, 'd'},
4140 {"arch-specific", no_argument
, 0, 'A'},
4141 {"version-info", no_argument
, 0, 'V'},
4142 {"use-dynamic", no_argument
, 0, 'D'},
4143 {"unwind", no_argument
, 0, 'u'},
4144 {"archive-index", no_argument
, 0, 'c'},
4145 {"hex-dump", required_argument
, 0, 'x'},
4146 {"relocated-dump", required_argument
, 0, 'R'},
4147 {"string-dump", required_argument
, 0, 'p'},
4148 {"decompress", no_argument
, 0, 'z'},
4149 #ifdef SUPPORT_DISASSEMBLY
4150 {"instruction-dump", required_argument
, 0, 'i'},
4152 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4154 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4155 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4156 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4158 {"version", no_argument
, 0, 'v'},
4159 {"wide", no_argument
, 0, 'W'},
4160 {"help", no_argument
, 0, 'H'},
4161 {0, no_argument
, 0, 0}
4165 usage (FILE * stream
)
4167 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4168 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4169 fprintf (stream
, _(" Options are:\n\
4170 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4171 -h --file-header Display the ELF file header\n\
4172 -l --program-headers Display the program headers\n\
4173 --segments An alias for --program-headers\n\
4174 -S --section-headers Display the sections' header\n\
4175 --sections An alias for --section-headers\n\
4176 -g --section-groups Display the section groups\n\
4177 -t --section-details Display the section details\n\
4178 -e --headers Equivalent to: -h -l -S\n\
4179 -s --syms Display the symbol table\n\
4180 --symbols An alias for --syms\n\
4181 --dyn-syms Display the dynamic symbol table\n\
4182 -n --notes Display the core notes (if present)\n\
4183 -r --relocs Display the relocations (if present)\n\
4184 -u --unwind Display the unwind info (if present)\n\
4185 -d --dynamic Display the dynamic section (if present)\n\
4186 -V --version-info Display the version sections (if present)\n\
4187 -A --arch-specific Display architecture specific information (if any)\n\
4188 -c --archive-index Display the symbol/file index in an archive\n\
4189 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4190 -x --hex-dump=<number|name>\n\
4191 Dump the contents of section <number|name> as bytes\n\
4192 -p --string-dump=<number|name>\n\
4193 Dump the contents of section <number|name> as strings\n\
4194 -R --relocated-dump=<number|name>\n\
4195 Dump the contents of section <number|name> as relocated bytes\n\
4196 -z --decompress Decompress section before dumping it\n\
4197 -w[lLiaprmfFsoRt] or\n\
4198 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4199 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4200 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4202 Display the contents of DWARF2 debug sections\n"));
4203 fprintf (stream
, _("\
4204 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4205 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4207 #ifdef SUPPORT_DISASSEMBLY
4208 fprintf (stream
, _("\
4209 -i --instruction-dump=<number|name>\n\
4210 Disassemble the contents of section <number|name>\n"));
4212 fprintf (stream
, _("\
4213 -I --histogram Display histogram of bucket list lengths\n\
4214 -W --wide Allow output width to exceed 80 characters\n\
4215 @<file> Read options from <file>\n\
4216 -H --help Display this information\n\
4217 -v --version Display the version number of readelf\n"));
4219 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4220 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4222 exit (stream
== stdout
? 0 : 1);
4225 /* Record the fact that the user wants the contents of section number
4226 SECTION to be displayed using the method(s) encoded as flags bits
4227 in TYPE. Note, TYPE can be zero if we are creating the array for
4231 request_dump_bynumber (unsigned int section
, dump_type type
)
4233 if (section
>= num_dump_sects
)
4235 dump_type
* new_dump_sects
;
4237 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4238 sizeof (* dump_sects
));
4240 if (new_dump_sects
== NULL
)
4241 error (_("Out of memory allocating dump request table.\n"));
4244 /* Copy current flag settings. */
4245 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4249 dump_sects
= new_dump_sects
;
4250 num_dump_sects
= section
+ 1;
4255 dump_sects
[section
] |= type
;
4260 /* Request a dump by section name. */
4263 request_dump_byname (const char * section
, dump_type type
)
4265 struct dump_list_entry
* new_request
;
4267 new_request
= (struct dump_list_entry
*)
4268 malloc (sizeof (struct dump_list_entry
));
4270 error (_("Out of memory allocating dump request table.\n"));
4272 new_request
->name
= strdup (section
);
4273 if (!new_request
->name
)
4274 error (_("Out of memory allocating dump request table.\n"));
4276 new_request
->type
= type
;
4278 new_request
->next
= dump_sects_byname
;
4279 dump_sects_byname
= new_request
;
4283 request_dump (dump_type type
)
4289 section
= strtoul (optarg
, & cp
, 0);
4291 if (! *cp
&& section
>= 0)
4292 request_dump_bynumber (section
, type
);
4294 request_dump_byname (optarg
, type
);
4299 parse_args (int argc
, char ** argv
)
4306 while ((c
= getopt_long
4307 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4325 do_section_groups
++;
4333 do_section_groups
++;
4338 do_section_details
++;
4382 request_dump (HEX_DUMP
);
4385 request_dump (STRING_DUMP
);
4388 request_dump (RELOC_DUMP
);
4398 dwarf_select_sections_all ();
4403 dwarf_select_sections_by_letters (optarg
);
4406 case OPTION_DEBUG_DUMP
:
4413 dwarf_select_sections_by_names (optarg
);
4416 case OPTION_DWARF_DEPTH
:
4420 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4423 case OPTION_DWARF_START
:
4427 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4430 case OPTION_DWARF_CHECK
:
4433 case OPTION_DYN_SYMS
:
4436 #ifdef SUPPORT_DISASSEMBLY
4438 request_dump (DISASS_DUMP
);
4442 print_version (program_name
);
4451 /* xgettext:c-format */
4452 error (_("Invalid option '-%c'\n"), c
);
4459 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4460 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4461 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4462 && !do_section_groups
&& !do_archive_index
4468 get_elf_class (unsigned int elf_class
)
4470 static char buff
[32];
4474 case ELFCLASSNONE
: return _("none");
4475 case ELFCLASS32
: return "ELF32";
4476 case ELFCLASS64
: return "ELF64";
4478 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4484 get_data_encoding (unsigned int encoding
)
4486 static char buff
[32];
4490 case ELFDATANONE
: return _("none");
4491 case ELFDATA2LSB
: return _("2's complement, little endian");
4492 case ELFDATA2MSB
: return _("2's complement, big endian");
4494 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4499 /* Decode the data held in 'elf_header'. */
4502 process_file_header (void)
4504 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4505 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4506 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4507 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4510 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4514 init_dwarf_regnames (elf_header
.e_machine
);
4520 printf (_("ELF Header:\n"));
4521 printf (_(" Magic: "));
4522 for (i
= 0; i
< EI_NIDENT
; i
++)
4523 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4525 printf (_(" Class: %s\n"),
4526 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4527 printf (_(" Data: %s\n"),
4528 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4529 printf (_(" Version: %d %s\n"),
4530 elf_header
.e_ident
[EI_VERSION
],
4531 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4533 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4534 ? _("<unknown: %lx>")
4536 printf (_(" OS/ABI: %s\n"),
4537 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4538 printf (_(" ABI Version: %d\n"),
4539 elf_header
.e_ident
[EI_ABIVERSION
]);
4540 printf (_(" Type: %s\n"),
4541 get_file_type (elf_header
.e_type
));
4542 printf (_(" Machine: %s\n"),
4543 get_machine_name (elf_header
.e_machine
));
4544 printf (_(" Version: 0x%lx\n"),
4545 (unsigned long) elf_header
.e_version
);
4547 printf (_(" Entry point address: "));
4548 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4549 printf (_("\n Start of program headers: "));
4550 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4551 printf (_(" (bytes into file)\n Start of section headers: "));
4552 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4553 printf (_(" (bytes into file)\n"));
4555 printf (_(" Flags: 0x%lx%s\n"),
4556 (unsigned long) elf_header
.e_flags
,
4557 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4558 printf (_(" Size of this header: %ld (bytes)\n"),
4559 (long) elf_header
.e_ehsize
);
4560 printf (_(" Size of program headers: %ld (bytes)\n"),
4561 (long) elf_header
.e_phentsize
);
4562 printf (_(" Number of program headers: %ld"),
4563 (long) elf_header
.e_phnum
);
4564 if (section_headers
!= NULL
4565 && elf_header
.e_phnum
== PN_XNUM
4566 && section_headers
[0].sh_info
!= 0)
4567 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4568 putc ('\n', stdout
);
4569 printf (_(" Size of section headers: %ld (bytes)\n"),
4570 (long) elf_header
.e_shentsize
);
4571 printf (_(" Number of section headers: %ld"),
4572 (long) elf_header
.e_shnum
);
4573 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4574 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4575 putc ('\n', stdout
);
4576 printf (_(" Section header string table index: %ld"),
4577 (long) elf_header
.e_shstrndx
);
4578 if (section_headers
!= NULL
4579 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4580 printf (" (%u)", section_headers
[0].sh_link
);
4581 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4582 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4583 printf (_(" <corrupt: out of range>"));
4584 putc ('\n', stdout
);
4587 if (section_headers
!= NULL
)
4589 if (elf_header
.e_phnum
== PN_XNUM
4590 && section_headers
[0].sh_info
!= 0)
4591 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4592 if (elf_header
.e_shnum
== SHN_UNDEF
)
4593 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4594 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4595 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4596 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4597 elf_header
.e_shstrndx
= SHN_UNDEF
;
4598 free (section_headers
);
4599 section_headers
= NULL
;
4606 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4608 Elf32_External_Phdr
* phdrs
;
4609 Elf32_External_Phdr
* external
;
4610 Elf_Internal_Phdr
* internal
;
4612 unsigned int size
= elf_header
.e_phentsize
;
4613 unsigned int num
= elf_header
.e_phnum
;
4615 /* PR binutils/17531: Cope with unexpected section header sizes. */
4616 if (size
== 0 || num
== 0)
4618 if (size
< sizeof * phdrs
)
4620 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4623 if (size
> sizeof * phdrs
)
4624 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4626 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4627 size
, num
, _("program headers"));
4631 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4632 i
< elf_header
.e_phnum
;
4633 i
++, internal
++, external
++)
4635 internal
->p_type
= BYTE_GET (external
->p_type
);
4636 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4637 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4638 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4639 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4640 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4641 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4642 internal
->p_align
= BYTE_GET (external
->p_align
);
4650 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4652 Elf64_External_Phdr
* phdrs
;
4653 Elf64_External_Phdr
* external
;
4654 Elf_Internal_Phdr
* internal
;
4656 unsigned int size
= elf_header
.e_phentsize
;
4657 unsigned int num
= elf_header
.e_phnum
;
4659 /* PR binutils/17531: Cope with unexpected section header sizes. */
4660 if (size
== 0 || num
== 0)
4662 if (size
< sizeof * phdrs
)
4664 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4667 if (size
> sizeof * phdrs
)
4668 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4670 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4671 size
, num
, _("program headers"));
4675 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4676 i
< elf_header
.e_phnum
;
4677 i
++, internal
++, external
++)
4679 internal
->p_type
= BYTE_GET (external
->p_type
);
4680 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4681 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4682 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4683 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4684 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4685 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4686 internal
->p_align
= BYTE_GET (external
->p_align
);
4693 /* Returns 1 if the program headers were read into `program_headers'. */
4696 get_program_headers (FILE * file
)
4698 Elf_Internal_Phdr
* phdrs
;
4700 /* Check cache of prior read. */
4701 if (program_headers
!= NULL
)
4704 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4705 sizeof (Elf_Internal_Phdr
));
4709 error (_("Out of memory reading %u program headers\n"),
4710 elf_header
.e_phnum
);
4715 ? get_32bit_program_headers (file
, phdrs
)
4716 : get_64bit_program_headers (file
, phdrs
))
4718 program_headers
= phdrs
;
4726 /* Returns 1 if the program headers were loaded. */
4729 process_program_headers (FILE * file
)
4731 Elf_Internal_Phdr
* segment
;
4734 if (elf_header
.e_phnum
== 0)
4736 /* PR binutils/12467. */
4737 if (elf_header
.e_phoff
!= 0)
4738 warn (_("possibly corrupt ELF header - it has a non-zero program"
4739 " header offset, but no program headers\n"));
4740 else if (do_segments
)
4741 printf (_("\nThere are no program headers in this file.\n"));
4745 if (do_segments
&& !do_header
)
4747 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4748 printf (_("Entry point "));
4749 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4750 printf (_("\nThere are %d program headers, starting at offset "),
4751 elf_header
.e_phnum
);
4752 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4756 if (! get_program_headers (file
))
4761 if (elf_header
.e_phnum
> 1)
4762 printf (_("\nProgram Headers:\n"));
4764 printf (_("\nProgram Headers:\n"));
4768 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4771 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4775 (_(" Type Offset VirtAddr PhysAddr\n"));
4777 (_(" FileSiz MemSiz Flags Align\n"));
4784 for (i
= 0, segment
= program_headers
;
4785 i
< elf_header
.e_phnum
;
4790 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4794 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4795 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4796 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4797 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4798 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4800 (segment
->p_flags
& PF_R
? 'R' : ' '),
4801 (segment
->p_flags
& PF_W
? 'W' : ' '),
4802 (segment
->p_flags
& PF_X
? 'E' : ' '));
4803 printf ("%#lx", (unsigned long) segment
->p_align
);
4807 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4808 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4811 print_vma (segment
->p_offset
, FULL_HEX
);
4815 print_vma (segment
->p_vaddr
, FULL_HEX
);
4817 print_vma (segment
->p_paddr
, FULL_HEX
);
4820 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4821 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4824 print_vma (segment
->p_filesz
, FULL_HEX
);
4828 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4829 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4832 print_vma (segment
->p_memsz
, FULL_HEX
);
4836 (segment
->p_flags
& PF_R
? 'R' : ' '),
4837 (segment
->p_flags
& PF_W
? 'W' : ' '),
4838 (segment
->p_flags
& PF_X
? 'E' : ' '));
4840 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4841 printf ("%#lx", (unsigned long) segment
->p_align
);
4844 print_vma (segment
->p_align
, PREFIX_HEX
);
4849 print_vma (segment
->p_offset
, FULL_HEX
);
4851 print_vma (segment
->p_vaddr
, FULL_HEX
);
4853 print_vma (segment
->p_paddr
, FULL_HEX
);
4855 print_vma (segment
->p_filesz
, FULL_HEX
);
4857 print_vma (segment
->p_memsz
, FULL_HEX
);
4859 (segment
->p_flags
& PF_R
? 'R' : ' '),
4860 (segment
->p_flags
& PF_W
? 'W' : ' '),
4861 (segment
->p_flags
& PF_X
? 'E' : ' '));
4862 print_vma (segment
->p_align
, HEX
);
4867 putc ('\n', stdout
);
4869 switch (segment
->p_type
)
4873 error (_("more than one dynamic segment\n"));
4875 /* By default, assume that the .dynamic section is the first
4876 section in the DYNAMIC segment. */
4877 dynamic_addr
= segment
->p_offset
;
4878 dynamic_size
= segment
->p_filesz
;
4879 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4880 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4882 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4883 dynamic_addr
= dynamic_size
= 0;
4886 /* Try to locate the .dynamic section. If there is
4887 a section header table, we can easily locate it. */
4888 if (section_headers
!= NULL
)
4890 Elf_Internal_Shdr
* sec
;
4892 sec
= find_section (".dynamic");
4893 if (sec
== NULL
|| sec
->sh_size
== 0)
4895 /* A corresponding .dynamic section is expected, but on
4896 IA-64/OpenVMS it is OK for it to be missing. */
4897 if (!is_ia64_vms ())
4898 error (_("no .dynamic section in the dynamic segment\n"));
4902 if (sec
->sh_type
== SHT_NOBITS
)
4908 dynamic_addr
= sec
->sh_offset
;
4909 dynamic_size
= sec
->sh_size
;
4911 if (dynamic_addr
< segment
->p_offset
4912 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4913 warn (_("the .dynamic section is not contained"
4914 " within the dynamic segment\n"));
4915 else if (dynamic_addr
> segment
->p_offset
)
4916 warn (_("the .dynamic section is not the first section"
4917 " in the dynamic segment.\n"));
4922 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4924 error (_("Unable to find program interpreter name\n"));
4928 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4930 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4931 error (_("Internal error: failed to create format string to display program interpreter\n"));
4933 program_interpreter
[0] = 0;
4934 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4935 error (_("Unable to read program interpreter name\n"));
4938 printf (_(" [Requesting program interpreter: %s]\n"),
4939 program_interpreter
);
4945 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4947 printf (_("\n Section to Segment mapping:\n"));
4948 printf (_(" Segment Sections...\n"));
4950 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4953 Elf_Internal_Shdr
* section
;
4955 segment
= program_headers
+ i
;
4956 section
= section_headers
+ 1;
4958 printf (" %2.2d ", i
);
4960 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4962 if (!ELF_TBSS_SPECIAL (section
, segment
)
4963 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4964 printf ("%s ", printable_section_name (section
));
4975 /* Find the file offset corresponding to VMA by using the program headers. */
4978 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4980 Elf_Internal_Phdr
* seg
;
4982 if (! get_program_headers (file
))
4984 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4988 for (seg
= program_headers
;
4989 seg
< program_headers
+ elf_header
.e_phnum
;
4992 if (seg
->p_type
!= PT_LOAD
)
4995 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4996 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4997 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5000 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5001 (unsigned long) vma
);
5006 /* Allocate memory and load the sections headers into the global pointer
5007 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5008 generate any error messages if the load fails. */
5011 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5013 Elf32_External_Shdr
* shdrs
;
5014 Elf_Internal_Shdr
* internal
;
5016 unsigned int size
= elf_header
.e_shentsize
;
5017 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5019 /* PR binutils/17531: Cope with unexpected section header sizes. */
5020 if (size
== 0 || num
== 0)
5022 if (size
< sizeof * shdrs
)
5025 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5028 if (!probe
&& size
> sizeof * shdrs
)
5029 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5031 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5033 probe
? NULL
: _("section headers"));
5037 if (section_headers
!= NULL
)
5038 free (section_headers
);
5039 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5040 sizeof (Elf_Internal_Shdr
));
5041 if (section_headers
== NULL
)
5044 error (_("Out of memory reading %u section headers\n"), num
);
5048 for (i
= 0, internal
= section_headers
;
5052 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5053 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5054 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5055 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5056 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5057 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5058 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5059 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5060 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5061 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5062 if (!probe
&& internal
->sh_link
> num
)
5063 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5064 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5065 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5073 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5075 Elf64_External_Shdr
* shdrs
;
5076 Elf_Internal_Shdr
* internal
;
5078 unsigned int size
= elf_header
.e_shentsize
;
5079 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5081 /* PR binutils/17531: Cope with unexpected section header sizes. */
5082 if (size
== 0 || num
== 0)
5084 if (size
< sizeof * shdrs
)
5087 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5090 if (! probe
&& size
> sizeof * shdrs
)
5091 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5093 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5095 probe
? NULL
: _("section headers"));
5099 if (section_headers
!= NULL
)
5100 free (section_headers
);
5101 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5102 sizeof (Elf_Internal_Shdr
));
5103 if (section_headers
== NULL
)
5106 error (_("Out of memory reading %u section headers\n"), num
);
5110 for (i
= 0, internal
= section_headers
;
5114 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5115 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5116 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5117 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5118 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5119 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5120 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5121 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5122 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5123 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5124 if (!probe
&& internal
->sh_link
> num
)
5125 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5126 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5127 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5134 static Elf_Internal_Sym
*
5135 get_32bit_elf_symbols (FILE * file
,
5136 Elf_Internal_Shdr
* section
,
5137 unsigned long * num_syms_return
)
5139 unsigned long number
= 0;
5140 Elf32_External_Sym
* esyms
= NULL
;
5141 Elf_External_Sym_Shndx
* shndx
= NULL
;
5142 Elf_Internal_Sym
* isyms
= NULL
;
5143 Elf_Internal_Sym
* psym
;
5146 if (section
->sh_size
== 0)
5148 if (num_syms_return
!= NULL
)
5149 * num_syms_return
= 0;
5153 /* Run some sanity checks first. */
5154 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5156 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5157 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5161 if (section
->sh_size
> current_file_size
)
5163 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5164 printable_section_name (section
), (unsigned long) section
->sh_size
);
5168 number
= section
->sh_size
/ section
->sh_entsize
;
5170 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5172 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5173 (unsigned long) section
->sh_size
,
5174 printable_section_name (section
),
5175 (unsigned long) section
->sh_entsize
);
5179 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5180 section
->sh_size
, _("symbols"));
5185 elf_section_list
* entry
;
5188 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5189 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5191 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5192 entry
->hdr
->sh_offset
,
5193 1, entry
->hdr
->sh_size
,
5194 _("symbol table section indicies"));
5197 /* PR17531: file: heap-buffer-overflow */
5198 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5200 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5201 printable_section_name (entry
->hdr
),
5202 (unsigned long) entry
->hdr
->sh_size
,
5203 (unsigned long) section
->sh_size
);
5209 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5213 error (_("Out of memory reading %lu symbols\n"),
5214 (unsigned long) number
);
5218 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5220 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5221 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5222 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5223 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5224 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5226 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5227 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5228 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5229 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5230 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5239 if (num_syms_return
!= NULL
)
5240 * num_syms_return
= isyms
== NULL
? 0 : number
;
5245 static Elf_Internal_Sym
*
5246 get_64bit_elf_symbols (FILE * file
,
5247 Elf_Internal_Shdr
* section
,
5248 unsigned long * num_syms_return
)
5250 unsigned long number
= 0;
5251 Elf64_External_Sym
* esyms
= NULL
;
5252 Elf_External_Sym_Shndx
* shndx
= NULL
;
5253 Elf_Internal_Sym
* isyms
= NULL
;
5254 Elf_Internal_Sym
* psym
;
5257 if (section
->sh_size
== 0)
5259 if (num_syms_return
!= NULL
)
5260 * num_syms_return
= 0;
5264 /* Run some sanity checks first. */
5265 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5267 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5268 printable_section_name (section
),
5269 (unsigned long) section
->sh_entsize
);
5273 if (section
->sh_size
> current_file_size
)
5275 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5276 printable_section_name (section
),
5277 (unsigned long) section
->sh_size
);
5281 number
= section
->sh_size
/ section
->sh_entsize
;
5283 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5285 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5286 (unsigned long) section
->sh_size
,
5287 printable_section_name (section
),
5288 (unsigned long) section
->sh_entsize
);
5292 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5293 section
->sh_size
, _("symbols"));
5298 elf_section_list
* entry
;
5301 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5302 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5304 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5305 entry
->hdr
->sh_offset
,
5306 1, entry
->hdr
->sh_size
,
5307 _("symbol table section indicies"));
5310 /* PR17531: file: heap-buffer-overflow */
5311 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5313 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5314 printable_section_name (entry
->hdr
),
5315 (unsigned long) entry
->hdr
->sh_size
,
5316 (unsigned long) section
->sh_size
);
5322 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5326 error (_("Out of memory reading %lu symbols\n"),
5327 (unsigned long) number
);
5331 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5333 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5334 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5335 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5336 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5338 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5340 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5341 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5342 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5344 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5345 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5354 if (num_syms_return
!= NULL
)
5355 * num_syms_return
= isyms
== NULL
? 0 : number
;
5361 get_elf_section_flags (bfd_vma sh_flags
)
5363 static char buff
[1024];
5365 int field_size
= is_32bit_elf
? 8 : 16;
5367 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5368 bfd_vma os_flags
= 0;
5369 bfd_vma proc_flags
= 0;
5370 bfd_vma unknown_flags
= 0;
5378 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5379 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5380 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5381 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5382 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5383 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5384 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5385 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5386 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5387 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5388 /* IA-64 specific. */
5389 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5390 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5391 /* IA-64 OpenVMS specific. */
5392 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5393 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5394 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5395 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5396 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5397 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5399 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5400 /* SPARC specific. */
5401 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5402 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5404 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5405 /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5406 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5409 if (do_section_details
)
5411 sprintf (buff
, "[%*.*lx]: ",
5412 field_size
, field_size
, (unsigned long) sh_flags
);
5413 p
+= field_size
+ 4;
5420 flag
= sh_flags
& - sh_flags
;
5423 if (do_section_details
)
5427 case SHF_WRITE
: sindex
= 0; break;
5428 case SHF_ALLOC
: sindex
= 1; break;
5429 case SHF_EXECINSTR
: sindex
= 2; break;
5430 case SHF_MERGE
: sindex
= 3; break;
5431 case SHF_STRINGS
: sindex
= 4; break;
5432 case SHF_INFO_LINK
: sindex
= 5; break;
5433 case SHF_LINK_ORDER
: sindex
= 6; break;
5434 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5435 case SHF_GROUP
: sindex
= 8; break;
5436 case SHF_TLS
: sindex
= 9; break;
5437 case SHF_EXCLUDE
: sindex
= 18; break;
5438 case SHF_COMPRESSED
: sindex
= 20; break;
5442 switch (elf_header
.e_machine
)
5445 if (flag
== SHF_IA_64_SHORT
)
5447 else if (flag
== SHF_IA_64_NORECOV
)
5450 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5453 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5454 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5455 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5456 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5457 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5458 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5469 case EM_OLD_SPARCV9
:
5470 case EM_SPARC32PLUS
:
5473 if (flag
== SHF_ORDERED
)
5480 case SHF_ENTRYSECT
: sindex
= 21; break;
5481 case SHF_ARM_NOREAD
: sindex
= 22; break;
5482 case SHF_COMDEF
: sindex
= 23; break;
5494 if (p
!= buff
+ field_size
+ 4)
5496 if (size
< (10 + 2))
5498 warn (_("Internal error: not enough buffer room for section flag info"));
5499 return _("<unknown>");
5506 size
-= flags
[sindex
].len
;
5507 p
= stpcpy (p
, flags
[sindex
].str
);
5509 else if (flag
& SHF_MASKOS
)
5511 else if (flag
& SHF_MASKPROC
)
5514 unknown_flags
|= flag
;
5520 case SHF_WRITE
: *p
= 'W'; break;
5521 case SHF_ALLOC
: *p
= 'A'; break;
5522 case SHF_EXECINSTR
: *p
= 'X'; break;
5523 case SHF_MERGE
: *p
= 'M'; break;
5524 case SHF_STRINGS
: *p
= 'S'; break;
5525 case SHF_INFO_LINK
: *p
= 'I'; break;
5526 case SHF_LINK_ORDER
: *p
= 'L'; break;
5527 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5528 case SHF_GROUP
: *p
= 'G'; break;
5529 case SHF_TLS
: *p
= 'T'; break;
5530 case SHF_EXCLUDE
: *p
= 'E'; break;
5531 case SHF_COMPRESSED
: *p
= 'C'; break;
5534 if ((elf_header
.e_machine
== EM_X86_64
5535 || elf_header
.e_machine
== EM_L1OM
5536 || elf_header
.e_machine
== EM_K1OM
)
5537 && flag
== SHF_X86_64_LARGE
)
5539 else if (elf_header
.e_machine
== EM_ARM
5540 && flag
== SHF_ARM_NOREAD
)
5542 else if (flag
& SHF_MASKOS
)
5545 sh_flags
&= ~ SHF_MASKOS
;
5547 else if (flag
& SHF_MASKPROC
)
5550 sh_flags
&= ~ SHF_MASKPROC
;
5560 if (do_section_details
)
5564 size
-= 5 + field_size
;
5565 if (p
!= buff
+ field_size
+ 4)
5569 warn (_("Internal error: not enough buffer room for section flag info"));
5570 return _("<unknown>");
5576 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5577 (unsigned long) os_flags
);
5578 p
+= 5 + field_size
;
5582 size
-= 7 + field_size
;
5583 if (p
!= buff
+ field_size
+ 4)
5587 warn (_("Internal error: not enough buffer room for section flag info"));
5588 return _("<unknown>");
5594 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5595 (unsigned long) proc_flags
);
5596 p
+= 7 + field_size
;
5600 size
-= 10 + field_size
;
5601 if (p
!= buff
+ field_size
+ 4)
5605 warn (_("Internal error: not enough buffer room for section flag info"));
5606 return _("<unknown>");
5612 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5613 (unsigned long) unknown_flags
);
5614 p
+= 10 + field_size
;
5623 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5627 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5628 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5629 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5630 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5631 return sizeof (*echdr
);
5635 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5636 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5637 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5638 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5639 return sizeof (*echdr
);
5644 process_section_headers (FILE * file
)
5646 Elf_Internal_Shdr
* section
;
5649 section_headers
= NULL
;
5651 if (elf_header
.e_shnum
== 0)
5653 /* PR binutils/12467. */
5654 if (elf_header
.e_shoff
!= 0)
5655 warn (_("possibly corrupt ELF file header - it has a non-zero"
5656 " section header offset, but no section headers\n"));
5657 else if (do_sections
)
5658 printf (_("\nThere are no sections in this file.\n"));
5663 if (do_sections
&& !do_header
)
5664 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5665 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5669 if (! get_32bit_section_headers (file
, FALSE
))
5672 else if (! get_64bit_section_headers (file
, FALSE
))
5675 /* Read in the string table, so that we have names to display. */
5676 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5677 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5679 section
= section_headers
+ elf_header
.e_shstrndx
;
5681 if (section
->sh_size
!= 0)
5683 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5684 1, section
->sh_size
,
5687 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5691 /* Scan the sections for the dynamic symbol table
5692 and dynamic string table and debug sections. */
5693 dynamic_symbols
= NULL
;
5694 dynamic_strings
= NULL
;
5695 dynamic_syminfo
= NULL
;
5696 symtab_shndx_list
= NULL
;
5698 eh_addr_size
= is_32bit_elf
? 4 : 8;
5699 switch (elf_header
.e_machine
)
5702 case EM_MIPS_RS3_LE
:
5703 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5704 FDE addresses. However, the ABI also has a semi-official ILP32
5705 variant for which the normal FDE address size rules apply.
5707 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5708 section, where XX is the size of longs in bits. Unfortunately,
5709 earlier compilers provided no way of distinguishing ILP32 objects
5710 from LP64 objects, so if there's any doubt, we should assume that
5711 the official LP64 form is being used. */
5712 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5713 && find_section (".gcc_compiled_long32") == NULL
)
5719 switch (elf_header
.e_flags
& EF_H8_MACH
)
5721 case E_H8_MACH_H8300
:
5722 case E_H8_MACH_H8300HN
:
5723 case E_H8_MACH_H8300SN
:
5724 case E_H8_MACH_H8300SXN
:
5727 case E_H8_MACH_H8300H
:
5728 case E_H8_MACH_H8300S
:
5729 case E_H8_MACH_H8300SX
:
5737 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5739 case EF_M32C_CPU_M16C
:
5746 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5749 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5750 if (section->sh_entsize != expected_entsize) \
5753 sprintf_vma (buf, section->sh_entsize); \
5754 /* Note: coded this way so that there is a single string for \
5756 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5757 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5758 (unsigned) expected_entsize); \
5759 section->sh_entsize = expected_entsize; \
5764 #define CHECK_ENTSIZE(section, i, type) \
5765 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5766 sizeof (Elf64_External_##type))
5768 for (i
= 0, section
= section_headers
;
5769 i
< elf_header
.e_shnum
;
5772 char * name
= SECTION_NAME (section
);
5774 if (section
->sh_type
== SHT_DYNSYM
)
5776 if (dynamic_symbols
!= NULL
)
5778 error (_("File contains multiple dynamic symbol tables\n"));
5782 CHECK_ENTSIZE (section
, i
, Sym
);
5783 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5785 else if (section
->sh_type
== SHT_STRTAB
5786 && streq (name
, ".dynstr"))
5788 if (dynamic_strings
!= NULL
)
5790 error (_("File contains multiple dynamic string tables\n"));
5794 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5795 1, section
->sh_size
,
5796 _("dynamic strings"));
5797 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5799 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5801 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5802 entry
->hdr
= section
;
5803 entry
->next
= symtab_shndx_list
;
5804 symtab_shndx_list
= entry
;
5806 else if (section
->sh_type
== SHT_SYMTAB
)
5807 CHECK_ENTSIZE (section
, i
, Sym
);
5808 else if (section
->sh_type
== SHT_GROUP
)
5809 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5810 else if (section
->sh_type
== SHT_REL
)
5811 CHECK_ENTSIZE (section
, i
, Rel
);
5812 else if (section
->sh_type
== SHT_RELA
)
5813 CHECK_ENTSIZE (section
, i
, Rela
);
5814 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5815 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5816 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5817 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5818 || do_debug_addr
|| do_debug_cu_index
)
5819 && (const_strneq (name
, ".debug_")
5820 || const_strneq (name
, ".zdebug_")))
5823 name
+= sizeof (".zdebug_") - 1;
5825 name
+= sizeof (".debug_") - 1;
5828 || (do_debug_info
&& const_strneq (name
, "info"))
5829 || (do_debug_info
&& const_strneq (name
, "types"))
5830 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5831 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5832 || (do_debug_lines
&& const_strneq (name
, "line."))
5833 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5834 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5835 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5836 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5837 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5838 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5839 || (do_debug_frames
&& const_strneq (name
, "frame"))
5840 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5841 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5842 || (do_debug_str
&& const_strneq (name
, "str"))
5843 || (do_debug_loc
&& const_strneq (name
, "loc"))
5844 || (do_debug_addr
&& const_strneq (name
, "addr"))
5845 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5846 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5848 request_dump_bynumber (i
, DEBUG_DUMP
);
5850 /* Linkonce section to be combined with .debug_info at link time. */
5851 else if ((do_debugging
|| do_debug_info
)
5852 && const_strneq (name
, ".gnu.linkonce.wi."))
5853 request_dump_bynumber (i
, DEBUG_DUMP
);
5854 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5855 request_dump_bynumber (i
, DEBUG_DUMP
);
5856 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5857 request_dump_bynumber (i
, DEBUG_DUMP
);
5858 /* Trace sections for Itanium VMS. */
5859 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5860 || do_trace_aranges
)
5861 && const_strneq (name
, ".trace_"))
5863 name
+= sizeof (".trace_") - 1;
5866 || (do_trace_info
&& streq (name
, "info"))
5867 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5868 || (do_trace_aranges
&& streq (name
, "aranges"))
5870 request_dump_bynumber (i
, DEBUG_DUMP
);
5877 if (elf_header
.e_shnum
> 1)
5878 printf (_("\nSection Headers:\n"));
5880 printf (_("\nSection Header:\n"));
5884 if (do_section_details
)
5886 printf (_(" [Nr] Name\n"));
5887 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5891 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5895 if (do_section_details
)
5897 printf (_(" [Nr] Name\n"));
5898 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5902 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5906 if (do_section_details
)
5908 printf (_(" [Nr] Name\n"));
5909 printf (_(" Type Address Offset Link\n"));
5910 printf (_(" Size EntSize Info Align\n"));
5914 printf (_(" [Nr] Name Type Address Offset\n"));
5915 printf (_(" Size EntSize Flags Link Info Align\n"));
5919 if (do_section_details
)
5920 printf (_(" Flags\n"));
5922 for (i
= 0, section
= section_headers
;
5923 i
< elf_header
.e_shnum
;
5926 printf (" [%2u] ", i
);
5927 if (do_section_details
)
5928 printf ("%s\n ", printable_section_name (section
));
5930 print_symbol (-17, SECTION_NAME (section
));
5932 printf (do_wide
? " %-15s " : " %-15.15s ",
5933 get_section_type_name (section
->sh_type
));
5937 const char * link_too_big
= NULL
;
5939 print_vma (section
->sh_addr
, LONG_HEX
);
5941 printf ( " %6.6lx %6.6lx %2.2lx",
5942 (unsigned long) section
->sh_offset
,
5943 (unsigned long) section
->sh_size
,
5944 (unsigned long) section
->sh_entsize
);
5946 if (do_section_details
)
5947 fputs (" ", stdout
);
5949 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5951 if (section
->sh_link
>= elf_header
.e_shnum
)
5954 /* The sh_link value is out of range. Normally this indicates
5955 an error but it can have special values in Solaris binaries. */
5956 switch (elf_header
.e_machine
)
5963 case EM_OLD_SPARCV9
:
5964 case EM_SPARC32PLUS
:
5967 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5968 link_too_big
= "BEFORE";
5969 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5970 link_too_big
= "AFTER";
5977 if (do_section_details
)
5979 if (link_too_big
!= NULL
&& * link_too_big
)
5980 printf ("<%s> ", link_too_big
);
5982 printf ("%2u ", section
->sh_link
);
5983 printf ("%3u %2lu\n", section
->sh_info
,
5984 (unsigned long) section
->sh_addralign
);
5987 printf ("%2u %3u %2lu\n",
5990 (unsigned long) section
->sh_addralign
);
5992 if (link_too_big
&& ! * link_too_big
)
5993 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5994 i
, section
->sh_link
);
5998 print_vma (section
->sh_addr
, LONG_HEX
);
6000 if ((long) section
->sh_offset
== section
->sh_offset
)
6001 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6005 print_vma (section
->sh_offset
, LONG_HEX
);
6008 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6009 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6013 print_vma (section
->sh_size
, LONG_HEX
);
6016 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6017 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6021 print_vma (section
->sh_entsize
, LONG_HEX
);
6024 if (do_section_details
)
6025 fputs (" ", stdout
);
6027 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6029 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6031 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6032 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6035 print_vma (section
->sh_addralign
, DEC
);
6039 else if (do_section_details
)
6041 printf (" %-15.15s ",
6042 get_section_type_name (section
->sh_type
));
6043 print_vma (section
->sh_addr
, LONG_HEX
);
6044 if ((long) section
->sh_offset
== section
->sh_offset
)
6045 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6049 print_vma (section
->sh_offset
, LONG_HEX
);
6051 printf (" %u\n ", section
->sh_link
);
6052 print_vma (section
->sh_size
, LONG_HEX
);
6054 print_vma (section
->sh_entsize
, LONG_HEX
);
6056 printf (" %-16u %lu\n",
6058 (unsigned long) section
->sh_addralign
);
6063 print_vma (section
->sh_addr
, LONG_HEX
);
6064 if ((long) section
->sh_offset
== section
->sh_offset
)
6065 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6069 print_vma (section
->sh_offset
, LONG_HEX
);
6072 print_vma (section
->sh_size
, LONG_HEX
);
6074 print_vma (section
->sh_entsize
, LONG_HEX
);
6076 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6078 printf (" %2u %3u %lu\n",
6081 (unsigned long) section
->sh_addralign
);
6084 if (do_section_details
)
6086 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6087 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6089 /* Minimum section size is 12 bytes for 32-bit compression
6090 header + 12 bytes for compressed data header. */
6091 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
;
6097 get_compression_header (&chdr
, buf
);
6098 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6101 printf (_(" [<unknown>: 0x%x], "),
6103 print_vma (chdr
.ch_size
, LONG_HEX
);
6104 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6110 if (!do_section_details
)
6112 /* The ordering of the letters shown here matches the ordering of the
6113 corresponding SHF_xxx values, and hence the order in which these
6114 letters will be displayed to the user. */
6115 printf (_("Key to Flags:\n\
6116 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6117 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6118 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6119 if (elf_header
.e_machine
== EM_X86_64
6120 || elf_header
.e_machine
== EM_L1OM
6121 || elf_header
.e_machine
== EM_K1OM
)
6122 printf (_("l (large), "));
6123 else if (elf_header
.e_machine
== EM_ARM
)
6124 printf (_("y (noread), "));
6125 printf ("p (processor specific)\n");
6132 get_group_flags (unsigned int flags
)
6134 static char buff
[32];
6144 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
6151 process_section_groups (FILE * file
)
6153 Elf_Internal_Shdr
* section
;
6155 struct group
* group
;
6156 Elf_Internal_Shdr
* symtab_sec
;
6157 Elf_Internal_Shdr
* strtab_sec
;
6158 Elf_Internal_Sym
* symtab
;
6159 unsigned long num_syms
;
6163 /* Don't process section groups unless needed. */
6164 if (!do_unwind
&& !do_section_groups
)
6167 if (elf_header
.e_shnum
== 0)
6169 if (do_section_groups
)
6170 printf (_("\nThere are no sections to group in this file.\n"));
6175 if (section_headers
== NULL
)
6177 error (_("Section headers are not available!\n"));
6178 /* PR 13622: This can happen with a corrupt ELF header. */
6182 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6183 sizeof (struct group
*));
6185 if (section_headers_groups
== NULL
)
6187 error (_("Out of memory reading %u section group headers\n"),
6188 elf_header
.e_shnum
);
6192 /* Scan the sections for the group section. */
6194 for (i
= 0, section
= section_headers
;
6195 i
< elf_header
.e_shnum
;
6197 if (section
->sh_type
== SHT_GROUP
)
6200 if (group_count
== 0)
6202 if (do_section_groups
)
6203 printf (_("\nThere are no section groups in this file.\n"));
6208 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6210 if (section_groups
== NULL
)
6212 error (_("Out of memory reading %lu groups\n"),
6213 (unsigned long) group_count
);
6223 for (i
= 0, section
= section_headers
, group
= section_groups
;
6224 i
< elf_header
.e_shnum
;
6227 if (section
->sh_type
== SHT_GROUP
)
6229 const char * name
= printable_section_name (section
);
6230 const char * group_name
;
6231 unsigned char * start
;
6232 unsigned char * indices
;
6233 unsigned int entry
, j
, size
;
6234 Elf_Internal_Shdr
* sec
;
6235 Elf_Internal_Sym
* sym
;
6237 /* Get the symbol table. */
6238 if (section
->sh_link
>= elf_header
.e_shnum
6239 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6242 error (_("Bad sh_link in group section `%s'\n"), name
);
6246 if (symtab_sec
!= sec
)
6251 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6256 error (_("Corrupt header in group section `%s'\n"), name
);
6260 if (section
->sh_info
>= num_syms
)
6262 error (_("Bad sh_info in group section `%s'\n"), name
);
6266 sym
= symtab
+ section
->sh_info
;
6268 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6270 if (sym
->st_shndx
== 0
6271 || sym
->st_shndx
>= elf_header
.e_shnum
)
6273 error (_("Bad sh_info in group section `%s'\n"), name
);
6277 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6286 /* Get the string table. */
6287 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6296 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6302 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6303 1, strtab_sec
->sh_size
,
6305 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6307 group_name
= sym
->st_name
< strtab_size
6308 ? strtab
+ sym
->st_name
: _("<corrupt>");
6311 /* PR 17531: file: loop. */
6312 if (section
->sh_entsize
> section
->sh_size
)
6314 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6315 printable_section_name (section
),
6316 (unsigned long) section
->sh_entsize
,
6317 (unsigned long) section
->sh_size
);
6321 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6322 1, section
->sh_size
,
6328 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6329 entry
= byte_get (indices
, 4);
6332 if (do_section_groups
)
6334 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6335 get_group_flags (entry
), i
, name
, group_name
, size
);
6337 printf (_(" [Index] Name\n"));
6340 group
->group_index
= i
;
6342 for (j
= 0; j
< size
; j
++)
6344 struct group_list
* g
;
6346 entry
= byte_get (indices
, 4);
6349 if (entry
>= elf_header
.e_shnum
)
6351 static unsigned num_group_errors
= 0;
6353 if (num_group_errors
++ < 10)
6355 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6356 entry
, i
, elf_header
.e_shnum
- 1);
6357 if (num_group_errors
== 10)
6358 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6363 if (section_headers_groups
[entry
] != NULL
)
6367 static unsigned num_errs
= 0;
6369 if (num_errs
++ < 10)
6371 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6373 section_headers_groups
[entry
]->group_index
);
6375 warn (_("Further error messages about already contained group sections suppressed\n"));
6381 /* Intel C/C++ compiler may put section 0 in a
6382 section group. We just warn it the first time
6383 and ignore it afterwards. */
6384 static int warned
= 0;
6387 error (_("section 0 in group section [%5u]\n"),
6388 section_headers_groups
[entry
]->group_index
);
6394 section_headers_groups
[entry
] = group
;
6396 if (do_section_groups
)
6398 sec
= section_headers
+ entry
;
6399 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6402 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6403 g
->section_index
= entry
;
6404 g
->next
= group
->root
;
6422 /* Data used to display dynamic fixups. */
6424 struct ia64_vms_dynfixup
6426 bfd_vma needed_ident
; /* Library ident number. */
6427 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6428 bfd_vma fixup_needed
; /* Index of the library. */
6429 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6430 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6433 /* Data used to display dynamic relocations. */
6435 struct ia64_vms_dynimgrela
6437 bfd_vma img_rela_cnt
; /* Number of relocations. */
6438 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6441 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6445 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6446 const char *strtab
, unsigned int strtab_sz
)
6448 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6450 const char *lib_name
;
6452 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6453 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6454 _("dynamic section image fixups"));
6458 if (fixup
->needed
< strtab_sz
)
6459 lib_name
= strtab
+ fixup
->needed
;
6462 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6463 (unsigned long) fixup
->needed
);
6466 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6467 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6469 (_("Seg Offset Type SymVec DataType\n"));
6471 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6476 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6477 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6478 type
= BYTE_GET (imfs
[i
].type
);
6479 rtype
= elf_ia64_reloc_type (type
);
6481 printf (" 0x%08x ", type
);
6483 printf (" %-32s ", rtype
);
6484 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6485 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6491 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6494 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6496 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6499 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6500 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6501 _("dynamic section image relocations"));
6505 printf (_("\nImage relocs\n"));
6507 (_("Seg Offset Type Addend Seg Sym Off\n"));
6509 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6514 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6515 printf ("%08" BFD_VMA_FMT
"x ",
6516 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6517 type
= BYTE_GET (imrs
[i
].type
);
6518 rtype
= elf_ia64_reloc_type (type
);
6520 printf ("0x%08x ", type
);
6522 printf ("%-31s ", rtype
);
6523 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6524 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6525 printf ("%08" BFD_VMA_FMT
"x\n",
6526 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6532 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6535 process_ia64_vms_dynamic_relocs (FILE *file
)
6537 struct ia64_vms_dynfixup fixup
;
6538 struct ia64_vms_dynimgrela imgrela
;
6539 Elf_Internal_Dyn
*entry
;
6541 bfd_vma strtab_off
= 0;
6542 bfd_vma strtab_sz
= 0;
6543 char *strtab
= NULL
;
6545 memset (&fixup
, 0, sizeof (fixup
));
6546 memset (&imgrela
, 0, sizeof (imgrela
));
6548 /* Note: the order of the entries is specified by the OpenVMS specs. */
6549 for (entry
= dynamic_section
;
6550 entry
< dynamic_section
+ dynamic_nent
;
6553 switch (entry
->d_tag
)
6555 case DT_IA_64_VMS_STRTAB_OFFSET
:
6556 strtab_off
= entry
->d_un
.d_val
;
6559 strtab_sz
= entry
->d_un
.d_val
;
6561 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6562 1, strtab_sz
, _("dynamic string section"));
6565 case DT_IA_64_VMS_NEEDED_IDENT
:
6566 fixup
.needed_ident
= entry
->d_un
.d_val
;
6569 fixup
.needed
= entry
->d_un
.d_val
;
6571 case DT_IA_64_VMS_FIXUP_NEEDED
:
6572 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6574 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6575 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6577 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6578 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6580 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6583 case DT_IA_64_VMS_IMG_RELA_CNT
:
6584 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6586 case DT_IA_64_VMS_IMG_RELA_OFF
:
6587 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6589 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6609 } dynamic_relocations
[] =
6611 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6612 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6613 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6616 /* Process the reloc section. */
6619 process_relocs (FILE * file
)
6621 unsigned long rel_size
;
6622 unsigned long rel_offset
;
6628 if (do_using_dynamic
)
6632 int has_dynamic_reloc
;
6635 has_dynamic_reloc
= 0;
6637 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6639 is_rela
= dynamic_relocations
[i
].rela
;
6640 name
= dynamic_relocations
[i
].name
;
6641 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6642 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6644 has_dynamic_reloc
|= rel_size
;
6646 if (is_rela
== UNKNOWN
)
6648 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6649 switch (dynamic_info
[DT_PLTREL
])
6663 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6664 name
, rel_offset
, rel_size
);
6666 dump_relocations (file
,
6667 offset_from_vma (file
, rel_offset
, rel_size
),
6669 dynamic_symbols
, num_dynamic_syms
,
6670 dynamic_strings
, dynamic_strings_length
,
6676 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6678 if (! has_dynamic_reloc
)
6679 printf (_("\nThere are no dynamic relocations in this file.\n"));
6683 Elf_Internal_Shdr
* section
;
6687 for (i
= 0, section
= section_headers
;
6688 i
< elf_header
.e_shnum
;
6691 if ( section
->sh_type
!= SHT_RELA
6692 && section
->sh_type
!= SHT_REL
)
6695 rel_offset
= section
->sh_offset
;
6696 rel_size
= section
->sh_size
;
6700 Elf_Internal_Shdr
* strsec
;
6703 printf (_("\nRelocation section "));
6705 if (string_table
== NULL
)
6706 printf ("%d", section
->sh_name
);
6708 printf ("'%s'", printable_section_name (section
));
6710 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6711 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6713 is_rela
= section
->sh_type
== SHT_RELA
;
6715 if (section
->sh_link
!= 0
6716 && section
->sh_link
< elf_header
.e_shnum
)
6718 Elf_Internal_Shdr
* symsec
;
6719 Elf_Internal_Sym
* symtab
;
6720 unsigned long nsyms
;
6721 unsigned long strtablen
= 0;
6722 char * strtab
= NULL
;
6724 symsec
= section_headers
+ section
->sh_link
;
6725 if (symsec
->sh_type
!= SHT_SYMTAB
6726 && symsec
->sh_type
!= SHT_DYNSYM
)
6729 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6734 if (symsec
->sh_link
!= 0
6735 && symsec
->sh_link
< elf_header
.e_shnum
)
6737 strsec
= section_headers
+ symsec
->sh_link
;
6739 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6742 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6745 dump_relocations (file
, rel_offset
, rel_size
,
6746 symtab
, nsyms
, strtab
, strtablen
,
6748 symsec
->sh_type
== SHT_DYNSYM
);
6754 dump_relocations (file
, rel_offset
, rel_size
,
6755 NULL
, 0, NULL
, 0, is_rela
, 0);
6762 printf (_("\nThere are no relocations in this file.\n"));
6768 /* An absolute address consists of a section and an offset. If the
6769 section is NULL, the offset itself is the address, otherwise, the
6770 address equals to LOAD_ADDRESS(section) + offset. */
6774 unsigned short section
;
6778 #define ABSADDR(a) \
6780 ? section_headers [(a).section].sh_addr + (a).offset \
6783 /* Find the nearest symbol at or below ADDR. Returns the symbol
6784 name, if found, and the offset from the symbol to ADDR. */
6787 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6788 unsigned long nsyms
,
6789 const char * strtab
,
6790 unsigned long strtab_size
,
6791 struct absaddr addr
,
6792 const char ** symname
,
6795 bfd_vma dist
= 0x100000;
6796 Elf_Internal_Sym
* sym
;
6797 Elf_Internal_Sym
* beg
;
6798 Elf_Internal_Sym
* end
;
6799 Elf_Internal_Sym
* best
= NULL
;
6801 REMOVE_ARCH_BITS (addr
.offset
);
6803 end
= symtab
+ nsyms
;
6809 sym
= beg
+ (end
- beg
) / 2;
6811 value
= sym
->st_value
;
6812 REMOVE_ARCH_BITS (value
);
6814 if (sym
->st_name
!= 0
6815 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6816 && addr
.offset
>= value
6817 && addr
.offset
- value
< dist
)
6820 dist
= addr
.offset
- value
;
6825 if (addr
.offset
< value
)
6833 *symname
= (best
->st_name
>= strtab_size
6834 ? _("<corrupt>") : strtab
+ best
->st_name
);
6840 *offset
= addr
.offset
;
6844 symcmp (const void *p
, const void *q
)
6846 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6847 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6849 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6852 /* Process the unwind section. */
6854 #include "unwind-ia64.h"
6856 struct ia64_unw_table_entry
6858 struct absaddr start
;
6860 struct absaddr info
;
6863 struct ia64_unw_aux_info
6865 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6866 unsigned long table_len
; /* Length of unwind table. */
6867 unsigned char * info
; /* Unwind info. */
6868 unsigned long info_size
; /* Size of unwind info. */
6869 bfd_vma info_addr
; /* Starting address of unwind info. */
6870 bfd_vma seg_base
; /* Starting address of segment. */
6871 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6872 unsigned long nsyms
; /* Number of symbols. */
6873 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6874 unsigned long nfuns
; /* Number of entries in funtab. */
6875 char * strtab
; /* The string table. */
6876 unsigned long strtab_size
; /* Size of string table. */
6880 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6882 struct ia64_unw_table_entry
* tp
;
6883 unsigned long j
, nfuns
;
6886 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6887 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6888 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6889 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6891 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6893 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6897 const unsigned char * dp
;
6898 const unsigned char * head
;
6899 const unsigned char * end
;
6900 const char * procname
;
6902 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6903 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6905 fputs ("\n<", stdout
);
6909 fputs (procname
, stdout
);
6912 printf ("+%lx", (unsigned long) offset
);
6915 fputs (">: [", stdout
);
6916 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6917 fputc ('-', stdout
);
6918 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6919 printf ("], info at +0x%lx\n",
6920 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6922 /* PR 17531: file: 86232b32. */
6923 if (aux
->info
== NULL
)
6926 /* PR 17531: file: 0997b4d1. */
6927 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6929 warn (_("Invalid offset %lx in table entry %ld\n"),
6930 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6934 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6935 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6937 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6938 (unsigned) UNW_VER (stamp
),
6939 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6940 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6941 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6942 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6944 if (UNW_VER (stamp
) != 1)
6946 printf (_("\tUnknown version.\n"));
6951 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6952 /* PR 17531: file: 16ceda89. */
6953 if (end
> aux
->info
+ aux
->info_size
)
6954 end
= aux
->info
+ aux
->info_size
;
6955 for (dp
= head
+ 8; dp
< end
;)
6956 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
6963 slurp_ia64_unwind_table (FILE * file
,
6964 struct ia64_unw_aux_info
* aux
,
6965 Elf_Internal_Shdr
* sec
)
6967 unsigned long size
, nrelas
, i
;
6968 Elf_Internal_Phdr
* seg
;
6969 struct ia64_unw_table_entry
* tep
;
6970 Elf_Internal_Shdr
* relsec
;
6971 Elf_Internal_Rela
* rela
;
6972 Elf_Internal_Rela
* rp
;
6973 unsigned char * table
;
6975 Elf_Internal_Sym
* sym
;
6976 const char * relname
;
6980 /* First, find the starting address of the segment that includes
6983 if (elf_header
.e_phnum
)
6985 if (! get_program_headers (file
))
6988 for (seg
= program_headers
;
6989 seg
< program_headers
+ elf_header
.e_phnum
;
6992 if (seg
->p_type
!= PT_LOAD
)
6995 if (sec
->sh_addr
>= seg
->p_vaddr
6996 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6998 aux
->seg_base
= seg
->p_vaddr
;
7004 /* Second, build the unwind table from the contents of the unwind section: */
7005 size
= sec
->sh_size
;
7006 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7011 aux
->table_len
= size
/ (3 * eh_addr_size
);
7012 aux
->table
= (struct ia64_unw_table_entry
*)
7013 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7016 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7018 tep
->start
.section
= SHN_UNDEF
;
7019 tep
->end
.section
= SHN_UNDEF
;
7020 tep
->info
.section
= SHN_UNDEF
;
7021 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7022 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7023 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7024 tep
->start
.offset
+= aux
->seg_base
;
7025 tep
->end
.offset
+= aux
->seg_base
;
7026 tep
->info
.offset
+= aux
->seg_base
;
7030 /* Third, apply any relocations to the unwind table: */
7031 for (relsec
= section_headers
;
7032 relsec
< section_headers
+ elf_header
.e_shnum
;
7035 if (relsec
->sh_type
!= SHT_RELA
7036 || relsec
->sh_info
>= elf_header
.e_shnum
7037 || section_headers
+ relsec
->sh_info
!= sec
)
7040 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7049 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7051 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7052 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7054 /* PR 17531: file: 9fa67536. */
7055 if (relname
== NULL
)
7057 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7061 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7063 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7067 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7069 /* PR 17531: file: 5bc8d9bf. */
7070 if (i
>= aux
->table_len
)
7072 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7076 switch (rp
->r_offset
/ eh_addr_size
% 3)
7079 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7080 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7083 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7084 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7087 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7088 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7102 ia64_process_unwind (FILE * file
)
7104 Elf_Internal_Shdr
* sec
;
7105 Elf_Internal_Shdr
* unwsec
= NULL
;
7106 Elf_Internal_Shdr
* strsec
;
7107 unsigned long i
, unwcount
= 0, unwstart
= 0;
7108 struct ia64_unw_aux_info aux
;
7110 memset (& aux
, 0, sizeof (aux
));
7112 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7114 if (sec
->sh_type
== SHT_SYMTAB
7115 && sec
->sh_link
< elf_header
.e_shnum
)
7117 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7119 strsec
= section_headers
+ sec
->sh_link
;
7120 if (aux
.strtab
!= NULL
)
7122 error (_("Multiple auxillary string tables encountered\n"));
7125 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7128 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7130 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7135 printf (_("\nThere are no unwind sections in this file.\n"));
7137 while (unwcount
-- > 0)
7142 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7143 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7144 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7149 /* We have already counted the number of SHT_IA64_UNWIND
7150 sections so the loop above should never fail. */
7151 assert (unwsec
!= NULL
);
7154 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7156 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7158 /* We need to find which section group it is in. */
7159 struct group_list
* g
;
7161 if (section_headers_groups
== NULL
7162 || section_headers_groups
[i
] == NULL
)
7163 i
= elf_header
.e_shnum
;
7166 g
= section_headers_groups
[i
]->root
;
7168 for (; g
!= NULL
; g
= g
->next
)
7170 sec
= section_headers
+ g
->section_index
;
7172 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7177 i
= elf_header
.e_shnum
;
7180 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7182 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7183 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7184 suffix
= SECTION_NAME (unwsec
) + len
;
7185 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7187 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7188 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7193 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7194 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7195 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7196 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7198 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7199 suffix
= SECTION_NAME (unwsec
) + len
;
7200 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7202 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7203 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7207 if (i
== elf_header
.e_shnum
)
7209 printf (_("\nCould not find unwind info section for "));
7211 if (string_table
== NULL
)
7212 printf ("%d", unwsec
->sh_name
);
7214 printf ("'%s'", printable_section_name (unwsec
));
7218 aux
.info_addr
= sec
->sh_addr
;
7219 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7222 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7224 printf (_("\nUnwind section "));
7226 if (string_table
== NULL
)
7227 printf ("%d", unwsec
->sh_name
);
7229 printf ("'%s'", printable_section_name (unwsec
));
7231 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7232 (unsigned long) unwsec
->sh_offset
,
7233 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7235 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7236 && aux
.table_len
> 0)
7237 dump_ia64_unwind (& aux
);
7240 free ((char *) aux
.table
);
7242 free ((char *) aux
.info
);
7251 free ((char *) aux
.strtab
);
7254 struct hppa_unw_table_entry
7256 struct absaddr start
;
7258 unsigned int Cannot_unwind
:1; /* 0 */
7259 unsigned int Millicode
:1; /* 1 */
7260 unsigned int Millicode_save_sr0
:1; /* 2 */
7261 unsigned int Region_description
:2; /* 3..4 */
7262 unsigned int reserved1
:1; /* 5 */
7263 unsigned int Entry_SR
:1; /* 6 */
7264 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7265 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7266 unsigned int Args_stored
:1; /* 16 */
7267 unsigned int Variable_Frame
:1; /* 17 */
7268 unsigned int Separate_Package_Body
:1; /* 18 */
7269 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7270 unsigned int Stack_Overflow_Check
:1; /* 20 */
7271 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7272 unsigned int Ada_Region
:1; /* 22 */
7273 unsigned int cxx_info
:1; /* 23 */
7274 unsigned int cxx_try_catch
:1; /* 24 */
7275 unsigned int sched_entry_seq
:1; /* 25 */
7276 unsigned int reserved2
:1; /* 26 */
7277 unsigned int Save_SP
:1; /* 27 */
7278 unsigned int Save_RP
:1; /* 28 */
7279 unsigned int Save_MRP_in_frame
:1; /* 29 */
7280 unsigned int extn_ptr_defined
:1; /* 30 */
7281 unsigned int Cleanup_defined
:1; /* 31 */
7283 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7284 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7285 unsigned int Large_frame
:1; /* 2 */
7286 unsigned int Pseudo_SP_Set
:1; /* 3 */
7287 unsigned int reserved4
:1; /* 4 */
7288 unsigned int Total_frame_size
:27; /* 5..31 */
7291 struct hppa_unw_aux_info
7293 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7294 unsigned long table_len
; /* Length of unwind table. */
7295 bfd_vma seg_base
; /* Starting address of segment. */
7296 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7297 unsigned long nsyms
; /* Number of symbols. */
7298 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7299 unsigned long nfuns
; /* Number of entries in funtab. */
7300 char * strtab
; /* The string table. */
7301 unsigned long strtab_size
; /* Size of string table. */
7305 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7307 struct hppa_unw_table_entry
* tp
;
7308 unsigned long j
, nfuns
;
7310 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7311 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7312 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7313 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7315 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7317 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7320 const char * procname
;
7322 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7323 aux
->strtab_size
, tp
->start
, &procname
,
7326 fputs ("\n<", stdout
);
7330 fputs (procname
, stdout
);
7333 printf ("+%lx", (unsigned long) offset
);
7336 fputs (">: [", stdout
);
7337 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7338 fputc ('-', stdout
);
7339 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7342 #define PF(_m) if (tp->_m) printf (#_m " ");
7343 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7346 PF(Millicode_save_sr0
);
7347 /* PV(Region_description); */
7353 PF(Separate_Package_Body
);
7354 PF(Frame_Extension_Millicode
);
7355 PF(Stack_Overflow_Check
);
7356 PF(Two_Instruction_SP_Increment
);
7360 PF(sched_entry_seq
);
7363 PF(Save_MRP_in_frame
);
7364 PF(extn_ptr_defined
);
7365 PF(Cleanup_defined
);
7366 PF(MPE_XL_interrupt_marker
);
7367 PF(HP_UX_interrupt_marker
);
7370 PV(Total_frame_size
);
7381 slurp_hppa_unwind_table (FILE * file
,
7382 struct hppa_unw_aux_info
* aux
,
7383 Elf_Internal_Shdr
* sec
)
7385 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7386 Elf_Internal_Phdr
* seg
;
7387 struct hppa_unw_table_entry
* tep
;
7388 Elf_Internal_Shdr
* relsec
;
7389 Elf_Internal_Rela
* rela
;
7390 Elf_Internal_Rela
* rp
;
7391 unsigned char * table
;
7393 Elf_Internal_Sym
* sym
;
7394 const char * relname
;
7396 /* First, find the starting address of the segment that includes
7399 if (elf_header
.e_phnum
)
7401 if (! get_program_headers (file
))
7404 for (seg
= program_headers
;
7405 seg
< program_headers
+ elf_header
.e_phnum
;
7408 if (seg
->p_type
!= PT_LOAD
)
7411 if (sec
->sh_addr
>= seg
->p_vaddr
7412 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7414 aux
->seg_base
= seg
->p_vaddr
;
7420 /* Second, build the unwind table from the contents of the unwind
7422 size
= sec
->sh_size
;
7423 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7429 nentries
= size
/ unw_ent_size
;
7430 size
= unw_ent_size
* nentries
;
7432 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7433 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7435 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7437 unsigned int tmp1
, tmp2
;
7439 tep
->start
.section
= SHN_UNDEF
;
7440 tep
->end
.section
= SHN_UNDEF
;
7442 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7443 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7444 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7445 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7447 tep
->start
.offset
+= aux
->seg_base
;
7448 tep
->end
.offset
+= aux
->seg_base
;
7450 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7451 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7452 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7453 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7454 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7455 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7456 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7457 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7458 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7459 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7460 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7461 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7462 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7463 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7464 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7465 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7466 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7467 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7468 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7469 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7470 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7471 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7472 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7473 tep
->Cleanup_defined
= tmp1
& 0x1;
7475 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7476 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7477 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7478 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7479 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7480 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7484 /* Third, apply any relocations to the unwind table. */
7485 for (relsec
= section_headers
;
7486 relsec
< section_headers
+ elf_header
.e_shnum
;
7489 if (relsec
->sh_type
!= SHT_RELA
7490 || relsec
->sh_info
>= elf_header
.e_shnum
7491 || section_headers
+ relsec
->sh_info
!= sec
)
7494 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7498 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7500 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7501 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7503 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7504 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7506 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7510 i
= rp
->r_offset
/ unw_ent_size
;
7512 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7515 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7516 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7519 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7520 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7530 aux
->table_len
= nentries
;
7536 hppa_process_unwind (FILE * file
)
7538 struct hppa_unw_aux_info aux
;
7539 Elf_Internal_Shdr
* unwsec
= NULL
;
7540 Elf_Internal_Shdr
* strsec
;
7541 Elf_Internal_Shdr
* sec
;
7544 if (string_table
== NULL
)
7547 memset (& aux
, 0, sizeof (aux
));
7549 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7551 if (sec
->sh_type
== SHT_SYMTAB
7552 && sec
->sh_link
< elf_header
.e_shnum
)
7554 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7556 strsec
= section_headers
+ sec
->sh_link
;
7557 if (aux
.strtab
!= NULL
)
7559 error (_("Multiple auxillary string tables encountered\n"));
7562 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7565 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7567 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7572 printf (_("\nThere are no unwind sections in this file.\n"));
7574 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7576 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7578 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7579 printable_section_name (sec
),
7580 (unsigned long) sec
->sh_offset
,
7581 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7583 slurp_hppa_unwind_table (file
, &aux
, sec
);
7584 if (aux
.table_len
> 0)
7585 dump_hppa_unwind (&aux
);
7588 free ((char *) aux
.table
);
7596 free ((char *) aux
.strtab
);
7601 unsigned char * data
; /* The unwind data. */
7602 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7603 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7604 unsigned long nrelas
; /* The number of relocations. */
7605 unsigned int rel_type
; /* REL or RELA ? */
7606 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7609 struct arm_unw_aux_info
7611 FILE * file
; /* The file containing the unwind sections. */
7612 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7613 unsigned long nsyms
; /* Number of symbols. */
7614 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7615 unsigned long nfuns
; /* Number of these symbols. */
7616 char * strtab
; /* The file's string table. */
7617 unsigned long strtab_size
; /* Size of string table. */
7621 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7622 bfd_vma fn
, struct absaddr addr
)
7624 const char *procname
;
7627 if (addr
.section
== SHN_UNDEF
)
7630 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7631 aux
->strtab_size
, addr
, &procname
,
7634 print_vma (fn
, PREFIX_HEX
);
7638 fputs (" <", stdout
);
7639 fputs (procname
, stdout
);
7642 printf ("+0x%lx", (unsigned long) sym_offset
);
7643 fputc ('>', stdout
);
7650 arm_free_section (struct arm_section
*arm_sec
)
7652 if (arm_sec
->data
!= NULL
)
7653 free (arm_sec
->data
);
7655 if (arm_sec
->rela
!= NULL
)
7656 free (arm_sec
->rela
);
7659 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7660 cached section and install SEC instead.
7661 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7662 and return its valued in * WORDP, relocating if necessary.
7663 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7664 relocation's offset in ADDR.
7665 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7666 into the string table of the symbol associated with the reloc. If no
7667 reloc was applied store -1 there.
7668 5) Return TRUE upon success, FALSE otherwise. */
7671 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7672 struct arm_section
* arm_sec
,
7673 Elf_Internal_Shdr
* sec
,
7674 bfd_vma word_offset
,
7675 unsigned int * wordp
,
7676 struct absaddr
* addr
,
7679 Elf_Internal_Rela
*rp
;
7680 Elf_Internal_Sym
*sym
;
7681 const char * relname
;
7683 bfd_boolean wrapped
;
7685 if (sec
== NULL
|| arm_sec
== NULL
)
7688 addr
->section
= SHN_UNDEF
;
7691 if (sym_name
!= NULL
)
7692 *sym_name
= (bfd_vma
) -1;
7694 /* If necessary, update the section cache. */
7695 if (sec
!= arm_sec
->sec
)
7697 Elf_Internal_Shdr
*relsec
;
7699 arm_free_section (arm_sec
);
7702 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7703 sec
->sh_size
, _("unwind data"));
7704 arm_sec
->rela
= NULL
;
7705 arm_sec
->nrelas
= 0;
7707 for (relsec
= section_headers
;
7708 relsec
< section_headers
+ elf_header
.e_shnum
;
7711 if (relsec
->sh_info
>= elf_header
.e_shnum
7712 || section_headers
+ relsec
->sh_info
!= sec
7713 /* PR 15745: Check the section type as well. */
7714 || (relsec
->sh_type
!= SHT_REL
7715 && relsec
->sh_type
!= SHT_RELA
))
7718 arm_sec
->rel_type
= relsec
->sh_type
;
7719 if (relsec
->sh_type
== SHT_REL
)
7721 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7723 & arm_sec
->rela
, & arm_sec
->nrelas
))
7726 else /* relsec->sh_type == SHT_RELA */
7728 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7730 & arm_sec
->rela
, & arm_sec
->nrelas
))
7736 arm_sec
->next_rela
= arm_sec
->rela
;
7739 /* If there is no unwind data we can do nothing. */
7740 if (arm_sec
->data
== NULL
)
7743 /* If the offset is invalid then fail. */
7744 if (word_offset
> (sec
->sh_size
- 4)
7746 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7747 || ((bfd_signed_vma
) word_offset
) < 0)
7750 /* Get the word at the required offset. */
7751 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7753 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7754 if (arm_sec
->rela
== NULL
)
7760 /* Look through the relocs to find the one that applies to the provided offset. */
7762 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7764 bfd_vma prelval
, offset
;
7766 if (rp
->r_offset
> word_offset
&& !wrapped
)
7771 if (rp
->r_offset
> word_offset
)
7774 if (rp
->r_offset
& 3)
7776 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7777 (unsigned long) rp
->r_offset
);
7781 if (rp
->r_offset
< word_offset
)
7784 /* PR 17531: file: 027-161405-0.004 */
7785 if (aux
->symtab
== NULL
)
7788 if (arm_sec
->rel_type
== SHT_REL
)
7790 offset
= word
& 0x7fffffff;
7791 if (offset
& 0x40000000)
7792 offset
|= ~ (bfd_vma
) 0x7fffffff;
7794 else if (arm_sec
->rel_type
== SHT_RELA
)
7795 offset
= rp
->r_addend
;
7798 error (_("Unknown section relocation type %d encountered\n"),
7803 /* PR 17531 file: 027-1241568-0.004. */
7804 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7806 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7807 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7811 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7812 offset
+= sym
->st_value
;
7813 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7815 /* Check that we are processing the expected reloc type. */
7816 if (elf_header
.e_machine
== EM_ARM
)
7818 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7819 if (relname
== NULL
)
7821 warn (_("Skipping unknown ARM relocation type: %d\n"),
7822 (int) ELF32_R_TYPE (rp
->r_info
));
7826 if (streq (relname
, "R_ARM_NONE"))
7829 if (! streq (relname
, "R_ARM_PREL31"))
7831 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7835 else if (elf_header
.e_machine
== EM_TI_C6000
)
7837 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7838 if (relname
== NULL
)
7840 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7841 (int) ELF32_R_TYPE (rp
->r_info
));
7845 if (streq (relname
, "R_C6000_NONE"))
7848 if (! streq (relname
, "R_C6000_PREL31"))
7850 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7858 /* This function currently only supports ARM and TI unwinders. */
7859 warn (_("Only TI and ARM unwinders are currently supported\n"));
7863 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7864 addr
->section
= sym
->st_shndx
;
7865 addr
->offset
= offset
;
7868 * sym_name
= sym
->st_name
;
7873 arm_sec
->next_rela
= rp
;
7878 static const char *tic6x_unwind_regnames
[16] =
7880 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7881 "A14", "A13", "A12", "A11", "A10",
7882 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7886 decode_tic6x_unwind_regmask (unsigned int mask
)
7890 for (i
= 12; mask
; mask
>>= 1, i
--)
7894 fputs (tic6x_unwind_regnames
[i
], stdout
);
7896 fputs (", ", stdout
);
7902 if (remaining == 0 && more_words) \
7905 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7906 data_offset, & word, & addr, NULL)) \
7912 #define GET_OP(OP) \
7917 (OP) = word >> 24; \
7922 printf (_("[Truncated opcode]\n")); \
7925 printf ("0x%02x ", OP)
7928 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7930 unsigned int remaining
,
7931 unsigned int more_words
,
7932 bfd_vma data_offset
,
7933 Elf_Internal_Shdr
* data_sec
,
7934 struct arm_section
* data_arm_sec
)
7936 struct absaddr addr
;
7938 /* Decode the unwinding instructions. */
7941 unsigned int op
, op2
;
7950 printf (" 0x%02x ", op
);
7952 if ((op
& 0xc0) == 0x00)
7954 int offset
= ((op
& 0x3f) << 2) + 4;
7956 printf (" vsp = vsp + %d", offset
);
7958 else if ((op
& 0xc0) == 0x40)
7960 int offset
= ((op
& 0x3f) << 2) + 4;
7962 printf (" vsp = vsp - %d", offset
);
7964 else if ((op
& 0xf0) == 0x80)
7967 if (op
== 0x80 && op2
== 0)
7968 printf (_("Refuse to unwind"));
7971 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7976 for (i
= 0; i
< 12; i
++)
7977 if (mask
& (1 << i
))
7983 printf ("r%d", 4 + i
);
7988 else if ((op
& 0xf0) == 0x90)
7990 if (op
== 0x9d || op
== 0x9f)
7991 printf (_(" [Reserved]"));
7993 printf (" vsp = r%d", op
& 0x0f);
7995 else if ((op
& 0xf0) == 0xa0)
7997 int end
= 4 + (op
& 0x07);
8002 for (i
= 4; i
<= end
; i
++)
8018 else if (op
== 0xb0)
8019 printf (_(" finish"));
8020 else if (op
== 0xb1)
8023 if (op2
== 0 || (op2
& 0xf0) != 0)
8024 printf (_("[Spare]"));
8027 unsigned int mask
= op2
& 0x0f;
8032 for (i
= 0; i
< 12; i
++)
8033 if (mask
& (1 << i
))
8044 else if (op
== 0xb2)
8046 unsigned char buf
[9];
8047 unsigned int i
, len
;
8048 unsigned long offset
;
8050 for (i
= 0; i
< sizeof (buf
); i
++)
8053 if ((buf
[i
] & 0x80) == 0)
8056 if (i
== sizeof (buf
))
8057 printf (_("corrupt change to vsp"));
8060 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8061 assert (len
== i
+ 1);
8062 offset
= offset
* 4 + 0x204;
8063 printf ("vsp = vsp + %ld", offset
);
8066 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8068 unsigned int first
, last
;
8075 printf ("pop {D%d", first
);
8077 printf ("-D%d", first
+ last
);
8080 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8082 unsigned int count
= op
& 0x07;
8086 printf ("-D%d", 8 + count
);
8089 else if (op
>= 0xc0 && op
<= 0xc5)
8091 unsigned int count
= op
& 0x07;
8093 printf (" pop {wR10");
8095 printf ("-wR%d", 10 + count
);
8098 else if (op
== 0xc6)
8100 unsigned int first
, last
;
8105 printf ("pop {wR%d", first
);
8107 printf ("-wR%d", first
+ last
);
8110 else if (op
== 0xc7)
8113 if (op2
== 0 || (op2
& 0xf0) != 0)
8114 printf (_("[Spare]"));
8117 unsigned int mask
= op2
& 0x0f;
8122 for (i
= 0; i
< 4; i
++)
8123 if (mask
& (1 << i
))
8129 printf ("wCGR%d", i
);
8135 printf (_(" [unsupported opcode]"));
8141 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8143 unsigned int remaining
,
8144 unsigned int more_words
,
8145 bfd_vma data_offset
,
8146 Elf_Internal_Shdr
* data_sec
,
8147 struct arm_section
* data_arm_sec
)
8149 struct absaddr addr
;
8151 /* Decode the unwinding instructions. */
8154 unsigned int op
, op2
;
8163 printf (" 0x%02x ", op
);
8165 if ((op
& 0xc0) == 0x00)
8167 int offset
= ((op
& 0x3f) << 3) + 8;
8168 printf (" sp = sp + %d", offset
);
8170 else if ((op
& 0xc0) == 0x80)
8173 if (op
== 0x80 && op2
== 0)
8174 printf (_("Refuse to unwind"));
8177 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8179 printf ("pop compact {");
8183 decode_tic6x_unwind_regmask (mask
);
8187 else if ((op
& 0xf0) == 0xc0)
8195 unsigned int offset
;
8199 /* Scan entire instruction first so that GET_OP output is not
8200 interleaved with disassembly. */
8202 for (i
= 0; nregs
< (op
& 0xf); i
++)
8208 regpos
[nregs
].offset
= i
* 2;
8209 regpos
[nregs
].reg
= reg
;
8216 regpos
[nregs
].offset
= i
* 2 + 1;
8217 regpos
[nregs
].reg
= reg
;
8222 printf (_("pop frame {"));
8224 for (i
= i
* 2; i
> 0; i
--)
8226 if (regpos
[reg
].offset
== i
- 1)
8228 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8235 fputs (name
, stdout
);
8242 else if (op
== 0xd0)
8243 printf (" MOV FP, SP");
8244 else if (op
== 0xd1)
8245 printf (" __c6xabi_pop_rts");
8246 else if (op
== 0xd2)
8248 unsigned char buf
[9];
8249 unsigned int i
, len
;
8250 unsigned long offset
;
8252 for (i
= 0; i
< sizeof (buf
); i
++)
8255 if ((buf
[i
] & 0x80) == 0)
8258 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8259 if (i
== sizeof (buf
))
8261 printf ("<corrupt sp adjust>\n");
8262 warn (_("Corrupt stack pointer adjustment detected\n"));
8266 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8267 assert (len
== i
+ 1);
8268 offset
= offset
* 8 + 0x408;
8269 printf (_("sp = sp + %ld"), offset
);
8271 else if ((op
& 0xf0) == 0xe0)
8273 if ((op
& 0x0f) == 7)
8276 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8280 printf (_(" [unsupported opcode]"));
8287 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8291 offset
= word
& 0x7fffffff;
8292 if (offset
& 0x40000000)
8293 offset
|= ~ (bfd_vma
) 0x7fffffff;
8295 if (elf_header
.e_machine
== EM_TI_C6000
)
8298 return offset
+ where
;
8302 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8304 unsigned int remaining
,
8305 bfd_vma data_offset
,
8306 Elf_Internal_Shdr
* data_sec
,
8307 struct arm_section
* data_arm_sec
)
8310 unsigned int more_words
= 0;
8311 struct absaddr addr
;
8312 bfd_vma sym_name
= (bfd_vma
) -1;
8316 /* Fetch the first word.
8317 Note - when decoding an object file the address extracted
8318 here will always be 0. So we also pass in the sym_name
8319 parameter so that we can find the symbol associated with
8320 the personality routine. */
8321 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8322 & word
, & addr
, & sym_name
))
8328 if ((word
& 0x80000000) == 0)
8330 /* Expand prel31 for personality routine. */
8332 const char *procname
;
8334 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8335 printf (_(" Personality routine: "));
8337 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8338 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8340 procname
= aux
->strtab
+ sym_name
;
8341 print_vma (fn
, PREFIX_HEX
);
8344 fputs (" <", stdout
);
8345 fputs (procname
, stdout
);
8346 fputc ('>', stdout
);
8350 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8351 fputc ('\n', stdout
);
8353 /* The GCC personality routines use the standard compact
8354 encoding, starting with one byte giving the number of
8356 if (procname
!= NULL
8357 && (const_strneq (procname
, "__gcc_personality_v0")
8358 || const_strneq (procname
, "__gxx_personality_v0")
8359 || const_strneq (procname
, "__gcj_personality_v0")
8360 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8367 printf (_(" [Truncated data]\n"));
8370 more_words
= word
>> 24;
8380 /* ARM EHABI Section 6.3:
8382 An exception-handling table entry for the compact model looks like:
8386 1 0 index Data for personalityRoutine[index] */
8388 if (elf_header
.e_machine
== EM_ARM
8389 && (word
& 0x70000000))
8390 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8392 per_index
= (word
>> 24) & 0x7f;
8393 printf (_(" Compact model index: %d\n"), per_index
);
8400 else if (per_index
< 3)
8402 more_words
= (word
>> 16) & 0xff;
8408 switch (elf_header
.e_machine
)
8413 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8414 data_offset
, data_sec
, data_arm_sec
);
8418 warn (_("Unknown ARM compact model index encountered\n"));
8419 printf (_(" [reserved]\n"));
8426 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8427 data_offset
, data_sec
, data_arm_sec
);
8429 else if (per_index
< 5)
8431 if (((word
>> 17) & 0x7f) == 0x7f)
8432 printf (_(" Restore stack from frame pointer\n"));
8434 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8435 printf (_(" Registers restored: "));
8437 printf (" (compact) ");
8438 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8440 printf (_(" Return register: %s\n"),
8441 tic6x_unwind_regnames
[word
& 0xf]);
8444 printf (_(" [reserved (%d)]\n"), per_index
);
8448 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8449 elf_header
.e_machine
);
8452 /* Decode the descriptors. Not implemented. */
8456 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8458 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8459 unsigned int i
, exidx_len
;
8460 unsigned long j
, nfuns
;
8462 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8463 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8464 exidx_len
= exidx_sec
->sh_size
/ 8;
8466 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8467 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8468 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8469 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8471 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8473 for (i
= 0; i
< exidx_len
; i
++)
8475 unsigned int exidx_fn
, exidx_entry
;
8476 struct absaddr fn_addr
, entry_addr
;
8479 fputc ('\n', stdout
);
8481 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8482 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8483 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8484 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8487 arm_free_section (& exidx_arm_sec
);
8488 arm_free_section (& extab_arm_sec
);
8492 /* ARM EHABI, Section 5:
8493 An index table entry consists of 2 words.
8494 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8495 if (exidx_fn
& 0x80000000)
8496 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8498 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8500 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8501 fputs (": ", stdout
);
8503 if (exidx_entry
== 1)
8505 print_vma (exidx_entry
, PREFIX_HEX
);
8506 fputs (" [cantunwind]\n", stdout
);
8508 else if (exidx_entry
& 0x80000000)
8510 print_vma (exidx_entry
, PREFIX_HEX
);
8511 fputc ('\n', stdout
);
8512 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8516 bfd_vma table
, table_offset
= 0;
8517 Elf_Internal_Shdr
*table_sec
;
8519 fputs ("@", stdout
);
8520 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8521 print_vma (table
, PREFIX_HEX
);
8524 /* Locate the matching .ARM.extab. */
8525 if (entry_addr
.section
!= SHN_UNDEF
8526 && entry_addr
.section
< elf_header
.e_shnum
)
8528 table_sec
= section_headers
+ entry_addr
.section
;
8529 table_offset
= entry_addr
.offset
;
8531 if (table_offset
> table_sec
->sh_size
8532 || ((bfd_signed_vma
) table_offset
) < 0)
8534 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8535 (unsigned long) table_offset
,
8536 printable_section_name (table_sec
));
8542 table_sec
= find_section_by_address (table
);
8543 if (table_sec
!= NULL
)
8544 table_offset
= table
- table_sec
->sh_addr
;
8546 if (table_sec
== NULL
)
8548 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8549 (unsigned long) table
);
8552 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8560 arm_free_section (&exidx_arm_sec
);
8561 arm_free_section (&extab_arm_sec
);
8564 /* Used for both ARM and C6X unwinding tables. */
8567 arm_process_unwind (FILE *file
)
8569 struct arm_unw_aux_info aux
;
8570 Elf_Internal_Shdr
*unwsec
= NULL
;
8571 Elf_Internal_Shdr
*strsec
;
8572 Elf_Internal_Shdr
*sec
;
8574 unsigned int sec_type
;
8576 switch (elf_header
.e_machine
)
8579 sec_type
= SHT_ARM_EXIDX
;
8583 sec_type
= SHT_C6000_UNWIND
;
8587 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8588 elf_header
.e_machine
);
8592 if (string_table
== NULL
)
8595 memset (& aux
, 0, sizeof (aux
));
8598 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8600 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8602 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8604 strsec
= section_headers
+ sec
->sh_link
;
8606 /* PR binutils/17531 file: 011-12666-0.004. */
8607 if (aux
.strtab
!= NULL
)
8609 error (_("Multiple string tables found in file.\n"));
8612 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8613 1, strsec
->sh_size
, _("string table"));
8614 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8616 else if (sec
->sh_type
== sec_type
)
8621 printf (_("\nThere are no unwind sections in this file.\n"));
8623 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8625 if (sec
->sh_type
== sec_type
)
8627 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8628 printable_section_name (sec
),
8629 (unsigned long) sec
->sh_offset
,
8630 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8632 dump_arm_unwind (&aux
, sec
);
8639 free ((char *) aux
.strtab
);
8643 process_unwind (FILE * file
)
8645 struct unwind_handler
8648 void (* handler
)(FILE *);
8651 { EM_ARM
, arm_process_unwind
},
8652 { EM_IA_64
, ia64_process_unwind
},
8653 { EM_PARISC
, hppa_process_unwind
},
8654 { EM_TI_C6000
, arm_process_unwind
},
8662 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8663 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8665 handlers
[i
].handler (file
);
8669 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8670 get_machine_name (elf_header
.e_machine
));
8674 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8676 switch (entry
->d_tag
)
8679 if (entry
->d_un
.d_val
== 0)
8683 static const char * opts
[] =
8685 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8686 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8687 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8688 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8694 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8695 if (entry
->d_un
.d_val
& (1 << cnt
))
8697 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8703 case DT_MIPS_IVERSION
:
8704 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8705 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8709 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8710 /* Note: coded this way so that there is a single string for translation. */
8711 printf (_("<corrupt: %s>"), buf
);
8715 case DT_MIPS_TIME_STAMP
:
8719 time_t atime
= entry
->d_un
.d_val
;
8721 tmp
= gmtime (&atime
);
8722 /* PR 17531: file: 6accc532. */
8724 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8726 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8727 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8728 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8729 printf (_("Time Stamp: %s"), timebuf
);
8733 case DT_MIPS_RLD_VERSION
:
8734 case DT_MIPS_LOCAL_GOTNO
:
8735 case DT_MIPS_CONFLICTNO
:
8736 case DT_MIPS_LIBLISTNO
:
8737 case DT_MIPS_SYMTABNO
:
8738 case DT_MIPS_UNREFEXTNO
:
8739 case DT_MIPS_HIPAGENO
:
8740 case DT_MIPS_DELTA_CLASS_NO
:
8741 case DT_MIPS_DELTA_INSTANCE_NO
:
8742 case DT_MIPS_DELTA_RELOC_NO
:
8743 case DT_MIPS_DELTA_SYM_NO
:
8744 case DT_MIPS_DELTA_CLASSSYM_NO
:
8745 case DT_MIPS_COMPACT_SIZE
:
8746 print_vma (entry
->d_un
.d_val
, DEC
);
8750 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8756 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8758 switch (entry
->d_tag
)
8760 case DT_HP_DLD_FLAGS
:
8769 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8770 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8771 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8772 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8773 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8774 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8775 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8776 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8777 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8778 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8779 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8780 { DT_HP_GST
, "HP_GST" },
8781 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8782 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8783 { DT_HP_NODELETE
, "HP_NODELETE" },
8784 { DT_HP_GROUP
, "HP_GROUP" },
8785 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8789 bfd_vma val
= entry
->d_un
.d_val
;
8791 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8792 if (val
& flags
[cnt
].bit
)
8796 fputs (flags
[cnt
].str
, stdout
);
8798 val
^= flags
[cnt
].bit
;
8801 if (val
!= 0 || first
)
8805 print_vma (val
, HEX
);
8811 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8819 /* VMS vs Unix time offset and factor. */
8821 #define VMS_EPOCH_OFFSET 35067168000000000LL
8822 #define VMS_GRANULARITY_FACTOR 10000000
8824 /* Display a VMS time in a human readable format. */
8827 print_vms_time (bfd_int64_t vmstime
)
8832 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8833 tm
= gmtime (&unxtime
);
8834 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8835 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8836 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8841 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8843 switch (entry
->d_tag
)
8845 case DT_IA_64_PLT_RESERVE
:
8846 /* First 3 slots reserved. */
8847 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8849 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8852 case DT_IA_64_VMS_LINKTIME
:
8854 print_vms_time (entry
->d_un
.d_val
);
8858 case DT_IA_64_VMS_LNKFLAGS
:
8859 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8860 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8861 printf (" CALL_DEBUG");
8862 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8863 printf (" NOP0BUFS");
8864 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8865 printf (" P0IMAGE");
8866 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8867 printf (" MKTHREADS");
8868 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8869 printf (" UPCALLS");
8870 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8872 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8873 printf (" INITIALIZE");
8874 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8876 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8877 printf (" EXE_INIT");
8878 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8879 printf (" TBK_IN_IMG");
8880 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8881 printf (" DBG_IN_IMG");
8882 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8883 printf (" TBK_IN_DSF");
8884 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8885 printf (" DBG_IN_DSF");
8886 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8887 printf (" SIGNATURES");
8888 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8889 printf (" REL_SEG_OFF");
8893 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8900 get_32bit_dynamic_section (FILE * file
)
8902 Elf32_External_Dyn
* edyn
;
8903 Elf32_External_Dyn
* ext
;
8904 Elf_Internal_Dyn
* entry
;
8906 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8907 dynamic_size
, _("dynamic section"));
8911 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8912 might not have the luxury of section headers. Look for the DT_NULL
8913 terminator to determine the number of entries. */
8914 for (ext
= edyn
, dynamic_nent
= 0;
8915 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8919 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8923 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8925 if (dynamic_section
== NULL
)
8927 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8928 (unsigned long) dynamic_nent
);
8933 for (ext
= edyn
, entry
= dynamic_section
;
8934 entry
< dynamic_section
+ dynamic_nent
;
8937 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8938 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8947 get_64bit_dynamic_section (FILE * file
)
8949 Elf64_External_Dyn
* edyn
;
8950 Elf64_External_Dyn
* ext
;
8951 Elf_Internal_Dyn
* entry
;
8953 /* Read in the data. */
8954 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8955 dynamic_size
, _("dynamic section"));
8959 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8960 might not have the luxury of section headers. Look for the DT_NULL
8961 terminator to determine the number of entries. */
8962 for (ext
= edyn
, dynamic_nent
= 0;
8963 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8964 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8968 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8972 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8974 if (dynamic_section
== NULL
)
8976 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8977 (unsigned long) dynamic_nent
);
8982 /* Convert from external to internal formats. */
8983 for (ext
= edyn
, entry
= dynamic_section
;
8984 entry
< dynamic_section
+ dynamic_nent
;
8987 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8988 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8997 print_dynamic_flags (bfd_vma flags
)
9005 flag
= flags
& - flags
;
9015 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9016 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9017 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9018 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9019 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9020 default: fputs (_("unknown"), stdout
); break;
9026 /* Parse and display the contents of the dynamic section. */
9029 process_dynamic_section (FILE * file
)
9031 Elf_Internal_Dyn
* entry
;
9033 if (dynamic_size
== 0)
9036 printf (_("\nThere is no dynamic section in this file.\n"));
9043 if (! get_32bit_dynamic_section (file
))
9046 else if (! get_64bit_dynamic_section (file
))
9049 /* Find the appropriate symbol table. */
9050 if (dynamic_symbols
== NULL
)
9052 for (entry
= dynamic_section
;
9053 entry
< dynamic_section
+ dynamic_nent
;
9056 Elf_Internal_Shdr section
;
9058 if (entry
->d_tag
!= DT_SYMTAB
)
9061 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9063 /* Since we do not know how big the symbol table is,
9064 we default to reading in the entire file (!) and
9065 processing that. This is overkill, I know, but it
9067 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9069 if (archive_file_offset
!= 0)
9070 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9073 if (fseek (file
, 0, SEEK_END
))
9074 error (_("Unable to seek to end of file!\n"));
9076 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9080 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9082 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9083 section
.sh_name
= string_table_length
;
9085 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9086 if (num_dynamic_syms
< 1)
9088 error (_("Unable to determine the number of symbols to load\n"));
9094 /* Similarly find a string table. */
9095 if (dynamic_strings
== NULL
)
9097 for (entry
= dynamic_section
;
9098 entry
< dynamic_section
+ dynamic_nent
;
9101 unsigned long offset
;
9104 if (entry
->d_tag
!= DT_STRTAB
)
9107 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9109 /* Since we do not know how big the string table is,
9110 we default to reading in the entire file (!) and
9111 processing that. This is overkill, I know, but it
9114 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9116 if (archive_file_offset
!= 0)
9117 str_tab_len
= archive_file_size
- offset
;
9120 if (fseek (file
, 0, SEEK_END
))
9121 error (_("Unable to seek to end of file\n"));
9122 str_tab_len
= ftell (file
) - offset
;
9125 if (str_tab_len
< 1)
9128 (_("Unable to determine the length of the dynamic string table\n"));
9132 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9134 _("dynamic string table"));
9135 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9140 /* And find the syminfo section if available. */
9141 if (dynamic_syminfo
== NULL
)
9143 unsigned long syminsz
= 0;
9145 for (entry
= dynamic_section
;
9146 entry
< dynamic_section
+ dynamic_nent
;
9149 if (entry
->d_tag
== DT_SYMINENT
)
9151 /* Note: these braces are necessary to avoid a syntax
9152 error from the SunOS4 C compiler. */
9153 /* PR binutils/17531: A corrupt file can trigger this test.
9154 So do not use an assert, instead generate an error message. */
9155 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9156 error (_("Bad value (%d) for SYMINENT entry\n"),
9157 (int) entry
->d_un
.d_val
);
9159 else if (entry
->d_tag
== DT_SYMINSZ
)
9160 syminsz
= entry
->d_un
.d_val
;
9161 else if (entry
->d_tag
== DT_SYMINFO
)
9162 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9166 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9168 Elf_External_Syminfo
* extsyminfo
;
9169 Elf_External_Syminfo
* extsym
;
9170 Elf_Internal_Syminfo
* syminfo
;
9172 /* There is a syminfo section. Read the data. */
9173 extsyminfo
= (Elf_External_Syminfo
*)
9174 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9175 _("symbol information"));
9179 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9180 if (dynamic_syminfo
== NULL
)
9182 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9183 (unsigned long) syminsz
);
9187 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9188 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9189 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9190 ++syminfo
, ++extsym
)
9192 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9193 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9200 if (do_dynamic
&& dynamic_addr
)
9201 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9202 dynamic_addr
, (unsigned long) dynamic_nent
);
9204 printf (_(" Tag Type Name/Value\n"));
9206 for (entry
= dynamic_section
;
9207 entry
< dynamic_section
+ dynamic_nent
;
9215 print_vma (entry
->d_tag
, FULL_HEX
);
9216 dtype
= get_dynamic_type (entry
->d_tag
);
9217 printf (" (%s)%*s", dtype
,
9218 ((is_32bit_elf
? 27 : 19)
9219 - (int) strlen (dtype
)),
9223 switch (entry
->d_tag
)
9227 print_dynamic_flags (entry
->d_un
.d_val
);
9237 switch (entry
->d_tag
)
9240 printf (_("Auxiliary library"));
9244 printf (_("Filter library"));
9248 printf (_("Configuration file"));
9252 printf (_("Dependency audit library"));
9256 printf (_("Audit library"));
9260 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9261 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9265 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9274 printf (_("Flags:"));
9276 if (entry
->d_un
.d_val
== 0)
9277 printf (_(" None\n"));
9280 unsigned long int val
= entry
->d_un
.d_val
;
9282 if (val
& DTF_1_PARINIT
)
9284 printf (" PARINIT");
9285 val
^= DTF_1_PARINIT
;
9287 if (val
& DTF_1_CONFEXP
)
9289 printf (" CONFEXP");
9290 val
^= DTF_1_CONFEXP
;
9293 printf (" %lx", val
);
9302 printf (_("Flags:"));
9304 if (entry
->d_un
.d_val
== 0)
9305 printf (_(" None\n"));
9308 unsigned long int val
= entry
->d_un
.d_val
;
9310 if (val
& DF_P1_LAZYLOAD
)
9312 printf (" LAZYLOAD");
9313 val
^= DF_P1_LAZYLOAD
;
9315 if (val
& DF_P1_GROUPPERM
)
9317 printf (" GROUPPERM");
9318 val
^= DF_P1_GROUPPERM
;
9321 printf (" %lx", val
);
9330 printf (_("Flags:"));
9331 if (entry
->d_un
.d_val
== 0)
9332 printf (_(" None\n"));
9335 unsigned long int val
= entry
->d_un
.d_val
;
9342 if (val
& DF_1_GLOBAL
)
9347 if (val
& DF_1_GROUP
)
9352 if (val
& DF_1_NODELETE
)
9354 printf (" NODELETE");
9355 val
^= DF_1_NODELETE
;
9357 if (val
& DF_1_LOADFLTR
)
9359 printf (" LOADFLTR");
9360 val
^= DF_1_LOADFLTR
;
9362 if (val
& DF_1_INITFIRST
)
9364 printf (" INITFIRST");
9365 val
^= DF_1_INITFIRST
;
9367 if (val
& DF_1_NOOPEN
)
9372 if (val
& DF_1_ORIGIN
)
9377 if (val
& DF_1_DIRECT
)
9382 if (val
& DF_1_TRANS
)
9387 if (val
& DF_1_INTERPOSE
)
9389 printf (" INTERPOSE");
9390 val
^= DF_1_INTERPOSE
;
9392 if (val
& DF_1_NODEFLIB
)
9394 printf (" NODEFLIB");
9395 val
^= DF_1_NODEFLIB
;
9397 if (val
& DF_1_NODUMP
)
9402 if (val
& DF_1_CONFALT
)
9404 printf (" CONFALT");
9405 val
^= DF_1_CONFALT
;
9407 if (val
& DF_1_ENDFILTEE
)
9409 printf (" ENDFILTEE");
9410 val
^= DF_1_ENDFILTEE
;
9412 if (val
& DF_1_DISPRELDNE
)
9414 printf (" DISPRELDNE");
9415 val
^= DF_1_DISPRELDNE
;
9417 if (val
& DF_1_DISPRELPND
)
9419 printf (" DISPRELPND");
9420 val
^= DF_1_DISPRELPND
;
9422 if (val
& DF_1_NODIRECT
)
9424 printf (" NODIRECT");
9425 val
^= DF_1_NODIRECT
;
9427 if (val
& DF_1_IGNMULDEF
)
9429 printf (" IGNMULDEF");
9430 val
^= DF_1_IGNMULDEF
;
9432 if (val
& DF_1_NOKSYMS
)
9434 printf (" NOKSYMS");
9435 val
^= DF_1_NOKSYMS
;
9437 if (val
& DF_1_NOHDR
)
9442 if (val
& DF_1_EDITED
)
9447 if (val
& DF_1_NORELOC
)
9449 printf (" NORELOC");
9450 val
^= DF_1_NORELOC
;
9452 if (val
& DF_1_SYMINTPOSE
)
9454 printf (" SYMINTPOSE");
9455 val
^= DF_1_SYMINTPOSE
;
9457 if (val
& DF_1_GLOBAUDIT
)
9459 printf (" GLOBAUDIT");
9460 val
^= DF_1_GLOBAUDIT
;
9462 if (val
& DF_1_SINGLETON
)
9464 printf (" SINGLETON");
9465 val
^= DF_1_SINGLETON
;
9467 if (val
& DF_1_STUB
)
9478 printf (" %lx", val
);
9485 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9487 puts (get_dynamic_type (entry
->d_un
.d_val
));
9507 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9513 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9514 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9520 switch (entry
->d_tag
)
9523 printf (_("Shared library: [%s]"), name
);
9525 if (streq (name
, program_interpreter
))
9526 printf (_(" program interpreter"));
9530 printf (_("Library soname: [%s]"), name
);
9534 printf (_("Library rpath: [%s]"), name
);
9538 printf (_("Library runpath: [%s]"), name
);
9542 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9547 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9560 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9564 case DT_INIT_ARRAYSZ
:
9565 case DT_FINI_ARRAYSZ
:
9566 case DT_GNU_CONFLICTSZ
:
9567 case DT_GNU_LIBLISTSZ
:
9570 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9571 printf (_(" (bytes)\n"));
9581 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9594 if (entry
->d_tag
== DT_USED
9595 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9597 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9601 printf (_("Not needed object: [%s]\n"), name
);
9606 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9612 /* The value of this entry is ignored. */
9617 case DT_GNU_PRELINKED
:
9621 time_t atime
= entry
->d_un
.d_val
;
9623 tmp
= gmtime (&atime
);
9624 /* PR 17533 file: 041-1244816-0.004. */
9626 printf (_("<corrupt time val: %lx"),
9627 (unsigned long) atime
);
9629 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9630 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9631 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9637 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9640 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9646 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9647 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9652 switch (elf_header
.e_machine
)
9655 case EM_MIPS_RS3_LE
:
9656 dynamic_section_mips_val (entry
);
9659 dynamic_section_parisc_val (entry
);
9662 dynamic_section_ia64_val (entry
);
9665 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9677 get_ver_flags (unsigned int flags
)
9679 static char buff
[32];
9686 if (flags
& VER_FLG_BASE
)
9687 strcat (buff
, "BASE ");
9689 if (flags
& VER_FLG_WEAK
)
9691 if (flags
& VER_FLG_BASE
)
9692 strcat (buff
, "| ");
9694 strcat (buff
, "WEAK ");
9697 if (flags
& VER_FLG_INFO
)
9699 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9700 strcat (buff
, "| ");
9702 strcat (buff
, "INFO ");
9705 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9706 strcat (buff
, _("| <unknown>"));
9711 /* Display the contents of the version sections. */
9714 process_version_sections (FILE * file
)
9716 Elf_Internal_Shdr
* section
;
9723 for (i
= 0, section
= section_headers
;
9724 i
< elf_header
.e_shnum
;
9727 switch (section
->sh_type
)
9729 case SHT_GNU_verdef
:
9731 Elf_External_Verdef
* edefs
;
9738 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9739 printable_section_name (section
),
9742 printf (_(" Addr: 0x"));
9743 printf_vma (section
->sh_addr
);
9744 printf (_(" Offset: %#08lx Link: %u (%s)"),
9745 (unsigned long) section
->sh_offset
, section
->sh_link
,
9746 printable_section_name_from_index (section
->sh_link
));
9748 edefs
= (Elf_External_Verdef
*)
9749 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9750 _("version definition section"));
9753 endbuf
= (char *) edefs
+ section
->sh_size
;
9755 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9758 Elf_External_Verdef
* edef
;
9759 Elf_Internal_Verdef ent
;
9760 Elf_External_Verdaux
* eaux
;
9761 Elf_Internal_Verdaux aux
;
9765 /* Check for very large indicies. */
9766 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9769 vstart
= ((char *) edefs
) + idx
;
9770 if (vstart
+ sizeof (*edef
) > endbuf
)
9773 edef
= (Elf_External_Verdef
*) vstart
;
9775 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9776 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9777 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9778 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9779 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9780 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9781 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9783 printf (_(" %#06x: Rev: %d Flags: %s"),
9784 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9786 printf (_(" Index: %d Cnt: %d "),
9787 ent
.vd_ndx
, ent
.vd_cnt
);
9789 /* Check for overflow. */
9790 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9793 vstart
+= ent
.vd_aux
;
9795 eaux
= (Elf_External_Verdaux
*) vstart
;
9797 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9798 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9800 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9801 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9803 printf (_("Name index: %ld\n"), aux
.vda_name
);
9805 isum
= idx
+ ent
.vd_aux
;
9807 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9809 /* Check for overflow. */
9810 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9813 isum
+= aux
.vda_next
;
9814 vstart
+= aux
.vda_next
;
9816 eaux
= (Elf_External_Verdaux
*) vstart
;
9817 if (vstart
+ sizeof (*eaux
) > endbuf
)
9820 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9821 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9823 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9824 printf (_(" %#06x: Parent %d: %s\n"),
9825 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9827 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9828 isum
, j
, aux
.vda_name
);
9832 printf (_(" Version def aux past end of section\n"));
9834 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9835 if (idx
+ ent
.vd_next
<= idx
)
9841 if (cnt
< section
->sh_info
)
9842 printf (_(" Version definition past end of section\n"));
9848 case SHT_GNU_verneed
:
9850 Elf_External_Verneed
* eneed
;
9857 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9858 printable_section_name (section
), section
->sh_info
);
9860 printf (_(" Addr: 0x"));
9861 printf_vma (section
->sh_addr
);
9862 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9863 (unsigned long) section
->sh_offset
, section
->sh_link
,
9864 printable_section_name_from_index (section
->sh_link
));
9866 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9867 section
->sh_offset
, 1,
9869 _("Version Needs section"));
9872 endbuf
= (char *) eneed
+ section
->sh_size
;
9874 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9876 Elf_External_Verneed
* entry
;
9877 Elf_Internal_Verneed ent
;
9882 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9885 vstart
= ((char *) eneed
) + idx
;
9886 if (vstart
+ sizeof (*entry
) > endbuf
)
9889 entry
= (Elf_External_Verneed
*) vstart
;
9891 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9892 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9893 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9894 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9895 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9897 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9899 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9900 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9902 printf (_(" File: %lx"), ent
.vn_file
);
9904 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9906 /* Check for overflow. */
9907 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9909 vstart
+= ent
.vn_aux
;
9911 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9913 Elf_External_Vernaux
* eaux
;
9914 Elf_Internal_Vernaux aux
;
9916 if (vstart
+ sizeof (*eaux
) > endbuf
)
9918 eaux
= (Elf_External_Vernaux
*) vstart
;
9920 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9921 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9922 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9923 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9924 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9926 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9927 printf (_(" %#06x: Name: %s"),
9928 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9930 printf (_(" %#06x: Name index: %lx"),
9931 isum
, aux
.vna_name
);
9933 printf (_(" Flags: %s Version: %d\n"),
9934 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9936 /* Check for overflow. */
9937 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9938 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9940 warn (_("Invalid vna_next field of %lx\n"),
9945 isum
+= aux
.vna_next
;
9946 vstart
+= aux
.vna_next
;
9950 warn (_("Missing Version Needs auxillary information\n"));
9952 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9954 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9955 cnt
= section
->sh_info
;
9961 if (cnt
< section
->sh_info
)
9962 warn (_("Missing Version Needs information\n"));
9968 case SHT_GNU_versym
:
9970 Elf_Internal_Shdr
* link_section
;
9973 unsigned char * edata
;
9974 unsigned short * data
;
9976 Elf_Internal_Sym
* symbols
;
9977 Elf_Internal_Shdr
* string_sec
;
9978 unsigned long num_syms
;
9981 if (section
->sh_link
>= elf_header
.e_shnum
)
9984 link_section
= section_headers
+ section
->sh_link
;
9985 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9987 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9992 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9993 if (symbols
== NULL
)
9996 string_sec
= section_headers
+ link_section
->sh_link
;
9998 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9999 string_sec
->sh_size
,
10000 _("version string table"));
10007 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10008 printable_section_name (section
), (unsigned long) total
);
10010 printf (_(" Addr: "));
10011 printf_vma (section
->sh_addr
);
10012 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10013 (unsigned long) section
->sh_offset
, section
->sh_link
,
10014 printable_section_name (link_section
));
10016 off
= offset_from_vma (file
,
10017 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10018 total
* sizeof (short));
10019 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10021 _("version symbol data"));
10029 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10031 for (cnt
= total
; cnt
--;)
10032 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10037 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10041 char *invalid
= _("*invalid*");
10043 printf (" %03x:", cnt
);
10045 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10046 switch (data
[cnt
+ j
])
10049 fputs (_(" 0 (*local*) "), stdout
);
10053 fputs (_(" 1 (*global*) "), stdout
);
10057 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10058 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10060 /* If this index value is greater than the size of the symbols
10061 array, break to avoid an out-of-bounds read. */
10062 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10064 warn (_("invalid index into symbol array\n"));
10069 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10071 Elf_Internal_Verneed ivn
;
10072 unsigned long offset
;
10074 offset
= offset_from_vma
10075 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10076 sizeof (Elf_External_Verneed
));
10080 Elf_Internal_Vernaux ivna
;
10081 Elf_External_Verneed evn
;
10082 Elf_External_Vernaux evna
;
10083 unsigned long a_off
;
10085 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10086 _("version need")) == NULL
)
10089 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10090 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10092 a_off
= offset
+ ivn
.vn_aux
;
10096 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10097 1, _("version need aux (2)")) == NULL
)
10100 ivna
.vna_other
= 0;
10104 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10105 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10108 a_off
+= ivna
.vna_next
;
10110 while (ivna
.vna_other
!= data
[cnt
+ j
]
10111 && ivna
.vna_next
!= 0);
10113 if (ivna
.vna_other
== data
[cnt
+ j
])
10115 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10117 if (ivna
.vna_name
>= string_sec
->sh_size
)
10120 name
= strtab
+ ivna
.vna_name
;
10124 offset
+= ivn
.vn_next
;
10126 while (ivn
.vn_next
);
10129 if (data
[cnt
+ j
] != 0x8001
10130 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10132 Elf_Internal_Verdef ivd
;
10133 Elf_External_Verdef evd
;
10134 unsigned long offset
;
10136 offset
= offset_from_vma
10137 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10142 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10143 _("version def")) == NULL
)
10146 /* PR 17531: file: 046-1082287-0.004. */
10147 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10152 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10153 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10156 offset
+= ivd
.vd_next
;
10158 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10159 && ivd
.vd_next
!= 0);
10161 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10163 Elf_External_Verdaux evda
;
10164 Elf_Internal_Verdaux ivda
;
10166 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10168 if (get_data (&evda
, file
,
10169 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10171 _("version def aux")) == NULL
)
10174 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10176 if (ivda
.vda_name
>= string_sec
->sh_size
)
10178 else if (name
!= NULL
&& name
!= invalid
)
10179 name
= _("*both*");
10181 name
= strtab
+ ivda
.vda_name
;
10185 nn
+= printf ("(%s%-*s",
10187 12 - (int) strlen (name
),
10191 printf ("%*c", 18 - nn
, ' ');
10209 printf (_("\nNo version information found in this file.\n"));
10214 static const char *
10215 get_symbol_binding (unsigned int binding
)
10217 static char buff
[32];
10221 case STB_LOCAL
: return "LOCAL";
10222 case STB_GLOBAL
: return "GLOBAL";
10223 case STB_WEAK
: return "WEAK";
10225 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10226 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10228 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10230 if (binding
== STB_GNU_UNIQUE
10231 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10232 /* GNU is still using the default value 0. */
10233 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10235 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10238 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10243 static const char *
10244 get_symbol_type (unsigned int type
)
10246 static char buff
[32];
10250 case STT_NOTYPE
: return "NOTYPE";
10251 case STT_OBJECT
: return "OBJECT";
10252 case STT_FUNC
: return "FUNC";
10253 case STT_SECTION
: return "SECTION";
10254 case STT_FILE
: return "FILE";
10255 case STT_COMMON
: return "COMMON";
10256 case STT_TLS
: return "TLS";
10257 case STT_RELC
: return "RELC";
10258 case STT_SRELC
: return "SRELC";
10260 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10262 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10263 return "THUMB_FUNC";
10265 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10268 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10269 return "PARISC_MILLI";
10271 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10273 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10275 if (elf_header
.e_machine
== EM_PARISC
)
10277 if (type
== STT_HP_OPAQUE
)
10278 return "HP_OPAQUE";
10279 if (type
== STT_HP_STUB
)
10283 if (type
== STT_GNU_IFUNC
10284 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10285 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10286 /* GNU is still using the default value 0. */
10287 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10290 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10293 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10298 static const char *
10299 get_symbol_visibility (unsigned int visibility
)
10301 switch (visibility
)
10303 case STV_DEFAULT
: return "DEFAULT";
10304 case STV_INTERNAL
: return "INTERNAL";
10305 case STV_HIDDEN
: return "HIDDEN";
10306 case STV_PROTECTED
: return "PROTECTED";
10308 error (_("Unrecognized visibility value: %u"), visibility
);
10309 return _("<unknown>");
10313 static const char *
10314 get_solaris_symbol_visibility (unsigned int visibility
)
10316 switch (visibility
)
10318 case 4: return "EXPORTED";
10319 case 5: return "SINGLETON";
10320 case 6: return "ELIMINATE";
10321 default: return get_symbol_visibility (visibility
);
10325 static const char *
10326 get_mips_symbol_other (unsigned int other
)
10336 case STO_MICROMIPS
:
10337 return "MICROMIPS";
10338 case STO_MICROMIPS
| STO_MIPS_PIC
:
10339 return "MICROMIPS, MIPS PIC";
10347 static const char *
10348 get_ia64_symbol_other (unsigned int other
)
10350 if (is_ia64_vms ())
10352 static char res
[32];
10356 /* Function types is for images and .STB files only. */
10357 switch (elf_header
.e_type
)
10361 switch (VMS_ST_FUNC_TYPE (other
))
10363 case VMS_SFT_CODE_ADDR
:
10364 strcat (res
, " CA");
10366 case VMS_SFT_SYMV_IDX
:
10367 strcat (res
, " VEC");
10370 strcat (res
, " FD");
10372 case VMS_SFT_RESERVE
:
10373 strcat (res
, " RSV");
10376 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10377 VMS_ST_FUNC_TYPE (other
));
10378 strcat (res
, " <unknown>");
10385 switch (VMS_ST_LINKAGE (other
))
10387 case VMS_STL_IGNORE
:
10388 strcat (res
, " IGN");
10390 case VMS_STL_RESERVE
:
10391 strcat (res
, " RSV");
10394 strcat (res
, " STD");
10397 strcat (res
, " LNK");
10400 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10401 VMS_ST_LINKAGE (other
));
10402 strcat (res
, " <unknown>");
10414 static const char *
10415 get_ppc64_symbol_other (unsigned int other
)
10417 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10419 static char buf
[32];
10420 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10421 PPC64_LOCAL_ENTRY_OFFSET (other
));
10427 static const char *
10428 get_symbol_other (unsigned int other
)
10430 const char * result
= NULL
;
10431 static char buff
[32];
10436 switch (elf_header
.e_machine
)
10439 result
= get_mips_symbol_other (other
);
10442 result
= get_ia64_symbol_other (other
);
10445 result
= get_ppc64_symbol_other (other
);
10455 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10459 static const char *
10460 get_symbol_index_type (unsigned int type
)
10462 static char buff
[32];
10466 case SHN_UNDEF
: return "UND";
10467 case SHN_ABS
: return "ABS";
10468 case SHN_COMMON
: return "COM";
10470 if (type
== SHN_IA_64_ANSI_COMMON
10471 && elf_header
.e_machine
== EM_IA_64
10472 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10474 else if ((elf_header
.e_machine
== EM_X86_64
10475 || elf_header
.e_machine
== EM_L1OM
10476 || elf_header
.e_machine
== EM_K1OM
)
10477 && type
== SHN_X86_64_LCOMMON
)
10478 return "LARGE_COM";
10479 else if ((type
== SHN_MIPS_SCOMMON
10480 && elf_header
.e_machine
== EM_MIPS
)
10481 || (type
== SHN_TIC6X_SCOMMON
10482 && elf_header
.e_machine
== EM_TI_C6000
))
10484 else if (type
== SHN_MIPS_SUNDEFINED
10485 && elf_header
.e_machine
== EM_MIPS
)
10487 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10488 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10489 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10490 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10491 else if (type
>= SHN_LORESERVE
)
10492 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10493 else if (type
>= elf_header
.e_shnum
)
10494 sprintf (buff
, _("bad section index[%3d]"), type
);
10496 sprintf (buff
, "%3d", type
);
10504 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10506 unsigned char * e_data
;
10509 /* If the size_t type is smaller than the bfd_size_type, eg because
10510 you are building a 32-bit tool on a 64-bit host, then make sure
10511 that when (number) is cast to (size_t) no information is lost. */
10512 if (sizeof (size_t) < sizeof (bfd_size_type
)
10513 && (bfd_size_type
) ((size_t) number
) != number
)
10515 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10516 " elements of size %u\n"),
10521 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10522 attempting to allocate memory when the read is bound to fail. */
10523 if (ent_size
* number
> current_file_size
)
10525 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10530 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10531 if (e_data
== NULL
)
10533 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10538 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10540 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10541 number
* ent_size
);
10546 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10547 if (i_data
== NULL
)
10549 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10550 " dynamic entries\n"),
10557 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10565 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10567 Elf_Internal_Sym
* psym
;
10570 n
= print_vma (si
, DEC_5
);
10572 fputs (&" "[n
], stdout
);
10573 printf (" %3lu: ", hn
);
10575 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10577 printf (_("<No info available for dynamic symbol number %lu>\n"),
10578 (unsigned long) si
);
10582 psym
= dynamic_symbols
+ si
;
10583 print_vma (psym
->st_value
, LONG_HEX
);
10585 print_vma (psym
->st_size
, DEC_5
);
10587 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10588 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10590 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10591 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10594 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10596 printf (" %-7s", get_symbol_visibility (vis
));
10597 /* Check to see if any other bits in the st_other field are set.
10598 Note - displaying this information disrupts the layout of the
10599 table being generated, but for the moment this case is very
10601 if (psym
->st_other
^ vis
)
10602 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10605 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10606 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10607 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10609 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10613 static const char *
10614 get_symbol_version_string (FILE *file
, int is_dynsym
,
10615 const char *strtab
,
10616 unsigned long int strtab_size
,
10617 unsigned int si
, Elf_Internal_Sym
*psym
,
10618 enum versioned_symbol_info
*sym_info
,
10619 unsigned short *vna_other
)
10621 unsigned char data
[2];
10622 unsigned short vers_data
;
10623 unsigned long offset
;
10626 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10629 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10630 sizeof data
+ si
* sizeof (vers_data
));
10632 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10633 sizeof (data
), 1, _("version data")) == NULL
)
10636 vers_data
= byte_get (data
, 2);
10638 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10641 /* Usually we'd only see verdef for defined symbols, and verneed for
10642 undefined symbols. However, symbols defined by the linker in
10643 .dynbss for variables copied from a shared library in order to
10644 avoid text relocations are defined yet have verneed. We could
10645 use a heuristic to detect the special case, for example, check
10646 for verneed first on symbols defined in SHT_NOBITS sections, but
10647 it is simpler and more reliable to just look for both verdef and
10648 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10650 if (psym
->st_shndx
!= SHN_UNDEF
10651 && vers_data
!= 0x8001
10652 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10654 Elf_Internal_Verdef ivd
;
10655 Elf_Internal_Verdaux ivda
;
10656 Elf_External_Verdaux evda
;
10659 off
= offset_from_vma (file
,
10660 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10661 sizeof (Elf_External_Verdef
));
10665 Elf_External_Verdef evd
;
10667 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10668 _("version def")) == NULL
)
10676 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10677 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10678 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10681 off
+= ivd
.vd_next
;
10683 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10685 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10687 off
-= ivd
.vd_next
;
10690 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10691 _("version def aux")) != NULL
)
10693 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10695 if (psym
->st_name
!= ivda
.vda_name
)
10697 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10698 ? symbol_hidden
: symbol_public
);
10699 return (ivda
.vda_name
< strtab_size
10700 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10706 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10708 Elf_External_Verneed evn
;
10709 Elf_Internal_Verneed ivn
;
10710 Elf_Internal_Vernaux ivna
;
10712 offset
= offset_from_vma (file
,
10713 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10717 unsigned long vna_off
;
10719 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10720 _("version need")) == NULL
)
10723 ivna
.vna_other
= 0;
10728 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10729 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10731 vna_off
= offset
+ ivn
.vn_aux
;
10735 Elf_External_Vernaux evna
;
10737 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10738 _("version need aux (3)")) == NULL
)
10741 ivna
.vna_other
= 0;
10746 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10747 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10748 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10751 vna_off
+= ivna
.vna_next
;
10753 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10755 if (ivna
.vna_other
== vers_data
)
10758 offset
+= ivn
.vn_next
;
10760 while (ivn
.vn_next
!= 0);
10762 if (ivna
.vna_other
== vers_data
)
10764 *sym_info
= symbol_undefined
;
10765 *vna_other
= ivna
.vna_other
;
10766 return (ivna
.vna_name
< strtab_size
10767 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
10773 /* Dump the symbol table. */
10775 process_symbol_table (FILE * file
)
10777 Elf_Internal_Shdr
* section
;
10778 bfd_size_type nbuckets
= 0;
10779 bfd_size_type nchains
= 0;
10780 bfd_vma
* buckets
= NULL
;
10781 bfd_vma
* chains
= NULL
;
10782 bfd_vma ngnubuckets
= 0;
10783 bfd_vma
* gnubuckets
= NULL
;
10784 bfd_vma
* gnuchains
= NULL
;
10785 bfd_vma gnusymidx
= 0;
10786 bfd_size_type ngnuchains
= 0;
10788 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10791 if (dynamic_info
[DT_HASH
]
10793 || (do_using_dynamic
10795 && dynamic_strings
!= NULL
)))
10797 unsigned char nb
[8];
10798 unsigned char nc
[8];
10799 unsigned int hash_ent_size
= 4;
10801 if ((elf_header
.e_machine
== EM_ALPHA
10802 || elf_header
.e_machine
== EM_S390
10803 || elf_header
.e_machine
== EM_S390_OLD
)
10804 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10808 (archive_file_offset
10809 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10810 sizeof nb
+ sizeof nc
)),
10813 error (_("Unable to seek to start of dynamic information\n"));
10817 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10819 error (_("Failed to read in number of buckets\n"));
10823 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10825 error (_("Failed to read in number of chains\n"));
10829 nbuckets
= byte_get (nb
, hash_ent_size
);
10830 nchains
= byte_get (nc
, hash_ent_size
);
10832 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10833 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10836 if (buckets
== NULL
|| chains
== NULL
)
10838 if (do_using_dynamic
)
10849 if (dynamic_info_DT_GNU_HASH
10851 || (do_using_dynamic
10853 && dynamic_strings
!= NULL
)))
10855 unsigned char nb
[16];
10856 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10857 bfd_vma buckets_vma
;
10860 (archive_file_offset
10861 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10865 error (_("Unable to seek to start of dynamic information\n"));
10869 if (fread (nb
, 16, 1, file
) != 1)
10871 error (_("Failed to read in number of buckets\n"));
10875 ngnubuckets
= byte_get (nb
, 4);
10876 gnusymidx
= byte_get (nb
+ 4, 4);
10877 bitmaskwords
= byte_get (nb
+ 8, 4);
10878 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10880 buckets_vma
+= bitmaskwords
* 4;
10882 buckets_vma
+= bitmaskwords
* 8;
10885 (archive_file_offset
10886 + offset_from_vma (file
, buckets_vma
, 4)),
10889 error (_("Unable to seek to start of dynamic information\n"));
10893 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10895 if (gnubuckets
== NULL
)
10898 for (i
= 0; i
< ngnubuckets
; i
++)
10899 if (gnubuckets
[i
] != 0)
10901 if (gnubuckets
[i
] < gnusymidx
)
10904 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10905 maxchain
= gnubuckets
[i
];
10908 if (maxchain
== 0xffffffff)
10911 maxchain
-= gnusymidx
;
10914 (archive_file_offset
10915 + offset_from_vma (file
, buckets_vma
10916 + 4 * (ngnubuckets
+ maxchain
), 4)),
10919 error (_("Unable to seek to start of dynamic information\n"));
10925 if (fread (nb
, 4, 1, file
) != 1)
10927 error (_("Failed to determine last chain length\n"));
10931 if (maxchain
+ 1 == 0)
10936 while ((byte_get (nb
, 4) & 1) == 0);
10939 (archive_file_offset
10940 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10943 error (_("Unable to seek to start of dynamic information\n"));
10947 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10948 ngnuchains
= maxchain
;
10951 if (gnuchains
== NULL
)
10956 if (do_using_dynamic
)
10961 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10963 && do_using_dynamic
10964 && dynamic_strings
!= NULL
10965 && dynamic_symbols
!= NULL
)
10969 if (dynamic_info
[DT_HASH
])
10973 printf (_("\nSymbol table for image:\n"));
10975 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10977 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10979 for (hn
= 0; hn
< nbuckets
; hn
++)
10984 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10985 print_dynamic_symbol (si
, hn
);
10989 if (dynamic_info_DT_GNU_HASH
)
10991 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10993 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10995 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10997 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10998 if (gnubuckets
[hn
] != 0)
11000 bfd_vma si
= gnubuckets
[hn
];
11001 bfd_vma off
= si
- gnusymidx
;
11005 print_dynamic_symbol (si
, hn
);
11008 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11012 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11013 && section_headers
!= NULL
)
11017 for (i
= 0, section
= section_headers
;
11018 i
< elf_header
.e_shnum
;
11022 char * strtab
= NULL
;
11023 unsigned long int strtab_size
= 0;
11024 Elf_Internal_Sym
* symtab
;
11025 Elf_Internal_Sym
* psym
;
11026 unsigned long num_syms
;
11028 if ((section
->sh_type
!= SHT_SYMTAB
11029 && section
->sh_type
!= SHT_DYNSYM
)
11031 && section
->sh_type
== SHT_SYMTAB
))
11034 if (section
->sh_entsize
== 0)
11036 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11037 printable_section_name (section
));
11041 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11042 printable_section_name (section
),
11043 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11046 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11048 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11050 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11051 if (symtab
== NULL
)
11054 if (section
->sh_link
== elf_header
.e_shstrndx
)
11056 strtab
= string_table
;
11057 strtab_size
= string_table_length
;
11059 else if (section
->sh_link
< elf_header
.e_shnum
)
11061 Elf_Internal_Shdr
* string_sec
;
11063 string_sec
= section_headers
+ section
->sh_link
;
11065 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11066 1, string_sec
->sh_size
,
11067 _("string table"));
11068 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11071 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11073 const char *version_string
;
11074 enum versioned_symbol_info sym_info
;
11075 unsigned short vna_other
;
11077 printf ("%6d: ", si
);
11078 print_vma (psym
->st_value
, LONG_HEX
);
11080 print_vma (psym
->st_size
, DEC_5
);
11081 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11082 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11083 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11084 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11087 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11089 printf (" %-7s", get_symbol_visibility (vis
));
11090 /* Check to see if any other bits in the st_other field are set.
11091 Note - displaying this information disrupts the layout of the
11092 table being generated, but for the moment this case is very rare. */
11093 if (psym
->st_other
^ vis
)
11094 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11096 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11097 print_symbol (25, psym
->st_name
< strtab_size
11098 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11101 = get_symbol_version_string (file
,
11102 section
->sh_type
== SHT_DYNSYM
,
11103 strtab
, strtab_size
, si
,
11104 psym
, &sym_info
, &vna_other
);
11105 if (version_string
)
11107 if (sym_info
== symbol_undefined
)
11108 printf ("@%s (%d)", version_string
, vna_other
);
11110 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11118 if (strtab
!= string_table
)
11124 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11126 if (do_histogram
&& buckets
!= NULL
)
11128 unsigned long * lengths
;
11129 unsigned long * counts
;
11132 unsigned long maxlength
= 0;
11133 unsigned long nzero_counts
= 0;
11134 unsigned long nsyms
= 0;
11135 unsigned long chained
;
11137 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11138 (unsigned long) nbuckets
);
11140 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11141 if (lengths
== NULL
)
11143 error (_("Out of memory allocating space for histogram buckets\n"));
11147 printf (_(" Length Number %% of total Coverage\n"));
11148 for (hn
= 0; hn
< nbuckets
; ++hn
)
11150 for (si
= buckets
[hn
], chained
= 0;
11151 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11152 si
= chains
[si
], ++chained
)
11155 if (maxlength
< ++lengths
[hn
])
11159 /* PR binutils/17531: A corrupt binary could contain broken
11160 histogram data. Do not go into an infinite loop trying
11162 if (chained
> nchains
)
11164 error (_("histogram chain is corrupt\n"));
11169 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11170 if (counts
== NULL
)
11173 error (_("Out of memory allocating space for histogram counts\n"));
11177 for (hn
= 0; hn
< nbuckets
; ++hn
)
11178 ++counts
[lengths
[hn
]];
11183 printf (" 0 %-10lu (%5.1f%%)\n",
11184 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11185 for (i
= 1; i
<= maxlength
; ++i
)
11187 nzero_counts
+= counts
[i
] * i
;
11188 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11189 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11190 (nzero_counts
* 100.0) / nsyms
);
11198 if (buckets
!= NULL
)
11204 if (do_histogram
&& gnubuckets
!= NULL
)
11206 unsigned long * lengths
;
11207 unsigned long * counts
;
11209 unsigned long maxlength
= 0;
11210 unsigned long nzero_counts
= 0;
11211 unsigned long nsyms
= 0;
11213 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11214 (unsigned long) ngnubuckets
);
11216 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11217 if (lengths
== NULL
)
11219 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11223 printf (_(" Length Number %% of total Coverage\n"));
11225 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11226 if (gnubuckets
[hn
] != 0)
11228 bfd_vma off
, length
= 1;
11230 for (off
= gnubuckets
[hn
] - gnusymidx
;
11231 /* PR 17531 file: 010-77222-0.004. */
11232 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11235 lengths
[hn
] = length
;
11236 if (length
> maxlength
)
11237 maxlength
= length
;
11241 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11242 if (counts
== NULL
)
11245 error (_("Out of memory allocating space for gnu histogram counts\n"));
11249 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11250 ++counts
[lengths
[hn
]];
11252 if (ngnubuckets
> 0)
11255 printf (" 0 %-10lu (%5.1f%%)\n",
11256 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11257 for (j
= 1; j
<= maxlength
; ++j
)
11259 nzero_counts
+= counts
[j
] * j
;
11260 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11261 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11262 (nzero_counts
* 100.0) / nsyms
);
11276 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11280 if (dynamic_syminfo
== NULL
11282 /* No syminfo, this is ok. */
11285 /* There better should be a dynamic symbol section. */
11286 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11290 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11291 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11293 printf (_(" Num: Name BoundTo Flags\n"));
11294 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11296 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11298 printf ("%4d: ", i
);
11299 if (i
>= num_dynamic_syms
)
11300 printf (_("<corrupt index>"));
11301 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11302 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11304 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11307 switch (dynamic_syminfo
[i
].si_boundto
)
11309 case SYMINFO_BT_SELF
:
11310 fputs ("SELF ", stdout
);
11312 case SYMINFO_BT_PARENT
:
11313 fputs ("PARENT ", stdout
);
11316 if (dynamic_syminfo
[i
].si_boundto
> 0
11317 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11318 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11320 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11324 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11328 if (flags
& SYMINFO_FLG_DIRECT
)
11329 printf (" DIRECT");
11330 if (flags
& SYMINFO_FLG_PASSTHRU
)
11331 printf (" PASSTHRU");
11332 if (flags
& SYMINFO_FLG_COPY
)
11334 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11335 printf (" LAZYLOAD");
11343 /* Check to see if the given reloc needs to be handled in a target specific
11344 manner. If so then process the reloc and return TRUE otherwise return
11348 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11349 unsigned char * start
,
11350 Elf_Internal_Sym
* symtab
)
11352 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11354 switch (elf_header
.e_machine
)
11357 case EM_MSP430_OLD
:
11359 static Elf_Internal_Sym
* saved_sym
= NULL
;
11361 switch (reloc_type
)
11363 case 10: /* R_MSP430_SYM_DIFF */
11364 if (uses_msp430x_relocs ())
11366 case 21: /* R_MSP430X_SYM_DIFF */
11367 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11370 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11371 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11372 goto handle_sym_diff
;
11374 case 5: /* R_MSP430_16_BYTE */
11375 case 9: /* R_MSP430_8 */
11376 if (uses_msp430x_relocs ())
11378 goto handle_sym_diff
;
11380 case 2: /* R_MSP430_ABS16 */
11381 case 15: /* R_MSP430X_ABS16 */
11382 if (! uses_msp430x_relocs ())
11384 goto handle_sym_diff
;
11387 if (saved_sym
!= NULL
)
11391 value
= reloc
->r_addend
11392 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11393 - saved_sym
->st_value
);
11395 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11403 if (saved_sym
!= NULL
)
11404 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11411 case EM_CYGNUS_MN10300
:
11413 static Elf_Internal_Sym
* saved_sym
= NULL
;
11415 switch (reloc_type
)
11417 case 34: /* R_MN10300_ALIGN */
11419 case 33: /* R_MN10300_SYM_DIFF */
11420 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11422 case 1: /* R_MN10300_32 */
11423 case 2: /* R_MN10300_16 */
11424 if (saved_sym
!= NULL
)
11428 value
= reloc
->r_addend
11429 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11430 - saved_sym
->st_value
);
11432 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11439 if (saved_sym
!= NULL
)
11440 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11448 static bfd_vma saved_sym1
= 0;
11449 static bfd_vma saved_sym2
= 0;
11450 static bfd_vma value
;
11452 switch (reloc_type
)
11454 case 0x80: /* R_RL78_SYM. */
11455 saved_sym1
= saved_sym2
;
11456 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11457 saved_sym2
+= reloc
->r_addend
;
11460 case 0x83: /* R_RL78_OPsub. */
11461 value
= saved_sym1
- saved_sym2
;
11462 saved_sym2
= saved_sym1
= 0;
11466 case 0x41: /* R_RL78_ABS32. */
11467 byte_put (start
+ reloc
->r_offset
, value
, 4);
11471 case 0x43: /* R_RL78_ABS16. */
11472 byte_put (start
+ reloc
->r_offset
, value
, 2);
11486 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11487 DWARF debug sections. This is a target specific test. Note - we do not
11488 go through the whole including-target-headers-multiple-times route, (as
11489 we have already done with <elf/h8.h>) because this would become very
11490 messy and even then this function would have to contain target specific
11491 information (the names of the relocs instead of their numeric values).
11492 FIXME: This is not the correct way to solve this problem. The proper way
11493 is to have target specific reloc sizing and typing functions created by
11494 the reloc-macros.h header, in the same way that it already creates the
11495 reloc naming functions. */
11498 is_32bit_abs_reloc (unsigned int reloc_type
)
11500 /* Please keep this table alpha-sorted for ease of visual lookup. */
11501 switch (elf_header
.e_machine
)
11505 return reloc_type
== 1; /* R_386_32. */
11507 return reloc_type
== 1; /* R_68K_32. */
11509 return reloc_type
== 1; /* R_860_32. */
11511 return reloc_type
== 2; /* R_960_32. */
11513 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11514 case EM_ADAPTEVA_EPIPHANY
:
11515 return reloc_type
== 3;
11517 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11519 return reloc_type
== 1; /* R_ARC_32. */
11520 case EM_ARC_COMPACT
:
11521 case EM_ARC_COMPACT2
:
11522 return reloc_type
== 4; /* R_ARC_32. */
11524 return reloc_type
== 2; /* R_ARM_ABS32 */
11527 return reloc_type
== 1;
11529 return reloc_type
== 0x12; /* R_byte4_data. */
11531 return reloc_type
== 3; /* R_CRIS_32. */
11533 return reloc_type
== 3; /* R_CR16_NUM32. */
11535 return reloc_type
== 15; /* R_CRX_NUM32. */
11536 case EM_CYGNUS_FRV
:
11537 return reloc_type
== 1;
11538 case EM_CYGNUS_D10V
:
11540 return reloc_type
== 6; /* R_D10V_32. */
11541 case EM_CYGNUS_D30V
:
11543 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11545 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11546 case EM_CYGNUS_FR30
:
11548 return reloc_type
== 3; /* R_FR30_32. */
11550 return reloc_type
== 1; /* R_FT32_32. */
11554 return reloc_type
== 1; /* R_H8_DIR32. */
11556 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11557 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11560 return reloc_type
== 2; /* R_IP2K_32. */
11562 return reloc_type
== 2; /* R_IQ2000_32. */
11563 case EM_LATTICEMICO32
:
11564 return reloc_type
== 3; /* R_LM32_32. */
11567 return reloc_type
== 3; /* R_M32C_32. */
11569 return reloc_type
== 34; /* R_M32R_32_RELA. */
11572 return reloc_type
== 6; /* R_M68HC11_32. */
11574 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11575 case EM_CYGNUS_MEP
:
11576 return reloc_type
== 4; /* R_MEP_32. */
11578 return reloc_type
== 2; /* R_METAG_ADDR32. */
11579 case EM_MICROBLAZE
:
11580 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11582 return reloc_type
== 2; /* R_MIPS_32. */
11584 return reloc_type
== 4; /* R_MMIX_32. */
11585 case EM_CYGNUS_MN10200
:
11587 return reloc_type
== 1; /* R_MN10200_32. */
11588 case EM_CYGNUS_MN10300
:
11590 return reloc_type
== 1; /* R_MN10300_32. */
11592 return reloc_type
== 1; /* R_MOXIE_32. */
11593 case EM_MSP430_OLD
:
11595 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11597 return reloc_type
== 2; /* R_MT_32. */
11599 return reloc_type
== 20; /* R_NDS32_RELA. */
11600 case EM_ALTERA_NIOS2
:
11601 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11603 return reloc_type
== 1; /* R_NIOS_32. */
11605 return reloc_type
== 1; /* R_OR1K_32. */
11607 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11608 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11611 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11613 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11615 return reloc_type
== 1; /* R_PPC_ADDR32. */
11617 return reloc_type
== 1; /* R_RL78_DIR32. */
11619 return reloc_type
== 1; /* R_RX_DIR32. */
11621 return reloc_type
== 1; /* R_I370_ADDR31. */
11624 return reloc_type
== 4; /* R_S390_32. */
11626 return reloc_type
== 8; /* R_SCORE_ABS32. */
11628 return reloc_type
== 1; /* R_SH_DIR32. */
11629 case EM_SPARC32PLUS
:
11632 return reloc_type
== 3 /* R_SPARC_32. */
11633 || reloc_type
== 23; /* R_SPARC_UA32. */
11635 return reloc_type
== 6; /* R_SPU_ADDR32 */
11637 return reloc_type
== 1; /* R_C6000_ABS32. */
11639 return reloc_type
== 2; /* R_TILEGX_32. */
11641 return reloc_type
== 1; /* R_TILEPRO_32. */
11642 case EM_CYGNUS_V850
:
11644 return reloc_type
== 6; /* R_V850_ABS32. */
11646 return reloc_type
== 0x33; /* R_V810_WORD. */
11648 return reloc_type
== 1; /* R_VAX_32. */
11650 return reloc_type
== 3; /* R_VISIUM_32. */
11654 return reloc_type
== 10; /* R_X86_64_32. */
11657 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11659 return reloc_type
== 4; /* R_XGATE_32. */
11661 return reloc_type
== 1; /* R_XSTROMY16_32. */
11662 case EM_XTENSA_OLD
:
11664 return reloc_type
== 1; /* R_XTENSA_32. */
11667 static unsigned int prev_warn
= 0;
11669 /* Avoid repeating the same warning multiple times. */
11670 if (prev_warn
!= elf_header
.e_machine
)
11671 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11672 elf_header
.e_machine
);
11673 prev_warn
= elf_header
.e_machine
;
11679 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11680 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11683 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11685 switch (elf_header
.e_machine
)
11686 /* Please keep this table alpha-sorted for ease of visual lookup. */
11690 return reloc_type
== 2; /* R_386_PC32. */
11692 return reloc_type
== 4; /* R_68K_PC32. */
11694 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11695 case EM_ADAPTEVA_EPIPHANY
:
11696 return reloc_type
== 6;
11698 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11699 case EM_ARC_COMPACT
:
11700 case EM_ARC_COMPACT2
:
11701 return reloc_type
== 49; /* R_ARC_32_PCREL. */
11703 return reloc_type
== 3; /* R_ARM_REL32 */
11706 return reloc_type
== 36; /* R_AVR_32_PCREL. */
11707 case EM_MICROBLAZE
:
11708 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11710 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11712 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11714 return reloc_type
== 26; /* R_PPC_REL32. */
11716 return reloc_type
== 26; /* R_PPC64_REL32. */
11719 return reloc_type
== 5; /* R_390_PC32. */
11721 return reloc_type
== 2; /* R_SH_REL32. */
11722 case EM_SPARC32PLUS
:
11725 return reloc_type
== 6; /* R_SPARC_DISP32. */
11727 return reloc_type
== 13; /* R_SPU_REL32. */
11729 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11731 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11733 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11737 return reloc_type
== 2; /* R_X86_64_PC32. */
11738 case EM_XTENSA_OLD
:
11740 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11742 /* Do not abort or issue an error message here. Not all targets use
11743 pc-relative 32-bit relocs in their DWARF debug information and we
11744 have already tested for target coverage in is_32bit_abs_reloc. A
11745 more helpful warning message will be generated by apply_relocations
11746 anyway, so just return. */
11751 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11752 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11755 is_64bit_abs_reloc (unsigned int reloc_type
)
11757 switch (elf_header
.e_machine
)
11760 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11762 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11764 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11766 return reloc_type
== 80; /* R_PARISC_DIR64. */
11768 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11769 case EM_SPARC32PLUS
:
11772 return reloc_type
== 54; /* R_SPARC_UA64. */
11776 return reloc_type
== 1; /* R_X86_64_64. */
11779 return reloc_type
== 22; /* R_S390_64. */
11781 return reloc_type
== 1; /* R_TILEGX_64. */
11783 return reloc_type
== 18; /* R_MIPS_64. */
11789 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11790 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11793 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11795 switch (elf_header
.e_machine
)
11798 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11800 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11802 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11804 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11806 return reloc_type
== 44; /* R_PPC64_REL64. */
11807 case EM_SPARC32PLUS
:
11810 return reloc_type
== 46; /* R_SPARC_DISP64. */
11814 return reloc_type
== 24; /* R_X86_64_PC64. */
11817 return reloc_type
== 23; /* R_S390_PC64. */
11819 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11825 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11826 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11829 is_24bit_abs_reloc (unsigned int reloc_type
)
11831 switch (elf_header
.e_machine
)
11833 case EM_CYGNUS_MN10200
:
11835 return reloc_type
== 4; /* R_MN10200_24. */
11837 return reloc_type
== 5; /* R_FT32_20. */
11843 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11844 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11847 is_16bit_abs_reloc (unsigned int reloc_type
)
11849 /* Please keep this table alpha-sorted for ease of visual lookup. */
11850 switch (elf_header
.e_machine
)
11853 case EM_ARC_COMPACT
:
11854 case EM_ARC_COMPACT2
:
11855 return reloc_type
== 2; /* R_ARC_16. */
11856 case EM_ADAPTEVA_EPIPHANY
:
11857 return reloc_type
== 5;
11860 return reloc_type
== 4; /* R_AVR_16. */
11861 case EM_CYGNUS_D10V
:
11863 return reloc_type
== 3; /* R_D10V_16. */
11867 return reloc_type
== R_H8_DIR16
;
11870 return reloc_type
== 1; /* R_IP2K_16. */
11873 return reloc_type
== 1; /* R_M32C_16 */
11874 case EM_CYGNUS_MN10200
:
11876 return reloc_type
== 2; /* R_MN10200_16. */
11877 case EM_CYGNUS_MN10300
:
11879 return reloc_type
== 2; /* R_MN10300_16. */
11881 if (uses_msp430x_relocs ())
11882 return reloc_type
== 2; /* R_MSP430_ABS16. */
11883 case EM_MSP430_OLD
:
11884 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11886 return reloc_type
== 19; /* R_NDS32_RELA. */
11887 case EM_ALTERA_NIOS2
:
11888 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11890 return reloc_type
== 9; /* R_NIOS_16. */
11892 return reloc_type
== 2; /* R_OR1K_16. */
11894 return reloc_type
== 2; /* R_C6000_ABS16. */
11896 return reloc_type
== 2; /* R_VISIUM_16. */
11899 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11901 return reloc_type
== 3; /* R_XGATE_16. */
11907 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11908 relocation entries (possibly formerly used for SHT_GROUP sections). */
11911 is_none_reloc (unsigned int reloc_type
)
11913 switch (elf_header
.e_machine
)
11915 case EM_386
: /* R_386_NONE. */
11916 case EM_68K
: /* R_68K_NONE. */
11917 case EM_ADAPTEVA_EPIPHANY
:
11918 case EM_ALPHA
: /* R_ALPHA_NONE. */
11919 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11920 case EM_ARC
: /* R_ARC_NONE. */
11921 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
11922 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
11923 case EM_ARM
: /* R_ARM_NONE. */
11924 case EM_C166
: /* R_XC16X_NONE. */
11925 case EM_CRIS
: /* R_CRIS_NONE. */
11926 case EM_FT32
: /* R_FT32_NONE. */
11927 case EM_IA_64
: /* R_IA64_NONE. */
11928 case EM_K1OM
: /* R_X86_64_NONE. */
11929 case EM_L1OM
: /* R_X86_64_NONE. */
11930 case EM_M32R
: /* R_M32R_NONE. */
11931 case EM_MIPS
: /* R_MIPS_NONE. */
11932 case EM_MN10300
: /* R_MN10300_NONE. */
11933 case EM_MOXIE
: /* R_MOXIE_NONE. */
11934 case EM_NIOS32
: /* R_NIOS_NONE. */
11935 case EM_OR1K
: /* R_OR1K_NONE. */
11936 case EM_PARISC
: /* R_PARISC_NONE. */
11937 case EM_PPC64
: /* R_PPC64_NONE. */
11938 case EM_PPC
: /* R_PPC_NONE. */
11939 case EM_S390
: /* R_390_NONE. */
11941 case EM_SH
: /* R_SH_NONE. */
11942 case EM_SPARC32PLUS
:
11943 case EM_SPARC
: /* R_SPARC_NONE. */
11945 case EM_TILEGX
: /* R_TILEGX_NONE. */
11946 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11947 case EM_TI_C6000
:/* R_C6000_NONE. */
11948 case EM_X86_64
: /* R_X86_64_NONE. */
11950 return reloc_type
== 0;
11953 return reloc_type
== 0 || reloc_type
== 256;
11956 return (reloc_type
== 0 /* R_AVR_NONE. */
11957 || reloc_type
== 30 /* R_AVR_DIFF8. */
11958 || reloc_type
== 31 /* R_AVR_DIFF16. */
11959 || reloc_type
== 32 /* R_AVR_DIFF32. */);
11961 return reloc_type
== 3; /* R_METAG_NONE. */
11963 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11964 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11965 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11966 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11967 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11968 case EM_XTENSA_OLD
:
11970 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11971 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11972 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11973 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11978 /* Returns TRUE if there is a relocation against
11979 section NAME at OFFSET bytes. */
11982 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
11984 Elf_Internal_Rela
* relocs
;
11985 Elf_Internal_Rela
* rp
;
11987 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
11990 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
11992 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
11993 if (rp
->r_offset
== offset
)
11999 /* Apply relocations to a section.
12000 Note: So far support has been added only for those relocations
12001 which can be found in debug sections.
12002 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12003 loaded relocs. It is then the caller's responsibility to free them.
12004 FIXME: Add support for more relocations ? */
12007 apply_relocations (void * file
,
12008 const Elf_Internal_Shdr
* section
,
12009 unsigned char * start
,
12010 bfd_size_type size
,
12011 void ** relocs_return
,
12012 unsigned long * num_relocs_return
)
12014 Elf_Internal_Shdr
* relsec
;
12015 unsigned char * end
= start
+ size
;
12017 if (relocs_return
!= NULL
)
12019 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12020 * num_relocs_return
= 0;
12023 if (elf_header
.e_type
!= ET_REL
)
12026 /* Find the reloc section associated with the section. */
12027 for (relsec
= section_headers
;
12028 relsec
< section_headers
+ elf_header
.e_shnum
;
12031 bfd_boolean is_rela
;
12032 unsigned long num_relocs
;
12033 Elf_Internal_Rela
* relocs
;
12034 Elf_Internal_Rela
* rp
;
12035 Elf_Internal_Shdr
* symsec
;
12036 Elf_Internal_Sym
* symtab
;
12037 unsigned long num_syms
;
12038 Elf_Internal_Sym
* sym
;
12040 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12041 || relsec
->sh_info
>= elf_header
.e_shnum
12042 || section_headers
+ relsec
->sh_info
!= section
12043 || relsec
->sh_size
== 0
12044 || relsec
->sh_link
>= elf_header
.e_shnum
)
12047 is_rela
= relsec
->sh_type
== SHT_RELA
;
12051 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12052 relsec
->sh_size
, & relocs
, & num_relocs
))
12057 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12058 relsec
->sh_size
, & relocs
, & num_relocs
))
12062 /* SH uses RELA but uses in place value instead of the addend field. */
12063 if (elf_header
.e_machine
== EM_SH
)
12066 symsec
= section_headers
+ relsec
->sh_link
;
12067 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12069 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12072 unsigned int reloc_type
;
12073 unsigned int reloc_size
;
12074 unsigned char * rloc
;
12075 unsigned long sym_index
;
12077 reloc_type
= get_reloc_type (rp
->r_info
);
12079 if (target_specific_reloc_handling (rp
, start
, symtab
))
12081 else if (is_none_reloc (reloc_type
))
12083 else if (is_32bit_abs_reloc (reloc_type
)
12084 || is_32bit_pcrel_reloc (reloc_type
))
12086 else if (is_64bit_abs_reloc (reloc_type
)
12087 || is_64bit_pcrel_reloc (reloc_type
))
12089 else if (is_24bit_abs_reloc (reloc_type
))
12091 else if (is_16bit_abs_reloc (reloc_type
))
12095 static unsigned int prev_reloc
= 0;
12096 if (reloc_type
!= prev_reloc
)
12097 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12098 reloc_type
, printable_section_name (section
));
12099 prev_reloc
= reloc_type
;
12103 rloc
= start
+ rp
->r_offset
;
12104 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12106 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12107 (unsigned long) rp
->r_offset
,
12108 printable_section_name (section
));
12112 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12113 if (sym_index
>= num_syms
)
12115 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12116 sym_index
, printable_section_name (section
));
12119 sym
= symtab
+ sym_index
;
12121 /* If the reloc has a symbol associated with it,
12122 make sure that it is of an appropriate type.
12124 Relocations against symbols without type can happen.
12125 Gcc -feliminate-dwarf2-dups may generate symbols
12126 without type for debug info.
12128 Icc generates relocations against function symbols
12129 instead of local labels.
12131 Relocations against object symbols can happen, eg when
12132 referencing a global array. For an example of this see
12133 the _clz.o binary in libgcc.a. */
12135 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12136 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12138 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12139 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12140 (long int)(rp
- relocs
),
12141 printable_section_name (relsec
));
12147 addend
+= rp
->r_addend
;
12148 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12149 partial_inplace. */
12151 || (elf_header
.e_machine
== EM_XTENSA
12152 && reloc_type
== 1)
12153 || ((elf_header
.e_machine
== EM_PJ
12154 || elf_header
.e_machine
== EM_PJ_OLD
)
12155 && reloc_type
== 1)
12156 || ((elf_header
.e_machine
== EM_D30V
12157 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12158 && reloc_type
== 12))
12159 addend
+= byte_get (rloc
, reloc_size
);
12161 if (is_32bit_pcrel_reloc (reloc_type
)
12162 || is_64bit_pcrel_reloc (reloc_type
))
12164 /* On HPPA, all pc-relative relocations are biased by 8. */
12165 if (elf_header
.e_machine
== EM_PARISC
)
12167 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12171 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12178 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12179 * num_relocs_return
= num_relocs
;
12188 #ifdef SUPPORT_DISASSEMBLY
12190 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12192 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12194 /* FIXME: XXX -- to be done --- XXX */
12200 /* Reads in the contents of SECTION from FILE, returning a pointer
12201 to a malloc'ed buffer or NULL if something went wrong. */
12204 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12206 bfd_size_type num_bytes
;
12208 num_bytes
= section
->sh_size
;
12210 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12212 printf (_("\nSection '%s' has no data to dump.\n"),
12213 printable_section_name (section
));
12217 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12218 _("section contents"));
12221 /* Uncompresses a section that was compressed using zlib, in place. */
12224 uncompress_section_contents (unsigned char **buffer
,
12225 dwarf_size_type uncompressed_size
,
12226 dwarf_size_type
*size
)
12228 dwarf_size_type compressed_size
= *size
;
12229 unsigned char * compressed_buffer
= *buffer
;
12230 unsigned char * uncompressed_buffer
;
12234 /* It is possible the section consists of several compressed
12235 buffers concatenated together, so we uncompress in a loop. */
12236 /* PR 18313: The state field in the z_stream structure is supposed
12237 to be invisible to the user (ie us), but some compilers will
12238 still complain about it being used without initialisation. So
12239 we first zero the entire z_stream structure and then set the fields
12241 memset (& strm
, 0, sizeof strm
);
12242 strm
.avail_in
= compressed_size
;
12243 strm
.next_in
= (Bytef
*) compressed_buffer
;
12244 strm
.avail_out
= uncompressed_size
;
12245 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12247 rc
= inflateInit (& strm
);
12248 while (strm
.avail_in
> 0)
12252 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12253 + (uncompressed_size
- strm
.avail_out
));
12254 rc
= inflate (&strm
, Z_FINISH
);
12255 if (rc
!= Z_STREAM_END
)
12257 rc
= inflateReset (& strm
);
12259 rc
= inflateEnd (& strm
);
12261 || strm
.avail_out
!= 0)
12264 *buffer
= uncompressed_buffer
;
12265 *size
= uncompressed_size
;
12269 free (uncompressed_buffer
);
12270 /* Indicate decompression failure. */
12276 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12278 Elf_Internal_Shdr
* relsec
;
12279 bfd_size_type num_bytes
;
12280 unsigned char * data
;
12281 unsigned char * end
;
12282 unsigned char * real_start
;
12283 unsigned char * start
;
12284 bfd_boolean some_strings_shown
;
12286 real_start
= start
= (unsigned char *) get_section_contents (section
,
12290 num_bytes
= section
->sh_size
;
12292 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12294 if (decompress_dumps
)
12296 dwarf_size_type new_size
= num_bytes
;
12297 dwarf_size_type uncompressed_size
= 0;
12299 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12301 Elf_Internal_Chdr chdr
;
12302 unsigned int compression_header_size
12303 = get_compression_header (& chdr
, (unsigned char *) start
);
12305 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12307 warn (_("section '%s' has unsupported compress type: %d\n"),
12308 printable_section_name (section
), chdr
.ch_type
);
12311 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12313 warn (_("compressed section '%s' is corrupted\n"),
12314 printable_section_name (section
));
12317 uncompressed_size
= chdr
.ch_size
;
12318 start
+= compression_header_size
;
12319 new_size
-= compression_header_size
;
12321 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12323 /* Read the zlib header. In this case, it should be "ZLIB"
12324 followed by the uncompressed section size, 8 bytes in
12325 big-endian order. */
12326 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12327 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12328 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12329 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12330 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12331 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12332 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12333 uncompressed_size
+= start
[11];
12338 if (uncompressed_size
12339 && uncompress_section_contents (& start
,
12340 uncompressed_size
, & new_size
))
12341 num_bytes
= new_size
;
12344 /* If the section being dumped has relocations against it the user might
12345 be expecting these relocations to have been applied. Check for this
12346 case and issue a warning message in order to avoid confusion.
12347 FIXME: Maybe we ought to have an option that dumps a section with
12348 relocs applied ? */
12349 for (relsec
= section_headers
;
12350 relsec
< section_headers
+ elf_header
.e_shnum
;
12353 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12354 || relsec
->sh_info
>= elf_header
.e_shnum
12355 || section_headers
+ relsec
->sh_info
!= section
12356 || relsec
->sh_size
== 0
12357 || relsec
->sh_link
>= elf_header
.e_shnum
)
12360 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12365 end
= start
+ num_bytes
;
12366 some_strings_shown
= FALSE
;
12370 while (!ISPRINT (* data
))
12371 if (++ data
>= end
)
12376 size_t maxlen
= end
- data
;
12379 /* PR 11128: Use two separate invocations in order to work
12380 around bugs in the Solaris 8 implementation of printf. */
12381 printf (" [%6tx] ", data
- start
);
12383 printf (" [%6Ix] ", (size_t) (data
- start
));
12387 print_symbol ((int) maxlen
, (const char *) data
);
12389 data
+= strnlen ((const char *) data
, maxlen
);
12393 printf (_("<corrupt>\n"));
12396 some_strings_shown
= TRUE
;
12400 if (! some_strings_shown
)
12401 printf (_(" No strings found in this section."));
12409 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12411 bfd_boolean relocate
)
12413 Elf_Internal_Shdr
* relsec
;
12414 bfd_size_type bytes
;
12415 bfd_size_type section_size
;
12417 unsigned char * data
;
12418 unsigned char * real_start
;
12419 unsigned char * start
;
12421 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12424 section_size
= section
->sh_size
;
12426 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12428 if (decompress_dumps
)
12430 dwarf_size_type new_size
= section_size
;
12431 dwarf_size_type uncompressed_size
= 0;
12433 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12435 Elf_Internal_Chdr chdr
;
12436 unsigned int compression_header_size
12437 = get_compression_header (& chdr
, start
);
12439 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12441 warn (_("section '%s' has unsupported compress type: %d\n"),
12442 printable_section_name (section
), chdr
.ch_type
);
12445 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12447 warn (_("compressed section '%s' is corrupted\n"),
12448 printable_section_name (section
));
12451 uncompressed_size
= chdr
.ch_size
;
12452 start
+= compression_header_size
;
12453 new_size
-= compression_header_size
;
12455 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12457 /* Read the zlib header. In this case, it should be "ZLIB"
12458 followed by the uncompressed section size, 8 bytes in
12459 big-endian order. */
12460 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12461 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12462 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12463 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12464 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12465 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12466 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12467 uncompressed_size
+= start
[11];
12472 if (uncompressed_size
12473 && uncompress_section_contents (& start
, uncompressed_size
,
12475 section_size
= new_size
;
12480 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12484 /* If the section being dumped has relocations against it the user might
12485 be expecting these relocations to have been applied. Check for this
12486 case and issue a warning message in order to avoid confusion.
12487 FIXME: Maybe we ought to have an option that dumps a section with
12488 relocs applied ? */
12489 for (relsec
= section_headers
;
12490 relsec
< section_headers
+ elf_header
.e_shnum
;
12493 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12494 || relsec
->sh_info
>= elf_header
.e_shnum
12495 || section_headers
+ relsec
->sh_info
!= section
12496 || relsec
->sh_size
== 0
12497 || relsec
->sh_link
>= elf_header
.e_shnum
)
12500 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12505 addr
= section
->sh_addr
;
12506 bytes
= section_size
;
12515 lbytes
= (bytes
> 16 ? 16 : bytes
);
12517 printf (" 0x%8.8lx ", (unsigned long) addr
);
12519 for (j
= 0; j
< 16; j
++)
12522 printf ("%2.2x", data
[j
]);
12530 for (j
= 0; j
< lbytes
; j
++)
12533 if (k
>= ' ' && k
< 0x7f)
12552 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12553 const Elf_Internal_Shdr
* sec
, void * file
)
12555 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12558 /* If it is already loaded, do nothing. */
12559 if (section
->start
!= NULL
)
12562 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12563 section
->address
= sec
->sh_addr
;
12564 section
->user_data
= NULL
;
12565 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12567 sec
->sh_size
, buf
);
12568 if (section
->start
== NULL
)
12572 unsigned char *start
= section
->start
;
12573 dwarf_size_type size
= sec
->sh_size
;
12574 dwarf_size_type uncompressed_size
= 0;
12576 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12578 Elf_Internal_Chdr chdr
;
12579 unsigned int compression_header_size
12580 = get_compression_header (&chdr
, start
);
12581 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12583 warn (_("section '%s' has unsupported compress type: %d\n"),
12584 section
->name
, chdr
.ch_type
);
12587 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12589 warn (_("compressed section '%s' is corrupted\n"),
12593 uncompressed_size
= chdr
.ch_size
;
12594 start
+= compression_header_size
;
12595 size
-= compression_header_size
;
12597 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12599 /* Read the zlib header. In this case, it should be "ZLIB"
12600 followed by the uncompressed section size, 8 bytes in
12601 big-endian order. */
12602 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12603 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12604 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12605 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12606 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12607 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12608 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12609 uncompressed_size
+= start
[11];
12614 if (uncompressed_size
12615 && uncompress_section_contents (&start
, uncompressed_size
,
12618 /* Free the compressed buffer, update the section buffer
12619 and the section size if uncompress is successful. */
12620 free (section
->start
);
12621 section
->start
= start
;
12623 section
->size
= size
;
12626 if (section
->start
== NULL
)
12629 if (debug_displays
[debug
].relocate
)
12630 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12631 & section
->reloc_info
, & section
->num_relocs
);
12634 section
->reloc_info
= NULL
;
12635 section
->num_relocs
= 0;
12641 /* If this is not NULL, load_debug_section will only look for sections
12642 within the list of sections given here. */
12643 unsigned int *section_subset
= NULL
;
12646 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12648 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12649 Elf_Internal_Shdr
* sec
;
12651 /* Locate the debug section. */
12652 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12654 section
->name
= section
->uncompressed_name
;
12657 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12659 section
->name
= section
->compressed_name
;
12664 /* If we're loading from a subset of sections, and we've loaded
12665 a section matching this name before, it's likely that it's a
12667 if (section_subset
!= NULL
)
12668 free_debug_section (debug
);
12670 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12674 free_debug_section (enum dwarf_section_display_enum debug
)
12676 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12678 if (section
->start
== NULL
)
12681 free ((char *) section
->start
);
12682 section
->start
= NULL
;
12683 section
->address
= 0;
12688 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12690 char * name
= SECTION_NAME (section
);
12691 const char * print_name
= printable_section_name (section
);
12692 bfd_size_type length
;
12696 length
= section
->sh_size
;
12699 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12702 if (section
->sh_type
== SHT_NOBITS
)
12704 /* There is no point in dumping the contents of a debugging section
12705 which has the NOBITS type - the bits in the file will be random.
12706 This can happen when a file containing a .eh_frame section is
12707 stripped with the --only-keep-debug command line option. */
12708 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12713 if (const_strneq (name
, ".gnu.linkonce.wi."))
12714 name
= ".debug_info";
12716 /* See if we know how to display the contents of this section. */
12717 for (i
= 0; i
< max
; i
++)
12718 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12719 || (i
== line
&& const_strneq (name
, ".debug_line."))
12720 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12722 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12723 int secondary
= (section
!= find_section (name
));
12726 free_debug_section ((enum dwarf_section_display_enum
) i
);
12728 if (i
== line
&& const_strneq (name
, ".debug_line."))
12730 else if (streq (sec
->uncompressed_name
, name
))
12731 sec
->name
= sec
->uncompressed_name
;
12733 sec
->name
= sec
->compressed_name
;
12734 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12737 /* If this debug section is part of a CU/TU set in a .dwp file,
12738 restrict load_debug_section to the sections in that set. */
12739 section_subset
= find_cu_tu_set (file
, shndx
);
12741 result
&= debug_displays
[i
].display (sec
, file
);
12743 section_subset
= NULL
;
12745 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12746 free_debug_section ((enum dwarf_section_display_enum
) i
);
12754 printf (_("Unrecognized debug section: %s\n"), print_name
);
12761 /* Set DUMP_SECTS for all sections where dumps were requested
12762 based on section name. */
12765 initialise_dumps_byname (void)
12767 struct dump_list_entry
* cur
;
12769 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12774 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12775 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12777 request_dump_bynumber (i
, cur
->type
);
12782 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12788 process_section_contents (FILE * file
)
12790 Elf_Internal_Shdr
* section
;
12796 initialise_dumps_byname ();
12798 for (i
= 0, section
= section_headers
;
12799 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12802 #ifdef SUPPORT_DISASSEMBLY
12803 if (dump_sects
[i
] & DISASS_DUMP
)
12804 disassemble_section (section
, file
);
12806 if (dump_sects
[i
] & HEX_DUMP
)
12807 dump_section_as_bytes (section
, file
, FALSE
);
12809 if (dump_sects
[i
] & RELOC_DUMP
)
12810 dump_section_as_bytes (section
, file
, TRUE
);
12812 if (dump_sects
[i
] & STRING_DUMP
)
12813 dump_section_as_strings (section
, file
);
12815 if (dump_sects
[i
] & DEBUG_DUMP
)
12816 display_debug_section (i
, section
, file
);
12819 /* Check to see if the user requested a
12820 dump of a section that does not exist. */
12821 while (i
++ < num_dump_sects
)
12823 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12827 process_mips_fpe_exception (int mask
)
12832 if (mask
& OEX_FPU_INEX
)
12833 fputs ("INEX", stdout
), first
= 0;
12834 if (mask
& OEX_FPU_UFLO
)
12835 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12836 if (mask
& OEX_FPU_OFLO
)
12837 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12838 if (mask
& OEX_FPU_DIV0
)
12839 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12840 if (mask
& OEX_FPU_INVAL
)
12841 printf ("%sINVAL", first
? "" : "|");
12844 fputs ("0", stdout
);
12847 /* Display's the value of TAG at location P. If TAG is
12848 greater than 0 it is assumed to be an unknown tag, and
12849 a message is printed to this effect. Otherwise it is
12850 assumed that a message has already been printed.
12852 If the bottom bit of TAG is set it assumed to have a
12853 string value, otherwise it is assumed to have an integer
12856 Returns an updated P pointing to the first unread byte
12857 beyond the end of TAG's value.
12859 Reads at or beyond END will not be made. */
12861 static unsigned char *
12862 display_tag_value (int tag
,
12864 const unsigned char * const end
)
12869 printf (" Tag_unknown_%d: ", tag
);
12873 warn (_("<corrupt tag>\n"));
12877 /* PR 17531 file: 027-19978-0.004. */
12878 size_t maxlen
= (end
- p
) - 1;
12883 print_symbol ((int) maxlen
, (const char *) p
);
12884 p
+= strnlen ((char *) p
, maxlen
) + 1;
12888 printf (_("<corrupt string tag>"));
12889 p
= (unsigned char *) end
;
12897 val
= read_uleb128 (p
, &len
, end
);
12899 printf ("%ld (0x%lx)\n", val
, val
);
12906 /* ARM EABI attributes section. */
12911 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12913 const char ** table
;
12914 } arm_attr_public_tag
;
12916 static const char * arm_attr_tag_CPU_arch
[] =
12917 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12918 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12920 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12921 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12922 {"No", "Thumb-1", "Thumb-2", "Yes"};
12923 static const char * arm_attr_tag_FP_arch
[] =
12924 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12925 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12926 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12927 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12928 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
12929 "NEON for ARMv8.1"};
12930 static const char * arm_attr_tag_PCS_config
[] =
12931 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12932 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12933 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12934 {"V6", "SB", "TLS", "Unused"};
12935 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12936 {"Absolute", "PC-relative", "SB-relative", "None"};
12937 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12938 {"Absolute", "PC-relative", "None"};
12939 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12940 {"None", "direct", "GOT-indirect"};
12941 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12942 {"None", "??? 1", "2", "??? 3", "4"};
12943 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12944 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12945 {"Unused", "Needed", "Sign only"};
12946 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12947 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12948 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12949 {"Unused", "Finite", "RTABI", "IEEE 754"};
12950 static const char * arm_attr_tag_ABI_enum_size
[] =
12951 {"Unused", "small", "int", "forced to int"};
12952 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12953 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12954 static const char * arm_attr_tag_ABI_VFP_args
[] =
12955 {"AAPCS", "VFP registers", "custom", "compatible"};
12956 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12957 {"AAPCS", "WMMX registers", "custom"};
12958 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12959 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12960 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12961 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12962 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12963 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12964 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12965 static const char * arm_attr_tag_FP_HP_extension
[] =
12966 {"Not Allowed", "Allowed"};
12967 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12968 {"None", "IEEE 754", "Alternative Format"};
12969 static const char * arm_attr_tag_DSP_extension
[] =
12970 {"Follow architecture", "Allowed"};
12971 static const char * arm_attr_tag_MPextension_use
[] =
12972 {"Not Allowed", "Allowed"};
12973 static const char * arm_attr_tag_DIV_use
[] =
12974 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12975 "Allowed in v7-A with integer division extension"};
12976 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12977 static const char * arm_attr_tag_Virtualization_use
[] =
12978 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12979 "TrustZone and Virtualization Extensions"};
12980 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12981 {"Not Allowed", "Allowed"};
12983 #define LOOKUP(id, name) \
12984 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12985 static arm_attr_public_tag arm_attr_public_tags
[] =
12987 {4, "CPU_raw_name", 1, NULL
},
12988 {5, "CPU_name", 1, NULL
},
12989 LOOKUP(6, CPU_arch
),
12990 {7, "CPU_arch_profile", 0, NULL
},
12991 LOOKUP(8, ARM_ISA_use
),
12992 LOOKUP(9, THUMB_ISA_use
),
12993 LOOKUP(10, FP_arch
),
12994 LOOKUP(11, WMMX_arch
),
12995 LOOKUP(12, Advanced_SIMD_arch
),
12996 LOOKUP(13, PCS_config
),
12997 LOOKUP(14, ABI_PCS_R9_use
),
12998 LOOKUP(15, ABI_PCS_RW_data
),
12999 LOOKUP(16, ABI_PCS_RO_data
),
13000 LOOKUP(17, ABI_PCS_GOT_use
),
13001 LOOKUP(18, ABI_PCS_wchar_t
),
13002 LOOKUP(19, ABI_FP_rounding
),
13003 LOOKUP(20, ABI_FP_denormal
),
13004 LOOKUP(21, ABI_FP_exceptions
),
13005 LOOKUP(22, ABI_FP_user_exceptions
),
13006 LOOKUP(23, ABI_FP_number_model
),
13007 {24, "ABI_align_needed", 0, NULL
},
13008 {25, "ABI_align_preserved", 0, NULL
},
13009 LOOKUP(26, ABI_enum_size
),
13010 LOOKUP(27, ABI_HardFP_use
),
13011 LOOKUP(28, ABI_VFP_args
),
13012 LOOKUP(29, ABI_WMMX_args
),
13013 LOOKUP(30, ABI_optimization_goals
),
13014 LOOKUP(31, ABI_FP_optimization_goals
),
13015 {32, "compatibility", 0, NULL
},
13016 LOOKUP(34, CPU_unaligned_access
),
13017 LOOKUP(36, FP_HP_extension
),
13018 LOOKUP(38, ABI_FP_16bit_format
),
13019 LOOKUP(42, MPextension_use
),
13020 LOOKUP(44, DIV_use
),
13021 LOOKUP(46, DSP_extension
),
13022 {64, "nodefaults", 0, NULL
},
13023 {65, "also_compatible_with", 0, NULL
},
13024 LOOKUP(66, T2EE_use
),
13025 {67, "conformance", 1, NULL
},
13026 LOOKUP(68, Virtualization_use
),
13027 LOOKUP(70, MPextension_use_legacy
)
13031 static unsigned char *
13032 display_arm_attribute (unsigned char * p
,
13033 const unsigned char * const end
)
13038 arm_attr_public_tag
* attr
;
13042 tag
= read_uleb128 (p
, &len
, end
);
13045 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13047 if (arm_attr_public_tags
[i
].tag
== tag
)
13049 attr
= &arm_attr_public_tags
[i
];
13056 printf (" Tag_%s: ", attr
->name
);
13057 switch (attr
->type
)
13062 case 7: /* Tag_CPU_arch_profile. */
13063 val
= read_uleb128 (p
, &len
, end
);
13067 case 0: printf (_("None\n")); break;
13068 case 'A': printf (_("Application\n")); break;
13069 case 'R': printf (_("Realtime\n")); break;
13070 case 'M': printf (_("Microcontroller\n")); break;
13071 case 'S': printf (_("Application or Realtime\n")); break;
13072 default: printf ("??? (%d)\n", val
); break;
13076 case 24: /* Tag_align_needed. */
13077 val
= read_uleb128 (p
, &len
, end
);
13081 case 0: printf (_("None\n")); break;
13082 case 1: printf (_("8-byte\n")); break;
13083 case 2: printf (_("4-byte\n")); break;
13084 case 3: printf ("??? 3\n"); break;
13087 printf (_("8-byte and up to %d-byte extended\n"),
13090 printf ("??? (%d)\n", val
);
13095 case 25: /* Tag_align_preserved. */
13096 val
= read_uleb128 (p
, &len
, end
);
13100 case 0: printf (_("None\n")); break;
13101 case 1: printf (_("8-byte, except leaf SP\n")); break;
13102 case 2: printf (_("8-byte\n")); break;
13103 case 3: printf ("??? 3\n"); break;
13106 printf (_("8-byte and up to %d-byte extended\n"),
13109 printf ("??? (%d)\n", val
);
13114 case 32: /* Tag_compatibility. */
13116 val
= read_uleb128 (p
, &len
, end
);
13118 printf (_("flag = %d, vendor = "), val
);
13121 size_t maxlen
= (end
- p
) - 1;
13123 print_symbol ((int) maxlen
, (const char *) p
);
13124 p
+= strnlen ((char *) p
, maxlen
) + 1;
13128 printf (_("<corrupt>"));
13129 p
= (unsigned char *) end
;
13135 case 64: /* Tag_nodefaults. */
13136 /* PR 17531: file: 001-505008-0.01. */
13139 printf (_("True\n"));
13142 case 65: /* Tag_also_compatible_with. */
13143 val
= read_uleb128 (p
, &len
, end
);
13145 if (val
== 6 /* Tag_CPU_arch. */)
13147 val
= read_uleb128 (p
, &len
, end
);
13149 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13150 printf ("??? (%d)\n", val
);
13152 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13156 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13161 printf (_("<unknown: %d>\n"), tag
);
13167 return display_tag_value (-1, p
, end
);
13169 return display_tag_value (0, p
, end
);
13172 assert (attr
->type
& 0x80);
13173 val
= read_uleb128 (p
, &len
, end
);
13175 type
= attr
->type
& 0x7f;
13177 printf ("??? (%d)\n", val
);
13179 printf ("%s\n", attr
->table
[val
]);
13184 return display_tag_value (tag
, p
, end
);
13187 static unsigned char *
13188 display_gnu_attribute (unsigned char * p
,
13189 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13190 const unsigned char * const end
)
13196 tag
= read_uleb128 (p
, &len
, end
);
13199 /* Tag_compatibility is the only generic GNU attribute defined at
13203 val
= read_uleb128 (p
, &len
, end
);
13206 printf (_("flag = %d, vendor = "), val
);
13209 printf (_("<corrupt>\n"));
13210 warn (_("corrupt vendor attribute\n"));
13216 size_t maxlen
= (end
- p
) - 1;
13218 print_symbol ((int) maxlen
, (const char *) p
);
13219 p
+= strnlen ((char *) p
, maxlen
) + 1;
13223 printf (_("<corrupt>"));
13224 p
= (unsigned char *) end
;
13231 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13232 return display_proc_gnu_attribute (p
, tag
, end
);
13234 return display_tag_value (tag
, p
, end
);
13237 static unsigned char *
13238 display_power_gnu_attribute (unsigned char * p
,
13240 const unsigned char * const end
)
13245 if (tag
== Tag_GNU_Power_ABI_FP
)
13247 val
= read_uleb128 (p
, &len
, end
);
13249 printf (" Tag_GNU_Power_ABI_FP: ");
13254 printf (_("Hard or soft float\n"));
13257 printf (_("Hard float\n"));
13260 printf (_("Soft float\n"));
13263 printf (_("Single-precision hard float\n"));
13266 printf ("??? (%d)\n", val
);
13272 if (tag
== Tag_GNU_Power_ABI_Vector
)
13274 val
= read_uleb128 (p
, &len
, end
);
13276 printf (" Tag_GNU_Power_ABI_Vector: ");
13280 printf (_("Any\n"));
13283 printf (_("Generic\n"));
13286 printf ("AltiVec\n");
13292 printf ("??? (%d)\n", val
);
13298 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13302 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13306 val
= read_uleb128 (p
, &len
, end
);
13308 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13312 printf (_("Any\n"));
13315 printf ("r3/r4\n");
13318 printf (_("Memory\n"));
13321 printf ("??? (%d)\n", val
);
13327 return display_tag_value (tag
& 1, p
, end
);
13330 static unsigned char *
13331 display_s390_gnu_attribute (unsigned char * p
,
13333 const unsigned char * const end
)
13338 if (tag
== Tag_GNU_S390_ABI_Vector
)
13340 val
= read_uleb128 (p
, &len
, end
);
13342 printf (" Tag_GNU_S390_ABI_Vector: ");
13347 printf (_("any\n"));
13350 printf (_("software\n"));
13353 printf (_("hardware\n"));
13356 printf ("??? (%d)\n", val
);
13362 return display_tag_value (tag
& 1, p
, end
);
13366 display_sparc_hwcaps (int mask
)
13372 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13373 fputs ("mul32", stdout
), first
= 0;
13374 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13375 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13376 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13377 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13378 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13379 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13380 if (mask
& ELF_SPARC_HWCAP_POPC
)
13381 printf ("%spopc", first
? "" : "|"), first
= 0;
13382 if (mask
& ELF_SPARC_HWCAP_VIS
)
13383 printf ("%svis", first
? "" : "|"), first
= 0;
13384 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13385 printf ("%svis2", first
? "" : "|"), first
= 0;
13386 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13387 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13388 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13389 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13390 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13391 printf ("%svis3", first
? "" : "|"), first
= 0;
13392 if (mask
& ELF_SPARC_HWCAP_HPC
)
13393 printf ("%shpc", first
? "" : "|"), first
= 0;
13394 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13395 printf ("%srandom", first
? "" : "|"), first
= 0;
13396 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13397 printf ("%strans", first
? "" : "|"), first
= 0;
13398 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13399 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13400 if (mask
& ELF_SPARC_HWCAP_IMA
)
13401 printf ("%sima", first
? "" : "|"), first
= 0;
13402 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13403 printf ("%scspare", first
? "" : "|"), first
= 0;
13406 fputc ('0', stdout
);
13407 fputc ('\n', stdout
);
13411 display_sparc_hwcaps2 (int mask
)
13417 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13418 fputs ("fjathplus", stdout
), first
= 0;
13419 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13420 printf ("%svis3b", first
? "" : "|"), first
= 0;
13421 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13422 printf ("%sadp", first
? "" : "|"), first
= 0;
13423 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13424 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13425 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13426 printf ("%smwait", first
? "" : "|"), first
= 0;
13427 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13428 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13429 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13430 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13431 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13432 printf ("%snsec", first
? "" : "|"), first
= 0;
13433 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13434 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13435 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13436 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13437 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13438 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13441 fputc ('0', stdout
);
13442 fputc ('\n', stdout
);
13445 static unsigned char *
13446 display_sparc_gnu_attribute (unsigned char * p
,
13448 const unsigned char * const end
)
13453 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13455 val
= read_uleb128 (p
, &len
, end
);
13457 printf (" Tag_GNU_Sparc_HWCAPS: ");
13458 display_sparc_hwcaps (val
);
13461 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13463 val
= read_uleb128 (p
, &len
, end
);
13465 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13466 display_sparc_hwcaps2 (val
);
13470 return display_tag_value (tag
, p
, end
);
13474 print_mips_fp_abi_value (int val
)
13478 case Val_GNU_MIPS_ABI_FP_ANY
:
13479 printf (_("Hard or soft float\n"));
13481 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13482 printf (_("Hard float (double precision)\n"));
13484 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13485 printf (_("Hard float (single precision)\n"));
13487 case Val_GNU_MIPS_ABI_FP_SOFT
:
13488 printf (_("Soft float\n"));
13490 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13491 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13493 case Val_GNU_MIPS_ABI_FP_XX
:
13494 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13496 case Val_GNU_MIPS_ABI_FP_64
:
13497 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13499 case Val_GNU_MIPS_ABI_FP_64A
:
13500 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13502 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13503 printf (_("NaN 2008 compatibility\n"));
13506 printf ("??? (%d)\n", val
);
13511 static unsigned char *
13512 display_mips_gnu_attribute (unsigned char * p
,
13514 const unsigned char * const end
)
13516 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13521 val
= read_uleb128 (p
, &len
, end
);
13523 printf (" Tag_GNU_MIPS_ABI_FP: ");
13525 print_mips_fp_abi_value (val
);
13530 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13535 val
= read_uleb128 (p
, &len
, end
);
13537 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13541 case Val_GNU_MIPS_ABI_MSA_ANY
:
13542 printf (_("Any MSA or not\n"));
13544 case Val_GNU_MIPS_ABI_MSA_128
:
13545 printf (_("128-bit MSA\n"));
13548 printf ("??? (%d)\n", val
);
13554 return display_tag_value (tag
& 1, p
, end
);
13557 static unsigned char *
13558 display_tic6x_attribute (unsigned char * p
,
13559 const unsigned char * const end
)
13565 tag
= read_uleb128 (p
, &len
, end
);
13571 val
= read_uleb128 (p
, &len
, end
);
13573 printf (" Tag_ISA: ");
13577 case C6XABI_Tag_ISA_none
:
13578 printf (_("None\n"));
13580 case C6XABI_Tag_ISA_C62X
:
13583 case C6XABI_Tag_ISA_C67X
:
13586 case C6XABI_Tag_ISA_C67XP
:
13587 printf ("C67x+\n");
13589 case C6XABI_Tag_ISA_C64X
:
13592 case C6XABI_Tag_ISA_C64XP
:
13593 printf ("C64x+\n");
13595 case C6XABI_Tag_ISA_C674X
:
13596 printf ("C674x\n");
13599 printf ("??? (%d)\n", val
);
13604 case Tag_ABI_wchar_t
:
13605 val
= read_uleb128 (p
, &len
, end
);
13607 printf (" Tag_ABI_wchar_t: ");
13611 printf (_("Not used\n"));
13614 printf (_("2 bytes\n"));
13617 printf (_("4 bytes\n"));
13620 printf ("??? (%d)\n", val
);
13625 case Tag_ABI_stack_align_needed
:
13626 val
= read_uleb128 (p
, &len
, end
);
13628 printf (" Tag_ABI_stack_align_needed: ");
13632 printf (_("8-byte\n"));
13635 printf (_("16-byte\n"));
13638 printf ("??? (%d)\n", val
);
13643 case Tag_ABI_stack_align_preserved
:
13644 val
= read_uleb128 (p
, &len
, end
);
13646 printf (" Tag_ABI_stack_align_preserved: ");
13650 printf (_("8-byte\n"));
13653 printf (_("16-byte\n"));
13656 printf ("??? (%d)\n", val
);
13662 val
= read_uleb128 (p
, &len
, end
);
13664 printf (" Tag_ABI_DSBT: ");
13668 printf (_("DSBT addressing not used\n"));
13671 printf (_("DSBT addressing used\n"));
13674 printf ("??? (%d)\n", val
);
13680 val
= read_uleb128 (p
, &len
, end
);
13682 printf (" Tag_ABI_PID: ");
13686 printf (_("Data addressing position-dependent\n"));
13689 printf (_("Data addressing position-independent, GOT near DP\n"));
13692 printf (_("Data addressing position-independent, GOT far from DP\n"));
13695 printf ("??? (%d)\n", val
);
13701 val
= read_uleb128 (p
, &len
, end
);
13703 printf (" Tag_ABI_PIC: ");
13707 printf (_("Code addressing position-dependent\n"));
13710 printf (_("Code addressing position-independent\n"));
13713 printf ("??? (%d)\n", val
);
13718 case Tag_ABI_array_object_alignment
:
13719 val
= read_uleb128 (p
, &len
, end
);
13721 printf (" Tag_ABI_array_object_alignment: ");
13725 printf (_("8-byte\n"));
13728 printf (_("4-byte\n"));
13731 printf (_("16-byte\n"));
13734 printf ("??? (%d)\n", val
);
13739 case Tag_ABI_array_object_align_expected
:
13740 val
= read_uleb128 (p
, &len
, end
);
13742 printf (" Tag_ABI_array_object_align_expected: ");
13746 printf (_("8-byte\n"));
13749 printf (_("4-byte\n"));
13752 printf (_("16-byte\n"));
13755 printf ("??? (%d)\n", val
);
13760 case Tag_ABI_compatibility
:
13762 val
= read_uleb128 (p
, &len
, end
);
13764 printf (" Tag_ABI_compatibility: ");
13765 printf (_("flag = %d, vendor = "), val
);
13768 size_t maxlen
= (end
- p
) - 1;
13770 print_symbol ((int) maxlen
, (const char *) p
);
13771 p
+= strnlen ((char *) p
, maxlen
) + 1;
13775 printf (_("<corrupt>"));
13776 p
= (unsigned char *) end
;
13782 case Tag_ABI_conformance
:
13784 printf (" Tag_ABI_conformance: \"");
13787 size_t maxlen
= (end
- p
) - 1;
13789 print_symbol ((int) maxlen
, (const char *) p
);
13790 p
+= strnlen ((char *) p
, maxlen
) + 1;
13794 printf (_("<corrupt>"));
13795 p
= (unsigned char *) end
;
13802 return display_tag_value (tag
, p
, end
);
13806 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13808 unsigned long addr
= 0;
13809 size_t bytes
= end
- p
;
13816 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13818 printf (" 0x%8.8lx ", addr
);
13820 for (j
= 0; j
< 16; j
++)
13823 printf ("%2.2x", p
[j
]);
13831 for (j
= 0; j
< lbytes
; j
++)
13834 if (k
>= ' ' && k
< 0x7f)
13850 static unsigned char *
13851 display_msp430x_attribute (unsigned char * p
,
13852 const unsigned char * const end
)
13858 tag
= read_uleb128 (p
, & len
, end
);
13863 case OFBA_MSPABI_Tag_ISA
:
13864 val
= read_uleb128 (p
, &len
, end
);
13866 printf (" Tag_ISA: ");
13869 case 0: printf (_("None\n")); break;
13870 case 1: printf (_("MSP430\n")); break;
13871 case 2: printf (_("MSP430X\n")); break;
13872 default: printf ("??? (%d)\n", val
); break;
13876 case OFBA_MSPABI_Tag_Code_Model
:
13877 val
= read_uleb128 (p
, &len
, end
);
13879 printf (" Tag_Code_Model: ");
13882 case 0: printf (_("None\n")); break;
13883 case 1: printf (_("Small\n")); break;
13884 case 2: printf (_("Large\n")); break;
13885 default: printf ("??? (%d)\n", val
); break;
13889 case OFBA_MSPABI_Tag_Data_Model
:
13890 val
= read_uleb128 (p
, &len
, end
);
13892 printf (" Tag_Data_Model: ");
13895 case 0: printf (_("None\n")); break;
13896 case 1: printf (_("Small\n")); break;
13897 case 2: printf (_("Large\n")); break;
13898 case 3: printf (_("Restricted Large\n")); break;
13899 default: printf ("??? (%d)\n", val
); break;
13904 printf (_(" <unknown tag %d>: "), tag
);
13911 size_t maxlen
= (end
- p
) - 1;
13913 print_symbol ((int) maxlen
, (const char *) p
);
13914 p
+= strnlen ((char *) p
, maxlen
) + 1;
13918 printf (_("<corrupt>"));
13919 p
= (unsigned char *) end
;
13925 val
= read_uleb128 (p
, &len
, end
);
13927 printf ("%d (0x%x)\n", val
, val
);
13937 process_attributes (FILE * file
,
13938 const char * public_name
,
13939 unsigned int proc_type
,
13940 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13941 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13943 Elf_Internal_Shdr
* sect
;
13946 /* Find the section header so that we get the size. */
13947 for (i
= 0, sect
= section_headers
;
13948 i
< elf_header
.e_shnum
;
13951 unsigned char * contents
;
13954 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13957 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13958 sect
->sh_size
, _("attributes"));
13959 if (contents
== NULL
)
13965 bfd_vma section_len
;
13967 section_len
= sect
->sh_size
- 1;
13970 while (section_len
> 0)
13973 unsigned int namelen
;
13974 bfd_boolean public_section
;
13975 bfd_boolean gnu_section
;
13977 if (section_len
<= 4)
13979 error (_("Tag section ends prematurely\n"));
13982 attr_len
= byte_get (p
, 4);
13985 if (attr_len
> section_len
)
13987 error (_("Bad attribute length (%u > %u)\n"),
13988 (unsigned) attr_len
, (unsigned) section_len
);
13989 attr_len
= section_len
;
13991 /* PR 17531: file: 001-101425-0.004 */
13992 else if (attr_len
< 5)
13994 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13998 section_len
-= attr_len
;
14001 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14002 if (namelen
== 0 || namelen
>= attr_len
)
14004 error (_("Corrupt attribute section name\n"));
14008 printf (_("Attribute Section: "));
14009 print_symbol (INT_MAX
, (const char *) p
);
14012 if (public_name
&& streq ((char *) p
, public_name
))
14013 public_section
= TRUE
;
14015 public_section
= FALSE
;
14017 if (streq ((char *) p
, "gnu"))
14018 gnu_section
= TRUE
;
14020 gnu_section
= FALSE
;
14023 attr_len
-= namelen
;
14025 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14030 unsigned char * end
;
14032 /* PR binutils/17531: Safe handling of corrupt files. */
14035 error (_("Unused bytes at end of section\n"));
14041 size
= byte_get (p
, 4);
14042 if (size
> attr_len
)
14044 error (_("Bad subsection length (%u > %u)\n"),
14045 (unsigned) size
, (unsigned) attr_len
);
14048 /* PR binutils/17531: Safe handling of corrupt files. */
14051 error (_("Bad subsection length (%u < 6)\n"),
14058 end
= p
+ size
- 1;
14059 assert (end
<= contents
+ sect
->sh_size
);
14065 printf (_("File Attributes\n"));
14068 printf (_("Section Attributes:"));
14071 printf (_("Symbol Attributes:"));
14077 val
= read_uleb128 (p
, &j
, end
);
14081 printf (" %d", val
);
14086 printf (_("Unknown tag: %d\n"), tag
);
14087 public_section
= FALSE
;
14091 if (public_section
&& display_pub_attribute
!= NULL
)
14094 p
= display_pub_attribute (p
, end
);
14097 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14100 p
= display_gnu_attribute (p
,
14101 display_proc_gnu_attribute
,
14107 printf (_(" Unknown attribute:\n"));
14108 display_raw_attribute (p
, end
);
14117 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
14125 process_arm_specific (FILE * file
)
14127 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
14128 display_arm_attribute
, NULL
);
14132 process_power_specific (FILE * file
)
14134 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14135 display_power_gnu_attribute
);
14139 process_s390_specific (FILE * file
)
14141 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14142 display_s390_gnu_attribute
);
14146 process_sparc_specific (FILE * file
)
14148 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14149 display_sparc_gnu_attribute
);
14153 process_tic6x_specific (FILE * file
)
14155 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
14156 display_tic6x_attribute
, NULL
);
14160 process_msp430x_specific (FILE * file
)
14162 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
14163 display_msp430x_attribute
, NULL
);
14166 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14167 Print the Address, Access and Initial fields of an entry at VMA ADDR
14168 and return the VMA of the next entry, or -1 if there was a problem.
14169 Does not read from DATA_END or beyond. */
14172 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14173 unsigned char * data_end
)
14176 print_vma (addr
, LONG_HEX
);
14178 if (addr
< pltgot
+ 0xfff0)
14179 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14181 printf ("%10s", "");
14184 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14188 unsigned char * from
= data
+ addr
- pltgot
;
14190 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14192 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14193 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14194 return (bfd_vma
) -1;
14198 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14199 print_vma (entry
, LONG_HEX
);
14202 return addr
+ (is_32bit_elf
? 4 : 8);
14205 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14206 PLTGOT. Print the Address and Initial fields of an entry at VMA
14207 ADDR and return the VMA of the next entry. */
14210 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14213 print_vma (addr
, LONG_HEX
);
14216 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14221 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14222 print_vma (entry
, LONG_HEX
);
14224 return addr
+ (is_32bit_elf
? 4 : 8);
14228 print_mips_ases (unsigned int mask
)
14230 if (mask
& AFL_ASE_DSP
)
14231 fputs ("\n\tDSP ASE", stdout
);
14232 if (mask
& AFL_ASE_DSPR2
)
14233 fputs ("\n\tDSP R2 ASE", stdout
);
14234 if (mask
& AFL_ASE_DSPR3
)
14235 fputs ("\n\tDSP R3 ASE", stdout
);
14236 if (mask
& AFL_ASE_EVA
)
14237 fputs ("\n\tEnhanced VA Scheme", stdout
);
14238 if (mask
& AFL_ASE_MCU
)
14239 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14240 if (mask
& AFL_ASE_MDMX
)
14241 fputs ("\n\tMDMX ASE", stdout
);
14242 if (mask
& AFL_ASE_MIPS3D
)
14243 fputs ("\n\tMIPS-3D ASE", stdout
);
14244 if (mask
& AFL_ASE_MT
)
14245 fputs ("\n\tMT ASE", stdout
);
14246 if (mask
& AFL_ASE_SMARTMIPS
)
14247 fputs ("\n\tSmartMIPS ASE", stdout
);
14248 if (mask
& AFL_ASE_VIRT
)
14249 fputs ("\n\tVZ ASE", stdout
);
14250 if (mask
& AFL_ASE_MSA
)
14251 fputs ("\n\tMSA ASE", stdout
);
14252 if (mask
& AFL_ASE_MIPS16
)
14253 fputs ("\n\tMIPS16 ASE", stdout
);
14254 if (mask
& AFL_ASE_MICROMIPS
)
14255 fputs ("\n\tMICROMIPS ASE", stdout
);
14256 if (mask
& AFL_ASE_XPA
)
14257 fputs ("\n\tXPA ASE", stdout
);
14259 fprintf (stdout
, "\n\t%s", _("None"));
14260 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14261 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14265 print_mips_isa_ext (unsigned int isa_ext
)
14270 fputs (_("None"), stdout
);
14273 fputs ("RMI XLR", stdout
);
14275 case AFL_EXT_OCTEON3
:
14276 fputs ("Cavium Networks Octeon3", stdout
);
14278 case AFL_EXT_OCTEON2
:
14279 fputs ("Cavium Networks Octeon2", stdout
);
14281 case AFL_EXT_OCTEONP
:
14282 fputs ("Cavium Networks OcteonP", stdout
);
14284 case AFL_EXT_LOONGSON_3A
:
14285 fputs ("Loongson 3A", stdout
);
14287 case AFL_EXT_OCTEON
:
14288 fputs ("Cavium Networks Octeon", stdout
);
14291 fputs ("Toshiba R5900", stdout
);
14294 fputs ("MIPS R4650", stdout
);
14297 fputs ("LSI R4010", stdout
);
14300 fputs ("NEC VR4100", stdout
);
14303 fputs ("Toshiba R3900", stdout
);
14305 case AFL_EXT_10000
:
14306 fputs ("MIPS R10000", stdout
);
14309 fputs ("Broadcom SB-1", stdout
);
14312 fputs ("NEC VR4111/VR4181", stdout
);
14315 fputs ("NEC VR4120", stdout
);
14318 fputs ("NEC VR5400", stdout
);
14321 fputs ("NEC VR5500", stdout
);
14323 case AFL_EXT_LOONGSON_2E
:
14324 fputs ("ST Microelectronics Loongson 2E", stdout
);
14326 case AFL_EXT_LOONGSON_2F
:
14327 fputs ("ST Microelectronics Loongson 2F", stdout
);
14330 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14335 get_mips_reg_size (int reg_size
)
14337 return (reg_size
== AFL_REG_NONE
) ? 0
14338 : (reg_size
== AFL_REG_32
) ? 32
14339 : (reg_size
== AFL_REG_64
) ? 64
14340 : (reg_size
== AFL_REG_128
) ? 128
14345 process_mips_specific (FILE * file
)
14347 Elf_Internal_Dyn
* entry
;
14348 Elf_Internal_Shdr
*sect
= NULL
;
14349 size_t liblist_offset
= 0;
14350 size_t liblistno
= 0;
14351 size_t conflictsno
= 0;
14352 size_t options_offset
= 0;
14353 size_t conflicts_offset
= 0;
14354 size_t pltrelsz
= 0;
14356 bfd_vma pltgot
= 0;
14357 bfd_vma mips_pltgot
= 0;
14358 bfd_vma jmprel
= 0;
14359 bfd_vma local_gotno
= 0;
14360 bfd_vma gotsym
= 0;
14361 bfd_vma symtabno
= 0;
14363 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14364 display_mips_gnu_attribute
);
14366 sect
= find_section (".MIPS.abiflags");
14370 Elf_External_ABIFlags_v0
*abiflags_ext
;
14371 Elf_Internal_ABIFlags_v0 abiflags_in
;
14373 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14374 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14377 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14378 sect
->sh_size
, _("MIPS ABI Flags section"));
14381 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14382 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14383 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14384 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14385 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14386 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14387 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14388 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14389 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14390 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14391 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14393 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14394 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14395 if (abiflags_in
.isa_rev
> 1)
14396 printf ("r%d", abiflags_in
.isa_rev
);
14397 printf ("\nGPR size: %d",
14398 get_mips_reg_size (abiflags_in
.gpr_size
));
14399 printf ("\nCPR1 size: %d",
14400 get_mips_reg_size (abiflags_in
.cpr1_size
));
14401 printf ("\nCPR2 size: %d",
14402 get_mips_reg_size (abiflags_in
.cpr2_size
));
14403 fputs ("\nFP ABI: ", stdout
);
14404 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14405 fputs ("ISA Extension: ", stdout
);
14406 print_mips_isa_ext (abiflags_in
.isa_ext
);
14407 fputs ("\nASEs:", stdout
);
14408 print_mips_ases (abiflags_in
.ases
);
14409 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14410 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14411 fputc ('\n', stdout
);
14412 free (abiflags_ext
);
14417 /* We have a lot of special sections. Thanks SGI! */
14418 if (dynamic_section
== NULL
)
14419 /* No information available. */
14422 for (entry
= dynamic_section
;
14423 /* PR 17531 file: 012-50589-0.004. */
14424 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14426 switch (entry
->d_tag
)
14428 case DT_MIPS_LIBLIST
:
14430 = offset_from_vma (file
, entry
->d_un
.d_val
,
14431 liblistno
* sizeof (Elf32_External_Lib
));
14433 case DT_MIPS_LIBLISTNO
:
14434 liblistno
= entry
->d_un
.d_val
;
14436 case DT_MIPS_OPTIONS
:
14437 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14439 case DT_MIPS_CONFLICT
:
14441 = offset_from_vma (file
, entry
->d_un
.d_val
,
14442 conflictsno
* sizeof (Elf32_External_Conflict
));
14444 case DT_MIPS_CONFLICTNO
:
14445 conflictsno
= entry
->d_un
.d_val
;
14448 pltgot
= entry
->d_un
.d_ptr
;
14450 case DT_MIPS_LOCAL_GOTNO
:
14451 local_gotno
= entry
->d_un
.d_val
;
14453 case DT_MIPS_GOTSYM
:
14454 gotsym
= entry
->d_un
.d_val
;
14456 case DT_MIPS_SYMTABNO
:
14457 symtabno
= entry
->d_un
.d_val
;
14459 case DT_MIPS_PLTGOT
:
14460 mips_pltgot
= entry
->d_un
.d_ptr
;
14463 pltrel
= entry
->d_un
.d_val
;
14466 pltrelsz
= entry
->d_un
.d_val
;
14469 jmprel
= entry
->d_un
.d_ptr
;
14475 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14477 Elf32_External_Lib
* elib
;
14480 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14482 sizeof (Elf32_External_Lib
),
14483 _("liblist section data"));
14486 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14487 (unsigned long) liblistno
);
14488 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14491 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14498 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14499 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14500 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14501 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14502 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14504 tmp
= gmtime (&atime
);
14505 snprintf (timebuf
, sizeof (timebuf
),
14506 "%04u-%02u-%02uT%02u:%02u:%02u",
14507 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14508 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14510 printf ("%3lu: ", (unsigned long) cnt
);
14511 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14512 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14514 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14515 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14516 liblist
.l_version
);
14518 if (liblist
.l_flags
== 0)
14522 static const struct
14529 { " EXACT_MATCH", LL_EXACT_MATCH
},
14530 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14531 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14532 { " EXPORTS", LL_EXPORTS
},
14533 { " DELAY_LOAD", LL_DELAY_LOAD
},
14534 { " DELTA", LL_DELTA
}
14536 int flags
= liblist
.l_flags
;
14539 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14540 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14542 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14543 flags
^= l_flags_vals
[fcnt
].bit
;
14546 printf (" %#x", (unsigned int) flags
);
14556 if (options_offset
!= 0)
14558 Elf_External_Options
* eopt
;
14559 Elf_Internal_Options
* iopt
;
14560 Elf_Internal_Options
* option
;
14563 sect
= section_headers
;
14565 /* Find the section header so that we get the size. */
14566 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14567 /* PR 17533 file: 012-277276-0.004. */
14570 error (_("No MIPS_OPTIONS header found\n"));
14574 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14575 sect
->sh_size
, _("options"));
14578 iopt
= (Elf_Internal_Options
*)
14579 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14582 error (_("Out of memory allocatinf space for MIPS options\n"));
14589 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14591 Elf_External_Options
* eoption
;
14593 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14595 option
->kind
= BYTE_GET (eoption
->kind
);
14596 option
->size
= BYTE_GET (eoption
->size
);
14597 option
->section
= BYTE_GET (eoption
->section
);
14598 option
->info
= BYTE_GET (eoption
->info
);
14600 /* PR 17531: file: ffa0fa3b. */
14601 if (option
->size
< sizeof (* eopt
)
14602 || offset
+ option
->size
> sect
->sh_size
)
14604 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14607 offset
+= option
->size
;
14613 printf (_("\nSection '%s' contains %d entries:\n"),
14614 printable_section_name (sect
), cnt
);
14623 switch (option
->kind
)
14626 /* This shouldn't happen. */
14627 printf (" NULL %d %lx", option
->section
, option
->info
);
14630 printf (" REGINFO ");
14631 if (elf_header
.e_machine
== EM_MIPS
)
14634 Elf32_External_RegInfo
* ereg
;
14635 Elf32_RegInfo reginfo
;
14637 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14638 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14639 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14640 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14641 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14642 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14643 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14645 printf ("GPR %08lx GP 0x%lx\n",
14646 reginfo
.ri_gprmask
,
14647 (unsigned long) reginfo
.ri_gp_value
);
14648 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14649 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14650 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14655 Elf64_External_RegInfo
* ereg
;
14656 Elf64_Internal_RegInfo reginfo
;
14658 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14659 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14660 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14661 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14662 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14663 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14664 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14666 printf ("GPR %08lx GP 0x",
14667 reginfo
.ri_gprmask
);
14668 printf_vma (reginfo
.ri_gp_value
);
14671 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14672 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14673 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14677 case ODK_EXCEPTIONS
:
14678 fputs (" EXCEPTIONS fpe_min(", stdout
);
14679 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14680 fputs (") fpe_max(", stdout
);
14681 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14682 fputs (")", stdout
);
14684 if (option
->info
& OEX_PAGE0
)
14685 fputs (" PAGE0", stdout
);
14686 if (option
->info
& OEX_SMM
)
14687 fputs (" SMM", stdout
);
14688 if (option
->info
& OEX_FPDBUG
)
14689 fputs (" FPDBUG", stdout
);
14690 if (option
->info
& OEX_DISMISS
)
14691 fputs (" DISMISS", stdout
);
14694 fputs (" PAD ", stdout
);
14695 if (option
->info
& OPAD_PREFIX
)
14696 fputs (" PREFIX", stdout
);
14697 if (option
->info
& OPAD_POSTFIX
)
14698 fputs (" POSTFIX", stdout
);
14699 if (option
->info
& OPAD_SYMBOL
)
14700 fputs (" SYMBOL", stdout
);
14703 fputs (" HWPATCH ", stdout
);
14704 if (option
->info
& OHW_R4KEOP
)
14705 fputs (" R4KEOP", stdout
);
14706 if (option
->info
& OHW_R8KPFETCH
)
14707 fputs (" R8KPFETCH", stdout
);
14708 if (option
->info
& OHW_R5KEOP
)
14709 fputs (" R5KEOP", stdout
);
14710 if (option
->info
& OHW_R5KCVTL
)
14711 fputs (" R5KCVTL", stdout
);
14714 fputs (" FILL ", stdout
);
14715 /* XXX Print content of info word? */
14718 fputs (" TAGS ", stdout
);
14719 /* XXX Print content of info word? */
14722 fputs (" HWAND ", stdout
);
14723 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14724 fputs (" R4KEOP_CHECKED", stdout
);
14725 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14726 fputs (" R4KEOP_CLEAN", stdout
);
14729 fputs (" HWOR ", stdout
);
14730 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14731 fputs (" R4KEOP_CHECKED", stdout
);
14732 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14733 fputs (" R4KEOP_CLEAN", stdout
);
14736 printf (" GP_GROUP %#06lx self-contained %#06lx",
14737 option
->info
& OGP_GROUP
,
14738 (option
->info
& OGP_SELF
) >> 16);
14741 printf (" IDENT %#06lx self-contained %#06lx",
14742 option
->info
& OGP_GROUP
,
14743 (option
->info
& OGP_SELF
) >> 16);
14746 /* This shouldn't happen. */
14747 printf (" %3d ??? %d %lx",
14748 option
->kind
, option
->section
, option
->info
);
14752 len
= sizeof (* eopt
);
14753 while (len
< option
->size
)
14755 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14757 if (ISPRINT (datum
))
14758 printf ("%c", datum
);
14760 printf ("\\%03o", datum
);
14763 fputs ("\n", stdout
);
14765 offset
+= option
->size
;
14773 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14775 Elf32_Conflict
* iconf
;
14778 if (dynamic_symbols
== NULL
)
14780 error (_("conflict list found without a dynamic symbol table\n"));
14784 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14787 error (_("Out of memory allocating space for dynamic conflicts\n"));
14793 Elf32_External_Conflict
* econf32
;
14795 econf32
= (Elf32_External_Conflict
*)
14796 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14797 sizeof (* econf32
), _("conflict"));
14801 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14802 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14808 Elf64_External_Conflict
* econf64
;
14810 econf64
= (Elf64_External_Conflict
*)
14811 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14812 sizeof (* econf64
), _("conflict"));
14816 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14817 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14822 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14823 (unsigned long) conflictsno
);
14824 puts (_(" Num: Index Value Name"));
14826 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14828 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14830 if (iconf
[cnt
] >= num_dynamic_syms
)
14831 printf (_("<corrupt symbol index>"));
14834 Elf_Internal_Sym
* psym
;
14836 psym
= & dynamic_symbols
[iconf
[cnt
]];
14837 print_vma (psym
->st_value
, FULL_HEX
);
14839 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14840 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14842 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14850 if (pltgot
!= 0 && local_gotno
!= 0)
14852 bfd_vma ent
, local_end
, global_end
;
14854 unsigned char * data
;
14855 unsigned char * data_end
;
14859 addr_size
= (is_32bit_elf
? 4 : 8);
14860 local_end
= pltgot
+ local_gotno
* addr_size
;
14862 /* PR binutils/17533 file: 012-111227-0.004 */
14863 if (symtabno
< gotsym
)
14865 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14866 (unsigned long) gotsym
, (unsigned long) symtabno
);
14870 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14871 /* PR 17531: file: 54c91a34. */
14872 if (global_end
< local_end
)
14874 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14878 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14879 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14880 global_end
- pltgot
, 1,
14881 _("Global Offset Table data"));
14884 data_end
= data
+ (global_end
- pltgot
);
14886 printf (_("\nPrimary GOT:\n"));
14887 printf (_(" Canonical gp value: "));
14888 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14891 printf (_(" Reserved entries:\n"));
14892 printf (_(" %*s %10s %*s Purpose\n"),
14893 addr_size
* 2, _("Address"), _("Access"),
14894 addr_size
* 2, _("Initial"));
14895 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14896 printf (_(" Lazy resolver\n"));
14897 if (ent
== (bfd_vma
) -1)
14898 goto got_print_fail
;
14900 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14901 >> (addr_size
* 8 - 1)) != 0)
14903 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14904 printf (_(" Module pointer (GNU extension)\n"));
14905 if (ent
== (bfd_vma
) -1)
14906 goto got_print_fail
;
14910 if (ent
< local_end
)
14912 printf (_(" Local entries:\n"));
14913 printf (" %*s %10s %*s\n",
14914 addr_size
* 2, _("Address"), _("Access"),
14915 addr_size
* 2, _("Initial"));
14916 while (ent
< local_end
)
14918 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14920 if (ent
== (bfd_vma
) -1)
14921 goto got_print_fail
;
14926 if (gotsym
< symtabno
)
14930 printf (_(" Global entries:\n"));
14931 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14932 addr_size
* 2, _("Address"),
14934 addr_size
* 2, _("Initial"),
14935 addr_size
* 2, _("Sym.Val."),
14937 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14938 _("Ndx"), _("Name"));
14940 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14942 for (i
= gotsym
; i
< symtabno
; i
++)
14944 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14947 if (dynamic_symbols
== NULL
)
14948 printf (_("<no dynamic symbols>"));
14949 else if (i
< num_dynamic_syms
)
14951 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14953 print_vma (psym
->st_value
, LONG_HEX
);
14954 printf (" %-7s %3s ",
14955 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14956 get_symbol_index_type (psym
->st_shndx
));
14958 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14959 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14961 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14964 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14965 (unsigned long) i
);
14968 if (ent
== (bfd_vma
) -1)
14979 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14982 size_t offset
, rel_offset
;
14983 unsigned long count
, i
;
14984 unsigned char * data
;
14985 int addr_size
, sym_width
;
14986 Elf_Internal_Rela
* rels
;
14988 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14989 if (pltrel
== DT_RELA
)
14991 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14996 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15001 addr_size
= (is_32bit_elf
? 4 : 8);
15002 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15004 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15005 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15006 1, _("Procedure Linkage Table data"));
15010 printf ("\nPLT GOT:\n\n");
15011 printf (_(" Reserved entries:\n"));
15012 printf (_(" %*s %*s Purpose\n"),
15013 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15014 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15015 printf (_(" PLT lazy resolver\n"));
15016 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15017 printf (_(" Module pointer\n"));
15020 printf (_(" Entries:\n"));
15021 printf (" %*s %*s %*s %-7s %3s %s\n",
15022 addr_size
* 2, _("Address"),
15023 addr_size
* 2, _("Initial"),
15024 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15025 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15026 for (i
= 0; i
< count
; i
++)
15028 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15030 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15033 if (idx
>= num_dynamic_syms
)
15034 printf (_("<corrupt symbol index: %lu>"), idx
);
15037 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15039 print_vma (psym
->st_value
, LONG_HEX
);
15040 printf (" %-7s %3s ",
15041 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15042 get_symbol_index_type (psym
->st_shndx
));
15043 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15044 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15046 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15061 process_nds32_specific (FILE * file
)
15063 Elf_Internal_Shdr
*sect
= NULL
;
15065 sect
= find_section (".nds32_e_flags");
15068 unsigned int *flag
;
15070 printf ("\nNDS32 elf flags section:\n");
15071 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15072 sect
->sh_size
, _("NDS32 elf flags section"));
15074 switch ((*flag
) & 0x3)
15077 printf ("(VEC_SIZE):\tNo entry.\n");
15080 printf ("(VEC_SIZE):\t4 bytes\n");
15083 printf ("(VEC_SIZE):\t16 bytes\n");
15086 printf ("(VEC_SIZE):\treserved\n");
15095 process_gnu_liblist (FILE * file
)
15097 Elf_Internal_Shdr
* section
;
15098 Elf_Internal_Shdr
* string_sec
;
15099 Elf32_External_Lib
* elib
;
15101 size_t strtab_size
;
15108 for (i
= 0, section
= section_headers
;
15109 i
< elf_header
.e_shnum
;
15112 switch (section
->sh_type
)
15114 case SHT_GNU_LIBLIST
:
15115 if (section
->sh_link
>= elf_header
.e_shnum
)
15118 elib
= (Elf32_External_Lib
*)
15119 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15120 _("liblist section data"));
15124 string_sec
= section_headers
+ section
->sh_link
;
15126 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15127 string_sec
->sh_size
,
15128 _("liblist string table"));
15130 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15136 strtab_size
= string_sec
->sh_size
;
15138 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15139 printable_section_name (section
),
15140 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15142 puts (_(" Library Time Stamp Checksum Version Flags"));
15144 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15152 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15153 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15154 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15155 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15156 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15158 tmp
= gmtime (&atime
);
15159 snprintf (timebuf
, sizeof (timebuf
),
15160 "%04u-%02u-%02uT%02u:%02u:%02u",
15161 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15162 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15164 printf ("%3lu: ", (unsigned long) cnt
);
15166 printf ("%-20s", liblist
.l_name
< strtab_size
15167 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15169 printf ("%-20.20s", liblist
.l_name
< strtab_size
15170 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15171 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15172 liblist
.l_version
, liblist
.l_flags
);
15183 static const char *
15184 get_note_type (unsigned e_type
)
15186 static char buff
[64];
15188 if (elf_header
.e_type
== ET_CORE
)
15192 return _("NT_AUXV (auxiliary vector)");
15194 return _("NT_PRSTATUS (prstatus structure)");
15196 return _("NT_FPREGSET (floating point registers)");
15198 return _("NT_PRPSINFO (prpsinfo structure)");
15199 case NT_TASKSTRUCT
:
15200 return _("NT_TASKSTRUCT (task structure)");
15202 return _("NT_PRXFPREG (user_xfpregs structure)");
15204 return _("NT_PPC_VMX (ppc Altivec registers)");
15206 return _("NT_PPC_VSX (ppc VSX registers)");
15208 return _("NT_386_TLS (x86 TLS information)");
15209 case NT_386_IOPERM
:
15210 return _("NT_386_IOPERM (x86 I/O permissions)");
15211 case NT_X86_XSTATE
:
15212 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15213 case NT_S390_HIGH_GPRS
:
15214 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15215 case NT_S390_TIMER
:
15216 return _("NT_S390_TIMER (s390 timer register)");
15217 case NT_S390_TODCMP
:
15218 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15219 case NT_S390_TODPREG
:
15220 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15222 return _("NT_S390_CTRS (s390 control registers)");
15223 case NT_S390_PREFIX
:
15224 return _("NT_S390_PREFIX (s390 prefix register)");
15225 case NT_S390_LAST_BREAK
:
15226 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15227 case NT_S390_SYSTEM_CALL
:
15228 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15230 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15231 case NT_S390_VXRS_LOW
:
15232 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15233 case NT_S390_VXRS_HIGH
:
15234 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15236 return _("NT_ARM_VFP (arm VFP registers)");
15238 return _("NT_ARM_TLS (AArch TLS registers)");
15239 case NT_ARM_HW_BREAK
:
15240 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15241 case NT_ARM_HW_WATCH
:
15242 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15244 return _("NT_PSTATUS (pstatus structure)");
15246 return _("NT_FPREGS (floating point registers)");
15248 return _("NT_PSINFO (psinfo structure)");
15250 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15252 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15253 case NT_WIN32PSTATUS
:
15254 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15256 return _("NT_SIGINFO (siginfo_t data)");
15258 return _("NT_FILE (mapped files)");
15266 return _("NT_VERSION (version)");
15268 return _("NT_ARCH (architecture)");
15273 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15278 print_core_note (Elf_Internal_Note
*pnote
)
15280 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15281 bfd_vma count
, page_size
;
15282 unsigned char *descdata
, *filenames
, *descend
;
15284 if (pnote
->type
!= NT_FILE
)
15290 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15291 /* Still "successful". */
15296 if (pnote
->descsz
< 2 * addr_size
)
15298 printf (_(" Malformed note - too short for header\n"));
15302 descdata
= (unsigned char *) pnote
->descdata
;
15303 descend
= descdata
+ pnote
->descsz
;
15305 if (descdata
[pnote
->descsz
- 1] != '\0')
15307 printf (_(" Malformed note - does not end with \\0\n"));
15311 count
= byte_get (descdata
, addr_size
);
15312 descdata
+= addr_size
;
15314 page_size
= byte_get (descdata
, addr_size
);
15315 descdata
+= addr_size
;
15317 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15319 printf (_(" Malformed note - too short for supplied file count\n"));
15323 printf (_(" Page size: "));
15324 print_vma (page_size
, DEC
);
15327 printf (_(" %*s%*s%*s\n"),
15328 (int) (2 + 2 * addr_size
), _("Start"),
15329 (int) (4 + 2 * addr_size
), _("End"),
15330 (int) (4 + 2 * addr_size
), _("Page Offset"));
15331 filenames
= descdata
+ count
* 3 * addr_size
;
15332 while (count
-- > 0)
15334 bfd_vma start
, end
, file_ofs
;
15336 if (filenames
== descend
)
15338 printf (_(" Malformed note - filenames end too early\n"));
15342 start
= byte_get (descdata
, addr_size
);
15343 descdata
+= addr_size
;
15344 end
= byte_get (descdata
, addr_size
);
15345 descdata
+= addr_size
;
15346 file_ofs
= byte_get (descdata
, addr_size
);
15347 descdata
+= addr_size
;
15350 print_vma (start
, FULL_HEX
);
15352 print_vma (end
, FULL_HEX
);
15354 print_vma (file_ofs
, FULL_HEX
);
15355 printf ("\n %s\n", filenames
);
15357 filenames
+= 1 + strlen ((char *) filenames
);
15363 static const char *
15364 get_gnu_elf_note_type (unsigned e_type
)
15366 static char buff
[64];
15370 case NT_GNU_ABI_TAG
:
15371 return _("NT_GNU_ABI_TAG (ABI version tag)");
15373 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15374 case NT_GNU_BUILD_ID
:
15375 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15376 case NT_GNU_GOLD_VERSION
:
15377 return _("NT_GNU_GOLD_VERSION (gold version)");
15382 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15387 print_gnu_note (Elf_Internal_Note
*pnote
)
15389 switch (pnote
->type
)
15391 case NT_GNU_BUILD_ID
:
15395 printf (_(" Build ID: "));
15396 for (i
= 0; i
< pnote
->descsz
; ++i
)
15397 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15402 case NT_GNU_ABI_TAG
:
15404 unsigned long os
, major
, minor
, subminor
;
15405 const char *osname
;
15407 /* PR 17531: file: 030-599401-0.004. */
15408 if (pnote
->descsz
< 16)
15410 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15414 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15415 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15416 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15417 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15421 case GNU_ABI_TAG_LINUX
:
15424 case GNU_ABI_TAG_HURD
:
15427 case GNU_ABI_TAG_SOLARIS
:
15428 osname
= "Solaris";
15430 case GNU_ABI_TAG_FREEBSD
:
15431 osname
= "FreeBSD";
15433 case GNU_ABI_TAG_NETBSD
:
15436 case GNU_ABI_TAG_SYLLABLE
:
15437 osname
= "Syllable";
15439 case GNU_ABI_TAG_NACL
:
15443 osname
= "Unknown";
15447 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15448 major
, minor
, subminor
);
15452 case NT_GNU_GOLD_VERSION
:
15456 printf (_(" Version: "));
15457 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15458 printf ("%c", pnote
->descdata
[i
]);
15467 static const char *
15468 get_v850_elf_note_type (enum v850_notes n_type
)
15470 static char buff
[64];
15474 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15475 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15476 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15477 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15478 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15479 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15481 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15487 print_v850_note (Elf_Internal_Note
* pnote
)
15491 if (pnote
->descsz
!= 4)
15493 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15497 printf (_("not set\n"));
15501 switch (pnote
->type
)
15503 case V850_NOTE_ALIGNMENT
:
15506 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15507 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15511 case V850_NOTE_DATA_SIZE
:
15514 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15515 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15519 case V850_NOTE_FPU_INFO
:
15522 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15523 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15527 case V850_NOTE_MMU_INFO
:
15528 case V850_NOTE_CACHE_INFO
:
15529 case V850_NOTE_SIMD_INFO
:
15530 if (val
== EF_RH850_SIMD
)
15532 printf (_("yes\n"));
15538 /* An 'unknown note type' message will already have been displayed. */
15542 printf (_("unknown value: %x\n"), val
);
15547 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15549 unsigned int version
;
15551 switch (pnote
->type
)
15553 case NT_NETBSD_IDENT
:
15554 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15555 if ((version
/ 10000) % 100)
15556 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15557 version
, version
/ 100000000, (version
/ 1000000) % 100,
15558 (version
/ 10000) % 100 > 26 ? "Z" : "",
15559 'A' + (version
/ 10000) % 26);
15561 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15562 version
, version
/ 100000000, (version
/ 1000000) % 100,
15563 (version
/ 100) % 100);
15566 case NT_NETBSD_MARCH
:
15567 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15575 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15580 static const char *
15581 get_freebsd_elfcore_note_type (unsigned e_type
)
15585 case NT_FREEBSD_THRMISC
:
15586 return _("NT_THRMISC (thrmisc structure)");
15587 case NT_FREEBSD_PROCSTAT_PROC
:
15588 return _("NT_PROCSTAT_PROC (proc data)");
15589 case NT_FREEBSD_PROCSTAT_FILES
:
15590 return _("NT_PROCSTAT_FILES (files data)");
15591 case NT_FREEBSD_PROCSTAT_VMMAP
:
15592 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15593 case NT_FREEBSD_PROCSTAT_GROUPS
:
15594 return _("NT_PROCSTAT_GROUPS (groups data)");
15595 case NT_FREEBSD_PROCSTAT_UMASK
:
15596 return _("NT_PROCSTAT_UMASK (umask data)");
15597 case NT_FREEBSD_PROCSTAT_RLIMIT
:
15598 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15599 case NT_FREEBSD_PROCSTAT_OSREL
:
15600 return _("NT_PROCSTAT_OSREL (osreldate data)");
15601 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
15602 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15603 case NT_FREEBSD_PROCSTAT_AUXV
:
15604 return _("NT_PROCSTAT_AUXV (auxv data)");
15606 return get_note_type (e_type
);
15609 static const char *
15610 get_netbsd_elfcore_note_type (unsigned e_type
)
15612 static char buff
[64];
15614 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15616 /* NetBSD core "procinfo" structure. */
15617 return _("NetBSD procinfo structure");
15620 /* As of Jan 2002 there are no other machine-independent notes
15621 defined for NetBSD core files. If the note type is less
15622 than the start of the machine-dependent note types, we don't
15625 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15627 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15631 switch (elf_header
.e_machine
)
15633 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15634 and PT_GETFPREGS == mach+2. */
15639 case EM_SPARC32PLUS
:
15643 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15644 return _("PT_GETREGS (reg structure)");
15645 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15646 return _("PT_GETFPREGS (fpreg structure)");
15652 /* On all other arch's, PT_GETREGS == mach+1 and
15653 PT_GETFPREGS == mach+3. */
15657 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15658 return _("PT_GETREGS (reg structure)");
15659 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15660 return _("PT_GETFPREGS (fpreg structure)");
15666 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15667 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15671 static const char *
15672 get_stapsdt_note_type (unsigned e_type
)
15674 static char buff
[64];
15679 return _("NT_STAPSDT (SystemTap probe descriptors)");
15685 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15690 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15692 int addr_size
= is_32bit_elf
? 4 : 8;
15693 char *data
= pnote
->descdata
;
15694 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15695 bfd_vma pc
, base_addr
, semaphore
;
15696 char *provider
, *probe
, *arg_fmt
;
15698 pc
= byte_get ((unsigned char *) data
, addr_size
);
15700 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15702 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15706 data
+= strlen (data
) + 1;
15708 data
+= strlen (data
) + 1;
15710 data
+= strlen (data
) + 1;
15712 printf (_(" Provider: %s\n"), provider
);
15713 printf (_(" Name: %s\n"), probe
);
15714 printf (_(" Location: "));
15715 print_vma (pc
, FULL_HEX
);
15716 printf (_(", Base: "));
15717 print_vma (base_addr
, FULL_HEX
);
15718 printf (_(", Semaphore: "));
15719 print_vma (semaphore
, FULL_HEX
);
15721 printf (_(" Arguments: %s\n"), arg_fmt
);
15723 return data
== data_end
;
15726 static const char *
15727 get_ia64_vms_note_type (unsigned e_type
)
15729 static char buff
[64];
15734 return _("NT_VMS_MHD (module header)");
15736 return _("NT_VMS_LNM (language name)");
15738 return _("NT_VMS_SRC (source files)");
15740 return "NT_VMS_TITLE";
15742 return _("NT_VMS_EIDC (consistency check)");
15743 case NT_VMS_FPMODE
:
15744 return _("NT_VMS_FPMODE (FP mode)");
15745 case NT_VMS_LINKTIME
:
15746 return "NT_VMS_LINKTIME";
15747 case NT_VMS_IMGNAM
:
15748 return _("NT_VMS_IMGNAM (image name)");
15750 return _("NT_VMS_IMGID (image id)");
15751 case NT_VMS_LINKID
:
15752 return _("NT_VMS_LINKID (link id)");
15753 case NT_VMS_IMGBID
:
15754 return _("NT_VMS_IMGBID (build id)");
15755 case NT_VMS_GSTNAM
:
15756 return _("NT_VMS_GSTNAM (sym table name)");
15757 case NT_VMS_ORIG_DYN
:
15758 return "NT_VMS_ORIG_DYN";
15759 case NT_VMS_PATCHTIME
:
15760 return "NT_VMS_PATCHTIME";
15762 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15768 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15770 switch (pnote
->type
)
15773 if (pnote
->descsz
> 36)
15775 size_t l
= strlen (pnote
->descdata
+ 34);
15776 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15777 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15778 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15779 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15782 printf (_(" Invalid size\n"));
15785 printf (_(" Language: %s\n"), pnote
->descdata
);
15788 case NT_VMS_FPMODE
:
15789 printf (_(" Floating Point mode: "));
15790 printf ("0x%016" BFD_VMA_FMT
"x\n",
15791 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15793 case NT_VMS_LINKTIME
:
15794 printf (_(" Link time: "));
15796 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15799 case NT_VMS_PATCHTIME
:
15800 printf (_(" Patch time: "));
15802 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15805 case NT_VMS_ORIG_DYN
:
15806 printf (_(" Major id: %u, minor id: %u\n"),
15807 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15808 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15809 printf (_(" Last modified : "));
15811 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15812 printf (_("\n Link flags : "));
15813 printf ("0x%016" BFD_VMA_FMT
"x\n",
15814 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15815 printf (_(" Header flags: 0x%08x\n"),
15816 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15817 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15820 case NT_VMS_IMGNAM
:
15821 printf (_(" Image name: %s\n"), pnote
->descdata
);
15823 case NT_VMS_GSTNAM
:
15824 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15827 printf (_(" Image id: %s\n"), pnote
->descdata
);
15829 case NT_VMS_LINKID
:
15830 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15838 /* Note that by the ELF standard, the name field is already null byte
15839 terminated, and namesz includes the terminating null byte.
15840 I.E. the value of namesz for the name "FSF" is 4.
15842 If the value of namesz is zero, there is no name present. */
15844 process_note (Elf_Internal_Note
* pnote
)
15846 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15849 if (pnote
->namesz
== 0)
15850 /* If there is no note name, then use the default set of
15851 note type strings. */
15852 nt
= get_note_type (pnote
->type
);
15854 else if (const_strneq (pnote
->namedata
, "GNU"))
15855 /* GNU-specific object file notes. */
15856 nt
= get_gnu_elf_note_type (pnote
->type
);
15858 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
15859 /* FreeBSD-specific core file notes. */
15860 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
15862 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15863 /* NetBSD-specific core file notes. */
15864 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15866 else if (const_strneq (pnote
->namedata
, "NetBSD"))
15867 /* NetBSD-specific core file notes. */
15868 return process_netbsd_elf_note (pnote
);
15870 else if (strneq (pnote
->namedata
, "SPU/", 4))
15872 /* SPU-specific core file notes. */
15873 nt
= pnote
->namedata
+ 4;
15877 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15878 /* VMS/ia64-specific file notes. */
15879 nt
= get_ia64_vms_note_type (pnote
->type
);
15881 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15882 nt
= get_stapsdt_note_type (pnote
->type
);
15885 /* Don't recognize this note name; just use the default set of
15886 note type strings. */
15887 nt
= get_note_type (pnote
->type
);
15889 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15891 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15892 return print_ia64_vms_note (pnote
);
15893 else if (const_strneq (pnote
->namedata
, "GNU"))
15894 return print_gnu_note (pnote
);
15895 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15896 return print_stapsdt_note (pnote
);
15897 else if (const_strneq (pnote
->namedata
, "CORE"))
15898 return print_core_note (pnote
);
15905 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15907 Elf_External_Note
* pnotes
;
15908 Elf_External_Note
* external
;
15915 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15917 if (pnotes
== NULL
)
15922 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15923 (unsigned long) offset
, (unsigned long) length
);
15924 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15926 end
= (char *) pnotes
+ length
;
15927 while ((char *) external
< end
)
15929 Elf_Internal_Note inote
;
15932 char * temp
= NULL
;
15933 size_t data_remaining
= end
- (char *) external
;
15935 if (!is_ia64_vms ())
15937 /* PR binutils/15191
15938 Make sure that there is enough data to read. */
15939 min_notesz
= offsetof (Elf_External_Note
, name
);
15940 if (data_remaining
< min_notesz
)
15942 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15943 (int) data_remaining
);
15946 inote
.type
= BYTE_GET (external
->type
);
15947 inote
.namesz
= BYTE_GET (external
->namesz
);
15948 inote
.namedata
= external
->name
;
15949 inote
.descsz
= BYTE_GET (external
->descsz
);
15950 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15951 /* PR 17531: file: 3443835e. */
15952 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15954 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15955 inote
.descdata
= inote
.namedata
;
15959 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15960 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15964 Elf64_External_VMS_Note
*vms_external
;
15966 /* PR binutils/15191
15967 Make sure that there is enough data to read. */
15968 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15969 if (data_remaining
< min_notesz
)
15971 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15972 (int) data_remaining
);
15976 vms_external
= (Elf64_External_VMS_Note
*) external
;
15977 inote
.type
= BYTE_GET (vms_external
->type
);
15978 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15979 inote
.namedata
= vms_external
->name
;
15980 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15981 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15982 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15983 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15986 if (inote
.descdata
< (char *) external
+ min_notesz
15987 || next
< (char *) external
+ min_notesz
15988 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15989 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15990 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15991 || data_remaining
< (size_t)(next
- (char *) external
))
15993 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15994 (unsigned long) ((char *) external
- (char *) pnotes
));
15995 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15996 inote
.type
, inote
.namesz
, inote
.descsz
);
16000 external
= (Elf_External_Note
*) next
;
16002 /* Verify that name is null terminated. It appears that at least
16003 one version of Linux (RedHat 6.0) generates corefiles that don't
16004 comply with the ELF spec by failing to include the null byte in
16006 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
16008 temp
= (char *) malloc (inote
.namesz
+ 1);
16011 error (_("Out of memory allocating space for inote name\n"));
16016 strncpy (temp
, inote
.namedata
, inote
.namesz
);
16017 temp
[inote
.namesz
] = 0;
16019 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16020 inote
.namedata
= temp
;
16023 res
&= process_note (& inote
);
16038 process_corefile_note_segments (FILE * file
)
16040 Elf_Internal_Phdr
* segment
;
16044 if (! get_program_headers (file
))
16047 for (i
= 0, segment
= program_headers
;
16048 i
< elf_header
.e_phnum
;
16051 if (segment
->p_type
== PT_NOTE
)
16052 res
&= process_corefile_note_segment (file
,
16053 (bfd_vma
) segment
->p_offset
,
16054 (bfd_vma
) segment
->p_filesz
);
16061 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
16063 Elf_External_Note
* pnotes
;
16064 Elf_External_Note
* external
;
16071 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16073 if (pnotes
== NULL
)
16077 end
= (char*) pnotes
+ length
;
16079 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16080 (unsigned long) offset
, (unsigned long) length
);
16082 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
16084 Elf_External_Note
* next
;
16085 Elf_Internal_Note inote
;
16087 inote
.type
= BYTE_GET (external
->type
);
16088 inote
.namesz
= BYTE_GET (external
->namesz
);
16089 inote
.namedata
= external
->name
;
16090 inote
.descsz
= BYTE_GET (external
->descsz
);
16091 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16092 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16094 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
16096 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16097 inote
.descdata
= inote
.namedata
;
16101 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
16103 if ( ((char *) next
> end
)
16104 || ((char *) next
< (char *) pnotes
))
16106 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16107 (unsigned long) ((char *) external
- (char *) pnotes
));
16108 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16109 inote
.type
, inote
.namesz
, inote
.descsz
);
16115 /* Prevent out-of-bounds indexing. */
16116 if ( inote
.namedata
+ inote
.namesz
> end
16117 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
16119 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16120 (unsigned long) ((char *) external
- (char *) pnotes
));
16121 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16122 inote
.type
, inote
.namesz
, inote
.descsz
);
16126 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
16128 if (! print_v850_note (& inote
))
16131 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16132 inote
.namesz
, inote
.descsz
);
16142 process_note_sections (FILE * file
)
16144 Elf_Internal_Shdr
* section
;
16149 for (i
= 0, section
= section_headers
;
16150 i
< elf_header
.e_shnum
&& section
!= NULL
;
16153 if (section
->sh_type
== SHT_NOTE
)
16155 res
&= process_corefile_note_segment (file
,
16156 (bfd_vma
) section
->sh_offset
,
16157 (bfd_vma
) section
->sh_size
);
16161 if (( elf_header
.e_machine
== EM_V800
16162 || elf_header
.e_machine
== EM_V850
16163 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16164 && section
->sh_type
== SHT_RENESAS_INFO
)
16166 res
&= process_v850_notes (file
,
16167 (bfd_vma
) section
->sh_offset
,
16168 (bfd_vma
) section
->sh_size
);
16174 /* Try processing NOTE segments instead. */
16175 return process_corefile_note_segments (file
);
16181 process_notes (FILE * file
)
16183 /* If we have not been asked to display the notes then do nothing. */
16187 if (elf_header
.e_type
!= ET_CORE
)
16188 return process_note_sections (file
);
16190 /* No program headers means no NOTE segment. */
16191 if (elf_header
.e_phnum
> 0)
16192 return process_corefile_note_segments (file
);
16194 printf (_("No note segments present in the core file.\n"));
16199 process_arch_specific (FILE * file
)
16204 switch (elf_header
.e_machine
)
16207 return process_arm_specific (file
);
16209 case EM_MIPS_RS3_LE
:
16210 return process_mips_specific (file
);
16213 return process_nds32_specific (file
);
16216 return process_power_specific (file
);
16220 return process_s390_specific (file
);
16223 case EM_SPARC32PLUS
:
16225 return process_sparc_specific (file
);
16228 return process_tic6x_specific (file
);
16231 return process_msp430x_specific (file
);
16239 get_file_header (FILE * file
)
16241 /* Read in the identity array. */
16242 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16245 /* Determine how to read the rest of the header. */
16246 switch (elf_header
.e_ident
[EI_DATA
])
16248 default: /* fall through */
16249 case ELFDATANONE
: /* fall through */
16251 byte_get
= byte_get_little_endian
;
16252 byte_put
= byte_put_little_endian
;
16255 byte_get
= byte_get_big_endian
;
16256 byte_put
= byte_put_big_endian
;
16260 /* For now we only support 32 bit and 64 bit ELF files. */
16261 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16263 /* Read in the rest of the header. */
16266 Elf32_External_Ehdr ehdr32
;
16268 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16271 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16272 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16273 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16274 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16275 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16276 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16277 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16278 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16279 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16280 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16281 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16282 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16283 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16287 Elf64_External_Ehdr ehdr64
;
16289 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16290 we will not be able to cope with the 64bit data found in
16291 64 ELF files. Detect this now and abort before we start
16292 overwriting things. */
16293 if (sizeof (bfd_vma
) < 8)
16295 error (_("This instance of readelf has been built without support for a\n\
16296 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16300 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16303 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16304 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16305 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16306 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16307 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16308 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16309 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16310 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16311 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16312 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16313 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16314 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16315 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16318 if (elf_header
.e_shoff
)
16320 /* There may be some extensions in the first section header. Don't
16321 bomb if we can't read it. */
16323 get_32bit_section_headers (file
, TRUE
);
16325 get_64bit_section_headers (file
, TRUE
);
16331 /* Process one ELF object file according to the command line options.
16332 This file may actually be stored in an archive. The file is
16333 positioned at the start of the ELF object. */
16336 process_object (char * file_name
, FILE * file
)
16340 if (! get_file_header (file
))
16342 error (_("%s: Failed to read file header\n"), file_name
);
16346 /* Initialise per file variables. */
16347 for (i
= ARRAY_SIZE (version_info
); i
--;)
16348 version_info
[i
] = 0;
16350 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16351 dynamic_info
[i
] = 0;
16352 dynamic_info_DT_GNU_HASH
= 0;
16354 /* Process the file. */
16356 printf (_("\nFile: %s\n"), file_name
);
16358 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16359 Note we do this even if cmdline_dump_sects is empty because we
16360 must make sure that the dump_sets array is zeroed out before each
16361 object file is processed. */
16362 if (num_dump_sects
> num_cmdline_dump_sects
)
16363 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16365 if (num_cmdline_dump_sects
> 0)
16367 if (num_dump_sects
== 0)
16368 /* A sneaky way of allocating the dump_sects array. */
16369 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16371 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16372 memcpy (dump_sects
, cmdline_dump_sects
,
16373 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16376 if (! process_file_header ())
16379 if (! process_section_headers (file
))
16381 /* Without loaded section headers we cannot process lots of
16383 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16385 if (! do_using_dynamic
)
16386 do_syms
= do_dyn_syms
= do_reloc
= 0;
16389 if (! process_section_groups (file
))
16391 /* Without loaded section groups we cannot process unwind. */
16395 if (process_program_headers (file
))
16396 process_dynamic_section (file
);
16398 process_relocs (file
);
16400 process_unwind (file
);
16402 process_symbol_table (file
);
16404 process_syminfo (file
);
16406 process_version_sections (file
);
16408 process_section_contents (file
);
16410 process_notes (file
);
16412 process_gnu_liblist (file
);
16414 process_arch_specific (file
);
16416 if (program_headers
)
16418 free (program_headers
);
16419 program_headers
= NULL
;
16422 if (section_headers
)
16424 free (section_headers
);
16425 section_headers
= NULL
;
16430 free (string_table
);
16431 string_table
= NULL
;
16432 string_table_length
= 0;
16435 if (dynamic_strings
)
16437 free (dynamic_strings
);
16438 dynamic_strings
= NULL
;
16439 dynamic_strings_length
= 0;
16442 if (dynamic_symbols
)
16444 free (dynamic_symbols
);
16445 dynamic_symbols
= NULL
;
16446 num_dynamic_syms
= 0;
16449 if (dynamic_syminfo
)
16451 free (dynamic_syminfo
);
16452 dynamic_syminfo
= NULL
;
16455 if (dynamic_section
)
16457 free (dynamic_section
);
16458 dynamic_section
= NULL
;
16461 if (section_headers_groups
)
16463 free (section_headers_groups
);
16464 section_headers_groups
= NULL
;
16467 if (section_groups
)
16469 struct group_list
* g
;
16470 struct group_list
* next
;
16472 for (i
= 0; i
< group_count
; i
++)
16474 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16481 free (section_groups
);
16482 section_groups
= NULL
;
16485 free_debug_memory ();
16490 /* Process an ELF archive.
16491 On entry the file is positioned just after the ARMAG string. */
16494 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16496 struct archive_info arch
;
16497 struct archive_info nested_arch
;
16503 /* The ARCH structure is used to hold information about this archive. */
16504 arch
.file_name
= NULL
;
16506 arch
.index_array
= NULL
;
16507 arch
.sym_table
= NULL
;
16508 arch
.longnames
= NULL
;
16510 /* The NESTED_ARCH structure is used as a single-item cache of information
16511 about a nested archive (when members of a thin archive reside within
16512 another regular archive file). */
16513 nested_arch
.file_name
= NULL
;
16514 nested_arch
.file
= NULL
;
16515 nested_arch
.index_array
= NULL
;
16516 nested_arch
.sym_table
= NULL
;
16517 nested_arch
.longnames
= NULL
;
16519 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16525 if (do_archive_index
)
16527 if (arch
.sym_table
== NULL
)
16528 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16531 unsigned long i
, l
;
16532 unsigned long current_pos
;
16534 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16535 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16536 current_pos
= ftell (file
);
16538 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16540 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16542 char * member_name
;
16544 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16546 if (member_name
!= NULL
)
16548 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16550 if (qualified_name
!= NULL
)
16552 printf (_("Contents of binary %s at offset "), qualified_name
);
16553 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16555 free (qualified_name
);
16560 if (l
>= arch
.sym_size
)
16562 error (_("%s: end of the symbol table reached before the end of the index\n"),
16566 /* PR 17531: file: 0b6630b2. */
16567 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16568 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16571 if (arch
.uses_64bit_indicies
)
16576 if (l
< arch
.sym_size
)
16577 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16578 file_name
, arch
.sym_size
- l
);
16580 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16582 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16588 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16589 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16590 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16591 && !do_section_groups
&& !do_dyn_syms
)
16593 ret
= 0; /* Archive index only. */
16604 char * qualified_name
;
16606 /* Read the next archive header. */
16607 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16609 error (_("%s: failed to seek to next archive header\n"), file_name
);
16612 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16613 if (got
!= sizeof arch
.arhdr
)
16617 error (_("%s: failed to read archive header\n"), file_name
);
16621 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16623 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16628 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16630 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16631 if (archive_file_size
& 01)
16632 ++archive_file_size
;
16634 name
= get_archive_member_name (&arch
, &nested_arch
);
16637 error (_("%s: bad archive file name\n"), file_name
);
16641 namelen
= strlen (name
);
16643 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16644 if (qualified_name
== NULL
)
16646 error (_("%s: bad archive file name\n"), file_name
);
16651 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16653 /* This is a proxy for an external member of a thin archive. */
16654 FILE * member_file
;
16655 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16656 if (member_file_name
== NULL
)
16662 member_file
= fopen (member_file_name
, "rb");
16663 if (member_file
== NULL
)
16665 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16666 free (member_file_name
);
16671 archive_file_offset
= arch
.nested_member_origin
;
16673 ret
|= process_object (qualified_name
, member_file
);
16675 fclose (member_file
);
16676 free (member_file_name
);
16678 else if (is_thin_archive
)
16680 /* PR 15140: Allow for corrupt thin archives. */
16681 if (nested_arch
.file
== NULL
)
16683 error (_("%s: contains corrupt thin archive: %s\n"),
16689 /* This is a proxy for a member of a nested archive. */
16690 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16692 /* The nested archive file will have been opened and setup by
16693 get_archive_member_name. */
16694 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16696 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16701 ret
|= process_object (qualified_name
, nested_arch
.file
);
16705 archive_file_offset
= arch
.next_arhdr_offset
;
16706 arch
.next_arhdr_offset
+= archive_file_size
;
16708 ret
|= process_object (qualified_name
, file
);
16711 if (dump_sects
!= NULL
)
16715 num_dump_sects
= 0;
16718 free (qualified_name
);
16722 if (nested_arch
.file
!= NULL
)
16723 fclose (nested_arch
.file
);
16724 release_archive (&nested_arch
);
16725 release_archive (&arch
);
16731 process_file (char * file_name
)
16734 struct stat statbuf
;
16735 char armag
[SARMAG
];
16738 if (stat (file_name
, &statbuf
) < 0)
16740 if (errno
== ENOENT
)
16741 error (_("'%s': No such file\n"), file_name
);
16743 error (_("Could not locate '%s'. System error message: %s\n"),
16744 file_name
, strerror (errno
));
16748 if (! S_ISREG (statbuf
.st_mode
))
16750 error (_("'%s' is not an ordinary file\n"), file_name
);
16754 file
= fopen (file_name
, "rb");
16757 error (_("Input file '%s' is not readable.\n"), file_name
);
16761 if (fread (armag
, SARMAG
, 1, file
) != 1)
16763 error (_("%s: Failed to read file's magic number\n"), file_name
);
16768 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16770 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16771 ret
= process_archive (file_name
, file
, FALSE
);
16772 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16773 ret
= process_archive (file_name
, file
, TRUE
);
16776 if (do_archive_index
)
16777 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16781 archive_file_size
= archive_file_offset
= 0;
16782 ret
= process_object (file_name
, file
);
16787 current_file_size
= 0;
16791 #ifdef SUPPORT_DISASSEMBLY
16792 /* Needed by the i386 disassembler. For extra credit, someone could
16793 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16797 print_address (unsigned int addr
, FILE * outfile
)
16799 fprintf (outfile
,"0x%8.8x", addr
);
16802 /* Needed by the i386 disassembler. */
16804 db_task_printsym (unsigned int addr
)
16806 print_address (addr
, stderr
);
16811 main (int argc
, char ** argv
)
16815 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16816 setlocale (LC_MESSAGES
, "");
16818 #if defined (HAVE_SETLOCALE)
16819 setlocale (LC_CTYPE
, "");
16821 bindtextdomain (PACKAGE
, LOCALEDIR
);
16822 textdomain (PACKAGE
);
16824 expandargv (&argc
, &argv
);
16826 parse_args (argc
, argv
);
16828 if (num_dump_sects
> 0)
16830 /* Make a copy of the dump_sects array. */
16831 cmdline_dump_sects
= (dump_type
*)
16832 malloc (num_dump_sects
* sizeof (* dump_sects
));
16833 if (cmdline_dump_sects
== NULL
)
16834 error (_("Out of memory allocating dump request table.\n"));
16837 memcpy (cmdline_dump_sects
, dump_sects
,
16838 num_dump_sects
* sizeof (* dump_sects
));
16839 num_cmdline_dump_sects
= num_dump_sects
;
16843 if (optind
< (argc
- 1))
16845 else if (optind
>= argc
)
16847 warn (_("Nothing to do.\n"));
16852 while (optind
< argc
)
16853 err
|= process_file (argv
[optind
++]);
16855 if (dump_sects
!= NULL
)
16857 if (cmdline_dump_sects
!= NULL
)
16858 free (cmdline_dump_sects
);