1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2016 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/mmix.h"
128 #include "elf/mn10200.h"
129 #include "elf/mn10300.h"
130 #include "elf/moxie.h"
132 #include "elf/msp430.h"
133 #include "elf/nds32.h"
134 #include "elf/nios2.h"
135 #include "elf/or1k.h"
138 #include "elf/ppc64.h"
139 #include "elf/rl78.h"
141 #include "elf/s390.h"
142 #include "elf/score.h"
144 #include "elf/sparc.h"
146 #include "elf/tic6x.h"
147 #include "elf/tilegx.h"
148 #include "elf/tilepro.h"
149 #include "elf/v850.h"
151 #include "elf/visium.h"
152 #include "elf/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167 typedef struct elf_section_list
169 Elf_Internal_Shdr
* hdr
;
170 struct elf_section_list
* next
;
173 char * program_name
= "readelf";
174 static unsigned long archive_file_offset
;
175 static unsigned long archive_file_size
;
176 static bfd_size_type current_file_size
;
177 static unsigned long dynamic_addr
;
178 static bfd_size_type dynamic_size
;
179 static size_t dynamic_nent
;
180 static char * dynamic_strings
;
181 static unsigned long dynamic_strings_length
;
182 static char * string_table
;
183 static unsigned long string_table_length
;
184 static unsigned long num_dynamic_syms
;
185 static Elf_Internal_Sym
* dynamic_symbols
;
186 static Elf_Internal_Syminfo
* dynamic_syminfo
;
187 static unsigned long dynamic_syminfo_offset
;
188 static unsigned int dynamic_syminfo_nent
;
189 static char program_interpreter
[PATH_MAX
];
190 static bfd_vma dynamic_info
[DT_ENCODING
];
191 static bfd_vma dynamic_info_DT_GNU_HASH
;
192 static bfd_vma version_info
[16];
193 static Elf_Internal_Ehdr elf_header
;
194 static Elf_Internal_Shdr
* section_headers
;
195 static Elf_Internal_Phdr
* program_headers
;
196 static Elf_Internal_Dyn
* dynamic_section
;
197 static elf_section_list
* symtab_shndx_list
;
198 static int show_name
;
199 static int do_dynamic
;
201 static int do_dyn_syms
;
203 static int do_sections
;
204 static int do_section_groups
;
205 static int do_section_details
;
206 static int do_segments
;
207 static int do_unwind
;
208 static int do_using_dynamic
;
209 static int do_header
;
211 static int do_version
;
212 static int do_histogram
;
213 static int do_debugging
;
216 static int do_archive_index
;
217 static int is_32bit_elf
;
218 static int decompress_dumps
;
222 struct group_list
* next
;
223 unsigned int section_index
;
228 struct group_list
* root
;
229 unsigned int group_index
;
232 static size_t group_count
;
233 static struct group
* section_groups
;
234 static struct group
** section_headers_groups
;
237 /* Flag bits indicating particular types of dump. */
238 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
239 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
240 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
241 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
242 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
244 typedef unsigned char dump_type
;
246 /* A linked list of the section names for which dumps were requested. */
247 struct dump_list_entry
251 struct dump_list_entry
* next
;
253 static struct dump_list_entry
* dump_sects_byname
;
255 /* A dynamic array of flags indicating for which sections a dump
256 has been requested via command line switches. */
257 static dump_type
* cmdline_dump_sects
= NULL
;
258 static unsigned int num_cmdline_dump_sects
= 0;
260 /* A dynamic array of flags indicating for which sections a dump of
261 some kind has been requested. It is reset on a per-object file
262 basis and then initialised from the cmdline_dump_sects array,
263 the results of interpreting the -w switch, and the
264 dump_sects_byname list. */
265 static dump_type
* dump_sects
= NULL
;
266 static unsigned int num_dump_sects
= 0;
269 /* How to print a vma value. */
270 typedef enum print_mode
282 /* Versioned symbol info. */
283 enum versioned_symbol_info
290 static const char *get_symbol_version_string
291 (FILE *file
, int is_dynsym
, const char *strtab
,
292 unsigned long int strtab_size
, unsigned int si
,
293 Elf_Internal_Sym
*psym
, enum versioned_symbol_info
*sym_info
,
294 unsigned short *vna_other
);
298 #define SECTION_NAME(X) \
299 ((X) == NULL ? _("<none>") \
300 : string_table == NULL ? _("<no-name>") \
301 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
302 : string_table + (X)->sh_name))
304 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
306 #define GET_ELF_SYMBOLS(file, section, sym_count) \
307 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
308 : get_64bit_elf_symbols (file, section, sym_count))
310 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
311 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
312 already been called and verified that the string exists. */
313 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
315 #define REMOVE_ARCH_BITS(ADDR) \
318 if (elf_header.e_machine == EM_ARM) \
323 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
324 the offset of the current archive member, if we are examining an archive.
325 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
326 using malloc and fill that. In either case return the pointer to the start of
327 the retrieved data or NULL if something went wrong. If something does go wrong
328 and REASON is not NULL then emit an error message using REASON as part of the
332 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
333 bfd_size_type nmemb
, const char * reason
)
336 bfd_size_type amt
= size
* nmemb
;
338 if (size
== 0 || nmemb
== 0)
341 /* If the size_t type is smaller than the bfd_size_type, eg because
342 you are building a 32-bit tool on a 64-bit host, then make sure
343 that when the sizes are cast to (size_t) no information is lost. */
344 if (sizeof (size_t) < sizeof (bfd_size_type
)
345 && ( (bfd_size_type
) ((size_t) size
) != size
346 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
349 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT
"x"
350 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
351 nmemb
, size
, reason
);
355 /* Check for size overflow. */
359 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT
"x"
360 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
361 nmemb
, size
, reason
);
365 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
366 attempting to allocate memory when the read is bound to fail. */
367 if (amt
> current_file_size
368 || offset
+ archive_file_offset
+ amt
> current_file_size
)
371 error (_("Reading 0x%" BFD_VMA_FMT
"x"
372 " bytes extends past end of file for %s\n"),
377 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
380 error (_("Unable to seek to 0x%lx for %s\n"),
381 archive_file_offset
+ offset
, reason
);
388 /* Check for overflow. */
389 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
390 /* + 1 so that we can '\0' terminate invalid string table sections. */
391 mvar
= malloc ((size_t) amt
+ 1);
396 error (_("Out of memory allocating 0x%" BFD_VMA_FMT
"x"
402 ((char *) mvar
)[amt
] = '\0';
405 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
408 error (_("Unable to read in 0x%" BFD_VMA_FMT
"x bytes of %s\n"),
418 /* Print a VMA value. */
421 print_vma (bfd_vma vma
, print_mode mode
)
434 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
441 return printf ("%5" BFD_VMA_FMT
"d", vma
);
449 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
452 return printf ("%" BFD_VMA_FMT
"d", vma
);
455 return printf ("%" BFD_VMA_FMT
"u", vma
);
460 /* Display a symbol on stdout. Handles the display of control characters and
461 multibye characters (assuming the host environment supports them).
463 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
465 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
466 padding as necessary.
468 Returns the number of emitted characters. */
471 print_symbol (int width
, const char *symbol
)
473 bfd_boolean extra_padding
= FALSE
;
475 #ifdef HAVE_MBSTATE_T
482 /* Keep the width positive. This also helps. */
484 extra_padding
= TRUE
;
489 /* Set the remaining width to a very large value.
490 This simplifies the code below. */
491 width_remaining
= INT_MAX
;
493 width_remaining
= width
;
495 #ifdef HAVE_MBSTATE_T
496 /* Initialise the multibyte conversion state. */
497 memset (& state
, 0, sizeof (state
));
500 while (width_remaining
)
503 const char c
= *symbol
++;
508 /* Do not print control characters directly as they can affect terminal
509 settings. Such characters usually appear in the names generated
510 by the assembler for local labels. */
513 if (width_remaining
< 2)
516 printf ("^%c", c
+ 0x40);
517 width_remaining
-= 2;
520 else if (ISPRINT (c
))
528 #ifdef HAVE_MBSTATE_T
531 /* Let printf do the hard work of displaying multibyte characters. */
532 printf ("%.1s", symbol
- 1);
536 #ifdef HAVE_MBSTATE_T
537 /* Try to find out how many bytes made up the character that was
538 just printed. Advance the symbol pointer past the bytes that
540 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
544 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
549 if (extra_padding
&& num_printed
< width
)
551 /* Fill in the remaining spaces. */
552 printf ("%-*s", width
- num_printed
, " ");
559 /* Returns a pointer to a static buffer containing a printable version of
560 the given section's name. Like print_symbol, except that it does not try
561 to print multibyte characters, it just interprets them as hex values. */
564 printable_section_name (const Elf_Internal_Shdr
* sec
)
566 #define MAX_PRINT_SEC_NAME_LEN 128
567 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
568 const char * name
= SECTION_NAME (sec
);
569 char * buf
= sec_name_buf
;
571 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
573 while ((c
= * name
++) != 0)
584 else if (ISPRINT (c
))
591 static char hex
[17] = "0123456789ABCDEF";
596 * buf
++ = hex
[(c
& 0xf0) >> 4];
597 * buf
++ = hex
[c
& 0x0f];
611 printable_section_name_from_index (unsigned long ndx
)
613 if (ndx
>= elf_header
.e_shnum
)
614 return _("<corrupt>");
616 return printable_section_name (section_headers
+ ndx
);
619 /* Return a pointer to section NAME, or NULL if no such section exists. */
621 static Elf_Internal_Shdr
*
622 find_section (const char * name
)
626 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
627 if (streq (SECTION_NAME (section_headers
+ i
), name
))
628 return section_headers
+ i
;
633 /* Return a pointer to a section containing ADDR, or NULL if no such
636 static Elf_Internal_Shdr
*
637 find_section_by_address (bfd_vma addr
)
641 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
643 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
644 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
651 static Elf_Internal_Shdr
*
652 find_section_by_type (unsigned int type
)
656 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
658 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
659 if (sec
->sh_type
== type
)
666 /* Return a pointer to section NAME, or NULL if no such section exists,
667 restricted to the list of sections given in SET. */
669 static Elf_Internal_Shdr
*
670 find_section_in_set (const char * name
, unsigned int * set
)
676 while ((i
= *set
++) > 0)
677 if (streq (SECTION_NAME (section_headers
+ i
), name
))
678 return section_headers
+ i
;
681 return find_section (name
);
684 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
687 static inline unsigned long
688 read_uleb128 (unsigned char *data
,
689 unsigned int *length_return
,
690 const unsigned char * const end
)
692 return read_leb128 (data
, length_return
, FALSE
, end
);
695 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
696 This OS has so many departures from the ELF standard that we test it at
702 return elf_header
.e_machine
== EM_IA_64
703 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
706 /* Guess the relocation size commonly used by the specific machines. */
709 guess_is_rela (unsigned int e_machine
)
713 /* Targets that use REL relocations. */
728 /* Targets that use RELA relocations. */
732 case EM_ADAPTEVA_EPIPHANY
:
734 case EM_ALTERA_NIOS2
:
737 case EM_ARC_COMPACT2
:
757 case EM_LATTICEMICO32
:
766 case EM_CYGNUS_MN10200
:
768 case EM_CYGNUS_MN10300
:
802 case EM_MICROBLAZE_OLD
:
823 warn (_("Don't know about relocations on this machine architecture\n"));
829 slurp_rela_relocs (FILE * file
,
830 unsigned long rel_offset
,
831 unsigned long rel_size
,
832 Elf_Internal_Rela
** relasp
,
833 unsigned long * nrelasp
)
835 Elf_Internal_Rela
* relas
;
841 Elf32_External_Rela
* erelas
;
843 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
844 rel_size
, _("32-bit relocation data"));
848 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
850 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
851 sizeof (Elf_Internal_Rela
));
856 error (_("out of memory parsing relocs\n"));
860 for (i
= 0; i
< nrelas
; i
++)
862 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
863 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
864 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
871 Elf64_External_Rela
* erelas
;
873 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
874 rel_size
, _("64-bit relocation data"));
878 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
880 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
881 sizeof (Elf_Internal_Rela
));
886 error (_("out of memory parsing relocs\n"));
890 for (i
= 0; i
< nrelas
; i
++)
892 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
893 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
894 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
896 /* The #ifdef BFD64 below is to prevent a compile time
897 warning. We know that if we do not have a 64 bit data
898 type that we will never execute this code anyway. */
900 if (elf_header
.e_machine
== EM_MIPS
901 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
903 /* In little-endian objects, r_info isn't really a
904 64-bit little-endian value: it has a 32-bit
905 little-endian symbol index followed by four
906 individual byte fields. Reorder INFO
908 bfd_vma inf
= relas
[i
].r_info
;
909 inf
= (((inf
& 0xffffffff) << 32)
910 | ((inf
>> 56) & 0xff)
911 | ((inf
>> 40) & 0xff00)
912 | ((inf
>> 24) & 0xff0000)
913 | ((inf
>> 8) & 0xff000000));
914 relas
[i
].r_info
= inf
;
927 slurp_rel_relocs (FILE * file
,
928 unsigned long rel_offset
,
929 unsigned long rel_size
,
930 Elf_Internal_Rela
** relsp
,
931 unsigned long * nrelsp
)
933 Elf_Internal_Rela
* rels
;
939 Elf32_External_Rel
* erels
;
941 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
942 rel_size
, _("32-bit relocation data"));
946 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
948 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
953 error (_("out of memory parsing relocs\n"));
957 for (i
= 0; i
< nrels
; i
++)
959 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
960 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
961 rels
[i
].r_addend
= 0;
968 Elf64_External_Rel
* erels
;
970 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
971 rel_size
, _("64-bit relocation data"));
975 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
977 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
982 error (_("out of memory parsing relocs\n"));
986 for (i
= 0; i
< nrels
; i
++)
988 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
989 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
990 rels
[i
].r_addend
= 0;
992 /* The #ifdef BFD64 below is to prevent a compile time
993 warning. We know that if we do not have a 64 bit data
994 type that we will never execute this code anyway. */
996 if (elf_header
.e_machine
== EM_MIPS
997 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
999 /* In little-endian objects, r_info isn't really a
1000 64-bit little-endian value: it has a 32-bit
1001 little-endian symbol index followed by four
1002 individual byte fields. Reorder INFO
1004 bfd_vma inf
= rels
[i
].r_info
;
1005 inf
= (((inf
& 0xffffffff) << 32)
1006 | ((inf
>> 56) & 0xff)
1007 | ((inf
>> 40) & 0xff00)
1008 | ((inf
>> 24) & 0xff0000)
1009 | ((inf
>> 8) & 0xff000000));
1010 rels
[i
].r_info
= inf
;
1022 /* Returns the reloc type extracted from the reloc info field. */
1025 get_reloc_type (bfd_vma reloc_info
)
1028 return ELF32_R_TYPE (reloc_info
);
1030 switch (elf_header
.e_machine
)
1033 /* Note: We assume that reloc_info has already been adjusted for us. */
1034 return ELF64_MIPS_R_TYPE (reloc_info
);
1037 return ELF64_R_TYPE_ID (reloc_info
);
1040 return ELF64_R_TYPE (reloc_info
);
1044 /* Return the symbol index extracted from the reloc info field. */
1047 get_reloc_symindex (bfd_vma reloc_info
)
1049 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1052 static inline bfd_boolean
1053 uses_msp430x_relocs (void)
1056 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1057 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1058 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1059 /* TI compiler uses ELFOSABI_NONE. */
1060 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1063 /* Display the contents of the relocation data found at the specified
1067 dump_relocations (FILE * file
,
1068 unsigned long rel_offset
,
1069 unsigned long rel_size
,
1070 Elf_Internal_Sym
* symtab
,
1071 unsigned long nsyms
,
1073 unsigned long strtablen
,
1078 Elf_Internal_Rela
* rels
;
1080 if (is_rela
== UNKNOWN
)
1081 is_rela
= guess_is_rela (elf_header
.e_machine
);
1085 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1090 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1099 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1101 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1106 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1108 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1116 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1118 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1123 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1125 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1129 for (i
= 0; i
< rel_size
; i
++)
1134 bfd_vma symtab_index
;
1137 offset
= rels
[i
].r_offset
;
1138 inf
= rels
[i
].r_info
;
1140 type
= get_reloc_type (inf
);
1141 symtab_index
= get_reloc_symindex (inf
);
1145 printf ("%8.8lx %8.8lx ",
1146 (unsigned long) offset
& 0xffffffff,
1147 (unsigned long) inf
& 0xffffffff);
1151 #if BFD_HOST_64BIT_LONG
1153 ? "%16.16lx %16.16lx "
1154 : "%12.12lx %12.12lx ",
1156 #elif BFD_HOST_64BIT_LONG_LONG
1159 ? "%16.16llx %16.16llx "
1160 : "%12.12llx %12.12llx ",
1164 ? "%16.16I64x %16.16I64x "
1165 : "%12.12I64x %12.12I64x ",
1170 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1171 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1172 _bfd_int64_high (offset
),
1173 _bfd_int64_low (offset
),
1174 _bfd_int64_high (inf
),
1175 _bfd_int64_low (inf
));
1179 switch (elf_header
.e_machine
)
1186 rtype
= elf_aarch64_reloc_type (type
);
1190 case EM_CYGNUS_M32R
:
1191 rtype
= elf_m32r_reloc_type (type
);
1196 rtype
= elf_i386_reloc_type (type
);
1201 rtype
= elf_m68hc11_reloc_type (type
);
1205 rtype
= elf_m68k_reloc_type (type
);
1209 rtype
= elf_i960_reloc_type (type
);
1214 rtype
= elf_avr_reloc_type (type
);
1217 case EM_OLD_SPARCV9
:
1218 case EM_SPARC32PLUS
:
1221 rtype
= elf_sparc_reloc_type (type
);
1225 rtype
= elf_spu_reloc_type (type
);
1229 rtype
= v800_reloc_type (type
);
1232 case EM_CYGNUS_V850
:
1233 rtype
= v850_reloc_type (type
);
1237 case EM_CYGNUS_D10V
:
1238 rtype
= elf_d10v_reloc_type (type
);
1242 case EM_CYGNUS_D30V
:
1243 rtype
= elf_d30v_reloc_type (type
);
1247 rtype
= elf_dlx_reloc_type (type
);
1251 rtype
= elf_sh_reloc_type (type
);
1255 case EM_CYGNUS_MN10300
:
1256 rtype
= elf_mn10300_reloc_type (type
);
1260 case EM_CYGNUS_MN10200
:
1261 rtype
= elf_mn10200_reloc_type (type
);
1265 case EM_CYGNUS_FR30
:
1266 rtype
= elf_fr30_reloc_type (type
);
1270 rtype
= elf_frv_reloc_type (type
);
1274 rtype
= elf_ft32_reloc_type (type
);
1278 rtype
= elf_mcore_reloc_type (type
);
1282 rtype
= elf_mmix_reloc_type (type
);
1286 rtype
= elf_moxie_reloc_type (type
);
1290 if (uses_msp430x_relocs ())
1292 rtype
= elf_msp430x_reloc_type (type
);
1296 rtype
= elf_msp430_reloc_type (type
);
1300 rtype
= elf_nds32_reloc_type (type
);
1304 rtype
= elf_ppc_reloc_type (type
);
1308 rtype
= elf_ppc64_reloc_type (type
);
1312 case EM_MIPS_RS3_LE
:
1313 rtype
= elf_mips_reloc_type (type
);
1317 rtype
= elf_alpha_reloc_type (type
);
1321 rtype
= elf_arm_reloc_type (type
);
1325 case EM_ARC_COMPACT
:
1326 case EM_ARC_COMPACT2
:
1327 rtype
= elf_arc_reloc_type (type
);
1331 rtype
= elf_hppa_reloc_type (type
);
1337 rtype
= elf_h8_reloc_type (type
);
1341 rtype
= elf_or1k_reloc_type (type
);
1346 rtype
= elf_pj_reloc_type (type
);
1349 rtype
= elf_ia64_reloc_type (type
);
1353 rtype
= elf_cris_reloc_type (type
);
1357 rtype
= elf_i860_reloc_type (type
);
1363 rtype
= elf_x86_64_reloc_type (type
);
1367 rtype
= i370_reloc_type (type
);
1372 rtype
= elf_s390_reloc_type (type
);
1376 rtype
= elf_score_reloc_type (type
);
1380 rtype
= elf_xstormy16_reloc_type (type
);
1384 rtype
= elf_crx_reloc_type (type
);
1388 rtype
= elf_vax_reloc_type (type
);
1392 rtype
= elf_visium_reloc_type (type
);
1395 case EM_ADAPTEVA_EPIPHANY
:
1396 rtype
= elf_epiphany_reloc_type (type
);
1401 rtype
= elf_ip2k_reloc_type (type
);
1405 rtype
= elf_iq2000_reloc_type (type
);
1410 rtype
= elf_xtensa_reloc_type (type
);
1413 case EM_LATTICEMICO32
:
1414 rtype
= elf_lm32_reloc_type (type
);
1419 rtype
= elf_m32c_reloc_type (type
);
1423 rtype
= elf_mt_reloc_type (type
);
1427 rtype
= elf_bfin_reloc_type (type
);
1431 rtype
= elf_mep_reloc_type (type
);
1435 rtype
= elf_cr16_reloc_type (type
);
1439 case EM_MICROBLAZE_OLD
:
1440 rtype
= elf_microblaze_reloc_type (type
);
1444 rtype
= elf_rl78_reloc_type (type
);
1448 rtype
= elf_rx_reloc_type (type
);
1452 rtype
= elf_metag_reloc_type (type
);
1457 rtype
= elf_xc16x_reloc_type (type
);
1461 rtype
= elf_tic6x_reloc_type (type
);
1465 rtype
= elf_tilegx_reloc_type (type
);
1469 rtype
= elf_tilepro_reloc_type (type
);
1473 rtype
= elf_xgate_reloc_type (type
);
1476 case EM_ALTERA_NIOS2
:
1477 rtype
= elf_nios2_reloc_type (type
);
1482 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1484 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1486 if (elf_header
.e_machine
== EM_ALPHA
1488 && streq (rtype
, "R_ALPHA_LITUSE")
1491 switch (rels
[i
].r_addend
)
1493 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1494 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1495 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1496 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1497 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1498 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1499 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1500 default: rtype
= NULL
;
1503 printf (" (%s)", rtype
);
1507 printf (_("<unknown addend: %lx>"),
1508 (unsigned long) rels
[i
].r_addend
);
1511 else if (symtab_index
)
1513 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1514 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1517 Elf_Internal_Sym
* psym
;
1518 const char * version_string
;
1519 enum versioned_symbol_info sym_info
;
1520 unsigned short vna_other
;
1522 psym
= symtab
+ symtab_index
;
1525 = get_symbol_version_string (file
, is_dynsym
,
1534 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1538 unsigned int width
= is_32bit_elf
? 8 : 14;
1540 /* Relocations against GNU_IFUNC symbols do not use the value
1541 of the symbol as the address to relocate against. Instead
1542 they invoke the function named by the symbol and use its
1543 result as the address for relocation.
1545 To indicate this to the user, do not display the value of
1546 the symbol in the "Symbols's Value" field. Instead show
1547 its name followed by () as a hint that the symbol is
1551 || psym
->st_name
== 0
1552 || psym
->st_name
>= strtablen
)
1555 name
= strtab
+ psym
->st_name
;
1557 len
= print_symbol (width
, name
);
1559 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1561 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1565 print_vma (psym
->st_value
, LONG_HEX
);
1567 printf (is_32bit_elf
? " " : " ");
1570 if (psym
->st_name
== 0)
1572 const char * sec_name
= "<null>";
1575 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1577 if (psym
->st_shndx
< elf_header
.e_shnum
)
1578 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1579 else if (psym
->st_shndx
== SHN_ABS
)
1581 else if (psym
->st_shndx
== SHN_COMMON
)
1582 sec_name
= "COMMON";
1583 else if ((elf_header
.e_machine
== EM_MIPS
1584 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1585 || (elf_header
.e_machine
== EM_TI_C6000
1586 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1587 sec_name
= "SCOMMON";
1588 else if (elf_header
.e_machine
== EM_MIPS
1589 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1590 sec_name
= "SUNDEF";
1591 else if ((elf_header
.e_machine
== EM_X86_64
1592 || elf_header
.e_machine
== EM_L1OM
1593 || elf_header
.e_machine
== EM_K1OM
)
1594 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1595 sec_name
= "LARGE_COMMON";
1596 else if (elf_header
.e_machine
== EM_IA_64
1597 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1598 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1599 sec_name
= "ANSI_COM";
1600 else if (is_ia64_vms ()
1601 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1602 sec_name
= "VMS_SYMVEC";
1605 sprintf (name_buf
, "<section 0x%x>",
1606 (unsigned int) psym
->st_shndx
);
1607 sec_name
= name_buf
;
1610 print_symbol (22, sec_name
);
1612 else if (strtab
== NULL
)
1613 printf (_("<string table index: %3ld>"), psym
->st_name
);
1614 else if (psym
->st_name
>= strtablen
)
1615 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1618 print_symbol (22, strtab
+ psym
->st_name
);
1620 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1626 bfd_vma off
= rels
[i
].r_addend
;
1628 if ((bfd_signed_vma
) off
< 0)
1629 printf (" - %" BFD_VMA_FMT
"x", - off
);
1631 printf (" + %" BFD_VMA_FMT
"x", off
);
1637 bfd_vma off
= rels
[i
].r_addend
;
1639 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1640 if ((bfd_signed_vma
) off
< 0)
1641 printf ("-%" BFD_VMA_FMT
"x", - off
);
1643 printf ("%" BFD_VMA_FMT
"x", off
);
1646 if (elf_header
.e_machine
== EM_SPARCV9
1648 && streq (rtype
, "R_SPARC_OLO10"))
1649 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1654 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1656 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1657 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1658 const char * rtype2
= elf_mips_reloc_type (type2
);
1659 const char * rtype3
= elf_mips_reloc_type (type3
);
1661 printf (" Type2: ");
1664 printf (_("unrecognized: %-7lx"),
1665 (unsigned long) type2
& 0xffffffff);
1667 printf ("%-17.17s", rtype2
);
1669 printf ("\n Type3: ");
1672 printf (_("unrecognized: %-7lx"),
1673 (unsigned long) type3
& 0xffffffff);
1675 printf ("%-17.17s", rtype3
);
1686 get_mips_dynamic_type (unsigned long type
)
1690 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1691 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1692 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1693 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1694 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1695 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1696 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1697 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1698 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1699 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1700 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1701 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1702 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1703 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1704 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1705 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1706 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1707 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1708 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1709 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1710 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1711 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1712 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1713 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1714 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1715 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1716 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1717 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1718 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1719 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1720 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1721 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1722 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1723 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1724 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1725 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1726 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1727 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1728 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1729 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1730 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1731 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1732 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1733 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1734 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1735 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1742 get_sparc64_dynamic_type (unsigned long type
)
1746 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1753 get_ppc_dynamic_type (unsigned long type
)
1757 case DT_PPC_GOT
: return "PPC_GOT";
1758 case DT_PPC_OPT
: return "PPC_OPT";
1765 get_ppc64_dynamic_type (unsigned long type
)
1769 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1770 case DT_PPC64_OPD
: return "PPC64_OPD";
1771 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1772 case DT_PPC64_OPT
: return "PPC64_OPT";
1779 get_parisc_dynamic_type (unsigned long type
)
1783 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1784 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1785 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1786 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1787 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1788 case DT_HP_PREINIT
: return "HP_PREINIT";
1789 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1790 case DT_HP_NEEDED
: return "HP_NEEDED";
1791 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1792 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1793 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1794 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1795 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1796 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1797 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1798 case DT_HP_FILTERED
: return "HP_FILTERED";
1799 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1800 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1801 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1802 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1803 case DT_PLT
: return "PLT";
1804 case DT_PLT_SIZE
: return "PLT_SIZE";
1805 case DT_DLT
: return "DLT";
1806 case DT_DLT_SIZE
: return "DLT_SIZE";
1813 get_ia64_dynamic_type (unsigned long type
)
1817 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1818 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1819 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1820 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1821 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1822 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1823 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1824 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1825 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1826 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1827 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1828 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1829 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1830 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1831 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1832 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1833 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1834 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1835 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1836 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1837 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1838 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1839 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1840 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1841 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1842 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1843 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1844 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1845 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1846 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1847 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1854 get_solaris_section_type (unsigned long type
)
1858 case 0x6fffffee: return "SUNW_ancillary";
1859 case 0x6fffffef: return "SUNW_capchain";
1860 case 0x6ffffff0: return "SUNW_capinfo";
1861 case 0x6ffffff1: return "SUNW_symsort";
1862 case 0x6ffffff2: return "SUNW_tlssort";
1863 case 0x6ffffff3: return "SUNW_LDYNSYM";
1864 case 0x6ffffff4: return "SUNW_dof";
1865 case 0x6ffffff5: return "SUNW_cap";
1866 case 0x6ffffff6: return "SUNW_SIGNATURE";
1867 case 0x6ffffff7: return "SUNW_ANNOTATE";
1868 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1869 case 0x6ffffff9: return "SUNW_DEBUG";
1870 case 0x6ffffffa: return "SUNW_move";
1871 case 0x6ffffffb: return "SUNW_COMDAT";
1872 case 0x6ffffffc: return "SUNW_syminfo";
1873 case 0x6ffffffd: return "SUNW_verdef";
1874 case 0x6ffffffe: return "SUNW_verneed";
1875 case 0x6fffffff: return "SUNW_versym";
1876 case 0x70000000: return "SPARC_GOTDATA";
1877 default: return NULL
;
1882 get_alpha_dynamic_type (unsigned long type
)
1886 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1893 get_score_dynamic_type (unsigned long type
)
1897 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1898 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1899 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1900 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1901 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1902 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1909 get_tic6x_dynamic_type (unsigned long type
)
1913 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1914 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1915 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1916 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1917 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1918 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1925 get_nios2_dynamic_type (unsigned long type
)
1929 case DT_NIOS2_GP
: return "NIOS2_GP";
1936 get_solaris_dynamic_type (unsigned long type
)
1940 case 0x6000000d: return "SUNW_AUXILIARY";
1941 case 0x6000000e: return "SUNW_RTLDINF";
1942 case 0x6000000f: return "SUNW_FILTER";
1943 case 0x60000010: return "SUNW_CAP";
1944 case 0x60000011: return "SUNW_SYMTAB";
1945 case 0x60000012: return "SUNW_SYMSZ";
1946 case 0x60000013: return "SUNW_SORTENT";
1947 case 0x60000014: return "SUNW_SYMSORT";
1948 case 0x60000015: return "SUNW_SYMSORTSZ";
1949 case 0x60000016: return "SUNW_TLSSORT";
1950 case 0x60000017: return "SUNW_TLSSORTSZ";
1951 case 0x60000018: return "SUNW_CAPINFO";
1952 case 0x60000019: return "SUNW_STRPAD";
1953 case 0x6000001a: return "SUNW_CAPCHAIN";
1954 case 0x6000001b: return "SUNW_LDMACH";
1955 case 0x6000001d: return "SUNW_CAPCHAINENT";
1956 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1957 case 0x60000021: return "SUNW_PARENT";
1958 case 0x60000023: return "SUNW_ASLR";
1959 case 0x60000025: return "SUNW_RELAX";
1960 case 0x60000029: return "SUNW_NXHEAP";
1961 case 0x6000002b: return "SUNW_NXSTACK";
1963 case 0x70000001: return "SPARC_REGISTER";
1964 case 0x7ffffffd: return "AUXILIARY";
1965 case 0x7ffffffe: return "USED";
1966 case 0x7fffffff: return "FILTER";
1968 default: return NULL
;
1973 get_dynamic_type (unsigned long type
)
1975 static char buff
[64];
1979 case DT_NULL
: return "NULL";
1980 case DT_NEEDED
: return "NEEDED";
1981 case DT_PLTRELSZ
: return "PLTRELSZ";
1982 case DT_PLTGOT
: return "PLTGOT";
1983 case DT_HASH
: return "HASH";
1984 case DT_STRTAB
: return "STRTAB";
1985 case DT_SYMTAB
: return "SYMTAB";
1986 case DT_RELA
: return "RELA";
1987 case DT_RELASZ
: return "RELASZ";
1988 case DT_RELAENT
: return "RELAENT";
1989 case DT_STRSZ
: return "STRSZ";
1990 case DT_SYMENT
: return "SYMENT";
1991 case DT_INIT
: return "INIT";
1992 case DT_FINI
: return "FINI";
1993 case DT_SONAME
: return "SONAME";
1994 case DT_RPATH
: return "RPATH";
1995 case DT_SYMBOLIC
: return "SYMBOLIC";
1996 case DT_REL
: return "REL";
1997 case DT_RELSZ
: return "RELSZ";
1998 case DT_RELENT
: return "RELENT";
1999 case DT_PLTREL
: return "PLTREL";
2000 case DT_DEBUG
: return "DEBUG";
2001 case DT_TEXTREL
: return "TEXTREL";
2002 case DT_JMPREL
: return "JMPREL";
2003 case DT_BIND_NOW
: return "BIND_NOW";
2004 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2005 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2006 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2007 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2008 case DT_RUNPATH
: return "RUNPATH";
2009 case DT_FLAGS
: return "FLAGS";
2011 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2012 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2014 case DT_CHECKSUM
: return "CHECKSUM";
2015 case DT_PLTPADSZ
: return "PLTPADSZ";
2016 case DT_MOVEENT
: return "MOVEENT";
2017 case DT_MOVESZ
: return "MOVESZ";
2018 case DT_FEATURE
: return "FEATURE";
2019 case DT_POSFLAG_1
: return "POSFLAG_1";
2020 case DT_SYMINSZ
: return "SYMINSZ";
2021 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2023 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2024 case DT_CONFIG
: return "CONFIG";
2025 case DT_DEPAUDIT
: return "DEPAUDIT";
2026 case DT_AUDIT
: return "AUDIT";
2027 case DT_PLTPAD
: return "PLTPAD";
2028 case DT_MOVETAB
: return "MOVETAB";
2029 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2031 case DT_VERSYM
: return "VERSYM";
2033 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2034 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2035 case DT_RELACOUNT
: return "RELACOUNT";
2036 case DT_RELCOUNT
: return "RELCOUNT";
2037 case DT_FLAGS_1
: return "FLAGS_1";
2038 case DT_VERDEF
: return "VERDEF";
2039 case DT_VERDEFNUM
: return "VERDEFNUM";
2040 case DT_VERNEED
: return "VERNEED";
2041 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2043 case DT_AUXILIARY
: return "AUXILIARY";
2044 case DT_USED
: return "USED";
2045 case DT_FILTER
: return "FILTER";
2047 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2048 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2049 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2050 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2051 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2052 case DT_GNU_HASH
: return "GNU_HASH";
2055 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2057 const char * result
;
2059 switch (elf_header
.e_machine
)
2062 case EM_MIPS_RS3_LE
:
2063 result
= get_mips_dynamic_type (type
);
2066 result
= get_sparc64_dynamic_type (type
);
2069 result
= get_ppc_dynamic_type (type
);
2072 result
= get_ppc64_dynamic_type (type
);
2075 result
= get_ia64_dynamic_type (type
);
2078 result
= get_alpha_dynamic_type (type
);
2081 result
= get_score_dynamic_type (type
);
2084 result
= get_tic6x_dynamic_type (type
);
2086 case EM_ALTERA_NIOS2
:
2087 result
= get_nios2_dynamic_type (type
);
2090 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2091 result
= get_solaris_dynamic_type (type
);
2100 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2102 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2103 || (elf_header
.e_machine
== EM_PARISC
2104 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2106 const char * result
;
2108 switch (elf_header
.e_machine
)
2111 result
= get_parisc_dynamic_type (type
);
2114 result
= get_ia64_dynamic_type (type
);
2117 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2118 result
= get_solaris_dynamic_type (type
);
2127 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2131 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2138 get_file_type (unsigned e_type
)
2140 static char buff
[32];
2144 case ET_NONE
: return _("NONE (None)");
2145 case ET_REL
: return _("REL (Relocatable file)");
2146 case ET_EXEC
: return _("EXEC (Executable file)");
2147 case ET_DYN
: return _("DYN (Shared object file)");
2148 case ET_CORE
: return _("CORE (Core file)");
2151 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2152 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2153 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2154 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2156 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2162 get_machine_name (unsigned e_machine
)
2164 static char buff
[64]; /* XXX */
2168 case EM_NONE
: return _("None");
2169 case EM_AARCH64
: return "AArch64";
2170 case EM_M32
: return "WE32100";
2171 case EM_SPARC
: return "Sparc";
2172 case EM_SPU
: return "SPU";
2173 case EM_386
: return "Intel 80386";
2174 case EM_68K
: return "MC68000";
2175 case EM_88K
: return "MC88000";
2176 case EM_IAMCU
: return "Intel MCU";
2177 case EM_860
: return "Intel 80860";
2178 case EM_MIPS
: return "MIPS R3000";
2179 case EM_S370
: return "IBM System/370";
2180 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2181 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2182 case EM_PARISC
: return "HPPA";
2183 case EM_PPC_OLD
: return "Power PC (old)";
2184 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2185 case EM_960
: return "Intel 90860";
2186 case EM_PPC
: return "PowerPC";
2187 case EM_PPC64
: return "PowerPC64";
2188 case EM_FR20
: return "Fujitsu FR20";
2189 case EM_FT32
: return "FTDI FT32";
2190 case EM_RH32
: return "TRW RH32";
2191 case EM_MCORE
: return "MCORE";
2192 case EM_ARM
: return "ARM";
2193 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2194 case EM_SH
: return "Renesas / SuperH SH";
2195 case EM_SPARCV9
: return "Sparc v9";
2196 case EM_TRICORE
: return "Siemens Tricore";
2197 case EM_ARC
: return "ARC";
2198 case EM_ARC_COMPACT
: return "ARCompact";
2199 case EM_ARC_COMPACT2
: return "ARCv2";
2200 case EM_H8_300
: return "Renesas H8/300";
2201 case EM_H8_300H
: return "Renesas H8/300H";
2202 case EM_H8S
: return "Renesas H8S";
2203 case EM_H8_500
: return "Renesas H8/500";
2204 case EM_IA_64
: return "Intel IA-64";
2205 case EM_MIPS_X
: return "Stanford MIPS-X";
2206 case EM_COLDFIRE
: return "Motorola Coldfire";
2207 case EM_ALPHA
: return "Alpha";
2208 case EM_CYGNUS_D10V
:
2209 case EM_D10V
: return "d10v";
2210 case EM_CYGNUS_D30V
:
2211 case EM_D30V
: return "d30v";
2212 case EM_CYGNUS_M32R
:
2213 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2214 case EM_CYGNUS_V850
:
2215 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2216 case EM_V850
: return "Renesas V850";
2217 case EM_CYGNUS_MN10300
:
2218 case EM_MN10300
: return "mn10300";
2219 case EM_CYGNUS_MN10200
:
2220 case EM_MN10200
: return "mn10200";
2221 case EM_MOXIE
: return "Moxie";
2222 case EM_CYGNUS_FR30
:
2223 case EM_FR30
: return "Fujitsu FR30";
2224 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2226 case EM_PJ
: return "picoJava";
2227 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2228 case EM_PCP
: return "Siemens PCP";
2229 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2230 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2231 case EM_STARCORE
: return "Motorola Star*Core processor";
2232 case EM_ME16
: return "Toyota ME16 processor";
2233 case EM_ST100
: return "STMicroelectronics ST100 processor";
2234 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2235 case EM_PDSP
: return "Sony DSP processor";
2236 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2237 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2238 case EM_FX66
: return "Siemens FX66 microcontroller";
2239 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2240 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2241 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2242 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2243 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2244 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2245 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2246 case EM_SVX
: return "Silicon Graphics SVx";
2247 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2248 case EM_VAX
: return "Digital VAX";
2249 case EM_VISIUM
: return "CDS VISIUMcore processor";
2251 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2252 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2253 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2254 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2255 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2256 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2257 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2258 case EM_PRISM
: return "Vitesse Prism";
2259 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2260 case EM_L1OM
: return "Intel L1OM";
2261 case EM_K1OM
: return "Intel K1OM";
2263 case EM_S390
: return "IBM S/390";
2264 case EM_SCORE
: return "SUNPLUS S+Core";
2265 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2266 case EM_OR1K
: return "OpenRISC 1000";
2267 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2268 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2269 case EM_DLX
: return "OpenDLX";
2271 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2272 case EM_IQ2000
: return "Vitesse IQ2000";
2274 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2275 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2276 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2277 case EM_NS32K
: return "National Semiconductor 32000 series";
2278 case EM_TPC
: return "Tenor Network TPC processor";
2279 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2280 case EM_MAX
: return "MAX Processor";
2281 case EM_CR
: return "National Semiconductor CompactRISC";
2282 case EM_F2MC16
: return "Fujitsu F2MC16";
2283 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2284 case EM_LATTICEMICO32
: return "Lattice Mico32";
2286 case EM_M32C
: return "Renesas M32c";
2287 case EM_MT
: return "Morpho Techologies MT processor";
2288 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2289 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2290 case EM_SEP
: return "Sharp embedded microprocessor";
2291 case EM_ARCA
: return "Arca RISC microprocessor";
2292 case EM_UNICORE
: return "Unicore";
2293 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2294 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2295 case EM_NIOS32
: return "Altera Nios";
2296 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2298 case EM_XC16X
: return "Infineon Technologies xc16x";
2299 case EM_M16C
: return "Renesas M16C series microprocessors";
2300 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2301 case EM_CE
: return "Freescale Communication Engine RISC core";
2302 case EM_TSK3000
: return "Altium TSK3000 core";
2303 case EM_RS08
: return "Freescale RS08 embedded processor";
2304 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2305 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2306 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2307 case EM_SE_C17
: return "Seiko Epson C17 family";
2308 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2309 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2310 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2311 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2312 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2313 case EM_R32C
: return "Renesas R32C series microprocessors";
2314 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2315 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2316 case EM_8051
: return "Intel 8051 and variants";
2317 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2318 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2319 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2320 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2321 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2322 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2323 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2324 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2327 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2328 case EM_RL78
: return "Renesas RL78";
2329 case EM_RX
: return "Renesas RX";
2330 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2331 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2332 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2333 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2334 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2335 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2336 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2337 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2338 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2339 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2340 case EM_CUDA
: return "NVIDIA CUDA architecture";
2341 case EM_XGATE
: return "Motorola XGATE embedded processor";
2343 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2349 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2351 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2352 other compilers don't a specific architecture type in the e_flags, and
2353 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2354 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2357 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2358 but also sets a specific architecture type in the e_flags field.
2360 However, when decoding the flags we don't worry if we see an
2361 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2362 ARCEM architecture type. */
2364 switch (e_flags
& EF_ARC_MACH_MSK
)
2366 /* We only expect these to occur for EM_ARC_COMPACT2. */
2367 case EF_ARC_CPU_ARCV2EM
:
2368 strcat (buf
, ", ARC EM");
2370 case EF_ARC_CPU_ARCV2HS
:
2371 strcat (buf
, ", ARC HS");
2374 /* We only expect these to occur for EM_ARC_COMPACT. */
2375 case E_ARC_MACH_ARC600
:
2376 strcat (buf
, ", ARC600");
2378 case E_ARC_MACH_ARC601
:
2379 strcat (buf
, ", ARC601");
2381 case E_ARC_MACH_ARC700
:
2382 strcat (buf
, ", ARC700");
2385 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2386 new ELF with new architecture being read by an old version of
2387 readelf, or (c) An ELF built with non-GNU compiler that does not
2388 set the architecture in the e_flags. */
2390 if (e_machine
== EM_ARC_COMPACT
)
2391 strcat (buf
, ", Unknown ARCompact");
2393 strcat (buf
, ", Unknown ARC");
2397 switch (e_flags
& EF_ARC_OSABI_MSK
)
2399 case E_ARC_OSABI_ORIG
:
2400 strcat (buf
, ", (ABI:legacy)");
2402 case E_ARC_OSABI_V2
:
2403 strcat (buf
, ", (ABI:v2)");
2405 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2406 case E_ARC_OSABI_V3
:
2407 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2410 strcat (buf
, ", unrecognised ARC OSABI flag");
2416 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2421 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2422 e_flags
&= ~ EF_ARM_EABIMASK
;
2424 /* Handle "generic" ARM flags. */
2425 if (e_flags
& EF_ARM_RELEXEC
)
2427 strcat (buf
, ", relocatable executable");
2428 e_flags
&= ~ EF_ARM_RELEXEC
;
2431 /* Now handle EABI specific flags. */
2435 strcat (buf
, ", <unrecognized EABI>");
2440 case EF_ARM_EABI_VER1
:
2441 strcat (buf
, ", Version1 EABI");
2446 /* Process flags one bit at a time. */
2447 flag
= e_flags
& - e_flags
;
2452 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2453 strcat (buf
, ", sorted symbol tables");
2463 case EF_ARM_EABI_VER2
:
2464 strcat (buf
, ", Version2 EABI");
2469 /* Process flags one bit at a time. */
2470 flag
= e_flags
& - e_flags
;
2475 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2476 strcat (buf
, ", sorted symbol tables");
2479 case EF_ARM_DYNSYMSUSESEGIDX
:
2480 strcat (buf
, ", dynamic symbols use segment index");
2483 case EF_ARM_MAPSYMSFIRST
:
2484 strcat (buf
, ", mapping symbols precede others");
2494 case EF_ARM_EABI_VER3
:
2495 strcat (buf
, ", Version3 EABI");
2498 case EF_ARM_EABI_VER4
:
2499 strcat (buf
, ", Version4 EABI");
2504 /* Process flags one bit at a time. */
2505 flag
= e_flags
& - e_flags
;
2511 strcat (buf
, ", BE8");
2515 strcat (buf
, ", LE8");
2526 case EF_ARM_EABI_VER5
:
2527 strcat (buf
, ", Version5 EABI");
2532 /* Process flags one bit at a time. */
2533 flag
= e_flags
& - e_flags
;
2539 strcat (buf
, ", BE8");
2543 strcat (buf
, ", LE8");
2546 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2547 strcat (buf
, ", soft-float ABI");
2550 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2551 strcat (buf
, ", hard-float ABI");
2561 case EF_ARM_EABI_UNKNOWN
:
2562 strcat (buf
, ", GNU EABI");
2567 /* Process flags one bit at a time. */
2568 flag
= e_flags
& - e_flags
;
2573 case EF_ARM_INTERWORK
:
2574 strcat (buf
, ", interworking enabled");
2577 case EF_ARM_APCS_26
:
2578 strcat (buf
, ", uses APCS/26");
2581 case EF_ARM_APCS_FLOAT
:
2582 strcat (buf
, ", uses APCS/float");
2586 strcat (buf
, ", position independent");
2590 strcat (buf
, ", 8 bit structure alignment");
2593 case EF_ARM_NEW_ABI
:
2594 strcat (buf
, ", uses new ABI");
2597 case EF_ARM_OLD_ABI
:
2598 strcat (buf
, ", uses old ABI");
2601 case EF_ARM_SOFT_FLOAT
:
2602 strcat (buf
, ", software FP");
2605 case EF_ARM_VFP_FLOAT
:
2606 strcat (buf
, ", VFP");
2609 case EF_ARM_MAVERICK_FLOAT
:
2610 strcat (buf
, ", Maverick FP");
2621 strcat (buf
,_(", <unknown>"));
2625 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2627 --size
; /* Leave space for null terminator. */
2629 switch (e_flags
& EF_AVR_MACH
)
2631 case E_AVR_MACH_AVR1
:
2632 strncat (buf
, ", avr:1", size
);
2634 case E_AVR_MACH_AVR2
:
2635 strncat (buf
, ", avr:2", size
);
2637 case E_AVR_MACH_AVR25
:
2638 strncat (buf
, ", avr:25", size
);
2640 case E_AVR_MACH_AVR3
:
2641 strncat (buf
, ", avr:3", size
);
2643 case E_AVR_MACH_AVR31
:
2644 strncat (buf
, ", avr:31", size
);
2646 case E_AVR_MACH_AVR35
:
2647 strncat (buf
, ", avr:35", size
);
2649 case E_AVR_MACH_AVR4
:
2650 strncat (buf
, ", avr:4", size
);
2652 case E_AVR_MACH_AVR5
:
2653 strncat (buf
, ", avr:5", size
);
2655 case E_AVR_MACH_AVR51
:
2656 strncat (buf
, ", avr:51", size
);
2658 case E_AVR_MACH_AVR6
:
2659 strncat (buf
, ", avr:6", size
);
2661 case E_AVR_MACH_AVRTINY
:
2662 strncat (buf
, ", avr:100", size
);
2664 case E_AVR_MACH_XMEGA1
:
2665 strncat (buf
, ", avr:101", size
);
2667 case E_AVR_MACH_XMEGA2
:
2668 strncat (buf
, ", avr:102", size
);
2670 case E_AVR_MACH_XMEGA3
:
2671 strncat (buf
, ", avr:103", size
);
2673 case E_AVR_MACH_XMEGA4
:
2674 strncat (buf
, ", avr:104", size
);
2676 case E_AVR_MACH_XMEGA5
:
2677 strncat (buf
, ", avr:105", size
);
2679 case E_AVR_MACH_XMEGA6
:
2680 strncat (buf
, ", avr:106", size
);
2682 case E_AVR_MACH_XMEGA7
:
2683 strncat (buf
, ", avr:107", size
);
2686 strncat (buf
, ", avr:<unknown>", size
);
2690 size
-= strlen (buf
);
2691 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2692 strncat (buf
, ", link-relax", size
);
2696 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2705 static const char *ABI_STRINGS
[] =
2707 "ABI v0", /* use r5 as return register; only used in N1213HC */
2708 "ABI v1", /* use r0 as return register */
2709 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2710 "ABI v2fp", /* for FPU */
2714 static const char *VER_STRINGS
[] =
2716 "Andes ELF V1.3 or older",
2720 static const char *ARCH_STRINGS
[] =
2729 abi
= EF_NDS_ABI
& e_flags
;
2730 arch
= EF_NDS_ARCH
& e_flags
;
2731 config
= EF_NDS_INST
& e_flags
;
2732 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2734 memset (buf
, 0, size
);
2741 case E_NDS_ABI_V2FP
:
2742 case E_NDS_ABI_AABI
:
2743 case E_NDS_ABI_V2FP_PLUS
:
2744 /* In case there are holes in the array. */
2745 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2749 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2755 case E_NDS32_ELF_VER_1_2
:
2756 case E_NDS32_ELF_VER_1_3
:
2757 case E_NDS32_ELF_VER_1_4
:
2758 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2762 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2766 if (E_NDS_ABI_V0
== abi
)
2768 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2769 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2770 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2771 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2777 case E_NDS_ARCH_STAR_V1_0
:
2778 case E_NDS_ARCH_STAR_V2_0
:
2779 case E_NDS_ARCH_STAR_V3_0
:
2780 case E_NDS_ARCH_STAR_V3_M
:
2781 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2785 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2786 /* ARCH version determines how the e_flags are interpreted.
2787 If it is unknown, we cannot proceed. */
2791 /* Newer ABI; Now handle architecture specific flags. */
2792 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2794 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2795 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2797 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2798 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2800 if (config
& E_NDS32_HAS_DIV_INST
)
2801 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2803 if (config
& E_NDS32_HAS_16BIT_INST
)
2804 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2808 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2810 if (version
<= E_NDS32_ELF_VER_1_3
)
2811 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2813 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2816 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2817 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2819 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2820 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2822 if (config
& E_NDS32_HAS_16BIT_INST
)
2824 if (version
<= E_NDS32_ELF_VER_1_3
)
2825 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2827 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2831 if (config
& E_NDS32_HAS_EXT_INST
)
2832 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2834 if (config
& E_NDS32_HAS_EXT2_INST
)
2835 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2837 if (config
& E_NDS32_HAS_FPU_INST
)
2840 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2843 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2846 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2849 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2852 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2857 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2859 case E_NDS32_FPU_REG_8SP_4DP
:
2860 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2862 case E_NDS32_FPU_REG_16SP_8DP
:
2863 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2865 case E_NDS32_FPU_REG_32SP_16DP
:
2866 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2868 case E_NDS32_FPU_REG_32SP_32DP
:
2869 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2874 if (config
& E_NDS32_HAS_AUDIO_INST
)
2875 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2877 if (config
& E_NDS32_HAS_STRING_INST
)
2878 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2880 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2881 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2883 if (config
& E_NDS32_HAS_VIDEO_INST
)
2885 if (version
<= E_NDS32_ELF_VER_1_3
)
2886 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2888 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2891 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2892 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2894 if (config
& E_NDS32_HAS_L2C_INST
)
2895 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2899 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2901 static char buf
[1024];
2912 case EM_ARC_COMPACT2
:
2913 case EM_ARC_COMPACT
:
2914 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
2918 decode_ARM_machine_flags (e_flags
, buf
);
2922 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2926 if (e_flags
& EF_BFIN_PIC
)
2927 strcat (buf
, ", PIC");
2929 if (e_flags
& EF_BFIN_FDPIC
)
2930 strcat (buf
, ", FDPIC");
2932 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2933 strcat (buf
, ", code in L1");
2935 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2936 strcat (buf
, ", data in L1");
2941 switch (e_flags
& EF_FRV_CPU_MASK
)
2943 case EF_FRV_CPU_GENERIC
:
2947 strcat (buf
, ", fr???");
2950 case EF_FRV_CPU_FR300
:
2951 strcat (buf
, ", fr300");
2954 case EF_FRV_CPU_FR400
:
2955 strcat (buf
, ", fr400");
2957 case EF_FRV_CPU_FR405
:
2958 strcat (buf
, ", fr405");
2961 case EF_FRV_CPU_FR450
:
2962 strcat (buf
, ", fr450");
2965 case EF_FRV_CPU_FR500
:
2966 strcat (buf
, ", fr500");
2968 case EF_FRV_CPU_FR550
:
2969 strcat (buf
, ", fr550");
2972 case EF_FRV_CPU_SIMPLE
:
2973 strcat (buf
, ", simple");
2975 case EF_FRV_CPU_TOMCAT
:
2976 strcat (buf
, ", tomcat");
2982 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2983 strcat (buf
, ", m68000");
2984 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2985 strcat (buf
, ", cpu32");
2986 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2987 strcat (buf
, ", fido_a");
2990 char const * isa
= _("unknown");
2991 char const * mac
= _("unknown mac");
2992 char const * additional
= NULL
;
2994 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2996 case EF_M68K_CF_ISA_A_NODIV
:
2998 additional
= ", nodiv";
3000 case EF_M68K_CF_ISA_A
:
3003 case EF_M68K_CF_ISA_A_PLUS
:
3006 case EF_M68K_CF_ISA_B_NOUSP
:
3008 additional
= ", nousp";
3010 case EF_M68K_CF_ISA_B
:
3013 case EF_M68K_CF_ISA_C
:
3016 case EF_M68K_CF_ISA_C_NODIV
:
3018 additional
= ", nodiv";
3021 strcat (buf
, ", cf, isa ");
3024 strcat (buf
, additional
);
3025 if (e_flags
& EF_M68K_CF_FLOAT
)
3026 strcat (buf
, ", float");
3027 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3032 case EF_M68K_CF_MAC
:
3035 case EF_M68K_CF_EMAC
:
3038 case EF_M68K_CF_EMAC_B
:
3051 switch (e_flags
& EF_MEP_CPU_MASK
)
3053 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3054 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3055 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3056 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3057 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3058 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3059 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3062 switch (e_flags
& EF_MEP_COP_MASK
)
3064 case EF_MEP_COP_NONE
: break;
3065 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3066 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3067 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3068 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3069 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3072 if (e_flags
& EF_MEP_LIBRARY
)
3073 strcat (buf
, ", Built for Library");
3075 if (e_flags
& EF_MEP_INDEX_MASK
)
3076 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3077 e_flags
& EF_MEP_INDEX_MASK
);
3079 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3080 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3081 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3085 if (e_flags
& EF_PPC_EMB
)
3086 strcat (buf
, ", emb");
3088 if (e_flags
& EF_PPC_RELOCATABLE
)
3089 strcat (buf
, _(", relocatable"));
3091 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3092 strcat (buf
, _(", relocatable-lib"));
3096 if (e_flags
& EF_PPC64_ABI
)
3098 char abi
[] = ", abiv0";
3100 abi
[6] += e_flags
& EF_PPC64_ABI
;
3106 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3107 strcat (buf
, ", RH850 ABI");
3109 if (e_flags
& EF_V800_850E3
)
3110 strcat (buf
, ", V3 architecture");
3112 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3113 strcat (buf
, ", FPU not used");
3115 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3116 strcat (buf
, ", regmode: COMMON");
3118 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3119 strcat (buf
, ", r4 not used");
3121 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3122 strcat (buf
, ", r30 not used");
3124 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3125 strcat (buf
, ", r5 not used");
3127 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3128 strcat (buf
, ", r2 not used");
3130 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3132 switch (e_flags
& - e_flags
)
3134 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3135 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3136 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3137 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3138 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3139 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3140 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3141 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3142 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3143 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3144 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3145 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3152 case EM_CYGNUS_V850
:
3153 switch (e_flags
& EF_V850_ARCH
)
3155 case E_V850E3V5_ARCH
:
3156 strcat (buf
, ", v850e3v5");
3158 case E_V850E2V3_ARCH
:
3159 strcat (buf
, ", v850e2v3");
3162 strcat (buf
, ", v850e2");
3165 strcat (buf
, ", v850e1");
3168 strcat (buf
, ", v850e");
3171 strcat (buf
, ", v850");
3174 strcat (buf
, _(", unknown v850 architecture variant"));
3180 case EM_CYGNUS_M32R
:
3181 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3182 strcat (buf
, ", m32r");
3186 case EM_MIPS_RS3_LE
:
3187 if (e_flags
& EF_MIPS_NOREORDER
)
3188 strcat (buf
, ", noreorder");
3190 if (e_flags
& EF_MIPS_PIC
)
3191 strcat (buf
, ", pic");
3193 if (e_flags
& EF_MIPS_CPIC
)
3194 strcat (buf
, ", cpic");
3196 if (e_flags
& EF_MIPS_UCODE
)
3197 strcat (buf
, ", ugen_reserved");
3199 if (e_flags
& EF_MIPS_ABI2
)
3200 strcat (buf
, ", abi2");
3202 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3203 strcat (buf
, ", odk first");
3205 if (e_flags
& EF_MIPS_32BITMODE
)
3206 strcat (buf
, ", 32bitmode");
3208 if (e_flags
& EF_MIPS_NAN2008
)
3209 strcat (buf
, ", nan2008");
3211 if (e_flags
& EF_MIPS_FP64
)
3212 strcat (buf
, ", fp64");
3214 switch ((e_flags
& EF_MIPS_MACH
))
3216 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3217 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3218 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3219 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3220 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3221 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3222 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3223 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3224 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3225 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3226 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3227 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3228 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3229 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3230 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3231 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3232 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3234 /* We simply ignore the field in this case to avoid confusion:
3235 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3238 default: strcat (buf
, _(", unknown CPU")); break;
3241 switch ((e_flags
& EF_MIPS_ABI
))
3243 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3244 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3245 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3246 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3248 /* We simply ignore the field in this case to avoid confusion:
3249 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3250 This means it is likely to be an o32 file, but not for
3253 default: strcat (buf
, _(", unknown ABI")); break;
3256 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3257 strcat (buf
, ", mdmx");
3259 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3260 strcat (buf
, ", mips16");
3262 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3263 strcat (buf
, ", micromips");
3265 switch ((e_flags
& EF_MIPS_ARCH
))
3267 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3268 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3269 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3270 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3271 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3272 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3273 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3274 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3275 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3276 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3277 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3278 default: strcat (buf
, _(", unknown ISA")); break;
3283 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3287 switch ((e_flags
& EF_SH_MACH_MASK
))
3289 case EF_SH1
: strcat (buf
, ", sh1"); break;
3290 case EF_SH2
: strcat (buf
, ", sh2"); break;
3291 case EF_SH3
: strcat (buf
, ", sh3"); break;
3292 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3293 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3294 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3295 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3296 case EF_SH4
: strcat (buf
, ", sh4"); break;
3297 case EF_SH5
: strcat (buf
, ", sh5"); break;
3298 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3299 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3300 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3301 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3302 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3303 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3304 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3305 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3306 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3307 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3308 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3309 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3310 default: strcat (buf
, _(", unknown ISA")); break;
3313 if (e_flags
& EF_SH_PIC
)
3314 strcat (buf
, ", pic");
3316 if (e_flags
& EF_SH_FDPIC
)
3317 strcat (buf
, ", fdpic");
3321 if (e_flags
& EF_OR1K_NODELAY
)
3322 strcat (buf
, ", no delay");
3326 if (e_flags
& EF_SPARC_32PLUS
)
3327 strcat (buf
, ", v8+");
3329 if (e_flags
& EF_SPARC_SUN_US1
)
3330 strcat (buf
, ", ultrasparcI");
3332 if (e_flags
& EF_SPARC_SUN_US3
)
3333 strcat (buf
, ", ultrasparcIII");
3335 if (e_flags
& EF_SPARC_HAL_R1
)
3336 strcat (buf
, ", halr1");
3338 if (e_flags
& EF_SPARC_LEDATA
)
3339 strcat (buf
, ", ledata");
3341 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3342 strcat (buf
, ", tso");
3344 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3345 strcat (buf
, ", pso");
3347 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3348 strcat (buf
, ", rmo");
3352 switch (e_flags
& EF_PARISC_ARCH
)
3354 case EFA_PARISC_1_0
:
3355 strcpy (buf
, ", PA-RISC 1.0");
3357 case EFA_PARISC_1_1
:
3358 strcpy (buf
, ", PA-RISC 1.1");
3360 case EFA_PARISC_2_0
:
3361 strcpy (buf
, ", PA-RISC 2.0");
3366 if (e_flags
& EF_PARISC_TRAPNIL
)
3367 strcat (buf
, ", trapnil");
3368 if (e_flags
& EF_PARISC_EXT
)
3369 strcat (buf
, ", ext");
3370 if (e_flags
& EF_PARISC_LSB
)
3371 strcat (buf
, ", lsb");
3372 if (e_flags
& EF_PARISC_WIDE
)
3373 strcat (buf
, ", wide");
3374 if (e_flags
& EF_PARISC_NO_KABP
)
3375 strcat (buf
, ", no kabp");
3376 if (e_flags
& EF_PARISC_LAZYSWAP
)
3377 strcat (buf
, ", lazyswap");
3382 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3383 strcat (buf
, ", new calling convention");
3385 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3386 strcat (buf
, ", gnu calling convention");
3390 if ((e_flags
& EF_IA_64_ABI64
))
3391 strcat (buf
, ", 64-bit");
3393 strcat (buf
, ", 32-bit");
3394 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3395 strcat (buf
, ", reduced fp model");
3396 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3397 strcat (buf
, ", no function descriptors, constant gp");
3398 else if ((e_flags
& EF_IA_64_CONS_GP
))
3399 strcat (buf
, ", constant gp");
3400 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3401 strcat (buf
, ", absolute");
3402 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3404 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3405 strcat (buf
, ", vms_linkages");
3406 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3408 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3410 case EF_IA_64_VMS_COMCOD_WARNING
:
3411 strcat (buf
, ", warning");
3413 case EF_IA_64_VMS_COMCOD_ERROR
:
3414 strcat (buf
, ", error");
3416 case EF_IA_64_VMS_COMCOD_ABORT
:
3417 strcat (buf
, ", abort");
3420 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3421 e_flags
& EF_IA_64_VMS_COMCOD
);
3422 strcat (buf
, ", <unknown>");
3428 if ((e_flags
& EF_VAX_NONPIC
))
3429 strcat (buf
, ", non-PIC");
3430 if ((e_flags
& EF_VAX_DFLOAT
))
3431 strcat (buf
, ", D-Float");
3432 if ((e_flags
& EF_VAX_GFLOAT
))
3433 strcat (buf
, ", G-Float");
3437 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3438 strcat (buf
, ", mcm");
3439 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3440 strcat (buf
, ", mcm24");
3441 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3442 strcat (buf
, ", gr6");
3446 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3448 case E_FLAG_RL78_ANY_CPU
: break;
3449 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3450 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3451 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3453 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3454 strcat (buf
, ", 64-bit doubles");
3458 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3459 strcat (buf
, ", 64-bit doubles");
3460 if (e_flags
& E_FLAG_RX_DSP
)
3461 strcat (buf
, ", dsp");
3462 if (e_flags
& E_FLAG_RX_PID
)
3463 strcat (buf
, ", pid");
3464 if (e_flags
& E_FLAG_RX_ABI
)
3465 strcat (buf
, ", RX ABI");
3466 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3467 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3468 ? ", uses String instructions" : ", bans String instructions");
3469 if (e_flags
& E_FLAG_RX_V2
)
3470 strcat (buf
, ", V2");
3474 if (e_flags
& EF_S390_HIGH_GPRS
)
3475 strcat (buf
, ", highgprs");
3479 if ((e_flags
& EF_C6000_REL
))
3480 strcat (buf
, ", relocatable module");
3484 strcat (buf
, _(": architecture variant: "));
3485 switch (e_flags
& EF_MSP430_MACH
)
3487 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3488 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3489 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3490 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3491 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3492 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3493 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3494 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3495 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3496 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3497 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3498 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3499 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3500 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3501 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3503 strcat (buf
, _(": unknown")); break;
3506 if (e_flags
& ~ EF_MSP430_MACH
)
3507 strcat (buf
, _(": unknown extra flag bits also present"));
3515 get_osabi_name (unsigned int osabi
)
3517 static char buff
[32];
3521 case ELFOSABI_NONE
: return "UNIX - System V";
3522 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3523 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3524 case ELFOSABI_GNU
: return "UNIX - GNU";
3525 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3526 case ELFOSABI_AIX
: return "UNIX - AIX";
3527 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3528 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3529 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3530 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3531 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3532 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3533 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3534 case ELFOSABI_AROS
: return "AROS";
3535 case ELFOSABI_FENIXOS
: return "FenixOS";
3538 switch (elf_header
.e_machine
)
3543 case ELFOSABI_ARM
: return "ARM";
3554 case ELFOSABI_STANDALONE
: return _("Standalone App");
3563 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3564 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3573 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3579 get_aarch64_segment_type (unsigned long type
)
3583 case PT_AARCH64_ARCHEXT
:
3584 return "AARCH64_ARCHEXT";
3593 get_arm_segment_type (unsigned long type
)
3607 get_mips_segment_type (unsigned long type
)
3611 case PT_MIPS_REGINFO
:
3613 case PT_MIPS_RTPROC
:
3615 case PT_MIPS_OPTIONS
:
3617 case PT_MIPS_ABIFLAGS
:
3627 get_parisc_segment_type (unsigned long type
)
3631 case PT_HP_TLS
: return "HP_TLS";
3632 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3633 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3634 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3635 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3636 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3637 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3638 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3639 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3640 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3641 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3642 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3643 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3644 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3645 case PT_HP_STACK
: return "HP_STACK";
3646 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3647 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3648 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3649 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3658 get_ia64_segment_type (unsigned long type
)
3662 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3663 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3664 case PT_HP_TLS
: return "HP_TLS";
3665 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3666 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3667 case PT_IA_64_HP_STACK
: return "HP_STACK";
3676 get_tic6x_segment_type (unsigned long type
)
3680 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3689 get_solaris_segment_type (unsigned long type
)
3693 case 0x6464e550: return "PT_SUNW_UNWIND";
3694 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3695 case 0x6ffffff7: return "PT_LOSUNW";
3696 case 0x6ffffffa: return "PT_SUNWBSS";
3697 case 0x6ffffffb: return "PT_SUNWSTACK";
3698 case 0x6ffffffc: return "PT_SUNWDTRACE";
3699 case 0x6ffffffd: return "PT_SUNWCAP";
3700 case 0x6fffffff: return "PT_HISUNW";
3701 default: return NULL
;
3706 get_segment_type (unsigned long p_type
)
3708 static char buff
[32];
3712 case PT_NULL
: return "NULL";
3713 case PT_LOAD
: return "LOAD";
3714 case PT_DYNAMIC
: return "DYNAMIC";
3715 case PT_INTERP
: return "INTERP";
3716 case PT_NOTE
: return "NOTE";
3717 case PT_SHLIB
: return "SHLIB";
3718 case PT_PHDR
: return "PHDR";
3719 case PT_TLS
: return "TLS";
3721 case PT_GNU_EH_FRAME
:
3722 return "GNU_EH_FRAME";
3723 case PT_GNU_STACK
: return "GNU_STACK";
3724 case PT_GNU_RELRO
: return "GNU_RELRO";
3727 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3729 const char * result
;
3731 switch (elf_header
.e_machine
)
3734 result
= get_aarch64_segment_type (p_type
);
3737 result
= get_arm_segment_type (p_type
);
3740 case EM_MIPS_RS3_LE
:
3741 result
= get_mips_segment_type (p_type
);
3744 result
= get_parisc_segment_type (p_type
);
3747 result
= get_ia64_segment_type (p_type
);
3750 result
= get_tic6x_segment_type (p_type
);
3760 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3762 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3764 const char * result
;
3766 switch (elf_header
.e_machine
)
3769 result
= get_parisc_segment_type (p_type
);
3772 result
= get_ia64_segment_type (p_type
);
3775 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3776 result
= get_solaris_segment_type (p_type
);
3785 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3788 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3795 get_mips_section_type_name (unsigned int sh_type
)
3799 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3800 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3801 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3802 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3803 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3804 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3805 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3806 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3807 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3808 case SHT_MIPS_RELD
: return "MIPS_RELD";
3809 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3810 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3811 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3812 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3813 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3814 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3815 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3816 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3817 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3818 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3819 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3820 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3821 case SHT_MIPS_LINE
: return "MIPS_LINE";
3822 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3823 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3824 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3825 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3826 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3827 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3828 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3829 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3830 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3831 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3832 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3833 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3834 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3835 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3836 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3837 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3838 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3846 get_parisc_section_type_name (unsigned int sh_type
)
3850 case SHT_PARISC_EXT
: return "PARISC_EXT";
3851 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3852 case SHT_PARISC_DOC
: return "PARISC_DOC";
3853 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3854 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3855 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3856 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3864 get_ia64_section_type_name (unsigned int sh_type
)
3866 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3867 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3868 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3872 case SHT_IA_64_EXT
: return "IA_64_EXT";
3873 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3874 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3875 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3876 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3877 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3878 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3879 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3880 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3881 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3889 get_x86_64_section_type_name (unsigned int sh_type
)
3893 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3901 get_aarch64_section_type_name (unsigned int sh_type
)
3905 case SHT_AARCH64_ATTRIBUTES
:
3906 return "AARCH64_ATTRIBUTES";
3914 get_arm_section_type_name (unsigned int sh_type
)
3918 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3919 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3920 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3921 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3922 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3930 get_tic6x_section_type_name (unsigned int sh_type
)
3934 case SHT_C6000_UNWIND
:
3935 return "C6000_UNWIND";
3936 case SHT_C6000_PREEMPTMAP
:
3937 return "C6000_PREEMPTMAP";
3938 case SHT_C6000_ATTRIBUTES
:
3939 return "C6000_ATTRIBUTES";
3944 case SHT_TI_HANDLER
:
3945 return "TI_HANDLER";
3946 case SHT_TI_INITINFO
:
3947 return "TI_INITINFO";
3948 case SHT_TI_PHATTRS
:
3949 return "TI_PHATTRS";
3957 get_msp430x_section_type_name (unsigned int sh_type
)
3961 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3962 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3963 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3964 default: return NULL
;
3969 get_v850_section_type_name (unsigned int sh_type
)
3973 case SHT_V850_SCOMMON
: return "V850 Small Common";
3974 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3975 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3976 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3977 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3978 default: return NULL
;
3983 get_section_type_name (unsigned int sh_type
)
3985 static char buff
[32];
3986 const char * result
;
3990 case SHT_NULL
: return "NULL";
3991 case SHT_PROGBITS
: return "PROGBITS";
3992 case SHT_SYMTAB
: return "SYMTAB";
3993 case SHT_STRTAB
: return "STRTAB";
3994 case SHT_RELA
: return "RELA";
3995 case SHT_HASH
: return "HASH";
3996 case SHT_DYNAMIC
: return "DYNAMIC";
3997 case SHT_NOTE
: return "NOTE";
3998 case SHT_NOBITS
: return "NOBITS";
3999 case SHT_REL
: return "REL";
4000 case SHT_SHLIB
: return "SHLIB";
4001 case SHT_DYNSYM
: return "DYNSYM";
4002 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4003 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4004 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4005 case SHT_GNU_HASH
: return "GNU_HASH";
4006 case SHT_GROUP
: return "GROUP";
4007 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4008 case SHT_GNU_verdef
: return "VERDEF";
4009 case SHT_GNU_verneed
: return "VERNEED";
4010 case SHT_GNU_versym
: return "VERSYM";
4011 case 0x6ffffff0: return "VERSYM";
4012 case 0x6ffffffc: return "VERDEF";
4013 case 0x7ffffffd: return "AUXILIARY";
4014 case 0x7fffffff: return "FILTER";
4015 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4018 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4020 switch (elf_header
.e_machine
)
4023 case EM_MIPS_RS3_LE
:
4024 result
= get_mips_section_type_name (sh_type
);
4027 result
= get_parisc_section_type_name (sh_type
);
4030 result
= get_ia64_section_type_name (sh_type
);
4035 result
= get_x86_64_section_type_name (sh_type
);
4038 result
= get_aarch64_section_type_name (sh_type
);
4041 result
= get_arm_section_type_name (sh_type
);
4044 result
= get_tic6x_section_type_name (sh_type
);
4047 result
= get_msp430x_section_type_name (sh_type
);
4051 case EM_CYGNUS_V850
:
4052 result
= get_v850_section_type_name (sh_type
);
4062 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4064 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4066 switch (elf_header
.e_machine
)
4069 result
= get_ia64_section_type_name (sh_type
);
4072 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4073 result
= get_solaris_section_type (sh_type
);
4082 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4084 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4086 switch (elf_header
.e_machine
)
4090 case EM_CYGNUS_V850
:
4091 result
= get_v850_section_type_name (sh_type
);
4101 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4104 /* This message is probably going to be displayed in a 15
4105 character wide field, so put the hex value first. */
4106 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4112 #define OPTION_DEBUG_DUMP 512
4113 #define OPTION_DYN_SYMS 513
4114 #define OPTION_DWARF_DEPTH 514
4115 #define OPTION_DWARF_START 515
4116 #define OPTION_DWARF_CHECK 516
4118 static struct option options
[] =
4120 {"all", no_argument
, 0, 'a'},
4121 {"file-header", no_argument
, 0, 'h'},
4122 {"program-headers", no_argument
, 0, 'l'},
4123 {"headers", no_argument
, 0, 'e'},
4124 {"histogram", no_argument
, 0, 'I'},
4125 {"segments", no_argument
, 0, 'l'},
4126 {"sections", no_argument
, 0, 'S'},
4127 {"section-headers", no_argument
, 0, 'S'},
4128 {"section-groups", no_argument
, 0, 'g'},
4129 {"section-details", no_argument
, 0, 't'},
4130 {"full-section-name",no_argument
, 0, 'N'},
4131 {"symbols", no_argument
, 0, 's'},
4132 {"syms", no_argument
, 0, 's'},
4133 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4134 {"relocs", no_argument
, 0, 'r'},
4135 {"notes", no_argument
, 0, 'n'},
4136 {"dynamic", no_argument
, 0, 'd'},
4137 {"arch-specific", no_argument
, 0, 'A'},
4138 {"version-info", no_argument
, 0, 'V'},
4139 {"use-dynamic", no_argument
, 0, 'D'},
4140 {"unwind", no_argument
, 0, 'u'},
4141 {"archive-index", no_argument
, 0, 'c'},
4142 {"hex-dump", required_argument
, 0, 'x'},
4143 {"relocated-dump", required_argument
, 0, 'R'},
4144 {"string-dump", required_argument
, 0, 'p'},
4145 {"decompress", no_argument
, 0, 'z'},
4146 #ifdef SUPPORT_DISASSEMBLY
4147 {"instruction-dump", required_argument
, 0, 'i'},
4149 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4151 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4152 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4153 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4155 {"version", no_argument
, 0, 'v'},
4156 {"wide", no_argument
, 0, 'W'},
4157 {"help", no_argument
, 0, 'H'},
4158 {0, no_argument
, 0, 0}
4162 usage (FILE * stream
)
4164 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4165 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4166 fprintf (stream
, _(" Options are:\n\
4167 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4168 -h --file-header Display the ELF file header\n\
4169 -l --program-headers Display the program headers\n\
4170 --segments An alias for --program-headers\n\
4171 -S --section-headers Display the sections' header\n\
4172 --sections An alias for --section-headers\n\
4173 -g --section-groups Display the section groups\n\
4174 -t --section-details Display the section details\n\
4175 -e --headers Equivalent to: -h -l -S\n\
4176 -s --syms Display the symbol table\n\
4177 --symbols An alias for --syms\n\
4178 --dyn-syms Display the dynamic symbol table\n\
4179 -n --notes Display the core notes (if present)\n\
4180 -r --relocs Display the relocations (if present)\n\
4181 -u --unwind Display the unwind info (if present)\n\
4182 -d --dynamic Display the dynamic section (if present)\n\
4183 -V --version-info Display the version sections (if present)\n\
4184 -A --arch-specific Display architecture specific information (if any)\n\
4185 -c --archive-index Display the symbol/file index in an archive\n\
4186 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4187 -x --hex-dump=<number|name>\n\
4188 Dump the contents of section <number|name> as bytes\n\
4189 -p --string-dump=<number|name>\n\
4190 Dump the contents of section <number|name> as strings\n\
4191 -R --relocated-dump=<number|name>\n\
4192 Dump the contents of section <number|name> as relocated bytes\n\
4193 -z --decompress Decompress section before dumping it\n\
4194 -w[lLiaprmfFsoRt] or\n\
4195 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4196 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4197 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4199 Display the contents of DWARF2 debug sections\n"));
4200 fprintf (stream
, _("\
4201 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4202 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4204 #ifdef SUPPORT_DISASSEMBLY
4205 fprintf (stream
, _("\
4206 -i --instruction-dump=<number|name>\n\
4207 Disassemble the contents of section <number|name>\n"));
4209 fprintf (stream
, _("\
4210 -I --histogram Display histogram of bucket list lengths\n\
4211 -W --wide Allow output width to exceed 80 characters\n\
4212 @<file> Read options from <file>\n\
4213 -H --help Display this information\n\
4214 -v --version Display the version number of readelf\n"));
4216 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4217 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4219 exit (stream
== stdout
? 0 : 1);
4222 /* Record the fact that the user wants the contents of section number
4223 SECTION to be displayed using the method(s) encoded as flags bits
4224 in TYPE. Note, TYPE can be zero if we are creating the array for
4228 request_dump_bynumber (unsigned int section
, dump_type type
)
4230 if (section
>= num_dump_sects
)
4232 dump_type
* new_dump_sects
;
4234 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4235 sizeof (* dump_sects
));
4237 if (new_dump_sects
== NULL
)
4238 error (_("Out of memory allocating dump request table.\n"));
4243 /* Copy current flag settings. */
4244 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_PURECODE") },
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_PURECODE
: 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_PURECODE
)
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
;
5629 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5630 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5631 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5632 return sizeof (*echdr
);
5636 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5638 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5639 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5640 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5641 return sizeof (*echdr
);
5646 process_section_headers (FILE * file
)
5648 Elf_Internal_Shdr
* section
;
5651 section_headers
= NULL
;
5653 if (elf_header
.e_shnum
== 0)
5655 /* PR binutils/12467. */
5656 if (elf_header
.e_shoff
!= 0)
5657 warn (_("possibly corrupt ELF file header - it has a non-zero"
5658 " section header offset, but no section headers\n"));
5659 else if (do_sections
)
5660 printf (_("\nThere are no sections in this file.\n"));
5665 if (do_sections
&& !do_header
)
5666 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5667 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5671 if (! get_32bit_section_headers (file
, FALSE
))
5674 else if (! get_64bit_section_headers (file
, FALSE
))
5677 /* Read in the string table, so that we have names to display. */
5678 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5679 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5681 section
= section_headers
+ elf_header
.e_shstrndx
;
5683 if (section
->sh_size
!= 0)
5685 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5686 1, section
->sh_size
,
5689 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5693 /* Scan the sections for the dynamic symbol table
5694 and dynamic string table and debug sections. */
5695 dynamic_symbols
= NULL
;
5696 dynamic_strings
= NULL
;
5697 dynamic_syminfo
= NULL
;
5698 symtab_shndx_list
= NULL
;
5700 eh_addr_size
= is_32bit_elf
? 4 : 8;
5701 switch (elf_header
.e_machine
)
5704 case EM_MIPS_RS3_LE
:
5705 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5706 FDE addresses. However, the ABI also has a semi-official ILP32
5707 variant for which the normal FDE address size rules apply.
5709 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5710 section, where XX is the size of longs in bits. Unfortunately,
5711 earlier compilers provided no way of distinguishing ILP32 objects
5712 from LP64 objects, so if there's any doubt, we should assume that
5713 the official LP64 form is being used. */
5714 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5715 && find_section (".gcc_compiled_long32") == NULL
)
5721 switch (elf_header
.e_flags
& EF_H8_MACH
)
5723 case E_H8_MACH_H8300
:
5724 case E_H8_MACH_H8300HN
:
5725 case E_H8_MACH_H8300SN
:
5726 case E_H8_MACH_H8300SXN
:
5729 case E_H8_MACH_H8300H
:
5730 case E_H8_MACH_H8300S
:
5731 case E_H8_MACH_H8300SX
:
5739 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5741 case EF_M32C_CPU_M16C
:
5748 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5751 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5752 if (section->sh_entsize != expected_entsize) \
5755 sprintf_vma (buf, section->sh_entsize); \
5756 /* Note: coded this way so that there is a single string for \
5758 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5759 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5760 (unsigned) expected_entsize); \
5761 section->sh_entsize = expected_entsize; \
5766 #define CHECK_ENTSIZE(section, i, type) \
5767 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5768 sizeof (Elf64_External_##type))
5770 for (i
= 0, section
= section_headers
;
5771 i
< elf_header
.e_shnum
;
5774 char * name
= SECTION_NAME (section
);
5776 if (section
->sh_type
== SHT_DYNSYM
)
5778 if (dynamic_symbols
!= NULL
)
5780 error (_("File contains multiple dynamic symbol tables\n"));
5784 CHECK_ENTSIZE (section
, i
, Sym
);
5785 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5787 else if (section
->sh_type
== SHT_STRTAB
5788 && streq (name
, ".dynstr"))
5790 if (dynamic_strings
!= NULL
)
5792 error (_("File contains multiple dynamic string tables\n"));
5796 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5797 1, section
->sh_size
,
5798 _("dynamic strings"));
5799 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5801 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5803 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5804 entry
->hdr
= section
;
5805 entry
->next
= symtab_shndx_list
;
5806 symtab_shndx_list
= entry
;
5808 else if (section
->sh_type
== SHT_SYMTAB
)
5809 CHECK_ENTSIZE (section
, i
, Sym
);
5810 else if (section
->sh_type
== SHT_GROUP
)
5811 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5812 else if (section
->sh_type
== SHT_REL
)
5813 CHECK_ENTSIZE (section
, i
, Rel
);
5814 else if (section
->sh_type
== SHT_RELA
)
5815 CHECK_ENTSIZE (section
, i
, Rela
);
5816 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5817 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5818 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5819 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5820 || do_debug_addr
|| do_debug_cu_index
)
5821 && (const_strneq (name
, ".debug_")
5822 || const_strneq (name
, ".zdebug_")))
5825 name
+= sizeof (".zdebug_") - 1;
5827 name
+= sizeof (".debug_") - 1;
5830 || (do_debug_info
&& const_strneq (name
, "info"))
5831 || (do_debug_info
&& const_strneq (name
, "types"))
5832 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5833 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5834 || (do_debug_lines
&& const_strneq (name
, "line."))
5835 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5836 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5837 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5838 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5839 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5840 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5841 || (do_debug_frames
&& const_strneq (name
, "frame"))
5842 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5843 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5844 || (do_debug_str
&& const_strneq (name
, "str"))
5845 || (do_debug_loc
&& const_strneq (name
, "loc"))
5846 || (do_debug_addr
&& const_strneq (name
, "addr"))
5847 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5848 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5850 request_dump_bynumber (i
, DEBUG_DUMP
);
5852 /* Linkonce section to be combined with .debug_info at link time. */
5853 else if ((do_debugging
|| do_debug_info
)
5854 && const_strneq (name
, ".gnu.linkonce.wi."))
5855 request_dump_bynumber (i
, DEBUG_DUMP
);
5856 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5857 request_dump_bynumber (i
, DEBUG_DUMP
);
5858 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5859 request_dump_bynumber (i
, DEBUG_DUMP
);
5860 /* Trace sections for Itanium VMS. */
5861 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5862 || do_trace_aranges
)
5863 && const_strneq (name
, ".trace_"))
5865 name
+= sizeof (".trace_") - 1;
5868 || (do_trace_info
&& streq (name
, "info"))
5869 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5870 || (do_trace_aranges
&& streq (name
, "aranges"))
5872 request_dump_bynumber (i
, DEBUG_DUMP
);
5879 if (elf_header
.e_shnum
> 1)
5880 printf (_("\nSection Headers:\n"));
5882 printf (_("\nSection Header:\n"));
5886 if (do_section_details
)
5888 printf (_(" [Nr] Name\n"));
5889 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5893 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5897 if (do_section_details
)
5899 printf (_(" [Nr] Name\n"));
5900 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5904 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5908 if (do_section_details
)
5910 printf (_(" [Nr] Name\n"));
5911 printf (_(" Type Address Offset Link\n"));
5912 printf (_(" Size EntSize Info Align\n"));
5916 printf (_(" [Nr] Name Type Address Offset\n"));
5917 printf (_(" Size EntSize Flags Link Info Align\n"));
5921 if (do_section_details
)
5922 printf (_(" Flags\n"));
5924 for (i
= 0, section
= section_headers
;
5925 i
< elf_header
.e_shnum
;
5928 /* Run some sanity checks on the section header. */
5930 /* Check the sh_link field. */
5931 switch (section
->sh_type
)
5933 case SHT_SYMTAB_SHNDX
:
5937 case SHT_GNU_versym
:
5940 if (section
->sh_link
< 1
5941 || section
->sh_link
> elf_header
.e_shnum
5942 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
5943 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
5944 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
5945 i
, section
->sh_link
);
5951 case SHT_GNU_verneed
:
5952 case SHT_GNU_verdef
:
5953 case SHT_GNU_LIBLIST
:
5954 if (section
->sh_link
< 1
5955 || section
->sh_link
> elf_header
.e_shnum
5956 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
5957 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
5958 i
, section
->sh_link
);
5961 case SHT_INIT_ARRAY
:
5962 case SHT_FINI_ARRAY
:
5963 case SHT_PREINIT_ARRAY
:
5964 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
5965 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
5966 i
, section
->sh_link
);
5970 /* FIXME: Add support for target specific section types. */
5971 #if 0 /* Currently we do not check other section types as there are too
5972 many special cases. Stab sections for example have a type
5973 of SHT_PROGBITS but an sh_link field that links to the .stabstr
5975 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
5976 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
5977 i
, section
->sh_link
);
5982 /* Check the sh_info field. */
5983 switch (section
->sh_type
)
5987 if (section
->sh_info
< 1
5988 || section
->sh_info
> elf_header
.e_shnum
5989 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
5990 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
5991 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
5992 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
5993 /* FIXME: Are other section types valid ? */
5994 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
5996 if (section
->sh_info
== 0
5997 && (streq (SECTION_NAME (section
), ".rel.dyn")
5998 || streq (SECTION_NAME (section
), ".rela.dyn")))
5999 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6000 of zero. No idea why. I would have expected the index
6001 of the .plt section. */
6004 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6005 i
, section
->sh_info
);
6011 case SHT_SYMTAB_SHNDX
:
6012 case SHT_INIT_ARRAY
:
6013 case SHT_FINI_ARRAY
:
6014 case SHT_PREINIT_ARRAY
:
6015 if (section
->sh_info
!= 0)
6016 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6017 i
, section
->sh_info
);
6023 /* A symbol index - we assume that it is valid. */
6027 /* FIXME: Add support for target specific section types. */
6028 if (section
->sh_type
== SHT_NOBITS
)
6029 /* NOBITS section headers with non-zero sh_info fields can be
6030 created when a binary is stripped of everything but its debug
6031 information. The stripped sections have their headers preserved but their types set to SHT_NOBITS. so do not check this type of section. */
6033 else if (section
->sh_flags
& SHF_INFO_LINK
)
6035 if (section
->sh_info
< 1 || section
->sh_info
> elf_header
.e_shnum
)
6036 warn (_("[%2u]: Expected link to another section in info field"), i
);
6038 else if (section
->sh_type
< SHT_LOOS
&& section
->sh_info
!= 0)
6039 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6040 i
, section
->sh_info
);
6044 printf (" [%2u] ", i
);
6045 if (do_section_details
)
6046 printf ("%s\n ", printable_section_name (section
));
6048 print_symbol (-17, SECTION_NAME (section
));
6050 printf (do_wide
? " %-15s " : " %-15.15s ",
6051 get_section_type_name (section
->sh_type
));
6055 const char * link_too_big
= NULL
;
6057 print_vma (section
->sh_addr
, LONG_HEX
);
6059 printf ( " %6.6lx %6.6lx %2.2lx",
6060 (unsigned long) section
->sh_offset
,
6061 (unsigned long) section
->sh_size
,
6062 (unsigned long) section
->sh_entsize
);
6064 if (do_section_details
)
6065 fputs (" ", stdout
);
6067 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6069 if (section
->sh_link
>= elf_header
.e_shnum
)
6072 /* The sh_link value is out of range. Normally this indicates
6073 an error but it can have special values in Solaris binaries. */
6074 switch (elf_header
.e_machine
)
6081 case EM_OLD_SPARCV9
:
6082 case EM_SPARC32PLUS
:
6085 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6086 link_too_big
= "BEFORE";
6087 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6088 link_too_big
= "AFTER";
6095 if (do_section_details
)
6097 if (link_too_big
!= NULL
&& * link_too_big
)
6098 printf ("<%s> ", link_too_big
);
6100 printf ("%2u ", section
->sh_link
);
6101 printf ("%3u %2lu\n", section
->sh_info
,
6102 (unsigned long) section
->sh_addralign
);
6105 printf ("%2u %3u %2lu\n",
6108 (unsigned long) section
->sh_addralign
);
6110 if (link_too_big
&& ! * link_too_big
)
6111 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6112 i
, section
->sh_link
);
6116 print_vma (section
->sh_addr
, LONG_HEX
);
6118 if ((long) section
->sh_offset
== section
->sh_offset
)
6119 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6123 print_vma (section
->sh_offset
, LONG_HEX
);
6126 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6127 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6131 print_vma (section
->sh_size
, LONG_HEX
);
6134 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6135 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6139 print_vma (section
->sh_entsize
, LONG_HEX
);
6142 if (do_section_details
)
6143 fputs (" ", stdout
);
6145 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6147 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6149 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6150 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6153 print_vma (section
->sh_addralign
, DEC
);
6157 else if (do_section_details
)
6159 printf (" %-15.15s ",
6160 get_section_type_name (section
->sh_type
));
6161 print_vma (section
->sh_addr
, LONG_HEX
);
6162 if ((long) section
->sh_offset
== section
->sh_offset
)
6163 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6167 print_vma (section
->sh_offset
, LONG_HEX
);
6169 printf (" %u\n ", section
->sh_link
);
6170 print_vma (section
->sh_size
, LONG_HEX
);
6172 print_vma (section
->sh_entsize
, LONG_HEX
);
6174 printf (" %-16u %lu\n",
6176 (unsigned long) section
->sh_addralign
);
6181 print_vma (section
->sh_addr
, LONG_HEX
);
6182 if ((long) section
->sh_offset
== section
->sh_offset
)
6183 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6187 print_vma (section
->sh_offset
, LONG_HEX
);
6190 print_vma (section
->sh_size
, LONG_HEX
);
6192 print_vma (section
->sh_entsize
, LONG_HEX
);
6194 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6196 printf (" %2u %3u %lu\n",
6199 (unsigned long) section
->sh_addralign
);
6202 if (do_section_details
)
6204 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6205 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6207 /* Minimum section size is 12 bytes for 32-bit compression
6208 header + 12 bytes for compressed data header. */
6209 unsigned char buf
[24];
6211 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6212 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6213 sizeof (buf
), _("compression header")))
6215 Elf_Internal_Chdr chdr
;
6217 (void) get_compression_header (&chdr
, buf
);
6219 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6222 printf (_(" [<unknown>: 0x%x], "),
6224 print_vma (chdr
.ch_size
, LONG_HEX
);
6225 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6231 if (!do_section_details
)
6233 /* The ordering of the letters shown here matches the ordering of the
6234 corresponding SHF_xxx values, and hence the order in which these
6235 letters will be displayed to the user. */
6236 printf (_("Key to Flags:\n\
6237 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6238 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6239 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6240 if (elf_header
.e_machine
== EM_X86_64
6241 || elf_header
.e_machine
== EM_L1OM
6242 || elf_header
.e_machine
== EM_K1OM
)
6243 printf (_("l (large), "));
6244 else if (elf_header
.e_machine
== EM_ARM
)
6245 printf (_("y (purecode), "));
6246 printf ("p (processor specific)\n");
6253 get_group_flags (unsigned int flags
)
6255 static char buff
[32];
6265 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
6272 process_section_groups (FILE * file
)
6274 Elf_Internal_Shdr
* section
;
6276 struct group
* group
;
6277 Elf_Internal_Shdr
* symtab_sec
;
6278 Elf_Internal_Shdr
* strtab_sec
;
6279 Elf_Internal_Sym
* symtab
;
6280 unsigned long num_syms
;
6284 /* Don't process section groups unless needed. */
6285 if (!do_unwind
&& !do_section_groups
)
6288 if (elf_header
.e_shnum
== 0)
6290 if (do_section_groups
)
6291 printf (_("\nThere are no sections to group in this file.\n"));
6296 if (section_headers
== NULL
)
6298 error (_("Section headers are not available!\n"));
6299 /* PR 13622: This can happen with a corrupt ELF header. */
6303 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6304 sizeof (struct group
*));
6306 if (section_headers_groups
== NULL
)
6308 error (_("Out of memory reading %u section group headers\n"),
6309 elf_header
.e_shnum
);
6313 /* Scan the sections for the group section. */
6315 for (i
= 0, section
= section_headers
;
6316 i
< elf_header
.e_shnum
;
6318 if (section
->sh_type
== SHT_GROUP
)
6321 if (group_count
== 0)
6323 if (do_section_groups
)
6324 printf (_("\nThere are no section groups in this file.\n"));
6329 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6331 if (section_groups
== NULL
)
6333 error (_("Out of memory reading %lu groups\n"),
6334 (unsigned long) group_count
);
6344 for (i
= 0, section
= section_headers
, group
= section_groups
;
6345 i
< elf_header
.e_shnum
;
6348 if (section
->sh_type
== SHT_GROUP
)
6350 const char * name
= printable_section_name (section
);
6351 const char * group_name
;
6352 unsigned char * start
;
6353 unsigned char * indices
;
6354 unsigned int entry
, j
, size
;
6355 Elf_Internal_Shdr
* sec
;
6356 Elf_Internal_Sym
* sym
;
6358 /* Get the symbol table. */
6359 if (section
->sh_link
>= elf_header
.e_shnum
6360 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6363 error (_("Bad sh_link in group section `%s'\n"), name
);
6367 if (symtab_sec
!= sec
)
6372 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6377 error (_("Corrupt header in group section `%s'\n"), name
);
6381 if (section
->sh_info
>= num_syms
)
6383 error (_("Bad sh_info in group section `%s'\n"), name
);
6387 sym
= symtab
+ section
->sh_info
;
6389 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6391 if (sym
->st_shndx
== 0
6392 || sym
->st_shndx
>= elf_header
.e_shnum
)
6394 error (_("Bad sh_info in group section `%s'\n"), name
);
6398 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6407 /* Get the string table. */
6408 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6417 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6423 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6424 1, strtab_sec
->sh_size
,
6426 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6428 group_name
= sym
->st_name
< strtab_size
6429 ? strtab
+ sym
->st_name
: _("<corrupt>");
6432 /* PR 17531: file: loop. */
6433 if (section
->sh_entsize
> section
->sh_size
)
6435 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6436 printable_section_name (section
),
6437 (unsigned long) section
->sh_entsize
,
6438 (unsigned long) section
->sh_size
);
6442 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6443 1, section
->sh_size
,
6449 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6450 entry
= byte_get (indices
, 4);
6453 if (do_section_groups
)
6455 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6456 get_group_flags (entry
), i
, name
, group_name
, size
);
6458 printf (_(" [Index] Name\n"));
6461 group
->group_index
= i
;
6463 for (j
= 0; j
< size
; j
++)
6465 struct group_list
* g
;
6467 entry
= byte_get (indices
, 4);
6470 if (entry
>= elf_header
.e_shnum
)
6472 static unsigned num_group_errors
= 0;
6474 if (num_group_errors
++ < 10)
6476 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6477 entry
, i
, elf_header
.e_shnum
- 1);
6478 if (num_group_errors
== 10)
6479 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6484 if (section_headers_groups
[entry
] != NULL
)
6488 static unsigned num_errs
= 0;
6490 if (num_errs
++ < 10)
6492 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6494 section_headers_groups
[entry
]->group_index
);
6496 warn (_("Further error messages about already contained group sections suppressed\n"));
6502 /* Intel C/C++ compiler may put section 0 in a
6503 section group. We just warn it the first time
6504 and ignore it afterwards. */
6505 static int warned
= 0;
6508 error (_("section 0 in group section [%5u]\n"),
6509 section_headers_groups
[entry
]->group_index
);
6515 section_headers_groups
[entry
] = group
;
6517 if (do_section_groups
)
6519 sec
= section_headers
+ entry
;
6520 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6523 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6524 g
->section_index
= entry
;
6525 g
->next
= group
->root
;
6543 /* Data used to display dynamic fixups. */
6545 struct ia64_vms_dynfixup
6547 bfd_vma needed_ident
; /* Library ident number. */
6548 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6549 bfd_vma fixup_needed
; /* Index of the library. */
6550 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6551 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6554 /* Data used to display dynamic relocations. */
6556 struct ia64_vms_dynimgrela
6558 bfd_vma img_rela_cnt
; /* Number of relocations. */
6559 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6562 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6566 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6567 const char *strtab
, unsigned int strtab_sz
)
6569 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6571 const char *lib_name
;
6573 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6574 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6575 _("dynamic section image fixups"));
6579 if (fixup
->needed
< strtab_sz
)
6580 lib_name
= strtab
+ fixup
->needed
;
6583 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6584 (unsigned long) fixup
->needed
);
6587 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6588 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6590 (_("Seg Offset Type SymVec DataType\n"));
6592 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6597 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6598 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6599 type
= BYTE_GET (imfs
[i
].type
);
6600 rtype
= elf_ia64_reloc_type (type
);
6602 printf (" 0x%08x ", type
);
6604 printf (" %-32s ", rtype
);
6605 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6606 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6612 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6615 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6617 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6620 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6621 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6622 _("dynamic section image relocations"));
6626 printf (_("\nImage relocs\n"));
6628 (_("Seg Offset Type Addend Seg Sym Off\n"));
6630 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6635 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6636 printf ("%08" BFD_VMA_FMT
"x ",
6637 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6638 type
= BYTE_GET (imrs
[i
].type
);
6639 rtype
= elf_ia64_reloc_type (type
);
6641 printf ("0x%08x ", type
);
6643 printf ("%-31s ", rtype
);
6644 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6645 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6646 printf ("%08" BFD_VMA_FMT
"x\n",
6647 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6653 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6656 process_ia64_vms_dynamic_relocs (FILE *file
)
6658 struct ia64_vms_dynfixup fixup
;
6659 struct ia64_vms_dynimgrela imgrela
;
6660 Elf_Internal_Dyn
*entry
;
6662 bfd_vma strtab_off
= 0;
6663 bfd_vma strtab_sz
= 0;
6664 char *strtab
= NULL
;
6666 memset (&fixup
, 0, sizeof (fixup
));
6667 memset (&imgrela
, 0, sizeof (imgrela
));
6669 /* Note: the order of the entries is specified by the OpenVMS specs. */
6670 for (entry
= dynamic_section
;
6671 entry
< dynamic_section
+ dynamic_nent
;
6674 switch (entry
->d_tag
)
6676 case DT_IA_64_VMS_STRTAB_OFFSET
:
6677 strtab_off
= entry
->d_un
.d_val
;
6680 strtab_sz
= entry
->d_un
.d_val
;
6682 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6683 1, strtab_sz
, _("dynamic string section"));
6686 case DT_IA_64_VMS_NEEDED_IDENT
:
6687 fixup
.needed_ident
= entry
->d_un
.d_val
;
6690 fixup
.needed
= entry
->d_un
.d_val
;
6692 case DT_IA_64_VMS_FIXUP_NEEDED
:
6693 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6695 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6696 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6698 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6699 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6701 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6704 case DT_IA_64_VMS_IMG_RELA_CNT
:
6705 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6707 case DT_IA_64_VMS_IMG_RELA_OFF
:
6708 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6710 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6730 } dynamic_relocations
[] =
6732 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6733 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6734 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6737 /* Process the reloc section. */
6740 process_relocs (FILE * file
)
6742 unsigned long rel_size
;
6743 unsigned long rel_offset
;
6749 if (do_using_dynamic
)
6753 int has_dynamic_reloc
;
6756 has_dynamic_reloc
= 0;
6758 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6760 is_rela
= dynamic_relocations
[i
].rela
;
6761 name
= dynamic_relocations
[i
].name
;
6762 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6763 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6765 has_dynamic_reloc
|= rel_size
;
6767 if (is_rela
== UNKNOWN
)
6769 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6770 switch (dynamic_info
[DT_PLTREL
])
6784 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6785 name
, rel_offset
, rel_size
);
6787 dump_relocations (file
,
6788 offset_from_vma (file
, rel_offset
, rel_size
),
6790 dynamic_symbols
, num_dynamic_syms
,
6791 dynamic_strings
, dynamic_strings_length
,
6797 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6799 if (! has_dynamic_reloc
)
6800 printf (_("\nThere are no dynamic relocations in this file.\n"));
6804 Elf_Internal_Shdr
* section
;
6808 for (i
= 0, section
= section_headers
;
6809 i
< elf_header
.e_shnum
;
6812 if ( section
->sh_type
!= SHT_RELA
6813 && section
->sh_type
!= SHT_REL
)
6816 rel_offset
= section
->sh_offset
;
6817 rel_size
= section
->sh_size
;
6821 Elf_Internal_Shdr
* strsec
;
6824 printf (_("\nRelocation section "));
6826 if (string_table
== NULL
)
6827 printf ("%d", section
->sh_name
);
6829 printf ("'%s'", printable_section_name (section
));
6831 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6832 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6834 is_rela
= section
->sh_type
== SHT_RELA
;
6836 if (section
->sh_link
!= 0
6837 && section
->sh_link
< elf_header
.e_shnum
)
6839 Elf_Internal_Shdr
* symsec
;
6840 Elf_Internal_Sym
* symtab
;
6841 unsigned long nsyms
;
6842 unsigned long strtablen
= 0;
6843 char * strtab
= NULL
;
6845 symsec
= section_headers
+ section
->sh_link
;
6846 if (symsec
->sh_type
!= SHT_SYMTAB
6847 && symsec
->sh_type
!= SHT_DYNSYM
)
6850 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6855 if (symsec
->sh_link
!= 0
6856 && symsec
->sh_link
< elf_header
.e_shnum
)
6858 strsec
= section_headers
+ symsec
->sh_link
;
6860 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6863 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6866 dump_relocations (file
, rel_offset
, rel_size
,
6867 symtab
, nsyms
, strtab
, strtablen
,
6869 symsec
->sh_type
== SHT_DYNSYM
);
6875 dump_relocations (file
, rel_offset
, rel_size
,
6876 NULL
, 0, NULL
, 0, is_rela
, 0);
6883 printf (_("\nThere are no relocations in this file.\n"));
6889 /* An absolute address consists of a section and an offset. If the
6890 section is NULL, the offset itself is the address, otherwise, the
6891 address equals to LOAD_ADDRESS(section) + offset. */
6895 unsigned short section
;
6899 #define ABSADDR(a) \
6901 ? section_headers [(a).section].sh_addr + (a).offset \
6904 /* Find the nearest symbol at or below ADDR. Returns the symbol
6905 name, if found, and the offset from the symbol to ADDR. */
6908 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6909 unsigned long nsyms
,
6910 const char * strtab
,
6911 unsigned long strtab_size
,
6912 struct absaddr addr
,
6913 const char ** symname
,
6916 bfd_vma dist
= 0x100000;
6917 Elf_Internal_Sym
* sym
;
6918 Elf_Internal_Sym
* beg
;
6919 Elf_Internal_Sym
* end
;
6920 Elf_Internal_Sym
* best
= NULL
;
6922 REMOVE_ARCH_BITS (addr
.offset
);
6924 end
= symtab
+ nsyms
;
6930 sym
= beg
+ (end
- beg
) / 2;
6932 value
= sym
->st_value
;
6933 REMOVE_ARCH_BITS (value
);
6935 if (sym
->st_name
!= 0
6936 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6937 && addr
.offset
>= value
6938 && addr
.offset
- value
< dist
)
6941 dist
= addr
.offset
- value
;
6946 if (addr
.offset
< value
)
6954 *symname
= (best
->st_name
>= strtab_size
6955 ? _("<corrupt>") : strtab
+ best
->st_name
);
6961 *offset
= addr
.offset
;
6965 symcmp (const void *p
, const void *q
)
6967 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6968 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6970 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6973 /* Process the unwind section. */
6975 #include "unwind-ia64.h"
6977 struct ia64_unw_table_entry
6979 struct absaddr start
;
6981 struct absaddr info
;
6984 struct ia64_unw_aux_info
6986 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6987 unsigned long table_len
; /* Length of unwind table. */
6988 unsigned char * info
; /* Unwind info. */
6989 unsigned long info_size
; /* Size of unwind info. */
6990 bfd_vma info_addr
; /* Starting address of unwind info. */
6991 bfd_vma seg_base
; /* Starting address of segment. */
6992 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6993 unsigned long nsyms
; /* Number of symbols. */
6994 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6995 unsigned long nfuns
; /* Number of entries in funtab. */
6996 char * strtab
; /* The string table. */
6997 unsigned long strtab_size
; /* Size of string table. */
7001 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7003 struct ia64_unw_table_entry
* tp
;
7004 unsigned long j
, nfuns
;
7007 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7008 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7009 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7010 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7012 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7014 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7018 const unsigned char * dp
;
7019 const unsigned char * head
;
7020 const unsigned char * end
;
7021 const char * procname
;
7023 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7024 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7026 fputs ("\n<", stdout
);
7030 fputs (procname
, stdout
);
7033 printf ("+%lx", (unsigned long) offset
);
7036 fputs (">: [", stdout
);
7037 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7038 fputc ('-', stdout
);
7039 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7040 printf ("], info at +0x%lx\n",
7041 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7043 /* PR 17531: file: 86232b32. */
7044 if (aux
->info
== NULL
)
7047 /* PR 17531: file: 0997b4d1. */
7048 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7050 warn (_("Invalid offset %lx in table entry %ld\n"),
7051 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7055 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7056 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7058 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7059 (unsigned) UNW_VER (stamp
),
7060 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7061 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7062 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7063 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7065 if (UNW_VER (stamp
) != 1)
7067 printf (_("\tUnknown version.\n"));
7072 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7073 /* PR 17531: file: 16ceda89. */
7074 if (end
> aux
->info
+ aux
->info_size
)
7075 end
= aux
->info
+ aux
->info_size
;
7076 for (dp
= head
+ 8; dp
< end
;)
7077 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7084 slurp_ia64_unwind_table (FILE * file
,
7085 struct ia64_unw_aux_info
* aux
,
7086 Elf_Internal_Shdr
* sec
)
7088 unsigned long size
, nrelas
, i
;
7089 Elf_Internal_Phdr
* seg
;
7090 struct ia64_unw_table_entry
* tep
;
7091 Elf_Internal_Shdr
* relsec
;
7092 Elf_Internal_Rela
* rela
;
7093 Elf_Internal_Rela
* rp
;
7094 unsigned char * table
;
7096 Elf_Internal_Sym
* sym
;
7097 const char * relname
;
7101 /* First, find the starting address of the segment that includes
7104 if (elf_header
.e_phnum
)
7106 if (! get_program_headers (file
))
7109 for (seg
= program_headers
;
7110 seg
< program_headers
+ elf_header
.e_phnum
;
7113 if (seg
->p_type
!= PT_LOAD
)
7116 if (sec
->sh_addr
>= seg
->p_vaddr
7117 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7119 aux
->seg_base
= seg
->p_vaddr
;
7125 /* Second, build the unwind table from the contents of the unwind section: */
7126 size
= sec
->sh_size
;
7127 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7132 aux
->table_len
= size
/ (3 * eh_addr_size
);
7133 aux
->table
= (struct ia64_unw_table_entry
*)
7134 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7137 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7139 tep
->start
.section
= SHN_UNDEF
;
7140 tep
->end
.section
= SHN_UNDEF
;
7141 tep
->info
.section
= SHN_UNDEF
;
7142 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7143 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7144 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7145 tep
->start
.offset
+= aux
->seg_base
;
7146 tep
->end
.offset
+= aux
->seg_base
;
7147 tep
->info
.offset
+= aux
->seg_base
;
7151 /* Third, apply any relocations to the unwind table: */
7152 for (relsec
= section_headers
;
7153 relsec
< section_headers
+ elf_header
.e_shnum
;
7156 if (relsec
->sh_type
!= SHT_RELA
7157 || relsec
->sh_info
>= elf_header
.e_shnum
7158 || section_headers
+ relsec
->sh_info
!= sec
)
7161 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7170 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7172 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7173 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7175 /* PR 17531: file: 9fa67536. */
7176 if (relname
== NULL
)
7178 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7182 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7184 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7188 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7190 /* PR 17531: file: 5bc8d9bf. */
7191 if (i
>= aux
->table_len
)
7193 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7197 switch (rp
->r_offset
/ eh_addr_size
% 3)
7200 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7201 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7204 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7205 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7208 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7209 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7223 ia64_process_unwind (FILE * file
)
7225 Elf_Internal_Shdr
* sec
;
7226 Elf_Internal_Shdr
* unwsec
= NULL
;
7227 Elf_Internal_Shdr
* strsec
;
7228 unsigned long i
, unwcount
= 0, unwstart
= 0;
7229 struct ia64_unw_aux_info aux
;
7231 memset (& aux
, 0, sizeof (aux
));
7233 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7235 if (sec
->sh_type
== SHT_SYMTAB
7236 && sec
->sh_link
< elf_header
.e_shnum
)
7238 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7240 strsec
= section_headers
+ sec
->sh_link
;
7241 if (aux
.strtab
!= NULL
)
7243 error (_("Multiple auxillary string tables encountered\n"));
7246 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7249 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7251 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7256 printf (_("\nThere are no unwind sections in this file.\n"));
7258 while (unwcount
-- > 0)
7263 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7264 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7265 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7270 /* We have already counted the number of SHT_IA64_UNWIND
7271 sections so the loop above should never fail. */
7272 assert (unwsec
!= NULL
);
7275 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7277 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7279 /* We need to find which section group it is in. */
7280 struct group_list
* g
;
7282 if (section_headers_groups
== NULL
7283 || section_headers_groups
[i
] == NULL
)
7284 i
= elf_header
.e_shnum
;
7287 g
= section_headers_groups
[i
]->root
;
7289 for (; g
!= NULL
; g
= g
->next
)
7291 sec
= section_headers
+ g
->section_index
;
7293 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7298 i
= elf_header
.e_shnum
;
7301 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7303 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7304 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7305 suffix
= SECTION_NAME (unwsec
) + len
;
7306 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7308 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7309 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7314 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7315 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7316 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7317 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7319 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7320 suffix
= SECTION_NAME (unwsec
) + len
;
7321 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7323 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7324 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7328 if (i
== elf_header
.e_shnum
)
7330 printf (_("\nCould not find unwind info section for "));
7332 if (string_table
== NULL
)
7333 printf ("%d", unwsec
->sh_name
);
7335 printf ("'%s'", printable_section_name (unwsec
));
7339 aux
.info_addr
= sec
->sh_addr
;
7340 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7343 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7345 printf (_("\nUnwind section "));
7347 if (string_table
== NULL
)
7348 printf ("%d", unwsec
->sh_name
);
7350 printf ("'%s'", printable_section_name (unwsec
));
7352 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7353 (unsigned long) unwsec
->sh_offset
,
7354 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7356 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7357 && aux
.table_len
> 0)
7358 dump_ia64_unwind (& aux
);
7361 free ((char *) aux
.table
);
7363 free ((char *) aux
.info
);
7372 free ((char *) aux
.strtab
);
7375 struct hppa_unw_table_entry
7377 struct absaddr start
;
7379 unsigned int Cannot_unwind
:1; /* 0 */
7380 unsigned int Millicode
:1; /* 1 */
7381 unsigned int Millicode_save_sr0
:1; /* 2 */
7382 unsigned int Region_description
:2; /* 3..4 */
7383 unsigned int reserved1
:1; /* 5 */
7384 unsigned int Entry_SR
:1; /* 6 */
7385 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7386 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7387 unsigned int Args_stored
:1; /* 16 */
7388 unsigned int Variable_Frame
:1; /* 17 */
7389 unsigned int Separate_Package_Body
:1; /* 18 */
7390 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7391 unsigned int Stack_Overflow_Check
:1; /* 20 */
7392 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7393 unsigned int Ada_Region
:1; /* 22 */
7394 unsigned int cxx_info
:1; /* 23 */
7395 unsigned int cxx_try_catch
:1; /* 24 */
7396 unsigned int sched_entry_seq
:1; /* 25 */
7397 unsigned int reserved2
:1; /* 26 */
7398 unsigned int Save_SP
:1; /* 27 */
7399 unsigned int Save_RP
:1; /* 28 */
7400 unsigned int Save_MRP_in_frame
:1; /* 29 */
7401 unsigned int extn_ptr_defined
:1; /* 30 */
7402 unsigned int Cleanup_defined
:1; /* 31 */
7404 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7405 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7406 unsigned int Large_frame
:1; /* 2 */
7407 unsigned int Pseudo_SP_Set
:1; /* 3 */
7408 unsigned int reserved4
:1; /* 4 */
7409 unsigned int Total_frame_size
:27; /* 5..31 */
7412 struct hppa_unw_aux_info
7414 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7415 unsigned long table_len
; /* Length of unwind table. */
7416 bfd_vma seg_base
; /* Starting address of segment. */
7417 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7418 unsigned long nsyms
; /* Number of symbols. */
7419 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7420 unsigned long nfuns
; /* Number of entries in funtab. */
7421 char * strtab
; /* The string table. */
7422 unsigned long strtab_size
; /* Size of string table. */
7426 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7428 struct hppa_unw_table_entry
* tp
;
7429 unsigned long j
, nfuns
;
7431 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7432 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7433 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7434 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7436 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7438 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7441 const char * procname
;
7443 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7444 aux
->strtab_size
, tp
->start
, &procname
,
7447 fputs ("\n<", stdout
);
7451 fputs (procname
, stdout
);
7454 printf ("+%lx", (unsigned long) offset
);
7457 fputs (">: [", stdout
);
7458 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7459 fputc ('-', stdout
);
7460 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7463 #define PF(_m) if (tp->_m) printf (#_m " ");
7464 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7467 PF(Millicode_save_sr0
);
7468 /* PV(Region_description); */
7474 PF(Separate_Package_Body
);
7475 PF(Frame_Extension_Millicode
);
7476 PF(Stack_Overflow_Check
);
7477 PF(Two_Instruction_SP_Increment
);
7481 PF(sched_entry_seq
);
7484 PF(Save_MRP_in_frame
);
7485 PF(extn_ptr_defined
);
7486 PF(Cleanup_defined
);
7487 PF(MPE_XL_interrupt_marker
);
7488 PF(HP_UX_interrupt_marker
);
7491 PV(Total_frame_size
);
7502 slurp_hppa_unwind_table (FILE * file
,
7503 struct hppa_unw_aux_info
* aux
,
7504 Elf_Internal_Shdr
* sec
)
7506 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7507 Elf_Internal_Phdr
* seg
;
7508 struct hppa_unw_table_entry
* tep
;
7509 Elf_Internal_Shdr
* relsec
;
7510 Elf_Internal_Rela
* rela
;
7511 Elf_Internal_Rela
* rp
;
7512 unsigned char * table
;
7514 Elf_Internal_Sym
* sym
;
7515 const char * relname
;
7517 /* First, find the starting address of the segment that includes
7520 if (elf_header
.e_phnum
)
7522 if (! get_program_headers (file
))
7525 for (seg
= program_headers
;
7526 seg
< program_headers
+ elf_header
.e_phnum
;
7529 if (seg
->p_type
!= PT_LOAD
)
7532 if (sec
->sh_addr
>= seg
->p_vaddr
7533 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7535 aux
->seg_base
= seg
->p_vaddr
;
7541 /* Second, build the unwind table from the contents of the unwind
7543 size
= sec
->sh_size
;
7544 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7550 nentries
= size
/ unw_ent_size
;
7551 size
= unw_ent_size
* nentries
;
7553 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7554 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7556 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7558 unsigned int tmp1
, tmp2
;
7560 tep
->start
.section
= SHN_UNDEF
;
7561 tep
->end
.section
= SHN_UNDEF
;
7563 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7564 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7565 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7566 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7568 tep
->start
.offset
+= aux
->seg_base
;
7569 tep
->end
.offset
+= aux
->seg_base
;
7571 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7572 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7573 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7574 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7575 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7576 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7577 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7578 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7579 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7580 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7581 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7582 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7583 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7584 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7585 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7586 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7587 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7588 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7589 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7590 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7591 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7592 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7593 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7594 tep
->Cleanup_defined
= tmp1
& 0x1;
7596 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7597 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7598 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7599 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7600 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7601 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7605 /* Third, apply any relocations to the unwind table. */
7606 for (relsec
= section_headers
;
7607 relsec
< section_headers
+ elf_header
.e_shnum
;
7610 if (relsec
->sh_type
!= SHT_RELA
7611 || relsec
->sh_info
>= elf_header
.e_shnum
7612 || section_headers
+ relsec
->sh_info
!= sec
)
7615 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7619 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7621 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7622 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7624 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7625 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7627 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7631 i
= rp
->r_offset
/ unw_ent_size
;
7633 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7636 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7637 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7640 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7641 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7651 aux
->table_len
= nentries
;
7657 hppa_process_unwind (FILE * file
)
7659 struct hppa_unw_aux_info aux
;
7660 Elf_Internal_Shdr
* unwsec
= NULL
;
7661 Elf_Internal_Shdr
* strsec
;
7662 Elf_Internal_Shdr
* sec
;
7665 if (string_table
== NULL
)
7668 memset (& aux
, 0, sizeof (aux
));
7670 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7672 if (sec
->sh_type
== SHT_SYMTAB
7673 && sec
->sh_link
< elf_header
.e_shnum
)
7675 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7677 strsec
= section_headers
+ sec
->sh_link
;
7678 if (aux
.strtab
!= NULL
)
7680 error (_("Multiple auxillary string tables encountered\n"));
7683 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7686 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7688 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7693 printf (_("\nThere are no unwind sections in this file.\n"));
7695 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7697 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7699 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7700 printable_section_name (sec
),
7701 (unsigned long) sec
->sh_offset
,
7702 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7704 slurp_hppa_unwind_table (file
, &aux
, sec
);
7705 if (aux
.table_len
> 0)
7706 dump_hppa_unwind (&aux
);
7709 free ((char *) aux
.table
);
7717 free ((char *) aux
.strtab
);
7722 unsigned char * data
; /* The unwind data. */
7723 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7724 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7725 unsigned long nrelas
; /* The number of relocations. */
7726 unsigned int rel_type
; /* REL or RELA ? */
7727 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7730 struct arm_unw_aux_info
7732 FILE * file
; /* The file containing the unwind sections. */
7733 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7734 unsigned long nsyms
; /* Number of symbols. */
7735 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7736 unsigned long nfuns
; /* Number of these symbols. */
7737 char * strtab
; /* The file's string table. */
7738 unsigned long strtab_size
; /* Size of string table. */
7742 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7743 bfd_vma fn
, struct absaddr addr
)
7745 const char *procname
;
7748 if (addr
.section
== SHN_UNDEF
)
7751 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7752 aux
->strtab_size
, addr
, &procname
,
7755 print_vma (fn
, PREFIX_HEX
);
7759 fputs (" <", stdout
);
7760 fputs (procname
, stdout
);
7763 printf ("+0x%lx", (unsigned long) sym_offset
);
7764 fputc ('>', stdout
);
7771 arm_free_section (struct arm_section
*arm_sec
)
7773 if (arm_sec
->data
!= NULL
)
7774 free (arm_sec
->data
);
7776 if (arm_sec
->rela
!= NULL
)
7777 free (arm_sec
->rela
);
7780 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7781 cached section and install SEC instead.
7782 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7783 and return its valued in * WORDP, relocating if necessary.
7784 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7785 relocation's offset in ADDR.
7786 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7787 into the string table of the symbol associated with the reloc. If no
7788 reloc was applied store -1 there.
7789 5) Return TRUE upon success, FALSE otherwise. */
7792 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7793 struct arm_section
* arm_sec
,
7794 Elf_Internal_Shdr
* sec
,
7795 bfd_vma word_offset
,
7796 unsigned int * wordp
,
7797 struct absaddr
* addr
,
7800 Elf_Internal_Rela
*rp
;
7801 Elf_Internal_Sym
*sym
;
7802 const char * relname
;
7804 bfd_boolean wrapped
;
7806 if (sec
== NULL
|| arm_sec
== NULL
)
7809 addr
->section
= SHN_UNDEF
;
7812 if (sym_name
!= NULL
)
7813 *sym_name
= (bfd_vma
) -1;
7815 /* If necessary, update the section cache. */
7816 if (sec
!= arm_sec
->sec
)
7818 Elf_Internal_Shdr
*relsec
;
7820 arm_free_section (arm_sec
);
7823 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7824 sec
->sh_size
, _("unwind data"));
7825 arm_sec
->rela
= NULL
;
7826 arm_sec
->nrelas
= 0;
7828 for (relsec
= section_headers
;
7829 relsec
< section_headers
+ elf_header
.e_shnum
;
7832 if (relsec
->sh_info
>= elf_header
.e_shnum
7833 || section_headers
+ relsec
->sh_info
!= sec
7834 /* PR 15745: Check the section type as well. */
7835 || (relsec
->sh_type
!= SHT_REL
7836 && relsec
->sh_type
!= SHT_RELA
))
7839 arm_sec
->rel_type
= relsec
->sh_type
;
7840 if (relsec
->sh_type
== SHT_REL
)
7842 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7844 & arm_sec
->rela
, & arm_sec
->nrelas
))
7847 else /* relsec->sh_type == SHT_RELA */
7849 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7851 & arm_sec
->rela
, & arm_sec
->nrelas
))
7857 arm_sec
->next_rela
= arm_sec
->rela
;
7860 /* If there is no unwind data we can do nothing. */
7861 if (arm_sec
->data
== NULL
)
7864 /* If the offset is invalid then fail. */
7865 if (word_offset
> (sec
->sh_size
- 4)
7867 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7868 || ((bfd_signed_vma
) word_offset
) < 0)
7871 /* Get the word at the required offset. */
7872 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7874 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7875 if (arm_sec
->rela
== NULL
)
7881 /* Look through the relocs to find the one that applies to the provided offset. */
7883 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7885 bfd_vma prelval
, offset
;
7887 if (rp
->r_offset
> word_offset
&& !wrapped
)
7892 if (rp
->r_offset
> word_offset
)
7895 if (rp
->r_offset
& 3)
7897 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7898 (unsigned long) rp
->r_offset
);
7902 if (rp
->r_offset
< word_offset
)
7905 /* PR 17531: file: 027-161405-0.004 */
7906 if (aux
->symtab
== NULL
)
7909 if (arm_sec
->rel_type
== SHT_REL
)
7911 offset
= word
& 0x7fffffff;
7912 if (offset
& 0x40000000)
7913 offset
|= ~ (bfd_vma
) 0x7fffffff;
7915 else if (arm_sec
->rel_type
== SHT_RELA
)
7916 offset
= rp
->r_addend
;
7919 error (_("Unknown section relocation type %d encountered\n"),
7924 /* PR 17531 file: 027-1241568-0.004. */
7925 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7927 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7928 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7932 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7933 offset
+= sym
->st_value
;
7934 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7936 /* Check that we are processing the expected reloc type. */
7937 if (elf_header
.e_machine
== EM_ARM
)
7939 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7940 if (relname
== NULL
)
7942 warn (_("Skipping unknown ARM relocation type: %d\n"),
7943 (int) ELF32_R_TYPE (rp
->r_info
));
7947 if (streq (relname
, "R_ARM_NONE"))
7950 if (! streq (relname
, "R_ARM_PREL31"))
7952 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7956 else if (elf_header
.e_machine
== EM_TI_C6000
)
7958 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7959 if (relname
== NULL
)
7961 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7962 (int) ELF32_R_TYPE (rp
->r_info
));
7966 if (streq (relname
, "R_C6000_NONE"))
7969 if (! streq (relname
, "R_C6000_PREL31"))
7971 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7979 /* This function currently only supports ARM and TI unwinders. */
7980 warn (_("Only TI and ARM unwinders are currently supported\n"));
7984 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7985 addr
->section
= sym
->st_shndx
;
7986 addr
->offset
= offset
;
7989 * sym_name
= sym
->st_name
;
7994 arm_sec
->next_rela
= rp
;
7999 static const char *tic6x_unwind_regnames
[16] =
8001 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8002 "A14", "A13", "A12", "A11", "A10",
8003 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8007 decode_tic6x_unwind_regmask (unsigned int mask
)
8011 for (i
= 12; mask
; mask
>>= 1, i
--)
8015 fputs (tic6x_unwind_regnames
[i
], stdout
);
8017 fputs (", ", stdout
);
8023 if (remaining == 0 && more_words) \
8026 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8027 data_offset, & word, & addr, NULL)) \
8033 #define GET_OP(OP) \
8038 (OP) = word >> 24; \
8043 printf (_("[Truncated opcode]\n")); \
8046 printf ("0x%02x ", OP)
8049 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8051 unsigned int remaining
,
8052 unsigned int more_words
,
8053 bfd_vma data_offset
,
8054 Elf_Internal_Shdr
* data_sec
,
8055 struct arm_section
* data_arm_sec
)
8057 struct absaddr addr
;
8059 /* Decode the unwinding instructions. */
8062 unsigned int op
, op2
;
8071 printf (" 0x%02x ", op
);
8073 if ((op
& 0xc0) == 0x00)
8075 int offset
= ((op
& 0x3f) << 2) + 4;
8077 printf (" vsp = vsp + %d", offset
);
8079 else if ((op
& 0xc0) == 0x40)
8081 int offset
= ((op
& 0x3f) << 2) + 4;
8083 printf (" vsp = vsp - %d", offset
);
8085 else if ((op
& 0xf0) == 0x80)
8088 if (op
== 0x80 && op2
== 0)
8089 printf (_("Refuse to unwind"));
8092 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8097 for (i
= 0; i
< 12; i
++)
8098 if (mask
& (1 << i
))
8104 printf ("r%d", 4 + i
);
8109 else if ((op
& 0xf0) == 0x90)
8111 if (op
== 0x9d || op
== 0x9f)
8112 printf (_(" [Reserved]"));
8114 printf (" vsp = r%d", op
& 0x0f);
8116 else if ((op
& 0xf0) == 0xa0)
8118 int end
= 4 + (op
& 0x07);
8123 for (i
= 4; i
<= end
; i
++)
8139 else if (op
== 0xb0)
8140 printf (_(" finish"));
8141 else if (op
== 0xb1)
8144 if (op2
== 0 || (op2
& 0xf0) != 0)
8145 printf (_("[Spare]"));
8148 unsigned int mask
= op2
& 0x0f;
8153 for (i
= 0; i
< 12; i
++)
8154 if (mask
& (1 << i
))
8165 else if (op
== 0xb2)
8167 unsigned char buf
[9];
8168 unsigned int i
, len
;
8169 unsigned long offset
;
8171 for (i
= 0; i
< sizeof (buf
); i
++)
8174 if ((buf
[i
] & 0x80) == 0)
8177 if (i
== sizeof (buf
))
8178 printf (_("corrupt change to vsp"));
8181 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8182 assert (len
== i
+ 1);
8183 offset
= offset
* 4 + 0x204;
8184 printf ("vsp = vsp + %ld", offset
);
8187 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8189 unsigned int first
, last
;
8196 printf ("pop {D%d", first
);
8198 printf ("-D%d", first
+ last
);
8201 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8203 unsigned int count
= op
& 0x07;
8207 printf ("-D%d", 8 + count
);
8210 else if (op
>= 0xc0 && op
<= 0xc5)
8212 unsigned int count
= op
& 0x07;
8214 printf (" pop {wR10");
8216 printf ("-wR%d", 10 + count
);
8219 else if (op
== 0xc6)
8221 unsigned int first
, last
;
8226 printf ("pop {wR%d", first
);
8228 printf ("-wR%d", first
+ last
);
8231 else if (op
== 0xc7)
8234 if (op2
== 0 || (op2
& 0xf0) != 0)
8235 printf (_("[Spare]"));
8238 unsigned int mask
= op2
& 0x0f;
8243 for (i
= 0; i
< 4; i
++)
8244 if (mask
& (1 << i
))
8250 printf ("wCGR%d", i
);
8256 printf (_(" [unsupported opcode]"));
8262 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8264 unsigned int remaining
,
8265 unsigned int more_words
,
8266 bfd_vma data_offset
,
8267 Elf_Internal_Shdr
* data_sec
,
8268 struct arm_section
* data_arm_sec
)
8270 struct absaddr addr
;
8272 /* Decode the unwinding instructions. */
8275 unsigned int op
, op2
;
8284 printf (" 0x%02x ", op
);
8286 if ((op
& 0xc0) == 0x00)
8288 int offset
= ((op
& 0x3f) << 3) + 8;
8289 printf (" sp = sp + %d", offset
);
8291 else if ((op
& 0xc0) == 0x80)
8294 if (op
== 0x80 && op2
== 0)
8295 printf (_("Refuse to unwind"));
8298 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8300 printf ("pop compact {");
8304 decode_tic6x_unwind_regmask (mask
);
8308 else if ((op
& 0xf0) == 0xc0)
8316 unsigned int offset
;
8320 /* Scan entire instruction first so that GET_OP output is not
8321 interleaved with disassembly. */
8323 for (i
= 0; nregs
< (op
& 0xf); i
++)
8329 regpos
[nregs
].offset
= i
* 2;
8330 regpos
[nregs
].reg
= reg
;
8337 regpos
[nregs
].offset
= i
* 2 + 1;
8338 regpos
[nregs
].reg
= reg
;
8343 printf (_("pop frame {"));
8345 for (i
= i
* 2; i
> 0; i
--)
8347 if (regpos
[reg
].offset
== i
- 1)
8349 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8356 fputs (name
, stdout
);
8363 else if (op
== 0xd0)
8364 printf (" MOV FP, SP");
8365 else if (op
== 0xd1)
8366 printf (" __c6xabi_pop_rts");
8367 else if (op
== 0xd2)
8369 unsigned char buf
[9];
8370 unsigned int i
, len
;
8371 unsigned long offset
;
8373 for (i
= 0; i
< sizeof (buf
); i
++)
8376 if ((buf
[i
] & 0x80) == 0)
8379 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8380 if (i
== sizeof (buf
))
8382 printf ("<corrupt sp adjust>\n");
8383 warn (_("Corrupt stack pointer adjustment detected\n"));
8387 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8388 assert (len
== i
+ 1);
8389 offset
= offset
* 8 + 0x408;
8390 printf (_("sp = sp + %ld"), offset
);
8392 else if ((op
& 0xf0) == 0xe0)
8394 if ((op
& 0x0f) == 7)
8397 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8401 printf (_(" [unsupported opcode]"));
8408 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8412 offset
= word
& 0x7fffffff;
8413 if (offset
& 0x40000000)
8414 offset
|= ~ (bfd_vma
) 0x7fffffff;
8416 if (elf_header
.e_machine
== EM_TI_C6000
)
8419 return offset
+ where
;
8423 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8425 unsigned int remaining
,
8426 bfd_vma data_offset
,
8427 Elf_Internal_Shdr
* data_sec
,
8428 struct arm_section
* data_arm_sec
)
8431 unsigned int more_words
= 0;
8432 struct absaddr addr
;
8433 bfd_vma sym_name
= (bfd_vma
) -1;
8437 /* Fetch the first word.
8438 Note - when decoding an object file the address extracted
8439 here will always be 0. So we also pass in the sym_name
8440 parameter so that we can find the symbol associated with
8441 the personality routine. */
8442 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8443 & word
, & addr
, & sym_name
))
8449 if ((word
& 0x80000000) == 0)
8451 /* Expand prel31 for personality routine. */
8453 const char *procname
;
8455 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8456 printf (_(" Personality routine: "));
8458 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8459 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8461 procname
= aux
->strtab
+ sym_name
;
8462 print_vma (fn
, PREFIX_HEX
);
8465 fputs (" <", stdout
);
8466 fputs (procname
, stdout
);
8467 fputc ('>', stdout
);
8471 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8472 fputc ('\n', stdout
);
8474 /* The GCC personality routines use the standard compact
8475 encoding, starting with one byte giving the number of
8477 if (procname
!= NULL
8478 && (const_strneq (procname
, "__gcc_personality_v0")
8479 || const_strneq (procname
, "__gxx_personality_v0")
8480 || const_strneq (procname
, "__gcj_personality_v0")
8481 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8488 printf (_(" [Truncated data]\n"));
8491 more_words
= word
>> 24;
8501 /* ARM EHABI Section 6.3:
8503 An exception-handling table entry for the compact model looks like:
8507 1 0 index Data for personalityRoutine[index] */
8509 if (elf_header
.e_machine
== EM_ARM
8510 && (word
& 0x70000000))
8511 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8513 per_index
= (word
>> 24) & 0x7f;
8514 printf (_(" Compact model index: %d\n"), per_index
);
8521 else if (per_index
< 3)
8523 more_words
= (word
>> 16) & 0xff;
8529 switch (elf_header
.e_machine
)
8534 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8535 data_offset
, data_sec
, data_arm_sec
);
8539 warn (_("Unknown ARM compact model index encountered\n"));
8540 printf (_(" [reserved]\n"));
8547 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8548 data_offset
, data_sec
, data_arm_sec
);
8550 else if (per_index
< 5)
8552 if (((word
>> 17) & 0x7f) == 0x7f)
8553 printf (_(" Restore stack from frame pointer\n"));
8555 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8556 printf (_(" Registers restored: "));
8558 printf (" (compact) ");
8559 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8561 printf (_(" Return register: %s\n"),
8562 tic6x_unwind_regnames
[word
& 0xf]);
8565 printf (_(" [reserved (%d)]\n"), per_index
);
8569 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8570 elf_header
.e_machine
);
8573 /* Decode the descriptors. Not implemented. */
8577 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8579 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8580 unsigned int i
, exidx_len
;
8581 unsigned long j
, nfuns
;
8583 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8584 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8585 exidx_len
= exidx_sec
->sh_size
/ 8;
8587 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8588 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8589 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8590 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8592 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8594 for (i
= 0; i
< exidx_len
; i
++)
8596 unsigned int exidx_fn
, exidx_entry
;
8597 struct absaddr fn_addr
, entry_addr
;
8600 fputc ('\n', stdout
);
8602 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8603 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8604 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8605 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8608 arm_free_section (& exidx_arm_sec
);
8609 arm_free_section (& extab_arm_sec
);
8613 /* ARM EHABI, Section 5:
8614 An index table entry consists of 2 words.
8615 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8616 if (exidx_fn
& 0x80000000)
8617 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8619 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8621 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8622 fputs (": ", stdout
);
8624 if (exidx_entry
== 1)
8626 print_vma (exidx_entry
, PREFIX_HEX
);
8627 fputs (" [cantunwind]\n", stdout
);
8629 else if (exidx_entry
& 0x80000000)
8631 print_vma (exidx_entry
, PREFIX_HEX
);
8632 fputc ('\n', stdout
);
8633 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8637 bfd_vma table
, table_offset
= 0;
8638 Elf_Internal_Shdr
*table_sec
;
8640 fputs ("@", stdout
);
8641 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8642 print_vma (table
, PREFIX_HEX
);
8645 /* Locate the matching .ARM.extab. */
8646 if (entry_addr
.section
!= SHN_UNDEF
8647 && entry_addr
.section
< elf_header
.e_shnum
)
8649 table_sec
= section_headers
+ entry_addr
.section
;
8650 table_offset
= entry_addr
.offset
;
8652 if (table_offset
> table_sec
->sh_size
8653 || ((bfd_signed_vma
) table_offset
) < 0)
8655 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8656 (unsigned long) table_offset
,
8657 printable_section_name (table_sec
));
8663 table_sec
= find_section_by_address (table
);
8664 if (table_sec
!= NULL
)
8665 table_offset
= table
- table_sec
->sh_addr
;
8667 if (table_sec
== NULL
)
8669 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8670 (unsigned long) table
);
8673 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8681 arm_free_section (&exidx_arm_sec
);
8682 arm_free_section (&extab_arm_sec
);
8685 /* Used for both ARM and C6X unwinding tables. */
8688 arm_process_unwind (FILE *file
)
8690 struct arm_unw_aux_info aux
;
8691 Elf_Internal_Shdr
*unwsec
= NULL
;
8692 Elf_Internal_Shdr
*strsec
;
8693 Elf_Internal_Shdr
*sec
;
8695 unsigned int sec_type
;
8697 switch (elf_header
.e_machine
)
8700 sec_type
= SHT_ARM_EXIDX
;
8704 sec_type
= SHT_C6000_UNWIND
;
8708 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8709 elf_header
.e_machine
);
8713 if (string_table
== NULL
)
8716 memset (& aux
, 0, sizeof (aux
));
8719 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8721 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8723 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8725 strsec
= section_headers
+ sec
->sh_link
;
8727 /* PR binutils/17531 file: 011-12666-0.004. */
8728 if (aux
.strtab
!= NULL
)
8730 error (_("Multiple string tables found in file.\n"));
8733 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8734 1, strsec
->sh_size
, _("string table"));
8735 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8737 else if (sec
->sh_type
== sec_type
)
8742 printf (_("\nThere are no unwind sections in this file.\n"));
8744 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8746 if (sec
->sh_type
== sec_type
)
8748 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8749 printable_section_name (sec
),
8750 (unsigned long) sec
->sh_offset
,
8751 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8753 dump_arm_unwind (&aux
, sec
);
8760 free ((char *) aux
.strtab
);
8764 process_unwind (FILE * file
)
8766 struct unwind_handler
8769 void (* handler
)(FILE *);
8772 { EM_ARM
, arm_process_unwind
},
8773 { EM_IA_64
, ia64_process_unwind
},
8774 { EM_PARISC
, hppa_process_unwind
},
8775 { EM_TI_C6000
, arm_process_unwind
},
8783 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8784 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8786 handlers
[i
].handler (file
);
8790 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8791 get_machine_name (elf_header
.e_machine
));
8795 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8797 switch (entry
->d_tag
)
8800 if (entry
->d_un
.d_val
== 0)
8804 static const char * opts
[] =
8806 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8807 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8808 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8809 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8815 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8816 if (entry
->d_un
.d_val
& (1 << cnt
))
8818 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8824 case DT_MIPS_IVERSION
:
8825 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8826 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8830 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8831 /* Note: coded this way so that there is a single string for translation. */
8832 printf (_("<corrupt: %s>"), buf
);
8836 case DT_MIPS_TIME_STAMP
:
8840 time_t atime
= entry
->d_un
.d_val
;
8842 tmp
= gmtime (&atime
);
8843 /* PR 17531: file: 6accc532. */
8845 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8847 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8848 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8849 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8850 printf (_("Time Stamp: %s"), timebuf
);
8854 case DT_MIPS_RLD_VERSION
:
8855 case DT_MIPS_LOCAL_GOTNO
:
8856 case DT_MIPS_CONFLICTNO
:
8857 case DT_MIPS_LIBLISTNO
:
8858 case DT_MIPS_SYMTABNO
:
8859 case DT_MIPS_UNREFEXTNO
:
8860 case DT_MIPS_HIPAGENO
:
8861 case DT_MIPS_DELTA_CLASS_NO
:
8862 case DT_MIPS_DELTA_INSTANCE_NO
:
8863 case DT_MIPS_DELTA_RELOC_NO
:
8864 case DT_MIPS_DELTA_SYM_NO
:
8865 case DT_MIPS_DELTA_CLASSSYM_NO
:
8866 case DT_MIPS_COMPACT_SIZE
:
8867 print_vma (entry
->d_un
.d_val
, DEC
);
8871 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8877 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8879 switch (entry
->d_tag
)
8881 case DT_HP_DLD_FLAGS
:
8890 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8891 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8892 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8893 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8894 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8895 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8896 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8897 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8898 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8899 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8900 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8901 { DT_HP_GST
, "HP_GST" },
8902 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8903 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8904 { DT_HP_NODELETE
, "HP_NODELETE" },
8905 { DT_HP_GROUP
, "HP_GROUP" },
8906 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8910 bfd_vma val
= entry
->d_un
.d_val
;
8912 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8913 if (val
& flags
[cnt
].bit
)
8917 fputs (flags
[cnt
].str
, stdout
);
8919 val
^= flags
[cnt
].bit
;
8922 if (val
!= 0 || first
)
8926 print_vma (val
, HEX
);
8932 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8940 /* VMS vs Unix time offset and factor. */
8942 #define VMS_EPOCH_OFFSET 35067168000000000LL
8943 #define VMS_GRANULARITY_FACTOR 10000000
8945 /* Display a VMS time in a human readable format. */
8948 print_vms_time (bfd_int64_t vmstime
)
8953 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8954 tm
= gmtime (&unxtime
);
8955 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8956 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8957 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8962 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8964 switch (entry
->d_tag
)
8966 case DT_IA_64_PLT_RESERVE
:
8967 /* First 3 slots reserved. */
8968 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8970 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8973 case DT_IA_64_VMS_LINKTIME
:
8975 print_vms_time (entry
->d_un
.d_val
);
8979 case DT_IA_64_VMS_LNKFLAGS
:
8980 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8981 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8982 printf (" CALL_DEBUG");
8983 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8984 printf (" NOP0BUFS");
8985 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8986 printf (" P0IMAGE");
8987 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8988 printf (" MKTHREADS");
8989 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8990 printf (" UPCALLS");
8991 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8993 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8994 printf (" INITIALIZE");
8995 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8997 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8998 printf (" EXE_INIT");
8999 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9000 printf (" TBK_IN_IMG");
9001 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9002 printf (" DBG_IN_IMG");
9003 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9004 printf (" TBK_IN_DSF");
9005 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9006 printf (" DBG_IN_DSF");
9007 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9008 printf (" SIGNATURES");
9009 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9010 printf (" REL_SEG_OFF");
9014 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9021 get_32bit_dynamic_section (FILE * file
)
9023 Elf32_External_Dyn
* edyn
;
9024 Elf32_External_Dyn
* ext
;
9025 Elf_Internal_Dyn
* entry
;
9027 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9028 dynamic_size
, _("dynamic section"));
9032 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9033 might not have the luxury of section headers. Look for the DT_NULL
9034 terminator to determine the number of entries. */
9035 for (ext
= edyn
, dynamic_nent
= 0;
9036 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9040 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9044 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9046 if (dynamic_section
== NULL
)
9048 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9049 (unsigned long) dynamic_nent
);
9054 for (ext
= edyn
, entry
= dynamic_section
;
9055 entry
< dynamic_section
+ dynamic_nent
;
9058 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9059 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9068 get_64bit_dynamic_section (FILE * file
)
9070 Elf64_External_Dyn
* edyn
;
9071 Elf64_External_Dyn
* ext
;
9072 Elf_Internal_Dyn
* entry
;
9074 /* Read in the data. */
9075 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9076 dynamic_size
, _("dynamic section"));
9080 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9081 might not have the luxury of section headers. Look for the DT_NULL
9082 terminator to determine the number of entries. */
9083 for (ext
= edyn
, dynamic_nent
= 0;
9084 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9085 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9089 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9093 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9095 if (dynamic_section
== NULL
)
9097 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9098 (unsigned long) dynamic_nent
);
9103 /* Convert from external to internal formats. */
9104 for (ext
= edyn
, entry
= dynamic_section
;
9105 entry
< dynamic_section
+ dynamic_nent
;
9108 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9109 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9118 print_dynamic_flags (bfd_vma flags
)
9126 flag
= flags
& - flags
;
9136 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9137 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9138 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9139 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9140 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9141 default: fputs (_("unknown"), stdout
); break;
9147 /* Parse and display the contents of the dynamic section. */
9150 process_dynamic_section (FILE * file
)
9152 Elf_Internal_Dyn
* entry
;
9154 if (dynamic_size
== 0)
9157 printf (_("\nThere is no dynamic section in this file.\n"));
9164 if (! get_32bit_dynamic_section (file
))
9167 else if (! get_64bit_dynamic_section (file
))
9170 /* Find the appropriate symbol table. */
9171 if (dynamic_symbols
== NULL
)
9173 for (entry
= dynamic_section
;
9174 entry
< dynamic_section
+ dynamic_nent
;
9177 Elf_Internal_Shdr section
;
9179 if (entry
->d_tag
!= DT_SYMTAB
)
9182 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9184 /* Since we do not know how big the symbol table is,
9185 we default to reading in the entire file (!) and
9186 processing that. This is overkill, I know, but it
9188 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9190 if (archive_file_offset
!= 0)
9191 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9194 if (fseek (file
, 0, SEEK_END
))
9195 error (_("Unable to seek to end of file!\n"));
9197 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9201 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9203 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9204 section
.sh_name
= string_table_length
;
9206 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9207 if (num_dynamic_syms
< 1)
9209 error (_("Unable to determine the number of symbols to load\n"));
9215 /* Similarly find a string table. */
9216 if (dynamic_strings
== NULL
)
9218 for (entry
= dynamic_section
;
9219 entry
< dynamic_section
+ dynamic_nent
;
9222 unsigned long offset
;
9225 if (entry
->d_tag
!= DT_STRTAB
)
9228 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9230 /* Since we do not know how big the string table is,
9231 we default to reading in the entire file (!) and
9232 processing that. This is overkill, I know, but it
9235 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9237 if (archive_file_offset
!= 0)
9238 str_tab_len
= archive_file_size
- offset
;
9241 if (fseek (file
, 0, SEEK_END
))
9242 error (_("Unable to seek to end of file\n"));
9243 str_tab_len
= ftell (file
) - offset
;
9246 if (str_tab_len
< 1)
9249 (_("Unable to determine the length of the dynamic string table\n"));
9253 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9255 _("dynamic string table"));
9256 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9261 /* And find the syminfo section if available. */
9262 if (dynamic_syminfo
== NULL
)
9264 unsigned long syminsz
= 0;
9266 for (entry
= dynamic_section
;
9267 entry
< dynamic_section
+ dynamic_nent
;
9270 if (entry
->d_tag
== DT_SYMINENT
)
9272 /* Note: these braces are necessary to avoid a syntax
9273 error from the SunOS4 C compiler. */
9274 /* PR binutils/17531: A corrupt file can trigger this test.
9275 So do not use an assert, instead generate an error message. */
9276 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9277 error (_("Bad value (%d) for SYMINENT entry\n"),
9278 (int) entry
->d_un
.d_val
);
9280 else if (entry
->d_tag
== DT_SYMINSZ
)
9281 syminsz
= entry
->d_un
.d_val
;
9282 else if (entry
->d_tag
== DT_SYMINFO
)
9283 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9287 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9289 Elf_External_Syminfo
* extsyminfo
;
9290 Elf_External_Syminfo
* extsym
;
9291 Elf_Internal_Syminfo
* syminfo
;
9293 /* There is a syminfo section. Read the data. */
9294 extsyminfo
= (Elf_External_Syminfo
*)
9295 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9296 _("symbol information"));
9300 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9301 if (dynamic_syminfo
== NULL
)
9303 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9304 (unsigned long) syminsz
);
9308 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9309 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9310 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9311 ++syminfo
, ++extsym
)
9313 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9314 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9321 if (do_dynamic
&& dynamic_addr
)
9322 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9323 dynamic_addr
, (unsigned long) dynamic_nent
);
9325 printf (_(" Tag Type Name/Value\n"));
9327 for (entry
= dynamic_section
;
9328 entry
< dynamic_section
+ dynamic_nent
;
9336 print_vma (entry
->d_tag
, FULL_HEX
);
9337 dtype
= get_dynamic_type (entry
->d_tag
);
9338 printf (" (%s)%*s", dtype
,
9339 ((is_32bit_elf
? 27 : 19)
9340 - (int) strlen (dtype
)),
9344 switch (entry
->d_tag
)
9348 print_dynamic_flags (entry
->d_un
.d_val
);
9358 switch (entry
->d_tag
)
9361 printf (_("Auxiliary library"));
9365 printf (_("Filter library"));
9369 printf (_("Configuration file"));
9373 printf (_("Dependency audit library"));
9377 printf (_("Audit library"));
9381 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9382 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9386 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9395 printf (_("Flags:"));
9397 if (entry
->d_un
.d_val
== 0)
9398 printf (_(" None\n"));
9401 unsigned long int val
= entry
->d_un
.d_val
;
9403 if (val
& DTF_1_PARINIT
)
9405 printf (" PARINIT");
9406 val
^= DTF_1_PARINIT
;
9408 if (val
& DTF_1_CONFEXP
)
9410 printf (" CONFEXP");
9411 val
^= DTF_1_CONFEXP
;
9414 printf (" %lx", val
);
9423 printf (_("Flags:"));
9425 if (entry
->d_un
.d_val
== 0)
9426 printf (_(" None\n"));
9429 unsigned long int val
= entry
->d_un
.d_val
;
9431 if (val
& DF_P1_LAZYLOAD
)
9433 printf (" LAZYLOAD");
9434 val
^= DF_P1_LAZYLOAD
;
9436 if (val
& DF_P1_GROUPPERM
)
9438 printf (" GROUPPERM");
9439 val
^= DF_P1_GROUPPERM
;
9442 printf (" %lx", val
);
9451 printf (_("Flags:"));
9452 if (entry
->d_un
.d_val
== 0)
9453 printf (_(" None\n"));
9456 unsigned long int val
= entry
->d_un
.d_val
;
9463 if (val
& DF_1_GLOBAL
)
9468 if (val
& DF_1_GROUP
)
9473 if (val
& DF_1_NODELETE
)
9475 printf (" NODELETE");
9476 val
^= DF_1_NODELETE
;
9478 if (val
& DF_1_LOADFLTR
)
9480 printf (" LOADFLTR");
9481 val
^= DF_1_LOADFLTR
;
9483 if (val
& DF_1_INITFIRST
)
9485 printf (" INITFIRST");
9486 val
^= DF_1_INITFIRST
;
9488 if (val
& DF_1_NOOPEN
)
9493 if (val
& DF_1_ORIGIN
)
9498 if (val
& DF_1_DIRECT
)
9503 if (val
& DF_1_TRANS
)
9508 if (val
& DF_1_INTERPOSE
)
9510 printf (" INTERPOSE");
9511 val
^= DF_1_INTERPOSE
;
9513 if (val
& DF_1_NODEFLIB
)
9515 printf (" NODEFLIB");
9516 val
^= DF_1_NODEFLIB
;
9518 if (val
& DF_1_NODUMP
)
9523 if (val
& DF_1_CONFALT
)
9525 printf (" CONFALT");
9526 val
^= DF_1_CONFALT
;
9528 if (val
& DF_1_ENDFILTEE
)
9530 printf (" ENDFILTEE");
9531 val
^= DF_1_ENDFILTEE
;
9533 if (val
& DF_1_DISPRELDNE
)
9535 printf (" DISPRELDNE");
9536 val
^= DF_1_DISPRELDNE
;
9538 if (val
& DF_1_DISPRELPND
)
9540 printf (" DISPRELPND");
9541 val
^= DF_1_DISPRELPND
;
9543 if (val
& DF_1_NODIRECT
)
9545 printf (" NODIRECT");
9546 val
^= DF_1_NODIRECT
;
9548 if (val
& DF_1_IGNMULDEF
)
9550 printf (" IGNMULDEF");
9551 val
^= DF_1_IGNMULDEF
;
9553 if (val
& DF_1_NOKSYMS
)
9555 printf (" NOKSYMS");
9556 val
^= DF_1_NOKSYMS
;
9558 if (val
& DF_1_NOHDR
)
9563 if (val
& DF_1_EDITED
)
9568 if (val
& DF_1_NORELOC
)
9570 printf (" NORELOC");
9571 val
^= DF_1_NORELOC
;
9573 if (val
& DF_1_SYMINTPOSE
)
9575 printf (" SYMINTPOSE");
9576 val
^= DF_1_SYMINTPOSE
;
9578 if (val
& DF_1_GLOBAUDIT
)
9580 printf (" GLOBAUDIT");
9581 val
^= DF_1_GLOBAUDIT
;
9583 if (val
& DF_1_SINGLETON
)
9585 printf (" SINGLETON");
9586 val
^= DF_1_SINGLETON
;
9588 if (val
& DF_1_STUB
)
9599 printf (" %lx", val
);
9606 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9608 puts (get_dynamic_type (entry
->d_un
.d_val
));
9628 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9634 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9635 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9641 switch (entry
->d_tag
)
9644 printf (_("Shared library: [%s]"), name
);
9646 if (streq (name
, program_interpreter
))
9647 printf (_(" program interpreter"));
9651 printf (_("Library soname: [%s]"), name
);
9655 printf (_("Library rpath: [%s]"), name
);
9659 printf (_("Library runpath: [%s]"), name
);
9663 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9668 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9681 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9685 case DT_INIT_ARRAYSZ
:
9686 case DT_FINI_ARRAYSZ
:
9687 case DT_GNU_CONFLICTSZ
:
9688 case DT_GNU_LIBLISTSZ
:
9691 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9692 printf (_(" (bytes)\n"));
9702 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9715 if (entry
->d_tag
== DT_USED
9716 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9718 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9722 printf (_("Not needed object: [%s]\n"), name
);
9727 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9733 /* The value of this entry is ignored. */
9738 case DT_GNU_PRELINKED
:
9742 time_t atime
= entry
->d_un
.d_val
;
9744 tmp
= gmtime (&atime
);
9745 /* PR 17533 file: 041-1244816-0.004. */
9747 printf (_("<corrupt time val: %lx"),
9748 (unsigned long) atime
);
9750 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9751 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9752 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9758 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9761 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9767 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9768 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9773 switch (elf_header
.e_machine
)
9776 case EM_MIPS_RS3_LE
:
9777 dynamic_section_mips_val (entry
);
9780 dynamic_section_parisc_val (entry
);
9783 dynamic_section_ia64_val (entry
);
9786 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9798 get_ver_flags (unsigned int flags
)
9800 static char buff
[32];
9807 if (flags
& VER_FLG_BASE
)
9808 strcat (buff
, "BASE ");
9810 if (flags
& VER_FLG_WEAK
)
9812 if (flags
& VER_FLG_BASE
)
9813 strcat (buff
, "| ");
9815 strcat (buff
, "WEAK ");
9818 if (flags
& VER_FLG_INFO
)
9820 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9821 strcat (buff
, "| ");
9823 strcat (buff
, "INFO ");
9826 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9827 strcat (buff
, _("| <unknown>"));
9832 /* Display the contents of the version sections. */
9835 process_version_sections (FILE * file
)
9837 Elf_Internal_Shdr
* section
;
9844 for (i
= 0, section
= section_headers
;
9845 i
< elf_header
.e_shnum
;
9848 switch (section
->sh_type
)
9850 case SHT_GNU_verdef
:
9852 Elf_External_Verdef
* edefs
;
9859 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9860 printable_section_name (section
),
9863 printf (_(" Addr: 0x"));
9864 printf_vma (section
->sh_addr
);
9865 printf (_(" Offset: %#08lx Link: %u (%s)"),
9866 (unsigned long) section
->sh_offset
, section
->sh_link
,
9867 printable_section_name_from_index (section
->sh_link
));
9869 edefs
= (Elf_External_Verdef
*)
9870 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9871 _("version definition section"));
9874 endbuf
= (char *) edefs
+ section
->sh_size
;
9876 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9879 Elf_External_Verdef
* edef
;
9880 Elf_Internal_Verdef ent
;
9881 Elf_External_Verdaux
* eaux
;
9882 Elf_Internal_Verdaux aux
;
9886 /* Check for very large indicies. */
9887 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9890 vstart
= ((char *) edefs
) + idx
;
9891 if (vstart
+ sizeof (*edef
) > endbuf
)
9894 edef
= (Elf_External_Verdef
*) vstart
;
9896 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9897 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9898 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9899 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9900 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9901 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9902 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9904 printf (_(" %#06x: Rev: %d Flags: %s"),
9905 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9907 printf (_(" Index: %d Cnt: %d "),
9908 ent
.vd_ndx
, ent
.vd_cnt
);
9910 /* Check for overflow. */
9911 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9914 vstart
+= ent
.vd_aux
;
9916 eaux
= (Elf_External_Verdaux
*) vstart
;
9918 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9919 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9921 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9922 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9924 printf (_("Name index: %ld\n"), aux
.vda_name
);
9926 isum
= idx
+ ent
.vd_aux
;
9928 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9930 /* Check for overflow. */
9931 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9934 isum
+= aux
.vda_next
;
9935 vstart
+= aux
.vda_next
;
9937 eaux
= (Elf_External_Verdaux
*) vstart
;
9938 if (vstart
+ sizeof (*eaux
) > endbuf
)
9941 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9942 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9944 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9945 printf (_(" %#06x: Parent %d: %s\n"),
9946 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9948 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9949 isum
, j
, aux
.vda_name
);
9953 printf (_(" Version def aux past end of section\n"));
9955 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9956 if (idx
+ ent
.vd_next
<= idx
)
9962 if (cnt
< section
->sh_info
)
9963 printf (_(" Version definition past end of section\n"));
9969 case SHT_GNU_verneed
:
9971 Elf_External_Verneed
* eneed
;
9978 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9979 printable_section_name (section
), section
->sh_info
);
9981 printf (_(" Addr: 0x"));
9982 printf_vma (section
->sh_addr
);
9983 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9984 (unsigned long) section
->sh_offset
, section
->sh_link
,
9985 printable_section_name_from_index (section
->sh_link
));
9987 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9988 section
->sh_offset
, 1,
9990 _("Version Needs section"));
9993 endbuf
= (char *) eneed
+ section
->sh_size
;
9995 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9997 Elf_External_Verneed
* entry
;
9998 Elf_Internal_Verneed ent
;
10003 if (idx
> (size_t) (endbuf
- (char *) eneed
))
10006 vstart
= ((char *) eneed
) + idx
;
10007 if (vstart
+ sizeof (*entry
) > endbuf
)
10010 entry
= (Elf_External_Verneed
*) vstart
;
10012 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10013 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10014 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10015 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10016 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10018 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
10020 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10021 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10023 printf (_(" File: %lx"), ent
.vn_file
);
10025 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10027 /* Check for overflow. */
10028 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10030 vstart
+= ent
.vn_aux
;
10032 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10034 Elf_External_Vernaux
* eaux
;
10035 Elf_Internal_Vernaux aux
;
10037 if (vstart
+ sizeof (*eaux
) > endbuf
)
10039 eaux
= (Elf_External_Vernaux
*) vstart
;
10041 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10042 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10043 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10044 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10045 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10047 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10048 printf (_(" %#06x: Name: %s"),
10049 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10051 printf (_(" %#06x: Name index: %lx"),
10052 isum
, aux
.vna_name
);
10054 printf (_(" Flags: %s Version: %d\n"),
10055 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10057 /* Check for overflow. */
10058 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
10059 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
10061 warn (_("Invalid vna_next field of %lx\n"),
10066 isum
+= aux
.vna_next
;
10067 vstart
+= aux
.vna_next
;
10070 if (j
< ent
.vn_cnt
)
10071 warn (_("Missing Version Needs auxillary information\n"));
10073 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
10075 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10076 cnt
= section
->sh_info
;
10079 idx
+= ent
.vn_next
;
10082 if (cnt
< section
->sh_info
)
10083 warn (_("Missing Version Needs information\n"));
10089 case SHT_GNU_versym
:
10091 Elf_Internal_Shdr
* link_section
;
10094 unsigned char * edata
;
10095 unsigned short * data
;
10097 Elf_Internal_Sym
* symbols
;
10098 Elf_Internal_Shdr
* string_sec
;
10099 unsigned long num_syms
;
10102 if (section
->sh_link
>= elf_header
.e_shnum
)
10105 link_section
= section_headers
+ section
->sh_link
;
10106 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10108 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10113 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10114 if (symbols
== NULL
)
10117 string_sec
= section_headers
+ link_section
->sh_link
;
10119 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10120 string_sec
->sh_size
,
10121 _("version string table"));
10128 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10129 printable_section_name (section
), (unsigned long) total
);
10131 printf (_(" Addr: "));
10132 printf_vma (section
->sh_addr
);
10133 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10134 (unsigned long) section
->sh_offset
, section
->sh_link
,
10135 printable_section_name (link_section
));
10137 off
= offset_from_vma (file
,
10138 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10139 total
* sizeof (short));
10140 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10142 _("version symbol data"));
10150 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10152 for (cnt
= total
; cnt
--;)
10153 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10158 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10162 char *invalid
= _("*invalid*");
10164 printf (" %03x:", cnt
);
10166 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10167 switch (data
[cnt
+ j
])
10170 fputs (_(" 0 (*local*) "), stdout
);
10174 fputs (_(" 1 (*global*) "), stdout
);
10178 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10179 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10181 /* If this index value is greater than the size of the symbols
10182 array, break to avoid an out-of-bounds read. */
10183 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10185 warn (_("invalid index into symbol array\n"));
10190 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10192 Elf_Internal_Verneed ivn
;
10193 unsigned long offset
;
10195 offset
= offset_from_vma
10196 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10197 sizeof (Elf_External_Verneed
));
10201 Elf_Internal_Vernaux ivna
;
10202 Elf_External_Verneed evn
;
10203 Elf_External_Vernaux evna
;
10204 unsigned long a_off
;
10206 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10207 _("version need")) == NULL
)
10210 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10211 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10213 a_off
= offset
+ ivn
.vn_aux
;
10217 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10218 1, _("version need aux (2)")) == NULL
)
10221 ivna
.vna_other
= 0;
10225 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10226 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10229 a_off
+= ivna
.vna_next
;
10231 while (ivna
.vna_other
!= data
[cnt
+ j
]
10232 && ivna
.vna_next
!= 0);
10234 if (ivna
.vna_other
== data
[cnt
+ j
])
10236 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10238 if (ivna
.vna_name
>= string_sec
->sh_size
)
10241 name
= strtab
+ ivna
.vna_name
;
10245 offset
+= ivn
.vn_next
;
10247 while (ivn
.vn_next
);
10250 if (data
[cnt
+ j
] != 0x8001
10251 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10253 Elf_Internal_Verdef ivd
;
10254 Elf_External_Verdef evd
;
10255 unsigned long offset
;
10257 offset
= offset_from_vma
10258 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10263 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10264 _("version def")) == NULL
)
10267 /* PR 17531: file: 046-1082287-0.004. */
10268 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10273 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10274 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10277 offset
+= ivd
.vd_next
;
10279 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10280 && ivd
.vd_next
!= 0);
10282 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10284 Elf_External_Verdaux evda
;
10285 Elf_Internal_Verdaux ivda
;
10287 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10289 if (get_data (&evda
, file
,
10290 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10292 _("version def aux")) == NULL
)
10295 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10297 if (ivda
.vda_name
>= string_sec
->sh_size
)
10299 else if (name
!= NULL
&& name
!= invalid
)
10300 name
= _("*both*");
10302 name
= strtab
+ ivda
.vda_name
;
10306 nn
+= printf ("(%s%-*s",
10308 12 - (int) strlen (name
),
10312 printf ("%*c", 18 - nn
, ' ');
10330 printf (_("\nNo version information found in this file.\n"));
10335 static const char *
10336 get_symbol_binding (unsigned int binding
)
10338 static char buff
[32];
10342 case STB_LOCAL
: return "LOCAL";
10343 case STB_GLOBAL
: return "GLOBAL";
10344 case STB_WEAK
: return "WEAK";
10346 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10347 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10349 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10351 if (binding
== STB_GNU_UNIQUE
10352 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10353 /* GNU is still using the default value 0. */
10354 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10356 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10359 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10364 static const char *
10365 get_symbol_type (unsigned int type
)
10367 static char buff
[32];
10371 case STT_NOTYPE
: return "NOTYPE";
10372 case STT_OBJECT
: return "OBJECT";
10373 case STT_FUNC
: return "FUNC";
10374 case STT_SECTION
: return "SECTION";
10375 case STT_FILE
: return "FILE";
10376 case STT_COMMON
: return "COMMON";
10377 case STT_TLS
: return "TLS";
10378 case STT_RELC
: return "RELC";
10379 case STT_SRELC
: return "SRELC";
10381 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10383 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10384 return "THUMB_FUNC";
10386 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10389 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10390 return "PARISC_MILLI";
10392 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10394 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10396 if (elf_header
.e_machine
== EM_PARISC
)
10398 if (type
== STT_HP_OPAQUE
)
10399 return "HP_OPAQUE";
10400 if (type
== STT_HP_STUB
)
10404 if (type
== STT_GNU_IFUNC
10405 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10406 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10407 /* GNU is still using the default value 0. */
10408 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10411 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10414 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10419 static const char *
10420 get_symbol_visibility (unsigned int visibility
)
10422 switch (visibility
)
10424 case STV_DEFAULT
: return "DEFAULT";
10425 case STV_INTERNAL
: return "INTERNAL";
10426 case STV_HIDDEN
: return "HIDDEN";
10427 case STV_PROTECTED
: return "PROTECTED";
10429 error (_("Unrecognized visibility value: %u"), visibility
);
10430 return _("<unknown>");
10434 static const char *
10435 get_solaris_symbol_visibility (unsigned int visibility
)
10437 switch (visibility
)
10439 case 4: return "EXPORTED";
10440 case 5: return "SINGLETON";
10441 case 6: return "ELIMINATE";
10442 default: return get_symbol_visibility (visibility
);
10446 static const char *
10447 get_mips_symbol_other (unsigned int other
)
10457 case STO_MICROMIPS
:
10458 return "MICROMIPS";
10459 case STO_MICROMIPS
| STO_MIPS_PIC
:
10460 return "MICROMIPS, MIPS PIC";
10468 static const char *
10469 get_ia64_symbol_other (unsigned int other
)
10471 if (is_ia64_vms ())
10473 static char res
[32];
10477 /* Function types is for images and .STB files only. */
10478 switch (elf_header
.e_type
)
10482 switch (VMS_ST_FUNC_TYPE (other
))
10484 case VMS_SFT_CODE_ADDR
:
10485 strcat (res
, " CA");
10487 case VMS_SFT_SYMV_IDX
:
10488 strcat (res
, " VEC");
10491 strcat (res
, " FD");
10493 case VMS_SFT_RESERVE
:
10494 strcat (res
, " RSV");
10497 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10498 VMS_ST_FUNC_TYPE (other
));
10499 strcat (res
, " <unknown>");
10506 switch (VMS_ST_LINKAGE (other
))
10508 case VMS_STL_IGNORE
:
10509 strcat (res
, " IGN");
10511 case VMS_STL_RESERVE
:
10512 strcat (res
, " RSV");
10515 strcat (res
, " STD");
10518 strcat (res
, " LNK");
10521 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10522 VMS_ST_LINKAGE (other
));
10523 strcat (res
, " <unknown>");
10535 static const char *
10536 get_ppc64_symbol_other (unsigned int other
)
10538 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10540 static char buf
[32];
10541 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10542 PPC64_LOCAL_ENTRY_OFFSET (other
));
10548 static const char *
10549 get_symbol_other (unsigned int other
)
10551 const char * result
= NULL
;
10552 static char buff
[32];
10557 switch (elf_header
.e_machine
)
10560 result
= get_mips_symbol_other (other
);
10563 result
= get_ia64_symbol_other (other
);
10566 result
= get_ppc64_symbol_other (other
);
10576 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10580 static const char *
10581 get_symbol_index_type (unsigned int type
)
10583 static char buff
[32];
10587 case SHN_UNDEF
: return "UND";
10588 case SHN_ABS
: return "ABS";
10589 case SHN_COMMON
: return "COM";
10591 if (type
== SHN_IA_64_ANSI_COMMON
10592 && elf_header
.e_machine
== EM_IA_64
10593 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10595 else if ((elf_header
.e_machine
== EM_X86_64
10596 || elf_header
.e_machine
== EM_L1OM
10597 || elf_header
.e_machine
== EM_K1OM
)
10598 && type
== SHN_X86_64_LCOMMON
)
10599 return "LARGE_COM";
10600 else if ((type
== SHN_MIPS_SCOMMON
10601 && elf_header
.e_machine
== EM_MIPS
)
10602 || (type
== SHN_TIC6X_SCOMMON
10603 && elf_header
.e_machine
== EM_TI_C6000
))
10605 else if (type
== SHN_MIPS_SUNDEFINED
10606 && elf_header
.e_machine
== EM_MIPS
)
10608 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10609 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10610 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10611 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10612 else if (type
>= SHN_LORESERVE
)
10613 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10614 else if (type
>= elf_header
.e_shnum
)
10615 sprintf (buff
, _("bad section index[%3d]"), type
);
10617 sprintf (buff
, "%3d", type
);
10625 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10627 unsigned char * e_data
;
10630 /* If the size_t type is smaller than the bfd_size_type, eg because
10631 you are building a 32-bit tool on a 64-bit host, then make sure
10632 that when (number) is cast to (size_t) no information is lost. */
10633 if (sizeof (size_t) < sizeof (bfd_size_type
)
10634 && (bfd_size_type
) ((size_t) number
) != number
)
10636 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10637 " elements of size %u\n"),
10642 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10643 attempting to allocate memory when the read is bound to fail. */
10644 if (ent_size
* number
> current_file_size
)
10646 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10651 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10652 if (e_data
== NULL
)
10654 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10659 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10661 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10662 number
* ent_size
);
10667 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10668 if (i_data
== NULL
)
10670 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10671 " dynamic entries\n"),
10678 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10686 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10688 Elf_Internal_Sym
* psym
;
10691 n
= print_vma (si
, DEC_5
);
10693 fputs (&" "[n
], stdout
);
10694 printf (" %3lu: ", hn
);
10696 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10698 printf (_("<No info available for dynamic symbol number %lu>\n"),
10699 (unsigned long) si
);
10703 psym
= dynamic_symbols
+ si
;
10704 print_vma (psym
->st_value
, LONG_HEX
);
10706 print_vma (psym
->st_size
, DEC_5
);
10708 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10709 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10711 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
10712 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
10715 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
10717 printf (" %-7s", get_symbol_visibility (vis
));
10718 /* Check to see if any other bits in the st_other field are set.
10719 Note - displaying this information disrupts the layout of the
10720 table being generated, but for the moment this case is very
10722 if (psym
->st_other
^ vis
)
10723 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
10726 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10727 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10728 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10730 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10734 static const char *
10735 get_symbol_version_string (FILE *file
, int is_dynsym
,
10736 const char *strtab
,
10737 unsigned long int strtab_size
,
10738 unsigned int si
, Elf_Internal_Sym
*psym
,
10739 enum versioned_symbol_info
*sym_info
,
10740 unsigned short *vna_other
)
10742 unsigned char data
[2];
10743 unsigned short vers_data
;
10744 unsigned long offset
;
10747 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10750 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10751 sizeof data
+ si
* sizeof (vers_data
));
10753 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10754 sizeof (data
), 1, _("version data")) == NULL
)
10757 vers_data
= byte_get (data
, 2);
10759 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10762 /* Usually we'd only see verdef for defined symbols, and verneed for
10763 undefined symbols. However, symbols defined by the linker in
10764 .dynbss for variables copied from a shared library in order to
10765 avoid text relocations are defined yet have verneed. We could
10766 use a heuristic to detect the special case, for example, check
10767 for verneed first on symbols defined in SHT_NOBITS sections, but
10768 it is simpler and more reliable to just look for both verdef and
10769 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10771 if (psym
->st_shndx
!= SHN_UNDEF
10772 && vers_data
!= 0x8001
10773 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10775 Elf_Internal_Verdef ivd
;
10776 Elf_Internal_Verdaux ivda
;
10777 Elf_External_Verdaux evda
;
10780 off
= offset_from_vma (file
,
10781 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10782 sizeof (Elf_External_Verdef
));
10786 Elf_External_Verdef evd
;
10788 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10789 _("version def")) == NULL
)
10797 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10798 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10799 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10802 off
+= ivd
.vd_next
;
10804 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10806 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10808 off
-= ivd
.vd_next
;
10811 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10812 _("version def aux")) != NULL
)
10814 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10816 if (psym
->st_name
!= ivda
.vda_name
)
10818 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10819 ? symbol_hidden
: symbol_public
);
10820 return (ivda
.vda_name
< strtab_size
10821 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10827 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10829 Elf_External_Verneed evn
;
10830 Elf_Internal_Verneed ivn
;
10831 Elf_Internal_Vernaux ivna
;
10833 offset
= offset_from_vma (file
,
10834 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10838 unsigned long vna_off
;
10840 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10841 _("version need")) == NULL
)
10844 ivna
.vna_other
= 0;
10849 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10850 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10852 vna_off
= offset
+ ivn
.vn_aux
;
10856 Elf_External_Vernaux evna
;
10858 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10859 _("version need aux (3)")) == NULL
)
10862 ivna
.vna_other
= 0;
10867 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10868 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10869 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10872 vna_off
+= ivna
.vna_next
;
10874 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10876 if (ivna
.vna_other
== vers_data
)
10879 offset
+= ivn
.vn_next
;
10881 while (ivn
.vn_next
!= 0);
10883 if (ivna
.vna_other
== vers_data
)
10885 *sym_info
= symbol_undefined
;
10886 *vna_other
= ivna
.vna_other
;
10887 return (ivna
.vna_name
< strtab_size
10888 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
10894 /* Dump the symbol table. */
10896 process_symbol_table (FILE * file
)
10898 Elf_Internal_Shdr
* section
;
10899 bfd_size_type nbuckets
= 0;
10900 bfd_size_type nchains
= 0;
10901 bfd_vma
* buckets
= NULL
;
10902 bfd_vma
* chains
= NULL
;
10903 bfd_vma ngnubuckets
= 0;
10904 bfd_vma
* gnubuckets
= NULL
;
10905 bfd_vma
* gnuchains
= NULL
;
10906 bfd_vma gnusymidx
= 0;
10907 bfd_size_type ngnuchains
= 0;
10909 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10912 if (dynamic_info
[DT_HASH
]
10914 || (do_using_dynamic
10916 && dynamic_strings
!= NULL
)))
10918 unsigned char nb
[8];
10919 unsigned char nc
[8];
10920 unsigned int hash_ent_size
= 4;
10922 if ((elf_header
.e_machine
== EM_ALPHA
10923 || elf_header
.e_machine
== EM_S390
10924 || elf_header
.e_machine
== EM_S390_OLD
)
10925 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10929 (archive_file_offset
10930 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10931 sizeof nb
+ sizeof nc
)),
10934 error (_("Unable to seek to start of dynamic information\n"));
10938 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10940 error (_("Failed to read in number of buckets\n"));
10944 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10946 error (_("Failed to read in number of chains\n"));
10950 nbuckets
= byte_get (nb
, hash_ent_size
);
10951 nchains
= byte_get (nc
, hash_ent_size
);
10953 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10954 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10957 if (buckets
== NULL
|| chains
== NULL
)
10959 if (do_using_dynamic
)
10970 if (dynamic_info_DT_GNU_HASH
10972 || (do_using_dynamic
10974 && dynamic_strings
!= NULL
)))
10976 unsigned char nb
[16];
10977 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10978 bfd_vma buckets_vma
;
10981 (archive_file_offset
10982 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10986 error (_("Unable to seek to start of dynamic information\n"));
10990 if (fread (nb
, 16, 1, file
) != 1)
10992 error (_("Failed to read in number of buckets\n"));
10996 ngnubuckets
= byte_get (nb
, 4);
10997 gnusymidx
= byte_get (nb
+ 4, 4);
10998 bitmaskwords
= byte_get (nb
+ 8, 4);
10999 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11001 buckets_vma
+= bitmaskwords
* 4;
11003 buckets_vma
+= bitmaskwords
* 8;
11006 (archive_file_offset
11007 + offset_from_vma (file
, buckets_vma
, 4)),
11010 error (_("Unable to seek to start of dynamic information\n"));
11014 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11016 if (gnubuckets
== NULL
)
11019 for (i
= 0; i
< ngnubuckets
; i
++)
11020 if (gnubuckets
[i
] != 0)
11022 if (gnubuckets
[i
] < gnusymidx
)
11025 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11026 maxchain
= gnubuckets
[i
];
11029 if (maxchain
== 0xffffffff)
11032 maxchain
-= gnusymidx
;
11035 (archive_file_offset
11036 + offset_from_vma (file
, buckets_vma
11037 + 4 * (ngnubuckets
+ maxchain
), 4)),
11040 error (_("Unable to seek to start of dynamic information\n"));
11046 if (fread (nb
, 4, 1, file
) != 1)
11048 error (_("Failed to determine last chain length\n"));
11052 if (maxchain
+ 1 == 0)
11057 while ((byte_get (nb
, 4) & 1) == 0);
11060 (archive_file_offset
11061 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11064 error (_("Unable to seek to start of dynamic information\n"));
11068 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11069 ngnuchains
= maxchain
;
11072 if (gnuchains
== NULL
)
11077 if (do_using_dynamic
)
11082 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11084 && do_using_dynamic
11085 && dynamic_strings
!= NULL
11086 && dynamic_symbols
!= NULL
)
11090 if (dynamic_info
[DT_HASH
])
11094 printf (_("\nSymbol table for image:\n"));
11096 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11098 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11100 for (hn
= 0; hn
< nbuckets
; hn
++)
11105 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11106 print_dynamic_symbol (si
, hn
);
11110 if (dynamic_info_DT_GNU_HASH
)
11112 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11114 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11116 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11118 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11119 if (gnubuckets
[hn
] != 0)
11121 bfd_vma si
= gnubuckets
[hn
];
11122 bfd_vma off
= si
- gnusymidx
;
11126 print_dynamic_symbol (si
, hn
);
11129 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11133 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11134 && section_headers
!= NULL
)
11138 for (i
= 0, section
= section_headers
;
11139 i
< elf_header
.e_shnum
;
11143 char * strtab
= NULL
;
11144 unsigned long int strtab_size
= 0;
11145 Elf_Internal_Sym
* symtab
;
11146 Elf_Internal_Sym
* psym
;
11147 unsigned long num_syms
;
11149 if ((section
->sh_type
!= SHT_SYMTAB
11150 && section
->sh_type
!= SHT_DYNSYM
)
11152 && section
->sh_type
== SHT_SYMTAB
))
11155 if (section
->sh_entsize
== 0)
11157 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11158 printable_section_name (section
));
11162 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11163 printable_section_name (section
),
11164 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11167 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11169 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11171 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11172 if (symtab
== NULL
)
11175 if (section
->sh_link
== elf_header
.e_shstrndx
)
11177 strtab
= string_table
;
11178 strtab_size
= string_table_length
;
11180 else if (section
->sh_link
< elf_header
.e_shnum
)
11182 Elf_Internal_Shdr
* string_sec
;
11184 string_sec
= section_headers
+ section
->sh_link
;
11186 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11187 1, string_sec
->sh_size
,
11188 _("string table"));
11189 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11192 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11194 const char *version_string
;
11195 enum versioned_symbol_info sym_info
;
11196 unsigned short vna_other
;
11198 printf ("%6d: ", si
);
11199 print_vma (psym
->st_value
, LONG_HEX
);
11201 print_vma (psym
->st_size
, DEC_5
);
11202 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11203 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11204 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11205 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11208 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11210 printf (" %-7s", get_symbol_visibility (vis
));
11211 /* Check to see if any other bits in the st_other field are set.
11212 Note - displaying this information disrupts the layout of the
11213 table being generated, but for the moment this case is very rare. */
11214 if (psym
->st_other
^ vis
)
11215 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11217 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11218 print_symbol (25, psym
->st_name
< strtab_size
11219 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11222 = get_symbol_version_string (file
,
11223 section
->sh_type
== SHT_DYNSYM
,
11224 strtab
, strtab_size
, si
,
11225 psym
, &sym_info
, &vna_other
);
11226 if (version_string
)
11228 if (sym_info
== symbol_undefined
)
11229 printf ("@%s (%d)", version_string
, vna_other
);
11231 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11237 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11238 && si
>= section
->sh_info
11239 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11240 && elf_header
.e_machine
!= EM_MIPS
11241 /* Solaris binaries have been found to violate this requirement as
11242 well. Not sure if this is a bug or an ABI requirement. */
11243 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11244 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11245 si
, printable_section_name (section
), section
->sh_info
);
11249 if (strtab
!= string_table
)
11255 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11257 if (do_histogram
&& buckets
!= NULL
)
11259 unsigned long * lengths
;
11260 unsigned long * counts
;
11263 unsigned long maxlength
= 0;
11264 unsigned long nzero_counts
= 0;
11265 unsigned long nsyms
= 0;
11266 unsigned long chained
;
11268 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11269 (unsigned long) nbuckets
);
11271 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11272 if (lengths
== NULL
)
11274 error (_("Out of memory allocating space for histogram buckets\n"));
11278 printf (_(" Length Number %% of total Coverage\n"));
11279 for (hn
= 0; hn
< nbuckets
; ++hn
)
11281 for (si
= buckets
[hn
], chained
= 0;
11282 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11283 si
= chains
[si
], ++chained
)
11286 if (maxlength
< ++lengths
[hn
])
11290 /* PR binutils/17531: A corrupt binary could contain broken
11291 histogram data. Do not go into an infinite loop trying
11293 if (chained
> nchains
)
11295 error (_("histogram chain is corrupt\n"));
11300 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11301 if (counts
== NULL
)
11304 error (_("Out of memory allocating space for histogram counts\n"));
11308 for (hn
= 0; hn
< nbuckets
; ++hn
)
11309 ++counts
[lengths
[hn
]];
11314 printf (" 0 %-10lu (%5.1f%%)\n",
11315 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11316 for (i
= 1; i
<= maxlength
; ++i
)
11318 nzero_counts
+= counts
[i
] * i
;
11319 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11320 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11321 (nzero_counts
* 100.0) / nsyms
);
11329 if (buckets
!= NULL
)
11335 if (do_histogram
&& gnubuckets
!= NULL
)
11337 unsigned long * lengths
;
11338 unsigned long * counts
;
11340 unsigned long maxlength
= 0;
11341 unsigned long nzero_counts
= 0;
11342 unsigned long nsyms
= 0;
11344 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11345 (unsigned long) ngnubuckets
);
11347 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11348 if (lengths
== NULL
)
11350 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11354 printf (_(" Length Number %% of total Coverage\n"));
11356 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11357 if (gnubuckets
[hn
] != 0)
11359 bfd_vma off
, length
= 1;
11361 for (off
= gnubuckets
[hn
] - gnusymidx
;
11362 /* PR 17531 file: 010-77222-0.004. */
11363 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11366 lengths
[hn
] = length
;
11367 if (length
> maxlength
)
11368 maxlength
= length
;
11372 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11373 if (counts
== NULL
)
11376 error (_("Out of memory allocating space for gnu histogram counts\n"));
11380 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11381 ++counts
[lengths
[hn
]];
11383 if (ngnubuckets
> 0)
11386 printf (" 0 %-10lu (%5.1f%%)\n",
11387 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11388 for (j
= 1; j
<= maxlength
; ++j
)
11390 nzero_counts
+= counts
[j
] * j
;
11391 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11392 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11393 (nzero_counts
* 100.0) / nsyms
);
11407 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11411 if (dynamic_syminfo
== NULL
11413 /* No syminfo, this is ok. */
11416 /* There better should be a dynamic symbol section. */
11417 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11421 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11422 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11424 printf (_(" Num: Name BoundTo Flags\n"));
11425 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11427 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11429 printf ("%4d: ", i
);
11430 if (i
>= num_dynamic_syms
)
11431 printf (_("<corrupt index>"));
11432 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11433 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11435 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11438 switch (dynamic_syminfo
[i
].si_boundto
)
11440 case SYMINFO_BT_SELF
:
11441 fputs ("SELF ", stdout
);
11443 case SYMINFO_BT_PARENT
:
11444 fputs ("PARENT ", stdout
);
11447 if (dynamic_syminfo
[i
].si_boundto
> 0
11448 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11449 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11451 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11455 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11459 if (flags
& SYMINFO_FLG_DIRECT
)
11460 printf (" DIRECT");
11461 if (flags
& SYMINFO_FLG_PASSTHRU
)
11462 printf (" PASSTHRU");
11463 if (flags
& SYMINFO_FLG_COPY
)
11465 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11466 printf (" LAZYLOAD");
11474 /* Check to see if the given reloc needs to be handled in a target specific
11475 manner. If so then process the reloc and return TRUE otherwise return
11479 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11480 unsigned char * start
,
11481 Elf_Internal_Sym
* symtab
)
11483 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11485 switch (elf_header
.e_machine
)
11488 case EM_MSP430_OLD
:
11490 static Elf_Internal_Sym
* saved_sym
= NULL
;
11492 switch (reloc_type
)
11494 case 10: /* R_MSP430_SYM_DIFF */
11495 if (uses_msp430x_relocs ())
11497 case 21: /* R_MSP430X_SYM_DIFF */
11498 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11501 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11502 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11503 goto handle_sym_diff
;
11505 case 5: /* R_MSP430_16_BYTE */
11506 case 9: /* R_MSP430_8 */
11507 if (uses_msp430x_relocs ())
11509 goto handle_sym_diff
;
11511 case 2: /* R_MSP430_ABS16 */
11512 case 15: /* R_MSP430X_ABS16 */
11513 if (! uses_msp430x_relocs ())
11515 goto handle_sym_diff
;
11518 if (saved_sym
!= NULL
)
11522 value
= reloc
->r_addend
11523 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11524 - saved_sym
->st_value
);
11526 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11534 if (saved_sym
!= NULL
)
11535 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11542 case EM_CYGNUS_MN10300
:
11544 static Elf_Internal_Sym
* saved_sym
= NULL
;
11546 switch (reloc_type
)
11548 case 34: /* R_MN10300_ALIGN */
11550 case 33: /* R_MN10300_SYM_DIFF */
11551 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11553 case 1: /* R_MN10300_32 */
11554 case 2: /* R_MN10300_16 */
11555 if (saved_sym
!= NULL
)
11559 value
= reloc
->r_addend
11560 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11561 - saved_sym
->st_value
);
11563 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11570 if (saved_sym
!= NULL
)
11571 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11579 static bfd_vma saved_sym1
= 0;
11580 static bfd_vma saved_sym2
= 0;
11581 static bfd_vma value
;
11583 switch (reloc_type
)
11585 case 0x80: /* R_RL78_SYM. */
11586 saved_sym1
= saved_sym2
;
11587 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11588 saved_sym2
+= reloc
->r_addend
;
11591 case 0x83: /* R_RL78_OPsub. */
11592 value
= saved_sym1
- saved_sym2
;
11593 saved_sym2
= saved_sym1
= 0;
11597 case 0x41: /* R_RL78_ABS32. */
11598 byte_put (start
+ reloc
->r_offset
, value
, 4);
11602 case 0x43: /* R_RL78_ABS16. */
11603 byte_put (start
+ reloc
->r_offset
, value
, 2);
11617 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11618 DWARF debug sections. This is a target specific test. Note - we do not
11619 go through the whole including-target-headers-multiple-times route, (as
11620 we have already done with <elf/h8.h>) because this would become very
11621 messy and even then this function would have to contain target specific
11622 information (the names of the relocs instead of their numeric values).
11623 FIXME: This is not the correct way to solve this problem. The proper way
11624 is to have target specific reloc sizing and typing functions created by
11625 the reloc-macros.h header, in the same way that it already creates the
11626 reloc naming functions. */
11629 is_32bit_abs_reloc (unsigned int reloc_type
)
11631 /* Please keep this table alpha-sorted for ease of visual lookup. */
11632 switch (elf_header
.e_machine
)
11636 return reloc_type
== 1; /* R_386_32. */
11638 return reloc_type
== 1; /* R_68K_32. */
11640 return reloc_type
== 1; /* R_860_32. */
11642 return reloc_type
== 2; /* R_960_32. */
11644 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11645 case EM_ADAPTEVA_EPIPHANY
:
11646 return reloc_type
== 3;
11648 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11650 return reloc_type
== 1; /* R_ARC_32. */
11651 case EM_ARC_COMPACT
:
11652 case EM_ARC_COMPACT2
:
11653 return reloc_type
== 4; /* R_ARC_32. */
11655 return reloc_type
== 2; /* R_ARM_ABS32 */
11658 return reloc_type
== 1;
11660 return reloc_type
== 0x12; /* R_byte4_data. */
11662 return reloc_type
== 3; /* R_CRIS_32. */
11664 return reloc_type
== 3; /* R_CR16_NUM32. */
11666 return reloc_type
== 15; /* R_CRX_NUM32. */
11667 case EM_CYGNUS_FRV
:
11668 return reloc_type
== 1;
11669 case EM_CYGNUS_D10V
:
11671 return reloc_type
== 6; /* R_D10V_32. */
11672 case EM_CYGNUS_D30V
:
11674 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11676 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11677 case EM_CYGNUS_FR30
:
11679 return reloc_type
== 3; /* R_FR30_32. */
11681 return reloc_type
== 1; /* R_FT32_32. */
11685 return reloc_type
== 1; /* R_H8_DIR32. */
11687 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11688 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11691 return reloc_type
== 2; /* R_IP2K_32. */
11693 return reloc_type
== 2; /* R_IQ2000_32. */
11694 case EM_LATTICEMICO32
:
11695 return reloc_type
== 3; /* R_LM32_32. */
11698 return reloc_type
== 3; /* R_M32C_32. */
11700 return reloc_type
== 34; /* R_M32R_32_RELA. */
11703 return reloc_type
== 6; /* R_M68HC11_32. */
11705 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11706 case EM_CYGNUS_MEP
:
11707 return reloc_type
== 4; /* R_MEP_32. */
11709 return reloc_type
== 2; /* R_METAG_ADDR32. */
11710 case EM_MICROBLAZE
:
11711 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11713 return reloc_type
== 2; /* R_MIPS_32. */
11715 return reloc_type
== 4; /* R_MMIX_32. */
11716 case EM_CYGNUS_MN10200
:
11718 return reloc_type
== 1; /* R_MN10200_32. */
11719 case EM_CYGNUS_MN10300
:
11721 return reloc_type
== 1; /* R_MN10300_32. */
11723 return reloc_type
== 1; /* R_MOXIE_32. */
11724 case EM_MSP430_OLD
:
11726 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11728 return reloc_type
== 2; /* R_MT_32. */
11730 return reloc_type
== 20; /* R_NDS32_RELA. */
11731 case EM_ALTERA_NIOS2
:
11732 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11734 return reloc_type
== 1; /* R_NIOS_32. */
11736 return reloc_type
== 1; /* R_OR1K_32. */
11738 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11739 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11742 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11744 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11746 return reloc_type
== 1; /* R_PPC_ADDR32. */
11748 return reloc_type
== 1; /* R_RL78_DIR32. */
11750 return reloc_type
== 1; /* R_RX_DIR32. */
11752 return reloc_type
== 1; /* R_I370_ADDR31. */
11755 return reloc_type
== 4; /* R_S390_32. */
11757 return reloc_type
== 8; /* R_SCORE_ABS32. */
11759 return reloc_type
== 1; /* R_SH_DIR32. */
11760 case EM_SPARC32PLUS
:
11763 return reloc_type
== 3 /* R_SPARC_32. */
11764 || reloc_type
== 23; /* R_SPARC_UA32. */
11766 return reloc_type
== 6; /* R_SPU_ADDR32 */
11768 return reloc_type
== 1; /* R_C6000_ABS32. */
11770 return reloc_type
== 2; /* R_TILEGX_32. */
11772 return reloc_type
== 1; /* R_TILEPRO_32. */
11773 case EM_CYGNUS_V850
:
11775 return reloc_type
== 6; /* R_V850_ABS32. */
11777 return reloc_type
== 0x33; /* R_V810_WORD. */
11779 return reloc_type
== 1; /* R_VAX_32. */
11781 return reloc_type
== 3; /* R_VISIUM_32. */
11785 return reloc_type
== 10; /* R_X86_64_32. */
11788 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11790 return reloc_type
== 4; /* R_XGATE_32. */
11792 return reloc_type
== 1; /* R_XSTROMY16_32. */
11793 case EM_XTENSA_OLD
:
11795 return reloc_type
== 1; /* R_XTENSA_32. */
11798 static unsigned int prev_warn
= 0;
11800 /* Avoid repeating the same warning multiple times. */
11801 if (prev_warn
!= elf_header
.e_machine
)
11802 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11803 elf_header
.e_machine
);
11804 prev_warn
= elf_header
.e_machine
;
11810 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11811 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11814 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11816 switch (elf_header
.e_machine
)
11817 /* Please keep this table alpha-sorted for ease of visual lookup. */
11821 return reloc_type
== 2; /* R_386_PC32. */
11823 return reloc_type
== 4; /* R_68K_PC32. */
11825 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11826 case EM_ADAPTEVA_EPIPHANY
:
11827 return reloc_type
== 6;
11829 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11830 case EM_ARC_COMPACT
:
11831 case EM_ARC_COMPACT2
:
11832 return reloc_type
== 49; /* R_ARC_32_PCREL. */
11834 return reloc_type
== 3; /* R_ARM_REL32 */
11837 return reloc_type
== 36; /* R_AVR_32_PCREL. */
11838 case EM_MICROBLAZE
:
11839 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11841 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11843 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11845 return reloc_type
== 26; /* R_PPC_REL32. */
11847 return reloc_type
== 26; /* R_PPC64_REL32. */
11850 return reloc_type
== 5; /* R_390_PC32. */
11852 return reloc_type
== 2; /* R_SH_REL32. */
11853 case EM_SPARC32PLUS
:
11856 return reloc_type
== 6; /* R_SPARC_DISP32. */
11858 return reloc_type
== 13; /* R_SPU_REL32. */
11860 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11862 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11864 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11868 return reloc_type
== 2; /* R_X86_64_PC32. */
11869 case EM_XTENSA_OLD
:
11871 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11873 /* Do not abort or issue an error message here. Not all targets use
11874 pc-relative 32-bit relocs in their DWARF debug information and we
11875 have already tested for target coverage in is_32bit_abs_reloc. A
11876 more helpful warning message will be generated by apply_relocations
11877 anyway, so just return. */
11882 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11883 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11886 is_64bit_abs_reloc (unsigned int reloc_type
)
11888 switch (elf_header
.e_machine
)
11891 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11893 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11895 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11897 return reloc_type
== 80; /* R_PARISC_DIR64. */
11899 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11900 case EM_SPARC32PLUS
:
11903 return reloc_type
== 54; /* R_SPARC_UA64. */
11907 return reloc_type
== 1; /* R_X86_64_64. */
11910 return reloc_type
== 22; /* R_S390_64. */
11912 return reloc_type
== 1; /* R_TILEGX_64. */
11914 return reloc_type
== 18; /* R_MIPS_64. */
11920 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11921 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11924 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11926 switch (elf_header
.e_machine
)
11929 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11931 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11933 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11935 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11937 return reloc_type
== 44; /* R_PPC64_REL64. */
11938 case EM_SPARC32PLUS
:
11941 return reloc_type
== 46; /* R_SPARC_DISP64. */
11945 return reloc_type
== 24; /* R_X86_64_PC64. */
11948 return reloc_type
== 23; /* R_S390_PC64. */
11950 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11956 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11957 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11960 is_24bit_abs_reloc (unsigned int reloc_type
)
11962 switch (elf_header
.e_machine
)
11964 case EM_CYGNUS_MN10200
:
11966 return reloc_type
== 4; /* R_MN10200_24. */
11968 return reloc_type
== 5; /* R_FT32_20. */
11974 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11975 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11978 is_16bit_abs_reloc (unsigned int reloc_type
)
11980 /* Please keep this table alpha-sorted for ease of visual lookup. */
11981 switch (elf_header
.e_machine
)
11984 case EM_ARC_COMPACT
:
11985 case EM_ARC_COMPACT2
:
11986 return reloc_type
== 2; /* R_ARC_16. */
11987 case EM_ADAPTEVA_EPIPHANY
:
11988 return reloc_type
== 5;
11991 return reloc_type
== 4; /* R_AVR_16. */
11992 case EM_CYGNUS_D10V
:
11994 return reloc_type
== 3; /* R_D10V_16. */
11998 return reloc_type
== R_H8_DIR16
;
12001 return reloc_type
== 1; /* R_IP2K_16. */
12004 return reloc_type
== 1; /* R_M32C_16 */
12005 case EM_CYGNUS_MN10200
:
12007 return reloc_type
== 2; /* R_MN10200_16. */
12008 case EM_CYGNUS_MN10300
:
12010 return reloc_type
== 2; /* R_MN10300_16. */
12012 if (uses_msp430x_relocs ())
12013 return reloc_type
== 2; /* R_MSP430_ABS16. */
12014 case EM_MSP430_OLD
:
12015 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12017 return reloc_type
== 19; /* R_NDS32_RELA. */
12018 case EM_ALTERA_NIOS2
:
12019 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12021 return reloc_type
== 9; /* R_NIOS_16. */
12023 return reloc_type
== 2; /* R_OR1K_16. */
12025 return reloc_type
== 2; /* R_C6000_ABS16. */
12027 return reloc_type
== 2; /* R_VISIUM_16. */
12030 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12032 return reloc_type
== 3; /* R_XGATE_16. */
12038 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12039 relocation entries (possibly formerly used for SHT_GROUP sections). */
12042 is_none_reloc (unsigned int reloc_type
)
12044 switch (elf_header
.e_machine
)
12046 case EM_386
: /* R_386_NONE. */
12047 case EM_68K
: /* R_68K_NONE. */
12048 case EM_ADAPTEVA_EPIPHANY
:
12049 case EM_ALPHA
: /* R_ALPHA_NONE. */
12050 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12051 case EM_ARC
: /* R_ARC_NONE. */
12052 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12053 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12054 case EM_ARM
: /* R_ARM_NONE. */
12055 case EM_C166
: /* R_XC16X_NONE. */
12056 case EM_CRIS
: /* R_CRIS_NONE. */
12057 case EM_FT32
: /* R_FT32_NONE. */
12058 case EM_IA_64
: /* R_IA64_NONE. */
12059 case EM_K1OM
: /* R_X86_64_NONE. */
12060 case EM_L1OM
: /* R_X86_64_NONE. */
12061 case EM_M32R
: /* R_M32R_NONE. */
12062 case EM_MIPS
: /* R_MIPS_NONE. */
12063 case EM_MN10300
: /* R_MN10300_NONE. */
12064 case EM_MOXIE
: /* R_MOXIE_NONE. */
12065 case EM_NIOS32
: /* R_NIOS_NONE. */
12066 case EM_OR1K
: /* R_OR1K_NONE. */
12067 case EM_PARISC
: /* R_PARISC_NONE. */
12068 case EM_PPC64
: /* R_PPC64_NONE. */
12069 case EM_PPC
: /* R_PPC_NONE. */
12070 case EM_S390
: /* R_390_NONE. */
12072 case EM_SH
: /* R_SH_NONE. */
12073 case EM_SPARC32PLUS
:
12074 case EM_SPARC
: /* R_SPARC_NONE. */
12076 case EM_TILEGX
: /* R_TILEGX_NONE. */
12077 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12078 case EM_TI_C6000
:/* R_C6000_NONE. */
12079 case EM_X86_64
: /* R_X86_64_NONE. */
12081 return reloc_type
== 0;
12084 return reloc_type
== 0 || reloc_type
== 256;
12087 return (reloc_type
== 0 /* R_AVR_NONE. */
12088 || reloc_type
== 30 /* R_AVR_DIFF8. */
12089 || reloc_type
== 31 /* R_AVR_DIFF16. */
12090 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12092 return reloc_type
== 3; /* R_METAG_NONE. */
12094 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12095 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12096 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12097 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12098 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12099 case EM_XTENSA_OLD
:
12101 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12102 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12103 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12104 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12109 /* Returns TRUE if there is a relocation against
12110 section NAME at OFFSET bytes. */
12113 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12115 Elf_Internal_Rela
* relocs
;
12116 Elf_Internal_Rela
* rp
;
12118 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12121 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12123 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12124 if (rp
->r_offset
== offset
)
12130 /* Apply relocations to a section.
12131 Note: So far support has been added only for those relocations
12132 which can be found in debug sections.
12133 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
12134 loaded relocs. It is then the caller's responsibility to free them.
12135 FIXME: Add support for more relocations ? */
12138 apply_relocations (void * file
,
12139 const Elf_Internal_Shdr
* section
,
12140 unsigned char * start
,
12141 bfd_size_type size
,
12142 void ** relocs_return
,
12143 unsigned long * num_relocs_return
)
12145 Elf_Internal_Shdr
* relsec
;
12146 unsigned char * end
= start
+ size
;
12148 if (relocs_return
!= NULL
)
12150 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12151 * num_relocs_return
= 0;
12154 if (elf_header
.e_type
!= ET_REL
)
12157 /* Find the reloc section associated with the section. */
12158 for (relsec
= section_headers
;
12159 relsec
< section_headers
+ elf_header
.e_shnum
;
12162 bfd_boolean is_rela
;
12163 unsigned long num_relocs
;
12164 Elf_Internal_Rela
* relocs
;
12165 Elf_Internal_Rela
* rp
;
12166 Elf_Internal_Shdr
* symsec
;
12167 Elf_Internal_Sym
* symtab
;
12168 unsigned long num_syms
;
12169 Elf_Internal_Sym
* sym
;
12171 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12172 || relsec
->sh_info
>= elf_header
.e_shnum
12173 || section_headers
+ relsec
->sh_info
!= section
12174 || relsec
->sh_size
== 0
12175 || relsec
->sh_link
>= elf_header
.e_shnum
)
12178 is_rela
= relsec
->sh_type
== SHT_RELA
;
12182 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12183 relsec
->sh_size
, & relocs
, & num_relocs
))
12188 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12189 relsec
->sh_size
, & relocs
, & num_relocs
))
12193 /* SH uses RELA but uses in place value instead of the addend field. */
12194 if (elf_header
.e_machine
== EM_SH
)
12197 symsec
= section_headers
+ relsec
->sh_link
;
12198 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12200 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12203 unsigned int reloc_type
;
12204 unsigned int reloc_size
;
12205 unsigned char * rloc
;
12206 unsigned long sym_index
;
12208 reloc_type
= get_reloc_type (rp
->r_info
);
12210 if (target_specific_reloc_handling (rp
, start
, symtab
))
12212 else if (is_none_reloc (reloc_type
))
12214 else if (is_32bit_abs_reloc (reloc_type
)
12215 || is_32bit_pcrel_reloc (reloc_type
))
12217 else if (is_64bit_abs_reloc (reloc_type
)
12218 || is_64bit_pcrel_reloc (reloc_type
))
12220 else if (is_24bit_abs_reloc (reloc_type
))
12222 else if (is_16bit_abs_reloc (reloc_type
))
12226 static unsigned int prev_reloc
= 0;
12227 if (reloc_type
!= prev_reloc
)
12228 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12229 reloc_type
, printable_section_name (section
));
12230 prev_reloc
= reloc_type
;
12234 rloc
= start
+ rp
->r_offset
;
12235 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12237 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12238 (unsigned long) rp
->r_offset
,
12239 printable_section_name (section
));
12243 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12244 if (sym_index
>= num_syms
)
12246 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12247 sym_index
, printable_section_name (section
));
12250 sym
= symtab
+ sym_index
;
12252 /* If the reloc has a symbol associated with it,
12253 make sure that it is of an appropriate type.
12255 Relocations against symbols without type can happen.
12256 Gcc -feliminate-dwarf2-dups may generate symbols
12257 without type for debug info.
12259 Icc generates relocations against function symbols
12260 instead of local labels.
12262 Relocations against object symbols can happen, eg when
12263 referencing a global array. For an example of this see
12264 the _clz.o binary in libgcc.a. */
12266 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12267 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12269 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12270 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12271 (long int)(rp
- relocs
),
12272 printable_section_name (relsec
));
12278 addend
+= rp
->r_addend
;
12279 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12280 partial_inplace. */
12282 || (elf_header
.e_machine
== EM_XTENSA
12283 && reloc_type
== 1)
12284 || ((elf_header
.e_machine
== EM_PJ
12285 || elf_header
.e_machine
== EM_PJ_OLD
)
12286 && reloc_type
== 1)
12287 || ((elf_header
.e_machine
== EM_D30V
12288 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12289 && reloc_type
== 12))
12290 addend
+= byte_get (rloc
, reloc_size
);
12292 if (is_32bit_pcrel_reloc (reloc_type
)
12293 || is_64bit_pcrel_reloc (reloc_type
))
12295 /* On HPPA, all pc-relative relocations are biased by 8. */
12296 if (elf_header
.e_machine
== EM_PARISC
)
12298 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12302 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12309 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12310 * num_relocs_return
= num_relocs
;
12319 #ifdef SUPPORT_DISASSEMBLY
12321 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12323 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12325 /* FIXME: XXX -- to be done --- XXX */
12331 /* Reads in the contents of SECTION from FILE, returning a pointer
12332 to a malloc'ed buffer or NULL if something went wrong. */
12335 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12337 bfd_size_type num_bytes
;
12339 num_bytes
= section
->sh_size
;
12341 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12343 printf (_("\nSection '%s' has no data to dump.\n"),
12344 printable_section_name (section
));
12348 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12349 _("section contents"));
12352 /* Uncompresses a section that was compressed using zlib, in place. */
12355 uncompress_section_contents (unsigned char **buffer
,
12356 dwarf_size_type uncompressed_size
,
12357 dwarf_size_type
*size
)
12359 dwarf_size_type compressed_size
= *size
;
12360 unsigned char * compressed_buffer
= *buffer
;
12361 unsigned char * uncompressed_buffer
;
12365 /* It is possible the section consists of several compressed
12366 buffers concatenated together, so we uncompress in a loop. */
12367 /* PR 18313: The state field in the z_stream structure is supposed
12368 to be invisible to the user (ie us), but some compilers will
12369 still complain about it being used without initialisation. So
12370 we first zero the entire z_stream structure and then set the fields
12372 memset (& strm
, 0, sizeof strm
);
12373 strm
.avail_in
= compressed_size
;
12374 strm
.next_in
= (Bytef
*) compressed_buffer
;
12375 strm
.avail_out
= uncompressed_size
;
12376 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12378 rc
= inflateInit (& strm
);
12379 while (strm
.avail_in
> 0)
12383 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12384 + (uncompressed_size
- strm
.avail_out
));
12385 rc
= inflate (&strm
, Z_FINISH
);
12386 if (rc
!= Z_STREAM_END
)
12388 rc
= inflateReset (& strm
);
12390 rc
= inflateEnd (& strm
);
12392 || strm
.avail_out
!= 0)
12395 *buffer
= uncompressed_buffer
;
12396 *size
= uncompressed_size
;
12400 free (uncompressed_buffer
);
12401 /* Indicate decompression failure. */
12407 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12409 Elf_Internal_Shdr
* relsec
;
12410 bfd_size_type num_bytes
;
12411 unsigned char * data
;
12412 unsigned char * end
;
12413 unsigned char * real_start
;
12414 unsigned char * start
;
12415 bfd_boolean some_strings_shown
;
12417 real_start
= start
= (unsigned char *) get_section_contents (section
,
12421 num_bytes
= section
->sh_size
;
12423 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12425 if (decompress_dumps
)
12427 dwarf_size_type new_size
= num_bytes
;
12428 dwarf_size_type uncompressed_size
= 0;
12430 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12432 Elf_Internal_Chdr chdr
;
12433 unsigned int compression_header_size
12434 = get_compression_header (& chdr
, (unsigned char *) start
);
12436 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12438 warn (_("section '%s' has unsupported compress type: %d\n"),
12439 printable_section_name (section
), chdr
.ch_type
);
12442 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12444 warn (_("compressed section '%s' is corrupted\n"),
12445 printable_section_name (section
));
12448 uncompressed_size
= chdr
.ch_size
;
12449 start
+= compression_header_size
;
12450 new_size
-= compression_header_size
;
12452 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12454 /* Read the zlib header. In this case, it should be "ZLIB"
12455 followed by the uncompressed section size, 8 bytes in
12456 big-endian order. */
12457 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12458 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12459 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12460 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12461 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12462 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12463 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12464 uncompressed_size
+= start
[11];
12469 if (uncompressed_size
12470 && uncompress_section_contents (& start
,
12471 uncompressed_size
, & new_size
))
12472 num_bytes
= new_size
;
12475 /* If the section being dumped has relocations against it the user might
12476 be expecting these relocations to have been applied. Check for this
12477 case and issue a warning message in order to avoid confusion.
12478 FIXME: Maybe we ought to have an option that dumps a section with
12479 relocs applied ? */
12480 for (relsec
= section_headers
;
12481 relsec
< section_headers
+ elf_header
.e_shnum
;
12484 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12485 || relsec
->sh_info
>= elf_header
.e_shnum
12486 || section_headers
+ relsec
->sh_info
!= section
12487 || relsec
->sh_size
== 0
12488 || relsec
->sh_link
>= elf_header
.e_shnum
)
12491 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12496 end
= start
+ num_bytes
;
12497 some_strings_shown
= FALSE
;
12501 while (!ISPRINT (* data
))
12502 if (++ data
>= end
)
12507 size_t maxlen
= end
- data
;
12510 /* PR 11128: Use two separate invocations in order to work
12511 around bugs in the Solaris 8 implementation of printf. */
12512 printf (" [%6tx] ", data
- start
);
12514 printf (" [%6Ix] ", (size_t) (data
- start
));
12518 print_symbol ((int) maxlen
, (const char *) data
);
12520 data
+= strnlen ((const char *) data
, maxlen
);
12524 printf (_("<corrupt>\n"));
12527 some_strings_shown
= TRUE
;
12531 if (! some_strings_shown
)
12532 printf (_(" No strings found in this section."));
12540 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12542 bfd_boolean relocate
)
12544 Elf_Internal_Shdr
* relsec
;
12545 bfd_size_type bytes
;
12546 bfd_size_type section_size
;
12548 unsigned char * data
;
12549 unsigned char * real_start
;
12550 unsigned char * start
;
12552 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12555 section_size
= section
->sh_size
;
12557 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12559 if (decompress_dumps
)
12561 dwarf_size_type new_size
= section_size
;
12562 dwarf_size_type uncompressed_size
= 0;
12564 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12566 Elf_Internal_Chdr chdr
;
12567 unsigned int compression_header_size
12568 = get_compression_header (& chdr
, start
);
12570 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12572 warn (_("section '%s' has unsupported compress type: %d\n"),
12573 printable_section_name (section
), chdr
.ch_type
);
12576 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12578 warn (_("compressed section '%s' is corrupted\n"),
12579 printable_section_name (section
));
12582 uncompressed_size
= chdr
.ch_size
;
12583 start
+= compression_header_size
;
12584 new_size
-= compression_header_size
;
12586 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12588 /* Read the zlib header. In this case, it should be "ZLIB"
12589 followed by the uncompressed section size, 8 bytes in
12590 big-endian order. */
12591 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12592 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12593 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12594 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12595 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12596 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12597 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12598 uncompressed_size
+= start
[11];
12603 if (uncompressed_size
12604 && uncompress_section_contents (& start
, uncompressed_size
,
12606 section_size
= new_size
;
12611 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12615 /* If the section being dumped has relocations against it the user might
12616 be expecting these relocations to have been applied. Check for this
12617 case and issue a warning message in order to avoid confusion.
12618 FIXME: Maybe we ought to have an option that dumps a section with
12619 relocs applied ? */
12620 for (relsec
= section_headers
;
12621 relsec
< section_headers
+ elf_header
.e_shnum
;
12624 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12625 || relsec
->sh_info
>= elf_header
.e_shnum
12626 || section_headers
+ relsec
->sh_info
!= section
12627 || relsec
->sh_size
== 0
12628 || relsec
->sh_link
>= elf_header
.e_shnum
)
12631 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12636 addr
= section
->sh_addr
;
12637 bytes
= section_size
;
12646 lbytes
= (bytes
> 16 ? 16 : bytes
);
12648 printf (" 0x%8.8lx ", (unsigned long) addr
);
12650 for (j
= 0; j
< 16; j
++)
12653 printf ("%2.2x", data
[j
]);
12661 for (j
= 0; j
< lbytes
; j
++)
12664 if (k
>= ' ' && k
< 0x7f)
12683 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12684 const Elf_Internal_Shdr
* sec
, void * file
)
12686 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12689 /* If it is already loaded, do nothing. */
12690 if (section
->start
!= NULL
)
12693 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12694 section
->address
= sec
->sh_addr
;
12695 section
->user_data
= NULL
;
12696 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12698 sec
->sh_size
, buf
);
12699 if (section
->start
== NULL
)
12703 unsigned char *start
= section
->start
;
12704 dwarf_size_type size
= sec
->sh_size
;
12705 dwarf_size_type uncompressed_size
= 0;
12707 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12709 Elf_Internal_Chdr chdr
;
12710 unsigned int compression_header_size
;
12712 if (size
< (is_32bit_elf
12713 ? sizeof (Elf32_External_Chdr
)
12714 : sizeof (Elf64_External_Chdr
)))
12716 warn (_("compressed section %s is too small to contain a compression header"),
12721 compression_header_size
= get_compression_header (&chdr
, start
);
12723 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12725 warn (_("section '%s' has unsupported compress type: %d\n"),
12726 section
->name
, chdr
.ch_type
);
12729 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12731 warn (_("compressed section '%s' is corrupted\n"),
12735 uncompressed_size
= chdr
.ch_size
;
12736 start
+= compression_header_size
;
12737 size
-= compression_header_size
;
12739 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12741 /* Read the zlib header. In this case, it should be "ZLIB"
12742 followed by the uncompressed section size, 8 bytes in
12743 big-endian order. */
12744 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12745 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12746 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12747 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12748 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12749 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12750 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12751 uncompressed_size
+= start
[11];
12756 if (uncompressed_size
12757 && uncompress_section_contents (&start
, uncompressed_size
,
12760 /* Free the compressed buffer, update the section buffer
12761 and the section size if uncompress is successful. */
12762 free (section
->start
);
12763 section
->start
= start
;
12765 section
->size
= size
;
12768 if (section
->start
== NULL
)
12771 if (debug_displays
[debug
].relocate
)
12772 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12773 & section
->reloc_info
, & section
->num_relocs
);
12776 section
->reloc_info
= NULL
;
12777 section
->num_relocs
= 0;
12783 /* If this is not NULL, load_debug_section will only look for sections
12784 within the list of sections given here. */
12785 unsigned int *section_subset
= NULL
;
12788 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12790 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12791 Elf_Internal_Shdr
* sec
;
12793 /* Locate the debug section. */
12794 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12796 section
->name
= section
->uncompressed_name
;
12799 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12801 section
->name
= section
->compressed_name
;
12806 /* If we're loading from a subset of sections, and we've loaded
12807 a section matching this name before, it's likely that it's a
12809 if (section_subset
!= NULL
)
12810 free_debug_section (debug
);
12812 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12816 free_debug_section (enum dwarf_section_display_enum debug
)
12818 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12820 if (section
->start
== NULL
)
12823 free ((char *) section
->start
);
12824 section
->start
= NULL
;
12825 section
->address
= 0;
12830 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12832 char * name
= SECTION_NAME (section
);
12833 const char * print_name
= printable_section_name (section
);
12834 bfd_size_type length
;
12838 length
= section
->sh_size
;
12841 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12844 if (section
->sh_type
== SHT_NOBITS
)
12846 /* There is no point in dumping the contents of a debugging section
12847 which has the NOBITS type - the bits in the file will be random.
12848 This can happen when a file containing a .eh_frame section is
12849 stripped with the --only-keep-debug command line option. */
12850 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12855 if (const_strneq (name
, ".gnu.linkonce.wi."))
12856 name
= ".debug_info";
12858 /* See if we know how to display the contents of this section. */
12859 for (i
= 0; i
< max
; i
++)
12860 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12861 || (i
== line
&& const_strneq (name
, ".debug_line."))
12862 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12864 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12865 int secondary
= (section
!= find_section (name
));
12868 free_debug_section ((enum dwarf_section_display_enum
) i
);
12870 if (i
== line
&& const_strneq (name
, ".debug_line."))
12872 else if (streq (sec
->uncompressed_name
, name
))
12873 sec
->name
= sec
->uncompressed_name
;
12875 sec
->name
= sec
->compressed_name
;
12876 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12879 /* If this debug section is part of a CU/TU set in a .dwp file,
12880 restrict load_debug_section to the sections in that set. */
12881 section_subset
= find_cu_tu_set (file
, shndx
);
12883 result
&= debug_displays
[i
].display (sec
, file
);
12885 section_subset
= NULL
;
12887 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12888 free_debug_section ((enum dwarf_section_display_enum
) i
);
12896 printf (_("Unrecognized debug section: %s\n"), print_name
);
12903 /* Set DUMP_SECTS for all sections where dumps were requested
12904 based on section name. */
12907 initialise_dumps_byname (void)
12909 struct dump_list_entry
* cur
;
12911 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12916 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12917 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12919 request_dump_bynumber (i
, cur
->type
);
12924 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12930 process_section_contents (FILE * file
)
12932 Elf_Internal_Shdr
* section
;
12938 initialise_dumps_byname ();
12940 for (i
= 0, section
= section_headers
;
12941 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12944 #ifdef SUPPORT_DISASSEMBLY
12945 if (dump_sects
[i
] & DISASS_DUMP
)
12946 disassemble_section (section
, file
);
12948 if (dump_sects
[i
] & HEX_DUMP
)
12949 dump_section_as_bytes (section
, file
, FALSE
);
12951 if (dump_sects
[i
] & RELOC_DUMP
)
12952 dump_section_as_bytes (section
, file
, TRUE
);
12954 if (dump_sects
[i
] & STRING_DUMP
)
12955 dump_section_as_strings (section
, file
);
12957 if (dump_sects
[i
] & DEBUG_DUMP
)
12958 display_debug_section (i
, section
, file
);
12961 /* Check to see if the user requested a
12962 dump of a section that does not exist. */
12963 while (i
++ < num_dump_sects
)
12965 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12969 process_mips_fpe_exception (int mask
)
12974 if (mask
& OEX_FPU_INEX
)
12975 fputs ("INEX", stdout
), first
= 0;
12976 if (mask
& OEX_FPU_UFLO
)
12977 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12978 if (mask
& OEX_FPU_OFLO
)
12979 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12980 if (mask
& OEX_FPU_DIV0
)
12981 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12982 if (mask
& OEX_FPU_INVAL
)
12983 printf ("%sINVAL", first
? "" : "|");
12986 fputs ("0", stdout
);
12989 /* Display's the value of TAG at location P. If TAG is
12990 greater than 0 it is assumed to be an unknown tag, and
12991 a message is printed to this effect. Otherwise it is
12992 assumed that a message has already been printed.
12994 If the bottom bit of TAG is set it assumed to have a
12995 string value, otherwise it is assumed to have an integer
12998 Returns an updated P pointing to the first unread byte
12999 beyond the end of TAG's value.
13001 Reads at or beyond END will not be made. */
13003 static unsigned char *
13004 display_tag_value (int tag
,
13006 const unsigned char * const end
)
13011 printf (" Tag_unknown_%d: ", tag
);
13015 warn (_("<corrupt tag>\n"));
13019 /* PR 17531 file: 027-19978-0.004. */
13020 size_t maxlen
= (end
- p
) - 1;
13025 print_symbol ((int) maxlen
, (const char *) p
);
13026 p
+= strnlen ((char *) p
, maxlen
) + 1;
13030 printf (_("<corrupt string tag>"));
13031 p
= (unsigned char *) end
;
13039 val
= read_uleb128 (p
, &len
, end
);
13041 printf ("%ld (0x%lx)\n", val
, val
);
13048 /* ARM EABI attributes section. */
13053 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13055 const char ** table
;
13056 } arm_attr_public_tag
;
13058 static const char * arm_attr_tag_CPU_arch
[] =
13059 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13060 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13062 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13063 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13064 {"No", "Thumb-1", "Thumb-2", "Yes"};
13065 static const char * arm_attr_tag_FP_arch
[] =
13066 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13067 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13068 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13069 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13070 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13071 "NEON for ARMv8.1"};
13072 static const char * arm_attr_tag_PCS_config
[] =
13073 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13074 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13075 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13076 {"V6", "SB", "TLS", "Unused"};
13077 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13078 {"Absolute", "PC-relative", "SB-relative", "None"};
13079 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13080 {"Absolute", "PC-relative", "None"};
13081 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13082 {"None", "direct", "GOT-indirect"};
13083 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13084 {"None", "??? 1", "2", "??? 3", "4"};
13085 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13086 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13087 {"Unused", "Needed", "Sign only"};
13088 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13089 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13090 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13091 {"Unused", "Finite", "RTABI", "IEEE 754"};
13092 static const char * arm_attr_tag_ABI_enum_size
[] =
13093 {"Unused", "small", "int", "forced to int"};
13094 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13095 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13096 static const char * arm_attr_tag_ABI_VFP_args
[] =
13097 {"AAPCS", "VFP registers", "custom", "compatible"};
13098 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13099 {"AAPCS", "WMMX registers", "custom"};
13100 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13101 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13102 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13103 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13104 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13105 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13106 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13107 static const char * arm_attr_tag_FP_HP_extension
[] =
13108 {"Not Allowed", "Allowed"};
13109 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13110 {"None", "IEEE 754", "Alternative Format"};
13111 static const char * arm_attr_tag_DSP_extension
[] =
13112 {"Follow architecture", "Allowed"};
13113 static const char * arm_attr_tag_MPextension_use
[] =
13114 {"Not Allowed", "Allowed"};
13115 static const char * arm_attr_tag_DIV_use
[] =
13116 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13117 "Allowed in v7-A with integer division extension"};
13118 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13119 static const char * arm_attr_tag_Virtualization_use
[] =
13120 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13121 "TrustZone and Virtualization Extensions"};
13122 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13123 {"Not Allowed", "Allowed"};
13125 #define LOOKUP(id, name) \
13126 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13127 static arm_attr_public_tag arm_attr_public_tags
[] =
13129 {4, "CPU_raw_name", 1, NULL
},
13130 {5, "CPU_name", 1, NULL
},
13131 LOOKUP(6, CPU_arch
),
13132 {7, "CPU_arch_profile", 0, NULL
},
13133 LOOKUP(8, ARM_ISA_use
),
13134 LOOKUP(9, THUMB_ISA_use
),
13135 LOOKUP(10, FP_arch
),
13136 LOOKUP(11, WMMX_arch
),
13137 LOOKUP(12, Advanced_SIMD_arch
),
13138 LOOKUP(13, PCS_config
),
13139 LOOKUP(14, ABI_PCS_R9_use
),
13140 LOOKUP(15, ABI_PCS_RW_data
),
13141 LOOKUP(16, ABI_PCS_RO_data
),
13142 LOOKUP(17, ABI_PCS_GOT_use
),
13143 LOOKUP(18, ABI_PCS_wchar_t
),
13144 LOOKUP(19, ABI_FP_rounding
),
13145 LOOKUP(20, ABI_FP_denormal
),
13146 LOOKUP(21, ABI_FP_exceptions
),
13147 LOOKUP(22, ABI_FP_user_exceptions
),
13148 LOOKUP(23, ABI_FP_number_model
),
13149 {24, "ABI_align_needed", 0, NULL
},
13150 {25, "ABI_align_preserved", 0, NULL
},
13151 LOOKUP(26, ABI_enum_size
),
13152 LOOKUP(27, ABI_HardFP_use
),
13153 LOOKUP(28, ABI_VFP_args
),
13154 LOOKUP(29, ABI_WMMX_args
),
13155 LOOKUP(30, ABI_optimization_goals
),
13156 LOOKUP(31, ABI_FP_optimization_goals
),
13157 {32, "compatibility", 0, NULL
},
13158 LOOKUP(34, CPU_unaligned_access
),
13159 LOOKUP(36, FP_HP_extension
),
13160 LOOKUP(38, ABI_FP_16bit_format
),
13161 LOOKUP(42, MPextension_use
),
13162 LOOKUP(44, DIV_use
),
13163 LOOKUP(46, DSP_extension
),
13164 {64, "nodefaults", 0, NULL
},
13165 {65, "also_compatible_with", 0, NULL
},
13166 LOOKUP(66, T2EE_use
),
13167 {67, "conformance", 1, NULL
},
13168 LOOKUP(68, Virtualization_use
),
13169 LOOKUP(70, MPextension_use_legacy
)
13173 static unsigned char *
13174 display_arm_attribute (unsigned char * p
,
13175 const unsigned char * const end
)
13180 arm_attr_public_tag
* attr
;
13184 tag
= read_uleb128 (p
, &len
, end
);
13187 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13189 if (arm_attr_public_tags
[i
].tag
== tag
)
13191 attr
= &arm_attr_public_tags
[i
];
13198 printf (" Tag_%s: ", attr
->name
);
13199 switch (attr
->type
)
13204 case 7: /* Tag_CPU_arch_profile. */
13205 val
= read_uleb128 (p
, &len
, end
);
13209 case 0: printf (_("None\n")); break;
13210 case 'A': printf (_("Application\n")); break;
13211 case 'R': printf (_("Realtime\n")); break;
13212 case 'M': printf (_("Microcontroller\n")); break;
13213 case 'S': printf (_("Application or Realtime\n")); break;
13214 default: printf ("??? (%d)\n", val
); break;
13218 case 24: /* Tag_align_needed. */
13219 val
= read_uleb128 (p
, &len
, end
);
13223 case 0: printf (_("None\n")); break;
13224 case 1: printf (_("8-byte\n")); break;
13225 case 2: printf (_("4-byte\n")); break;
13226 case 3: printf ("??? 3\n"); break;
13229 printf (_("8-byte and up to %d-byte extended\n"),
13232 printf ("??? (%d)\n", val
);
13237 case 25: /* Tag_align_preserved. */
13238 val
= read_uleb128 (p
, &len
, end
);
13242 case 0: printf (_("None\n")); break;
13243 case 1: printf (_("8-byte, except leaf SP\n")); break;
13244 case 2: printf (_("8-byte\n")); break;
13245 case 3: printf ("??? 3\n"); break;
13248 printf (_("8-byte and up to %d-byte extended\n"),
13251 printf ("??? (%d)\n", val
);
13256 case 32: /* Tag_compatibility. */
13258 val
= read_uleb128 (p
, &len
, end
);
13260 printf (_("flag = %d, vendor = "), val
);
13263 size_t maxlen
= (end
- p
) - 1;
13265 print_symbol ((int) maxlen
, (const char *) p
);
13266 p
+= strnlen ((char *) p
, maxlen
) + 1;
13270 printf (_("<corrupt>"));
13271 p
= (unsigned char *) end
;
13277 case 64: /* Tag_nodefaults. */
13278 /* PR 17531: file: 001-505008-0.01. */
13281 printf (_("True\n"));
13284 case 65: /* Tag_also_compatible_with. */
13285 val
= read_uleb128 (p
, &len
, end
);
13287 if (val
== 6 /* Tag_CPU_arch. */)
13289 val
= read_uleb128 (p
, &len
, end
);
13291 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13292 printf ("??? (%d)\n", val
);
13294 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13298 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13303 printf (_("<unknown: %d>\n"), tag
);
13309 return display_tag_value (-1, p
, end
);
13311 return display_tag_value (0, p
, end
);
13314 assert (attr
->type
& 0x80);
13315 val
= read_uleb128 (p
, &len
, end
);
13317 type
= attr
->type
& 0x7f;
13319 printf ("??? (%d)\n", val
);
13321 printf ("%s\n", attr
->table
[val
]);
13326 return display_tag_value (tag
, p
, end
);
13329 static unsigned char *
13330 display_gnu_attribute (unsigned char * p
,
13331 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13332 const unsigned char * const end
)
13338 tag
= read_uleb128 (p
, &len
, end
);
13341 /* Tag_compatibility is the only generic GNU attribute defined at
13345 val
= read_uleb128 (p
, &len
, end
);
13348 printf (_("flag = %d, vendor = "), val
);
13351 printf (_("<corrupt>\n"));
13352 warn (_("corrupt vendor attribute\n"));
13358 size_t maxlen
= (end
- p
) - 1;
13360 print_symbol ((int) maxlen
, (const char *) p
);
13361 p
+= strnlen ((char *) p
, maxlen
) + 1;
13365 printf (_("<corrupt>"));
13366 p
= (unsigned char *) end
;
13373 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13374 return display_proc_gnu_attribute (p
, tag
, end
);
13376 return display_tag_value (tag
, p
, end
);
13379 static unsigned char *
13380 display_power_gnu_attribute (unsigned char * p
,
13382 const unsigned char * const end
)
13387 if (tag
== Tag_GNU_Power_ABI_FP
)
13389 val
= read_uleb128 (p
, &len
, end
);
13391 printf (" Tag_GNU_Power_ABI_FP: ");
13394 printf (_("<corrupt>\n"));
13399 printf ("(%#x), ", val
);
13404 printf (_("unspecified hard/soft float, "));
13407 printf (_("hard float, "));
13410 printf (_("soft float, "));
13413 printf (_("single-precision hard float, "));
13420 printf (_("unspecified long double\n"));
13423 printf (_("128-bit IBM long double\n"));
13426 printf (_("64-bit long double\n"));
13429 printf (_("128-bit IEEE long double\n"));
13435 if (tag
== Tag_GNU_Power_ABI_Vector
)
13437 val
= read_uleb128 (p
, &len
, end
);
13439 printf (" Tag_GNU_Power_ABI_Vector: ");
13442 printf (_("<corrupt>\n"));
13447 printf ("(%#x), ", val
);
13452 printf (_("unspecified\n"));
13455 printf (_("generic\n"));
13458 printf ("AltiVec\n");
13467 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13469 val
= read_uleb128 (p
, &len
, end
);
13471 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13474 printf (_("<corrupt>\n"));
13479 printf ("(%#x), ", val
);
13484 printf (_("unspecified\n"));
13487 printf ("r3/r4\n");
13490 printf (_("memory\n"));
13499 return display_tag_value (tag
& 1, p
, end
);
13502 static unsigned char *
13503 display_s390_gnu_attribute (unsigned char * p
,
13505 const unsigned char * const end
)
13510 if (tag
== Tag_GNU_S390_ABI_Vector
)
13512 val
= read_uleb128 (p
, &len
, end
);
13514 printf (" Tag_GNU_S390_ABI_Vector: ");
13519 printf (_("any\n"));
13522 printf (_("software\n"));
13525 printf (_("hardware\n"));
13528 printf ("??? (%d)\n", val
);
13534 return display_tag_value (tag
& 1, p
, end
);
13538 display_sparc_hwcaps (int mask
)
13544 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13545 fputs ("mul32", stdout
), first
= 0;
13546 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13547 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13548 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13549 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13550 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13551 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13552 if (mask
& ELF_SPARC_HWCAP_POPC
)
13553 printf ("%spopc", first
? "" : "|"), first
= 0;
13554 if (mask
& ELF_SPARC_HWCAP_VIS
)
13555 printf ("%svis", first
? "" : "|"), first
= 0;
13556 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13557 printf ("%svis2", first
? "" : "|"), first
= 0;
13558 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13559 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13560 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13561 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13562 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13563 printf ("%svis3", first
? "" : "|"), first
= 0;
13564 if (mask
& ELF_SPARC_HWCAP_HPC
)
13565 printf ("%shpc", first
? "" : "|"), first
= 0;
13566 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13567 printf ("%srandom", first
? "" : "|"), first
= 0;
13568 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13569 printf ("%strans", first
? "" : "|"), first
= 0;
13570 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13571 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13572 if (mask
& ELF_SPARC_HWCAP_IMA
)
13573 printf ("%sima", first
? "" : "|"), first
= 0;
13574 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13575 printf ("%scspare", first
? "" : "|"), first
= 0;
13578 fputc ('0', stdout
);
13579 fputc ('\n', stdout
);
13583 display_sparc_hwcaps2 (int mask
)
13589 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13590 fputs ("fjathplus", stdout
), first
= 0;
13591 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13592 printf ("%svis3b", first
? "" : "|"), first
= 0;
13593 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13594 printf ("%sadp", first
? "" : "|"), first
= 0;
13595 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13596 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13597 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13598 printf ("%smwait", first
? "" : "|"), first
= 0;
13599 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13600 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13601 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13602 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13603 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13604 printf ("%snsec", first
? "" : "|"), first
= 0;
13605 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13606 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13607 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13608 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13609 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13610 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13613 fputc ('0', stdout
);
13614 fputc ('\n', stdout
);
13617 static unsigned char *
13618 display_sparc_gnu_attribute (unsigned char * p
,
13620 const unsigned char * const end
)
13625 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13627 val
= read_uleb128 (p
, &len
, end
);
13629 printf (" Tag_GNU_Sparc_HWCAPS: ");
13630 display_sparc_hwcaps (val
);
13633 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13635 val
= read_uleb128 (p
, &len
, end
);
13637 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13638 display_sparc_hwcaps2 (val
);
13642 return display_tag_value (tag
, p
, end
);
13646 print_mips_fp_abi_value (int val
)
13650 case Val_GNU_MIPS_ABI_FP_ANY
:
13651 printf (_("Hard or soft float\n"));
13653 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13654 printf (_("Hard float (double precision)\n"));
13656 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13657 printf (_("Hard float (single precision)\n"));
13659 case Val_GNU_MIPS_ABI_FP_SOFT
:
13660 printf (_("Soft float\n"));
13662 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13663 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13665 case Val_GNU_MIPS_ABI_FP_XX
:
13666 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13668 case Val_GNU_MIPS_ABI_FP_64
:
13669 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13671 case Val_GNU_MIPS_ABI_FP_64A
:
13672 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13674 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13675 printf (_("NaN 2008 compatibility\n"));
13678 printf ("??? (%d)\n", val
);
13683 static unsigned char *
13684 display_mips_gnu_attribute (unsigned char * p
,
13686 const unsigned char * const end
)
13688 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13693 val
= read_uleb128 (p
, &len
, end
);
13695 printf (" Tag_GNU_MIPS_ABI_FP: ");
13697 print_mips_fp_abi_value (val
);
13702 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13707 val
= read_uleb128 (p
, &len
, end
);
13709 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13713 case Val_GNU_MIPS_ABI_MSA_ANY
:
13714 printf (_("Any MSA or not\n"));
13716 case Val_GNU_MIPS_ABI_MSA_128
:
13717 printf (_("128-bit MSA\n"));
13720 printf ("??? (%d)\n", val
);
13726 return display_tag_value (tag
& 1, p
, end
);
13729 static unsigned char *
13730 display_tic6x_attribute (unsigned char * p
,
13731 const unsigned char * const end
)
13737 tag
= read_uleb128 (p
, &len
, end
);
13743 val
= read_uleb128 (p
, &len
, end
);
13745 printf (" Tag_ISA: ");
13749 case C6XABI_Tag_ISA_none
:
13750 printf (_("None\n"));
13752 case C6XABI_Tag_ISA_C62X
:
13755 case C6XABI_Tag_ISA_C67X
:
13758 case C6XABI_Tag_ISA_C67XP
:
13759 printf ("C67x+\n");
13761 case C6XABI_Tag_ISA_C64X
:
13764 case C6XABI_Tag_ISA_C64XP
:
13765 printf ("C64x+\n");
13767 case C6XABI_Tag_ISA_C674X
:
13768 printf ("C674x\n");
13771 printf ("??? (%d)\n", val
);
13776 case Tag_ABI_wchar_t
:
13777 val
= read_uleb128 (p
, &len
, end
);
13779 printf (" Tag_ABI_wchar_t: ");
13783 printf (_("Not used\n"));
13786 printf (_("2 bytes\n"));
13789 printf (_("4 bytes\n"));
13792 printf ("??? (%d)\n", val
);
13797 case Tag_ABI_stack_align_needed
:
13798 val
= read_uleb128 (p
, &len
, end
);
13800 printf (" Tag_ABI_stack_align_needed: ");
13804 printf (_("8-byte\n"));
13807 printf (_("16-byte\n"));
13810 printf ("??? (%d)\n", val
);
13815 case Tag_ABI_stack_align_preserved
:
13816 val
= read_uleb128 (p
, &len
, end
);
13818 printf (" Tag_ABI_stack_align_preserved: ");
13822 printf (_("8-byte\n"));
13825 printf (_("16-byte\n"));
13828 printf ("??? (%d)\n", val
);
13834 val
= read_uleb128 (p
, &len
, end
);
13836 printf (" Tag_ABI_DSBT: ");
13840 printf (_("DSBT addressing not used\n"));
13843 printf (_("DSBT addressing used\n"));
13846 printf ("??? (%d)\n", val
);
13852 val
= read_uleb128 (p
, &len
, end
);
13854 printf (" Tag_ABI_PID: ");
13858 printf (_("Data addressing position-dependent\n"));
13861 printf (_("Data addressing position-independent, GOT near DP\n"));
13864 printf (_("Data addressing position-independent, GOT far from DP\n"));
13867 printf ("??? (%d)\n", val
);
13873 val
= read_uleb128 (p
, &len
, end
);
13875 printf (" Tag_ABI_PIC: ");
13879 printf (_("Code addressing position-dependent\n"));
13882 printf (_("Code addressing position-independent\n"));
13885 printf ("??? (%d)\n", val
);
13890 case Tag_ABI_array_object_alignment
:
13891 val
= read_uleb128 (p
, &len
, end
);
13893 printf (" Tag_ABI_array_object_alignment: ");
13897 printf (_("8-byte\n"));
13900 printf (_("4-byte\n"));
13903 printf (_("16-byte\n"));
13906 printf ("??? (%d)\n", val
);
13911 case Tag_ABI_array_object_align_expected
:
13912 val
= read_uleb128 (p
, &len
, end
);
13914 printf (" Tag_ABI_array_object_align_expected: ");
13918 printf (_("8-byte\n"));
13921 printf (_("4-byte\n"));
13924 printf (_("16-byte\n"));
13927 printf ("??? (%d)\n", val
);
13932 case Tag_ABI_compatibility
:
13934 val
= read_uleb128 (p
, &len
, end
);
13936 printf (" Tag_ABI_compatibility: ");
13937 printf (_("flag = %d, vendor = "), val
);
13940 size_t maxlen
= (end
- p
) - 1;
13942 print_symbol ((int) maxlen
, (const char *) p
);
13943 p
+= strnlen ((char *) p
, maxlen
) + 1;
13947 printf (_("<corrupt>"));
13948 p
= (unsigned char *) end
;
13954 case Tag_ABI_conformance
:
13956 printf (" Tag_ABI_conformance: \"");
13959 size_t maxlen
= (end
- p
) - 1;
13961 print_symbol ((int) maxlen
, (const char *) p
);
13962 p
+= strnlen ((char *) p
, maxlen
) + 1;
13966 printf (_("<corrupt>"));
13967 p
= (unsigned char *) end
;
13974 return display_tag_value (tag
, p
, end
);
13978 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13980 unsigned long addr
= 0;
13981 size_t bytes
= end
- p
;
13988 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13990 printf (" 0x%8.8lx ", addr
);
13992 for (j
= 0; j
< 16; j
++)
13995 printf ("%2.2x", p
[j
]);
14003 for (j
= 0; j
< lbytes
; j
++)
14006 if (k
>= ' ' && k
< 0x7f)
14022 static unsigned char *
14023 display_msp430x_attribute (unsigned char * p
,
14024 const unsigned char * const end
)
14030 tag
= read_uleb128 (p
, & len
, end
);
14035 case OFBA_MSPABI_Tag_ISA
:
14036 val
= read_uleb128 (p
, &len
, end
);
14038 printf (" Tag_ISA: ");
14041 case 0: printf (_("None\n")); break;
14042 case 1: printf (_("MSP430\n")); break;
14043 case 2: printf (_("MSP430X\n")); break;
14044 default: printf ("??? (%d)\n", val
); break;
14048 case OFBA_MSPABI_Tag_Code_Model
:
14049 val
= read_uleb128 (p
, &len
, end
);
14051 printf (" Tag_Code_Model: ");
14054 case 0: printf (_("None\n")); break;
14055 case 1: printf (_("Small\n")); break;
14056 case 2: printf (_("Large\n")); break;
14057 default: printf ("??? (%d)\n", val
); break;
14061 case OFBA_MSPABI_Tag_Data_Model
:
14062 val
= read_uleb128 (p
, &len
, end
);
14064 printf (" Tag_Data_Model: ");
14067 case 0: printf (_("None\n")); break;
14068 case 1: printf (_("Small\n")); break;
14069 case 2: printf (_("Large\n")); break;
14070 case 3: printf (_("Restricted Large\n")); break;
14071 default: printf ("??? (%d)\n", val
); break;
14076 printf (_(" <unknown tag %d>: "), tag
);
14083 size_t maxlen
= (end
- p
) - 1;
14085 print_symbol ((int) maxlen
, (const char *) p
);
14086 p
+= strnlen ((char *) p
, maxlen
) + 1;
14090 printf (_("<corrupt>"));
14091 p
= (unsigned char *) end
;
14097 val
= read_uleb128 (p
, &len
, end
);
14099 printf ("%d (0x%x)\n", val
, val
);
14109 process_attributes (FILE * file
,
14110 const char * public_name
,
14111 unsigned int proc_type
,
14112 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14113 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
14115 Elf_Internal_Shdr
* sect
;
14118 /* Find the section header so that we get the size. */
14119 for (i
= 0, sect
= section_headers
;
14120 i
< elf_header
.e_shnum
;
14123 unsigned char * contents
;
14126 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14129 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14130 sect
->sh_size
, _("attributes"));
14131 if (contents
== NULL
)
14137 bfd_vma section_len
;
14139 section_len
= sect
->sh_size
- 1;
14142 while (section_len
> 0)
14145 unsigned int namelen
;
14146 bfd_boolean public_section
;
14147 bfd_boolean gnu_section
;
14149 if (section_len
<= 4)
14151 error (_("Tag section ends prematurely\n"));
14154 attr_len
= byte_get (p
, 4);
14157 if (attr_len
> section_len
)
14159 error (_("Bad attribute length (%u > %u)\n"),
14160 (unsigned) attr_len
, (unsigned) section_len
);
14161 attr_len
= section_len
;
14163 /* PR 17531: file: 001-101425-0.004 */
14164 else if (attr_len
< 5)
14166 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14170 section_len
-= attr_len
;
14173 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14174 if (namelen
== 0 || namelen
>= attr_len
)
14176 error (_("Corrupt attribute section name\n"));
14180 printf (_("Attribute Section: "));
14181 print_symbol (INT_MAX
, (const char *) p
);
14184 if (public_name
&& streq ((char *) p
, public_name
))
14185 public_section
= TRUE
;
14187 public_section
= FALSE
;
14189 if (streq ((char *) p
, "gnu"))
14190 gnu_section
= TRUE
;
14192 gnu_section
= FALSE
;
14195 attr_len
-= namelen
;
14197 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14202 unsigned char * end
;
14204 /* PR binutils/17531: Safe handling of corrupt files. */
14207 error (_("Unused bytes at end of section\n"));
14213 size
= byte_get (p
, 4);
14214 if (size
> attr_len
)
14216 error (_("Bad subsection length (%u > %u)\n"),
14217 (unsigned) size
, (unsigned) attr_len
);
14220 /* PR binutils/17531: Safe handling of corrupt files. */
14223 error (_("Bad subsection length (%u < 6)\n"),
14230 end
= p
+ size
- 1;
14231 assert (end
<= contents
+ sect
->sh_size
);
14237 printf (_("File Attributes\n"));
14240 printf (_("Section Attributes:"));
14243 printf (_("Symbol Attributes:"));
14249 val
= read_uleb128 (p
, &j
, end
);
14253 printf (" %d", val
);
14258 printf (_("Unknown tag: %d\n"), tag
);
14259 public_section
= FALSE
;
14263 if (public_section
&& display_pub_attribute
!= NULL
)
14266 p
= display_pub_attribute (p
, end
);
14269 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14272 p
= display_gnu_attribute (p
,
14273 display_proc_gnu_attribute
,
14279 printf (_(" Unknown attribute:\n"));
14280 display_raw_attribute (p
, end
);
14289 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
14297 process_arm_specific (FILE * file
)
14299 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
14300 display_arm_attribute
, NULL
);
14304 process_power_specific (FILE * file
)
14306 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14307 display_power_gnu_attribute
);
14311 process_s390_specific (FILE * file
)
14313 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14314 display_s390_gnu_attribute
);
14318 process_sparc_specific (FILE * file
)
14320 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14321 display_sparc_gnu_attribute
);
14325 process_tic6x_specific (FILE * file
)
14327 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
14328 display_tic6x_attribute
, NULL
);
14332 process_msp430x_specific (FILE * file
)
14334 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
14335 display_msp430x_attribute
, NULL
);
14338 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14339 Print the Address, Access and Initial fields of an entry at VMA ADDR
14340 and return the VMA of the next entry, or -1 if there was a problem.
14341 Does not read from DATA_END or beyond. */
14344 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14345 unsigned char * data_end
)
14348 print_vma (addr
, LONG_HEX
);
14350 if (addr
< pltgot
+ 0xfff0)
14351 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14353 printf ("%10s", "");
14356 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14360 unsigned char * from
= data
+ addr
- pltgot
;
14362 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14364 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14365 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14366 return (bfd_vma
) -1;
14370 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14371 print_vma (entry
, LONG_HEX
);
14374 return addr
+ (is_32bit_elf
? 4 : 8);
14377 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14378 PLTGOT. Print the Address and Initial fields of an entry at VMA
14379 ADDR and return the VMA of the next entry. */
14382 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14385 print_vma (addr
, LONG_HEX
);
14388 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14393 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14394 print_vma (entry
, LONG_HEX
);
14396 return addr
+ (is_32bit_elf
? 4 : 8);
14400 print_mips_ases (unsigned int mask
)
14402 if (mask
& AFL_ASE_DSP
)
14403 fputs ("\n\tDSP ASE", stdout
);
14404 if (mask
& AFL_ASE_DSPR2
)
14405 fputs ("\n\tDSP R2 ASE", stdout
);
14406 if (mask
& AFL_ASE_DSPR3
)
14407 fputs ("\n\tDSP R3 ASE", stdout
);
14408 if (mask
& AFL_ASE_EVA
)
14409 fputs ("\n\tEnhanced VA Scheme", stdout
);
14410 if (mask
& AFL_ASE_MCU
)
14411 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14412 if (mask
& AFL_ASE_MDMX
)
14413 fputs ("\n\tMDMX ASE", stdout
);
14414 if (mask
& AFL_ASE_MIPS3D
)
14415 fputs ("\n\tMIPS-3D ASE", stdout
);
14416 if (mask
& AFL_ASE_MT
)
14417 fputs ("\n\tMT ASE", stdout
);
14418 if (mask
& AFL_ASE_SMARTMIPS
)
14419 fputs ("\n\tSmartMIPS ASE", stdout
);
14420 if (mask
& AFL_ASE_VIRT
)
14421 fputs ("\n\tVZ ASE", stdout
);
14422 if (mask
& AFL_ASE_MSA
)
14423 fputs ("\n\tMSA ASE", stdout
);
14424 if (mask
& AFL_ASE_MIPS16
)
14425 fputs ("\n\tMIPS16 ASE", stdout
);
14426 if (mask
& AFL_ASE_MICROMIPS
)
14427 fputs ("\n\tMICROMIPS ASE", stdout
);
14428 if (mask
& AFL_ASE_XPA
)
14429 fputs ("\n\tXPA ASE", stdout
);
14431 fprintf (stdout
, "\n\t%s", _("None"));
14432 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14433 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14437 print_mips_isa_ext (unsigned int isa_ext
)
14442 fputs (_("None"), stdout
);
14445 fputs ("RMI XLR", stdout
);
14447 case AFL_EXT_OCTEON3
:
14448 fputs ("Cavium Networks Octeon3", stdout
);
14450 case AFL_EXT_OCTEON2
:
14451 fputs ("Cavium Networks Octeon2", stdout
);
14453 case AFL_EXT_OCTEONP
:
14454 fputs ("Cavium Networks OcteonP", stdout
);
14456 case AFL_EXT_LOONGSON_3A
:
14457 fputs ("Loongson 3A", stdout
);
14459 case AFL_EXT_OCTEON
:
14460 fputs ("Cavium Networks Octeon", stdout
);
14463 fputs ("Toshiba R5900", stdout
);
14466 fputs ("MIPS R4650", stdout
);
14469 fputs ("LSI R4010", stdout
);
14472 fputs ("NEC VR4100", stdout
);
14475 fputs ("Toshiba R3900", stdout
);
14477 case AFL_EXT_10000
:
14478 fputs ("MIPS R10000", stdout
);
14481 fputs ("Broadcom SB-1", stdout
);
14484 fputs ("NEC VR4111/VR4181", stdout
);
14487 fputs ("NEC VR4120", stdout
);
14490 fputs ("NEC VR5400", stdout
);
14493 fputs ("NEC VR5500", stdout
);
14495 case AFL_EXT_LOONGSON_2E
:
14496 fputs ("ST Microelectronics Loongson 2E", stdout
);
14498 case AFL_EXT_LOONGSON_2F
:
14499 fputs ("ST Microelectronics Loongson 2F", stdout
);
14502 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14507 get_mips_reg_size (int reg_size
)
14509 return (reg_size
== AFL_REG_NONE
) ? 0
14510 : (reg_size
== AFL_REG_32
) ? 32
14511 : (reg_size
== AFL_REG_64
) ? 64
14512 : (reg_size
== AFL_REG_128
) ? 128
14517 process_mips_specific (FILE * file
)
14519 Elf_Internal_Dyn
* entry
;
14520 Elf_Internal_Shdr
*sect
= NULL
;
14521 size_t liblist_offset
= 0;
14522 size_t liblistno
= 0;
14523 size_t conflictsno
= 0;
14524 size_t options_offset
= 0;
14525 size_t conflicts_offset
= 0;
14526 size_t pltrelsz
= 0;
14528 bfd_vma pltgot
= 0;
14529 bfd_vma mips_pltgot
= 0;
14530 bfd_vma jmprel
= 0;
14531 bfd_vma local_gotno
= 0;
14532 bfd_vma gotsym
= 0;
14533 bfd_vma symtabno
= 0;
14535 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14536 display_mips_gnu_attribute
);
14538 sect
= find_section (".MIPS.abiflags");
14542 Elf_External_ABIFlags_v0
*abiflags_ext
;
14543 Elf_Internal_ABIFlags_v0 abiflags_in
;
14545 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14546 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14549 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14550 sect
->sh_size
, _("MIPS ABI Flags section"));
14553 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14554 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14555 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14556 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14557 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14558 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14559 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14560 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14561 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14562 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14563 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14565 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14566 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14567 if (abiflags_in
.isa_rev
> 1)
14568 printf ("r%d", abiflags_in
.isa_rev
);
14569 printf ("\nGPR size: %d",
14570 get_mips_reg_size (abiflags_in
.gpr_size
));
14571 printf ("\nCPR1 size: %d",
14572 get_mips_reg_size (abiflags_in
.cpr1_size
));
14573 printf ("\nCPR2 size: %d",
14574 get_mips_reg_size (abiflags_in
.cpr2_size
));
14575 fputs ("\nFP ABI: ", stdout
);
14576 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14577 fputs ("ISA Extension: ", stdout
);
14578 print_mips_isa_ext (abiflags_in
.isa_ext
);
14579 fputs ("\nASEs:", stdout
);
14580 print_mips_ases (abiflags_in
.ases
);
14581 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14582 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14583 fputc ('\n', stdout
);
14584 free (abiflags_ext
);
14589 /* We have a lot of special sections. Thanks SGI! */
14590 if (dynamic_section
== NULL
)
14591 /* No information available. */
14594 for (entry
= dynamic_section
;
14595 /* PR 17531 file: 012-50589-0.004. */
14596 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14598 switch (entry
->d_tag
)
14600 case DT_MIPS_LIBLIST
:
14602 = offset_from_vma (file
, entry
->d_un
.d_val
,
14603 liblistno
* sizeof (Elf32_External_Lib
));
14605 case DT_MIPS_LIBLISTNO
:
14606 liblistno
= entry
->d_un
.d_val
;
14608 case DT_MIPS_OPTIONS
:
14609 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14611 case DT_MIPS_CONFLICT
:
14613 = offset_from_vma (file
, entry
->d_un
.d_val
,
14614 conflictsno
* sizeof (Elf32_External_Conflict
));
14616 case DT_MIPS_CONFLICTNO
:
14617 conflictsno
= entry
->d_un
.d_val
;
14620 pltgot
= entry
->d_un
.d_ptr
;
14622 case DT_MIPS_LOCAL_GOTNO
:
14623 local_gotno
= entry
->d_un
.d_val
;
14625 case DT_MIPS_GOTSYM
:
14626 gotsym
= entry
->d_un
.d_val
;
14628 case DT_MIPS_SYMTABNO
:
14629 symtabno
= entry
->d_un
.d_val
;
14631 case DT_MIPS_PLTGOT
:
14632 mips_pltgot
= entry
->d_un
.d_ptr
;
14635 pltrel
= entry
->d_un
.d_val
;
14638 pltrelsz
= entry
->d_un
.d_val
;
14641 jmprel
= entry
->d_un
.d_ptr
;
14647 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14649 Elf32_External_Lib
* elib
;
14652 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14654 sizeof (Elf32_External_Lib
),
14655 _("liblist section data"));
14658 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14659 (unsigned long) liblistno
);
14660 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14663 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14670 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14671 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14672 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14673 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14674 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14676 tmp
= gmtime (&atime
);
14677 snprintf (timebuf
, sizeof (timebuf
),
14678 "%04u-%02u-%02uT%02u:%02u:%02u",
14679 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14680 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14682 printf ("%3lu: ", (unsigned long) cnt
);
14683 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14684 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14686 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14687 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14688 liblist
.l_version
);
14690 if (liblist
.l_flags
== 0)
14694 static const struct
14701 { " EXACT_MATCH", LL_EXACT_MATCH
},
14702 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14703 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14704 { " EXPORTS", LL_EXPORTS
},
14705 { " DELAY_LOAD", LL_DELAY_LOAD
},
14706 { " DELTA", LL_DELTA
}
14708 int flags
= liblist
.l_flags
;
14711 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14712 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14714 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14715 flags
^= l_flags_vals
[fcnt
].bit
;
14718 printf (" %#x", (unsigned int) flags
);
14728 if (options_offset
!= 0)
14730 Elf_External_Options
* eopt
;
14731 Elf_Internal_Options
* iopt
;
14732 Elf_Internal_Options
* option
;
14735 sect
= section_headers
;
14737 /* Find the section header so that we get the size. */
14738 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14739 /* PR 17533 file: 012-277276-0.004. */
14742 error (_("No MIPS_OPTIONS header found\n"));
14746 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14747 sect
->sh_size
, _("options"));
14750 iopt
= (Elf_Internal_Options
*)
14751 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14754 error (_("Out of memory allocating space for MIPS options\n"));
14761 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14763 Elf_External_Options
* eoption
;
14765 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14767 option
->kind
= BYTE_GET (eoption
->kind
);
14768 option
->size
= BYTE_GET (eoption
->size
);
14769 option
->section
= BYTE_GET (eoption
->section
);
14770 option
->info
= BYTE_GET (eoption
->info
);
14772 /* PR 17531: file: ffa0fa3b. */
14773 if (option
->size
< sizeof (* eopt
)
14774 || offset
+ option
->size
> sect
->sh_size
)
14776 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14779 offset
+= option
->size
;
14785 printf (_("\nSection '%s' contains %d entries:\n"),
14786 printable_section_name (sect
), cnt
);
14795 switch (option
->kind
)
14798 /* This shouldn't happen. */
14799 printf (" NULL %d %lx", option
->section
, option
->info
);
14802 printf (" REGINFO ");
14803 if (elf_header
.e_machine
== EM_MIPS
)
14806 Elf32_External_RegInfo
* ereg
;
14807 Elf32_RegInfo reginfo
;
14809 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14810 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14811 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14812 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14813 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14814 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14815 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14817 printf ("GPR %08lx GP 0x%lx\n",
14818 reginfo
.ri_gprmask
,
14819 (unsigned long) reginfo
.ri_gp_value
);
14820 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14821 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14822 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14827 Elf64_External_RegInfo
* ereg
;
14828 Elf64_Internal_RegInfo reginfo
;
14830 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14831 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14832 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14833 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14834 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14835 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14836 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14838 printf ("GPR %08lx GP 0x",
14839 reginfo
.ri_gprmask
);
14840 printf_vma (reginfo
.ri_gp_value
);
14843 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14844 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14845 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14849 case ODK_EXCEPTIONS
:
14850 fputs (" EXCEPTIONS fpe_min(", stdout
);
14851 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14852 fputs (") fpe_max(", stdout
);
14853 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14854 fputs (")", stdout
);
14856 if (option
->info
& OEX_PAGE0
)
14857 fputs (" PAGE0", stdout
);
14858 if (option
->info
& OEX_SMM
)
14859 fputs (" SMM", stdout
);
14860 if (option
->info
& OEX_FPDBUG
)
14861 fputs (" FPDBUG", stdout
);
14862 if (option
->info
& OEX_DISMISS
)
14863 fputs (" DISMISS", stdout
);
14866 fputs (" PAD ", stdout
);
14867 if (option
->info
& OPAD_PREFIX
)
14868 fputs (" PREFIX", stdout
);
14869 if (option
->info
& OPAD_POSTFIX
)
14870 fputs (" POSTFIX", stdout
);
14871 if (option
->info
& OPAD_SYMBOL
)
14872 fputs (" SYMBOL", stdout
);
14875 fputs (" HWPATCH ", stdout
);
14876 if (option
->info
& OHW_R4KEOP
)
14877 fputs (" R4KEOP", stdout
);
14878 if (option
->info
& OHW_R8KPFETCH
)
14879 fputs (" R8KPFETCH", stdout
);
14880 if (option
->info
& OHW_R5KEOP
)
14881 fputs (" R5KEOP", stdout
);
14882 if (option
->info
& OHW_R5KCVTL
)
14883 fputs (" R5KCVTL", stdout
);
14886 fputs (" FILL ", stdout
);
14887 /* XXX Print content of info word? */
14890 fputs (" TAGS ", stdout
);
14891 /* XXX Print content of info word? */
14894 fputs (" HWAND ", stdout
);
14895 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14896 fputs (" R4KEOP_CHECKED", stdout
);
14897 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14898 fputs (" R4KEOP_CLEAN", stdout
);
14901 fputs (" HWOR ", stdout
);
14902 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14903 fputs (" R4KEOP_CHECKED", stdout
);
14904 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14905 fputs (" R4KEOP_CLEAN", stdout
);
14908 printf (" GP_GROUP %#06lx self-contained %#06lx",
14909 option
->info
& OGP_GROUP
,
14910 (option
->info
& OGP_SELF
) >> 16);
14913 printf (" IDENT %#06lx self-contained %#06lx",
14914 option
->info
& OGP_GROUP
,
14915 (option
->info
& OGP_SELF
) >> 16);
14918 /* This shouldn't happen. */
14919 printf (" %3d ??? %d %lx",
14920 option
->kind
, option
->section
, option
->info
);
14924 len
= sizeof (* eopt
);
14925 while (len
< option
->size
)
14927 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14929 if (ISPRINT (datum
))
14930 printf ("%c", datum
);
14932 printf ("\\%03o", datum
);
14935 fputs ("\n", stdout
);
14937 offset
+= option
->size
;
14945 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14947 Elf32_Conflict
* iconf
;
14950 if (dynamic_symbols
== NULL
)
14952 error (_("conflict list found without a dynamic symbol table\n"));
14956 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14959 error (_("Out of memory allocating space for dynamic conflicts\n"));
14965 Elf32_External_Conflict
* econf32
;
14967 econf32
= (Elf32_External_Conflict
*)
14968 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14969 sizeof (* econf32
), _("conflict"));
14973 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14974 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14980 Elf64_External_Conflict
* econf64
;
14982 econf64
= (Elf64_External_Conflict
*)
14983 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14984 sizeof (* econf64
), _("conflict"));
14988 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14989 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14994 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14995 (unsigned long) conflictsno
);
14996 puts (_(" Num: Index Value Name"));
14998 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15000 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15002 if (iconf
[cnt
] >= num_dynamic_syms
)
15003 printf (_("<corrupt symbol index>"));
15006 Elf_Internal_Sym
* psym
;
15008 psym
= & dynamic_symbols
[iconf
[cnt
]];
15009 print_vma (psym
->st_value
, FULL_HEX
);
15011 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15012 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15014 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15022 if (pltgot
!= 0 && local_gotno
!= 0)
15024 bfd_vma ent
, local_end
, global_end
;
15026 unsigned char * data
;
15027 unsigned char * data_end
;
15031 addr_size
= (is_32bit_elf
? 4 : 8);
15032 local_end
= pltgot
+ local_gotno
* addr_size
;
15034 /* PR binutils/17533 file: 012-111227-0.004 */
15035 if (symtabno
< gotsym
)
15037 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15038 (unsigned long) gotsym
, (unsigned long) symtabno
);
15042 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15043 /* PR 17531: file: 54c91a34. */
15044 if (global_end
< local_end
)
15046 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15050 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15051 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15052 global_end
- pltgot
, 1,
15053 _("Global Offset Table data"));
15056 data_end
= data
+ (global_end
- pltgot
);
15058 printf (_("\nPrimary GOT:\n"));
15059 printf (_(" Canonical gp value: "));
15060 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15063 printf (_(" Reserved entries:\n"));
15064 printf (_(" %*s %10s %*s Purpose\n"),
15065 addr_size
* 2, _("Address"), _("Access"),
15066 addr_size
* 2, _("Initial"));
15067 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15068 printf (_(" Lazy resolver\n"));
15069 if (ent
== (bfd_vma
) -1)
15070 goto got_print_fail
;
15072 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15073 >> (addr_size
* 8 - 1)) != 0)
15075 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15076 printf (_(" Module pointer (GNU extension)\n"));
15077 if (ent
== (bfd_vma
) -1)
15078 goto got_print_fail
;
15082 if (ent
< local_end
)
15084 printf (_(" Local entries:\n"));
15085 printf (" %*s %10s %*s\n",
15086 addr_size
* 2, _("Address"), _("Access"),
15087 addr_size
* 2, _("Initial"));
15088 while (ent
< local_end
)
15090 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15092 if (ent
== (bfd_vma
) -1)
15093 goto got_print_fail
;
15098 if (gotsym
< symtabno
)
15102 printf (_(" Global entries:\n"));
15103 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15104 addr_size
* 2, _("Address"),
15106 addr_size
* 2, _("Initial"),
15107 addr_size
* 2, _("Sym.Val."),
15109 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15110 _("Ndx"), _("Name"));
15112 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15114 for (i
= gotsym
; i
< symtabno
; i
++)
15116 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15119 if (dynamic_symbols
== NULL
)
15120 printf (_("<no dynamic symbols>"));
15121 else if (i
< num_dynamic_syms
)
15123 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15125 print_vma (psym
->st_value
, LONG_HEX
);
15126 printf (" %-7s %3s ",
15127 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15128 get_symbol_index_type (psym
->st_shndx
));
15130 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15131 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15133 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15136 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15137 (unsigned long) i
);
15140 if (ent
== (bfd_vma
) -1)
15151 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15154 size_t offset
, rel_offset
;
15155 unsigned long count
, i
;
15156 unsigned char * data
;
15157 int addr_size
, sym_width
;
15158 Elf_Internal_Rela
* rels
;
15160 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15161 if (pltrel
== DT_RELA
)
15163 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15168 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15173 addr_size
= (is_32bit_elf
? 4 : 8);
15174 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15176 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15177 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15178 1, _("Procedure Linkage Table data"));
15182 printf ("\nPLT GOT:\n\n");
15183 printf (_(" Reserved entries:\n"));
15184 printf (_(" %*s %*s Purpose\n"),
15185 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15186 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15187 printf (_(" PLT lazy resolver\n"));
15188 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15189 printf (_(" Module pointer\n"));
15192 printf (_(" Entries:\n"));
15193 printf (" %*s %*s %*s %-7s %3s %s\n",
15194 addr_size
* 2, _("Address"),
15195 addr_size
* 2, _("Initial"),
15196 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15197 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15198 for (i
= 0; i
< count
; i
++)
15200 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15202 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15205 if (idx
>= num_dynamic_syms
)
15206 printf (_("<corrupt symbol index: %lu>"), idx
);
15209 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15211 print_vma (psym
->st_value
, LONG_HEX
);
15212 printf (" %-7s %3s ",
15213 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15214 get_symbol_index_type (psym
->st_shndx
));
15215 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15216 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15218 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15233 process_nds32_specific (FILE * file
)
15235 Elf_Internal_Shdr
*sect
= NULL
;
15237 sect
= find_section (".nds32_e_flags");
15240 unsigned int *flag
;
15242 printf ("\nNDS32 elf flags section:\n");
15243 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15244 sect
->sh_size
, _("NDS32 elf flags section"));
15246 switch ((*flag
) & 0x3)
15249 printf ("(VEC_SIZE):\tNo entry.\n");
15252 printf ("(VEC_SIZE):\t4 bytes\n");
15255 printf ("(VEC_SIZE):\t16 bytes\n");
15258 printf ("(VEC_SIZE):\treserved\n");
15267 process_gnu_liblist (FILE * file
)
15269 Elf_Internal_Shdr
* section
;
15270 Elf_Internal_Shdr
* string_sec
;
15271 Elf32_External_Lib
* elib
;
15273 size_t strtab_size
;
15280 for (i
= 0, section
= section_headers
;
15281 i
< elf_header
.e_shnum
;
15284 switch (section
->sh_type
)
15286 case SHT_GNU_LIBLIST
:
15287 if (section
->sh_link
>= elf_header
.e_shnum
)
15290 elib
= (Elf32_External_Lib
*)
15291 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
15292 _("liblist section data"));
15296 string_sec
= section_headers
+ section
->sh_link
;
15298 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
15299 string_sec
->sh_size
,
15300 _("liblist string table"));
15302 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
15308 strtab_size
= string_sec
->sh_size
;
15310 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15311 printable_section_name (section
),
15312 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
15314 puts (_(" Library Time Stamp Checksum Version Flags"));
15316 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
15324 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15325 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15326 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15327 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15328 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15330 tmp
= gmtime (&atime
);
15331 snprintf (timebuf
, sizeof (timebuf
),
15332 "%04u-%02u-%02uT%02u:%02u:%02u",
15333 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15334 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15336 printf ("%3lu: ", (unsigned long) cnt
);
15338 printf ("%-20s", liblist
.l_name
< strtab_size
15339 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15341 printf ("%-20.20s", liblist
.l_name
< strtab_size
15342 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15343 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15344 liblist
.l_version
, liblist
.l_flags
);
15355 static const char *
15356 get_note_type (unsigned e_type
)
15358 static char buff
[64];
15360 if (elf_header
.e_type
== ET_CORE
)
15364 return _("NT_AUXV (auxiliary vector)");
15366 return _("NT_PRSTATUS (prstatus structure)");
15368 return _("NT_FPREGSET (floating point registers)");
15370 return _("NT_PRPSINFO (prpsinfo structure)");
15371 case NT_TASKSTRUCT
:
15372 return _("NT_TASKSTRUCT (task structure)");
15374 return _("NT_PRXFPREG (user_xfpregs structure)");
15376 return _("NT_PPC_VMX (ppc Altivec registers)");
15378 return _("NT_PPC_VSX (ppc VSX registers)");
15380 return _("NT_386_TLS (x86 TLS information)");
15381 case NT_386_IOPERM
:
15382 return _("NT_386_IOPERM (x86 I/O permissions)");
15383 case NT_X86_XSTATE
:
15384 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15385 case NT_S390_HIGH_GPRS
:
15386 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15387 case NT_S390_TIMER
:
15388 return _("NT_S390_TIMER (s390 timer register)");
15389 case NT_S390_TODCMP
:
15390 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15391 case NT_S390_TODPREG
:
15392 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15394 return _("NT_S390_CTRS (s390 control registers)");
15395 case NT_S390_PREFIX
:
15396 return _("NT_S390_PREFIX (s390 prefix register)");
15397 case NT_S390_LAST_BREAK
:
15398 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15399 case NT_S390_SYSTEM_CALL
:
15400 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15402 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15403 case NT_S390_VXRS_LOW
:
15404 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15405 case NT_S390_VXRS_HIGH
:
15406 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15408 return _("NT_ARM_VFP (arm VFP registers)");
15410 return _("NT_ARM_TLS (AArch TLS registers)");
15411 case NT_ARM_HW_BREAK
:
15412 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15413 case NT_ARM_HW_WATCH
:
15414 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15416 return _("NT_PSTATUS (pstatus structure)");
15418 return _("NT_FPREGS (floating point registers)");
15420 return _("NT_PSINFO (psinfo structure)");
15422 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15424 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15425 case NT_WIN32PSTATUS
:
15426 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15428 return _("NT_SIGINFO (siginfo_t data)");
15430 return _("NT_FILE (mapped files)");
15438 return _("NT_VERSION (version)");
15440 return _("NT_ARCH (architecture)");
15445 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15450 print_core_note (Elf_Internal_Note
*pnote
)
15452 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15453 bfd_vma count
, page_size
;
15454 unsigned char *descdata
, *filenames
, *descend
;
15456 if (pnote
->type
!= NT_FILE
)
15462 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15463 /* Still "successful". */
15468 if (pnote
->descsz
< 2 * addr_size
)
15470 printf (_(" Malformed note - too short for header\n"));
15474 descdata
= (unsigned char *) pnote
->descdata
;
15475 descend
= descdata
+ pnote
->descsz
;
15477 if (descdata
[pnote
->descsz
- 1] != '\0')
15479 printf (_(" Malformed note - does not end with \\0\n"));
15483 count
= byte_get (descdata
, addr_size
);
15484 descdata
+= addr_size
;
15486 page_size
= byte_get (descdata
, addr_size
);
15487 descdata
+= addr_size
;
15489 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15491 printf (_(" Malformed note - too short for supplied file count\n"));
15495 printf (_(" Page size: "));
15496 print_vma (page_size
, DEC
);
15499 printf (_(" %*s%*s%*s\n"),
15500 (int) (2 + 2 * addr_size
), _("Start"),
15501 (int) (4 + 2 * addr_size
), _("End"),
15502 (int) (4 + 2 * addr_size
), _("Page Offset"));
15503 filenames
= descdata
+ count
* 3 * addr_size
;
15504 while (count
-- > 0)
15506 bfd_vma start
, end
, file_ofs
;
15508 if (filenames
== descend
)
15510 printf (_(" Malformed note - filenames end too early\n"));
15514 start
= byte_get (descdata
, addr_size
);
15515 descdata
+= addr_size
;
15516 end
= byte_get (descdata
, addr_size
);
15517 descdata
+= addr_size
;
15518 file_ofs
= byte_get (descdata
, addr_size
);
15519 descdata
+= addr_size
;
15522 print_vma (start
, FULL_HEX
);
15524 print_vma (end
, FULL_HEX
);
15526 print_vma (file_ofs
, FULL_HEX
);
15527 printf ("\n %s\n", filenames
);
15529 filenames
+= 1 + strlen ((char *) filenames
);
15535 static const char *
15536 get_gnu_elf_note_type (unsigned e_type
)
15538 static char buff
[64];
15542 case NT_GNU_ABI_TAG
:
15543 return _("NT_GNU_ABI_TAG (ABI version tag)");
15545 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15546 case NT_GNU_BUILD_ID
:
15547 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15548 case NT_GNU_GOLD_VERSION
:
15549 return _("NT_GNU_GOLD_VERSION (gold version)");
15554 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15559 print_gnu_note (Elf_Internal_Note
*pnote
)
15561 switch (pnote
->type
)
15563 case NT_GNU_BUILD_ID
:
15567 printf (_(" Build ID: "));
15568 for (i
= 0; i
< pnote
->descsz
; ++i
)
15569 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15574 case NT_GNU_ABI_TAG
:
15576 unsigned long os
, major
, minor
, subminor
;
15577 const char *osname
;
15579 /* PR 17531: file: 030-599401-0.004. */
15580 if (pnote
->descsz
< 16)
15582 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15586 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15587 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15588 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15589 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15593 case GNU_ABI_TAG_LINUX
:
15596 case GNU_ABI_TAG_HURD
:
15599 case GNU_ABI_TAG_SOLARIS
:
15600 osname
= "Solaris";
15602 case GNU_ABI_TAG_FREEBSD
:
15603 osname
= "FreeBSD";
15605 case GNU_ABI_TAG_NETBSD
:
15608 case GNU_ABI_TAG_SYLLABLE
:
15609 osname
= "Syllable";
15611 case GNU_ABI_TAG_NACL
:
15615 osname
= "Unknown";
15619 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15620 major
, minor
, subminor
);
15624 case NT_GNU_GOLD_VERSION
:
15628 printf (_(" Version: "));
15629 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15630 printf ("%c", pnote
->descdata
[i
]);
15639 static const char *
15640 get_v850_elf_note_type (enum v850_notes n_type
)
15642 static char buff
[64];
15646 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15647 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15648 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15649 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15650 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15651 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15653 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15659 print_v850_note (Elf_Internal_Note
* pnote
)
15663 if (pnote
->descsz
!= 4)
15665 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15669 printf (_("not set\n"));
15673 switch (pnote
->type
)
15675 case V850_NOTE_ALIGNMENT
:
15678 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15679 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15683 case V850_NOTE_DATA_SIZE
:
15686 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15687 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15691 case V850_NOTE_FPU_INFO
:
15694 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15695 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15699 case V850_NOTE_MMU_INFO
:
15700 case V850_NOTE_CACHE_INFO
:
15701 case V850_NOTE_SIMD_INFO
:
15702 if (val
== EF_RH850_SIMD
)
15704 printf (_("yes\n"));
15710 /* An 'unknown note type' message will already have been displayed. */
15714 printf (_("unknown value: %x\n"), val
);
15719 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15721 unsigned int version
;
15723 switch (pnote
->type
)
15725 case NT_NETBSD_IDENT
:
15726 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15727 if ((version
/ 10000) % 100)
15728 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15729 version
, version
/ 100000000, (version
/ 1000000) % 100,
15730 (version
/ 10000) % 100 > 26 ? "Z" : "",
15731 'A' + (version
/ 10000) % 26);
15733 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15734 version
, version
/ 100000000, (version
/ 1000000) % 100,
15735 (version
/ 100) % 100);
15738 case NT_NETBSD_MARCH
:
15739 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15747 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15752 static const char *
15753 get_freebsd_elfcore_note_type (unsigned e_type
)
15757 case NT_FREEBSD_THRMISC
:
15758 return _("NT_THRMISC (thrmisc structure)");
15759 case NT_FREEBSD_PROCSTAT_PROC
:
15760 return _("NT_PROCSTAT_PROC (proc data)");
15761 case NT_FREEBSD_PROCSTAT_FILES
:
15762 return _("NT_PROCSTAT_FILES (files data)");
15763 case NT_FREEBSD_PROCSTAT_VMMAP
:
15764 return _("NT_PROCSTAT_VMMAP (vmmap data)");
15765 case NT_FREEBSD_PROCSTAT_GROUPS
:
15766 return _("NT_PROCSTAT_GROUPS (groups data)");
15767 case NT_FREEBSD_PROCSTAT_UMASK
:
15768 return _("NT_PROCSTAT_UMASK (umask data)");
15769 case NT_FREEBSD_PROCSTAT_RLIMIT
:
15770 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
15771 case NT_FREEBSD_PROCSTAT_OSREL
:
15772 return _("NT_PROCSTAT_OSREL (osreldate data)");
15773 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
15774 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
15775 case NT_FREEBSD_PROCSTAT_AUXV
:
15776 return _("NT_PROCSTAT_AUXV (auxv data)");
15778 return get_note_type (e_type
);
15781 static const char *
15782 get_netbsd_elfcore_note_type (unsigned e_type
)
15784 static char buff
[64];
15786 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15788 /* NetBSD core "procinfo" structure. */
15789 return _("NetBSD procinfo structure");
15792 /* As of Jan 2002 there are no other machine-independent notes
15793 defined for NetBSD core files. If the note type is less
15794 than the start of the machine-dependent note types, we don't
15797 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15799 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15803 switch (elf_header
.e_machine
)
15805 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15806 and PT_GETFPREGS == mach+2. */
15811 case EM_SPARC32PLUS
:
15815 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15816 return _("PT_GETREGS (reg structure)");
15817 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15818 return _("PT_GETFPREGS (fpreg structure)");
15824 /* On all other arch's, PT_GETREGS == mach+1 and
15825 PT_GETFPREGS == mach+3. */
15829 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15830 return _("PT_GETREGS (reg structure)");
15831 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15832 return _("PT_GETFPREGS (fpreg structure)");
15838 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15839 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15843 static const char *
15844 get_stapsdt_note_type (unsigned e_type
)
15846 static char buff
[64];
15851 return _("NT_STAPSDT (SystemTap probe descriptors)");
15857 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15862 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15864 int addr_size
= is_32bit_elf
? 4 : 8;
15865 char *data
= pnote
->descdata
;
15866 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15867 bfd_vma pc
, base_addr
, semaphore
;
15868 char *provider
, *probe
, *arg_fmt
;
15870 pc
= byte_get ((unsigned char *) data
, addr_size
);
15872 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15874 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15878 data
+= strlen (data
) + 1;
15880 data
+= strlen (data
) + 1;
15882 data
+= strlen (data
) + 1;
15884 printf (_(" Provider: %s\n"), provider
);
15885 printf (_(" Name: %s\n"), probe
);
15886 printf (_(" Location: "));
15887 print_vma (pc
, FULL_HEX
);
15888 printf (_(", Base: "));
15889 print_vma (base_addr
, FULL_HEX
);
15890 printf (_(", Semaphore: "));
15891 print_vma (semaphore
, FULL_HEX
);
15893 printf (_(" Arguments: %s\n"), arg_fmt
);
15895 return data
== data_end
;
15898 static const char *
15899 get_ia64_vms_note_type (unsigned e_type
)
15901 static char buff
[64];
15906 return _("NT_VMS_MHD (module header)");
15908 return _("NT_VMS_LNM (language name)");
15910 return _("NT_VMS_SRC (source files)");
15912 return "NT_VMS_TITLE";
15914 return _("NT_VMS_EIDC (consistency check)");
15915 case NT_VMS_FPMODE
:
15916 return _("NT_VMS_FPMODE (FP mode)");
15917 case NT_VMS_LINKTIME
:
15918 return "NT_VMS_LINKTIME";
15919 case NT_VMS_IMGNAM
:
15920 return _("NT_VMS_IMGNAM (image name)");
15922 return _("NT_VMS_IMGID (image id)");
15923 case NT_VMS_LINKID
:
15924 return _("NT_VMS_LINKID (link id)");
15925 case NT_VMS_IMGBID
:
15926 return _("NT_VMS_IMGBID (build id)");
15927 case NT_VMS_GSTNAM
:
15928 return _("NT_VMS_GSTNAM (sym table name)");
15929 case NT_VMS_ORIG_DYN
:
15930 return "NT_VMS_ORIG_DYN";
15931 case NT_VMS_PATCHTIME
:
15932 return "NT_VMS_PATCHTIME";
15934 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15940 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15942 switch (pnote
->type
)
15945 if (pnote
->descsz
> 36)
15947 size_t l
= strlen (pnote
->descdata
+ 34);
15948 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15949 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15950 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15951 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15954 printf (_(" Invalid size\n"));
15957 printf (_(" Language: %s\n"), pnote
->descdata
);
15960 case NT_VMS_FPMODE
:
15961 printf (_(" Floating Point mode: "));
15962 printf ("0x%016" BFD_VMA_FMT
"x\n",
15963 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15965 case NT_VMS_LINKTIME
:
15966 printf (_(" Link time: "));
15968 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15971 case NT_VMS_PATCHTIME
:
15972 printf (_(" Patch time: "));
15974 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15977 case NT_VMS_ORIG_DYN
:
15978 printf (_(" Major id: %u, minor id: %u\n"),
15979 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15980 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15981 printf (_(" Last modified : "));
15983 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15984 printf (_("\n Link flags : "));
15985 printf ("0x%016" BFD_VMA_FMT
"x\n",
15986 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15987 printf (_(" Header flags: 0x%08x\n"),
15988 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15989 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15992 case NT_VMS_IMGNAM
:
15993 printf (_(" Image name: %s\n"), pnote
->descdata
);
15995 case NT_VMS_GSTNAM
:
15996 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15999 printf (_(" Image id: %s\n"), pnote
->descdata
);
16001 case NT_VMS_LINKID
:
16002 printf (_(" Linker id: %s\n"), pnote
->descdata
);
16010 /* Note that by the ELF standard, the name field is already null byte
16011 terminated, and namesz includes the terminating null byte.
16012 I.E. the value of namesz for the name "FSF" is 4.
16014 If the value of namesz is zero, there is no name present. */
16016 process_note (Elf_Internal_Note
* pnote
)
16018 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
16021 if (pnote
->namesz
== 0)
16022 /* If there is no note name, then use the default set of
16023 note type strings. */
16024 nt
= get_note_type (pnote
->type
);
16026 else if (const_strneq (pnote
->namedata
, "GNU"))
16027 /* GNU-specific object file notes. */
16028 nt
= get_gnu_elf_note_type (pnote
->type
);
16030 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
16031 /* FreeBSD-specific core file notes. */
16032 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
16034 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
16035 /* NetBSD-specific core file notes. */
16036 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
16038 else if (const_strneq (pnote
->namedata
, "NetBSD"))
16039 /* NetBSD-specific core file notes. */
16040 return process_netbsd_elf_note (pnote
);
16042 else if (strneq (pnote
->namedata
, "SPU/", 4))
16044 /* SPU-specific core file notes. */
16045 nt
= pnote
->namedata
+ 4;
16049 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16050 /* VMS/ia64-specific file notes. */
16051 nt
= get_ia64_vms_note_type (pnote
->type
);
16053 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16054 nt
= get_stapsdt_note_type (pnote
->type
);
16057 /* Don't recognize this note name; just use the default set of
16058 note type strings. */
16059 nt
= get_note_type (pnote
->type
);
16061 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
16063 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
16064 return print_ia64_vms_note (pnote
);
16065 else if (const_strneq (pnote
->namedata
, "GNU"))
16066 return print_gnu_note (pnote
);
16067 else if (const_strneq (pnote
->namedata
, "stapsdt"))
16068 return print_stapsdt_note (pnote
);
16069 else if (const_strneq (pnote
->namedata
, "CORE"))
16070 return print_core_note (pnote
);
16077 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
16079 Elf_External_Note
* pnotes
;
16080 Elf_External_Note
* external
;
16087 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16089 if (pnotes
== NULL
)
16094 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16095 (unsigned long) offset
, (unsigned long) length
);
16096 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
16098 end
= (char *) pnotes
+ length
;
16099 while ((char *) external
< end
)
16101 Elf_Internal_Note inote
;
16104 char * temp
= NULL
;
16105 size_t data_remaining
= end
- (char *) external
;
16107 if (!is_ia64_vms ())
16109 /* PR binutils/15191
16110 Make sure that there is enough data to read. */
16111 min_notesz
= offsetof (Elf_External_Note
, name
);
16112 if (data_remaining
< min_notesz
)
16114 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16115 (int) data_remaining
);
16118 inote
.type
= BYTE_GET (external
->type
);
16119 inote
.namesz
= BYTE_GET (external
->namesz
);
16120 inote
.namedata
= external
->name
;
16121 inote
.descsz
= BYTE_GET (external
->descsz
);
16122 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16123 /* PR 17531: file: 3443835e. */
16124 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
16126 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16127 inote
.descdata
= inote
.namedata
;
16131 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16132 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
16136 Elf64_External_VMS_Note
*vms_external
;
16138 /* PR binutils/15191
16139 Make sure that there is enough data to read. */
16140 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
16141 if (data_remaining
< min_notesz
)
16143 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16144 (int) data_remaining
);
16148 vms_external
= (Elf64_External_VMS_Note
*) external
;
16149 inote
.type
= BYTE_GET (vms_external
->type
);
16150 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
16151 inote
.namedata
= vms_external
->name
;
16152 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
16153 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
16154 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16155 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
16158 if (inote
.descdata
< (char *) external
+ min_notesz
16159 || next
< (char *) external
+ min_notesz
16160 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
16161 || inote
.namedata
+ inote
.namesz
< inote
.namedata
16162 || inote
.descdata
+ inote
.descsz
< inote
.descdata
16163 || data_remaining
< (size_t)(next
- (char *) external
))
16165 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
16166 (unsigned long) ((char *) external
- (char *) pnotes
));
16167 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
16168 inote
.type
, inote
.namesz
, inote
.descsz
);
16172 external
= (Elf_External_Note
*) next
;
16174 /* Verify that name is null terminated. It appears that at least
16175 one version of Linux (RedHat 6.0) generates corefiles that don't
16176 comply with the ELF spec by failing to include the null byte in
16178 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
16180 temp
= (char *) malloc (inote
.namesz
+ 1);
16183 error (_("Out of memory allocating space for inote name\n"));
16188 strncpy (temp
, inote
.namedata
, inote
.namesz
);
16189 temp
[inote
.namesz
] = 0;
16191 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
16192 inote
.namedata
= temp
;
16195 res
&= process_note (& inote
);
16210 process_corefile_note_segments (FILE * file
)
16212 Elf_Internal_Phdr
* segment
;
16216 if (! get_program_headers (file
))
16219 for (i
= 0, segment
= program_headers
;
16220 i
< elf_header
.e_phnum
;
16223 if (segment
->p_type
== PT_NOTE
)
16224 res
&= process_corefile_note_segment (file
,
16225 (bfd_vma
) segment
->p_offset
,
16226 (bfd_vma
) segment
->p_filesz
);
16233 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
16235 Elf_External_Note
* pnotes
;
16236 Elf_External_Note
* external
;
16243 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
16245 if (pnotes
== NULL
)
16249 end
= (char*) pnotes
+ length
;
16251 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
16252 (unsigned long) offset
, (unsigned long) length
);
16254 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
16256 Elf_External_Note
* next
;
16257 Elf_Internal_Note inote
;
16259 inote
.type
= BYTE_GET (external
->type
);
16260 inote
.namesz
= BYTE_GET (external
->namesz
);
16261 inote
.namedata
= external
->name
;
16262 inote
.descsz
= BYTE_GET (external
->descsz
);
16263 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
16264 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
16266 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
16268 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
16269 inote
.descdata
= inote
.namedata
;
16273 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
16275 if ( ((char *) next
> end
)
16276 || ((char *) next
< (char *) pnotes
))
16278 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
16279 (unsigned long) ((char *) external
- (char *) pnotes
));
16280 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16281 inote
.type
, inote
.namesz
, inote
.descsz
);
16287 /* Prevent out-of-bounds indexing. */
16288 if ( inote
.namedata
+ inote
.namesz
> end
16289 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
16291 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
16292 (unsigned long) ((char *) external
- (char *) pnotes
));
16293 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
16294 inote
.type
, inote
.namesz
, inote
.descsz
);
16298 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
16300 if (! print_v850_note (& inote
))
16303 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
16304 inote
.namesz
, inote
.descsz
);
16314 process_note_sections (FILE * file
)
16316 Elf_Internal_Shdr
* section
;
16321 for (i
= 0, section
= section_headers
;
16322 i
< elf_header
.e_shnum
&& section
!= NULL
;
16325 if (section
->sh_type
== SHT_NOTE
)
16327 res
&= process_corefile_note_segment (file
,
16328 (bfd_vma
) section
->sh_offset
,
16329 (bfd_vma
) section
->sh_size
);
16333 if (( elf_header
.e_machine
== EM_V800
16334 || elf_header
.e_machine
== EM_V850
16335 || elf_header
.e_machine
== EM_CYGNUS_V850
)
16336 && section
->sh_type
== SHT_RENESAS_INFO
)
16338 res
&= process_v850_notes (file
,
16339 (bfd_vma
) section
->sh_offset
,
16340 (bfd_vma
) section
->sh_size
);
16346 /* Try processing NOTE segments instead. */
16347 return process_corefile_note_segments (file
);
16353 process_notes (FILE * file
)
16355 /* If we have not been asked to display the notes then do nothing. */
16359 if (elf_header
.e_type
!= ET_CORE
)
16360 return process_note_sections (file
);
16362 /* No program headers means no NOTE segment. */
16363 if (elf_header
.e_phnum
> 0)
16364 return process_corefile_note_segments (file
);
16366 printf (_("No note segments present in the core file.\n"));
16371 process_arch_specific (FILE * file
)
16376 switch (elf_header
.e_machine
)
16379 return process_arm_specific (file
);
16381 case EM_MIPS_RS3_LE
:
16382 return process_mips_specific (file
);
16385 return process_nds32_specific (file
);
16389 return process_power_specific (file
);
16393 return process_s390_specific (file
);
16396 case EM_SPARC32PLUS
:
16398 return process_sparc_specific (file
);
16401 return process_tic6x_specific (file
);
16404 return process_msp430x_specific (file
);
16412 get_file_header (FILE * file
)
16414 /* Read in the identity array. */
16415 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16418 /* Determine how to read the rest of the header. */
16419 switch (elf_header
.e_ident
[EI_DATA
])
16421 default: /* fall through */
16422 case ELFDATANONE
: /* fall through */
16424 byte_get
= byte_get_little_endian
;
16425 byte_put
= byte_put_little_endian
;
16428 byte_get
= byte_get_big_endian
;
16429 byte_put
= byte_put_big_endian
;
16433 /* For now we only support 32 bit and 64 bit ELF files. */
16434 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16436 /* Read in the rest of the header. */
16439 Elf32_External_Ehdr ehdr32
;
16441 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16444 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16445 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16446 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16447 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16448 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16449 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16450 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16451 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16452 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16453 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16454 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16455 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16456 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16460 Elf64_External_Ehdr ehdr64
;
16462 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16463 we will not be able to cope with the 64bit data found in
16464 64 ELF files. Detect this now and abort before we start
16465 overwriting things. */
16466 if (sizeof (bfd_vma
) < 8)
16468 error (_("This instance of readelf has been built without support for a\n\
16469 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16473 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16476 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16477 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16478 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16479 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16480 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16481 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16482 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16483 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16484 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16485 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16486 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16487 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16488 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16491 if (elf_header
.e_shoff
)
16493 /* There may be some extensions in the first section header. Don't
16494 bomb if we can't read it. */
16496 get_32bit_section_headers (file
, TRUE
);
16498 get_64bit_section_headers (file
, TRUE
);
16504 /* Process one ELF object file according to the command line options.
16505 This file may actually be stored in an archive. The file is
16506 positioned at the start of the ELF object. */
16509 process_object (char * file_name
, FILE * file
)
16513 if (! get_file_header (file
))
16515 error (_("%s: Failed to read file header\n"), file_name
);
16519 /* Initialise per file variables. */
16520 for (i
= ARRAY_SIZE (version_info
); i
--;)
16521 version_info
[i
] = 0;
16523 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16524 dynamic_info
[i
] = 0;
16525 dynamic_info_DT_GNU_HASH
= 0;
16527 /* Process the file. */
16529 printf (_("\nFile: %s\n"), file_name
);
16531 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16532 Note we do this even if cmdline_dump_sects is empty because we
16533 must make sure that the dump_sets array is zeroed out before each
16534 object file is processed. */
16535 if (num_dump_sects
> num_cmdline_dump_sects
)
16536 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16538 if (num_cmdline_dump_sects
> 0)
16540 if (num_dump_sects
== 0)
16541 /* A sneaky way of allocating the dump_sects array. */
16542 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16544 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16545 memcpy (dump_sects
, cmdline_dump_sects
,
16546 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16549 if (! process_file_header ())
16552 if (! process_section_headers (file
))
16554 /* Without loaded section headers we cannot process lots of
16556 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16558 if (! do_using_dynamic
)
16559 do_syms
= do_dyn_syms
= do_reloc
= 0;
16562 if (! process_section_groups (file
))
16564 /* Without loaded section groups we cannot process unwind. */
16568 if (process_program_headers (file
))
16569 process_dynamic_section (file
);
16571 process_relocs (file
);
16573 process_unwind (file
);
16575 process_symbol_table (file
);
16577 process_syminfo (file
);
16579 process_version_sections (file
);
16581 process_section_contents (file
);
16583 process_notes (file
);
16585 process_gnu_liblist (file
);
16587 process_arch_specific (file
);
16589 if (program_headers
)
16591 free (program_headers
);
16592 program_headers
= NULL
;
16595 if (section_headers
)
16597 free (section_headers
);
16598 section_headers
= NULL
;
16603 free (string_table
);
16604 string_table
= NULL
;
16605 string_table_length
= 0;
16608 if (dynamic_strings
)
16610 free (dynamic_strings
);
16611 dynamic_strings
= NULL
;
16612 dynamic_strings_length
= 0;
16615 if (dynamic_symbols
)
16617 free (dynamic_symbols
);
16618 dynamic_symbols
= NULL
;
16619 num_dynamic_syms
= 0;
16622 if (dynamic_syminfo
)
16624 free (dynamic_syminfo
);
16625 dynamic_syminfo
= NULL
;
16628 if (dynamic_section
)
16630 free (dynamic_section
);
16631 dynamic_section
= NULL
;
16634 if (section_headers_groups
)
16636 free (section_headers_groups
);
16637 section_headers_groups
= NULL
;
16640 if (section_groups
)
16642 struct group_list
* g
;
16643 struct group_list
* next
;
16645 for (i
= 0; i
< group_count
; i
++)
16647 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16654 free (section_groups
);
16655 section_groups
= NULL
;
16658 free_debug_memory ();
16663 /* Process an ELF archive.
16664 On entry the file is positioned just after the ARMAG string. */
16667 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16669 struct archive_info arch
;
16670 struct archive_info nested_arch
;
16676 /* The ARCH structure is used to hold information about this archive. */
16677 arch
.file_name
= NULL
;
16679 arch
.index_array
= NULL
;
16680 arch
.sym_table
= NULL
;
16681 arch
.longnames
= NULL
;
16683 /* The NESTED_ARCH structure is used as a single-item cache of information
16684 about a nested archive (when members of a thin archive reside within
16685 another regular archive file). */
16686 nested_arch
.file_name
= NULL
;
16687 nested_arch
.file
= NULL
;
16688 nested_arch
.index_array
= NULL
;
16689 nested_arch
.sym_table
= NULL
;
16690 nested_arch
.longnames
= NULL
;
16692 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16698 if (do_archive_index
)
16700 if (arch
.sym_table
== NULL
)
16701 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16704 unsigned long i
, l
;
16705 unsigned long current_pos
;
16707 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16708 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16709 current_pos
= ftell (file
);
16711 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16713 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16715 char * member_name
;
16717 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16719 if (member_name
!= NULL
)
16721 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16723 if (qualified_name
!= NULL
)
16725 printf (_("Contents of binary %s at offset "), qualified_name
);
16726 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16728 free (qualified_name
);
16733 if (l
>= arch
.sym_size
)
16735 error (_("%s: end of the symbol table reached before the end of the index\n"),
16739 /* PR 17531: file: 0b6630b2. */
16740 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16741 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16744 if (arch
.uses_64bit_indicies
)
16749 if (l
< arch
.sym_size
)
16750 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16751 file_name
, arch
.sym_size
- l
);
16753 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16755 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16761 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16762 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16763 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16764 && !do_section_groups
&& !do_dyn_syms
)
16766 ret
= 0; /* Archive index only. */
16777 char * qualified_name
;
16779 /* Read the next archive header. */
16780 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16782 error (_("%s: failed to seek to next archive header\n"), file_name
);
16785 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16786 if (got
!= sizeof arch
.arhdr
)
16790 error (_("%s: failed to read archive header\n"), file_name
);
16794 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16796 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16801 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16803 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16804 if (archive_file_size
& 01)
16805 ++archive_file_size
;
16807 name
= get_archive_member_name (&arch
, &nested_arch
);
16810 error (_("%s: bad archive file name\n"), file_name
);
16814 namelen
= strlen (name
);
16816 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16817 if (qualified_name
== NULL
)
16819 error (_("%s: bad archive file name\n"), file_name
);
16824 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16826 /* This is a proxy for an external member of a thin archive. */
16827 FILE * member_file
;
16828 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16829 if (member_file_name
== NULL
)
16835 member_file
= fopen (member_file_name
, "rb");
16836 if (member_file
== NULL
)
16838 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16839 free (member_file_name
);
16844 archive_file_offset
= arch
.nested_member_origin
;
16846 ret
|= process_object (qualified_name
, member_file
);
16848 fclose (member_file
);
16849 free (member_file_name
);
16851 else if (is_thin_archive
)
16853 /* PR 15140: Allow for corrupt thin archives. */
16854 if (nested_arch
.file
== NULL
)
16856 error (_("%s: contains corrupt thin archive: %s\n"),
16862 /* This is a proxy for a member of a nested archive. */
16863 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16865 /* The nested archive file will have been opened and setup by
16866 get_archive_member_name. */
16867 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16869 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16874 ret
|= process_object (qualified_name
, nested_arch
.file
);
16878 archive_file_offset
= arch
.next_arhdr_offset
;
16879 arch
.next_arhdr_offset
+= archive_file_size
;
16881 ret
|= process_object (qualified_name
, file
);
16884 if (dump_sects
!= NULL
)
16888 num_dump_sects
= 0;
16891 free (qualified_name
);
16895 if (nested_arch
.file
!= NULL
)
16896 fclose (nested_arch
.file
);
16897 release_archive (&nested_arch
);
16898 release_archive (&arch
);
16904 process_file (char * file_name
)
16907 struct stat statbuf
;
16908 char armag
[SARMAG
];
16911 if (stat (file_name
, &statbuf
) < 0)
16913 if (errno
== ENOENT
)
16914 error (_("'%s': No such file\n"), file_name
);
16916 error (_("Could not locate '%s'. System error message: %s\n"),
16917 file_name
, strerror (errno
));
16921 if (! S_ISREG (statbuf
.st_mode
))
16923 error (_("'%s' is not an ordinary file\n"), file_name
);
16927 file
= fopen (file_name
, "rb");
16930 error (_("Input file '%s' is not readable.\n"), file_name
);
16934 if (fread (armag
, SARMAG
, 1, file
) != 1)
16936 error (_("%s: Failed to read file's magic number\n"), file_name
);
16941 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16943 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16944 ret
= process_archive (file_name
, file
, FALSE
);
16945 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16946 ret
= process_archive (file_name
, file
, TRUE
);
16949 if (do_archive_index
)
16950 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16954 archive_file_size
= archive_file_offset
= 0;
16955 ret
= process_object (file_name
, file
);
16960 current_file_size
= 0;
16964 #ifdef SUPPORT_DISASSEMBLY
16965 /* Needed by the i386 disassembler. For extra credit, someone could
16966 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16970 print_address (unsigned int addr
, FILE * outfile
)
16972 fprintf (outfile
,"0x%8.8x", addr
);
16975 /* Needed by the i386 disassembler. */
16977 db_task_printsym (unsigned int addr
)
16979 print_address (addr
, stderr
);
16984 main (int argc
, char ** argv
)
16988 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16989 setlocale (LC_MESSAGES
, "");
16991 #if defined (HAVE_SETLOCALE)
16992 setlocale (LC_CTYPE
, "");
16994 bindtextdomain (PACKAGE
, LOCALEDIR
);
16995 textdomain (PACKAGE
);
16997 expandargv (&argc
, &argv
);
16999 parse_args (argc
, argv
);
17001 if (num_dump_sects
> 0)
17003 /* Make a copy of the dump_sects array. */
17004 cmdline_dump_sects
= (dump_type
*)
17005 malloc (num_dump_sects
* sizeof (* dump_sects
));
17006 if (cmdline_dump_sects
== NULL
)
17007 error (_("Out of memory allocating dump request table.\n"));
17010 memcpy (cmdline_dump_sects
, dump_sects
,
17011 num_dump_sects
* sizeof (* dump_sects
));
17012 num_cmdline_dump_sects
= num_dump_sects
;
17016 if (optind
< (argc
- 1))
17018 else if (optind
>= argc
)
17020 warn (_("Nothing to do.\n"));
17025 while (optind
< argc
)
17026 err
|= process_file (argv
[optind
++]);
17028 if (dump_sects
!= NULL
)
17030 if (cmdline_dump_sects
!= NULL
)
17031 free (cmdline_dump_sects
);