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%llx elements of size 0x%llx for %s\n"),
350 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
354 /* Check for size overflow. */
358 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
359 (unsigned long long) nmemb
, (unsigned long long) size
, reason
);
363 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
364 attempting to allocate memory when the read is bound to fail. */
365 if (amt
> current_file_size
366 || offset
+ archive_file_offset
+ amt
> current_file_size
)
369 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
370 (unsigned long long) amt
, reason
);
374 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
377 error (_("Unable to seek to 0x%lx for %s\n"),
378 (unsigned long) archive_file_offset
+ offset
, reason
);
385 /* Check for overflow. */
386 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
387 /* + 1 so that we can '\0' terminate invalid string table sections. */
388 mvar
= malloc ((size_t) amt
+ 1);
393 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
394 (unsigned long long) amt
, reason
);
398 ((char *) mvar
)[amt
] = '\0';
401 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
404 error (_("Unable to read in 0x%llx bytes of %s\n"),
405 (unsigned long long) amt
, reason
);
414 /* Print a VMA value. */
417 print_vma (bfd_vma vma
, print_mode mode
)
430 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
437 return printf ("%5" BFD_VMA_FMT
"d", vma
);
445 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
448 return printf ("%" BFD_VMA_FMT
"d", vma
);
451 return printf ("%" BFD_VMA_FMT
"u", vma
);
456 /* Display a symbol on stdout. Handles the display of control characters and
457 multibye characters (assuming the host environment supports them).
459 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
461 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
462 padding as necessary.
464 Returns the number of emitted characters. */
467 print_symbol (int width
, const char *symbol
)
469 bfd_boolean extra_padding
= FALSE
;
471 #ifdef HAVE_MBSTATE_T
478 /* Keep the width positive. This also helps. */
480 extra_padding
= TRUE
;
485 /* Set the remaining width to a very large value.
486 This simplifies the code below. */
487 width_remaining
= INT_MAX
;
489 width_remaining
= width
;
491 #ifdef HAVE_MBSTATE_T
492 /* Initialise the multibyte conversion state. */
493 memset (& state
, 0, sizeof (state
));
496 while (width_remaining
)
499 const char c
= *symbol
++;
504 /* Do not print control characters directly as they can affect terminal
505 settings. Such characters usually appear in the names generated
506 by the assembler for local labels. */
509 if (width_remaining
< 2)
512 printf ("^%c", c
+ 0x40);
513 width_remaining
-= 2;
516 else if (ISPRINT (c
))
524 #ifdef HAVE_MBSTATE_T
527 /* Let printf do the hard work of displaying multibyte characters. */
528 printf ("%.1s", symbol
- 1);
532 #ifdef HAVE_MBSTATE_T
533 /* Try to find out how many bytes made up the character that was
534 just printed. Advance the symbol pointer past the bytes that
536 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
540 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
545 if (extra_padding
&& num_printed
< width
)
547 /* Fill in the remaining spaces. */
548 printf ("%-*s", width
- num_printed
, " ");
555 /* Returns a pointer to a static buffer containing a printable version of
556 the given section's name. Like print_symbol, except that it does not try
557 to print multibyte characters, it just interprets them as hex values. */
560 printable_section_name (const Elf_Internal_Shdr
* sec
)
562 #define MAX_PRINT_SEC_NAME_LEN 128
563 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
564 const char * name
= SECTION_NAME (sec
);
565 char * buf
= sec_name_buf
;
567 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
569 while ((c
= * name
++) != 0)
580 else if (ISPRINT (c
))
587 static char hex
[17] = "0123456789ABCDEF";
592 * buf
++ = hex
[(c
& 0xf0) >> 4];
593 * buf
++ = hex
[c
& 0x0f];
607 printable_section_name_from_index (unsigned long ndx
)
609 if (ndx
>= elf_header
.e_shnum
)
610 return _("<corrupt>");
612 return printable_section_name (section_headers
+ ndx
);
615 /* Return a pointer to section NAME, or NULL if no such section exists. */
617 static Elf_Internal_Shdr
*
618 find_section (const char * name
)
622 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
623 if (streq (SECTION_NAME (section_headers
+ i
), name
))
624 return section_headers
+ i
;
629 /* Return a pointer to a section containing ADDR, or NULL if no such
632 static Elf_Internal_Shdr
*
633 find_section_by_address (bfd_vma addr
)
637 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
639 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
640 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
647 static Elf_Internal_Shdr
*
648 find_section_by_type (unsigned int type
)
652 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
654 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
655 if (sec
->sh_type
== type
)
662 /* Return a pointer to section NAME, or NULL if no such section exists,
663 restricted to the list of sections given in SET. */
665 static Elf_Internal_Shdr
*
666 find_section_in_set (const char * name
, unsigned int * set
)
672 while ((i
= *set
++) > 0)
673 if (streq (SECTION_NAME (section_headers
+ i
), name
))
674 return section_headers
+ i
;
677 return find_section (name
);
680 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
683 static inline unsigned long
684 read_uleb128 (unsigned char *data
,
685 unsigned int *length_return
,
686 const unsigned char * const end
)
688 return read_leb128 (data
, length_return
, FALSE
, end
);
691 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
692 This OS has so many departures from the ELF standard that we test it at
698 return elf_header
.e_machine
== EM_IA_64
699 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
702 /* Guess the relocation size commonly used by the specific machines. */
705 guess_is_rela (unsigned int e_machine
)
709 /* Targets that use REL relocations. */
724 /* Targets that use RELA relocations. */
728 case EM_ADAPTEVA_EPIPHANY
:
730 case EM_ALTERA_NIOS2
:
733 case EM_ARC_COMPACT2
:
753 case EM_LATTICEMICO32
:
762 case EM_CYGNUS_MN10200
:
764 case EM_CYGNUS_MN10300
:
798 case EM_MICROBLAZE_OLD
:
819 warn (_("Don't know about relocations on this machine architecture\n"));
825 slurp_rela_relocs (FILE * file
,
826 unsigned long rel_offset
,
827 unsigned long rel_size
,
828 Elf_Internal_Rela
** relasp
,
829 unsigned long * nrelasp
)
831 Elf_Internal_Rela
* relas
;
837 Elf32_External_Rela
* erelas
;
839 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
840 rel_size
, _("32-bit relocation data"));
844 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
846 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
847 sizeof (Elf_Internal_Rela
));
852 error (_("out of memory parsing relocs\n"));
856 for (i
= 0; i
< nrelas
; i
++)
858 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
859 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
860 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
867 Elf64_External_Rela
* erelas
;
869 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
870 rel_size
, _("64-bit relocation data"));
874 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
876 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
877 sizeof (Elf_Internal_Rela
));
882 error (_("out of memory parsing relocs\n"));
886 for (i
= 0; i
< nrelas
; i
++)
888 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
889 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
890 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
892 /* The #ifdef BFD64 below is to prevent a compile time
893 warning. We know that if we do not have a 64 bit data
894 type that we will never execute this code anyway. */
896 if (elf_header
.e_machine
== EM_MIPS
897 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
899 /* In little-endian objects, r_info isn't really a
900 64-bit little-endian value: it has a 32-bit
901 little-endian symbol index followed by four
902 individual byte fields. Reorder INFO
904 bfd_vma inf
= relas
[i
].r_info
;
905 inf
= (((inf
& 0xffffffff) << 32)
906 | ((inf
>> 56) & 0xff)
907 | ((inf
>> 40) & 0xff00)
908 | ((inf
>> 24) & 0xff0000)
909 | ((inf
>> 8) & 0xff000000));
910 relas
[i
].r_info
= inf
;
923 slurp_rel_relocs (FILE * file
,
924 unsigned long rel_offset
,
925 unsigned long rel_size
,
926 Elf_Internal_Rela
** relsp
,
927 unsigned long * nrelsp
)
929 Elf_Internal_Rela
* rels
;
935 Elf32_External_Rel
* erels
;
937 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
938 rel_size
, _("32-bit relocation data"));
942 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
944 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
949 error (_("out of memory parsing relocs\n"));
953 for (i
= 0; i
< nrels
; i
++)
955 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
956 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
957 rels
[i
].r_addend
= 0;
964 Elf64_External_Rel
* erels
;
966 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
967 rel_size
, _("64-bit relocation data"));
971 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
973 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
978 error (_("out of memory parsing relocs\n"));
982 for (i
= 0; i
< nrels
; i
++)
984 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
985 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
986 rels
[i
].r_addend
= 0;
988 /* The #ifdef BFD64 below is to prevent a compile time
989 warning. We know that if we do not have a 64 bit data
990 type that we will never execute this code anyway. */
992 if (elf_header
.e_machine
== EM_MIPS
993 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
995 /* In little-endian objects, r_info isn't really a
996 64-bit little-endian value: it has a 32-bit
997 little-endian symbol index followed by four
998 individual byte fields. Reorder INFO
1000 bfd_vma inf
= rels
[i
].r_info
;
1001 inf
= (((inf
& 0xffffffff) << 32)
1002 | ((inf
>> 56) & 0xff)
1003 | ((inf
>> 40) & 0xff00)
1004 | ((inf
>> 24) & 0xff0000)
1005 | ((inf
>> 8) & 0xff000000));
1006 rels
[i
].r_info
= inf
;
1018 /* Returns the reloc type extracted from the reloc info field. */
1021 get_reloc_type (bfd_vma reloc_info
)
1024 return ELF32_R_TYPE (reloc_info
);
1026 switch (elf_header
.e_machine
)
1029 /* Note: We assume that reloc_info has already been adjusted for us. */
1030 return ELF64_MIPS_R_TYPE (reloc_info
);
1033 return ELF64_R_TYPE_ID (reloc_info
);
1036 return ELF64_R_TYPE (reloc_info
);
1040 /* Return the symbol index extracted from the reloc info field. */
1043 get_reloc_symindex (bfd_vma reloc_info
)
1045 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1048 static inline bfd_boolean
1049 uses_msp430x_relocs (void)
1052 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1053 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1054 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1055 /* TI compiler uses ELFOSABI_NONE. */
1056 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1059 /* Display the contents of the relocation data found at the specified
1063 dump_relocations (FILE * file
,
1064 unsigned long rel_offset
,
1065 unsigned long rel_size
,
1066 Elf_Internal_Sym
* symtab
,
1067 unsigned long nsyms
,
1069 unsigned long strtablen
,
1074 Elf_Internal_Rela
* rels
;
1076 if (is_rela
== UNKNOWN
)
1077 is_rela
= guess_is_rela (elf_header
.e_machine
);
1081 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1086 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1095 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1097 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1102 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1104 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1112 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1114 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1119 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1121 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1125 for (i
= 0; i
< rel_size
; i
++)
1130 bfd_vma symtab_index
;
1133 offset
= rels
[i
].r_offset
;
1134 inf
= rels
[i
].r_info
;
1136 type
= get_reloc_type (inf
);
1137 symtab_index
= get_reloc_symindex (inf
);
1141 printf ("%8.8lx %8.8lx ",
1142 (unsigned long) offset
& 0xffffffff,
1143 (unsigned long) inf
& 0xffffffff);
1147 #if BFD_HOST_64BIT_LONG
1149 ? "%16.16lx %16.16lx "
1150 : "%12.12lx %12.12lx ",
1152 #elif BFD_HOST_64BIT_LONG_LONG
1155 ? "%16.16llx %16.16llx "
1156 : "%12.12llx %12.12llx ",
1160 ? "%16.16I64x %16.16I64x "
1161 : "%12.12I64x %12.12I64x ",
1166 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1167 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1168 _bfd_int64_high (offset
),
1169 _bfd_int64_low (offset
),
1170 _bfd_int64_high (inf
),
1171 _bfd_int64_low (inf
));
1175 switch (elf_header
.e_machine
)
1182 rtype
= elf_aarch64_reloc_type (type
);
1186 case EM_CYGNUS_M32R
:
1187 rtype
= elf_m32r_reloc_type (type
);
1192 rtype
= elf_i386_reloc_type (type
);
1197 rtype
= elf_m68hc11_reloc_type (type
);
1201 rtype
= elf_m68k_reloc_type (type
);
1205 rtype
= elf_i960_reloc_type (type
);
1210 rtype
= elf_avr_reloc_type (type
);
1213 case EM_OLD_SPARCV9
:
1214 case EM_SPARC32PLUS
:
1217 rtype
= elf_sparc_reloc_type (type
);
1221 rtype
= elf_spu_reloc_type (type
);
1225 rtype
= v800_reloc_type (type
);
1228 case EM_CYGNUS_V850
:
1229 rtype
= v850_reloc_type (type
);
1233 case EM_CYGNUS_D10V
:
1234 rtype
= elf_d10v_reloc_type (type
);
1238 case EM_CYGNUS_D30V
:
1239 rtype
= elf_d30v_reloc_type (type
);
1243 rtype
= elf_dlx_reloc_type (type
);
1247 rtype
= elf_sh_reloc_type (type
);
1251 case EM_CYGNUS_MN10300
:
1252 rtype
= elf_mn10300_reloc_type (type
);
1256 case EM_CYGNUS_MN10200
:
1257 rtype
= elf_mn10200_reloc_type (type
);
1261 case EM_CYGNUS_FR30
:
1262 rtype
= elf_fr30_reloc_type (type
);
1266 rtype
= elf_frv_reloc_type (type
);
1270 rtype
= elf_ft32_reloc_type (type
);
1274 rtype
= elf_mcore_reloc_type (type
);
1278 rtype
= elf_mmix_reloc_type (type
);
1282 rtype
= elf_moxie_reloc_type (type
);
1286 if (uses_msp430x_relocs ())
1288 rtype
= elf_msp430x_reloc_type (type
);
1292 rtype
= elf_msp430_reloc_type (type
);
1296 rtype
= elf_nds32_reloc_type (type
);
1300 rtype
= elf_ppc_reloc_type (type
);
1304 rtype
= elf_ppc64_reloc_type (type
);
1308 case EM_MIPS_RS3_LE
:
1309 rtype
= elf_mips_reloc_type (type
);
1313 rtype
= elf_alpha_reloc_type (type
);
1317 rtype
= elf_arm_reloc_type (type
);
1321 case EM_ARC_COMPACT
:
1322 case EM_ARC_COMPACT2
:
1323 rtype
= elf_arc_reloc_type (type
);
1327 rtype
= elf_hppa_reloc_type (type
);
1333 rtype
= elf_h8_reloc_type (type
);
1337 rtype
= elf_or1k_reloc_type (type
);
1342 rtype
= elf_pj_reloc_type (type
);
1345 rtype
= elf_ia64_reloc_type (type
);
1349 rtype
= elf_cris_reloc_type (type
);
1353 rtype
= elf_i860_reloc_type (type
);
1359 rtype
= elf_x86_64_reloc_type (type
);
1363 rtype
= i370_reloc_type (type
);
1368 rtype
= elf_s390_reloc_type (type
);
1372 rtype
= elf_score_reloc_type (type
);
1376 rtype
= elf_xstormy16_reloc_type (type
);
1380 rtype
= elf_crx_reloc_type (type
);
1384 rtype
= elf_vax_reloc_type (type
);
1388 rtype
= elf_visium_reloc_type (type
);
1391 case EM_ADAPTEVA_EPIPHANY
:
1392 rtype
= elf_epiphany_reloc_type (type
);
1397 rtype
= elf_ip2k_reloc_type (type
);
1401 rtype
= elf_iq2000_reloc_type (type
);
1406 rtype
= elf_xtensa_reloc_type (type
);
1409 case EM_LATTICEMICO32
:
1410 rtype
= elf_lm32_reloc_type (type
);
1415 rtype
= elf_m32c_reloc_type (type
);
1419 rtype
= elf_mt_reloc_type (type
);
1423 rtype
= elf_bfin_reloc_type (type
);
1427 rtype
= elf_mep_reloc_type (type
);
1431 rtype
= elf_cr16_reloc_type (type
);
1435 case EM_MICROBLAZE_OLD
:
1436 rtype
= elf_microblaze_reloc_type (type
);
1440 rtype
= elf_rl78_reloc_type (type
);
1444 rtype
= elf_rx_reloc_type (type
);
1448 rtype
= elf_metag_reloc_type (type
);
1453 rtype
= elf_xc16x_reloc_type (type
);
1457 rtype
= elf_tic6x_reloc_type (type
);
1461 rtype
= elf_tilegx_reloc_type (type
);
1465 rtype
= elf_tilepro_reloc_type (type
);
1469 rtype
= elf_xgate_reloc_type (type
);
1472 case EM_ALTERA_NIOS2
:
1473 rtype
= elf_nios2_reloc_type (type
);
1478 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1480 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1482 if (elf_header
.e_machine
== EM_ALPHA
1484 && streq (rtype
, "R_ALPHA_LITUSE")
1487 switch (rels
[i
].r_addend
)
1489 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1490 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1491 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1492 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1493 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1494 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1495 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1496 default: rtype
= NULL
;
1499 printf (" (%s)", rtype
);
1503 printf (_("<unknown addend: %lx>"),
1504 (unsigned long) rels
[i
].r_addend
);
1507 else if (symtab_index
)
1509 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1510 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index
);
1513 Elf_Internal_Sym
* psym
;
1514 const char * version_string
;
1515 enum versioned_symbol_info sym_info
;
1516 unsigned short vna_other
;
1518 psym
= symtab
+ symtab_index
;
1521 = get_symbol_version_string (file
, is_dynsym
,
1530 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1534 unsigned int width
= is_32bit_elf
? 8 : 14;
1536 /* Relocations against GNU_IFUNC symbols do not use the value
1537 of the symbol as the address to relocate against. Instead
1538 they invoke the function named by the symbol and use its
1539 result as the address for relocation.
1541 To indicate this to the user, do not display the value of
1542 the symbol in the "Symbols's Value" field. Instead show
1543 its name followed by () as a hint that the symbol is
1547 || psym
->st_name
== 0
1548 || psym
->st_name
>= strtablen
)
1551 name
= strtab
+ psym
->st_name
;
1553 len
= print_symbol (width
, name
);
1555 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1557 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1561 print_vma (psym
->st_value
, LONG_HEX
);
1563 printf (is_32bit_elf
? " " : " ");
1566 if (psym
->st_name
== 0)
1568 const char * sec_name
= "<null>";
1571 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1573 if (psym
->st_shndx
< elf_header
.e_shnum
)
1574 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1575 else if (psym
->st_shndx
== SHN_ABS
)
1577 else if (psym
->st_shndx
== SHN_COMMON
)
1578 sec_name
= "COMMON";
1579 else if ((elf_header
.e_machine
== EM_MIPS
1580 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1581 || (elf_header
.e_machine
== EM_TI_C6000
1582 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1583 sec_name
= "SCOMMON";
1584 else if (elf_header
.e_machine
== EM_MIPS
1585 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1586 sec_name
= "SUNDEF";
1587 else if ((elf_header
.e_machine
== EM_X86_64
1588 || elf_header
.e_machine
== EM_L1OM
1589 || elf_header
.e_machine
== EM_K1OM
)
1590 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1591 sec_name
= "LARGE_COMMON";
1592 else if (elf_header
.e_machine
== EM_IA_64
1593 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1594 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1595 sec_name
= "ANSI_COM";
1596 else if (is_ia64_vms ()
1597 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1598 sec_name
= "VMS_SYMVEC";
1601 sprintf (name_buf
, "<section 0x%x>",
1602 (unsigned int) psym
->st_shndx
);
1603 sec_name
= name_buf
;
1606 print_symbol (22, sec_name
);
1608 else if (strtab
== NULL
)
1609 printf (_("<string table index: %3ld>"), psym
->st_name
);
1610 else if (psym
->st_name
>= strtablen
)
1611 printf (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1614 print_symbol (22, strtab
+ psym
->st_name
);
1616 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1622 bfd_vma off
= rels
[i
].r_addend
;
1624 if ((bfd_signed_vma
) off
< 0)
1625 printf (" - %" BFD_VMA_FMT
"x", - off
);
1627 printf (" + %" BFD_VMA_FMT
"x", off
);
1633 bfd_vma off
= rels
[i
].r_addend
;
1635 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1636 if ((bfd_signed_vma
) off
< 0)
1637 printf ("-%" BFD_VMA_FMT
"x", - off
);
1639 printf ("%" BFD_VMA_FMT
"x", off
);
1642 if (elf_header
.e_machine
== EM_SPARCV9
1644 && streq (rtype
, "R_SPARC_OLO10"))
1645 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1650 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1652 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1653 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1654 const char * rtype2
= elf_mips_reloc_type (type2
);
1655 const char * rtype3
= elf_mips_reloc_type (type3
);
1657 printf (" Type2: ");
1660 printf (_("unrecognized: %-7lx"),
1661 (unsigned long) type2
& 0xffffffff);
1663 printf ("%-17.17s", rtype2
);
1665 printf ("\n Type3: ");
1668 printf (_("unrecognized: %-7lx"),
1669 (unsigned long) type3
& 0xffffffff);
1671 printf ("%-17.17s", rtype3
);
1682 get_mips_dynamic_type (unsigned long type
)
1686 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1687 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1688 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1689 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1690 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1691 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1692 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1693 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1694 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1695 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1696 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1697 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1698 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1699 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1700 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1701 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1702 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1703 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1704 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1705 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1706 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1707 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1708 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1709 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1710 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1711 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1712 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1713 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1714 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1715 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1716 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1717 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1718 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1719 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1720 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1721 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1722 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1723 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1724 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1725 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1726 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1727 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1728 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1729 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1730 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1731 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1738 get_sparc64_dynamic_type (unsigned long type
)
1742 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1749 get_ppc_dynamic_type (unsigned long type
)
1753 case DT_PPC_GOT
: return "PPC_GOT";
1754 case DT_PPC_OPT
: return "PPC_OPT";
1761 get_ppc64_dynamic_type (unsigned long type
)
1765 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1766 case DT_PPC64_OPD
: return "PPC64_OPD";
1767 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1768 case DT_PPC64_OPT
: return "PPC64_OPT";
1775 get_parisc_dynamic_type (unsigned long type
)
1779 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1780 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1781 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1782 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1783 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1784 case DT_HP_PREINIT
: return "HP_PREINIT";
1785 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1786 case DT_HP_NEEDED
: return "HP_NEEDED";
1787 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1788 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1789 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1790 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1791 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1792 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1793 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1794 case DT_HP_FILTERED
: return "HP_FILTERED";
1795 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1796 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1797 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1798 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1799 case DT_PLT
: return "PLT";
1800 case DT_PLT_SIZE
: return "PLT_SIZE";
1801 case DT_DLT
: return "DLT";
1802 case DT_DLT_SIZE
: return "DLT_SIZE";
1809 get_ia64_dynamic_type (unsigned long type
)
1813 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1814 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1815 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1816 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1817 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1818 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1819 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1820 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1821 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1822 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1823 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1824 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1825 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1826 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1827 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1828 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1829 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1830 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1831 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1832 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1833 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1834 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1835 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1836 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1837 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1838 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1839 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1840 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1841 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1842 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1843 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1850 get_alpha_dynamic_type (unsigned long type
)
1854 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1861 get_score_dynamic_type (unsigned long type
)
1865 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1866 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1867 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1868 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1869 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1870 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1877 get_tic6x_dynamic_type (unsigned long type
)
1881 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1882 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1883 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1884 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1885 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1886 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1893 get_nios2_dynamic_type (unsigned long type
)
1897 case DT_NIOS2_GP
: return "NIOS2_GP";
1904 get_dynamic_type (unsigned long type
)
1906 static char buff
[64];
1910 case DT_NULL
: return "NULL";
1911 case DT_NEEDED
: return "NEEDED";
1912 case DT_PLTRELSZ
: return "PLTRELSZ";
1913 case DT_PLTGOT
: return "PLTGOT";
1914 case DT_HASH
: return "HASH";
1915 case DT_STRTAB
: return "STRTAB";
1916 case DT_SYMTAB
: return "SYMTAB";
1917 case DT_RELA
: return "RELA";
1918 case DT_RELASZ
: return "RELASZ";
1919 case DT_RELAENT
: return "RELAENT";
1920 case DT_STRSZ
: return "STRSZ";
1921 case DT_SYMENT
: return "SYMENT";
1922 case DT_INIT
: return "INIT";
1923 case DT_FINI
: return "FINI";
1924 case DT_SONAME
: return "SONAME";
1925 case DT_RPATH
: return "RPATH";
1926 case DT_SYMBOLIC
: return "SYMBOLIC";
1927 case DT_REL
: return "REL";
1928 case DT_RELSZ
: return "RELSZ";
1929 case DT_RELENT
: return "RELENT";
1930 case DT_PLTREL
: return "PLTREL";
1931 case DT_DEBUG
: return "DEBUG";
1932 case DT_TEXTREL
: return "TEXTREL";
1933 case DT_JMPREL
: return "JMPREL";
1934 case DT_BIND_NOW
: return "BIND_NOW";
1935 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1936 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1937 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1938 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1939 case DT_RUNPATH
: return "RUNPATH";
1940 case DT_FLAGS
: return "FLAGS";
1942 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1943 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1945 case DT_CHECKSUM
: return "CHECKSUM";
1946 case DT_PLTPADSZ
: return "PLTPADSZ";
1947 case DT_MOVEENT
: return "MOVEENT";
1948 case DT_MOVESZ
: return "MOVESZ";
1949 case DT_FEATURE
: return "FEATURE";
1950 case DT_POSFLAG_1
: return "POSFLAG_1";
1951 case DT_SYMINSZ
: return "SYMINSZ";
1952 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1954 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1955 case DT_CONFIG
: return "CONFIG";
1956 case DT_DEPAUDIT
: return "DEPAUDIT";
1957 case DT_AUDIT
: return "AUDIT";
1958 case DT_PLTPAD
: return "PLTPAD";
1959 case DT_MOVETAB
: return "MOVETAB";
1960 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1962 case DT_VERSYM
: return "VERSYM";
1964 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
1965 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
1966 case DT_RELACOUNT
: return "RELACOUNT";
1967 case DT_RELCOUNT
: return "RELCOUNT";
1968 case DT_FLAGS_1
: return "FLAGS_1";
1969 case DT_VERDEF
: return "VERDEF";
1970 case DT_VERDEFNUM
: return "VERDEFNUM";
1971 case DT_VERNEED
: return "VERNEED";
1972 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1974 case DT_AUXILIARY
: return "AUXILIARY";
1975 case DT_USED
: return "USED";
1976 case DT_FILTER
: return "FILTER";
1978 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
1979 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
1980 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
1981 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
1982 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
1983 case DT_GNU_HASH
: return "GNU_HASH";
1986 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1988 const char * result
;
1990 switch (elf_header
.e_machine
)
1993 case EM_MIPS_RS3_LE
:
1994 result
= get_mips_dynamic_type (type
);
1997 result
= get_sparc64_dynamic_type (type
);
2000 result
= get_ppc_dynamic_type (type
);
2003 result
= get_ppc64_dynamic_type (type
);
2006 result
= get_ia64_dynamic_type (type
);
2009 result
= get_alpha_dynamic_type (type
);
2012 result
= get_score_dynamic_type (type
);
2015 result
= get_tic6x_dynamic_type (type
);
2017 case EM_ALTERA_NIOS2
:
2018 result
= get_nios2_dynamic_type (type
);
2028 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2030 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2031 || (elf_header
.e_machine
== EM_PARISC
2032 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2034 const char * result
;
2036 switch (elf_header
.e_machine
)
2039 result
= get_parisc_dynamic_type (type
);
2042 result
= get_ia64_dynamic_type (type
);
2052 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2056 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2063 get_file_type (unsigned e_type
)
2065 static char buff
[32];
2069 case ET_NONE
: return _("NONE (None)");
2070 case ET_REL
: return _("REL (Relocatable file)");
2071 case ET_EXEC
: return _("EXEC (Executable file)");
2072 case ET_DYN
: return _("DYN (Shared object file)");
2073 case ET_CORE
: return _("CORE (Core file)");
2076 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2077 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2078 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2079 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2081 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2087 get_machine_name (unsigned e_machine
)
2089 static char buff
[64]; /* XXX */
2093 case EM_NONE
: return _("None");
2094 case EM_AARCH64
: return "AArch64";
2095 case EM_M32
: return "WE32100";
2096 case EM_SPARC
: return "Sparc";
2097 case EM_SPU
: return "SPU";
2098 case EM_386
: return "Intel 80386";
2099 case EM_68K
: return "MC68000";
2100 case EM_88K
: return "MC88000";
2101 case EM_IAMCU
: return "Intel MCU";
2102 case EM_860
: return "Intel 80860";
2103 case EM_MIPS
: return "MIPS R3000";
2104 case EM_S370
: return "IBM System/370";
2105 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2106 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2107 case EM_PARISC
: return "HPPA";
2108 case EM_PPC_OLD
: return "Power PC (old)";
2109 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2110 case EM_960
: return "Intel 90860";
2111 case EM_PPC
: return "PowerPC";
2112 case EM_PPC64
: return "PowerPC64";
2113 case EM_FR20
: return "Fujitsu FR20";
2114 case EM_FT32
: return "FTDI FT32";
2115 case EM_RH32
: return "TRW RH32";
2116 case EM_MCORE
: return "MCORE";
2117 case EM_ARM
: return "ARM";
2118 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2119 case EM_SH
: return "Renesas / SuperH SH";
2120 case EM_SPARCV9
: return "Sparc v9";
2121 case EM_TRICORE
: return "Siemens Tricore";
2122 case EM_ARC
: return "ARC";
2123 case EM_ARC_COMPACT
: return "ARCompact";
2124 case EM_ARC_COMPACT2
: return "ARCv2";
2125 case EM_H8_300
: return "Renesas H8/300";
2126 case EM_H8_300H
: return "Renesas H8/300H";
2127 case EM_H8S
: return "Renesas H8S";
2128 case EM_H8_500
: return "Renesas H8/500";
2129 case EM_IA_64
: return "Intel IA-64";
2130 case EM_MIPS_X
: return "Stanford MIPS-X";
2131 case EM_COLDFIRE
: return "Motorola Coldfire";
2132 case EM_ALPHA
: return "Alpha";
2133 case EM_CYGNUS_D10V
:
2134 case EM_D10V
: return "d10v";
2135 case EM_CYGNUS_D30V
:
2136 case EM_D30V
: return "d30v";
2137 case EM_CYGNUS_M32R
:
2138 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2139 case EM_CYGNUS_V850
:
2140 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2141 case EM_V850
: return "Renesas V850";
2142 case EM_CYGNUS_MN10300
:
2143 case EM_MN10300
: return "mn10300";
2144 case EM_CYGNUS_MN10200
:
2145 case EM_MN10200
: return "mn10200";
2146 case EM_MOXIE
: return "Moxie";
2147 case EM_CYGNUS_FR30
:
2148 case EM_FR30
: return "Fujitsu FR30";
2149 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2151 case EM_PJ
: return "picoJava";
2152 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2153 case EM_PCP
: return "Siemens PCP";
2154 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2155 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2156 case EM_STARCORE
: return "Motorola Star*Core processor";
2157 case EM_ME16
: return "Toyota ME16 processor";
2158 case EM_ST100
: return "STMicroelectronics ST100 processor";
2159 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2160 case EM_PDSP
: return "Sony DSP processor";
2161 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2162 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2163 case EM_FX66
: return "Siemens FX66 microcontroller";
2164 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2165 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2166 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2167 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2168 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2169 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2170 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2171 case EM_SVX
: return "Silicon Graphics SVx";
2172 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2173 case EM_VAX
: return "Digital VAX";
2174 case EM_VISIUM
: return "CDS VISIUMcore processor";
2176 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2177 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2178 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2179 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2180 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2181 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2182 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2183 case EM_PRISM
: return "Vitesse Prism";
2184 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2185 case EM_L1OM
: return "Intel L1OM";
2186 case EM_K1OM
: return "Intel K1OM";
2188 case EM_S390
: return "IBM S/390";
2189 case EM_SCORE
: return "SUNPLUS S+Core";
2190 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2191 case EM_OR1K
: return "OpenRISC 1000";
2192 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2193 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2194 case EM_DLX
: return "OpenDLX";
2196 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2197 case EM_IQ2000
: return "Vitesse IQ2000";
2199 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2200 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2201 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2202 case EM_NS32K
: return "National Semiconductor 32000 series";
2203 case EM_TPC
: return "Tenor Network TPC processor";
2204 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2205 case EM_MAX
: return "MAX Processor";
2206 case EM_CR
: return "National Semiconductor CompactRISC";
2207 case EM_F2MC16
: return "Fujitsu F2MC16";
2208 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2209 case EM_LATTICEMICO32
: return "Lattice Mico32";
2211 case EM_M32C
: return "Renesas M32c";
2212 case EM_MT
: return "Morpho Techologies MT processor";
2213 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2214 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2215 case EM_SEP
: return "Sharp embedded microprocessor";
2216 case EM_ARCA
: return "Arca RISC microprocessor";
2217 case EM_UNICORE
: return "Unicore";
2218 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2219 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2220 case EM_NIOS32
: return "Altera Nios";
2221 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2223 case EM_XC16X
: return "Infineon Technologies xc16x";
2224 case EM_M16C
: return "Renesas M16C series microprocessors";
2225 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2226 case EM_CE
: return "Freescale Communication Engine RISC core";
2227 case EM_TSK3000
: return "Altium TSK3000 core";
2228 case EM_RS08
: return "Freescale RS08 embedded processor";
2229 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2230 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2231 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2232 case EM_SE_C17
: return "Seiko Epson C17 family";
2233 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2234 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2235 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2236 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2237 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2238 case EM_R32C
: return "Renesas R32C series microprocessors";
2239 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2240 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2241 case EM_8051
: return "Intel 8051 and variants";
2242 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2243 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2244 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2245 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2246 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2247 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2248 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2249 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2252 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2253 case EM_RL78
: return "Renesas RL78";
2254 case EM_RX
: return "Renesas RX";
2255 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2256 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2257 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2258 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2259 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2260 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor family";
2261 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2262 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2263 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2264 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2265 case EM_CUDA
: return "NVIDIA CUDA architecture";
2266 case EM_XGATE
: return "Motorola XGATE embedded processor";
2268 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2274 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2279 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2280 e_flags
&= ~ EF_ARM_EABIMASK
;
2282 /* Handle "generic" ARM flags. */
2283 if (e_flags
& EF_ARM_RELEXEC
)
2285 strcat (buf
, ", relocatable executable");
2286 e_flags
&= ~ EF_ARM_RELEXEC
;
2289 /* Now handle EABI specific flags. */
2293 strcat (buf
, ", <unrecognized EABI>");
2298 case EF_ARM_EABI_VER1
:
2299 strcat (buf
, ", Version1 EABI");
2304 /* Process flags one bit at a time. */
2305 flag
= e_flags
& - e_flags
;
2310 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2311 strcat (buf
, ", sorted symbol tables");
2321 case EF_ARM_EABI_VER2
:
2322 strcat (buf
, ", Version2 EABI");
2327 /* Process flags one bit at a time. */
2328 flag
= e_flags
& - e_flags
;
2333 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2334 strcat (buf
, ", sorted symbol tables");
2337 case EF_ARM_DYNSYMSUSESEGIDX
:
2338 strcat (buf
, ", dynamic symbols use segment index");
2341 case EF_ARM_MAPSYMSFIRST
:
2342 strcat (buf
, ", mapping symbols precede others");
2352 case EF_ARM_EABI_VER3
:
2353 strcat (buf
, ", Version3 EABI");
2356 case EF_ARM_EABI_VER4
:
2357 strcat (buf
, ", Version4 EABI");
2362 /* Process flags one bit at a time. */
2363 flag
= e_flags
& - e_flags
;
2369 strcat (buf
, ", BE8");
2373 strcat (buf
, ", LE8");
2384 case EF_ARM_EABI_VER5
:
2385 strcat (buf
, ", Version5 EABI");
2390 /* Process flags one bit at a time. */
2391 flag
= e_flags
& - e_flags
;
2397 strcat (buf
, ", BE8");
2401 strcat (buf
, ", LE8");
2404 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2405 strcat (buf
, ", soft-float ABI");
2408 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2409 strcat (buf
, ", hard-float ABI");
2419 case EF_ARM_EABI_UNKNOWN
:
2420 strcat (buf
, ", GNU EABI");
2425 /* Process flags one bit at a time. */
2426 flag
= e_flags
& - e_flags
;
2431 case EF_ARM_INTERWORK
:
2432 strcat (buf
, ", interworking enabled");
2435 case EF_ARM_APCS_26
:
2436 strcat (buf
, ", uses APCS/26");
2439 case EF_ARM_APCS_FLOAT
:
2440 strcat (buf
, ", uses APCS/float");
2444 strcat (buf
, ", position independent");
2448 strcat (buf
, ", 8 bit structure alignment");
2451 case EF_ARM_NEW_ABI
:
2452 strcat (buf
, ", uses new ABI");
2455 case EF_ARM_OLD_ABI
:
2456 strcat (buf
, ", uses old ABI");
2459 case EF_ARM_SOFT_FLOAT
:
2460 strcat (buf
, ", software FP");
2463 case EF_ARM_VFP_FLOAT
:
2464 strcat (buf
, ", VFP");
2467 case EF_ARM_MAVERICK_FLOAT
:
2468 strcat (buf
, ", Maverick FP");
2479 strcat (buf
,_(", <unknown>"));
2483 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2485 --size
; /* Leave space for null terminator. */
2487 switch (e_flags
& EF_AVR_MACH
)
2489 case E_AVR_MACH_AVR1
:
2490 strncat (buf
, ", avr:1", size
);
2492 case E_AVR_MACH_AVR2
:
2493 strncat (buf
, ", avr:2", size
);
2495 case E_AVR_MACH_AVR25
:
2496 strncat (buf
, ", avr:25", size
);
2498 case E_AVR_MACH_AVR3
:
2499 strncat (buf
, ", avr:3", size
);
2501 case E_AVR_MACH_AVR31
:
2502 strncat (buf
, ", avr:31", size
);
2504 case E_AVR_MACH_AVR35
:
2505 strncat (buf
, ", avr:35", size
);
2507 case E_AVR_MACH_AVR4
:
2508 strncat (buf
, ", avr:4", size
);
2510 case E_AVR_MACH_AVR5
:
2511 strncat (buf
, ", avr:5", size
);
2513 case E_AVR_MACH_AVR51
:
2514 strncat (buf
, ", avr:51", size
);
2516 case E_AVR_MACH_AVR6
:
2517 strncat (buf
, ", avr:6", size
);
2519 case E_AVR_MACH_AVRTINY
:
2520 strncat (buf
, ", avr:100", size
);
2522 case E_AVR_MACH_XMEGA1
:
2523 strncat (buf
, ", avr:101", size
);
2525 case E_AVR_MACH_XMEGA2
:
2526 strncat (buf
, ", avr:102", size
);
2528 case E_AVR_MACH_XMEGA3
:
2529 strncat (buf
, ", avr:103", size
);
2531 case E_AVR_MACH_XMEGA4
:
2532 strncat (buf
, ", avr:104", size
);
2534 case E_AVR_MACH_XMEGA5
:
2535 strncat (buf
, ", avr:105", size
);
2537 case E_AVR_MACH_XMEGA6
:
2538 strncat (buf
, ", avr:106", size
);
2540 case E_AVR_MACH_XMEGA7
:
2541 strncat (buf
, ", avr:107", size
);
2544 strncat (buf
, ", avr:<unknown>", size
);
2548 size
-= strlen (buf
);
2549 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2550 strncat (buf
, ", link-relax", size
);
2554 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2563 static const char *ABI_STRINGS
[] =
2565 "ABI v0", /* use r5 as return register; only used in N1213HC */
2566 "ABI v1", /* use r0 as return register */
2567 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2568 "ABI v2fp", /* for FPU */
2572 static const char *VER_STRINGS
[] =
2574 "Andes ELF V1.3 or older",
2578 static const char *ARCH_STRINGS
[] =
2587 abi
= EF_NDS_ABI
& e_flags
;
2588 arch
= EF_NDS_ARCH
& e_flags
;
2589 config
= EF_NDS_INST
& e_flags
;
2590 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2592 memset (buf
, 0, size
);
2599 case E_NDS_ABI_V2FP
:
2600 case E_NDS_ABI_AABI
:
2601 case E_NDS_ABI_V2FP_PLUS
:
2602 /* In case there are holes in the array. */
2603 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2607 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2613 case E_NDS32_ELF_VER_1_2
:
2614 case E_NDS32_ELF_VER_1_3
:
2615 case E_NDS32_ELF_VER_1_4
:
2616 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2620 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2624 if (E_NDS_ABI_V0
== abi
)
2626 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2627 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2628 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2629 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2635 case E_NDS_ARCH_STAR_V1_0
:
2636 case E_NDS_ARCH_STAR_V2_0
:
2637 case E_NDS_ARCH_STAR_V3_0
:
2638 case E_NDS_ARCH_STAR_V3_M
:
2639 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2643 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2644 /* ARCH version determines how the e_flags are interpreted.
2645 If it is unknown, we cannot proceed. */
2649 /* Newer ABI; Now handle architecture specific flags. */
2650 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2652 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2653 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2655 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2656 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2658 if (config
& E_NDS32_HAS_DIV_INST
)
2659 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2661 if (config
& E_NDS32_HAS_16BIT_INST
)
2662 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2666 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2668 if (version
<= E_NDS32_ELF_VER_1_3
)
2669 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2671 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2674 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2675 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2677 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2678 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2680 if (config
& E_NDS32_HAS_16BIT_INST
)
2682 if (version
<= E_NDS32_ELF_VER_1_3
)
2683 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2685 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2689 if (config
& E_NDS32_HAS_EXT_INST
)
2690 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2692 if (config
& E_NDS32_HAS_EXT2_INST
)
2693 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2695 if (config
& E_NDS32_HAS_FPU_INST
)
2698 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2701 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2704 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2707 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2710 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2715 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2717 case E_NDS32_FPU_REG_8SP_4DP
:
2718 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2720 case E_NDS32_FPU_REG_16SP_8DP
:
2721 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2723 case E_NDS32_FPU_REG_32SP_16DP
:
2724 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2726 case E_NDS32_FPU_REG_32SP_32DP
:
2727 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2732 if (config
& E_NDS32_HAS_AUDIO_INST
)
2733 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2735 if (config
& E_NDS32_HAS_STRING_INST
)
2736 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2738 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2739 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2741 if (config
& E_NDS32_HAS_VIDEO_INST
)
2743 if (version
<= E_NDS32_ELF_VER_1_3
)
2744 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2746 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2749 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2750 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2752 if (config
& E_NDS32_HAS_L2C_INST
)
2753 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
2757 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
2759 static char buf
[1024];
2770 case EM_ARC_COMPACT2
:
2771 switch (e_flags
& EF_ARC_MACH_MSK
)
2773 case EF_ARC_CPU_ARCV2EM
:
2774 strcat (buf
, ", ARC EM");
2776 case EF_ARC_CPU_ARCV2HS
:
2777 strcat (buf
, ", ARC HS");
2779 case EF_ARC_CPU_GENERIC
:
2780 strcat (buf
, ", ARC generic");
2782 case E_ARC_MACH_ARC600
:
2783 strcat (buf
, ", ARC600");
2785 case E_ARC_MACH_ARC601
:
2786 strcat (buf
, ", ARC601");
2788 case E_ARC_MACH_ARC700
:
2789 strcat (buf
, ", ARC700");
2792 strcat (buf
, ", unrecognized cpu flag for ARCv2");
2795 switch (e_flags
& EF_ARC_OSABI_MSK
)
2797 case E_ARC_OSABI_ORIG
:
2798 strcat (buf
, ", (ABI:legacy)");
2800 case E_ARC_OSABI_V2
:
2801 strcat (buf
, ", (ABI:v2)");
2803 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2804 case E_ARC_OSABI_V3
:
2805 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2808 strcat (buf
, ", unrecognised ARC OSABI flag");
2813 case EM_ARC_COMPACT
:
2814 switch (e_flags
& EF_ARC_MACH_MSK
)
2816 case E_ARC_MACH_ARC600
:
2817 strcat (buf
, ", ARC 600");
2819 case E_ARC_MACH_ARC601
:
2820 strcat (buf
, ", ARC 601");
2822 case E_ARC_MACH_ARC700
:
2823 strcat (buf
, ", ARC 700");
2826 strcat (buf
, ", Generic ARCompact");
2829 switch (e_flags
& EF_ARC_OSABI_MSK
)
2831 case E_ARC_OSABI_ORIG
:
2832 strcat (buf
, ", legacy syscall ABI");
2834 case E_ARC_OSABI_V2
:
2835 /* For 3.2+ Linux kernels which use asm-generic
2837 strcat (buf
, ", v2 syscall ABI");
2839 case E_ARC_OSABI_V3
:
2840 /* Upstream 3.9+ kernels which don't use any legacy
2842 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2848 decode_ARM_machine_flags (e_flags
, buf
);
2852 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2856 if (e_flags
& EF_BFIN_PIC
)
2857 strcat (buf
, ", PIC");
2859 if (e_flags
& EF_BFIN_FDPIC
)
2860 strcat (buf
, ", FDPIC");
2862 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2863 strcat (buf
, ", code in L1");
2865 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2866 strcat (buf
, ", data in L1");
2871 switch (e_flags
& EF_FRV_CPU_MASK
)
2873 case EF_FRV_CPU_GENERIC
:
2877 strcat (buf
, ", fr???");
2880 case EF_FRV_CPU_FR300
:
2881 strcat (buf
, ", fr300");
2884 case EF_FRV_CPU_FR400
:
2885 strcat (buf
, ", fr400");
2887 case EF_FRV_CPU_FR405
:
2888 strcat (buf
, ", fr405");
2891 case EF_FRV_CPU_FR450
:
2892 strcat (buf
, ", fr450");
2895 case EF_FRV_CPU_FR500
:
2896 strcat (buf
, ", fr500");
2898 case EF_FRV_CPU_FR550
:
2899 strcat (buf
, ", fr550");
2902 case EF_FRV_CPU_SIMPLE
:
2903 strcat (buf
, ", simple");
2905 case EF_FRV_CPU_TOMCAT
:
2906 strcat (buf
, ", tomcat");
2912 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2913 strcat (buf
, ", m68000");
2914 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2915 strcat (buf
, ", cpu32");
2916 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2917 strcat (buf
, ", fido_a");
2920 char const * isa
= _("unknown");
2921 char const * mac
= _("unknown mac");
2922 char const * additional
= NULL
;
2924 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2926 case EF_M68K_CF_ISA_A_NODIV
:
2928 additional
= ", nodiv";
2930 case EF_M68K_CF_ISA_A
:
2933 case EF_M68K_CF_ISA_A_PLUS
:
2936 case EF_M68K_CF_ISA_B_NOUSP
:
2938 additional
= ", nousp";
2940 case EF_M68K_CF_ISA_B
:
2943 case EF_M68K_CF_ISA_C
:
2946 case EF_M68K_CF_ISA_C_NODIV
:
2948 additional
= ", nodiv";
2951 strcat (buf
, ", cf, isa ");
2954 strcat (buf
, additional
);
2955 if (e_flags
& EF_M68K_CF_FLOAT
)
2956 strcat (buf
, ", float");
2957 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2962 case EF_M68K_CF_MAC
:
2965 case EF_M68K_CF_EMAC
:
2968 case EF_M68K_CF_EMAC_B
:
2981 switch (e_flags
& EF_MEP_CPU_MASK
)
2983 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
2984 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
2985 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
2986 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
2987 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
2988 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
2989 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
2992 switch (e_flags
& EF_MEP_COP_MASK
)
2994 case EF_MEP_COP_NONE
: break;
2995 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
2996 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
2997 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
2998 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
2999 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3002 if (e_flags
& EF_MEP_LIBRARY
)
3003 strcat (buf
, ", Built for Library");
3005 if (e_flags
& EF_MEP_INDEX_MASK
)
3006 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3007 e_flags
& EF_MEP_INDEX_MASK
);
3009 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3010 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3011 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3015 if (e_flags
& EF_PPC_EMB
)
3016 strcat (buf
, ", emb");
3018 if (e_flags
& EF_PPC_RELOCATABLE
)
3019 strcat (buf
, _(", relocatable"));
3021 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3022 strcat (buf
, _(", relocatable-lib"));
3026 if (e_flags
& EF_PPC64_ABI
)
3028 char abi
[] = ", abiv0";
3030 abi
[6] += e_flags
& EF_PPC64_ABI
;
3036 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3037 strcat (buf
, ", RH850 ABI");
3039 if (e_flags
& EF_V800_850E3
)
3040 strcat (buf
, ", V3 architecture");
3042 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3043 strcat (buf
, ", FPU not used");
3045 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3046 strcat (buf
, ", regmode: COMMON");
3048 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3049 strcat (buf
, ", r4 not used");
3051 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3052 strcat (buf
, ", r30 not used");
3054 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3055 strcat (buf
, ", r5 not used");
3057 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3058 strcat (buf
, ", r2 not used");
3060 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3062 switch (e_flags
& - e_flags
)
3064 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3065 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3066 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3067 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3068 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3069 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3070 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3071 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3072 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3073 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3074 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3075 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3082 case EM_CYGNUS_V850
:
3083 switch (e_flags
& EF_V850_ARCH
)
3085 case E_V850E3V5_ARCH
:
3086 strcat (buf
, ", v850e3v5");
3088 case E_V850E2V3_ARCH
:
3089 strcat (buf
, ", v850e2v3");
3092 strcat (buf
, ", v850e2");
3095 strcat (buf
, ", v850e1");
3098 strcat (buf
, ", v850e");
3101 strcat (buf
, ", v850");
3104 strcat (buf
, _(", unknown v850 architecture variant"));
3110 case EM_CYGNUS_M32R
:
3111 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3112 strcat (buf
, ", m32r");
3116 case EM_MIPS_RS3_LE
:
3117 if (e_flags
& EF_MIPS_NOREORDER
)
3118 strcat (buf
, ", noreorder");
3120 if (e_flags
& EF_MIPS_PIC
)
3121 strcat (buf
, ", pic");
3123 if (e_flags
& EF_MIPS_CPIC
)
3124 strcat (buf
, ", cpic");
3126 if (e_flags
& EF_MIPS_UCODE
)
3127 strcat (buf
, ", ugen_reserved");
3129 if (e_flags
& EF_MIPS_ABI2
)
3130 strcat (buf
, ", abi2");
3132 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3133 strcat (buf
, ", odk first");
3135 if (e_flags
& EF_MIPS_32BITMODE
)
3136 strcat (buf
, ", 32bitmode");
3138 if (e_flags
& EF_MIPS_NAN2008
)
3139 strcat (buf
, ", nan2008");
3141 if (e_flags
& EF_MIPS_FP64
)
3142 strcat (buf
, ", fp64");
3144 switch ((e_flags
& EF_MIPS_MACH
))
3146 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3147 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3148 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3149 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3150 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3151 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3152 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3153 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3154 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3155 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3156 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3157 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3158 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3159 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3160 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3161 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3162 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3164 /* We simply ignore the field in this case to avoid confusion:
3165 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3168 default: strcat (buf
, _(", unknown CPU")); break;
3171 switch ((e_flags
& EF_MIPS_ABI
))
3173 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3174 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3175 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3176 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3178 /* We simply ignore the field in this case to avoid confusion:
3179 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3180 This means it is likely to be an o32 file, but not for
3183 default: strcat (buf
, _(", unknown ABI")); break;
3186 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3187 strcat (buf
, ", mdmx");
3189 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3190 strcat (buf
, ", mips16");
3192 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3193 strcat (buf
, ", micromips");
3195 switch ((e_flags
& EF_MIPS_ARCH
))
3197 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3198 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3199 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3200 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3201 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3202 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3203 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3204 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3205 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3206 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3207 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3208 default: strcat (buf
, _(", unknown ISA")); break;
3213 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3217 switch ((e_flags
& EF_SH_MACH_MASK
))
3219 case EF_SH1
: strcat (buf
, ", sh1"); break;
3220 case EF_SH2
: strcat (buf
, ", sh2"); break;
3221 case EF_SH3
: strcat (buf
, ", sh3"); break;
3222 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3223 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3224 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3225 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3226 case EF_SH4
: strcat (buf
, ", sh4"); break;
3227 case EF_SH5
: strcat (buf
, ", sh5"); break;
3228 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3229 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3230 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3231 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3232 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3233 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3234 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3235 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3236 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3237 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3238 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3239 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3240 default: strcat (buf
, _(", unknown ISA")); break;
3243 if (e_flags
& EF_SH_PIC
)
3244 strcat (buf
, ", pic");
3246 if (e_flags
& EF_SH_FDPIC
)
3247 strcat (buf
, ", fdpic");
3251 if (e_flags
& EF_OR1K_NODELAY
)
3252 strcat (buf
, ", no delay");
3256 if (e_flags
& EF_SPARC_32PLUS
)
3257 strcat (buf
, ", v8+");
3259 if (e_flags
& EF_SPARC_SUN_US1
)
3260 strcat (buf
, ", ultrasparcI");
3262 if (e_flags
& EF_SPARC_SUN_US3
)
3263 strcat (buf
, ", ultrasparcIII");
3265 if (e_flags
& EF_SPARC_HAL_R1
)
3266 strcat (buf
, ", halr1");
3268 if (e_flags
& EF_SPARC_LEDATA
)
3269 strcat (buf
, ", ledata");
3271 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3272 strcat (buf
, ", tso");
3274 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3275 strcat (buf
, ", pso");
3277 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3278 strcat (buf
, ", rmo");
3282 switch (e_flags
& EF_PARISC_ARCH
)
3284 case EFA_PARISC_1_0
:
3285 strcpy (buf
, ", PA-RISC 1.0");
3287 case EFA_PARISC_1_1
:
3288 strcpy (buf
, ", PA-RISC 1.1");
3290 case EFA_PARISC_2_0
:
3291 strcpy (buf
, ", PA-RISC 2.0");
3296 if (e_flags
& EF_PARISC_TRAPNIL
)
3297 strcat (buf
, ", trapnil");
3298 if (e_flags
& EF_PARISC_EXT
)
3299 strcat (buf
, ", ext");
3300 if (e_flags
& EF_PARISC_LSB
)
3301 strcat (buf
, ", lsb");
3302 if (e_flags
& EF_PARISC_WIDE
)
3303 strcat (buf
, ", wide");
3304 if (e_flags
& EF_PARISC_NO_KABP
)
3305 strcat (buf
, ", no kabp");
3306 if (e_flags
& EF_PARISC_LAZYSWAP
)
3307 strcat (buf
, ", lazyswap");
3312 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3313 strcat (buf
, ", new calling convention");
3315 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3316 strcat (buf
, ", gnu calling convention");
3320 if ((e_flags
& EF_IA_64_ABI64
))
3321 strcat (buf
, ", 64-bit");
3323 strcat (buf
, ", 32-bit");
3324 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3325 strcat (buf
, ", reduced fp model");
3326 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3327 strcat (buf
, ", no function descriptors, constant gp");
3328 else if ((e_flags
& EF_IA_64_CONS_GP
))
3329 strcat (buf
, ", constant gp");
3330 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3331 strcat (buf
, ", absolute");
3332 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3334 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3335 strcat (buf
, ", vms_linkages");
3336 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3338 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3340 case EF_IA_64_VMS_COMCOD_WARNING
:
3341 strcat (buf
, ", warning");
3343 case EF_IA_64_VMS_COMCOD_ERROR
:
3344 strcat (buf
, ", error");
3346 case EF_IA_64_VMS_COMCOD_ABORT
:
3347 strcat (buf
, ", abort");
3350 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3351 e_flags
& EF_IA_64_VMS_COMCOD
);
3352 strcat (buf
, ", <unknown>");
3358 if ((e_flags
& EF_VAX_NONPIC
))
3359 strcat (buf
, ", non-PIC");
3360 if ((e_flags
& EF_VAX_DFLOAT
))
3361 strcat (buf
, ", D-Float");
3362 if ((e_flags
& EF_VAX_GFLOAT
))
3363 strcat (buf
, ", G-Float");
3367 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3368 strcat (buf
, ", mcm");
3369 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3370 strcat (buf
, ", mcm24");
3371 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3372 strcat (buf
, ", gr6");
3376 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3378 case E_FLAG_RL78_ANY_CPU
: break;
3379 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3380 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3381 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3383 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3384 strcat (buf
, ", 64-bit doubles");
3388 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3389 strcat (buf
, ", 64-bit doubles");
3390 if (e_flags
& E_FLAG_RX_DSP
)
3391 strcat (buf
, ", dsp");
3392 if (e_flags
& E_FLAG_RX_PID
)
3393 strcat (buf
, ", pid");
3394 if (e_flags
& E_FLAG_RX_ABI
)
3395 strcat (buf
, ", RX ABI");
3396 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3397 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3398 ? ", uses String instructions" : ", bans String instructions");
3399 if (e_flags
& E_FLAG_RX_V2
)
3400 strcat (buf
, ", V2");
3404 if (e_flags
& EF_S390_HIGH_GPRS
)
3405 strcat (buf
, ", highgprs");
3409 if ((e_flags
& EF_C6000_REL
))
3410 strcat (buf
, ", relocatable module");
3414 strcat (buf
, _(": architecture variant: "));
3415 switch (e_flags
& EF_MSP430_MACH
)
3417 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3418 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3419 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3420 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3421 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3422 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3423 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3424 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3425 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3426 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3427 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3428 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3429 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3430 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3431 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3433 strcat (buf
, _(": unknown")); break;
3436 if (e_flags
& ~ EF_MSP430_MACH
)
3437 strcat (buf
, _(": unknown extra flag bits also present"));
3445 get_osabi_name (unsigned int osabi
)
3447 static char buff
[32];
3451 case ELFOSABI_NONE
: return "UNIX - System V";
3452 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3453 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3454 case ELFOSABI_GNU
: return "UNIX - GNU";
3455 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3456 case ELFOSABI_AIX
: return "UNIX - AIX";
3457 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3458 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3459 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3460 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3461 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3462 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3463 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3464 case ELFOSABI_AROS
: return "AROS";
3465 case ELFOSABI_FENIXOS
: return "FenixOS";
3468 switch (elf_header
.e_machine
)
3473 case ELFOSABI_ARM
: return "ARM";
3484 case ELFOSABI_STANDALONE
: return _("Standalone App");
3493 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3494 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3503 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3509 get_aarch64_segment_type (unsigned long type
)
3513 case PT_AARCH64_ARCHEXT
:
3514 return "AARCH64_ARCHEXT";
3523 get_arm_segment_type (unsigned long type
)
3537 get_mips_segment_type (unsigned long type
)
3541 case PT_MIPS_REGINFO
:
3543 case PT_MIPS_RTPROC
:
3545 case PT_MIPS_OPTIONS
:
3547 case PT_MIPS_ABIFLAGS
:
3557 get_parisc_segment_type (unsigned long type
)
3561 case PT_HP_TLS
: return "HP_TLS";
3562 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3563 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3564 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3565 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3566 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3567 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3568 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3569 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3570 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3571 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3572 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3573 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3574 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3575 case PT_HP_STACK
: return "HP_STACK";
3576 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3577 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3578 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3579 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3588 get_ia64_segment_type (unsigned long type
)
3592 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3593 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3594 case PT_HP_TLS
: return "HP_TLS";
3595 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3596 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3597 case PT_IA_64_HP_STACK
: return "HP_STACK";
3606 get_tic6x_segment_type (unsigned long type
)
3610 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3619 get_segment_type (unsigned long p_type
)
3621 static char buff
[32];
3625 case PT_NULL
: return "NULL";
3626 case PT_LOAD
: return "LOAD";
3627 case PT_DYNAMIC
: return "DYNAMIC";
3628 case PT_INTERP
: return "INTERP";
3629 case PT_NOTE
: return "NOTE";
3630 case PT_SHLIB
: return "SHLIB";
3631 case PT_PHDR
: return "PHDR";
3632 case PT_TLS
: return "TLS";
3634 case PT_GNU_EH_FRAME
:
3635 return "GNU_EH_FRAME";
3636 case PT_GNU_STACK
: return "GNU_STACK";
3637 case PT_GNU_RELRO
: return "GNU_RELRO";
3640 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3642 const char * result
;
3644 switch (elf_header
.e_machine
)
3647 result
= get_aarch64_segment_type (p_type
);
3650 result
= get_arm_segment_type (p_type
);
3653 case EM_MIPS_RS3_LE
:
3654 result
= get_mips_segment_type (p_type
);
3657 result
= get_parisc_segment_type (p_type
);
3660 result
= get_ia64_segment_type (p_type
);
3663 result
= get_tic6x_segment_type (p_type
);
3673 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3675 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3677 const char * result
;
3679 switch (elf_header
.e_machine
)
3682 result
= get_parisc_segment_type (p_type
);
3685 result
= get_ia64_segment_type (p_type
);
3695 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3698 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3705 get_mips_section_type_name (unsigned int sh_type
)
3709 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3710 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3711 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3712 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3713 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3714 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3715 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3716 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3717 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3718 case SHT_MIPS_RELD
: return "MIPS_RELD";
3719 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3720 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3721 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3722 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3723 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3724 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3725 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3726 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3727 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3728 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3729 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3730 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3731 case SHT_MIPS_LINE
: return "MIPS_LINE";
3732 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3733 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3734 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3735 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3736 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3737 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3738 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3739 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3740 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3741 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3742 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3743 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3744 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3745 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3746 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3747 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3748 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3756 get_parisc_section_type_name (unsigned int sh_type
)
3760 case SHT_PARISC_EXT
: return "PARISC_EXT";
3761 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3762 case SHT_PARISC_DOC
: return "PARISC_DOC";
3763 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3764 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3765 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3766 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3774 get_ia64_section_type_name (unsigned int sh_type
)
3776 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3777 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3778 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3782 case SHT_IA_64_EXT
: return "IA_64_EXT";
3783 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3784 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3785 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3786 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3787 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3788 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3789 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3790 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3791 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3799 get_x86_64_section_type_name (unsigned int sh_type
)
3803 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3811 get_aarch64_section_type_name (unsigned int sh_type
)
3815 case SHT_AARCH64_ATTRIBUTES
:
3816 return "AARCH64_ATTRIBUTES";
3824 get_arm_section_type_name (unsigned int sh_type
)
3828 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3829 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3830 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3831 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3832 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3840 get_tic6x_section_type_name (unsigned int sh_type
)
3844 case SHT_C6000_UNWIND
:
3845 return "C6000_UNWIND";
3846 case SHT_C6000_PREEMPTMAP
:
3847 return "C6000_PREEMPTMAP";
3848 case SHT_C6000_ATTRIBUTES
:
3849 return "C6000_ATTRIBUTES";
3854 case SHT_TI_HANDLER
:
3855 return "TI_HANDLER";
3856 case SHT_TI_INITINFO
:
3857 return "TI_INITINFO";
3858 case SHT_TI_PHATTRS
:
3859 return "TI_PHATTRS";
3867 get_msp430x_section_type_name (unsigned int sh_type
)
3871 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3872 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3873 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3874 default: return NULL
;
3879 get_v850_section_type_name (unsigned int sh_type
)
3883 case SHT_V850_SCOMMON
: return "V850 Small Common";
3884 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3885 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3886 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3887 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3888 default: return NULL
;
3893 get_section_type_name (unsigned int sh_type
)
3895 static char buff
[32];
3899 case SHT_NULL
: return "NULL";
3900 case SHT_PROGBITS
: return "PROGBITS";
3901 case SHT_SYMTAB
: return "SYMTAB";
3902 case SHT_STRTAB
: return "STRTAB";
3903 case SHT_RELA
: return "RELA";
3904 case SHT_HASH
: return "HASH";
3905 case SHT_DYNAMIC
: return "DYNAMIC";
3906 case SHT_NOTE
: return "NOTE";
3907 case SHT_NOBITS
: return "NOBITS";
3908 case SHT_REL
: return "REL";
3909 case SHT_SHLIB
: return "SHLIB";
3910 case SHT_DYNSYM
: return "DYNSYM";
3911 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3912 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3913 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3914 case SHT_GNU_HASH
: return "GNU_HASH";
3915 case SHT_GROUP
: return "GROUP";
3916 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3917 case SHT_GNU_verdef
: return "VERDEF";
3918 case SHT_GNU_verneed
: return "VERNEED";
3919 case SHT_GNU_versym
: return "VERSYM";
3920 case 0x6ffffff0: return "VERSYM";
3921 case 0x6ffffffc: return "VERDEF";
3922 case 0x7ffffffd: return "AUXILIARY";
3923 case 0x7fffffff: return "FILTER";
3924 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3927 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3929 const char * result
;
3931 switch (elf_header
.e_machine
)
3934 case EM_MIPS_RS3_LE
:
3935 result
= get_mips_section_type_name (sh_type
);
3938 result
= get_parisc_section_type_name (sh_type
);
3941 result
= get_ia64_section_type_name (sh_type
);
3946 result
= get_x86_64_section_type_name (sh_type
);
3949 result
= get_aarch64_section_type_name (sh_type
);
3952 result
= get_arm_section_type_name (sh_type
);
3955 result
= get_tic6x_section_type_name (sh_type
);
3958 result
= get_msp430x_section_type_name (sh_type
);
3962 case EM_CYGNUS_V850
:
3963 result
= get_v850_section_type_name (sh_type
);
3973 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3975 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3977 const char * result
;
3979 switch (elf_header
.e_machine
)
3982 result
= get_ia64_section_type_name (sh_type
);
3992 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3994 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3996 switch (elf_header
.e_machine
)
4000 case EM_CYGNUS_V850
:
4001 return get_v850_section_type_name (sh_type
);
4006 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
4009 /* This message is probably going to be displayed in a 15
4010 character wide field, so put the hex value first. */
4011 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4017 #define OPTION_DEBUG_DUMP 512
4018 #define OPTION_DYN_SYMS 513
4019 #define OPTION_DWARF_DEPTH 514
4020 #define OPTION_DWARF_START 515
4021 #define OPTION_DWARF_CHECK 516
4023 static struct option options
[] =
4025 {"all", no_argument
, 0, 'a'},
4026 {"file-header", no_argument
, 0, 'h'},
4027 {"program-headers", no_argument
, 0, 'l'},
4028 {"headers", no_argument
, 0, 'e'},
4029 {"histogram", no_argument
, 0, 'I'},
4030 {"segments", no_argument
, 0, 'l'},
4031 {"sections", no_argument
, 0, 'S'},
4032 {"section-headers", no_argument
, 0, 'S'},
4033 {"section-groups", no_argument
, 0, 'g'},
4034 {"section-details", no_argument
, 0, 't'},
4035 {"full-section-name",no_argument
, 0, 'N'},
4036 {"symbols", no_argument
, 0, 's'},
4037 {"syms", no_argument
, 0, 's'},
4038 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4039 {"relocs", no_argument
, 0, 'r'},
4040 {"notes", no_argument
, 0, 'n'},
4041 {"dynamic", no_argument
, 0, 'd'},
4042 {"arch-specific", no_argument
, 0, 'A'},
4043 {"version-info", no_argument
, 0, 'V'},
4044 {"use-dynamic", no_argument
, 0, 'D'},
4045 {"unwind", no_argument
, 0, 'u'},
4046 {"archive-index", no_argument
, 0, 'c'},
4047 {"hex-dump", required_argument
, 0, 'x'},
4048 {"relocated-dump", required_argument
, 0, 'R'},
4049 {"string-dump", required_argument
, 0, 'p'},
4050 {"decompress", no_argument
, 0, 'z'},
4051 #ifdef SUPPORT_DISASSEMBLY
4052 {"instruction-dump", required_argument
, 0, 'i'},
4054 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4056 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4057 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4058 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4060 {"version", no_argument
, 0, 'v'},
4061 {"wide", no_argument
, 0, 'W'},
4062 {"help", no_argument
, 0, 'H'},
4063 {0, no_argument
, 0, 0}
4067 usage (FILE * stream
)
4069 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4070 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4071 fprintf (stream
, _(" Options are:\n\
4072 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4073 -h --file-header Display the ELF file header\n\
4074 -l --program-headers Display the program headers\n\
4075 --segments An alias for --program-headers\n\
4076 -S --section-headers Display the sections' header\n\
4077 --sections An alias for --section-headers\n\
4078 -g --section-groups Display the section groups\n\
4079 -t --section-details Display the section details\n\
4080 -e --headers Equivalent to: -h -l -S\n\
4081 -s --syms Display the symbol table\n\
4082 --symbols An alias for --syms\n\
4083 --dyn-syms Display the dynamic symbol table\n\
4084 -n --notes Display the core notes (if present)\n\
4085 -r --relocs Display the relocations (if present)\n\
4086 -u --unwind Display the unwind info (if present)\n\
4087 -d --dynamic Display the dynamic section (if present)\n\
4088 -V --version-info Display the version sections (if present)\n\
4089 -A --arch-specific Display architecture specific information (if any)\n\
4090 -c --archive-index Display the symbol/file index in an archive\n\
4091 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4092 -x --hex-dump=<number|name>\n\
4093 Dump the contents of section <number|name> as bytes\n\
4094 -p --string-dump=<number|name>\n\
4095 Dump the contents of section <number|name> as strings\n\
4096 -R --relocated-dump=<number|name>\n\
4097 Dump the contents of section <number|name> as relocated bytes\n\
4098 -z --decompress Decompress section before dumping it\n\
4099 -w[lLiaprmfFsoRt] or\n\
4100 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4101 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4102 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4104 Display the contents of DWARF2 debug sections\n"));
4105 fprintf (stream
, _("\
4106 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4107 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4109 #ifdef SUPPORT_DISASSEMBLY
4110 fprintf (stream
, _("\
4111 -i --instruction-dump=<number|name>\n\
4112 Disassemble the contents of section <number|name>\n"));
4114 fprintf (stream
, _("\
4115 -I --histogram Display histogram of bucket list lengths\n\
4116 -W --wide Allow output width to exceed 80 characters\n\
4117 @<file> Read options from <file>\n\
4118 -H --help Display this information\n\
4119 -v --version Display the version number of readelf\n"));
4121 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4122 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4124 exit (stream
== stdout
? 0 : 1);
4127 /* Record the fact that the user wants the contents of section number
4128 SECTION to be displayed using the method(s) encoded as flags bits
4129 in TYPE. Note, TYPE can be zero if we are creating the array for
4133 request_dump_bynumber (unsigned int section
, dump_type type
)
4135 if (section
>= num_dump_sects
)
4137 dump_type
* new_dump_sects
;
4139 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4140 sizeof (* dump_sects
));
4142 if (new_dump_sects
== NULL
)
4143 error (_("Out of memory allocating dump request table.\n"));
4146 /* Copy current flag settings. */
4147 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4151 dump_sects
= new_dump_sects
;
4152 num_dump_sects
= section
+ 1;
4157 dump_sects
[section
] |= type
;
4162 /* Request a dump by section name. */
4165 request_dump_byname (const char * section
, dump_type type
)
4167 struct dump_list_entry
* new_request
;
4169 new_request
= (struct dump_list_entry
*)
4170 malloc (sizeof (struct dump_list_entry
));
4172 error (_("Out of memory allocating dump request table.\n"));
4174 new_request
->name
= strdup (section
);
4175 if (!new_request
->name
)
4176 error (_("Out of memory allocating dump request table.\n"));
4178 new_request
->type
= type
;
4180 new_request
->next
= dump_sects_byname
;
4181 dump_sects_byname
= new_request
;
4185 request_dump (dump_type type
)
4191 section
= strtoul (optarg
, & cp
, 0);
4193 if (! *cp
&& section
>= 0)
4194 request_dump_bynumber (section
, type
);
4196 request_dump_byname (optarg
, type
);
4201 parse_args (int argc
, char ** argv
)
4208 while ((c
= getopt_long
4209 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4227 do_section_groups
++;
4235 do_section_groups
++;
4240 do_section_details
++;
4284 request_dump (HEX_DUMP
);
4287 request_dump (STRING_DUMP
);
4290 request_dump (RELOC_DUMP
);
4300 dwarf_select_sections_all ();
4305 dwarf_select_sections_by_letters (optarg
);
4308 case OPTION_DEBUG_DUMP
:
4315 dwarf_select_sections_by_names (optarg
);
4318 case OPTION_DWARF_DEPTH
:
4322 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4325 case OPTION_DWARF_START
:
4329 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4332 case OPTION_DWARF_CHECK
:
4335 case OPTION_DYN_SYMS
:
4338 #ifdef SUPPORT_DISASSEMBLY
4340 request_dump (DISASS_DUMP
);
4344 print_version (program_name
);
4353 /* xgettext:c-format */
4354 error (_("Invalid option '-%c'\n"), c
);
4361 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4362 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4363 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4364 && !do_section_groups
&& !do_archive_index
4370 get_elf_class (unsigned int elf_class
)
4372 static char buff
[32];
4376 case ELFCLASSNONE
: return _("none");
4377 case ELFCLASS32
: return "ELF32";
4378 case ELFCLASS64
: return "ELF64";
4380 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4386 get_data_encoding (unsigned int encoding
)
4388 static char buff
[32];
4392 case ELFDATANONE
: return _("none");
4393 case ELFDATA2LSB
: return _("2's complement, little endian");
4394 case ELFDATA2MSB
: return _("2's complement, big endian");
4396 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4401 /* Decode the data held in 'elf_header'. */
4404 process_file_header (void)
4406 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4407 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4408 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4409 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4412 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4416 init_dwarf_regnames (elf_header
.e_machine
);
4422 printf (_("ELF Header:\n"));
4423 printf (_(" Magic: "));
4424 for (i
= 0; i
< EI_NIDENT
; i
++)
4425 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4427 printf (_(" Class: %s\n"),
4428 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4429 printf (_(" Data: %s\n"),
4430 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4431 printf (_(" Version: %d %s\n"),
4432 elf_header
.e_ident
[EI_VERSION
],
4433 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4435 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4436 ? _("<unknown: %lx>")
4438 printf (_(" OS/ABI: %s\n"),
4439 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4440 printf (_(" ABI Version: %d\n"),
4441 elf_header
.e_ident
[EI_ABIVERSION
]);
4442 printf (_(" Type: %s\n"),
4443 get_file_type (elf_header
.e_type
));
4444 printf (_(" Machine: %s\n"),
4445 get_machine_name (elf_header
.e_machine
));
4446 printf (_(" Version: 0x%lx\n"),
4447 (unsigned long) elf_header
.e_version
);
4449 printf (_(" Entry point address: "));
4450 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4451 printf (_("\n Start of program headers: "));
4452 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4453 printf (_(" (bytes into file)\n Start of section headers: "));
4454 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4455 printf (_(" (bytes into file)\n"));
4457 printf (_(" Flags: 0x%lx%s\n"),
4458 (unsigned long) elf_header
.e_flags
,
4459 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4460 printf (_(" Size of this header: %ld (bytes)\n"),
4461 (long) elf_header
.e_ehsize
);
4462 printf (_(" Size of program headers: %ld (bytes)\n"),
4463 (long) elf_header
.e_phentsize
);
4464 printf (_(" Number of program headers: %ld"),
4465 (long) elf_header
.e_phnum
);
4466 if (section_headers
!= NULL
4467 && elf_header
.e_phnum
== PN_XNUM
4468 && section_headers
[0].sh_info
!= 0)
4469 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4470 putc ('\n', stdout
);
4471 printf (_(" Size of section headers: %ld (bytes)\n"),
4472 (long) elf_header
.e_shentsize
);
4473 printf (_(" Number of section headers: %ld"),
4474 (long) elf_header
.e_shnum
);
4475 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4476 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4477 putc ('\n', stdout
);
4478 printf (_(" Section header string table index: %ld"),
4479 (long) elf_header
.e_shstrndx
);
4480 if (section_headers
!= NULL
4481 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4482 printf (" (%u)", section_headers
[0].sh_link
);
4483 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4484 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4485 printf (_(" <corrupt: out of range>"));
4486 putc ('\n', stdout
);
4489 if (section_headers
!= NULL
)
4491 if (elf_header
.e_phnum
== PN_XNUM
4492 && section_headers
[0].sh_info
!= 0)
4493 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4494 if (elf_header
.e_shnum
== SHN_UNDEF
)
4495 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4496 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4497 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4498 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4499 elf_header
.e_shstrndx
= SHN_UNDEF
;
4500 free (section_headers
);
4501 section_headers
= NULL
;
4508 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4510 Elf32_External_Phdr
* phdrs
;
4511 Elf32_External_Phdr
* external
;
4512 Elf_Internal_Phdr
* internal
;
4514 unsigned int size
= elf_header
.e_phentsize
;
4515 unsigned int num
= elf_header
.e_phnum
;
4517 /* PR binutils/17531: Cope with unexpected section header sizes. */
4518 if (size
== 0 || num
== 0)
4520 if (size
< sizeof * phdrs
)
4522 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4525 if (size
> sizeof * phdrs
)
4526 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4528 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4529 size
, num
, _("program headers"));
4533 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4534 i
< elf_header
.e_phnum
;
4535 i
++, internal
++, external
++)
4537 internal
->p_type
= BYTE_GET (external
->p_type
);
4538 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4539 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4540 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4541 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4542 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4543 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4544 internal
->p_align
= BYTE_GET (external
->p_align
);
4552 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4554 Elf64_External_Phdr
* phdrs
;
4555 Elf64_External_Phdr
* external
;
4556 Elf_Internal_Phdr
* internal
;
4558 unsigned int size
= elf_header
.e_phentsize
;
4559 unsigned int num
= elf_header
.e_phnum
;
4561 /* PR binutils/17531: Cope with unexpected section header sizes. */
4562 if (size
== 0 || num
== 0)
4564 if (size
< sizeof * phdrs
)
4566 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4569 if (size
> sizeof * phdrs
)
4570 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4572 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4573 size
, num
, _("program headers"));
4577 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4578 i
< elf_header
.e_phnum
;
4579 i
++, internal
++, external
++)
4581 internal
->p_type
= BYTE_GET (external
->p_type
);
4582 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4583 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4584 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4585 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4586 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4587 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4588 internal
->p_align
= BYTE_GET (external
->p_align
);
4595 /* Returns 1 if the program headers were read into `program_headers'. */
4598 get_program_headers (FILE * file
)
4600 Elf_Internal_Phdr
* phdrs
;
4602 /* Check cache of prior read. */
4603 if (program_headers
!= NULL
)
4606 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4607 sizeof (Elf_Internal_Phdr
));
4611 error (_("Out of memory reading %u program headers\n"),
4612 elf_header
.e_phnum
);
4617 ? get_32bit_program_headers (file
, phdrs
)
4618 : get_64bit_program_headers (file
, phdrs
))
4620 program_headers
= phdrs
;
4628 /* Returns 1 if the program headers were loaded. */
4631 process_program_headers (FILE * file
)
4633 Elf_Internal_Phdr
* segment
;
4636 if (elf_header
.e_phnum
== 0)
4638 /* PR binutils/12467. */
4639 if (elf_header
.e_phoff
!= 0)
4640 warn (_("possibly corrupt ELF header - it has a non-zero program"
4641 " header offset, but no program headers\n"));
4642 else if (do_segments
)
4643 printf (_("\nThere are no program headers in this file.\n"));
4647 if (do_segments
&& !do_header
)
4649 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4650 printf (_("Entry point "));
4651 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4652 printf (_("\nThere are %d program headers, starting at offset "),
4653 elf_header
.e_phnum
);
4654 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4658 if (! get_program_headers (file
))
4663 if (elf_header
.e_phnum
> 1)
4664 printf (_("\nProgram Headers:\n"));
4666 printf (_("\nProgram Headers:\n"));
4670 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4673 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4677 (_(" Type Offset VirtAddr PhysAddr\n"));
4679 (_(" FileSiz MemSiz Flags Align\n"));
4686 for (i
= 0, segment
= program_headers
;
4687 i
< elf_header
.e_phnum
;
4692 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4696 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4697 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4698 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4699 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4700 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4702 (segment
->p_flags
& PF_R
? 'R' : ' '),
4703 (segment
->p_flags
& PF_W
? 'W' : ' '),
4704 (segment
->p_flags
& PF_X
? 'E' : ' '));
4705 printf ("%#lx", (unsigned long) segment
->p_align
);
4709 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4710 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4713 print_vma (segment
->p_offset
, FULL_HEX
);
4717 print_vma (segment
->p_vaddr
, FULL_HEX
);
4719 print_vma (segment
->p_paddr
, FULL_HEX
);
4722 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4723 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4726 print_vma (segment
->p_filesz
, FULL_HEX
);
4730 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4731 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4734 print_vma (segment
->p_memsz
, FULL_HEX
);
4738 (segment
->p_flags
& PF_R
? 'R' : ' '),
4739 (segment
->p_flags
& PF_W
? 'W' : ' '),
4740 (segment
->p_flags
& PF_X
? 'E' : ' '));
4742 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4743 printf ("%#lx", (unsigned long) segment
->p_align
);
4746 print_vma (segment
->p_align
, PREFIX_HEX
);
4751 print_vma (segment
->p_offset
, FULL_HEX
);
4753 print_vma (segment
->p_vaddr
, FULL_HEX
);
4755 print_vma (segment
->p_paddr
, FULL_HEX
);
4757 print_vma (segment
->p_filesz
, FULL_HEX
);
4759 print_vma (segment
->p_memsz
, FULL_HEX
);
4761 (segment
->p_flags
& PF_R
? 'R' : ' '),
4762 (segment
->p_flags
& PF_W
? 'W' : ' '),
4763 (segment
->p_flags
& PF_X
? 'E' : ' '));
4764 print_vma (segment
->p_align
, HEX
);
4769 putc ('\n', stdout
);
4771 switch (segment
->p_type
)
4775 error (_("more than one dynamic segment\n"));
4777 /* By default, assume that the .dynamic section is the first
4778 section in the DYNAMIC segment. */
4779 dynamic_addr
= segment
->p_offset
;
4780 dynamic_size
= segment
->p_filesz
;
4781 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4782 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4784 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4785 dynamic_addr
= dynamic_size
= 0;
4788 /* Try to locate the .dynamic section. If there is
4789 a section header table, we can easily locate it. */
4790 if (section_headers
!= NULL
)
4792 Elf_Internal_Shdr
* sec
;
4794 sec
= find_section (".dynamic");
4795 if (sec
== NULL
|| sec
->sh_size
== 0)
4797 /* A corresponding .dynamic section is expected, but on
4798 IA-64/OpenVMS it is OK for it to be missing. */
4799 if (!is_ia64_vms ())
4800 error (_("no .dynamic section in the dynamic segment\n"));
4804 if (sec
->sh_type
== SHT_NOBITS
)
4810 dynamic_addr
= sec
->sh_offset
;
4811 dynamic_size
= sec
->sh_size
;
4813 if (dynamic_addr
< segment
->p_offset
4814 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4815 warn (_("the .dynamic section is not contained"
4816 " within the dynamic segment\n"));
4817 else if (dynamic_addr
> segment
->p_offset
)
4818 warn (_("the .dynamic section is not the first section"
4819 " in the dynamic segment.\n"));
4824 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4826 error (_("Unable to find program interpreter name\n"));
4830 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4832 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4833 error (_("Internal error: failed to create format string to display program interpreter\n"));
4835 program_interpreter
[0] = 0;
4836 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4837 error (_("Unable to read program interpreter name\n"));
4840 printf (_(" [Requesting program interpreter: %s]\n"),
4841 program_interpreter
);
4847 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4849 printf (_("\n Section to Segment mapping:\n"));
4850 printf (_(" Segment Sections...\n"));
4852 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4855 Elf_Internal_Shdr
* section
;
4857 segment
= program_headers
+ i
;
4858 section
= section_headers
+ 1;
4860 printf (" %2.2d ", i
);
4862 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4864 if (!ELF_TBSS_SPECIAL (section
, segment
)
4865 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4866 printf ("%s ", printable_section_name (section
));
4877 /* Find the file offset corresponding to VMA by using the program headers. */
4880 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4882 Elf_Internal_Phdr
* seg
;
4884 if (! get_program_headers (file
))
4886 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4890 for (seg
= program_headers
;
4891 seg
< program_headers
+ elf_header
.e_phnum
;
4894 if (seg
->p_type
!= PT_LOAD
)
4897 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4898 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4899 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4902 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4903 (unsigned long) vma
);
4908 /* Allocate memory and load the sections headers into the global pointer
4909 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4910 generate any error messages if the load fails. */
4913 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4915 Elf32_External_Shdr
* shdrs
;
4916 Elf_Internal_Shdr
* internal
;
4918 unsigned int size
= elf_header
.e_shentsize
;
4919 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4921 /* PR binutils/17531: Cope with unexpected section header sizes. */
4922 if (size
== 0 || num
== 0)
4924 if (size
< sizeof * shdrs
)
4927 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4930 if (!probe
&& size
> sizeof * shdrs
)
4931 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4933 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4935 probe
? NULL
: _("section headers"));
4939 if (section_headers
!= NULL
)
4940 free (section_headers
);
4941 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4942 sizeof (Elf_Internal_Shdr
));
4943 if (section_headers
== NULL
)
4946 error (_("Out of memory reading %u section headers\n"), num
);
4950 for (i
= 0, internal
= section_headers
;
4954 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4955 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4956 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4957 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4958 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4959 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4960 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4961 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4962 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4963 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4971 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4973 Elf64_External_Shdr
* shdrs
;
4974 Elf_Internal_Shdr
* internal
;
4976 unsigned int size
= elf_header
.e_shentsize
;
4977 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4979 /* PR binutils/17531: Cope with unexpected section header sizes. */
4980 if (size
== 0 || num
== 0)
4982 if (size
< sizeof * shdrs
)
4985 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4988 if (! probe
&& size
> sizeof * shdrs
)
4989 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4991 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4993 probe
? NULL
: _("section headers"));
4997 if (section_headers
!= NULL
)
4998 free (section_headers
);
4999 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5000 sizeof (Elf_Internal_Shdr
));
5001 if (section_headers
== NULL
)
5004 error (_("Out of memory reading %u section headers\n"), num
);
5008 for (i
= 0, internal
= section_headers
;
5012 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5013 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5014 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5015 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5016 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5017 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5018 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5019 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5020 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5021 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5028 static Elf_Internal_Sym
*
5029 get_32bit_elf_symbols (FILE * file
,
5030 Elf_Internal_Shdr
* section
,
5031 unsigned long * num_syms_return
)
5033 unsigned long number
= 0;
5034 Elf32_External_Sym
* esyms
= NULL
;
5035 Elf_External_Sym_Shndx
* shndx
= NULL
;
5036 Elf_Internal_Sym
* isyms
= NULL
;
5037 Elf_Internal_Sym
* psym
;
5040 if (section
->sh_size
== 0)
5042 if (num_syms_return
!= NULL
)
5043 * num_syms_return
= 0;
5047 /* Run some sanity checks first. */
5048 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5050 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5051 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5055 if (section
->sh_size
> current_file_size
)
5057 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5058 printable_section_name (section
), (unsigned long) section
->sh_size
);
5062 number
= section
->sh_size
/ section
->sh_entsize
;
5064 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5066 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5067 (unsigned long) section
->sh_size
,
5068 printable_section_name (section
),
5069 (unsigned long) section
->sh_entsize
);
5073 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5074 section
->sh_size
, _("symbols"));
5079 elf_section_list
* entry
;
5082 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5083 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5085 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5086 entry
->hdr
->sh_offset
,
5087 1, entry
->hdr
->sh_size
,
5088 _("symbol table section indicies"));
5091 /* PR17531: file: heap-buffer-overflow */
5092 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5094 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5095 printable_section_name (entry
->hdr
),
5096 (unsigned long) entry
->hdr
->sh_size
,
5097 (unsigned long) section
->sh_size
);
5103 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5107 error (_("Out of memory reading %lu symbols\n"),
5108 (unsigned long) number
);
5112 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5114 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5115 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5116 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5117 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5118 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5120 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5121 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5122 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5123 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5124 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5133 if (num_syms_return
!= NULL
)
5134 * num_syms_return
= isyms
== NULL
? 0 : number
;
5139 static Elf_Internal_Sym
*
5140 get_64bit_elf_symbols (FILE * file
,
5141 Elf_Internal_Shdr
* section
,
5142 unsigned long * num_syms_return
)
5144 unsigned long number
= 0;
5145 Elf64_External_Sym
* esyms
= NULL
;
5146 Elf_External_Sym_Shndx
* shndx
= NULL
;
5147 Elf_Internal_Sym
* isyms
= NULL
;
5148 Elf_Internal_Sym
* psym
;
5151 if (section
->sh_size
== 0)
5153 if (num_syms_return
!= NULL
)
5154 * num_syms_return
= 0;
5158 /* Run some sanity checks first. */
5159 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5161 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5162 printable_section_name (section
),
5163 (unsigned long) section
->sh_entsize
);
5167 if (section
->sh_size
> current_file_size
)
5169 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5170 printable_section_name (section
),
5171 (unsigned long) section
->sh_size
);
5175 number
= section
->sh_size
/ section
->sh_entsize
;
5177 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5179 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5180 (unsigned long) section
->sh_size
,
5181 printable_section_name (section
),
5182 (unsigned long) section
->sh_entsize
);
5186 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5187 section
->sh_size
, _("symbols"));
5192 elf_section_list
* entry
;
5195 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5196 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5198 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5199 entry
->hdr
->sh_offset
,
5200 1, entry
->hdr
->sh_size
,
5201 _("symbol table section indicies"));
5204 /* PR17531: file: heap-buffer-overflow */
5205 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5207 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5208 printable_section_name (entry
->hdr
),
5209 (unsigned long) entry
->hdr
->sh_size
,
5210 (unsigned long) section
->sh_size
);
5216 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5220 error (_("Out of memory reading %lu symbols\n"),
5221 (unsigned long) number
);
5225 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5227 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5228 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5229 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5230 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5232 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5234 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5235 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5236 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5238 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5239 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5248 if (num_syms_return
!= NULL
)
5249 * num_syms_return
= isyms
== NULL
? 0 : number
;
5255 get_elf_section_flags (bfd_vma sh_flags
)
5257 static char buff
[1024];
5259 int field_size
= is_32bit_elf
? 8 : 16;
5261 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5262 bfd_vma os_flags
= 0;
5263 bfd_vma proc_flags
= 0;
5264 bfd_vma unknown_flags
= 0;
5272 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5273 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5274 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5275 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5276 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5277 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5278 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5279 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5280 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5281 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5282 /* IA-64 specific. */
5283 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5284 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5285 /* IA-64 OpenVMS specific. */
5286 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5287 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5288 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5289 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5290 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5291 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5293 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5294 /* SPARC specific. */
5295 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5296 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5298 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5299 /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
5300 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5303 if (do_section_details
)
5305 sprintf (buff
, "[%*.*lx]: ",
5306 field_size
, field_size
, (unsigned long) sh_flags
);
5307 p
+= field_size
+ 4;
5314 flag
= sh_flags
& - sh_flags
;
5317 if (do_section_details
)
5321 case SHF_WRITE
: sindex
= 0; break;
5322 case SHF_ALLOC
: sindex
= 1; break;
5323 case SHF_EXECINSTR
: sindex
= 2; break;
5324 case SHF_MERGE
: sindex
= 3; break;
5325 case SHF_STRINGS
: sindex
= 4; break;
5326 case SHF_INFO_LINK
: sindex
= 5; break;
5327 case SHF_LINK_ORDER
: sindex
= 6; break;
5328 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5329 case SHF_GROUP
: sindex
= 8; break;
5330 case SHF_TLS
: sindex
= 9; break;
5331 case SHF_EXCLUDE
: sindex
= 18; break;
5332 case SHF_COMPRESSED
: sindex
= 20; break;
5336 switch (elf_header
.e_machine
)
5339 if (flag
== SHF_IA_64_SHORT
)
5341 else if (flag
== SHF_IA_64_NORECOV
)
5344 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5347 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5348 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5349 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5350 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5351 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5352 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5363 case EM_OLD_SPARCV9
:
5364 case EM_SPARC32PLUS
:
5367 if (flag
== SHF_ORDERED
)
5374 case SHF_ENTRYSECT
: sindex
= 21; break;
5375 case SHF_ARM_NOREAD
: sindex
= 22; break;
5376 case SHF_COMDEF
: sindex
= 23; break;
5388 if (p
!= buff
+ field_size
+ 4)
5390 if (size
< (10 + 2))
5392 warn (_("Internal error: not enough buffer room for section flag info"));
5393 return _("<unknown>");
5400 size
-= flags
[sindex
].len
;
5401 p
= stpcpy (p
, flags
[sindex
].str
);
5403 else if (flag
& SHF_MASKOS
)
5405 else if (flag
& SHF_MASKPROC
)
5408 unknown_flags
|= flag
;
5414 case SHF_WRITE
: *p
= 'W'; break;
5415 case SHF_ALLOC
: *p
= 'A'; break;
5416 case SHF_EXECINSTR
: *p
= 'X'; break;
5417 case SHF_MERGE
: *p
= 'M'; break;
5418 case SHF_STRINGS
: *p
= 'S'; break;
5419 case SHF_INFO_LINK
: *p
= 'I'; break;
5420 case SHF_LINK_ORDER
: *p
= 'L'; break;
5421 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5422 case SHF_GROUP
: *p
= 'G'; break;
5423 case SHF_TLS
: *p
= 'T'; break;
5424 case SHF_EXCLUDE
: *p
= 'E'; break;
5425 case SHF_COMPRESSED
: *p
= 'C'; break;
5428 if ((elf_header
.e_machine
== EM_X86_64
5429 || elf_header
.e_machine
== EM_L1OM
5430 || elf_header
.e_machine
== EM_K1OM
)
5431 && flag
== SHF_X86_64_LARGE
)
5433 else if (flag
& SHF_MASKOS
)
5436 sh_flags
&= ~ SHF_MASKOS
;
5438 else if (flag
& SHF_MASKPROC
)
5441 sh_flags
&= ~ SHF_MASKPROC
;
5451 if (do_section_details
)
5455 size
-= 5 + field_size
;
5456 if (p
!= buff
+ field_size
+ 4)
5460 warn (_("Internal error: not enough buffer room for section flag info"));
5461 return _("<unknown>");
5467 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5468 (unsigned long) os_flags
);
5469 p
+= 5 + field_size
;
5473 size
-= 7 + field_size
;
5474 if (p
!= buff
+ field_size
+ 4)
5478 warn (_("Internal error: not enough buffer room for section flag info"));
5479 return _("<unknown>");
5485 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5486 (unsigned long) proc_flags
);
5487 p
+= 7 + field_size
;
5491 size
-= 10 + field_size
;
5492 if (p
!= buff
+ field_size
+ 4)
5496 warn (_("Internal error: not enough buffer room for section flag info"));
5497 return _("<unknown>");
5503 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5504 (unsigned long) unknown_flags
);
5505 p
+= 10 + field_size
;
5514 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5518 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5519 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5520 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5521 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5522 return sizeof (*echdr
);
5526 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5527 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5528 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5529 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5530 return sizeof (*echdr
);
5535 process_section_headers (FILE * file
)
5537 Elf_Internal_Shdr
* section
;
5540 section_headers
= NULL
;
5542 if (elf_header
.e_shnum
== 0)
5544 /* PR binutils/12467. */
5545 if (elf_header
.e_shoff
!= 0)
5546 warn (_("possibly corrupt ELF file header - it has a non-zero"
5547 " section header offset, but no section headers\n"));
5548 else if (do_sections
)
5549 printf (_("\nThere are no sections in this file.\n"));
5554 if (do_sections
&& !do_header
)
5555 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5556 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5560 if (! get_32bit_section_headers (file
, FALSE
))
5563 else if (! get_64bit_section_headers (file
, FALSE
))
5566 /* Read in the string table, so that we have names to display. */
5567 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5568 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5570 section
= section_headers
+ elf_header
.e_shstrndx
;
5572 if (section
->sh_size
!= 0)
5574 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5575 1, section
->sh_size
,
5578 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5582 /* Scan the sections for the dynamic symbol table
5583 and dynamic string table and debug sections. */
5584 dynamic_symbols
= NULL
;
5585 dynamic_strings
= NULL
;
5586 dynamic_syminfo
= NULL
;
5587 symtab_shndx_list
= NULL
;
5589 eh_addr_size
= is_32bit_elf
? 4 : 8;
5590 switch (elf_header
.e_machine
)
5593 case EM_MIPS_RS3_LE
:
5594 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5595 FDE addresses. However, the ABI also has a semi-official ILP32
5596 variant for which the normal FDE address size rules apply.
5598 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5599 section, where XX is the size of longs in bits. Unfortunately,
5600 earlier compilers provided no way of distinguishing ILP32 objects
5601 from LP64 objects, so if there's any doubt, we should assume that
5602 the official LP64 form is being used. */
5603 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5604 && find_section (".gcc_compiled_long32") == NULL
)
5610 switch (elf_header
.e_flags
& EF_H8_MACH
)
5612 case E_H8_MACH_H8300
:
5613 case E_H8_MACH_H8300HN
:
5614 case E_H8_MACH_H8300SN
:
5615 case E_H8_MACH_H8300SXN
:
5618 case E_H8_MACH_H8300H
:
5619 case E_H8_MACH_H8300S
:
5620 case E_H8_MACH_H8300SX
:
5628 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5630 case EF_M32C_CPU_M16C
:
5637 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5640 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5641 if (section->sh_entsize != expected_entsize) \
5644 sprintf_vma (buf, section->sh_entsize); \
5645 /* Note: coded this way so that there is a single string for \
5647 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5648 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5649 (unsigned) expected_entsize); \
5650 section->sh_entsize = expected_entsize; \
5655 #define CHECK_ENTSIZE(section, i, type) \
5656 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5657 sizeof (Elf64_External_##type))
5659 for (i
= 0, section
= section_headers
;
5660 i
< elf_header
.e_shnum
;
5663 char * name
= SECTION_NAME (section
);
5665 if (section
->sh_type
== SHT_DYNSYM
)
5667 if (dynamic_symbols
!= NULL
)
5669 error (_("File contains multiple dynamic symbol tables\n"));
5673 CHECK_ENTSIZE (section
, i
, Sym
);
5674 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5676 else if (section
->sh_type
== SHT_STRTAB
5677 && streq (name
, ".dynstr"))
5679 if (dynamic_strings
!= NULL
)
5681 error (_("File contains multiple dynamic string tables\n"));
5685 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5686 1, section
->sh_size
,
5687 _("dynamic strings"));
5688 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5690 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5692 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5693 entry
->hdr
= section
;
5694 entry
->next
= symtab_shndx_list
;
5695 symtab_shndx_list
= entry
;
5697 else if (section
->sh_type
== SHT_SYMTAB
)
5698 CHECK_ENTSIZE (section
, i
, Sym
);
5699 else if (section
->sh_type
== SHT_GROUP
)
5700 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5701 else if (section
->sh_type
== SHT_REL
)
5702 CHECK_ENTSIZE (section
, i
, Rel
);
5703 else if (section
->sh_type
== SHT_RELA
)
5704 CHECK_ENTSIZE (section
, i
, Rela
);
5705 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5706 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5707 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5708 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5709 || do_debug_addr
|| do_debug_cu_index
)
5710 && (const_strneq (name
, ".debug_")
5711 || const_strneq (name
, ".zdebug_")))
5714 name
+= sizeof (".zdebug_") - 1;
5716 name
+= sizeof (".debug_") - 1;
5719 || (do_debug_info
&& const_strneq (name
, "info"))
5720 || (do_debug_info
&& const_strneq (name
, "types"))
5721 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5722 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5723 || (do_debug_lines
&& const_strneq (name
, "line."))
5724 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5725 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5726 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5727 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5728 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5729 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5730 || (do_debug_frames
&& const_strneq (name
, "frame"))
5731 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5732 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5733 || (do_debug_str
&& const_strneq (name
, "str"))
5734 || (do_debug_loc
&& const_strneq (name
, "loc"))
5735 || (do_debug_addr
&& const_strneq (name
, "addr"))
5736 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5737 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5739 request_dump_bynumber (i
, DEBUG_DUMP
);
5741 /* Linkonce section to be combined with .debug_info at link time. */
5742 else if ((do_debugging
|| do_debug_info
)
5743 && const_strneq (name
, ".gnu.linkonce.wi."))
5744 request_dump_bynumber (i
, DEBUG_DUMP
);
5745 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5746 request_dump_bynumber (i
, DEBUG_DUMP
);
5747 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5748 request_dump_bynumber (i
, DEBUG_DUMP
);
5749 /* Trace sections for Itanium VMS. */
5750 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5751 || do_trace_aranges
)
5752 && const_strneq (name
, ".trace_"))
5754 name
+= sizeof (".trace_") - 1;
5757 || (do_trace_info
&& streq (name
, "info"))
5758 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5759 || (do_trace_aranges
&& streq (name
, "aranges"))
5761 request_dump_bynumber (i
, DEBUG_DUMP
);
5768 if (elf_header
.e_shnum
> 1)
5769 printf (_("\nSection Headers:\n"));
5771 printf (_("\nSection Header:\n"));
5775 if (do_section_details
)
5777 printf (_(" [Nr] Name\n"));
5778 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5782 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5786 if (do_section_details
)
5788 printf (_(" [Nr] Name\n"));
5789 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5793 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5797 if (do_section_details
)
5799 printf (_(" [Nr] Name\n"));
5800 printf (_(" Type Address Offset Link\n"));
5801 printf (_(" Size EntSize Info Align\n"));
5805 printf (_(" [Nr] Name Type Address Offset\n"));
5806 printf (_(" Size EntSize Flags Link Info Align\n"));
5810 if (do_section_details
)
5811 printf (_(" Flags\n"));
5813 for (i
= 0, section
= section_headers
;
5814 i
< elf_header
.e_shnum
;
5817 printf (" [%2u] ", i
);
5818 if (do_section_details
)
5819 printf ("%s\n ", printable_section_name (section
));
5821 print_symbol (-17, SECTION_NAME (section
));
5823 printf (do_wide
? " %-15s " : " %-15.15s ",
5824 get_section_type_name (section
->sh_type
));
5828 const char * link_too_big
= NULL
;
5830 print_vma (section
->sh_addr
, LONG_HEX
);
5832 printf ( " %6.6lx %6.6lx %2.2lx",
5833 (unsigned long) section
->sh_offset
,
5834 (unsigned long) section
->sh_size
,
5835 (unsigned long) section
->sh_entsize
);
5837 if (do_section_details
)
5838 fputs (" ", stdout
);
5840 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5842 if (section
->sh_link
>= elf_header
.e_shnum
)
5845 /* The sh_link value is out of range. Normally this indicates
5846 an error but it can have special values in Solaris binaries. */
5847 switch (elf_header
.e_machine
)
5854 case EM_OLD_SPARCV9
:
5855 case EM_SPARC32PLUS
:
5858 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5859 link_too_big
= "BEFORE";
5860 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5861 link_too_big
= "AFTER";
5868 if (do_section_details
)
5870 if (link_too_big
!= NULL
&& * link_too_big
)
5871 printf ("<%s> ", link_too_big
);
5873 printf ("%2u ", section
->sh_link
);
5874 printf ("%3u %2lu\n", section
->sh_info
,
5875 (unsigned long) section
->sh_addralign
);
5878 printf ("%2u %3u %2lu\n",
5881 (unsigned long) section
->sh_addralign
);
5883 if (link_too_big
&& ! * link_too_big
)
5884 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5885 i
, section
->sh_link
);
5889 print_vma (section
->sh_addr
, LONG_HEX
);
5891 if ((long) section
->sh_offset
== section
->sh_offset
)
5892 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5896 print_vma (section
->sh_offset
, LONG_HEX
);
5899 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5900 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5904 print_vma (section
->sh_size
, LONG_HEX
);
5907 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5908 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5912 print_vma (section
->sh_entsize
, LONG_HEX
);
5915 if (do_section_details
)
5916 fputs (" ", stdout
);
5918 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5920 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5922 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5923 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5926 print_vma (section
->sh_addralign
, DEC
);
5930 else if (do_section_details
)
5932 printf (" %-15.15s ",
5933 get_section_type_name (section
->sh_type
));
5934 print_vma (section
->sh_addr
, LONG_HEX
);
5935 if ((long) section
->sh_offset
== section
->sh_offset
)
5936 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5940 print_vma (section
->sh_offset
, LONG_HEX
);
5942 printf (" %u\n ", section
->sh_link
);
5943 print_vma (section
->sh_size
, LONG_HEX
);
5945 print_vma (section
->sh_entsize
, LONG_HEX
);
5947 printf (" %-16u %lu\n",
5949 (unsigned long) section
->sh_addralign
);
5954 print_vma (section
->sh_addr
, LONG_HEX
);
5955 if ((long) section
->sh_offset
== section
->sh_offset
)
5956 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5960 print_vma (section
->sh_offset
, LONG_HEX
);
5963 print_vma (section
->sh_size
, LONG_HEX
);
5965 print_vma (section
->sh_entsize
, LONG_HEX
);
5967 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5969 printf (" %2u %3u %lu\n",
5972 (unsigned long) section
->sh_addralign
);
5975 if (do_section_details
)
5977 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5978 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
5980 /* Minimum section size is 12 bytes for 32-bit compression
5981 header + 12 bytes for compressed data header. */
5982 unsigned char buf
[24];
5983 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
5984 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
5985 sizeof (buf
), _("compression header")))
5987 Elf_Internal_Chdr chdr
;
5988 get_compression_header (&chdr
, buf
);
5989 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
5992 printf (_(" [<unknown>: 0x%x], "),
5994 print_vma (chdr
.ch_size
, LONG_HEX
);
5995 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6001 if (!do_section_details
)
6003 if (elf_header
.e_machine
== EM_X86_64
6004 || elf_header
.e_machine
== EM_L1OM
6005 || elf_header
.e_machine
== EM_K1OM
)
6006 printf (_("Key to Flags:\n\
6007 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
6008 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
6009 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
6011 printf (_("Key to Flags:\n\
6012 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
6013 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
6014 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
6021 get_group_flags (unsigned int flags
)
6023 static char buff
[32];
6033 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
6040 process_section_groups (FILE * file
)
6042 Elf_Internal_Shdr
* section
;
6044 struct group
* group
;
6045 Elf_Internal_Shdr
* symtab_sec
;
6046 Elf_Internal_Shdr
* strtab_sec
;
6047 Elf_Internal_Sym
* symtab
;
6048 unsigned long num_syms
;
6052 /* Don't process section groups unless needed. */
6053 if (!do_unwind
&& !do_section_groups
)
6056 if (elf_header
.e_shnum
== 0)
6058 if (do_section_groups
)
6059 printf (_("\nThere are no sections to group in this file.\n"));
6064 if (section_headers
== NULL
)
6066 error (_("Section headers are not available!\n"));
6067 /* PR 13622: This can happen with a corrupt ELF header. */
6071 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6072 sizeof (struct group
*));
6074 if (section_headers_groups
== NULL
)
6076 error (_("Out of memory reading %u section group headers\n"),
6077 elf_header
.e_shnum
);
6081 /* Scan the sections for the group section. */
6083 for (i
= 0, section
= section_headers
;
6084 i
< elf_header
.e_shnum
;
6086 if (section
->sh_type
== SHT_GROUP
)
6089 if (group_count
== 0)
6091 if (do_section_groups
)
6092 printf (_("\nThere are no section groups in this file.\n"));
6097 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6099 if (section_groups
== NULL
)
6101 error (_("Out of memory reading %lu groups\n"),
6102 (unsigned long) group_count
);
6112 for (i
= 0, section
= section_headers
, group
= section_groups
;
6113 i
< elf_header
.e_shnum
;
6116 if (section
->sh_type
== SHT_GROUP
)
6118 const char * name
= printable_section_name (section
);
6119 const char * group_name
;
6120 unsigned char * start
;
6121 unsigned char * indices
;
6122 unsigned int entry
, j
, size
;
6123 Elf_Internal_Shdr
* sec
;
6124 Elf_Internal_Sym
* sym
;
6126 /* Get the symbol table. */
6127 if (section
->sh_link
>= elf_header
.e_shnum
6128 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6131 error (_("Bad sh_link in group section `%s'\n"), name
);
6135 if (symtab_sec
!= sec
)
6140 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6145 error (_("Corrupt header in group section `%s'\n"), name
);
6149 if (section
->sh_info
>= num_syms
)
6151 error (_("Bad sh_info in group section `%s'\n"), name
);
6155 sym
= symtab
+ section
->sh_info
;
6157 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6159 if (sym
->st_shndx
== 0
6160 || sym
->st_shndx
>= elf_header
.e_shnum
)
6162 error (_("Bad sh_info in group section `%s'\n"), name
);
6166 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6175 /* Get the string table. */
6176 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6185 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6191 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6192 1, strtab_sec
->sh_size
,
6194 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6196 group_name
= sym
->st_name
< strtab_size
6197 ? strtab
+ sym
->st_name
: _("<corrupt>");
6200 /* PR 17531: file: loop. */
6201 if (section
->sh_entsize
> section
->sh_size
)
6203 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6204 printable_section_name (section
),
6205 (unsigned long) section
->sh_entsize
,
6206 (unsigned long) section
->sh_size
);
6210 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6211 1, section
->sh_size
,
6217 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6218 entry
= byte_get (indices
, 4);
6221 if (do_section_groups
)
6223 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6224 get_group_flags (entry
), i
, name
, group_name
, size
);
6226 printf (_(" [Index] Name\n"));
6229 group
->group_index
= i
;
6231 for (j
= 0; j
< size
; j
++)
6233 struct group_list
* g
;
6235 entry
= byte_get (indices
, 4);
6238 if (entry
>= elf_header
.e_shnum
)
6240 static unsigned num_group_errors
= 0;
6242 if (num_group_errors
++ < 10)
6244 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6245 entry
, i
, elf_header
.e_shnum
- 1);
6246 if (num_group_errors
== 10)
6247 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6252 if (section_headers_groups
[entry
] != NULL
)
6256 static unsigned num_errs
= 0;
6258 if (num_errs
++ < 10)
6260 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6262 section_headers_groups
[entry
]->group_index
);
6264 warn (_("Further error messages about already contained group sections suppressed\n"));
6270 /* Intel C/C++ compiler may put section 0 in a
6271 section group. We just warn it the first time
6272 and ignore it afterwards. */
6273 static int warned
= 0;
6276 error (_("section 0 in group section [%5u]\n"),
6277 section_headers_groups
[entry
]->group_index
);
6283 section_headers_groups
[entry
] = group
;
6285 if (do_section_groups
)
6287 sec
= section_headers
+ entry
;
6288 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6291 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6292 g
->section_index
= entry
;
6293 g
->next
= group
->root
;
6311 /* Data used to display dynamic fixups. */
6313 struct ia64_vms_dynfixup
6315 bfd_vma needed_ident
; /* Library ident number. */
6316 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6317 bfd_vma fixup_needed
; /* Index of the library. */
6318 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6319 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6322 /* Data used to display dynamic relocations. */
6324 struct ia64_vms_dynimgrela
6326 bfd_vma img_rela_cnt
; /* Number of relocations. */
6327 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6330 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6334 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6335 const char *strtab
, unsigned int strtab_sz
)
6337 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6339 const char *lib_name
;
6341 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6342 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6343 _("dynamic section image fixups"));
6347 if (fixup
->needed
< strtab_sz
)
6348 lib_name
= strtab
+ fixup
->needed
;
6351 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6352 (unsigned long) fixup
->needed
);
6355 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6356 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6358 (_("Seg Offset Type SymVec DataType\n"));
6360 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6365 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6366 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6367 type
= BYTE_GET (imfs
[i
].type
);
6368 rtype
= elf_ia64_reloc_type (type
);
6370 printf (" 0x%08x ", type
);
6372 printf (" %-32s ", rtype
);
6373 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6374 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6380 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6383 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6385 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6388 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6389 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6390 _("dynamic section image relocations"));
6394 printf (_("\nImage relocs\n"));
6396 (_("Seg Offset Type Addend Seg Sym Off\n"));
6398 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6403 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6404 printf ("%08" BFD_VMA_FMT
"x ",
6405 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6406 type
= BYTE_GET (imrs
[i
].type
);
6407 rtype
= elf_ia64_reloc_type (type
);
6409 printf ("0x%08x ", type
);
6411 printf ("%-31s ", rtype
);
6412 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6413 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6414 printf ("%08" BFD_VMA_FMT
"x\n",
6415 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6421 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6424 process_ia64_vms_dynamic_relocs (FILE *file
)
6426 struct ia64_vms_dynfixup fixup
;
6427 struct ia64_vms_dynimgrela imgrela
;
6428 Elf_Internal_Dyn
*entry
;
6430 bfd_vma strtab_off
= 0;
6431 bfd_vma strtab_sz
= 0;
6432 char *strtab
= NULL
;
6434 memset (&fixup
, 0, sizeof (fixup
));
6435 memset (&imgrela
, 0, sizeof (imgrela
));
6437 /* Note: the order of the entries is specified by the OpenVMS specs. */
6438 for (entry
= dynamic_section
;
6439 entry
< dynamic_section
+ dynamic_nent
;
6442 switch (entry
->d_tag
)
6444 case DT_IA_64_VMS_STRTAB_OFFSET
:
6445 strtab_off
= entry
->d_un
.d_val
;
6448 strtab_sz
= entry
->d_un
.d_val
;
6450 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6451 1, strtab_sz
, _("dynamic string section"));
6454 case DT_IA_64_VMS_NEEDED_IDENT
:
6455 fixup
.needed_ident
= entry
->d_un
.d_val
;
6458 fixup
.needed
= entry
->d_un
.d_val
;
6460 case DT_IA_64_VMS_FIXUP_NEEDED
:
6461 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6463 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6464 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6466 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6467 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6469 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6472 case DT_IA_64_VMS_IMG_RELA_CNT
:
6473 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6475 case DT_IA_64_VMS_IMG_RELA_OFF
:
6476 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6478 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6498 } dynamic_relocations
[] =
6500 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6501 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6502 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6505 /* Process the reloc section. */
6508 process_relocs (FILE * file
)
6510 unsigned long rel_size
;
6511 unsigned long rel_offset
;
6517 if (do_using_dynamic
)
6521 int has_dynamic_reloc
;
6524 has_dynamic_reloc
= 0;
6526 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6528 is_rela
= dynamic_relocations
[i
].rela
;
6529 name
= dynamic_relocations
[i
].name
;
6530 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6531 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6533 has_dynamic_reloc
|= rel_size
;
6535 if (is_rela
== UNKNOWN
)
6537 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6538 switch (dynamic_info
[DT_PLTREL
])
6552 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6553 name
, rel_offset
, rel_size
);
6555 dump_relocations (file
,
6556 offset_from_vma (file
, rel_offset
, rel_size
),
6558 dynamic_symbols
, num_dynamic_syms
,
6559 dynamic_strings
, dynamic_strings_length
,
6565 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6567 if (! has_dynamic_reloc
)
6568 printf (_("\nThere are no dynamic relocations in this file.\n"));
6572 Elf_Internal_Shdr
* section
;
6576 for (i
= 0, section
= section_headers
;
6577 i
< elf_header
.e_shnum
;
6580 if ( section
->sh_type
!= SHT_RELA
6581 && section
->sh_type
!= SHT_REL
)
6584 rel_offset
= section
->sh_offset
;
6585 rel_size
= section
->sh_size
;
6589 Elf_Internal_Shdr
* strsec
;
6592 printf (_("\nRelocation section "));
6594 if (string_table
== NULL
)
6595 printf ("%d", section
->sh_name
);
6597 printf ("'%s'", printable_section_name (section
));
6599 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6600 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6602 is_rela
= section
->sh_type
== SHT_RELA
;
6604 if (section
->sh_link
!= 0
6605 && section
->sh_link
< elf_header
.e_shnum
)
6607 Elf_Internal_Shdr
* symsec
;
6608 Elf_Internal_Sym
* symtab
;
6609 unsigned long nsyms
;
6610 unsigned long strtablen
= 0;
6611 char * strtab
= NULL
;
6613 symsec
= section_headers
+ section
->sh_link
;
6614 if (symsec
->sh_type
!= SHT_SYMTAB
6615 && symsec
->sh_type
!= SHT_DYNSYM
)
6618 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6623 if (symsec
->sh_link
!= 0
6624 && symsec
->sh_link
< elf_header
.e_shnum
)
6626 strsec
= section_headers
+ symsec
->sh_link
;
6628 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6631 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6634 dump_relocations (file
, rel_offset
, rel_size
,
6635 symtab
, nsyms
, strtab
, strtablen
,
6637 symsec
->sh_type
== SHT_DYNSYM
);
6643 dump_relocations (file
, rel_offset
, rel_size
,
6644 NULL
, 0, NULL
, 0, is_rela
, 0);
6651 printf (_("\nThere are no relocations in this file.\n"));
6657 /* An absolute address consists of a section and an offset. If the
6658 section is NULL, the offset itself is the address, otherwise, the
6659 address equals to LOAD_ADDRESS(section) + offset. */
6663 unsigned short section
;
6667 #define ABSADDR(a) \
6669 ? section_headers [(a).section].sh_addr + (a).offset \
6672 /* Find the nearest symbol at or below ADDR. Returns the symbol
6673 name, if found, and the offset from the symbol to ADDR. */
6676 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6677 unsigned long nsyms
,
6678 const char * strtab
,
6679 unsigned long strtab_size
,
6680 struct absaddr addr
,
6681 const char ** symname
,
6684 bfd_vma dist
= 0x100000;
6685 Elf_Internal_Sym
* sym
;
6686 Elf_Internal_Sym
* beg
;
6687 Elf_Internal_Sym
* end
;
6688 Elf_Internal_Sym
* best
= NULL
;
6690 REMOVE_ARCH_BITS (addr
.offset
);
6692 end
= symtab
+ nsyms
;
6698 sym
= beg
+ (end
- beg
) / 2;
6700 value
= sym
->st_value
;
6701 REMOVE_ARCH_BITS (value
);
6703 if (sym
->st_name
!= 0
6704 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6705 && addr
.offset
>= value
6706 && addr
.offset
- value
< dist
)
6709 dist
= addr
.offset
- value
;
6714 if (addr
.offset
< value
)
6722 *symname
= (best
->st_name
>= strtab_size
6723 ? _("<corrupt>") : strtab
+ best
->st_name
);
6729 *offset
= addr
.offset
;
6733 symcmp (const void *p
, const void *q
)
6735 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6736 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6738 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6741 /* Process the unwind section. */
6743 #include "unwind-ia64.h"
6745 struct ia64_unw_table_entry
6747 struct absaddr start
;
6749 struct absaddr info
;
6752 struct ia64_unw_aux_info
6754 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6755 unsigned long table_len
; /* Length of unwind table. */
6756 unsigned char * info
; /* Unwind info. */
6757 unsigned long info_size
; /* Size of unwind info. */
6758 bfd_vma info_addr
; /* Starting address of unwind info. */
6759 bfd_vma seg_base
; /* Starting address of segment. */
6760 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6761 unsigned long nsyms
; /* Number of symbols. */
6762 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6763 unsigned long nfuns
; /* Number of entries in funtab. */
6764 char * strtab
; /* The string table. */
6765 unsigned long strtab_size
; /* Size of string table. */
6769 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6771 struct ia64_unw_table_entry
* tp
;
6772 unsigned long j
, nfuns
;
6775 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6776 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6777 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6778 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6780 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6782 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6786 const unsigned char * dp
;
6787 const unsigned char * head
;
6788 const unsigned char * end
;
6789 const char * procname
;
6791 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6792 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6794 fputs ("\n<", stdout
);
6798 fputs (procname
, stdout
);
6801 printf ("+%lx", (unsigned long) offset
);
6804 fputs (">: [", stdout
);
6805 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6806 fputc ('-', stdout
);
6807 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6808 printf ("], info at +0x%lx\n",
6809 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6811 /* PR 17531: file: 86232b32. */
6812 if (aux
->info
== NULL
)
6815 /* PR 17531: file: 0997b4d1. */
6816 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6818 warn (_("Invalid offset %lx in table entry %ld\n"),
6819 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6823 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6824 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6826 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6827 (unsigned) UNW_VER (stamp
),
6828 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6829 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6830 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6831 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6833 if (UNW_VER (stamp
) != 1)
6835 printf (_("\tUnknown version.\n"));
6840 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6841 /* PR 17531: file: 16ceda89. */
6842 if (end
> aux
->info
+ aux
->info_size
)
6843 end
= aux
->info
+ aux
->info_size
;
6844 for (dp
= head
+ 8; dp
< end
;)
6845 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
6852 slurp_ia64_unwind_table (FILE * file
,
6853 struct ia64_unw_aux_info
* aux
,
6854 Elf_Internal_Shdr
* sec
)
6856 unsigned long size
, nrelas
, i
;
6857 Elf_Internal_Phdr
* seg
;
6858 struct ia64_unw_table_entry
* tep
;
6859 Elf_Internal_Shdr
* relsec
;
6860 Elf_Internal_Rela
* rela
;
6861 Elf_Internal_Rela
* rp
;
6862 unsigned char * table
;
6864 Elf_Internal_Sym
* sym
;
6865 const char * relname
;
6869 /* First, find the starting address of the segment that includes
6872 if (elf_header
.e_phnum
)
6874 if (! get_program_headers (file
))
6877 for (seg
= program_headers
;
6878 seg
< program_headers
+ elf_header
.e_phnum
;
6881 if (seg
->p_type
!= PT_LOAD
)
6884 if (sec
->sh_addr
>= seg
->p_vaddr
6885 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6887 aux
->seg_base
= seg
->p_vaddr
;
6893 /* Second, build the unwind table from the contents of the unwind section: */
6894 size
= sec
->sh_size
;
6895 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6900 aux
->table_len
= size
/ (3 * eh_addr_size
);
6901 aux
->table
= (struct ia64_unw_table_entry
*)
6902 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6905 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6907 tep
->start
.section
= SHN_UNDEF
;
6908 tep
->end
.section
= SHN_UNDEF
;
6909 tep
->info
.section
= SHN_UNDEF
;
6910 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6911 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6912 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6913 tep
->start
.offset
+= aux
->seg_base
;
6914 tep
->end
.offset
+= aux
->seg_base
;
6915 tep
->info
.offset
+= aux
->seg_base
;
6919 /* Third, apply any relocations to the unwind table: */
6920 for (relsec
= section_headers
;
6921 relsec
< section_headers
+ elf_header
.e_shnum
;
6924 if (relsec
->sh_type
!= SHT_RELA
6925 || relsec
->sh_info
>= elf_header
.e_shnum
6926 || section_headers
+ relsec
->sh_info
!= sec
)
6929 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6938 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6940 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6941 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6943 /* PR 17531: file: 9fa67536. */
6944 if (relname
== NULL
)
6946 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6950 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6952 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6956 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6958 /* PR 17531: file: 5bc8d9bf. */
6959 if (i
>= aux
->table_len
)
6961 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6965 switch (rp
->r_offset
/ eh_addr_size
% 3)
6968 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6969 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6972 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6973 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6976 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6977 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6991 ia64_process_unwind (FILE * file
)
6993 Elf_Internal_Shdr
* sec
;
6994 Elf_Internal_Shdr
* unwsec
= NULL
;
6995 Elf_Internal_Shdr
* strsec
;
6996 unsigned long i
, unwcount
= 0, unwstart
= 0;
6997 struct ia64_unw_aux_info aux
;
6999 memset (& aux
, 0, sizeof (aux
));
7001 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7003 if (sec
->sh_type
== SHT_SYMTAB
7004 && sec
->sh_link
< elf_header
.e_shnum
)
7006 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7008 strsec
= section_headers
+ sec
->sh_link
;
7009 if (aux
.strtab
!= NULL
)
7011 error (_("Multiple auxillary string tables encountered\n"));
7014 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7017 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7019 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7024 printf (_("\nThere are no unwind sections in this file.\n"));
7026 while (unwcount
-- > 0)
7031 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7032 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7033 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7038 /* We have already counted the number of SHT_IA64_UNWIND
7039 sections so the loop above should never fail. */
7040 assert (unwsec
!= NULL
);
7043 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7045 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7047 /* We need to find which section group it is in. */
7048 struct group_list
* g
;
7050 if (section_headers_groups
== NULL
7051 || section_headers_groups
[i
] == NULL
)
7052 i
= elf_header
.e_shnum
;
7055 g
= section_headers_groups
[i
]->root
;
7057 for (; g
!= NULL
; g
= g
->next
)
7059 sec
= section_headers
+ g
->section_index
;
7061 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7066 i
= elf_header
.e_shnum
;
7069 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7071 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7072 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7073 suffix
= SECTION_NAME (unwsec
) + len
;
7074 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7076 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7077 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7082 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7083 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7084 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7085 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7087 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7088 suffix
= SECTION_NAME (unwsec
) + len
;
7089 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7091 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7092 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7096 if (i
== elf_header
.e_shnum
)
7098 printf (_("\nCould not find unwind info section for "));
7100 if (string_table
== NULL
)
7101 printf ("%d", unwsec
->sh_name
);
7103 printf ("'%s'", printable_section_name (unwsec
));
7107 aux
.info_addr
= sec
->sh_addr
;
7108 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7111 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7113 printf (_("\nUnwind section "));
7115 if (string_table
== NULL
)
7116 printf ("%d", unwsec
->sh_name
);
7118 printf ("'%s'", printable_section_name (unwsec
));
7120 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7121 (unsigned long) unwsec
->sh_offset
,
7122 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7124 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7125 && aux
.table_len
> 0)
7126 dump_ia64_unwind (& aux
);
7129 free ((char *) aux
.table
);
7131 free ((char *) aux
.info
);
7140 free ((char *) aux
.strtab
);
7143 struct hppa_unw_table_entry
7145 struct absaddr start
;
7147 unsigned int Cannot_unwind
:1; /* 0 */
7148 unsigned int Millicode
:1; /* 1 */
7149 unsigned int Millicode_save_sr0
:1; /* 2 */
7150 unsigned int Region_description
:2; /* 3..4 */
7151 unsigned int reserved1
:1; /* 5 */
7152 unsigned int Entry_SR
:1; /* 6 */
7153 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7154 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7155 unsigned int Args_stored
:1; /* 16 */
7156 unsigned int Variable_Frame
:1; /* 17 */
7157 unsigned int Separate_Package_Body
:1; /* 18 */
7158 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7159 unsigned int Stack_Overflow_Check
:1; /* 20 */
7160 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7161 unsigned int Ada_Region
:1; /* 22 */
7162 unsigned int cxx_info
:1; /* 23 */
7163 unsigned int cxx_try_catch
:1; /* 24 */
7164 unsigned int sched_entry_seq
:1; /* 25 */
7165 unsigned int reserved2
:1; /* 26 */
7166 unsigned int Save_SP
:1; /* 27 */
7167 unsigned int Save_RP
:1; /* 28 */
7168 unsigned int Save_MRP_in_frame
:1; /* 29 */
7169 unsigned int extn_ptr_defined
:1; /* 30 */
7170 unsigned int Cleanup_defined
:1; /* 31 */
7172 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7173 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7174 unsigned int Large_frame
:1; /* 2 */
7175 unsigned int Pseudo_SP_Set
:1; /* 3 */
7176 unsigned int reserved4
:1; /* 4 */
7177 unsigned int Total_frame_size
:27; /* 5..31 */
7180 struct hppa_unw_aux_info
7182 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7183 unsigned long table_len
; /* Length of unwind table. */
7184 bfd_vma seg_base
; /* Starting address of segment. */
7185 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7186 unsigned long nsyms
; /* Number of symbols. */
7187 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7188 unsigned long nfuns
; /* Number of entries in funtab. */
7189 char * strtab
; /* The string table. */
7190 unsigned long strtab_size
; /* Size of string table. */
7194 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7196 struct hppa_unw_table_entry
* tp
;
7197 unsigned long j
, nfuns
;
7199 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7200 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7201 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7202 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7204 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7206 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7209 const char * procname
;
7211 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7212 aux
->strtab_size
, tp
->start
, &procname
,
7215 fputs ("\n<", stdout
);
7219 fputs (procname
, stdout
);
7222 printf ("+%lx", (unsigned long) offset
);
7225 fputs (">: [", stdout
);
7226 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7227 fputc ('-', stdout
);
7228 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7231 #define PF(_m) if (tp->_m) printf (#_m " ");
7232 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7235 PF(Millicode_save_sr0
);
7236 /* PV(Region_description); */
7242 PF(Separate_Package_Body
);
7243 PF(Frame_Extension_Millicode
);
7244 PF(Stack_Overflow_Check
);
7245 PF(Two_Instruction_SP_Increment
);
7249 PF(sched_entry_seq
);
7252 PF(Save_MRP_in_frame
);
7253 PF(extn_ptr_defined
);
7254 PF(Cleanup_defined
);
7255 PF(MPE_XL_interrupt_marker
);
7256 PF(HP_UX_interrupt_marker
);
7259 PV(Total_frame_size
);
7270 slurp_hppa_unwind_table (FILE * file
,
7271 struct hppa_unw_aux_info
* aux
,
7272 Elf_Internal_Shdr
* sec
)
7274 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7275 Elf_Internal_Phdr
* seg
;
7276 struct hppa_unw_table_entry
* tep
;
7277 Elf_Internal_Shdr
* relsec
;
7278 Elf_Internal_Rela
* rela
;
7279 Elf_Internal_Rela
* rp
;
7280 unsigned char * table
;
7282 Elf_Internal_Sym
* sym
;
7283 const char * relname
;
7285 /* First, find the starting address of the segment that includes
7288 if (elf_header
.e_phnum
)
7290 if (! get_program_headers (file
))
7293 for (seg
= program_headers
;
7294 seg
< program_headers
+ elf_header
.e_phnum
;
7297 if (seg
->p_type
!= PT_LOAD
)
7300 if (sec
->sh_addr
>= seg
->p_vaddr
7301 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7303 aux
->seg_base
= seg
->p_vaddr
;
7309 /* Second, build the unwind table from the contents of the unwind
7311 size
= sec
->sh_size
;
7312 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7318 nentries
= size
/ unw_ent_size
;
7319 size
= unw_ent_size
* nentries
;
7321 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7322 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7324 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7326 unsigned int tmp1
, tmp2
;
7328 tep
->start
.section
= SHN_UNDEF
;
7329 tep
->end
.section
= SHN_UNDEF
;
7331 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7332 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7333 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7334 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7336 tep
->start
.offset
+= aux
->seg_base
;
7337 tep
->end
.offset
+= aux
->seg_base
;
7339 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7340 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7341 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7342 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7343 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7344 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7345 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7346 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7347 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7348 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7349 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7350 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7351 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7352 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7353 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7354 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7355 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7356 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7357 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7358 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7359 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7360 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7361 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7362 tep
->Cleanup_defined
= tmp1
& 0x1;
7364 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7365 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7366 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7367 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7368 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7369 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7373 /* Third, apply any relocations to the unwind table. */
7374 for (relsec
= section_headers
;
7375 relsec
< section_headers
+ elf_header
.e_shnum
;
7378 if (relsec
->sh_type
!= SHT_RELA
7379 || relsec
->sh_info
>= elf_header
.e_shnum
7380 || section_headers
+ relsec
->sh_info
!= sec
)
7383 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7387 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7389 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7390 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7392 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7393 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7395 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7399 i
= rp
->r_offset
/ unw_ent_size
;
7401 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7404 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7405 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7408 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7409 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7419 aux
->table_len
= nentries
;
7425 hppa_process_unwind (FILE * file
)
7427 struct hppa_unw_aux_info aux
;
7428 Elf_Internal_Shdr
* unwsec
= NULL
;
7429 Elf_Internal_Shdr
* strsec
;
7430 Elf_Internal_Shdr
* sec
;
7433 if (string_table
== NULL
)
7436 memset (& aux
, 0, sizeof (aux
));
7438 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7440 if (sec
->sh_type
== SHT_SYMTAB
7441 && sec
->sh_link
< elf_header
.e_shnum
)
7443 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7445 strsec
= section_headers
+ sec
->sh_link
;
7446 if (aux
.strtab
!= NULL
)
7448 error (_("Multiple auxillary string tables encountered\n"));
7451 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7454 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7456 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7461 printf (_("\nThere are no unwind sections in this file.\n"));
7463 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7465 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7467 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7468 printable_section_name (sec
),
7469 (unsigned long) sec
->sh_offset
,
7470 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7472 slurp_hppa_unwind_table (file
, &aux
, sec
);
7473 if (aux
.table_len
> 0)
7474 dump_hppa_unwind (&aux
);
7477 free ((char *) aux
.table
);
7485 free ((char *) aux
.strtab
);
7490 unsigned char * data
; /* The unwind data. */
7491 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7492 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7493 unsigned long nrelas
; /* The number of relocations. */
7494 unsigned int rel_type
; /* REL or RELA ? */
7495 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7498 struct arm_unw_aux_info
7500 FILE * file
; /* The file containing the unwind sections. */
7501 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7502 unsigned long nsyms
; /* Number of symbols. */
7503 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7504 unsigned long nfuns
; /* Number of these symbols. */
7505 char * strtab
; /* The file's string table. */
7506 unsigned long strtab_size
; /* Size of string table. */
7510 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7511 bfd_vma fn
, struct absaddr addr
)
7513 const char *procname
;
7516 if (addr
.section
== SHN_UNDEF
)
7519 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7520 aux
->strtab_size
, addr
, &procname
,
7523 print_vma (fn
, PREFIX_HEX
);
7527 fputs (" <", stdout
);
7528 fputs (procname
, stdout
);
7531 printf ("+0x%lx", (unsigned long) sym_offset
);
7532 fputc ('>', stdout
);
7539 arm_free_section (struct arm_section
*arm_sec
)
7541 if (arm_sec
->data
!= NULL
)
7542 free (arm_sec
->data
);
7544 if (arm_sec
->rela
!= NULL
)
7545 free (arm_sec
->rela
);
7548 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7549 cached section and install SEC instead.
7550 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7551 and return its valued in * WORDP, relocating if necessary.
7552 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7553 relocation's offset in ADDR.
7554 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7555 into the string table of the symbol associated with the reloc. If no
7556 reloc was applied store -1 there.
7557 5) Return TRUE upon success, FALSE otherwise. */
7560 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7561 struct arm_section
* arm_sec
,
7562 Elf_Internal_Shdr
* sec
,
7563 bfd_vma word_offset
,
7564 unsigned int * wordp
,
7565 struct absaddr
* addr
,
7568 Elf_Internal_Rela
*rp
;
7569 Elf_Internal_Sym
*sym
;
7570 const char * relname
;
7572 bfd_boolean wrapped
;
7574 if (sec
== NULL
|| arm_sec
== NULL
)
7577 addr
->section
= SHN_UNDEF
;
7580 if (sym_name
!= NULL
)
7581 *sym_name
= (bfd_vma
) -1;
7583 /* If necessary, update the section cache. */
7584 if (sec
!= arm_sec
->sec
)
7586 Elf_Internal_Shdr
*relsec
;
7588 arm_free_section (arm_sec
);
7591 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7592 sec
->sh_size
, _("unwind data"));
7593 arm_sec
->rela
= NULL
;
7594 arm_sec
->nrelas
= 0;
7596 for (relsec
= section_headers
;
7597 relsec
< section_headers
+ elf_header
.e_shnum
;
7600 if (relsec
->sh_info
>= elf_header
.e_shnum
7601 || section_headers
+ relsec
->sh_info
!= sec
7602 /* PR 15745: Check the section type as well. */
7603 || (relsec
->sh_type
!= SHT_REL
7604 && relsec
->sh_type
!= SHT_RELA
))
7607 arm_sec
->rel_type
= relsec
->sh_type
;
7608 if (relsec
->sh_type
== SHT_REL
)
7610 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7612 & arm_sec
->rela
, & arm_sec
->nrelas
))
7615 else /* relsec->sh_type == SHT_RELA */
7617 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7619 & arm_sec
->rela
, & arm_sec
->nrelas
))
7625 arm_sec
->next_rela
= arm_sec
->rela
;
7628 /* If there is no unwind data we can do nothing. */
7629 if (arm_sec
->data
== NULL
)
7632 /* If the offset is invalid then fail. */
7633 if (word_offset
> (sec
->sh_size
- 4)
7635 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7636 || ((bfd_signed_vma
) word_offset
) < 0)
7639 /* Get the word at the required offset. */
7640 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7642 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7643 if (arm_sec
->rela
== NULL
)
7649 /* Look through the relocs to find the one that applies to the provided offset. */
7651 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7653 bfd_vma prelval
, offset
;
7655 if (rp
->r_offset
> word_offset
&& !wrapped
)
7660 if (rp
->r_offset
> word_offset
)
7663 if (rp
->r_offset
& 3)
7665 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7666 (unsigned long) rp
->r_offset
);
7670 if (rp
->r_offset
< word_offset
)
7673 /* PR 17531: file: 027-161405-0.004 */
7674 if (aux
->symtab
== NULL
)
7677 if (arm_sec
->rel_type
== SHT_REL
)
7679 offset
= word
& 0x7fffffff;
7680 if (offset
& 0x40000000)
7681 offset
|= ~ (bfd_vma
) 0x7fffffff;
7683 else if (arm_sec
->rel_type
== SHT_RELA
)
7684 offset
= rp
->r_addend
;
7687 error (_("Unknown section relocation type %d encountered\n"),
7692 /* PR 17531 file: 027-1241568-0.004. */
7693 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7695 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7696 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7700 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7701 offset
+= sym
->st_value
;
7702 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7704 /* Check that we are processing the expected reloc type. */
7705 if (elf_header
.e_machine
== EM_ARM
)
7707 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7708 if (relname
== NULL
)
7710 warn (_("Skipping unknown ARM relocation type: %d\n"),
7711 (int) ELF32_R_TYPE (rp
->r_info
));
7715 if (streq (relname
, "R_ARM_NONE"))
7718 if (! streq (relname
, "R_ARM_PREL31"))
7720 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7724 else if (elf_header
.e_machine
== EM_TI_C6000
)
7726 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7727 if (relname
== NULL
)
7729 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7730 (int) ELF32_R_TYPE (rp
->r_info
));
7734 if (streq (relname
, "R_C6000_NONE"))
7737 if (! streq (relname
, "R_C6000_PREL31"))
7739 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7747 /* This function currently only supports ARM and TI unwinders. */
7748 warn (_("Only TI and ARM unwinders are currently supported\n"));
7752 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7753 addr
->section
= sym
->st_shndx
;
7754 addr
->offset
= offset
;
7757 * sym_name
= sym
->st_name
;
7762 arm_sec
->next_rela
= rp
;
7767 static const char *tic6x_unwind_regnames
[16] =
7769 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7770 "A14", "A13", "A12", "A11", "A10",
7771 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7775 decode_tic6x_unwind_regmask (unsigned int mask
)
7779 for (i
= 12; mask
; mask
>>= 1, i
--)
7783 fputs (tic6x_unwind_regnames
[i
], stdout
);
7785 fputs (", ", stdout
);
7791 if (remaining == 0 && more_words) \
7794 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7795 data_offset, & word, & addr, NULL)) \
7801 #define GET_OP(OP) \
7806 (OP) = word >> 24; \
7811 printf (_("[Truncated opcode]\n")); \
7814 printf ("0x%02x ", OP)
7817 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7819 unsigned int remaining
,
7820 unsigned int more_words
,
7821 bfd_vma data_offset
,
7822 Elf_Internal_Shdr
* data_sec
,
7823 struct arm_section
* data_arm_sec
)
7825 struct absaddr addr
;
7827 /* Decode the unwinding instructions. */
7830 unsigned int op
, op2
;
7839 printf (" 0x%02x ", op
);
7841 if ((op
& 0xc0) == 0x00)
7843 int offset
= ((op
& 0x3f) << 2) + 4;
7845 printf (" vsp = vsp + %d", offset
);
7847 else if ((op
& 0xc0) == 0x40)
7849 int offset
= ((op
& 0x3f) << 2) + 4;
7851 printf (" vsp = vsp - %d", offset
);
7853 else if ((op
& 0xf0) == 0x80)
7856 if (op
== 0x80 && op2
== 0)
7857 printf (_("Refuse to unwind"));
7860 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7865 for (i
= 0; i
< 12; i
++)
7866 if (mask
& (1 << i
))
7872 printf ("r%d", 4 + i
);
7877 else if ((op
& 0xf0) == 0x90)
7879 if (op
== 0x9d || op
== 0x9f)
7880 printf (_(" [Reserved]"));
7882 printf (" vsp = r%d", op
& 0x0f);
7884 else if ((op
& 0xf0) == 0xa0)
7886 int end
= 4 + (op
& 0x07);
7891 for (i
= 4; i
<= end
; i
++)
7907 else if (op
== 0xb0)
7908 printf (_(" finish"));
7909 else if (op
== 0xb1)
7912 if (op2
== 0 || (op2
& 0xf0) != 0)
7913 printf (_("[Spare]"));
7916 unsigned int mask
= op2
& 0x0f;
7921 for (i
= 0; i
< 12; i
++)
7922 if (mask
& (1 << i
))
7933 else if (op
== 0xb2)
7935 unsigned char buf
[9];
7936 unsigned int i
, len
;
7937 unsigned long offset
;
7939 for (i
= 0; i
< sizeof (buf
); i
++)
7942 if ((buf
[i
] & 0x80) == 0)
7945 if (i
== sizeof (buf
))
7946 printf (_("corrupt change to vsp"));
7949 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7950 assert (len
== i
+ 1);
7951 offset
= offset
* 4 + 0x204;
7952 printf ("vsp = vsp + %ld", offset
);
7955 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7957 unsigned int first
, last
;
7964 printf ("pop {D%d", first
);
7966 printf ("-D%d", first
+ last
);
7969 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7971 unsigned int count
= op
& 0x07;
7975 printf ("-D%d", 8 + count
);
7978 else if (op
>= 0xc0 && op
<= 0xc5)
7980 unsigned int count
= op
& 0x07;
7982 printf (" pop {wR10");
7984 printf ("-wR%d", 10 + count
);
7987 else if (op
== 0xc6)
7989 unsigned int first
, last
;
7994 printf ("pop {wR%d", first
);
7996 printf ("-wR%d", first
+ last
);
7999 else if (op
== 0xc7)
8002 if (op2
== 0 || (op2
& 0xf0) != 0)
8003 printf (_("[Spare]"));
8006 unsigned int mask
= op2
& 0x0f;
8011 for (i
= 0; i
< 4; i
++)
8012 if (mask
& (1 << i
))
8018 printf ("wCGR%d", i
);
8024 printf (_(" [unsupported opcode]"));
8030 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8032 unsigned int remaining
,
8033 unsigned int more_words
,
8034 bfd_vma data_offset
,
8035 Elf_Internal_Shdr
* data_sec
,
8036 struct arm_section
* data_arm_sec
)
8038 struct absaddr addr
;
8040 /* Decode the unwinding instructions. */
8043 unsigned int op
, op2
;
8052 printf (" 0x%02x ", op
);
8054 if ((op
& 0xc0) == 0x00)
8056 int offset
= ((op
& 0x3f) << 3) + 8;
8057 printf (" sp = sp + %d", offset
);
8059 else if ((op
& 0xc0) == 0x80)
8062 if (op
== 0x80 && op2
== 0)
8063 printf (_("Refuse to unwind"));
8066 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8068 printf ("pop compact {");
8072 decode_tic6x_unwind_regmask (mask
);
8076 else if ((op
& 0xf0) == 0xc0)
8084 unsigned int offset
;
8088 /* Scan entire instruction first so that GET_OP output is not
8089 interleaved with disassembly. */
8091 for (i
= 0; nregs
< (op
& 0xf); i
++)
8097 regpos
[nregs
].offset
= i
* 2;
8098 regpos
[nregs
].reg
= reg
;
8105 regpos
[nregs
].offset
= i
* 2 + 1;
8106 regpos
[nregs
].reg
= reg
;
8111 printf (_("pop frame {"));
8113 for (i
= i
* 2; i
> 0; i
--)
8115 if (regpos
[reg
].offset
== i
- 1)
8117 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8124 fputs (name
, stdout
);
8131 else if (op
== 0xd0)
8132 printf (" MOV FP, SP");
8133 else if (op
== 0xd1)
8134 printf (" __c6xabi_pop_rts");
8135 else if (op
== 0xd2)
8137 unsigned char buf
[9];
8138 unsigned int i
, len
;
8139 unsigned long offset
;
8141 for (i
= 0; i
< sizeof (buf
); i
++)
8144 if ((buf
[i
] & 0x80) == 0)
8147 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8148 if (i
== sizeof (buf
))
8150 printf ("<corrupt sp adjust>\n");
8151 warn (_("Corrupt stack pointer adjustment detected\n"));
8155 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8156 assert (len
== i
+ 1);
8157 offset
= offset
* 8 + 0x408;
8158 printf (_("sp = sp + %ld"), offset
);
8160 else if ((op
& 0xf0) == 0xe0)
8162 if ((op
& 0x0f) == 7)
8165 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8169 printf (_(" [unsupported opcode]"));
8176 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8180 offset
= word
& 0x7fffffff;
8181 if (offset
& 0x40000000)
8182 offset
|= ~ (bfd_vma
) 0x7fffffff;
8184 if (elf_header
.e_machine
== EM_TI_C6000
)
8187 return offset
+ where
;
8191 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8193 unsigned int remaining
,
8194 bfd_vma data_offset
,
8195 Elf_Internal_Shdr
* data_sec
,
8196 struct arm_section
* data_arm_sec
)
8199 unsigned int more_words
= 0;
8200 struct absaddr addr
;
8201 bfd_vma sym_name
= (bfd_vma
) -1;
8205 /* Fetch the first word.
8206 Note - when decoding an object file the address extracted
8207 here will always be 0. So we also pass in the sym_name
8208 parameter so that we can find the symbol associated with
8209 the personality routine. */
8210 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8211 & word
, & addr
, & sym_name
))
8217 if ((word
& 0x80000000) == 0)
8219 /* Expand prel31 for personality routine. */
8221 const char *procname
;
8223 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8224 printf (_(" Personality routine: "));
8226 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8227 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8229 procname
= aux
->strtab
+ sym_name
;
8230 print_vma (fn
, PREFIX_HEX
);
8233 fputs (" <", stdout
);
8234 fputs (procname
, stdout
);
8235 fputc ('>', stdout
);
8239 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8240 fputc ('\n', stdout
);
8242 /* The GCC personality routines use the standard compact
8243 encoding, starting with one byte giving the number of
8245 if (procname
!= NULL
8246 && (const_strneq (procname
, "__gcc_personality_v0")
8247 || const_strneq (procname
, "__gxx_personality_v0")
8248 || const_strneq (procname
, "__gcj_personality_v0")
8249 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8256 printf (_(" [Truncated data]\n"));
8259 more_words
= word
>> 24;
8269 /* ARM EHABI Section 6.3:
8271 An exception-handling table entry for the compact model looks like:
8275 1 0 index Data for personalityRoutine[index] */
8277 if (elf_header
.e_machine
== EM_ARM
8278 && (word
& 0x70000000))
8279 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8281 per_index
= (word
>> 24) & 0x7f;
8282 printf (_(" Compact model index: %d\n"), per_index
);
8289 else if (per_index
< 3)
8291 more_words
= (word
>> 16) & 0xff;
8297 switch (elf_header
.e_machine
)
8302 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8303 data_offset
, data_sec
, data_arm_sec
);
8307 warn (_("Unknown ARM compact model index encountered\n"));
8308 printf (_(" [reserved]\n"));
8315 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8316 data_offset
, data_sec
, data_arm_sec
);
8318 else if (per_index
< 5)
8320 if (((word
>> 17) & 0x7f) == 0x7f)
8321 printf (_(" Restore stack from frame pointer\n"));
8323 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8324 printf (_(" Registers restored: "));
8326 printf (" (compact) ");
8327 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8329 printf (_(" Return register: %s\n"),
8330 tic6x_unwind_regnames
[word
& 0xf]);
8333 printf (_(" [reserved (%d)]\n"), per_index
);
8337 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8338 elf_header
.e_machine
);
8341 /* Decode the descriptors. Not implemented. */
8345 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8347 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8348 unsigned int i
, exidx_len
;
8349 unsigned long j
, nfuns
;
8351 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8352 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8353 exidx_len
= exidx_sec
->sh_size
/ 8;
8355 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8356 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8357 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8358 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8360 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8362 for (i
= 0; i
< exidx_len
; i
++)
8364 unsigned int exidx_fn
, exidx_entry
;
8365 struct absaddr fn_addr
, entry_addr
;
8368 fputc ('\n', stdout
);
8370 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8371 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8372 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8373 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8376 arm_free_section (& exidx_arm_sec
);
8377 arm_free_section (& extab_arm_sec
);
8381 /* ARM EHABI, Section 5:
8382 An index table entry consists of 2 words.
8383 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8384 if (exidx_fn
& 0x80000000)
8385 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8387 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8389 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8390 fputs (": ", stdout
);
8392 if (exidx_entry
== 1)
8394 print_vma (exidx_entry
, PREFIX_HEX
);
8395 fputs (" [cantunwind]\n", stdout
);
8397 else if (exidx_entry
& 0x80000000)
8399 print_vma (exidx_entry
, PREFIX_HEX
);
8400 fputc ('\n', stdout
);
8401 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8405 bfd_vma table
, table_offset
= 0;
8406 Elf_Internal_Shdr
*table_sec
;
8408 fputs ("@", stdout
);
8409 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8410 print_vma (table
, PREFIX_HEX
);
8413 /* Locate the matching .ARM.extab. */
8414 if (entry_addr
.section
!= SHN_UNDEF
8415 && entry_addr
.section
< elf_header
.e_shnum
)
8417 table_sec
= section_headers
+ entry_addr
.section
;
8418 table_offset
= entry_addr
.offset
;
8420 if (table_offset
> table_sec
->sh_size
8421 || ((bfd_signed_vma
) table_offset
) < 0)
8423 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8424 (unsigned long) table_offset
,
8425 printable_section_name (table_sec
));
8431 table_sec
= find_section_by_address (table
);
8432 if (table_sec
!= NULL
)
8433 table_offset
= table
- table_sec
->sh_addr
;
8435 if (table_sec
== NULL
)
8437 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8438 (unsigned long) table
);
8441 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8449 arm_free_section (&exidx_arm_sec
);
8450 arm_free_section (&extab_arm_sec
);
8453 /* Used for both ARM and C6X unwinding tables. */
8456 arm_process_unwind (FILE *file
)
8458 struct arm_unw_aux_info aux
;
8459 Elf_Internal_Shdr
*unwsec
= NULL
;
8460 Elf_Internal_Shdr
*strsec
;
8461 Elf_Internal_Shdr
*sec
;
8463 unsigned int sec_type
;
8465 switch (elf_header
.e_machine
)
8468 sec_type
= SHT_ARM_EXIDX
;
8472 sec_type
= SHT_C6000_UNWIND
;
8476 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8477 elf_header
.e_machine
);
8481 if (string_table
== NULL
)
8484 memset (& aux
, 0, sizeof (aux
));
8487 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8489 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8491 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8493 strsec
= section_headers
+ sec
->sh_link
;
8495 /* PR binutils/17531 file: 011-12666-0.004. */
8496 if (aux
.strtab
!= NULL
)
8498 error (_("Multiple string tables found in file.\n"));
8501 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8502 1, strsec
->sh_size
, _("string table"));
8503 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8505 else if (sec
->sh_type
== sec_type
)
8510 printf (_("\nThere are no unwind sections in this file.\n"));
8512 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8514 if (sec
->sh_type
== sec_type
)
8516 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8517 printable_section_name (sec
),
8518 (unsigned long) sec
->sh_offset
,
8519 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8521 dump_arm_unwind (&aux
, sec
);
8528 free ((char *) aux
.strtab
);
8532 process_unwind (FILE * file
)
8534 struct unwind_handler
8537 void (* handler
)(FILE *);
8540 { EM_ARM
, arm_process_unwind
},
8541 { EM_IA_64
, ia64_process_unwind
},
8542 { EM_PARISC
, hppa_process_unwind
},
8543 { EM_TI_C6000
, arm_process_unwind
},
8551 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8552 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8554 handlers
[i
].handler (file
);
8558 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8559 get_machine_name (elf_header
.e_machine
));
8563 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8565 switch (entry
->d_tag
)
8568 if (entry
->d_un
.d_val
== 0)
8572 static const char * opts
[] =
8574 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8575 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8576 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8577 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8583 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8584 if (entry
->d_un
.d_val
& (1 << cnt
))
8586 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8592 case DT_MIPS_IVERSION
:
8593 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8594 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8598 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8599 /* Note: coded this way so that there is a single string for translation. */
8600 printf (_("<corrupt: %s>"), buf
);
8604 case DT_MIPS_TIME_STAMP
:
8608 time_t atime
= entry
->d_un
.d_val
;
8610 tmp
= gmtime (&atime
);
8611 /* PR 17531: file: 6accc532. */
8613 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8615 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8616 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8617 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8618 printf (_("Time Stamp: %s"), timebuf
);
8622 case DT_MIPS_RLD_VERSION
:
8623 case DT_MIPS_LOCAL_GOTNO
:
8624 case DT_MIPS_CONFLICTNO
:
8625 case DT_MIPS_LIBLISTNO
:
8626 case DT_MIPS_SYMTABNO
:
8627 case DT_MIPS_UNREFEXTNO
:
8628 case DT_MIPS_HIPAGENO
:
8629 case DT_MIPS_DELTA_CLASS_NO
:
8630 case DT_MIPS_DELTA_INSTANCE_NO
:
8631 case DT_MIPS_DELTA_RELOC_NO
:
8632 case DT_MIPS_DELTA_SYM_NO
:
8633 case DT_MIPS_DELTA_CLASSSYM_NO
:
8634 case DT_MIPS_COMPACT_SIZE
:
8635 print_vma (entry
->d_un
.d_ptr
, DEC
);
8639 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8645 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8647 switch (entry
->d_tag
)
8649 case DT_HP_DLD_FLAGS
:
8658 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8659 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8660 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8661 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8662 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8663 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8664 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8665 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8666 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8667 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8668 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8669 { DT_HP_GST
, "HP_GST" },
8670 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8671 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8672 { DT_HP_NODELETE
, "HP_NODELETE" },
8673 { DT_HP_GROUP
, "HP_GROUP" },
8674 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8678 bfd_vma val
= entry
->d_un
.d_val
;
8680 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8681 if (val
& flags
[cnt
].bit
)
8685 fputs (flags
[cnt
].str
, stdout
);
8687 val
^= flags
[cnt
].bit
;
8690 if (val
!= 0 || first
)
8694 print_vma (val
, HEX
);
8700 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8708 /* VMS vs Unix time offset and factor. */
8710 #define VMS_EPOCH_OFFSET 35067168000000000LL
8711 #define VMS_GRANULARITY_FACTOR 10000000
8713 /* Display a VMS time in a human readable format. */
8716 print_vms_time (bfd_int64_t vmstime
)
8721 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8722 tm
= gmtime (&unxtime
);
8723 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8724 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8725 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8730 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8732 switch (entry
->d_tag
)
8734 case DT_IA_64_PLT_RESERVE
:
8735 /* First 3 slots reserved. */
8736 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8738 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8741 case DT_IA_64_VMS_LINKTIME
:
8743 print_vms_time (entry
->d_un
.d_val
);
8747 case DT_IA_64_VMS_LNKFLAGS
:
8748 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8749 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8750 printf (" CALL_DEBUG");
8751 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8752 printf (" NOP0BUFS");
8753 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8754 printf (" P0IMAGE");
8755 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8756 printf (" MKTHREADS");
8757 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8758 printf (" UPCALLS");
8759 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8761 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8762 printf (" INITIALIZE");
8763 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8765 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8766 printf (" EXE_INIT");
8767 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8768 printf (" TBK_IN_IMG");
8769 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8770 printf (" DBG_IN_IMG");
8771 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8772 printf (" TBK_IN_DSF");
8773 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8774 printf (" DBG_IN_DSF");
8775 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8776 printf (" SIGNATURES");
8777 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8778 printf (" REL_SEG_OFF");
8782 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8789 get_32bit_dynamic_section (FILE * file
)
8791 Elf32_External_Dyn
* edyn
;
8792 Elf32_External_Dyn
* ext
;
8793 Elf_Internal_Dyn
* entry
;
8795 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8796 dynamic_size
, _("dynamic section"));
8800 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8801 might not have the luxury of section headers. Look for the DT_NULL
8802 terminator to determine the number of entries. */
8803 for (ext
= edyn
, dynamic_nent
= 0;
8804 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8808 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8812 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8814 if (dynamic_section
== NULL
)
8816 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8817 (unsigned long) dynamic_nent
);
8822 for (ext
= edyn
, entry
= dynamic_section
;
8823 entry
< dynamic_section
+ dynamic_nent
;
8826 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8827 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8836 get_64bit_dynamic_section (FILE * file
)
8838 Elf64_External_Dyn
* edyn
;
8839 Elf64_External_Dyn
* ext
;
8840 Elf_Internal_Dyn
* entry
;
8842 /* Read in the data. */
8843 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8844 dynamic_size
, _("dynamic section"));
8848 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8849 might not have the luxury of section headers. Look for the DT_NULL
8850 terminator to determine the number of entries. */
8851 for (ext
= edyn
, dynamic_nent
= 0;
8852 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8853 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8857 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8861 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8863 if (dynamic_section
== NULL
)
8865 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8866 (unsigned long) dynamic_nent
);
8871 /* Convert from external to internal formats. */
8872 for (ext
= edyn
, entry
= dynamic_section
;
8873 entry
< dynamic_section
+ dynamic_nent
;
8876 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8877 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8886 print_dynamic_flags (bfd_vma flags
)
8894 flag
= flags
& - flags
;
8904 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8905 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8906 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8907 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8908 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8909 default: fputs (_("unknown"), stdout
); break;
8915 /* Parse and display the contents of the dynamic section. */
8918 process_dynamic_section (FILE * file
)
8920 Elf_Internal_Dyn
* entry
;
8922 if (dynamic_size
== 0)
8925 printf (_("\nThere is no dynamic section in this file.\n"));
8932 if (! get_32bit_dynamic_section (file
))
8935 else if (! get_64bit_dynamic_section (file
))
8938 /* Find the appropriate symbol table. */
8939 if (dynamic_symbols
== NULL
)
8941 for (entry
= dynamic_section
;
8942 entry
< dynamic_section
+ dynamic_nent
;
8945 Elf_Internal_Shdr section
;
8947 if (entry
->d_tag
!= DT_SYMTAB
)
8950 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8952 /* Since we do not know how big the symbol table is,
8953 we default to reading in the entire file (!) and
8954 processing that. This is overkill, I know, but it
8956 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8958 if (archive_file_offset
!= 0)
8959 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8962 if (fseek (file
, 0, SEEK_END
))
8963 error (_("Unable to seek to end of file!\n"));
8965 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8969 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8971 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8972 section
.sh_name
= string_table_length
;
8974 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8975 if (num_dynamic_syms
< 1)
8977 error (_("Unable to determine the number of symbols to load\n"));
8983 /* Similarly find a string table. */
8984 if (dynamic_strings
== NULL
)
8986 for (entry
= dynamic_section
;
8987 entry
< dynamic_section
+ dynamic_nent
;
8990 unsigned long offset
;
8993 if (entry
->d_tag
!= DT_STRTAB
)
8996 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8998 /* Since we do not know how big the string table is,
8999 we default to reading in the entire file (!) and
9000 processing that. This is overkill, I know, but it
9003 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9005 if (archive_file_offset
!= 0)
9006 str_tab_len
= archive_file_size
- offset
;
9009 if (fseek (file
, 0, SEEK_END
))
9010 error (_("Unable to seek to end of file\n"));
9011 str_tab_len
= ftell (file
) - offset
;
9014 if (str_tab_len
< 1)
9017 (_("Unable to determine the length of the dynamic string table\n"));
9021 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9023 _("dynamic string table"));
9024 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9029 /* And find the syminfo section if available. */
9030 if (dynamic_syminfo
== NULL
)
9032 unsigned long syminsz
= 0;
9034 for (entry
= dynamic_section
;
9035 entry
< dynamic_section
+ dynamic_nent
;
9038 if (entry
->d_tag
== DT_SYMINENT
)
9040 /* Note: these braces are necessary to avoid a syntax
9041 error from the SunOS4 C compiler. */
9042 /* PR binutils/17531: A corrupt file can trigger this test.
9043 So do not use an assert, instead generate an error message. */
9044 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9045 error (_("Bad value (%d) for SYMINENT entry\n"),
9046 (int) entry
->d_un
.d_val
);
9048 else if (entry
->d_tag
== DT_SYMINSZ
)
9049 syminsz
= entry
->d_un
.d_val
;
9050 else if (entry
->d_tag
== DT_SYMINFO
)
9051 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9055 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9057 Elf_External_Syminfo
* extsyminfo
;
9058 Elf_External_Syminfo
* extsym
;
9059 Elf_Internal_Syminfo
* syminfo
;
9061 /* There is a syminfo section. Read the data. */
9062 extsyminfo
= (Elf_External_Syminfo
*)
9063 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9064 _("symbol information"));
9068 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9069 if (dynamic_syminfo
== NULL
)
9071 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9072 (unsigned long) syminsz
);
9076 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9077 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9078 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9079 ++syminfo
, ++extsym
)
9081 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9082 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9089 if (do_dynamic
&& dynamic_addr
)
9090 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9091 dynamic_addr
, (unsigned long) dynamic_nent
);
9093 printf (_(" Tag Type Name/Value\n"));
9095 for (entry
= dynamic_section
;
9096 entry
< dynamic_section
+ dynamic_nent
;
9104 print_vma (entry
->d_tag
, FULL_HEX
);
9105 dtype
= get_dynamic_type (entry
->d_tag
);
9106 printf (" (%s)%*s", dtype
,
9107 ((is_32bit_elf
? 27 : 19)
9108 - (int) strlen (dtype
)),
9112 switch (entry
->d_tag
)
9116 print_dynamic_flags (entry
->d_un
.d_val
);
9126 switch (entry
->d_tag
)
9129 printf (_("Auxiliary library"));
9133 printf (_("Filter library"));
9137 printf (_("Configuration file"));
9141 printf (_("Dependency audit library"));
9145 printf (_("Audit library"));
9149 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9150 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9154 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9163 printf (_("Flags:"));
9165 if (entry
->d_un
.d_val
== 0)
9166 printf (_(" None\n"));
9169 unsigned long int val
= entry
->d_un
.d_val
;
9171 if (val
& DTF_1_PARINIT
)
9173 printf (" PARINIT");
9174 val
^= DTF_1_PARINIT
;
9176 if (val
& DTF_1_CONFEXP
)
9178 printf (" CONFEXP");
9179 val
^= DTF_1_CONFEXP
;
9182 printf (" %lx", val
);
9191 printf (_("Flags:"));
9193 if (entry
->d_un
.d_val
== 0)
9194 printf (_(" None\n"));
9197 unsigned long int val
= entry
->d_un
.d_val
;
9199 if (val
& DF_P1_LAZYLOAD
)
9201 printf (" LAZYLOAD");
9202 val
^= DF_P1_LAZYLOAD
;
9204 if (val
& DF_P1_GROUPPERM
)
9206 printf (" GROUPPERM");
9207 val
^= DF_P1_GROUPPERM
;
9210 printf (" %lx", val
);
9219 printf (_("Flags:"));
9220 if (entry
->d_un
.d_val
== 0)
9221 printf (_(" None\n"));
9224 unsigned long int val
= entry
->d_un
.d_val
;
9231 if (val
& DF_1_GLOBAL
)
9236 if (val
& DF_1_GROUP
)
9241 if (val
& DF_1_NODELETE
)
9243 printf (" NODELETE");
9244 val
^= DF_1_NODELETE
;
9246 if (val
& DF_1_LOADFLTR
)
9248 printf (" LOADFLTR");
9249 val
^= DF_1_LOADFLTR
;
9251 if (val
& DF_1_INITFIRST
)
9253 printf (" INITFIRST");
9254 val
^= DF_1_INITFIRST
;
9256 if (val
& DF_1_NOOPEN
)
9261 if (val
& DF_1_ORIGIN
)
9266 if (val
& DF_1_DIRECT
)
9271 if (val
& DF_1_TRANS
)
9276 if (val
& DF_1_INTERPOSE
)
9278 printf (" INTERPOSE");
9279 val
^= DF_1_INTERPOSE
;
9281 if (val
& DF_1_NODEFLIB
)
9283 printf (" NODEFLIB");
9284 val
^= DF_1_NODEFLIB
;
9286 if (val
& DF_1_NODUMP
)
9291 if (val
& DF_1_CONFALT
)
9293 printf (" CONFALT");
9294 val
^= DF_1_CONFALT
;
9296 if (val
& DF_1_ENDFILTEE
)
9298 printf (" ENDFILTEE");
9299 val
^= DF_1_ENDFILTEE
;
9301 if (val
& DF_1_DISPRELDNE
)
9303 printf (" DISPRELDNE");
9304 val
^= DF_1_DISPRELDNE
;
9306 if (val
& DF_1_DISPRELPND
)
9308 printf (" DISPRELPND");
9309 val
^= DF_1_DISPRELPND
;
9311 if (val
& DF_1_NODIRECT
)
9313 printf (" NODIRECT");
9314 val
^= DF_1_NODIRECT
;
9316 if (val
& DF_1_IGNMULDEF
)
9318 printf (" IGNMULDEF");
9319 val
^= DF_1_IGNMULDEF
;
9321 if (val
& DF_1_NOKSYMS
)
9323 printf (" NOKSYMS");
9324 val
^= DF_1_NOKSYMS
;
9326 if (val
& DF_1_NOHDR
)
9331 if (val
& DF_1_EDITED
)
9336 if (val
& DF_1_NORELOC
)
9338 printf (" NORELOC");
9339 val
^= DF_1_NORELOC
;
9341 if (val
& DF_1_SYMINTPOSE
)
9343 printf (" SYMINTPOSE");
9344 val
^= DF_1_SYMINTPOSE
;
9346 if (val
& DF_1_GLOBAUDIT
)
9348 printf (" GLOBAUDIT");
9349 val
^= DF_1_GLOBAUDIT
;
9351 if (val
& DF_1_SINGLETON
)
9353 printf (" SINGLETON");
9354 val
^= DF_1_SINGLETON
;
9356 if (val
& DF_1_STUB
)
9367 printf (" %lx", val
);
9374 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9376 puts (get_dynamic_type (entry
->d_un
.d_val
));
9396 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9402 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9403 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9409 switch (entry
->d_tag
)
9412 printf (_("Shared library: [%s]"), name
);
9414 if (streq (name
, program_interpreter
))
9415 printf (_(" program interpreter"));
9419 printf (_("Library soname: [%s]"), name
);
9423 printf (_("Library rpath: [%s]"), name
);
9427 printf (_("Library runpath: [%s]"), name
);
9431 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9436 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9449 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9453 case DT_INIT_ARRAYSZ
:
9454 case DT_FINI_ARRAYSZ
:
9455 case DT_GNU_CONFLICTSZ
:
9456 case DT_GNU_LIBLISTSZ
:
9459 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9460 printf (_(" (bytes)\n"));
9470 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9483 if (entry
->d_tag
== DT_USED
9484 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9486 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9490 printf (_("Not needed object: [%s]\n"), name
);
9495 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9501 /* The value of this entry is ignored. */
9506 case DT_GNU_PRELINKED
:
9510 time_t atime
= entry
->d_un
.d_val
;
9512 tmp
= gmtime (&atime
);
9513 /* PR 17533 file: 041-1244816-0.004. */
9515 printf (_("<corrupt time val: %lx"),
9516 (unsigned long) atime
);
9518 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9519 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9520 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9526 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9529 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9535 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9536 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9541 switch (elf_header
.e_machine
)
9544 case EM_MIPS_RS3_LE
:
9545 dynamic_section_mips_val (entry
);
9548 dynamic_section_parisc_val (entry
);
9551 dynamic_section_ia64_val (entry
);
9554 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9566 get_ver_flags (unsigned int flags
)
9568 static char buff
[32];
9575 if (flags
& VER_FLG_BASE
)
9576 strcat (buff
, "BASE ");
9578 if (flags
& VER_FLG_WEAK
)
9580 if (flags
& VER_FLG_BASE
)
9581 strcat (buff
, "| ");
9583 strcat (buff
, "WEAK ");
9586 if (flags
& VER_FLG_INFO
)
9588 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9589 strcat (buff
, "| ");
9591 strcat (buff
, "INFO ");
9594 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9595 strcat (buff
, _("| <unknown>"));
9600 /* Display the contents of the version sections. */
9603 process_version_sections (FILE * file
)
9605 Elf_Internal_Shdr
* section
;
9612 for (i
= 0, section
= section_headers
;
9613 i
< elf_header
.e_shnum
;
9616 switch (section
->sh_type
)
9618 case SHT_GNU_verdef
:
9620 Elf_External_Verdef
* edefs
;
9627 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9628 printable_section_name (section
),
9631 printf (_(" Addr: 0x"));
9632 printf_vma (section
->sh_addr
);
9633 printf (_(" Offset: %#08lx Link: %u (%s)"),
9634 (unsigned long) section
->sh_offset
, section
->sh_link
,
9635 printable_section_name_from_index (section
->sh_link
));
9637 edefs
= (Elf_External_Verdef
*)
9638 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9639 _("version definition section"));
9642 endbuf
= (char *) edefs
+ section
->sh_size
;
9644 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9647 Elf_External_Verdef
* edef
;
9648 Elf_Internal_Verdef ent
;
9649 Elf_External_Verdaux
* eaux
;
9650 Elf_Internal_Verdaux aux
;
9654 /* Check for very large indicies. */
9655 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9658 vstart
= ((char *) edefs
) + idx
;
9659 if (vstart
+ sizeof (*edef
) > endbuf
)
9662 edef
= (Elf_External_Verdef
*) vstart
;
9664 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9665 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9666 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9667 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9668 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9669 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9670 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9672 printf (_(" %#06x: Rev: %d Flags: %s"),
9673 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9675 printf (_(" Index: %d Cnt: %d "),
9676 ent
.vd_ndx
, ent
.vd_cnt
);
9678 /* Check for overflow. */
9679 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9682 vstart
+= ent
.vd_aux
;
9684 eaux
= (Elf_External_Verdaux
*) vstart
;
9686 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9687 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9689 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9690 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9692 printf (_("Name index: %ld\n"), aux
.vda_name
);
9694 isum
= idx
+ ent
.vd_aux
;
9696 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9698 /* Check for overflow. */
9699 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9702 isum
+= aux
.vda_next
;
9703 vstart
+= aux
.vda_next
;
9705 eaux
= (Elf_External_Verdaux
*) vstart
;
9706 if (vstart
+ sizeof (*eaux
) > endbuf
)
9709 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9710 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9712 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9713 printf (_(" %#06x: Parent %d: %s\n"),
9714 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9716 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9717 isum
, j
, aux
.vda_name
);
9721 printf (_(" Version def aux past end of section\n"));
9723 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9724 if (idx
+ ent
.vd_next
<= idx
)
9730 if (cnt
< section
->sh_info
)
9731 printf (_(" Version definition past end of section\n"));
9737 case SHT_GNU_verneed
:
9739 Elf_External_Verneed
* eneed
;
9746 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9747 printable_section_name (section
), section
->sh_info
);
9749 printf (_(" Addr: 0x"));
9750 printf_vma (section
->sh_addr
);
9751 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9752 (unsigned long) section
->sh_offset
, section
->sh_link
,
9753 printable_section_name_from_index (section
->sh_link
));
9755 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9756 section
->sh_offset
, 1,
9758 _("Version Needs section"));
9761 endbuf
= (char *) eneed
+ section
->sh_size
;
9763 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9765 Elf_External_Verneed
* entry
;
9766 Elf_Internal_Verneed ent
;
9771 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9774 vstart
= ((char *) eneed
) + idx
;
9775 if (vstart
+ sizeof (*entry
) > endbuf
)
9778 entry
= (Elf_External_Verneed
*) vstart
;
9780 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9781 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9782 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9783 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9784 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9786 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9788 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9789 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9791 printf (_(" File: %lx"), ent
.vn_file
);
9793 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9795 /* Check for overflow. */
9796 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9798 vstart
+= ent
.vn_aux
;
9800 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9802 Elf_External_Vernaux
* eaux
;
9803 Elf_Internal_Vernaux aux
;
9805 if (vstart
+ sizeof (*eaux
) > endbuf
)
9807 eaux
= (Elf_External_Vernaux
*) vstart
;
9809 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9810 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9811 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9812 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9813 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9815 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9816 printf (_(" %#06x: Name: %s"),
9817 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9819 printf (_(" %#06x: Name index: %lx"),
9820 isum
, aux
.vna_name
);
9822 printf (_(" Flags: %s Version: %d\n"),
9823 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9825 /* Check for overflow. */
9826 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9827 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9829 warn (_("Invalid vna_next field of %lx\n"),
9834 isum
+= aux
.vna_next
;
9835 vstart
+= aux
.vna_next
;
9839 warn (_("Missing Version Needs auxillary information\n"));
9841 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9843 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9844 cnt
= section
->sh_info
;
9850 if (cnt
< section
->sh_info
)
9851 warn (_("Missing Version Needs information\n"));
9857 case SHT_GNU_versym
:
9859 Elf_Internal_Shdr
* link_section
;
9862 unsigned char * edata
;
9863 unsigned short * data
;
9865 Elf_Internal_Sym
* symbols
;
9866 Elf_Internal_Shdr
* string_sec
;
9867 unsigned long num_syms
;
9870 if (section
->sh_link
>= elf_header
.e_shnum
)
9873 link_section
= section_headers
+ section
->sh_link
;
9874 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9876 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9881 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9882 if (symbols
== NULL
)
9885 string_sec
= section_headers
+ link_section
->sh_link
;
9887 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9888 string_sec
->sh_size
,
9889 _("version string table"));
9896 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9897 printable_section_name (section
), (unsigned long) total
);
9899 printf (_(" Addr: "));
9900 printf_vma (section
->sh_addr
);
9901 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9902 (unsigned long) section
->sh_offset
, section
->sh_link
,
9903 printable_section_name (link_section
));
9905 off
= offset_from_vma (file
,
9906 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9907 total
* sizeof (short));
9908 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9910 _("version symbol data"));
9918 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9920 for (cnt
= total
; cnt
--;)
9921 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9926 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9930 char *invalid
= _("*invalid*");
9932 printf (" %03x:", cnt
);
9934 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9935 switch (data
[cnt
+ j
])
9938 fputs (_(" 0 (*local*) "), stdout
);
9942 fputs (_(" 1 (*global*) "), stdout
);
9946 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9947 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9949 /* If this index value is greater than the size of the symbols
9950 array, break to avoid an out-of-bounds read. */
9951 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9953 warn (_("invalid index into symbol array\n"));
9958 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9960 Elf_Internal_Verneed ivn
;
9961 unsigned long offset
;
9963 offset
= offset_from_vma
9964 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9965 sizeof (Elf_External_Verneed
));
9969 Elf_Internal_Vernaux ivna
;
9970 Elf_External_Verneed evn
;
9971 Elf_External_Vernaux evna
;
9972 unsigned long a_off
;
9974 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9975 _("version need")) == NULL
)
9978 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9979 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9981 a_off
= offset
+ ivn
.vn_aux
;
9985 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9986 1, _("version need aux (2)")) == NULL
)
9993 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9994 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9997 a_off
+= ivna
.vna_next
;
9999 while (ivna
.vna_other
!= data
[cnt
+ j
]
10000 && ivna
.vna_next
!= 0);
10002 if (ivna
.vna_other
== data
[cnt
+ j
])
10004 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10006 if (ivna
.vna_name
>= string_sec
->sh_size
)
10009 name
= strtab
+ ivna
.vna_name
;
10013 offset
+= ivn
.vn_next
;
10015 while (ivn
.vn_next
);
10018 if (data
[cnt
+ j
] != 0x8001
10019 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10021 Elf_Internal_Verdef ivd
;
10022 Elf_External_Verdef evd
;
10023 unsigned long offset
;
10025 offset
= offset_from_vma
10026 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10031 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10032 _("version def")) == NULL
)
10035 /* PR 17531: file: 046-1082287-0.004. */
10036 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10041 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10042 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10045 offset
+= ivd
.vd_next
;
10047 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10048 && ivd
.vd_next
!= 0);
10050 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10052 Elf_External_Verdaux evda
;
10053 Elf_Internal_Verdaux ivda
;
10055 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10057 if (get_data (&evda
, file
,
10058 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10060 _("version def aux")) == NULL
)
10063 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10065 if (ivda
.vda_name
>= string_sec
->sh_size
)
10067 else if (name
!= NULL
&& name
!= invalid
)
10068 name
= _("*both*");
10070 name
= strtab
+ ivda
.vda_name
;
10074 nn
+= printf ("(%s%-*s",
10076 12 - (int) strlen (name
),
10080 printf ("%*c", 18 - nn
, ' ');
10098 printf (_("\nNo version information found in this file.\n"));
10103 static const char *
10104 get_symbol_binding (unsigned int binding
)
10106 static char buff
[32];
10110 case STB_LOCAL
: return "LOCAL";
10111 case STB_GLOBAL
: return "GLOBAL";
10112 case STB_WEAK
: return "WEAK";
10114 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10115 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10117 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10119 if (binding
== STB_GNU_UNIQUE
10120 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10121 /* GNU is still using the default value 0. */
10122 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10124 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10127 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10132 static const char *
10133 get_symbol_type (unsigned int type
)
10135 static char buff
[32];
10139 case STT_NOTYPE
: return "NOTYPE";
10140 case STT_OBJECT
: return "OBJECT";
10141 case STT_FUNC
: return "FUNC";
10142 case STT_SECTION
: return "SECTION";
10143 case STT_FILE
: return "FILE";
10144 case STT_COMMON
: return "COMMON";
10145 case STT_TLS
: return "TLS";
10146 case STT_RELC
: return "RELC";
10147 case STT_SRELC
: return "SRELC";
10149 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10151 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10152 return "THUMB_FUNC";
10154 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10157 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10158 return "PARISC_MILLI";
10160 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10162 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10164 if (elf_header
.e_machine
== EM_PARISC
)
10166 if (type
== STT_HP_OPAQUE
)
10167 return "HP_OPAQUE";
10168 if (type
== STT_HP_STUB
)
10172 if (type
== STT_GNU_IFUNC
10173 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10174 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10175 /* GNU is still using the default value 0. */
10176 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10179 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10182 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10187 static const char *
10188 get_symbol_visibility (unsigned int visibility
)
10190 switch (visibility
)
10192 case STV_DEFAULT
: return "DEFAULT";
10193 case STV_INTERNAL
: return "INTERNAL";
10194 case STV_HIDDEN
: return "HIDDEN";
10195 case STV_PROTECTED
: return "PROTECTED";
10197 error (_("Unrecognized visibility value: %u"), visibility
);
10198 return _("<unknown>");
10202 static const char *
10203 get_mips_symbol_other (unsigned int other
)
10213 case STO_MICROMIPS
:
10214 return "MICROMIPS";
10215 case STO_MICROMIPS
| STO_MIPS_PIC
:
10216 return "MICROMIPS, MIPS PIC";
10224 static const char *
10225 get_ia64_symbol_other (unsigned int other
)
10227 if (is_ia64_vms ())
10229 static char res
[32];
10233 /* Function types is for images and .STB files only. */
10234 switch (elf_header
.e_type
)
10238 switch (VMS_ST_FUNC_TYPE (other
))
10240 case VMS_SFT_CODE_ADDR
:
10241 strcat (res
, " CA");
10243 case VMS_SFT_SYMV_IDX
:
10244 strcat (res
, " VEC");
10247 strcat (res
, " FD");
10249 case VMS_SFT_RESERVE
:
10250 strcat (res
, " RSV");
10253 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10254 VMS_ST_FUNC_TYPE (other
));
10255 strcat (res
, " <unknown>");
10262 switch (VMS_ST_LINKAGE (other
))
10264 case VMS_STL_IGNORE
:
10265 strcat (res
, " IGN");
10267 case VMS_STL_RESERVE
:
10268 strcat (res
, " RSV");
10271 strcat (res
, " STD");
10274 strcat (res
, " LNK");
10277 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10278 VMS_ST_LINKAGE (other
));
10279 strcat (res
, " <unknown>");
10291 static const char *
10292 get_ppc64_symbol_other (unsigned int other
)
10294 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10296 static char buf
[32];
10297 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10298 PPC64_LOCAL_ENTRY_OFFSET (other
));
10304 static const char *
10305 get_symbol_other (unsigned int other
)
10307 const char * result
= NULL
;
10308 static char buff
[32];
10313 switch (elf_header
.e_machine
)
10316 result
= get_mips_symbol_other (other
);
10319 result
= get_ia64_symbol_other (other
);
10322 result
= get_ppc64_symbol_other (other
);
10331 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10335 static const char *
10336 get_symbol_index_type (unsigned int type
)
10338 static char buff
[32];
10342 case SHN_UNDEF
: return "UND";
10343 case SHN_ABS
: return "ABS";
10344 case SHN_COMMON
: return "COM";
10346 if (type
== SHN_IA_64_ANSI_COMMON
10347 && elf_header
.e_machine
== EM_IA_64
10348 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10350 else if ((elf_header
.e_machine
== EM_X86_64
10351 || elf_header
.e_machine
== EM_L1OM
10352 || elf_header
.e_machine
== EM_K1OM
)
10353 && type
== SHN_X86_64_LCOMMON
)
10354 return "LARGE_COM";
10355 else if ((type
== SHN_MIPS_SCOMMON
10356 && elf_header
.e_machine
== EM_MIPS
)
10357 || (type
== SHN_TIC6X_SCOMMON
10358 && elf_header
.e_machine
== EM_TI_C6000
))
10360 else if (type
== SHN_MIPS_SUNDEFINED
10361 && elf_header
.e_machine
== EM_MIPS
)
10363 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10364 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10365 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10366 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10367 else if (type
>= SHN_LORESERVE
)
10368 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10369 else if (type
>= elf_header
.e_shnum
)
10370 sprintf (buff
, _("bad section index[%3d]"), type
);
10372 sprintf (buff
, "%3d", type
);
10380 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10382 unsigned char * e_data
;
10385 /* If the size_t type is smaller than the bfd_size_type, eg because
10386 you are building a 32-bit tool on a 64-bit host, then make sure
10387 that when (number) is cast to (size_t) no information is lost. */
10388 if (sizeof (size_t) < sizeof (bfd_size_type
)
10389 && (bfd_size_type
) ((size_t) number
) != number
)
10391 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10392 (unsigned long long) number
, ent_size
);
10396 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10397 attempting to allocate memory when the read is bound to fail. */
10398 if (ent_size
* number
> current_file_size
)
10400 error (_("Invalid number of dynamic entries: %llu\n"),
10401 (unsigned long long) number
);
10405 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10406 if (e_data
== NULL
)
10408 error (_("Out of memory reading %llu dynamic entries\n"),
10409 (unsigned long long) number
);
10413 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10415 error (_("Unable to read in %llu bytes of dynamic data\n"),
10416 (unsigned long long) (number
* ent_size
));
10421 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10422 if (i_data
== NULL
)
10424 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10425 (unsigned long long) number
);
10431 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10439 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10441 Elf_Internal_Sym
* psym
;
10444 n
= print_vma (si
, DEC_5
);
10446 fputs (&" "[n
], stdout
);
10447 printf (" %3lu: ", hn
);
10449 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10451 printf (_("<No info available for dynamic symbol number %lu>\n"),
10452 (unsigned long) si
);
10456 psym
= dynamic_symbols
+ si
;
10457 print_vma (psym
->st_value
, LONG_HEX
);
10459 print_vma (psym
->st_size
, DEC_5
);
10461 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10462 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10463 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10464 /* Check to see if any other bits in the st_other field are set.
10465 Note - displaying this information disrupts the layout of the
10466 table being generated, but for the moment this case is very
10468 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10469 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10470 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10471 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10472 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10474 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10478 static const char *
10479 get_symbol_version_string (FILE *file
, int is_dynsym
,
10480 const char *strtab
,
10481 unsigned long int strtab_size
,
10482 unsigned int si
, Elf_Internal_Sym
*psym
,
10483 enum versioned_symbol_info
*sym_info
,
10484 unsigned short *vna_other
)
10486 unsigned char data
[2];
10487 unsigned short vers_data
;
10488 unsigned long offset
;
10491 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10494 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10495 sizeof data
+ si
* sizeof (vers_data
));
10497 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10498 sizeof (data
), 1, _("version data")) == NULL
)
10501 vers_data
= byte_get (data
, 2);
10503 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10506 /* Usually we'd only see verdef for defined symbols, and verneed for
10507 undefined symbols. However, symbols defined by the linker in
10508 .dynbss for variables copied from a shared library in order to
10509 avoid text relocations are defined yet have verneed. We could
10510 use a heuristic to detect the special case, for example, check
10511 for verneed first on symbols defined in SHT_NOBITS sections, but
10512 it is simpler and more reliable to just look for both verdef and
10513 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10515 if (psym
->st_shndx
!= SHN_UNDEF
10516 && vers_data
!= 0x8001
10517 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10519 Elf_Internal_Verdef ivd
;
10520 Elf_Internal_Verdaux ivda
;
10521 Elf_External_Verdaux evda
;
10524 off
= offset_from_vma (file
,
10525 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10526 sizeof (Elf_External_Verdef
));
10530 Elf_External_Verdef evd
;
10532 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10533 _("version def")) == NULL
)
10541 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10542 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10543 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10546 off
+= ivd
.vd_next
;
10548 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10550 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10552 off
-= ivd
.vd_next
;
10555 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10556 _("version def aux")) != NULL
)
10558 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10560 if (psym
->st_name
!= ivda
.vda_name
)
10562 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10563 ? symbol_hidden
: symbol_public
);
10564 return (ivda
.vda_name
< strtab_size
10565 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10571 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10573 Elf_External_Verneed evn
;
10574 Elf_Internal_Verneed ivn
;
10575 Elf_Internal_Vernaux ivna
;
10577 offset
= offset_from_vma (file
,
10578 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10582 unsigned long vna_off
;
10584 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10585 _("version need")) == NULL
)
10588 ivna
.vna_other
= 0;
10593 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10594 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10596 vna_off
= offset
+ ivn
.vn_aux
;
10600 Elf_External_Vernaux evna
;
10602 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10603 _("version need aux (3)")) == NULL
)
10606 ivna
.vna_other
= 0;
10611 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10612 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10613 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10616 vna_off
+= ivna
.vna_next
;
10618 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10620 if (ivna
.vna_other
== vers_data
)
10623 offset
+= ivn
.vn_next
;
10625 while (ivn
.vn_next
!= 0);
10627 if (ivna
.vna_other
== vers_data
)
10629 *sym_info
= symbol_undefined
;
10630 *vna_other
= ivna
.vna_other
;
10631 return (ivna
.vna_name
< strtab_size
10632 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
10638 /* Dump the symbol table. */
10640 process_symbol_table (FILE * file
)
10642 Elf_Internal_Shdr
* section
;
10643 bfd_size_type nbuckets
= 0;
10644 bfd_size_type nchains
= 0;
10645 bfd_vma
* buckets
= NULL
;
10646 bfd_vma
* chains
= NULL
;
10647 bfd_vma ngnubuckets
= 0;
10648 bfd_vma
* gnubuckets
= NULL
;
10649 bfd_vma
* gnuchains
= NULL
;
10650 bfd_vma gnusymidx
= 0;
10651 bfd_size_type ngnuchains
= 0;
10653 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10656 if (dynamic_info
[DT_HASH
]
10658 || (do_using_dynamic
10660 && dynamic_strings
!= NULL
)))
10662 unsigned char nb
[8];
10663 unsigned char nc
[8];
10664 unsigned int hash_ent_size
= 4;
10666 if ((elf_header
.e_machine
== EM_ALPHA
10667 || elf_header
.e_machine
== EM_S390
10668 || elf_header
.e_machine
== EM_S390_OLD
)
10669 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10673 (archive_file_offset
10674 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10675 sizeof nb
+ sizeof nc
)),
10678 error (_("Unable to seek to start of dynamic information\n"));
10682 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10684 error (_("Failed to read in number of buckets\n"));
10688 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10690 error (_("Failed to read in number of chains\n"));
10694 nbuckets
= byte_get (nb
, hash_ent_size
);
10695 nchains
= byte_get (nc
, hash_ent_size
);
10697 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10698 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10701 if (buckets
== NULL
|| chains
== NULL
)
10703 if (do_using_dynamic
)
10714 if (dynamic_info_DT_GNU_HASH
10716 || (do_using_dynamic
10718 && dynamic_strings
!= NULL
)))
10720 unsigned char nb
[16];
10721 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10722 bfd_vma buckets_vma
;
10725 (archive_file_offset
10726 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10730 error (_("Unable to seek to start of dynamic information\n"));
10734 if (fread (nb
, 16, 1, file
) != 1)
10736 error (_("Failed to read in number of buckets\n"));
10740 ngnubuckets
= byte_get (nb
, 4);
10741 gnusymidx
= byte_get (nb
+ 4, 4);
10742 bitmaskwords
= byte_get (nb
+ 8, 4);
10743 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10745 buckets_vma
+= bitmaskwords
* 4;
10747 buckets_vma
+= bitmaskwords
* 8;
10750 (archive_file_offset
10751 + offset_from_vma (file
, buckets_vma
, 4)),
10754 error (_("Unable to seek to start of dynamic information\n"));
10758 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10760 if (gnubuckets
== NULL
)
10763 for (i
= 0; i
< ngnubuckets
; i
++)
10764 if (gnubuckets
[i
] != 0)
10766 if (gnubuckets
[i
] < gnusymidx
)
10769 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10770 maxchain
= gnubuckets
[i
];
10773 if (maxchain
== 0xffffffff)
10776 maxchain
-= gnusymidx
;
10779 (archive_file_offset
10780 + offset_from_vma (file
, buckets_vma
10781 + 4 * (ngnubuckets
+ maxchain
), 4)),
10784 error (_("Unable to seek to start of dynamic information\n"));
10790 if (fread (nb
, 4, 1, file
) != 1)
10792 error (_("Failed to determine last chain length\n"));
10796 if (maxchain
+ 1 == 0)
10801 while ((byte_get (nb
, 4) & 1) == 0);
10804 (archive_file_offset
10805 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10808 error (_("Unable to seek to start of dynamic information\n"));
10812 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10813 ngnuchains
= maxchain
;
10816 if (gnuchains
== NULL
)
10821 if (do_using_dynamic
)
10826 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10828 && do_using_dynamic
10829 && dynamic_strings
!= NULL
10830 && dynamic_symbols
!= NULL
)
10834 if (dynamic_info
[DT_HASH
])
10838 printf (_("\nSymbol table for image:\n"));
10840 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10842 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10844 for (hn
= 0; hn
< nbuckets
; hn
++)
10849 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10850 print_dynamic_symbol (si
, hn
);
10854 if (dynamic_info_DT_GNU_HASH
)
10856 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10858 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10860 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10862 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10863 if (gnubuckets
[hn
] != 0)
10865 bfd_vma si
= gnubuckets
[hn
];
10866 bfd_vma off
= si
- gnusymidx
;
10870 print_dynamic_symbol (si
, hn
);
10873 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10877 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10878 && section_headers
!= NULL
)
10882 for (i
= 0, section
= section_headers
;
10883 i
< elf_header
.e_shnum
;
10887 char * strtab
= NULL
;
10888 unsigned long int strtab_size
= 0;
10889 Elf_Internal_Sym
* symtab
;
10890 Elf_Internal_Sym
* psym
;
10891 unsigned long num_syms
;
10893 if ((section
->sh_type
!= SHT_SYMTAB
10894 && section
->sh_type
!= SHT_DYNSYM
)
10896 && section
->sh_type
== SHT_SYMTAB
))
10899 if (section
->sh_entsize
== 0)
10901 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10902 printable_section_name (section
));
10906 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10907 printable_section_name (section
),
10908 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10911 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10913 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10915 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10916 if (symtab
== NULL
)
10919 if (section
->sh_link
== elf_header
.e_shstrndx
)
10921 strtab
= string_table
;
10922 strtab_size
= string_table_length
;
10924 else if (section
->sh_link
< elf_header
.e_shnum
)
10926 Elf_Internal_Shdr
* string_sec
;
10928 string_sec
= section_headers
+ section
->sh_link
;
10930 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10931 1, string_sec
->sh_size
,
10932 _("string table"));
10933 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10936 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10938 const char *version_string
;
10939 enum versioned_symbol_info sym_info
;
10940 unsigned short vna_other
;
10942 printf ("%6d: ", si
);
10943 print_vma (psym
->st_value
, LONG_HEX
);
10945 print_vma (psym
->st_size
, DEC_5
);
10946 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10947 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10948 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10949 /* Check to see if any other bits in the st_other field are set.
10950 Note - displaying this information disrupts the layout of the
10951 table being generated, but for the moment this case is very rare. */
10952 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10953 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10954 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10955 print_symbol (25, psym
->st_name
< strtab_size
10956 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10959 = get_symbol_version_string (file
,
10960 section
->sh_type
== SHT_DYNSYM
,
10961 strtab
, strtab_size
, si
,
10962 psym
, &sym_info
, &vna_other
);
10963 if (version_string
)
10965 if (sym_info
== symbol_undefined
)
10966 printf ("@%s (%d)", version_string
, vna_other
);
10968 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10976 if (strtab
!= string_table
)
10982 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10984 if (do_histogram
&& buckets
!= NULL
)
10986 unsigned long * lengths
;
10987 unsigned long * counts
;
10990 unsigned long maxlength
= 0;
10991 unsigned long nzero_counts
= 0;
10992 unsigned long nsyms
= 0;
10993 unsigned long chained
;
10995 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10996 (unsigned long) nbuckets
);
10998 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10999 if (lengths
== NULL
)
11001 error (_("Out of memory allocating space for histogram buckets\n"));
11005 printf (_(" Length Number %% of total Coverage\n"));
11006 for (hn
= 0; hn
< nbuckets
; ++hn
)
11008 for (si
= buckets
[hn
], chained
= 0;
11009 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11010 si
= chains
[si
], ++chained
)
11013 if (maxlength
< ++lengths
[hn
])
11017 /* PR binutils/17531: A corrupt binary could contain broken
11018 histogram data. Do not go into an infinite loop trying
11020 if (chained
> nchains
)
11022 error (_("histogram chain is corrupt\n"));
11027 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11028 if (counts
== NULL
)
11031 error (_("Out of memory allocating space for histogram counts\n"));
11035 for (hn
= 0; hn
< nbuckets
; ++hn
)
11036 ++counts
[lengths
[hn
]];
11041 printf (" 0 %-10lu (%5.1f%%)\n",
11042 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11043 for (i
= 1; i
<= maxlength
; ++i
)
11045 nzero_counts
+= counts
[i
] * i
;
11046 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11047 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11048 (nzero_counts
* 100.0) / nsyms
);
11056 if (buckets
!= NULL
)
11062 if (do_histogram
&& gnubuckets
!= NULL
)
11064 unsigned long * lengths
;
11065 unsigned long * counts
;
11067 unsigned long maxlength
= 0;
11068 unsigned long nzero_counts
= 0;
11069 unsigned long nsyms
= 0;
11071 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11072 (unsigned long) ngnubuckets
);
11074 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11075 if (lengths
== NULL
)
11077 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11081 printf (_(" Length Number %% of total Coverage\n"));
11083 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11084 if (gnubuckets
[hn
] != 0)
11086 bfd_vma off
, length
= 1;
11088 for (off
= gnubuckets
[hn
] - gnusymidx
;
11089 /* PR 17531 file: 010-77222-0.004. */
11090 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11093 lengths
[hn
] = length
;
11094 if (length
> maxlength
)
11095 maxlength
= length
;
11099 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11100 if (counts
== NULL
)
11103 error (_("Out of memory allocating space for gnu histogram counts\n"));
11107 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11108 ++counts
[lengths
[hn
]];
11110 if (ngnubuckets
> 0)
11113 printf (" 0 %-10lu (%5.1f%%)\n",
11114 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11115 for (j
= 1; j
<= maxlength
; ++j
)
11117 nzero_counts
+= counts
[j
] * j
;
11118 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11119 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11120 (nzero_counts
* 100.0) / nsyms
);
11134 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11138 if (dynamic_syminfo
== NULL
11140 /* No syminfo, this is ok. */
11143 /* There better should be a dynamic symbol section. */
11144 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11148 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11149 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11151 printf (_(" Num: Name BoundTo Flags\n"));
11152 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11154 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11156 printf ("%4d: ", i
);
11157 if (i
>= num_dynamic_syms
)
11158 printf (_("<corrupt index>"));
11159 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11160 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11162 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11165 switch (dynamic_syminfo
[i
].si_boundto
)
11167 case SYMINFO_BT_SELF
:
11168 fputs ("SELF ", stdout
);
11170 case SYMINFO_BT_PARENT
:
11171 fputs ("PARENT ", stdout
);
11174 if (dynamic_syminfo
[i
].si_boundto
> 0
11175 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11176 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11178 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11182 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11186 if (flags
& SYMINFO_FLG_DIRECT
)
11187 printf (" DIRECT");
11188 if (flags
& SYMINFO_FLG_PASSTHRU
)
11189 printf (" PASSTHRU");
11190 if (flags
& SYMINFO_FLG_COPY
)
11192 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11193 printf (" LAZYLOAD");
11201 /* Check to see if the given reloc needs to be handled in a target specific
11202 manner. If so then process the reloc and return TRUE otherwise return
11206 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11207 unsigned char * start
,
11208 Elf_Internal_Sym
* symtab
)
11210 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11212 switch (elf_header
.e_machine
)
11215 case EM_MSP430_OLD
:
11217 static Elf_Internal_Sym
* saved_sym
= NULL
;
11219 switch (reloc_type
)
11221 case 10: /* R_MSP430_SYM_DIFF */
11222 if (uses_msp430x_relocs ())
11224 case 21: /* R_MSP430X_SYM_DIFF */
11225 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11228 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11229 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11230 goto handle_sym_diff
;
11232 case 5: /* R_MSP430_16_BYTE */
11233 case 9: /* R_MSP430_8 */
11234 if (uses_msp430x_relocs ())
11236 goto handle_sym_diff
;
11238 case 2: /* R_MSP430_ABS16 */
11239 case 15: /* R_MSP430X_ABS16 */
11240 if (! uses_msp430x_relocs ())
11242 goto handle_sym_diff
;
11245 if (saved_sym
!= NULL
)
11249 value
= reloc
->r_addend
11250 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11251 - saved_sym
->st_value
);
11253 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11261 if (saved_sym
!= NULL
)
11262 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11269 case EM_CYGNUS_MN10300
:
11271 static Elf_Internal_Sym
* saved_sym
= NULL
;
11273 switch (reloc_type
)
11275 case 34: /* R_MN10300_ALIGN */
11277 case 33: /* R_MN10300_SYM_DIFF */
11278 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11280 case 1: /* R_MN10300_32 */
11281 case 2: /* R_MN10300_16 */
11282 if (saved_sym
!= NULL
)
11286 value
= reloc
->r_addend
11287 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11288 - saved_sym
->st_value
);
11290 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11297 if (saved_sym
!= NULL
)
11298 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11306 static bfd_vma saved_sym1
= 0;
11307 static bfd_vma saved_sym2
= 0;
11308 static bfd_vma value
;
11310 switch (reloc_type
)
11312 case 0x80: /* R_RL78_SYM. */
11313 saved_sym1
= saved_sym2
;
11314 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11315 saved_sym2
+= reloc
->r_addend
;
11318 case 0x83: /* R_RL78_OPsub. */
11319 value
= saved_sym1
- saved_sym2
;
11320 saved_sym2
= saved_sym1
= 0;
11324 case 0x41: /* R_RL78_ABS32. */
11325 byte_put (start
+ reloc
->r_offset
, value
, 4);
11329 case 0x43: /* R_RL78_ABS16. */
11330 byte_put (start
+ reloc
->r_offset
, value
, 2);
11344 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11345 DWARF debug sections. This is a target specific test. Note - we do not
11346 go through the whole including-target-headers-multiple-times route, (as
11347 we have already done with <elf/h8.h>) because this would become very
11348 messy and even then this function would have to contain target specific
11349 information (the names of the relocs instead of their numeric values).
11350 FIXME: This is not the correct way to solve this problem. The proper way
11351 is to have target specific reloc sizing and typing functions created by
11352 the reloc-macros.h header, in the same way that it already creates the
11353 reloc naming functions. */
11356 is_32bit_abs_reloc (unsigned int reloc_type
)
11358 switch (elf_header
.e_machine
)
11362 return reloc_type
== 1; /* R_386_32. */
11364 return reloc_type
== 1; /* R_68K_32. */
11366 return reloc_type
== 1; /* R_860_32. */
11368 return reloc_type
== 2; /* R_960_32. */
11370 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11372 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11374 return reloc_type
== 1; /* R_ARC_32. */
11375 case EM_ARC_COMPACT
:
11376 case EM_ARC_COMPACT2
:
11377 return reloc_type
== 4; /* R_ARC_32. */
11379 return reloc_type
== 2; /* R_ARM_ABS32 */
11382 return reloc_type
== 1;
11383 case EM_ADAPTEVA_EPIPHANY
:
11384 return reloc_type
== 3;
11386 return reloc_type
== 0x12; /* R_byte4_data. */
11388 return reloc_type
== 3; /* R_CRIS_32. */
11390 return reloc_type
== 3; /* R_CR16_NUM32. */
11392 return reloc_type
== 15; /* R_CRX_NUM32. */
11393 case EM_CYGNUS_FRV
:
11394 return reloc_type
== 1;
11395 case EM_CYGNUS_D10V
:
11397 return reloc_type
== 6; /* R_D10V_32. */
11398 case EM_CYGNUS_D30V
:
11400 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11402 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11403 case EM_CYGNUS_FR30
:
11405 return reloc_type
== 3; /* R_FR30_32. */
11407 return reloc_type
== 1; /* R_FT32_32. */
11411 return reloc_type
== 1; /* R_H8_DIR32. */
11413 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11414 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11417 return reloc_type
== 2; /* R_IP2K_32. */
11419 return reloc_type
== 2; /* R_IQ2000_32. */
11420 case EM_LATTICEMICO32
:
11421 return reloc_type
== 3; /* R_LM32_32. */
11424 return reloc_type
== 3; /* R_M32C_32. */
11426 return reloc_type
== 34; /* R_M32R_32_RELA. */
11429 return reloc_type
== 6; /* R_M68HC11_32. */
11431 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11432 case EM_CYGNUS_MEP
:
11433 return reloc_type
== 4; /* R_MEP_32. */
11435 return reloc_type
== 2; /* R_METAG_ADDR32. */
11436 case EM_MICROBLAZE
:
11437 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11439 return reloc_type
== 2; /* R_MIPS_32. */
11441 return reloc_type
== 4; /* R_MMIX_32. */
11442 case EM_CYGNUS_MN10200
:
11444 return reloc_type
== 1; /* R_MN10200_32. */
11445 case EM_CYGNUS_MN10300
:
11447 return reloc_type
== 1; /* R_MN10300_32. */
11449 return reloc_type
== 1; /* R_MOXIE_32. */
11450 case EM_MSP430_OLD
:
11452 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11454 return reloc_type
== 2; /* R_MT_32. */
11456 return reloc_type
== 20; /* R_NDS32_RELA. */
11457 case EM_ALTERA_NIOS2
:
11458 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11460 return reloc_type
== 1; /* R_NIOS_32. */
11462 return reloc_type
== 1; /* R_OR1K_32. */
11464 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11465 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11468 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11470 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11472 return reloc_type
== 1; /* R_PPC_ADDR32. */
11474 return reloc_type
== 1; /* R_RL78_DIR32. */
11476 return reloc_type
== 1; /* R_RX_DIR32. */
11478 return reloc_type
== 1; /* R_I370_ADDR31. */
11481 return reloc_type
== 4; /* R_S390_32. */
11483 return reloc_type
== 8; /* R_SCORE_ABS32. */
11485 return reloc_type
== 1; /* R_SH_DIR32. */
11486 case EM_SPARC32PLUS
:
11489 return reloc_type
== 3 /* R_SPARC_32. */
11490 || reloc_type
== 23; /* R_SPARC_UA32. */
11492 return reloc_type
== 6; /* R_SPU_ADDR32 */
11494 return reloc_type
== 1; /* R_C6000_ABS32. */
11496 return reloc_type
== 2; /* R_TILEGX_32. */
11498 return reloc_type
== 1; /* R_TILEPRO_32. */
11499 case EM_CYGNUS_V850
:
11501 return reloc_type
== 6; /* R_V850_ABS32. */
11503 return reloc_type
== 0x33; /* R_V810_WORD. */
11505 return reloc_type
== 1; /* R_VAX_32. */
11507 return reloc_type
== 3; /* R_VISIUM_32. */
11511 return reloc_type
== 10; /* R_X86_64_32. */
11514 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11516 return reloc_type
== 4; /* R_XGATE_32. */
11518 return reloc_type
== 1; /* R_XSTROMY16_32. */
11519 case EM_XTENSA_OLD
:
11521 return reloc_type
== 1; /* R_XTENSA_32. */
11524 static unsigned int prev_warn
= 0;
11526 /* Avoid repeating the same warning multiple times. */
11527 if (prev_warn
!= elf_header
.e_machine
)
11528 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11529 elf_header
.e_machine
);
11530 prev_warn
= elf_header
.e_machine
;
11536 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11537 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11540 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11542 switch (elf_header
.e_machine
)
11546 return reloc_type
== 2; /* R_386_PC32. */
11548 return reloc_type
== 4; /* R_68K_PC32. */
11550 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11551 case EM_ADAPTEVA_EPIPHANY
:
11552 return reloc_type
== 6;
11554 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11556 return reloc_type
== 3; /* R_ARM_REL32 */
11557 case EM_MICROBLAZE
:
11558 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11560 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11562 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11564 return reloc_type
== 26; /* R_PPC_REL32. */
11566 return reloc_type
== 26; /* R_PPC64_REL32. */
11569 return reloc_type
== 5; /* R_390_PC32. */
11571 return reloc_type
== 2; /* R_SH_REL32. */
11572 case EM_SPARC32PLUS
:
11575 return reloc_type
== 6; /* R_SPARC_DISP32. */
11577 return reloc_type
== 13; /* R_SPU_REL32. */
11579 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11581 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11583 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11587 return reloc_type
== 2; /* R_X86_64_PC32. */
11588 case EM_XTENSA_OLD
:
11590 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11592 /* Do not abort or issue an error message here. Not all targets use
11593 pc-relative 32-bit relocs in their DWARF debug information and we
11594 have already tested for target coverage in is_32bit_abs_reloc. A
11595 more helpful warning message will be generated by apply_relocations
11596 anyway, so just return. */
11601 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11602 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11605 is_64bit_abs_reloc (unsigned int reloc_type
)
11607 switch (elf_header
.e_machine
)
11610 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11612 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11614 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11616 return reloc_type
== 80; /* R_PARISC_DIR64. */
11618 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11619 case EM_SPARC32PLUS
:
11622 return reloc_type
== 54; /* R_SPARC_UA64. */
11626 return reloc_type
== 1; /* R_X86_64_64. */
11629 return reloc_type
== 22; /* R_S390_64. */
11631 return reloc_type
== 1; /* R_TILEGX_64. */
11633 return reloc_type
== 18; /* R_MIPS_64. */
11639 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11640 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11643 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11645 switch (elf_header
.e_machine
)
11648 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11650 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11652 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11654 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11656 return reloc_type
== 44; /* R_PPC64_REL64. */
11657 case EM_SPARC32PLUS
:
11660 return reloc_type
== 46; /* R_SPARC_DISP64. */
11664 return reloc_type
== 24; /* R_X86_64_PC64. */
11667 return reloc_type
== 23; /* R_S390_PC64. */
11669 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11675 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11676 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11679 is_24bit_abs_reloc (unsigned int reloc_type
)
11681 switch (elf_header
.e_machine
)
11683 case EM_CYGNUS_MN10200
:
11685 return reloc_type
== 4; /* R_MN10200_24. */
11691 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11692 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11695 is_16bit_abs_reloc (unsigned int reloc_type
)
11697 switch (elf_header
.e_machine
)
11700 case EM_ARC_COMPACT
:
11701 case EM_ARC_COMPACT2
:
11702 return reloc_type
== 2; /* R_ARC_16. */
11705 return reloc_type
== 4; /* R_AVR_16. */
11706 case EM_ADAPTEVA_EPIPHANY
:
11707 return reloc_type
== 5;
11708 case EM_CYGNUS_D10V
:
11710 return reloc_type
== 3; /* R_D10V_16. */
11714 return reloc_type
== R_H8_DIR16
;
11717 return reloc_type
== 1; /* R_IP2K_16. */
11720 return reloc_type
== 1; /* R_M32C_16 */
11722 if (uses_msp430x_relocs ())
11723 return reloc_type
== 2; /* R_MSP430_ABS16. */
11724 case EM_MSP430_OLD
:
11725 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11727 return reloc_type
== 19; /* R_NDS32_RELA. */
11728 case EM_ALTERA_NIOS2
:
11729 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11731 return reloc_type
== 9; /* R_NIOS_16. */
11733 return reloc_type
== 2; /* R_OR1K_16. */
11735 return reloc_type
== 2; /* R_C6000_ABS16. */
11738 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11739 case EM_CYGNUS_MN10200
:
11741 return reloc_type
== 2; /* R_MN10200_16. */
11742 case EM_CYGNUS_MN10300
:
11744 return reloc_type
== 2; /* R_MN10300_16. */
11746 return reloc_type
== 2; /* R_VISIUM_16. */
11748 return reloc_type
== 3; /* R_XGATE_16. */
11754 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11755 relocation entries (possibly formerly used for SHT_GROUP sections). */
11758 is_none_reloc (unsigned int reloc_type
)
11760 switch (elf_header
.e_machine
)
11762 case EM_68K
: /* R_68K_NONE. */
11763 case EM_386
: /* R_386_NONE. */
11764 case EM_SPARC32PLUS
:
11766 case EM_SPARC
: /* R_SPARC_NONE. */
11767 case EM_MIPS
: /* R_MIPS_NONE. */
11768 case EM_PARISC
: /* R_PARISC_NONE. */
11769 case EM_ALPHA
: /* R_ALPHA_NONE. */
11770 case EM_ADAPTEVA_EPIPHANY
:
11771 case EM_PPC
: /* R_PPC_NONE. */
11772 case EM_PPC64
: /* R_PPC64_NONE. */
11773 case EM_ARC
: /* R_ARC_NONE. */
11774 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
11775 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
11776 case EM_ARM
: /* R_ARM_NONE. */
11777 case EM_IA_64
: /* R_IA64_NONE. */
11778 case EM_SH
: /* R_SH_NONE. */
11780 case EM_S390
: /* R_390_NONE. */
11781 case EM_CRIS
: /* R_CRIS_NONE. */
11782 case EM_X86_64
: /* R_X86_64_NONE. */
11783 case EM_L1OM
: /* R_X86_64_NONE. */
11784 case EM_K1OM
: /* R_X86_64_NONE. */
11785 case EM_MN10300
: /* R_MN10300_NONE. */
11786 case EM_FT32
: /* R_FT32_NONE. */
11787 case EM_MOXIE
: /* R_MOXIE_NONE. */
11788 case EM_M32R
: /* R_M32R_NONE. */
11789 case EM_TI_C6000
:/* R_C6000_NONE. */
11790 case EM_TILEGX
: /* R_TILEGX_NONE. */
11791 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11793 case EM_C166
: /* R_XC16X_NONE. */
11794 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11795 case EM_NIOS32
: /* R_NIOS_NONE. */
11796 case EM_OR1K
: /* R_OR1K_NONE. */
11797 return reloc_type
== 0;
11799 return reloc_type
== 0 || reloc_type
== 256;
11801 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11802 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11803 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11804 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11805 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11806 case EM_XTENSA_OLD
:
11808 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11809 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11810 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11811 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11813 return reloc_type
== 3; /* R_METAG_NONE. */
11818 /* Returns TRUE if there is a relocation against
11819 section NAME at OFFSET bytes. */
11822 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
11824 Elf_Internal_Rela
* relocs
;
11825 Elf_Internal_Rela
* rp
;
11827 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
11830 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
11832 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
11833 if (rp
->r_offset
== offset
)
11839 /* Apply relocations to a section.
11840 Note: So far support has been added only for those relocations
11841 which can be found in debug sections.
11842 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11843 loaded relocs. It is then the caller's responsibility to free them.
11844 FIXME: Add support for more relocations ? */
11847 apply_relocations (void * file
,
11848 const Elf_Internal_Shdr
* section
,
11849 unsigned char * start
,
11850 bfd_size_type size
,
11851 void ** relocs_return
,
11852 unsigned long * num_relocs_return
)
11854 Elf_Internal_Shdr
* relsec
;
11855 unsigned char * end
= start
+ size
;
11857 if (relocs_return
!= NULL
)
11859 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
11860 * num_relocs_return
= 0;
11863 if (elf_header
.e_type
!= ET_REL
)
11866 /* Find the reloc section associated with the section. */
11867 for (relsec
= section_headers
;
11868 relsec
< section_headers
+ elf_header
.e_shnum
;
11871 bfd_boolean is_rela
;
11872 unsigned long num_relocs
;
11873 Elf_Internal_Rela
* relocs
;
11874 Elf_Internal_Rela
* rp
;
11875 Elf_Internal_Shdr
* symsec
;
11876 Elf_Internal_Sym
* symtab
;
11877 unsigned long num_syms
;
11878 Elf_Internal_Sym
* sym
;
11880 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11881 || relsec
->sh_info
>= elf_header
.e_shnum
11882 || section_headers
+ relsec
->sh_info
!= section
11883 || relsec
->sh_size
== 0
11884 || relsec
->sh_link
>= elf_header
.e_shnum
)
11887 is_rela
= relsec
->sh_type
== SHT_RELA
;
11891 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11892 relsec
->sh_size
, & relocs
, & num_relocs
))
11897 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11898 relsec
->sh_size
, & relocs
, & num_relocs
))
11902 /* SH uses RELA but uses in place value instead of the addend field. */
11903 if (elf_header
.e_machine
== EM_SH
)
11906 symsec
= section_headers
+ relsec
->sh_link
;
11907 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11909 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11912 unsigned int reloc_type
;
11913 unsigned int reloc_size
;
11914 unsigned char * rloc
;
11915 unsigned long sym_index
;
11917 reloc_type
= get_reloc_type (rp
->r_info
);
11919 if (target_specific_reloc_handling (rp
, start
, symtab
))
11921 else if (is_none_reloc (reloc_type
))
11923 else if (is_32bit_abs_reloc (reloc_type
)
11924 || is_32bit_pcrel_reloc (reloc_type
))
11926 else if (is_64bit_abs_reloc (reloc_type
)
11927 || is_64bit_pcrel_reloc (reloc_type
))
11929 else if (is_24bit_abs_reloc (reloc_type
))
11931 else if (is_16bit_abs_reloc (reloc_type
))
11935 static unsigned int prev_reloc
= 0;
11936 if (reloc_type
!= prev_reloc
)
11937 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11938 reloc_type
, printable_section_name (section
));
11939 prev_reloc
= reloc_type
;
11943 rloc
= start
+ rp
->r_offset
;
11944 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11946 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11947 (unsigned long) rp
->r_offset
,
11948 printable_section_name (section
));
11952 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11953 if (sym_index
>= num_syms
)
11955 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11956 sym_index
, printable_section_name (section
));
11959 sym
= symtab
+ sym_index
;
11961 /* If the reloc has a symbol associated with it,
11962 make sure that it is of an appropriate type.
11964 Relocations against symbols without type can happen.
11965 Gcc -feliminate-dwarf2-dups may generate symbols
11966 without type for debug info.
11968 Icc generates relocations against function symbols
11969 instead of local labels.
11971 Relocations against object symbols can happen, eg when
11972 referencing a global array. For an example of this see
11973 the _clz.o binary in libgcc.a. */
11975 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11977 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11978 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11979 (long int)(rp
- relocs
),
11980 printable_section_name (relsec
));
11986 addend
+= rp
->r_addend
;
11987 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11988 partial_inplace. */
11990 || (elf_header
.e_machine
== EM_XTENSA
11991 && reloc_type
== 1)
11992 || ((elf_header
.e_machine
== EM_PJ
11993 || elf_header
.e_machine
== EM_PJ_OLD
)
11994 && reloc_type
== 1)
11995 || ((elf_header
.e_machine
== EM_D30V
11996 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11997 && reloc_type
== 12))
11998 addend
+= byte_get (rloc
, reloc_size
);
12000 if (is_32bit_pcrel_reloc (reloc_type
)
12001 || is_64bit_pcrel_reloc (reloc_type
))
12003 /* On HPPA, all pc-relative relocations are biased by 8. */
12004 if (elf_header
.e_machine
== EM_PARISC
)
12006 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12010 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12017 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12018 * num_relocs_return
= num_relocs
;
12027 #ifdef SUPPORT_DISASSEMBLY
12029 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12031 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12033 /* FIXME: XXX -- to be done --- XXX */
12039 /* Reads in the contents of SECTION from FILE, returning a pointer
12040 to a malloc'ed buffer or NULL if something went wrong. */
12043 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12045 bfd_size_type num_bytes
;
12047 num_bytes
= section
->sh_size
;
12049 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12051 printf (_("\nSection '%s' has no data to dump.\n"),
12052 printable_section_name (section
));
12056 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12057 _("section contents"));
12060 /* Uncompresses a section that was compressed using zlib, in place. */
12063 uncompress_section_contents (unsigned char **buffer
,
12064 dwarf_size_type uncompressed_size
,
12065 dwarf_size_type
*size
)
12067 dwarf_size_type compressed_size
= *size
;
12068 unsigned char * compressed_buffer
= *buffer
;
12069 unsigned char * uncompressed_buffer
;
12073 /* It is possible the section consists of several compressed
12074 buffers concatenated together, so we uncompress in a loop. */
12075 /* PR 18313: The state field in the z_stream structure is supposed
12076 to be invisible to the user (ie us), but some compilers will
12077 still complain about it being used without initialisation. So
12078 we first zero the entire z_stream structure and then set the fields
12080 memset (& strm
, 0, sizeof strm
);
12081 strm
.avail_in
= compressed_size
;
12082 strm
.next_in
= (Bytef
*) compressed_buffer
;
12083 strm
.avail_out
= uncompressed_size
;
12084 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12086 rc
= inflateInit (& strm
);
12087 while (strm
.avail_in
> 0)
12091 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12092 + (uncompressed_size
- strm
.avail_out
));
12093 rc
= inflate (&strm
, Z_FINISH
);
12094 if (rc
!= Z_STREAM_END
)
12096 rc
= inflateReset (& strm
);
12098 rc
= inflateEnd (& strm
);
12100 || strm
.avail_out
!= 0)
12103 *buffer
= uncompressed_buffer
;
12104 *size
= uncompressed_size
;
12108 free (uncompressed_buffer
);
12109 /* Indicate decompression failure. */
12115 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12117 Elf_Internal_Shdr
* relsec
;
12118 bfd_size_type num_bytes
;
12119 unsigned char * data
;
12120 unsigned char * end
;
12121 unsigned char * real_start
;
12122 unsigned char * start
;
12123 bfd_boolean some_strings_shown
;
12125 real_start
= start
= (unsigned char *) get_section_contents (section
,
12129 num_bytes
= section
->sh_size
;
12131 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12133 if (decompress_dumps
)
12135 dwarf_size_type new_size
= num_bytes
;
12136 dwarf_size_type uncompressed_size
= 0;
12138 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12140 Elf_Internal_Chdr chdr
;
12141 unsigned int compression_header_size
12142 = get_compression_header (& chdr
, (unsigned char *) start
);
12144 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12146 warn (_("section '%s' has unsupported compress type: %d\n"),
12147 printable_section_name (section
), chdr
.ch_type
);
12150 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12152 warn (_("compressed section '%s' is corrupted\n"),
12153 printable_section_name (section
));
12156 uncompressed_size
= chdr
.ch_size
;
12157 start
+= compression_header_size
;
12158 new_size
-= compression_header_size
;
12160 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12162 /* Read the zlib header. In this case, it should be "ZLIB"
12163 followed by the uncompressed section size, 8 bytes in
12164 big-endian order. */
12165 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12166 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12167 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12168 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12169 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12170 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12171 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12172 uncompressed_size
+= start
[11];
12177 if (uncompressed_size
12178 && uncompress_section_contents (& start
,
12179 uncompressed_size
, & new_size
))
12180 num_bytes
= new_size
;
12183 /* If the section being dumped has relocations against it the user might
12184 be expecting these relocations to have been applied. Check for this
12185 case and issue a warning message in order to avoid confusion.
12186 FIXME: Maybe we ought to have an option that dumps a section with
12187 relocs applied ? */
12188 for (relsec
= section_headers
;
12189 relsec
< section_headers
+ elf_header
.e_shnum
;
12192 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12193 || relsec
->sh_info
>= elf_header
.e_shnum
12194 || section_headers
+ relsec
->sh_info
!= section
12195 || relsec
->sh_size
== 0
12196 || relsec
->sh_link
>= elf_header
.e_shnum
)
12199 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12204 end
= start
+ num_bytes
;
12205 some_strings_shown
= FALSE
;
12209 while (!ISPRINT (* data
))
12210 if (++ data
>= end
)
12215 size_t maxlen
= end
- data
;
12218 /* PR 11128: Use two separate invocations in order to work
12219 around bugs in the Solaris 8 implementation of printf. */
12220 printf (" [%6tx] ", data
- start
);
12222 printf (" [%6Ix] ", (size_t) (data
- start
));
12226 print_symbol ((int) maxlen
, (const char *) data
);
12228 data
+= strnlen ((const char *) data
, maxlen
);
12232 printf (_("<corrupt>\n"));
12235 some_strings_shown
= TRUE
;
12239 if (! some_strings_shown
)
12240 printf (_(" No strings found in this section."));
12248 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12250 bfd_boolean relocate
)
12252 Elf_Internal_Shdr
* relsec
;
12253 bfd_size_type bytes
;
12254 bfd_size_type section_size
;
12256 unsigned char * data
;
12257 unsigned char * real_start
;
12258 unsigned char * start
;
12260 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12263 section_size
= section
->sh_size
;
12265 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12267 if (decompress_dumps
)
12269 dwarf_size_type new_size
= section_size
;
12270 dwarf_size_type uncompressed_size
= 0;
12272 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12274 Elf_Internal_Chdr chdr
;
12275 unsigned int compression_header_size
12276 = get_compression_header (& chdr
, start
);
12278 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12280 warn (_("section '%s' has unsupported compress type: %d\n"),
12281 printable_section_name (section
), chdr
.ch_type
);
12284 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12286 warn (_("compressed section '%s' is corrupted\n"),
12287 printable_section_name (section
));
12290 uncompressed_size
= chdr
.ch_size
;
12291 start
+= compression_header_size
;
12292 new_size
-= compression_header_size
;
12294 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12296 /* Read the zlib header. In this case, it should be "ZLIB"
12297 followed by the uncompressed section size, 8 bytes in
12298 big-endian order. */
12299 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12300 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12301 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12302 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12303 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12304 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12305 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12306 uncompressed_size
+= start
[11];
12311 if (uncompressed_size
12312 && uncompress_section_contents (& start
, uncompressed_size
,
12314 section_size
= new_size
;
12319 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12323 /* If the section being dumped has relocations against it the user might
12324 be expecting these relocations to have been applied. Check for this
12325 case and issue a warning message in order to avoid confusion.
12326 FIXME: Maybe we ought to have an option that dumps a section with
12327 relocs applied ? */
12328 for (relsec
= section_headers
;
12329 relsec
< section_headers
+ elf_header
.e_shnum
;
12332 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12333 || relsec
->sh_info
>= elf_header
.e_shnum
12334 || section_headers
+ relsec
->sh_info
!= section
12335 || relsec
->sh_size
== 0
12336 || relsec
->sh_link
>= elf_header
.e_shnum
)
12339 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12344 addr
= section
->sh_addr
;
12345 bytes
= section_size
;
12354 lbytes
= (bytes
> 16 ? 16 : bytes
);
12356 printf (" 0x%8.8lx ", (unsigned long) addr
);
12358 for (j
= 0; j
< 16; j
++)
12361 printf ("%2.2x", data
[j
]);
12369 for (j
= 0; j
< lbytes
; j
++)
12372 if (k
>= ' ' && k
< 0x7f)
12391 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12392 const Elf_Internal_Shdr
* sec
, void * file
)
12394 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12397 /* If it is already loaded, do nothing. */
12398 if (section
->start
!= NULL
)
12401 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12402 section
->address
= sec
->sh_addr
;
12403 section
->user_data
= NULL
;
12404 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12406 sec
->sh_size
, buf
);
12407 if (section
->start
== NULL
)
12411 unsigned char *start
= section
->start
;
12412 dwarf_size_type size
= sec
->sh_size
;
12413 dwarf_size_type uncompressed_size
= 0;
12415 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12417 Elf_Internal_Chdr chdr
;
12418 unsigned int compression_header_size
12419 = get_compression_header (&chdr
, start
);
12420 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12422 warn (_("section '%s' has unsupported compress type: %d\n"),
12423 section
->name
, chdr
.ch_type
);
12426 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12428 warn (_("compressed section '%s' is corrupted\n"),
12432 uncompressed_size
= chdr
.ch_size
;
12433 start
+= compression_header_size
;
12434 size
-= compression_header_size
;
12436 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12438 /* Read the zlib header. In this case, it should be "ZLIB"
12439 followed by the uncompressed section size, 8 bytes in
12440 big-endian order. */
12441 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12442 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12443 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12444 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12445 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12446 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12447 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12448 uncompressed_size
+= start
[11];
12453 if (uncompressed_size
12454 && uncompress_section_contents (&start
, uncompressed_size
,
12457 /* Free the compressed buffer, update the section buffer
12458 and the section size if uncompress is successful. */
12459 free (section
->start
);
12460 section
->start
= start
;
12462 section
->size
= size
;
12465 if (section
->start
== NULL
)
12468 if (debug_displays
[debug
].relocate
)
12469 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12470 & section
->reloc_info
, & section
->num_relocs
);
12473 section
->reloc_info
= NULL
;
12474 section
->num_relocs
= 0;
12480 /* If this is not NULL, load_debug_section will only look for sections
12481 within the list of sections given here. */
12482 unsigned int *section_subset
= NULL
;
12485 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12487 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12488 Elf_Internal_Shdr
* sec
;
12490 /* Locate the debug section. */
12491 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12493 section
->name
= section
->uncompressed_name
;
12496 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12498 section
->name
= section
->compressed_name
;
12503 /* If we're loading from a subset of sections, and we've loaded
12504 a section matching this name before, it's likely that it's a
12506 if (section_subset
!= NULL
)
12507 free_debug_section (debug
);
12509 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12513 free_debug_section (enum dwarf_section_display_enum debug
)
12515 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12517 if (section
->start
== NULL
)
12520 free ((char *) section
->start
);
12521 section
->start
= NULL
;
12522 section
->address
= 0;
12527 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12529 char * name
= SECTION_NAME (section
);
12530 const char * print_name
= printable_section_name (section
);
12531 bfd_size_type length
;
12535 length
= section
->sh_size
;
12538 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12541 if (section
->sh_type
== SHT_NOBITS
)
12543 /* There is no point in dumping the contents of a debugging section
12544 which has the NOBITS type - the bits in the file will be random.
12545 This can happen when a file containing a .eh_frame section is
12546 stripped with the --only-keep-debug command line option. */
12547 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12552 if (const_strneq (name
, ".gnu.linkonce.wi."))
12553 name
= ".debug_info";
12555 /* See if we know how to display the contents of this section. */
12556 for (i
= 0; i
< max
; i
++)
12557 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12558 || (i
== line
&& const_strneq (name
, ".debug_line."))
12559 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12561 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12562 int secondary
= (section
!= find_section (name
));
12565 free_debug_section ((enum dwarf_section_display_enum
) i
);
12567 if (i
== line
&& const_strneq (name
, ".debug_line."))
12569 else if (streq (sec
->uncompressed_name
, name
))
12570 sec
->name
= sec
->uncompressed_name
;
12572 sec
->name
= sec
->compressed_name
;
12573 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12576 /* If this debug section is part of a CU/TU set in a .dwp file,
12577 restrict load_debug_section to the sections in that set. */
12578 section_subset
= find_cu_tu_set (file
, shndx
);
12580 result
&= debug_displays
[i
].display (sec
, file
);
12582 section_subset
= NULL
;
12584 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12585 free_debug_section ((enum dwarf_section_display_enum
) i
);
12593 printf (_("Unrecognized debug section: %s\n"), print_name
);
12600 /* Set DUMP_SECTS for all sections where dumps were requested
12601 based on section name. */
12604 initialise_dumps_byname (void)
12606 struct dump_list_entry
* cur
;
12608 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12613 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12614 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12616 request_dump_bynumber (i
, cur
->type
);
12621 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12627 process_section_contents (FILE * file
)
12629 Elf_Internal_Shdr
* section
;
12635 initialise_dumps_byname ();
12637 for (i
= 0, section
= section_headers
;
12638 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12641 #ifdef SUPPORT_DISASSEMBLY
12642 if (dump_sects
[i
] & DISASS_DUMP
)
12643 disassemble_section (section
, file
);
12645 if (dump_sects
[i
] & HEX_DUMP
)
12646 dump_section_as_bytes (section
, file
, FALSE
);
12648 if (dump_sects
[i
] & RELOC_DUMP
)
12649 dump_section_as_bytes (section
, file
, TRUE
);
12651 if (dump_sects
[i
] & STRING_DUMP
)
12652 dump_section_as_strings (section
, file
);
12654 if (dump_sects
[i
] & DEBUG_DUMP
)
12655 display_debug_section (i
, section
, file
);
12658 /* Check to see if the user requested a
12659 dump of a section that does not exist. */
12660 while (i
++ < num_dump_sects
)
12662 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12666 process_mips_fpe_exception (int mask
)
12671 if (mask
& OEX_FPU_INEX
)
12672 fputs ("INEX", stdout
), first
= 0;
12673 if (mask
& OEX_FPU_UFLO
)
12674 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12675 if (mask
& OEX_FPU_OFLO
)
12676 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12677 if (mask
& OEX_FPU_DIV0
)
12678 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12679 if (mask
& OEX_FPU_INVAL
)
12680 printf ("%sINVAL", first
? "" : "|");
12683 fputs ("0", stdout
);
12686 /* Display's the value of TAG at location P. If TAG is
12687 greater than 0 it is assumed to be an unknown tag, and
12688 a message is printed to this effect. Otherwise it is
12689 assumed that a message has already been printed.
12691 If the bottom bit of TAG is set it assumed to have a
12692 string value, otherwise it is assumed to have an integer
12695 Returns an updated P pointing to the first unread byte
12696 beyond the end of TAG's value.
12698 Reads at or beyond END will not be made. */
12700 static unsigned char *
12701 display_tag_value (int tag
,
12703 const unsigned char * const end
)
12708 printf (" Tag_unknown_%d: ", tag
);
12712 warn (_("<corrupt tag>\n"));
12716 /* PR 17531 file: 027-19978-0.004. */
12717 size_t maxlen
= (end
- p
) - 1;
12722 print_symbol ((int) maxlen
, (const char *) p
);
12723 p
+= strnlen ((char *) p
, maxlen
) + 1;
12727 printf (_("<corrupt string tag>"));
12728 p
= (unsigned char *) end
;
12736 val
= read_uleb128 (p
, &len
, end
);
12738 printf ("%ld (0x%lx)\n", val
, val
);
12745 /* ARM EABI attributes section. */
12750 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12752 const char ** table
;
12753 } arm_attr_public_tag
;
12755 static const char * arm_attr_tag_CPU_arch
[] =
12756 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12757 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
12759 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12760 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12761 {"No", "Thumb-1", "Thumb-2", "Yes"};
12762 static const char * arm_attr_tag_FP_arch
[] =
12763 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12764 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12765 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12766 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12767 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12768 static const char * arm_attr_tag_PCS_config
[] =
12769 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12770 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12771 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12772 {"V6", "SB", "TLS", "Unused"};
12773 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12774 {"Absolute", "PC-relative", "SB-relative", "None"};
12775 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12776 {"Absolute", "PC-relative", "None"};
12777 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12778 {"None", "direct", "GOT-indirect"};
12779 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12780 {"None", "??? 1", "2", "??? 3", "4"};
12781 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12782 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12783 {"Unused", "Needed", "Sign only"};
12784 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12785 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12786 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12787 {"Unused", "Finite", "RTABI", "IEEE 754"};
12788 static const char * arm_attr_tag_ABI_enum_size
[] =
12789 {"Unused", "small", "int", "forced to int"};
12790 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12791 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12792 static const char * arm_attr_tag_ABI_VFP_args
[] =
12793 {"AAPCS", "VFP registers", "custom", "compatible"};
12794 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12795 {"AAPCS", "WMMX registers", "custom"};
12796 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12797 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12798 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12799 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12800 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12801 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12802 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12803 static const char * arm_attr_tag_FP_HP_extension
[] =
12804 {"Not Allowed", "Allowed"};
12805 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12806 {"None", "IEEE 754", "Alternative Format"};
12807 static const char * arm_attr_tag_MPextension_use
[] =
12808 {"Not Allowed", "Allowed"};
12809 static const char * arm_attr_tag_DIV_use
[] =
12810 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12811 "Allowed in v7-A with integer division extension"};
12812 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12813 static const char * arm_attr_tag_Virtualization_use
[] =
12814 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12815 "TrustZone and Virtualization Extensions"};
12816 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12817 {"Not Allowed", "Allowed"};
12819 #define LOOKUP(id, name) \
12820 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12821 static arm_attr_public_tag arm_attr_public_tags
[] =
12823 {4, "CPU_raw_name", 1, NULL
},
12824 {5, "CPU_name", 1, NULL
},
12825 LOOKUP(6, CPU_arch
),
12826 {7, "CPU_arch_profile", 0, NULL
},
12827 LOOKUP(8, ARM_ISA_use
),
12828 LOOKUP(9, THUMB_ISA_use
),
12829 LOOKUP(10, FP_arch
),
12830 LOOKUP(11, WMMX_arch
),
12831 LOOKUP(12, Advanced_SIMD_arch
),
12832 LOOKUP(13, PCS_config
),
12833 LOOKUP(14, ABI_PCS_R9_use
),
12834 LOOKUP(15, ABI_PCS_RW_data
),
12835 LOOKUP(16, ABI_PCS_RO_data
),
12836 LOOKUP(17, ABI_PCS_GOT_use
),
12837 LOOKUP(18, ABI_PCS_wchar_t
),
12838 LOOKUP(19, ABI_FP_rounding
),
12839 LOOKUP(20, ABI_FP_denormal
),
12840 LOOKUP(21, ABI_FP_exceptions
),
12841 LOOKUP(22, ABI_FP_user_exceptions
),
12842 LOOKUP(23, ABI_FP_number_model
),
12843 {24, "ABI_align_needed", 0, NULL
},
12844 {25, "ABI_align_preserved", 0, NULL
},
12845 LOOKUP(26, ABI_enum_size
),
12846 LOOKUP(27, ABI_HardFP_use
),
12847 LOOKUP(28, ABI_VFP_args
),
12848 LOOKUP(29, ABI_WMMX_args
),
12849 LOOKUP(30, ABI_optimization_goals
),
12850 LOOKUP(31, ABI_FP_optimization_goals
),
12851 {32, "compatibility", 0, NULL
},
12852 LOOKUP(34, CPU_unaligned_access
),
12853 LOOKUP(36, FP_HP_extension
),
12854 LOOKUP(38, ABI_FP_16bit_format
),
12855 LOOKUP(42, MPextension_use
),
12856 LOOKUP(44, DIV_use
),
12857 {64, "nodefaults", 0, NULL
},
12858 {65, "also_compatible_with", 0, NULL
},
12859 LOOKUP(66, T2EE_use
),
12860 {67, "conformance", 1, NULL
},
12861 LOOKUP(68, Virtualization_use
),
12862 LOOKUP(70, MPextension_use_legacy
)
12866 static unsigned char *
12867 display_arm_attribute (unsigned char * p
,
12868 const unsigned char * const end
)
12873 arm_attr_public_tag
* attr
;
12877 tag
= read_uleb128 (p
, &len
, end
);
12880 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12882 if (arm_attr_public_tags
[i
].tag
== tag
)
12884 attr
= &arm_attr_public_tags
[i
];
12891 printf (" Tag_%s: ", attr
->name
);
12892 switch (attr
->type
)
12897 case 7: /* Tag_CPU_arch_profile. */
12898 val
= read_uleb128 (p
, &len
, end
);
12902 case 0: printf (_("None\n")); break;
12903 case 'A': printf (_("Application\n")); break;
12904 case 'R': printf (_("Realtime\n")); break;
12905 case 'M': printf (_("Microcontroller\n")); break;
12906 case 'S': printf (_("Application or Realtime\n")); break;
12907 default: printf ("??? (%d)\n", val
); break;
12911 case 24: /* Tag_align_needed. */
12912 val
= read_uleb128 (p
, &len
, end
);
12916 case 0: printf (_("None\n")); break;
12917 case 1: printf (_("8-byte\n")); break;
12918 case 2: printf (_("4-byte\n")); break;
12919 case 3: printf ("??? 3\n"); break;
12922 printf (_("8-byte and up to %d-byte extended\n"),
12925 printf ("??? (%d)\n", val
);
12930 case 25: /* Tag_align_preserved. */
12931 val
= read_uleb128 (p
, &len
, end
);
12935 case 0: printf (_("None\n")); break;
12936 case 1: printf (_("8-byte, except leaf SP\n")); break;
12937 case 2: printf (_("8-byte\n")); break;
12938 case 3: printf ("??? 3\n"); break;
12941 printf (_("8-byte and up to %d-byte extended\n"),
12944 printf ("??? (%d)\n", val
);
12949 case 32: /* Tag_compatibility. */
12951 val
= read_uleb128 (p
, &len
, end
);
12953 printf (_("flag = %d, vendor = "), val
);
12956 size_t maxlen
= (end
- p
) - 1;
12958 print_symbol ((int) maxlen
, (const char *) p
);
12959 p
+= strnlen ((char *) p
, maxlen
) + 1;
12963 printf (_("<corrupt>"));
12964 p
= (unsigned char *) end
;
12970 case 64: /* Tag_nodefaults. */
12971 /* PR 17531: file: 001-505008-0.01. */
12974 printf (_("True\n"));
12977 case 65: /* Tag_also_compatible_with. */
12978 val
= read_uleb128 (p
, &len
, end
);
12980 if (val
== 6 /* Tag_CPU_arch. */)
12982 val
= read_uleb128 (p
, &len
, end
);
12984 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12985 printf ("??? (%d)\n", val
);
12987 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12991 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12996 printf (_("<unknown: %d>\n"), tag
);
13002 return display_tag_value (-1, p
, end
);
13004 return display_tag_value (0, p
, end
);
13007 assert (attr
->type
& 0x80);
13008 val
= read_uleb128 (p
, &len
, end
);
13010 type
= attr
->type
& 0x7f;
13012 printf ("??? (%d)\n", val
);
13014 printf ("%s\n", attr
->table
[val
]);
13019 return display_tag_value (tag
, p
, end
);
13022 static unsigned char *
13023 display_gnu_attribute (unsigned char * p
,
13024 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13025 const unsigned char * const end
)
13031 tag
= read_uleb128 (p
, &len
, end
);
13034 /* Tag_compatibility is the only generic GNU attribute defined at
13038 val
= read_uleb128 (p
, &len
, end
);
13041 printf (_("flag = %d, vendor = "), val
);
13044 printf (_("<corrupt>\n"));
13045 warn (_("corrupt vendor attribute\n"));
13051 size_t maxlen
= (end
- p
) - 1;
13053 print_symbol ((int) maxlen
, (const char *) p
);
13054 p
+= strnlen ((char *) p
, maxlen
) + 1;
13058 printf (_("<corrupt>"));
13059 p
= (unsigned char *) end
;
13066 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13067 return display_proc_gnu_attribute (p
, tag
, end
);
13069 return display_tag_value (tag
, p
, end
);
13072 static unsigned char *
13073 display_power_gnu_attribute (unsigned char * p
,
13075 const unsigned char * const end
)
13080 if (tag
== Tag_GNU_Power_ABI_FP
)
13082 val
= read_uleb128 (p
, &len
, end
);
13084 printf (" Tag_GNU_Power_ABI_FP: ");
13089 printf (_("Hard or soft float\n"));
13092 printf (_("Hard float\n"));
13095 printf (_("Soft float\n"));
13098 printf (_("Single-precision hard float\n"));
13101 printf ("??? (%d)\n", val
);
13107 if (tag
== Tag_GNU_Power_ABI_Vector
)
13109 val
= read_uleb128 (p
, &len
, end
);
13111 printf (" Tag_GNU_Power_ABI_Vector: ");
13115 printf (_("Any\n"));
13118 printf (_("Generic\n"));
13121 printf ("AltiVec\n");
13127 printf ("??? (%d)\n", val
);
13133 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13137 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13141 val
= read_uleb128 (p
, &len
, end
);
13143 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13147 printf (_("Any\n"));
13150 printf ("r3/r4\n");
13153 printf (_("Memory\n"));
13156 printf ("??? (%d)\n", val
);
13162 return display_tag_value (tag
& 1, p
, end
);
13165 static unsigned char *
13166 display_s390_gnu_attribute (unsigned char * p
,
13168 const unsigned char * const end
)
13173 if (tag
== Tag_GNU_S390_ABI_Vector
)
13175 val
= read_uleb128 (p
, &len
, end
);
13177 printf (" Tag_GNU_S390_ABI_Vector: ");
13182 printf (_("any\n"));
13185 printf (_("software\n"));
13188 printf (_("hardware\n"));
13191 printf ("??? (%d)\n", val
);
13197 return display_tag_value (tag
& 1, p
, end
);
13201 display_sparc_hwcaps (int mask
)
13207 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13208 fputs ("mul32", stdout
), first
= 0;
13209 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13210 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13211 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13212 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13213 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13214 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13215 if (mask
& ELF_SPARC_HWCAP_POPC
)
13216 printf ("%spopc", first
? "" : "|"), first
= 0;
13217 if (mask
& ELF_SPARC_HWCAP_VIS
)
13218 printf ("%svis", first
? "" : "|"), first
= 0;
13219 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13220 printf ("%svis2", first
? "" : "|"), first
= 0;
13221 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13222 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13223 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13224 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13225 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13226 printf ("%svis3", first
? "" : "|"), first
= 0;
13227 if (mask
& ELF_SPARC_HWCAP_HPC
)
13228 printf ("%shpc", first
? "" : "|"), first
= 0;
13229 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13230 printf ("%srandom", first
? "" : "|"), first
= 0;
13231 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13232 printf ("%strans", first
? "" : "|"), first
= 0;
13233 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13234 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13235 if (mask
& ELF_SPARC_HWCAP_IMA
)
13236 printf ("%sima", first
? "" : "|"), first
= 0;
13237 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13238 printf ("%scspare", first
? "" : "|"), first
= 0;
13241 fputc ('0', stdout
);
13242 fputc ('\n', stdout
);
13246 display_sparc_hwcaps2 (int mask
)
13252 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13253 fputs ("fjathplus", stdout
), first
= 0;
13254 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13255 printf ("%svis3b", first
? "" : "|"), first
= 0;
13256 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13257 printf ("%sadp", first
? "" : "|"), first
= 0;
13258 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13259 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13260 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13261 printf ("%smwait", first
? "" : "|"), first
= 0;
13262 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13263 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13264 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13265 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13266 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13267 printf ("%snsec", first
? "" : "|"), first
= 0;
13268 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13269 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13270 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13271 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13272 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13273 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13276 fputc ('0', stdout
);
13277 fputc ('\n', stdout
);
13280 static unsigned char *
13281 display_sparc_gnu_attribute (unsigned char * p
,
13283 const unsigned char * const end
)
13288 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13290 val
= read_uleb128 (p
, &len
, end
);
13292 printf (" Tag_GNU_Sparc_HWCAPS: ");
13293 display_sparc_hwcaps (val
);
13296 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13298 val
= read_uleb128 (p
, &len
, end
);
13300 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13301 display_sparc_hwcaps2 (val
);
13305 return display_tag_value (tag
, p
, end
);
13309 print_mips_fp_abi_value (int val
)
13313 case Val_GNU_MIPS_ABI_FP_ANY
:
13314 printf (_("Hard or soft float\n"));
13316 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13317 printf (_("Hard float (double precision)\n"));
13319 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13320 printf (_("Hard float (single precision)\n"));
13322 case Val_GNU_MIPS_ABI_FP_SOFT
:
13323 printf (_("Soft float\n"));
13325 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13326 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13328 case Val_GNU_MIPS_ABI_FP_XX
:
13329 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13331 case Val_GNU_MIPS_ABI_FP_64
:
13332 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13334 case Val_GNU_MIPS_ABI_FP_64A
:
13335 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13337 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13338 printf (_("NaN 2008 compatibility\n"));
13341 printf ("??? (%d)\n", val
);
13346 static unsigned char *
13347 display_mips_gnu_attribute (unsigned char * p
,
13349 const unsigned char * const end
)
13351 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13356 val
= read_uleb128 (p
, &len
, end
);
13358 printf (" Tag_GNU_MIPS_ABI_FP: ");
13360 print_mips_fp_abi_value (val
);
13365 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13370 val
= read_uleb128 (p
, &len
, end
);
13372 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13376 case Val_GNU_MIPS_ABI_MSA_ANY
:
13377 printf (_("Any MSA or not\n"));
13379 case Val_GNU_MIPS_ABI_MSA_128
:
13380 printf (_("128-bit MSA\n"));
13383 printf ("??? (%d)\n", val
);
13389 return display_tag_value (tag
& 1, p
, end
);
13392 static unsigned char *
13393 display_tic6x_attribute (unsigned char * p
,
13394 const unsigned char * const end
)
13400 tag
= read_uleb128 (p
, &len
, end
);
13406 val
= read_uleb128 (p
, &len
, end
);
13408 printf (" Tag_ISA: ");
13412 case C6XABI_Tag_ISA_none
:
13413 printf (_("None\n"));
13415 case C6XABI_Tag_ISA_C62X
:
13418 case C6XABI_Tag_ISA_C67X
:
13421 case C6XABI_Tag_ISA_C67XP
:
13422 printf ("C67x+\n");
13424 case C6XABI_Tag_ISA_C64X
:
13427 case C6XABI_Tag_ISA_C64XP
:
13428 printf ("C64x+\n");
13430 case C6XABI_Tag_ISA_C674X
:
13431 printf ("C674x\n");
13434 printf ("??? (%d)\n", val
);
13439 case Tag_ABI_wchar_t
:
13440 val
= read_uleb128 (p
, &len
, end
);
13442 printf (" Tag_ABI_wchar_t: ");
13446 printf (_("Not used\n"));
13449 printf (_("2 bytes\n"));
13452 printf (_("4 bytes\n"));
13455 printf ("??? (%d)\n", val
);
13460 case Tag_ABI_stack_align_needed
:
13461 val
= read_uleb128 (p
, &len
, end
);
13463 printf (" Tag_ABI_stack_align_needed: ");
13467 printf (_("8-byte\n"));
13470 printf (_("16-byte\n"));
13473 printf ("??? (%d)\n", val
);
13478 case Tag_ABI_stack_align_preserved
:
13479 val
= read_uleb128 (p
, &len
, end
);
13481 printf (" Tag_ABI_stack_align_preserved: ");
13485 printf (_("8-byte\n"));
13488 printf (_("16-byte\n"));
13491 printf ("??? (%d)\n", val
);
13497 val
= read_uleb128 (p
, &len
, end
);
13499 printf (" Tag_ABI_DSBT: ");
13503 printf (_("DSBT addressing not used\n"));
13506 printf (_("DSBT addressing used\n"));
13509 printf ("??? (%d)\n", val
);
13515 val
= read_uleb128 (p
, &len
, end
);
13517 printf (" Tag_ABI_PID: ");
13521 printf (_("Data addressing position-dependent\n"));
13524 printf (_("Data addressing position-independent, GOT near DP\n"));
13527 printf (_("Data addressing position-independent, GOT far from DP\n"));
13530 printf ("??? (%d)\n", val
);
13536 val
= read_uleb128 (p
, &len
, end
);
13538 printf (" Tag_ABI_PIC: ");
13542 printf (_("Code addressing position-dependent\n"));
13545 printf (_("Code addressing position-independent\n"));
13548 printf ("??? (%d)\n", val
);
13553 case Tag_ABI_array_object_alignment
:
13554 val
= read_uleb128 (p
, &len
, end
);
13556 printf (" Tag_ABI_array_object_alignment: ");
13560 printf (_("8-byte\n"));
13563 printf (_("4-byte\n"));
13566 printf (_("16-byte\n"));
13569 printf ("??? (%d)\n", val
);
13574 case Tag_ABI_array_object_align_expected
:
13575 val
= read_uleb128 (p
, &len
, end
);
13577 printf (" Tag_ABI_array_object_align_expected: ");
13581 printf (_("8-byte\n"));
13584 printf (_("4-byte\n"));
13587 printf (_("16-byte\n"));
13590 printf ("??? (%d)\n", val
);
13595 case Tag_ABI_compatibility
:
13597 val
= read_uleb128 (p
, &len
, end
);
13599 printf (" Tag_ABI_compatibility: ");
13600 printf (_("flag = %d, vendor = "), val
);
13603 size_t maxlen
= (end
- p
) - 1;
13605 print_symbol ((int) maxlen
, (const char *) p
);
13606 p
+= strnlen ((char *) p
, maxlen
) + 1;
13610 printf (_("<corrupt>"));
13611 p
= (unsigned char *) end
;
13617 case Tag_ABI_conformance
:
13619 printf (" Tag_ABI_conformance: \"");
13622 size_t maxlen
= (end
- p
) - 1;
13624 print_symbol ((int) maxlen
, (const char *) p
);
13625 p
+= strnlen ((char *) p
, maxlen
) + 1;
13629 printf (_("<corrupt>"));
13630 p
= (unsigned char *) end
;
13637 return display_tag_value (tag
, p
, end
);
13641 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13643 unsigned long addr
= 0;
13644 size_t bytes
= end
- p
;
13651 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13653 printf (" 0x%8.8lx ", addr
);
13655 for (j
= 0; j
< 16; j
++)
13658 printf ("%2.2x", p
[j
]);
13666 for (j
= 0; j
< lbytes
; j
++)
13669 if (k
>= ' ' && k
< 0x7f)
13685 static unsigned char *
13686 display_msp430x_attribute (unsigned char * p
,
13687 const unsigned char * const end
)
13693 tag
= read_uleb128 (p
, & len
, end
);
13698 case OFBA_MSPABI_Tag_ISA
:
13699 val
= read_uleb128 (p
, &len
, end
);
13701 printf (" Tag_ISA: ");
13704 case 0: printf (_("None\n")); break;
13705 case 1: printf (_("MSP430\n")); break;
13706 case 2: printf (_("MSP430X\n")); break;
13707 default: printf ("??? (%d)\n", val
); break;
13711 case OFBA_MSPABI_Tag_Code_Model
:
13712 val
= read_uleb128 (p
, &len
, end
);
13714 printf (" Tag_Code_Model: ");
13717 case 0: printf (_("None\n")); break;
13718 case 1: printf (_("Small\n")); break;
13719 case 2: printf (_("Large\n")); break;
13720 default: printf ("??? (%d)\n", val
); break;
13724 case OFBA_MSPABI_Tag_Data_Model
:
13725 val
= read_uleb128 (p
, &len
, end
);
13727 printf (" Tag_Data_Model: ");
13730 case 0: printf (_("None\n")); break;
13731 case 1: printf (_("Small\n")); break;
13732 case 2: printf (_("Large\n")); break;
13733 case 3: printf (_("Restricted Large\n")); break;
13734 default: printf ("??? (%d)\n", val
); break;
13739 printf (_(" <unknown tag %d>: "), tag
);
13746 size_t maxlen
= (end
- p
) - 1;
13748 print_symbol ((int) maxlen
, (const char *) p
);
13749 p
+= strnlen ((char *) p
, maxlen
) + 1;
13753 printf (_("<corrupt>"));
13754 p
= (unsigned char *) end
;
13760 val
= read_uleb128 (p
, &len
, end
);
13762 printf ("%d (0x%x)\n", val
, val
);
13772 process_attributes (FILE * file
,
13773 const char * public_name
,
13774 unsigned int proc_type
,
13775 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13776 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13778 Elf_Internal_Shdr
* sect
;
13781 /* Find the section header so that we get the size. */
13782 for (i
= 0, sect
= section_headers
;
13783 i
< elf_header
.e_shnum
;
13786 unsigned char * contents
;
13789 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13792 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13793 sect
->sh_size
, _("attributes"));
13794 if (contents
== NULL
)
13800 bfd_vma section_len
;
13802 section_len
= sect
->sh_size
- 1;
13805 while (section_len
> 0)
13808 unsigned int namelen
;
13809 bfd_boolean public_section
;
13810 bfd_boolean gnu_section
;
13812 if (section_len
<= 4)
13814 error (_("Tag section ends prematurely\n"));
13817 attr_len
= byte_get (p
, 4);
13820 if (attr_len
> section_len
)
13822 error (_("Bad attribute length (%u > %u)\n"),
13823 (unsigned) attr_len
, (unsigned) section_len
);
13824 attr_len
= section_len
;
13826 /* PR 17531: file: 001-101425-0.004 */
13827 else if (attr_len
< 5)
13829 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13833 section_len
-= attr_len
;
13836 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13837 if (namelen
== 0 || namelen
>= attr_len
)
13839 error (_("Corrupt attribute section name\n"));
13843 printf (_("Attribute Section: "));
13844 print_symbol (INT_MAX
, (const char *) p
);
13847 if (public_name
&& streq ((char *) p
, public_name
))
13848 public_section
= TRUE
;
13850 public_section
= FALSE
;
13852 if (streq ((char *) p
, "gnu"))
13853 gnu_section
= TRUE
;
13855 gnu_section
= FALSE
;
13858 attr_len
-= namelen
;
13860 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13865 unsigned char * end
;
13867 /* PR binutils/17531: Safe handling of corrupt files. */
13870 error (_("Unused bytes at end of section\n"));
13876 size
= byte_get (p
, 4);
13877 if (size
> attr_len
)
13879 error (_("Bad subsection length (%u > %u)\n"),
13880 (unsigned) size
, (unsigned) attr_len
);
13883 /* PR binutils/17531: Safe handling of corrupt files. */
13886 error (_("Bad subsection length (%u < 6)\n"),
13893 end
= p
+ size
- 1;
13894 assert (end
<= contents
+ sect
->sh_size
);
13900 printf (_("File Attributes\n"));
13903 printf (_("Section Attributes:"));
13906 printf (_("Symbol Attributes:"));
13912 val
= read_uleb128 (p
, &j
, end
);
13916 printf (" %d", val
);
13921 printf (_("Unknown tag: %d\n"), tag
);
13922 public_section
= FALSE
;
13926 if (public_section
&& display_pub_attribute
!= NULL
)
13929 p
= display_pub_attribute (p
, end
);
13932 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13935 p
= display_gnu_attribute (p
,
13936 display_proc_gnu_attribute
,
13942 printf (_(" Unknown attribute:\n"));
13943 display_raw_attribute (p
, end
);
13952 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13960 process_arm_specific (FILE * file
)
13962 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13963 display_arm_attribute
, NULL
);
13967 process_power_specific (FILE * file
)
13969 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13970 display_power_gnu_attribute
);
13974 process_s390_specific (FILE * file
)
13976 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13977 display_s390_gnu_attribute
);
13981 process_sparc_specific (FILE * file
)
13983 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13984 display_sparc_gnu_attribute
);
13988 process_tic6x_specific (FILE * file
)
13990 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13991 display_tic6x_attribute
, NULL
);
13995 process_msp430x_specific (FILE * file
)
13997 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13998 display_msp430x_attribute
, NULL
);
14001 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14002 Print the Address, Access and Initial fields of an entry at VMA ADDR
14003 and return the VMA of the next entry, or -1 if there was a problem.
14004 Does not read from DATA_END or beyond. */
14007 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
14008 unsigned char * data_end
)
14011 print_vma (addr
, LONG_HEX
);
14013 if (addr
< pltgot
+ 0xfff0)
14014 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14016 printf ("%10s", "");
14019 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14023 unsigned char * from
= data
+ addr
- pltgot
;
14025 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14027 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14028 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14029 return (bfd_vma
) -1;
14033 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14034 print_vma (entry
, LONG_HEX
);
14037 return addr
+ (is_32bit_elf
? 4 : 8);
14040 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14041 PLTGOT. Print the Address and Initial fields of an entry at VMA
14042 ADDR and return the VMA of the next entry. */
14045 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14048 print_vma (addr
, LONG_HEX
);
14051 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14056 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14057 print_vma (entry
, LONG_HEX
);
14059 return addr
+ (is_32bit_elf
? 4 : 8);
14063 print_mips_ases (unsigned int mask
)
14065 if (mask
& AFL_ASE_DSP
)
14066 fputs ("\n\tDSP ASE", stdout
);
14067 if (mask
& AFL_ASE_DSPR2
)
14068 fputs ("\n\tDSP R2 ASE", stdout
);
14069 if (mask
& AFL_ASE_EVA
)
14070 fputs ("\n\tEnhanced VA Scheme", stdout
);
14071 if (mask
& AFL_ASE_MCU
)
14072 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14073 if (mask
& AFL_ASE_MDMX
)
14074 fputs ("\n\tMDMX ASE", stdout
);
14075 if (mask
& AFL_ASE_MIPS3D
)
14076 fputs ("\n\tMIPS-3D ASE", stdout
);
14077 if (mask
& AFL_ASE_MT
)
14078 fputs ("\n\tMT ASE", stdout
);
14079 if (mask
& AFL_ASE_SMARTMIPS
)
14080 fputs ("\n\tSmartMIPS ASE", stdout
);
14081 if (mask
& AFL_ASE_VIRT
)
14082 fputs ("\n\tVZ ASE", stdout
);
14083 if (mask
& AFL_ASE_MSA
)
14084 fputs ("\n\tMSA ASE", stdout
);
14085 if (mask
& AFL_ASE_MIPS16
)
14086 fputs ("\n\tMIPS16 ASE", stdout
);
14087 if (mask
& AFL_ASE_MICROMIPS
)
14088 fputs ("\n\tMICROMIPS ASE", stdout
);
14089 if (mask
& AFL_ASE_XPA
)
14090 fputs ("\n\tXPA ASE", stdout
);
14092 fprintf (stdout
, "\n\t%s", _("None"));
14093 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14094 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14098 print_mips_isa_ext (unsigned int isa_ext
)
14103 fputs (_("None"), stdout
);
14106 fputs ("RMI XLR", stdout
);
14108 case AFL_EXT_OCTEON3
:
14109 fputs ("Cavium Networks Octeon3", stdout
);
14111 case AFL_EXT_OCTEON2
:
14112 fputs ("Cavium Networks Octeon2", stdout
);
14114 case AFL_EXT_OCTEONP
:
14115 fputs ("Cavium Networks OcteonP", stdout
);
14117 case AFL_EXT_LOONGSON_3A
:
14118 fputs ("Loongson 3A", stdout
);
14120 case AFL_EXT_OCTEON
:
14121 fputs ("Cavium Networks Octeon", stdout
);
14124 fputs ("Toshiba R5900", stdout
);
14127 fputs ("MIPS R4650", stdout
);
14130 fputs ("LSI R4010", stdout
);
14133 fputs ("NEC VR4100", stdout
);
14136 fputs ("Toshiba R3900", stdout
);
14138 case AFL_EXT_10000
:
14139 fputs ("MIPS R10000", stdout
);
14142 fputs ("Broadcom SB-1", stdout
);
14145 fputs ("NEC VR4111/VR4181", stdout
);
14148 fputs ("NEC VR4120", stdout
);
14151 fputs ("NEC VR5400", stdout
);
14154 fputs ("NEC VR5500", stdout
);
14156 case AFL_EXT_LOONGSON_2E
:
14157 fputs ("ST Microelectronics Loongson 2E", stdout
);
14159 case AFL_EXT_LOONGSON_2F
:
14160 fputs ("ST Microelectronics Loongson 2F", stdout
);
14163 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14168 get_mips_reg_size (int reg_size
)
14170 return (reg_size
== AFL_REG_NONE
) ? 0
14171 : (reg_size
== AFL_REG_32
) ? 32
14172 : (reg_size
== AFL_REG_64
) ? 64
14173 : (reg_size
== AFL_REG_128
) ? 128
14178 process_mips_specific (FILE * file
)
14180 Elf_Internal_Dyn
* entry
;
14181 Elf_Internal_Shdr
*sect
= NULL
;
14182 size_t liblist_offset
= 0;
14183 size_t liblistno
= 0;
14184 size_t conflictsno
= 0;
14185 size_t options_offset
= 0;
14186 size_t conflicts_offset
= 0;
14187 size_t pltrelsz
= 0;
14189 bfd_vma pltgot
= 0;
14190 bfd_vma mips_pltgot
= 0;
14191 bfd_vma jmprel
= 0;
14192 bfd_vma local_gotno
= 0;
14193 bfd_vma gotsym
= 0;
14194 bfd_vma symtabno
= 0;
14196 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14197 display_mips_gnu_attribute
);
14199 sect
= find_section (".MIPS.abiflags");
14203 Elf_External_ABIFlags_v0
*abiflags_ext
;
14204 Elf_Internal_ABIFlags_v0 abiflags_in
;
14206 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14207 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14210 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14211 sect
->sh_size
, _("MIPS ABI Flags section"));
14214 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14215 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14216 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14217 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14218 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14219 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14220 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14221 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14222 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14223 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14224 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14226 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14227 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14228 if (abiflags_in
.isa_rev
> 1)
14229 printf ("r%d", abiflags_in
.isa_rev
);
14230 printf ("\nGPR size: %d",
14231 get_mips_reg_size (abiflags_in
.gpr_size
));
14232 printf ("\nCPR1 size: %d",
14233 get_mips_reg_size (abiflags_in
.cpr1_size
));
14234 printf ("\nCPR2 size: %d",
14235 get_mips_reg_size (abiflags_in
.cpr2_size
));
14236 fputs ("\nFP ABI: ", stdout
);
14237 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14238 fputs ("ISA Extension: ", stdout
);
14239 print_mips_isa_ext (abiflags_in
.isa_ext
);
14240 fputs ("\nASEs:", stdout
);
14241 print_mips_ases (abiflags_in
.ases
);
14242 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14243 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14244 fputc ('\n', stdout
);
14245 free (abiflags_ext
);
14250 /* We have a lot of special sections. Thanks SGI! */
14251 if (dynamic_section
== NULL
)
14252 /* No information available. */
14255 for (entry
= dynamic_section
;
14256 /* PR 17531 file: 012-50589-0.004. */
14257 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14259 switch (entry
->d_tag
)
14261 case DT_MIPS_LIBLIST
:
14263 = offset_from_vma (file
, entry
->d_un
.d_val
,
14264 liblistno
* sizeof (Elf32_External_Lib
));
14266 case DT_MIPS_LIBLISTNO
:
14267 liblistno
= entry
->d_un
.d_val
;
14269 case DT_MIPS_OPTIONS
:
14270 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14272 case DT_MIPS_CONFLICT
:
14274 = offset_from_vma (file
, entry
->d_un
.d_val
,
14275 conflictsno
* sizeof (Elf32_External_Conflict
));
14277 case DT_MIPS_CONFLICTNO
:
14278 conflictsno
= entry
->d_un
.d_val
;
14281 pltgot
= entry
->d_un
.d_ptr
;
14283 case DT_MIPS_LOCAL_GOTNO
:
14284 local_gotno
= entry
->d_un
.d_val
;
14286 case DT_MIPS_GOTSYM
:
14287 gotsym
= entry
->d_un
.d_val
;
14289 case DT_MIPS_SYMTABNO
:
14290 symtabno
= entry
->d_un
.d_val
;
14292 case DT_MIPS_PLTGOT
:
14293 mips_pltgot
= entry
->d_un
.d_ptr
;
14296 pltrel
= entry
->d_un
.d_val
;
14299 pltrelsz
= entry
->d_un
.d_val
;
14302 jmprel
= entry
->d_un
.d_ptr
;
14308 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14310 Elf32_External_Lib
* elib
;
14313 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14315 sizeof (Elf32_External_Lib
),
14316 _("liblist section data"));
14319 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14320 (unsigned long) liblistno
);
14321 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14324 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14331 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14332 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14333 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14334 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14335 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14337 tmp
= gmtime (&atime
);
14338 snprintf (timebuf
, sizeof (timebuf
),
14339 "%04u-%02u-%02uT%02u:%02u:%02u",
14340 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14341 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14343 printf ("%3lu: ", (unsigned long) cnt
);
14344 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14345 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14347 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14348 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14349 liblist
.l_version
);
14351 if (liblist
.l_flags
== 0)
14355 static const struct
14362 { " EXACT_MATCH", LL_EXACT_MATCH
},
14363 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14364 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14365 { " EXPORTS", LL_EXPORTS
},
14366 { " DELAY_LOAD", LL_DELAY_LOAD
},
14367 { " DELTA", LL_DELTA
}
14369 int flags
= liblist
.l_flags
;
14372 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14373 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14375 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14376 flags
^= l_flags_vals
[fcnt
].bit
;
14379 printf (" %#x", (unsigned int) flags
);
14389 if (options_offset
!= 0)
14391 Elf_External_Options
* eopt
;
14392 Elf_Internal_Options
* iopt
;
14393 Elf_Internal_Options
* option
;
14396 sect
= section_headers
;
14398 /* Find the section header so that we get the size. */
14399 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14400 /* PR 17533 file: 012-277276-0.004. */
14403 error (_("No MIPS_OPTIONS header found\n"));
14407 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14408 sect
->sh_size
, _("options"));
14411 iopt
= (Elf_Internal_Options
*)
14412 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14415 error (_("Out of memory allocatinf space for MIPS options\n"));
14422 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14424 Elf_External_Options
* eoption
;
14426 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14428 option
->kind
= BYTE_GET (eoption
->kind
);
14429 option
->size
= BYTE_GET (eoption
->size
);
14430 option
->section
= BYTE_GET (eoption
->section
);
14431 option
->info
= BYTE_GET (eoption
->info
);
14433 /* PR 17531: file: ffa0fa3b. */
14434 if (option
->size
< sizeof (* eopt
)
14435 || offset
+ option
->size
> sect
->sh_size
)
14437 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14440 offset
+= option
->size
;
14446 printf (_("\nSection '%s' contains %d entries:\n"),
14447 printable_section_name (sect
), cnt
);
14456 switch (option
->kind
)
14459 /* This shouldn't happen. */
14460 printf (" NULL %d %lx", option
->section
, option
->info
);
14463 printf (" REGINFO ");
14464 if (elf_header
.e_machine
== EM_MIPS
)
14467 Elf32_External_RegInfo
* ereg
;
14468 Elf32_RegInfo reginfo
;
14470 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14471 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14472 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14473 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14474 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14475 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14476 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14478 printf ("GPR %08lx GP 0x%lx\n",
14479 reginfo
.ri_gprmask
,
14480 (unsigned long) reginfo
.ri_gp_value
);
14481 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14482 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14483 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14488 Elf64_External_RegInfo
* ereg
;
14489 Elf64_Internal_RegInfo reginfo
;
14491 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14492 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14493 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14494 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14495 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14496 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14497 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14499 printf ("GPR %08lx GP 0x",
14500 reginfo
.ri_gprmask
);
14501 printf_vma (reginfo
.ri_gp_value
);
14504 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14505 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14506 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14510 case ODK_EXCEPTIONS
:
14511 fputs (" EXCEPTIONS fpe_min(", stdout
);
14512 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14513 fputs (") fpe_max(", stdout
);
14514 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14515 fputs (")", stdout
);
14517 if (option
->info
& OEX_PAGE0
)
14518 fputs (" PAGE0", stdout
);
14519 if (option
->info
& OEX_SMM
)
14520 fputs (" SMM", stdout
);
14521 if (option
->info
& OEX_FPDBUG
)
14522 fputs (" FPDBUG", stdout
);
14523 if (option
->info
& OEX_DISMISS
)
14524 fputs (" DISMISS", stdout
);
14527 fputs (" PAD ", stdout
);
14528 if (option
->info
& OPAD_PREFIX
)
14529 fputs (" PREFIX", stdout
);
14530 if (option
->info
& OPAD_POSTFIX
)
14531 fputs (" POSTFIX", stdout
);
14532 if (option
->info
& OPAD_SYMBOL
)
14533 fputs (" SYMBOL", stdout
);
14536 fputs (" HWPATCH ", stdout
);
14537 if (option
->info
& OHW_R4KEOP
)
14538 fputs (" R4KEOP", stdout
);
14539 if (option
->info
& OHW_R8KPFETCH
)
14540 fputs (" R8KPFETCH", stdout
);
14541 if (option
->info
& OHW_R5KEOP
)
14542 fputs (" R5KEOP", stdout
);
14543 if (option
->info
& OHW_R5KCVTL
)
14544 fputs (" R5KCVTL", stdout
);
14547 fputs (" FILL ", stdout
);
14548 /* XXX Print content of info word? */
14551 fputs (" TAGS ", stdout
);
14552 /* XXX Print content of info word? */
14555 fputs (" HWAND ", stdout
);
14556 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14557 fputs (" R4KEOP_CHECKED", stdout
);
14558 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14559 fputs (" R4KEOP_CLEAN", stdout
);
14562 fputs (" HWOR ", stdout
);
14563 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14564 fputs (" R4KEOP_CHECKED", stdout
);
14565 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14566 fputs (" R4KEOP_CLEAN", stdout
);
14569 printf (" GP_GROUP %#06lx self-contained %#06lx",
14570 option
->info
& OGP_GROUP
,
14571 (option
->info
& OGP_SELF
) >> 16);
14574 printf (" IDENT %#06lx self-contained %#06lx",
14575 option
->info
& OGP_GROUP
,
14576 (option
->info
& OGP_SELF
) >> 16);
14579 /* This shouldn't happen. */
14580 printf (" %3d ??? %d %lx",
14581 option
->kind
, option
->section
, option
->info
);
14585 len
= sizeof (* eopt
);
14586 while (len
< option
->size
)
14588 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14590 if (ISPRINT (datum
))
14591 printf ("%c", datum
);
14593 printf ("\\%03o", datum
);
14596 fputs ("\n", stdout
);
14598 offset
+= option
->size
;
14606 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14608 Elf32_Conflict
* iconf
;
14611 if (dynamic_symbols
== NULL
)
14613 error (_("conflict list found without a dynamic symbol table\n"));
14617 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14620 error (_("Out of memory allocating space for dynamic conflicts\n"));
14626 Elf32_External_Conflict
* econf32
;
14628 econf32
= (Elf32_External_Conflict
*)
14629 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14630 sizeof (* econf32
), _("conflict"));
14634 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14635 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14641 Elf64_External_Conflict
* econf64
;
14643 econf64
= (Elf64_External_Conflict
*)
14644 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14645 sizeof (* econf64
), _("conflict"));
14649 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14650 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14655 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14656 (unsigned long) conflictsno
);
14657 puts (_(" Num: Index Value Name"));
14659 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14661 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14663 if (iconf
[cnt
] >= num_dynamic_syms
)
14664 printf (_("<corrupt symbol index>"));
14667 Elf_Internal_Sym
* psym
;
14669 psym
= & dynamic_symbols
[iconf
[cnt
]];
14670 print_vma (psym
->st_value
, FULL_HEX
);
14672 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14673 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14675 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14683 if (pltgot
!= 0 && local_gotno
!= 0)
14685 bfd_vma ent
, local_end
, global_end
;
14687 unsigned char * data
;
14688 unsigned char * data_end
;
14692 addr_size
= (is_32bit_elf
? 4 : 8);
14693 local_end
= pltgot
+ local_gotno
* addr_size
;
14695 /* PR binutils/17533 file: 012-111227-0.004 */
14696 if (symtabno
< gotsym
)
14698 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14699 (unsigned long) gotsym
, (unsigned long) symtabno
);
14703 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14704 /* PR 17531: file: 54c91a34. */
14705 if (global_end
< local_end
)
14707 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14711 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14712 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14713 global_end
- pltgot
, 1,
14714 _("Global Offset Table data"));
14717 data_end
= data
+ (global_end
- pltgot
);
14719 printf (_("\nPrimary GOT:\n"));
14720 printf (_(" Canonical gp value: "));
14721 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14724 printf (_(" Reserved entries:\n"));
14725 printf (_(" %*s %10s %*s Purpose\n"),
14726 addr_size
* 2, _("Address"), _("Access"),
14727 addr_size
* 2, _("Initial"));
14728 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14729 printf (_(" Lazy resolver\n"));
14730 if (ent
== (bfd_vma
) -1)
14731 goto got_print_fail
;
14733 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14734 >> (addr_size
* 8 - 1)) != 0)
14736 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14737 printf (_(" Module pointer (GNU extension)\n"));
14738 if (ent
== (bfd_vma
) -1)
14739 goto got_print_fail
;
14743 if (ent
< local_end
)
14745 printf (_(" Local entries:\n"));
14746 printf (" %*s %10s %*s\n",
14747 addr_size
* 2, _("Address"), _("Access"),
14748 addr_size
* 2, _("Initial"));
14749 while (ent
< local_end
)
14751 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14753 if (ent
== (bfd_vma
) -1)
14754 goto got_print_fail
;
14759 if (gotsym
< symtabno
)
14763 printf (_(" Global entries:\n"));
14764 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14765 addr_size
* 2, _("Address"),
14767 addr_size
* 2, _("Initial"),
14768 addr_size
* 2, _("Sym.Val."),
14770 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14771 _("Ndx"), _("Name"));
14773 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14775 for (i
= gotsym
; i
< symtabno
; i
++)
14777 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14780 if (dynamic_symbols
== NULL
)
14781 printf (_("<no dynamic symbols>"));
14782 else if (i
< num_dynamic_syms
)
14784 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14786 print_vma (psym
->st_value
, LONG_HEX
);
14787 printf (" %-7s %3s ",
14788 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14789 get_symbol_index_type (psym
->st_shndx
));
14791 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14792 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14794 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14797 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14798 (unsigned long) i
);
14801 if (ent
== (bfd_vma
) -1)
14812 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14815 size_t offset
, rel_offset
;
14816 unsigned long count
, i
;
14817 unsigned char * data
;
14818 int addr_size
, sym_width
;
14819 Elf_Internal_Rela
* rels
;
14821 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14822 if (pltrel
== DT_RELA
)
14824 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14829 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14834 addr_size
= (is_32bit_elf
? 4 : 8);
14835 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14837 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14838 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14839 1, _("Procedure Linkage Table data"));
14843 printf ("\nPLT GOT:\n\n");
14844 printf (_(" Reserved entries:\n"));
14845 printf (_(" %*s %*s Purpose\n"),
14846 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14847 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14848 printf (_(" PLT lazy resolver\n"));
14849 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14850 printf (_(" Module pointer\n"));
14853 printf (_(" Entries:\n"));
14854 printf (" %*s %*s %*s %-7s %3s %s\n",
14855 addr_size
* 2, _("Address"),
14856 addr_size
* 2, _("Initial"),
14857 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14858 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14859 for (i
= 0; i
< count
; i
++)
14861 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14863 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14866 if (idx
>= num_dynamic_syms
)
14867 printf (_("<corrupt symbol index: %lu>"), idx
);
14870 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14872 print_vma (psym
->st_value
, LONG_HEX
);
14873 printf (" %-7s %3s ",
14874 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14875 get_symbol_index_type (psym
->st_shndx
));
14876 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14877 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14879 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14894 process_nds32_specific (FILE * file
)
14896 Elf_Internal_Shdr
*sect
= NULL
;
14898 sect
= find_section (".nds32_e_flags");
14901 unsigned int *flag
;
14903 printf ("\nNDS32 elf flags section:\n");
14904 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14905 sect
->sh_size
, _("NDS32 elf flags section"));
14907 switch ((*flag
) & 0x3)
14910 printf ("(VEC_SIZE):\tNo entry.\n");
14913 printf ("(VEC_SIZE):\t4 bytes\n");
14916 printf ("(VEC_SIZE):\t16 bytes\n");
14919 printf ("(VEC_SIZE):\treserved\n");
14928 process_gnu_liblist (FILE * file
)
14930 Elf_Internal_Shdr
* section
;
14931 Elf_Internal_Shdr
* string_sec
;
14932 Elf32_External_Lib
* elib
;
14934 size_t strtab_size
;
14941 for (i
= 0, section
= section_headers
;
14942 i
< elf_header
.e_shnum
;
14945 switch (section
->sh_type
)
14947 case SHT_GNU_LIBLIST
:
14948 if (section
->sh_link
>= elf_header
.e_shnum
)
14951 elib
= (Elf32_External_Lib
*)
14952 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14953 _("liblist section data"));
14957 string_sec
= section_headers
+ section
->sh_link
;
14959 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14960 string_sec
->sh_size
,
14961 _("liblist string table"));
14963 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14969 strtab_size
= string_sec
->sh_size
;
14971 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14972 printable_section_name (section
),
14973 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14975 puts (_(" Library Time Stamp Checksum Version Flags"));
14977 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14985 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14986 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14987 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14988 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14989 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14991 tmp
= gmtime (&atime
);
14992 snprintf (timebuf
, sizeof (timebuf
),
14993 "%04u-%02u-%02uT%02u:%02u:%02u",
14994 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14995 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14997 printf ("%3lu: ", (unsigned long) cnt
);
14999 printf ("%-20s", liblist
.l_name
< strtab_size
15000 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15002 printf ("%-20.20s", liblist
.l_name
< strtab_size
15003 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
15004 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
15005 liblist
.l_version
, liblist
.l_flags
);
15016 static const char *
15017 get_note_type (unsigned e_type
)
15019 static char buff
[64];
15021 if (elf_header
.e_type
== ET_CORE
)
15025 return _("NT_AUXV (auxiliary vector)");
15027 return _("NT_PRSTATUS (prstatus structure)");
15029 return _("NT_FPREGSET (floating point registers)");
15031 return _("NT_PRPSINFO (prpsinfo structure)");
15032 case NT_TASKSTRUCT
:
15033 return _("NT_TASKSTRUCT (task structure)");
15035 return _("NT_PRXFPREG (user_xfpregs structure)");
15037 return _("NT_PPC_VMX (ppc Altivec registers)");
15039 return _("NT_PPC_VSX (ppc VSX registers)");
15041 return _("NT_386_TLS (x86 TLS information)");
15042 case NT_386_IOPERM
:
15043 return _("NT_386_IOPERM (x86 I/O permissions)");
15044 case NT_X86_XSTATE
:
15045 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15046 case NT_S390_HIGH_GPRS
:
15047 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15048 case NT_S390_TIMER
:
15049 return _("NT_S390_TIMER (s390 timer register)");
15050 case NT_S390_TODCMP
:
15051 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15052 case NT_S390_TODPREG
:
15053 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15055 return _("NT_S390_CTRS (s390 control registers)");
15056 case NT_S390_PREFIX
:
15057 return _("NT_S390_PREFIX (s390 prefix register)");
15058 case NT_S390_LAST_BREAK
:
15059 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15060 case NT_S390_SYSTEM_CALL
:
15061 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15063 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15064 case NT_S390_VXRS_LOW
:
15065 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15066 case NT_S390_VXRS_HIGH
:
15067 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15069 return _("NT_ARM_VFP (arm VFP registers)");
15071 return _("NT_ARM_TLS (AArch TLS registers)");
15072 case NT_ARM_HW_BREAK
:
15073 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15074 case NT_ARM_HW_WATCH
:
15075 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15077 return _("NT_PSTATUS (pstatus structure)");
15079 return _("NT_FPREGS (floating point registers)");
15081 return _("NT_PSINFO (psinfo structure)");
15083 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15085 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15086 case NT_WIN32PSTATUS
:
15087 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15089 return _("NT_SIGINFO (siginfo_t data)");
15091 return _("NT_FILE (mapped files)");
15099 return _("NT_VERSION (version)");
15101 return _("NT_ARCH (architecture)");
15106 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15111 print_core_note (Elf_Internal_Note
*pnote
)
15113 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15114 bfd_vma count
, page_size
;
15115 unsigned char *descdata
, *filenames
, *descend
;
15117 if (pnote
->type
!= NT_FILE
)
15123 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15124 /* Still "successful". */
15129 if (pnote
->descsz
< 2 * addr_size
)
15131 printf (_(" Malformed note - too short for header\n"));
15135 descdata
= (unsigned char *) pnote
->descdata
;
15136 descend
= descdata
+ pnote
->descsz
;
15138 if (descdata
[pnote
->descsz
- 1] != '\0')
15140 printf (_(" Malformed note - does not end with \\0\n"));
15144 count
= byte_get (descdata
, addr_size
);
15145 descdata
+= addr_size
;
15147 page_size
= byte_get (descdata
, addr_size
);
15148 descdata
+= addr_size
;
15150 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15152 printf (_(" Malformed note - too short for supplied file count\n"));
15156 printf (_(" Page size: "));
15157 print_vma (page_size
, DEC
);
15160 printf (_(" %*s%*s%*s\n"),
15161 (int) (2 + 2 * addr_size
), _("Start"),
15162 (int) (4 + 2 * addr_size
), _("End"),
15163 (int) (4 + 2 * addr_size
), _("Page Offset"));
15164 filenames
= descdata
+ count
* 3 * addr_size
;
15165 while (count
-- > 0)
15167 bfd_vma start
, end
, file_ofs
;
15169 if (filenames
== descend
)
15171 printf (_(" Malformed note - filenames end too early\n"));
15175 start
= byte_get (descdata
, addr_size
);
15176 descdata
+= addr_size
;
15177 end
= byte_get (descdata
, addr_size
);
15178 descdata
+= addr_size
;
15179 file_ofs
= byte_get (descdata
, addr_size
);
15180 descdata
+= addr_size
;
15183 print_vma (start
, FULL_HEX
);
15185 print_vma (end
, FULL_HEX
);
15187 print_vma (file_ofs
, FULL_HEX
);
15188 printf ("\n %s\n", filenames
);
15190 filenames
+= 1 + strlen ((char *) filenames
);
15196 static const char *
15197 get_gnu_elf_note_type (unsigned e_type
)
15199 static char buff
[64];
15203 case NT_GNU_ABI_TAG
:
15204 return _("NT_GNU_ABI_TAG (ABI version tag)");
15206 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15207 case NT_GNU_BUILD_ID
:
15208 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15209 case NT_GNU_GOLD_VERSION
:
15210 return _("NT_GNU_GOLD_VERSION (gold version)");
15215 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15220 print_gnu_note (Elf_Internal_Note
*pnote
)
15222 switch (pnote
->type
)
15224 case NT_GNU_BUILD_ID
:
15228 printf (_(" Build ID: "));
15229 for (i
= 0; i
< pnote
->descsz
; ++i
)
15230 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15235 case NT_GNU_ABI_TAG
:
15237 unsigned long os
, major
, minor
, subminor
;
15238 const char *osname
;
15240 /* PR 17531: file: 030-599401-0.004. */
15241 if (pnote
->descsz
< 16)
15243 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15247 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15248 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15249 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15250 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15254 case GNU_ABI_TAG_LINUX
:
15257 case GNU_ABI_TAG_HURD
:
15260 case GNU_ABI_TAG_SOLARIS
:
15261 osname
= "Solaris";
15263 case GNU_ABI_TAG_FREEBSD
:
15264 osname
= "FreeBSD";
15266 case GNU_ABI_TAG_NETBSD
:
15269 case GNU_ABI_TAG_SYLLABLE
:
15270 osname
= "Syllable";
15272 case GNU_ABI_TAG_NACL
:
15276 osname
= "Unknown";
15280 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15281 major
, minor
, subminor
);
15285 case NT_GNU_GOLD_VERSION
:
15289 printf (_(" Version: "));
15290 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15291 printf ("%c", pnote
->descdata
[i
]);
15300 static const char *
15301 get_v850_elf_note_type (enum v850_notes n_type
)
15303 static char buff
[64];
15307 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15308 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15309 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15310 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15311 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15312 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15314 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15320 print_v850_note (Elf_Internal_Note
* pnote
)
15324 if (pnote
->descsz
!= 4)
15326 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15330 printf (_("not set\n"));
15334 switch (pnote
->type
)
15336 case V850_NOTE_ALIGNMENT
:
15339 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15340 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15344 case V850_NOTE_DATA_SIZE
:
15347 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15348 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15352 case V850_NOTE_FPU_INFO
:
15355 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15356 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15360 case V850_NOTE_MMU_INFO
:
15361 case V850_NOTE_CACHE_INFO
:
15362 case V850_NOTE_SIMD_INFO
:
15363 if (val
== EF_RH850_SIMD
)
15365 printf (_("yes\n"));
15371 /* An 'unknown note type' message will already have been displayed. */
15375 printf (_("unknown value: %x\n"), val
);
15380 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15382 unsigned int version
;
15384 switch (pnote
->type
)
15386 case NT_NETBSD_IDENT
:
15387 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15388 if ((version
/ 10000) % 100)
15389 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15390 version
, version
/ 100000000, (version
/ 1000000) % 100,
15391 (version
/ 10000) % 100 > 26 ? "Z" : "",
15392 'A' + (version
/ 10000) % 26);
15394 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15395 version
, version
/ 100000000, (version
/ 1000000) % 100,
15396 (version
/ 100) % 100);
15399 case NT_NETBSD_MARCH
:
15400 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15408 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15413 static const char *
15414 get_netbsd_elfcore_note_type (unsigned e_type
)
15416 static char buff
[64];
15418 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15420 /* NetBSD core "procinfo" structure. */
15421 return _("NetBSD procinfo structure");
15424 /* As of Jan 2002 there are no other machine-independent notes
15425 defined for NetBSD core files. If the note type is less
15426 than the start of the machine-dependent note types, we don't
15429 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15431 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15435 switch (elf_header
.e_machine
)
15437 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15438 and PT_GETFPREGS == mach+2. */
15443 case EM_SPARC32PLUS
:
15447 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15448 return _("PT_GETREGS (reg structure)");
15449 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15450 return _("PT_GETFPREGS (fpreg structure)");
15456 /* On all other arch's, PT_GETREGS == mach+1 and
15457 PT_GETFPREGS == mach+3. */
15461 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15462 return _("PT_GETREGS (reg structure)");
15463 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15464 return _("PT_GETFPREGS (fpreg structure)");
15470 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15471 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15475 static const char *
15476 get_stapsdt_note_type (unsigned e_type
)
15478 static char buff
[64];
15483 return _("NT_STAPSDT (SystemTap probe descriptors)");
15489 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15494 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15496 int addr_size
= is_32bit_elf
? 4 : 8;
15497 char *data
= pnote
->descdata
;
15498 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15499 bfd_vma pc
, base_addr
, semaphore
;
15500 char *provider
, *probe
, *arg_fmt
;
15502 pc
= byte_get ((unsigned char *) data
, addr_size
);
15504 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15506 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15510 data
+= strlen (data
) + 1;
15512 data
+= strlen (data
) + 1;
15514 data
+= strlen (data
) + 1;
15516 printf (_(" Provider: %s\n"), provider
);
15517 printf (_(" Name: %s\n"), probe
);
15518 printf (_(" Location: "));
15519 print_vma (pc
, FULL_HEX
);
15520 printf (_(", Base: "));
15521 print_vma (base_addr
, FULL_HEX
);
15522 printf (_(", Semaphore: "));
15523 print_vma (semaphore
, FULL_HEX
);
15525 printf (_(" Arguments: %s\n"), arg_fmt
);
15527 return data
== data_end
;
15530 static const char *
15531 get_ia64_vms_note_type (unsigned e_type
)
15533 static char buff
[64];
15538 return _("NT_VMS_MHD (module header)");
15540 return _("NT_VMS_LNM (language name)");
15542 return _("NT_VMS_SRC (source files)");
15544 return "NT_VMS_TITLE";
15546 return _("NT_VMS_EIDC (consistency check)");
15547 case NT_VMS_FPMODE
:
15548 return _("NT_VMS_FPMODE (FP mode)");
15549 case NT_VMS_LINKTIME
:
15550 return "NT_VMS_LINKTIME";
15551 case NT_VMS_IMGNAM
:
15552 return _("NT_VMS_IMGNAM (image name)");
15554 return _("NT_VMS_IMGID (image id)");
15555 case NT_VMS_LINKID
:
15556 return _("NT_VMS_LINKID (link id)");
15557 case NT_VMS_IMGBID
:
15558 return _("NT_VMS_IMGBID (build id)");
15559 case NT_VMS_GSTNAM
:
15560 return _("NT_VMS_GSTNAM (sym table name)");
15561 case NT_VMS_ORIG_DYN
:
15562 return "NT_VMS_ORIG_DYN";
15563 case NT_VMS_PATCHTIME
:
15564 return "NT_VMS_PATCHTIME";
15566 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15572 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15574 switch (pnote
->type
)
15577 if (pnote
->descsz
> 36)
15579 size_t l
= strlen (pnote
->descdata
+ 34);
15580 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15581 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15582 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15583 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15586 printf (_(" Invalid size\n"));
15589 printf (_(" Language: %s\n"), pnote
->descdata
);
15592 case NT_VMS_FPMODE
:
15593 printf (_(" Floating Point mode: "));
15594 printf ("0x%016" BFD_VMA_FMT
"x\n",
15595 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15597 case NT_VMS_LINKTIME
:
15598 printf (_(" Link time: "));
15600 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15603 case NT_VMS_PATCHTIME
:
15604 printf (_(" Patch time: "));
15606 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15609 case NT_VMS_ORIG_DYN
:
15610 printf (_(" Major id: %u, minor id: %u\n"),
15611 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15612 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15613 printf (_(" Last modified : "));
15615 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15616 printf (_("\n Link flags : "));
15617 printf ("0x%016" BFD_VMA_FMT
"x\n",
15618 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15619 printf (_(" Header flags: 0x%08x\n"),
15620 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15621 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15624 case NT_VMS_IMGNAM
:
15625 printf (_(" Image name: %s\n"), pnote
->descdata
);
15627 case NT_VMS_GSTNAM
:
15628 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15631 printf (_(" Image id: %s\n"), pnote
->descdata
);
15633 case NT_VMS_LINKID
:
15634 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15642 /* Note that by the ELF standard, the name field is already null byte
15643 terminated, and namesz includes the terminating null byte.
15644 I.E. the value of namesz for the name "FSF" is 4.
15646 If the value of namesz is zero, there is no name present. */
15648 process_note (Elf_Internal_Note
* pnote
)
15650 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15653 if (pnote
->namesz
== 0)
15654 /* If there is no note name, then use the default set of
15655 note type strings. */
15656 nt
= get_note_type (pnote
->type
);
15658 else if (const_strneq (pnote
->namedata
, "GNU"))
15659 /* GNU-specific object file notes. */
15660 nt
= get_gnu_elf_note_type (pnote
->type
);
15662 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15663 /* NetBSD-specific core file notes. */
15664 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15666 else if (const_strneq (pnote
->namedata
, "NetBSD"))
15667 /* NetBSD-specific core file notes. */
15668 return process_netbsd_elf_note (pnote
);
15670 else if (strneq (pnote
->namedata
, "SPU/", 4))
15672 /* SPU-specific core file notes. */
15673 nt
= pnote
->namedata
+ 4;
15677 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15678 /* VMS/ia64-specific file notes. */
15679 nt
= get_ia64_vms_note_type (pnote
->type
);
15681 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15682 nt
= get_stapsdt_note_type (pnote
->type
);
15685 /* Don't recognize this note name; just use the default set of
15686 note type strings. */
15687 nt
= get_note_type (pnote
->type
);
15689 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15691 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15692 return print_ia64_vms_note (pnote
);
15693 else if (const_strneq (pnote
->namedata
, "GNU"))
15694 return print_gnu_note (pnote
);
15695 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15696 return print_stapsdt_note (pnote
);
15697 else if (const_strneq (pnote
->namedata
, "CORE"))
15698 return print_core_note (pnote
);
15705 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15707 Elf_External_Note
* pnotes
;
15708 Elf_External_Note
* external
;
15715 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15717 if (pnotes
== NULL
)
15722 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15723 (unsigned long) offset
, (unsigned long) length
);
15724 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15726 end
= (char *) pnotes
+ length
;
15727 while ((char *) external
< end
)
15729 Elf_Internal_Note inote
;
15732 char * temp
= NULL
;
15733 size_t data_remaining
= end
- (char *) external
;
15735 if (!is_ia64_vms ())
15737 /* PR binutils/15191
15738 Make sure that there is enough data to read. */
15739 min_notesz
= offsetof (Elf_External_Note
, name
);
15740 if (data_remaining
< min_notesz
)
15742 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15743 (int) data_remaining
);
15746 inote
.type
= BYTE_GET (external
->type
);
15747 inote
.namesz
= BYTE_GET (external
->namesz
);
15748 inote
.namedata
= external
->name
;
15749 inote
.descsz
= BYTE_GET (external
->descsz
);
15750 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15751 /* PR 17531: file: 3443835e. */
15752 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15754 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15755 inote
.descdata
= inote
.namedata
;
15759 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15760 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15764 Elf64_External_VMS_Note
*vms_external
;
15766 /* PR binutils/15191
15767 Make sure that there is enough data to read. */
15768 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15769 if (data_remaining
< min_notesz
)
15771 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15772 (int) data_remaining
);
15776 vms_external
= (Elf64_External_VMS_Note
*) external
;
15777 inote
.type
= BYTE_GET (vms_external
->type
);
15778 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15779 inote
.namedata
= vms_external
->name
;
15780 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15781 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15782 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15783 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15786 if (inote
.descdata
< (char *) external
+ min_notesz
15787 || next
< (char *) external
+ min_notesz
15788 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15789 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15790 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15791 || data_remaining
< (size_t)(next
- (char *) external
))
15793 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15794 (unsigned long) ((char *) external
- (char *) pnotes
));
15795 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15796 inote
.type
, inote
.namesz
, inote
.descsz
);
15800 external
= (Elf_External_Note
*) next
;
15802 /* Verify that name is null terminated. It appears that at least
15803 one version of Linux (RedHat 6.0) generates corefiles that don't
15804 comply with the ELF spec by failing to include the null byte in
15806 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15808 temp
= (char *) malloc (inote
.namesz
+ 1);
15811 error (_("Out of memory allocating space for inote name\n"));
15816 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15817 temp
[inote
.namesz
] = 0;
15819 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15820 inote
.namedata
= temp
;
15823 res
&= process_note (& inote
);
15838 process_corefile_note_segments (FILE * file
)
15840 Elf_Internal_Phdr
* segment
;
15844 if (! get_program_headers (file
))
15847 for (i
= 0, segment
= program_headers
;
15848 i
< elf_header
.e_phnum
;
15851 if (segment
->p_type
== PT_NOTE
)
15852 res
&= process_corefile_note_segment (file
,
15853 (bfd_vma
) segment
->p_offset
,
15854 (bfd_vma
) segment
->p_filesz
);
15861 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
15863 Elf_External_Note
* pnotes
;
15864 Elf_External_Note
* external
;
15871 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15873 if (pnotes
== NULL
)
15877 end
= (char*) pnotes
+ length
;
15879 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15880 (unsigned long) offset
, (unsigned long) length
);
15882 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
15884 Elf_External_Note
* next
;
15885 Elf_Internal_Note inote
;
15887 inote
.type
= BYTE_GET (external
->type
);
15888 inote
.namesz
= BYTE_GET (external
->namesz
);
15889 inote
.namedata
= external
->name
;
15890 inote
.descsz
= BYTE_GET (external
->descsz
);
15891 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15892 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15894 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
15896 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15897 inote
.descdata
= inote
.namedata
;
15901 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
15903 if ( ((char *) next
> end
)
15904 || ((char *) next
< (char *) pnotes
))
15906 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15907 (unsigned long) ((char *) external
- (char *) pnotes
));
15908 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15909 inote
.type
, inote
.namesz
, inote
.descsz
);
15915 /* Prevent out-of-bounds indexing. */
15916 if ( inote
.namedata
+ inote
.namesz
> end
15917 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
15919 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15920 (unsigned long) ((char *) external
- (char *) pnotes
));
15921 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15922 inote
.type
, inote
.namesz
, inote
.descsz
);
15926 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
15928 if (! print_v850_note (& inote
))
15931 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15932 inote
.namesz
, inote
.descsz
);
15942 process_note_sections (FILE * file
)
15944 Elf_Internal_Shdr
* section
;
15949 for (i
= 0, section
= section_headers
;
15950 i
< elf_header
.e_shnum
&& section
!= NULL
;
15953 if (section
->sh_type
== SHT_NOTE
)
15955 res
&= process_corefile_note_segment (file
,
15956 (bfd_vma
) section
->sh_offset
,
15957 (bfd_vma
) section
->sh_size
);
15961 if (( elf_header
.e_machine
== EM_V800
15962 || elf_header
.e_machine
== EM_V850
15963 || elf_header
.e_machine
== EM_CYGNUS_V850
)
15964 && section
->sh_type
== SHT_RENESAS_INFO
)
15966 res
&= process_v850_notes (file
,
15967 (bfd_vma
) section
->sh_offset
,
15968 (bfd_vma
) section
->sh_size
);
15974 /* Try processing NOTE segments instead. */
15975 return process_corefile_note_segments (file
);
15981 process_notes (FILE * file
)
15983 /* If we have not been asked to display the notes then do nothing. */
15987 if (elf_header
.e_type
!= ET_CORE
)
15988 return process_note_sections (file
);
15990 /* No program headers means no NOTE segment. */
15991 if (elf_header
.e_phnum
> 0)
15992 return process_corefile_note_segments (file
);
15994 printf (_("No note segments present in the core file.\n"));
15999 process_arch_specific (FILE * file
)
16004 switch (elf_header
.e_machine
)
16007 return process_arm_specific (file
);
16009 case EM_MIPS_RS3_LE
:
16010 return process_mips_specific (file
);
16013 return process_nds32_specific (file
);
16016 return process_power_specific (file
);
16020 return process_s390_specific (file
);
16023 case EM_SPARC32PLUS
:
16025 return process_sparc_specific (file
);
16028 return process_tic6x_specific (file
);
16031 return process_msp430x_specific (file
);
16039 get_file_header (FILE * file
)
16041 /* Read in the identity array. */
16042 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16045 /* Determine how to read the rest of the header. */
16046 switch (elf_header
.e_ident
[EI_DATA
])
16048 default: /* fall through */
16049 case ELFDATANONE
: /* fall through */
16051 byte_get
= byte_get_little_endian
;
16052 byte_put
= byte_put_little_endian
;
16055 byte_get
= byte_get_big_endian
;
16056 byte_put
= byte_put_big_endian
;
16060 /* For now we only support 32 bit and 64 bit ELF files. */
16061 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16063 /* Read in the rest of the header. */
16066 Elf32_External_Ehdr ehdr32
;
16068 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16071 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16072 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16073 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16074 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16075 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16076 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16077 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16078 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16079 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16080 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16081 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16082 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16083 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16087 Elf64_External_Ehdr ehdr64
;
16089 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16090 we will not be able to cope with the 64bit data found in
16091 64 ELF files. Detect this now and abort before we start
16092 overwriting things. */
16093 if (sizeof (bfd_vma
) < 8)
16095 error (_("This instance of readelf has been built without support for a\n\
16096 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16100 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16103 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16104 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16105 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16106 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16107 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16108 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16109 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16110 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16111 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16112 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16113 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16114 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16115 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16118 if (elf_header
.e_shoff
)
16120 /* There may be some extensions in the first section header. Don't
16121 bomb if we can't read it. */
16123 get_32bit_section_headers (file
, TRUE
);
16125 get_64bit_section_headers (file
, TRUE
);
16131 /* Process one ELF object file according to the command line options.
16132 This file may actually be stored in an archive. The file is
16133 positioned at the start of the ELF object. */
16136 process_object (char * file_name
, FILE * file
)
16140 if (! get_file_header (file
))
16142 error (_("%s: Failed to read file header\n"), file_name
);
16146 /* Initialise per file variables. */
16147 for (i
= ARRAY_SIZE (version_info
); i
--;)
16148 version_info
[i
] = 0;
16150 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16151 dynamic_info
[i
] = 0;
16152 dynamic_info_DT_GNU_HASH
= 0;
16154 /* Process the file. */
16156 printf (_("\nFile: %s\n"), file_name
);
16158 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16159 Note we do this even if cmdline_dump_sects is empty because we
16160 must make sure that the dump_sets array is zeroed out before each
16161 object file is processed. */
16162 if (num_dump_sects
> num_cmdline_dump_sects
)
16163 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16165 if (num_cmdline_dump_sects
> 0)
16167 if (num_dump_sects
== 0)
16168 /* A sneaky way of allocating the dump_sects array. */
16169 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16171 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16172 memcpy (dump_sects
, cmdline_dump_sects
,
16173 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16176 if (! process_file_header ())
16179 if (! process_section_headers (file
))
16181 /* Without loaded section headers we cannot process lots of
16183 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16185 if (! do_using_dynamic
)
16186 do_syms
= do_dyn_syms
= do_reloc
= 0;
16189 if (! process_section_groups (file
))
16191 /* Without loaded section groups we cannot process unwind. */
16195 if (process_program_headers (file
))
16196 process_dynamic_section (file
);
16198 process_relocs (file
);
16200 process_unwind (file
);
16202 process_symbol_table (file
);
16204 process_syminfo (file
);
16206 process_version_sections (file
);
16208 process_section_contents (file
);
16210 process_notes (file
);
16212 process_gnu_liblist (file
);
16214 process_arch_specific (file
);
16216 if (program_headers
)
16218 free (program_headers
);
16219 program_headers
= NULL
;
16222 if (section_headers
)
16224 free (section_headers
);
16225 section_headers
= NULL
;
16230 free (string_table
);
16231 string_table
= NULL
;
16232 string_table_length
= 0;
16235 if (dynamic_strings
)
16237 free (dynamic_strings
);
16238 dynamic_strings
= NULL
;
16239 dynamic_strings_length
= 0;
16242 if (dynamic_symbols
)
16244 free (dynamic_symbols
);
16245 dynamic_symbols
= NULL
;
16246 num_dynamic_syms
= 0;
16249 if (dynamic_syminfo
)
16251 free (dynamic_syminfo
);
16252 dynamic_syminfo
= NULL
;
16255 if (dynamic_section
)
16257 free (dynamic_section
);
16258 dynamic_section
= NULL
;
16261 if (section_headers_groups
)
16263 free (section_headers_groups
);
16264 section_headers_groups
= NULL
;
16267 if (section_groups
)
16269 struct group_list
* g
;
16270 struct group_list
* next
;
16272 for (i
= 0; i
< group_count
; i
++)
16274 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16281 free (section_groups
);
16282 section_groups
= NULL
;
16285 free_debug_memory ();
16290 /* Process an ELF archive.
16291 On entry the file is positioned just after the ARMAG string. */
16294 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16296 struct archive_info arch
;
16297 struct archive_info nested_arch
;
16303 /* The ARCH structure is used to hold information about this archive. */
16304 arch
.file_name
= NULL
;
16306 arch
.index_array
= NULL
;
16307 arch
.sym_table
= NULL
;
16308 arch
.longnames
= NULL
;
16310 /* The NESTED_ARCH structure is used as a single-item cache of information
16311 about a nested archive (when members of a thin archive reside within
16312 another regular archive file). */
16313 nested_arch
.file_name
= NULL
;
16314 nested_arch
.file
= NULL
;
16315 nested_arch
.index_array
= NULL
;
16316 nested_arch
.sym_table
= NULL
;
16317 nested_arch
.longnames
= NULL
;
16319 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16325 if (do_archive_index
)
16327 if (arch
.sym_table
== NULL
)
16328 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16331 unsigned long i
, l
;
16332 unsigned long current_pos
;
16334 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16335 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16336 current_pos
= ftell (file
);
16338 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16340 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16342 char * member_name
;
16344 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16346 if (member_name
!= NULL
)
16348 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16350 if (qualified_name
!= NULL
)
16352 printf (_("Contents of binary %s at offset "), qualified_name
);
16353 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16355 free (qualified_name
);
16360 if (l
>= arch
.sym_size
)
16362 error (_("%s: end of the symbol table reached before the end of the index\n"),
16366 /* PR 17531: file: 0b6630b2. */
16367 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16368 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16371 if (arch
.uses_64bit_indicies
)
16376 if (l
< arch
.sym_size
)
16377 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16378 file_name
, arch
.sym_size
- l
);
16380 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16382 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16388 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16389 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16390 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16391 && !do_section_groups
&& !do_dyn_syms
)
16393 ret
= 0; /* Archive index only. */
16404 char * qualified_name
;
16406 /* Read the next archive header. */
16407 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16409 error (_("%s: failed to seek to next archive header\n"), file_name
);
16412 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16413 if (got
!= sizeof arch
.arhdr
)
16417 error (_("%s: failed to read archive header\n"), file_name
);
16421 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16423 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16428 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16430 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16431 if (archive_file_size
& 01)
16432 ++archive_file_size
;
16434 name
= get_archive_member_name (&arch
, &nested_arch
);
16437 error (_("%s: bad archive file name\n"), file_name
);
16441 namelen
= strlen (name
);
16443 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16444 if (qualified_name
== NULL
)
16446 error (_("%s: bad archive file name\n"), file_name
);
16451 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16453 /* This is a proxy for an external member of a thin archive. */
16454 FILE * member_file
;
16455 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16456 if (member_file_name
== NULL
)
16462 member_file
= fopen (member_file_name
, "rb");
16463 if (member_file
== NULL
)
16465 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16466 free (member_file_name
);
16471 archive_file_offset
= arch
.nested_member_origin
;
16473 ret
|= process_object (qualified_name
, member_file
);
16475 fclose (member_file
);
16476 free (member_file_name
);
16478 else if (is_thin_archive
)
16480 /* PR 15140: Allow for corrupt thin archives. */
16481 if (nested_arch
.file
== NULL
)
16483 error (_("%s: contains corrupt thin archive: %s\n"),
16489 /* This is a proxy for a member of a nested archive. */
16490 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16492 /* The nested archive file will have been opened and setup by
16493 get_archive_member_name. */
16494 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16496 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16501 ret
|= process_object (qualified_name
, nested_arch
.file
);
16505 archive_file_offset
= arch
.next_arhdr_offset
;
16506 arch
.next_arhdr_offset
+= archive_file_size
;
16508 ret
|= process_object (qualified_name
, file
);
16511 if (dump_sects
!= NULL
)
16515 num_dump_sects
= 0;
16518 free (qualified_name
);
16522 if (nested_arch
.file
!= NULL
)
16523 fclose (nested_arch
.file
);
16524 release_archive (&nested_arch
);
16525 release_archive (&arch
);
16531 process_file (char * file_name
)
16534 struct stat statbuf
;
16535 char armag
[SARMAG
];
16538 if (stat (file_name
, &statbuf
) < 0)
16540 if (errno
== ENOENT
)
16541 error (_("'%s': No such file\n"), file_name
);
16543 error (_("Could not locate '%s'. System error message: %s\n"),
16544 file_name
, strerror (errno
));
16548 if (! S_ISREG (statbuf
.st_mode
))
16550 error (_("'%s' is not an ordinary file\n"), file_name
);
16554 file
= fopen (file_name
, "rb");
16557 error (_("Input file '%s' is not readable.\n"), file_name
);
16561 if (fread (armag
, SARMAG
, 1, file
) != 1)
16563 error (_("%s: Failed to read file's magic number\n"), file_name
);
16568 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16570 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16571 ret
= process_archive (file_name
, file
, FALSE
);
16572 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16573 ret
= process_archive (file_name
, file
, TRUE
);
16576 if (do_archive_index
)
16577 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16581 archive_file_size
= archive_file_offset
= 0;
16582 ret
= process_object (file_name
, file
);
16587 current_file_size
= 0;
16591 #ifdef SUPPORT_DISASSEMBLY
16592 /* Needed by the i386 disassembler. For extra credit, someone could
16593 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16597 print_address (unsigned int addr
, FILE * outfile
)
16599 fprintf (outfile
,"0x%8.8x", addr
);
16602 /* Needed by the i386 disassembler. */
16604 db_task_printsym (unsigned int addr
)
16606 print_address (addr
, stderr
);
16611 main (int argc
, char ** argv
)
16615 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16616 setlocale (LC_MESSAGES
, "");
16618 #if defined (HAVE_SETLOCALE)
16619 setlocale (LC_CTYPE
, "");
16621 bindtextdomain (PACKAGE
, LOCALEDIR
);
16622 textdomain (PACKAGE
);
16624 expandargv (&argc
, &argv
);
16626 parse_args (argc
, argv
);
16628 if (num_dump_sects
> 0)
16630 /* Make a copy of the dump_sects array. */
16631 cmdline_dump_sects
= (dump_type
*)
16632 malloc (num_dump_sects
* sizeof (* dump_sects
));
16633 if (cmdline_dump_sects
== NULL
)
16634 error (_("Out of memory allocating dump request table.\n"));
16637 memcpy (cmdline_dump_sects
, dump_sects
,
16638 num_dump_sects
* sizeof (* dump_sects
));
16639 num_cmdline_dump_sects
= num_dump_sects
;
16643 if (optind
< (argc
- 1))
16645 else if (optind
>= argc
)
16647 warn (_("Nothing to do.\n"));
16652 while (optind
< argc
)
16653 err
|= process_file (argv
[optind
++]);
16655 if (dump_sects
!= NULL
)
16657 if (cmdline_dump_sects
!= NULL
)
16658 free (cmdline_dump_sects
);