1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2015 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");
2780 strcat (buf
, ", unrecognized flag for ARCv2");
2783 switch (e_flags
& EF_ARC_OSABI_MSK
)
2785 /* Only upstream 3.9+ kernels will support ARCv2
2787 case E_ARC_OSABI_V3
:
2788 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2793 case EM_ARC_COMPACT
:
2794 switch (e_flags
& EF_ARC_MACH_MSK
)
2796 case E_ARC_MACH_ARC600
:
2797 strcat (buf
, ", ARC 600");
2799 case E_ARC_MACH_ARC601
:
2800 strcat (buf
, ", ARC 601");
2802 case E_ARC_MACH_ARC700
:
2803 strcat (buf
, ", ARC 700");
2806 strcat (buf
, ", Generic ARCompact");
2809 switch (e_flags
& EF_ARC_OSABI_MSK
)
2811 case E_ARC_OSABI_ORIG
:
2812 strcat (buf
, ", legacy syscall ABI");
2814 case E_ARC_OSABI_V2
:
2815 /* For 3.2+ Linux kernels which use asm-generic
2817 strcat (buf
, ", v2 syscall ABI");
2819 case E_ARC_OSABI_V3
:
2820 /* Upstream 3.9+ kernels which don't use any legacy
2822 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2828 decode_ARM_machine_flags (e_flags
, buf
);
2832 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
2836 if (e_flags
& EF_BFIN_PIC
)
2837 strcat (buf
, ", PIC");
2839 if (e_flags
& EF_BFIN_FDPIC
)
2840 strcat (buf
, ", FDPIC");
2842 if (e_flags
& EF_BFIN_CODE_IN_L1
)
2843 strcat (buf
, ", code in L1");
2845 if (e_flags
& EF_BFIN_DATA_IN_L1
)
2846 strcat (buf
, ", data in L1");
2851 switch (e_flags
& EF_FRV_CPU_MASK
)
2853 case EF_FRV_CPU_GENERIC
:
2857 strcat (buf
, ", fr???");
2860 case EF_FRV_CPU_FR300
:
2861 strcat (buf
, ", fr300");
2864 case EF_FRV_CPU_FR400
:
2865 strcat (buf
, ", fr400");
2867 case EF_FRV_CPU_FR405
:
2868 strcat (buf
, ", fr405");
2871 case EF_FRV_CPU_FR450
:
2872 strcat (buf
, ", fr450");
2875 case EF_FRV_CPU_FR500
:
2876 strcat (buf
, ", fr500");
2878 case EF_FRV_CPU_FR550
:
2879 strcat (buf
, ", fr550");
2882 case EF_FRV_CPU_SIMPLE
:
2883 strcat (buf
, ", simple");
2885 case EF_FRV_CPU_TOMCAT
:
2886 strcat (buf
, ", tomcat");
2892 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
2893 strcat (buf
, ", m68000");
2894 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
2895 strcat (buf
, ", cpu32");
2896 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
2897 strcat (buf
, ", fido_a");
2900 char const * isa
= _("unknown");
2901 char const * mac
= _("unknown mac");
2902 char const * additional
= NULL
;
2904 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
2906 case EF_M68K_CF_ISA_A_NODIV
:
2908 additional
= ", nodiv";
2910 case EF_M68K_CF_ISA_A
:
2913 case EF_M68K_CF_ISA_A_PLUS
:
2916 case EF_M68K_CF_ISA_B_NOUSP
:
2918 additional
= ", nousp";
2920 case EF_M68K_CF_ISA_B
:
2923 case EF_M68K_CF_ISA_C
:
2926 case EF_M68K_CF_ISA_C_NODIV
:
2928 additional
= ", nodiv";
2931 strcat (buf
, ", cf, isa ");
2934 strcat (buf
, additional
);
2935 if (e_flags
& EF_M68K_CF_FLOAT
)
2936 strcat (buf
, ", float");
2937 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
2942 case EF_M68K_CF_MAC
:
2945 case EF_M68K_CF_EMAC
:
2948 case EF_M68K_CF_EMAC_B
:
2961 switch (e_flags
& EF_MEP_CPU_MASK
)
2963 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
2964 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
2965 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
2966 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
2967 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
2968 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
2969 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
2972 switch (e_flags
& EF_MEP_COP_MASK
)
2974 case EF_MEP_COP_NONE
: break;
2975 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
2976 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
2977 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
2978 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
2979 default: strcat (buf
, _("<unknown MeP copro type>")); break;
2982 if (e_flags
& EF_MEP_LIBRARY
)
2983 strcat (buf
, ", Built for Library");
2985 if (e_flags
& EF_MEP_INDEX_MASK
)
2986 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
2987 e_flags
& EF_MEP_INDEX_MASK
);
2989 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
2990 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
2991 e_flags
& ~ EF_MEP_ALL_FLAGS
);
2995 if (e_flags
& EF_PPC_EMB
)
2996 strcat (buf
, ", emb");
2998 if (e_flags
& EF_PPC_RELOCATABLE
)
2999 strcat (buf
, _(", relocatable"));
3001 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3002 strcat (buf
, _(", relocatable-lib"));
3006 if (e_flags
& EF_PPC64_ABI
)
3008 char abi
[] = ", abiv0";
3010 abi
[6] += e_flags
& EF_PPC64_ABI
;
3016 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3017 strcat (buf
, ", RH850 ABI");
3019 if (e_flags
& EF_V800_850E3
)
3020 strcat (buf
, ", V3 architecture");
3022 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3023 strcat (buf
, ", FPU not used");
3025 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3026 strcat (buf
, ", regmode: COMMON");
3028 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3029 strcat (buf
, ", r4 not used");
3031 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3032 strcat (buf
, ", r30 not used");
3034 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3035 strcat (buf
, ", r5 not used");
3037 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3038 strcat (buf
, ", r2 not used");
3040 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3042 switch (e_flags
& - e_flags
)
3044 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3045 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3046 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3047 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3048 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3049 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3050 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3051 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3052 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3053 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3054 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3055 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3062 case EM_CYGNUS_V850
:
3063 switch (e_flags
& EF_V850_ARCH
)
3065 case E_V850E3V5_ARCH
:
3066 strcat (buf
, ", v850e3v5");
3068 case E_V850E2V3_ARCH
:
3069 strcat (buf
, ", v850e2v3");
3072 strcat (buf
, ", v850e2");
3075 strcat (buf
, ", v850e1");
3078 strcat (buf
, ", v850e");
3081 strcat (buf
, ", v850");
3084 strcat (buf
, _(", unknown v850 architecture variant"));
3090 case EM_CYGNUS_M32R
:
3091 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3092 strcat (buf
, ", m32r");
3096 case EM_MIPS_RS3_LE
:
3097 if (e_flags
& EF_MIPS_NOREORDER
)
3098 strcat (buf
, ", noreorder");
3100 if (e_flags
& EF_MIPS_PIC
)
3101 strcat (buf
, ", pic");
3103 if (e_flags
& EF_MIPS_CPIC
)
3104 strcat (buf
, ", cpic");
3106 if (e_flags
& EF_MIPS_UCODE
)
3107 strcat (buf
, ", ugen_reserved");
3109 if (e_flags
& EF_MIPS_ABI2
)
3110 strcat (buf
, ", abi2");
3112 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3113 strcat (buf
, ", odk first");
3115 if (e_flags
& EF_MIPS_32BITMODE
)
3116 strcat (buf
, ", 32bitmode");
3118 if (e_flags
& EF_MIPS_NAN2008
)
3119 strcat (buf
, ", nan2008");
3121 if (e_flags
& EF_MIPS_FP64
)
3122 strcat (buf
, ", fp64");
3124 switch ((e_flags
& EF_MIPS_MACH
))
3126 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3127 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3128 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3129 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3130 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3131 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3132 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3133 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3134 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3135 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3136 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3137 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3138 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3139 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3140 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3141 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3142 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3144 /* We simply ignore the field in this case to avoid confusion:
3145 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3148 default: strcat (buf
, _(", unknown CPU")); break;
3151 switch ((e_flags
& EF_MIPS_ABI
))
3153 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3154 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3155 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3156 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3158 /* We simply ignore the field in this case to avoid confusion:
3159 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3160 This means it is likely to be an o32 file, but not for
3163 default: strcat (buf
, _(", unknown ABI")); break;
3166 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3167 strcat (buf
, ", mdmx");
3169 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3170 strcat (buf
, ", mips16");
3172 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3173 strcat (buf
, ", micromips");
3175 switch ((e_flags
& EF_MIPS_ARCH
))
3177 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3178 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3179 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3180 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3181 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3182 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3183 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3184 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3185 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3186 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3187 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3188 default: strcat (buf
, _(", unknown ISA")); break;
3193 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3197 switch ((e_flags
& EF_SH_MACH_MASK
))
3199 case EF_SH1
: strcat (buf
, ", sh1"); break;
3200 case EF_SH2
: strcat (buf
, ", sh2"); break;
3201 case EF_SH3
: strcat (buf
, ", sh3"); break;
3202 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3203 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3204 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3205 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3206 case EF_SH4
: strcat (buf
, ", sh4"); break;
3207 case EF_SH5
: strcat (buf
, ", sh5"); break;
3208 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3209 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3210 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3211 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3212 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3213 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3214 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3215 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3216 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3217 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3218 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3219 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3220 default: strcat (buf
, _(", unknown ISA")); break;
3223 if (e_flags
& EF_SH_PIC
)
3224 strcat (buf
, ", pic");
3226 if (e_flags
& EF_SH_FDPIC
)
3227 strcat (buf
, ", fdpic");
3231 if (e_flags
& EF_OR1K_NODELAY
)
3232 strcat (buf
, ", no delay");
3236 if (e_flags
& EF_SPARC_32PLUS
)
3237 strcat (buf
, ", v8+");
3239 if (e_flags
& EF_SPARC_SUN_US1
)
3240 strcat (buf
, ", ultrasparcI");
3242 if (e_flags
& EF_SPARC_SUN_US3
)
3243 strcat (buf
, ", ultrasparcIII");
3245 if (e_flags
& EF_SPARC_HAL_R1
)
3246 strcat (buf
, ", halr1");
3248 if (e_flags
& EF_SPARC_LEDATA
)
3249 strcat (buf
, ", ledata");
3251 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3252 strcat (buf
, ", tso");
3254 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3255 strcat (buf
, ", pso");
3257 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3258 strcat (buf
, ", rmo");
3262 switch (e_flags
& EF_PARISC_ARCH
)
3264 case EFA_PARISC_1_0
:
3265 strcpy (buf
, ", PA-RISC 1.0");
3267 case EFA_PARISC_1_1
:
3268 strcpy (buf
, ", PA-RISC 1.1");
3270 case EFA_PARISC_2_0
:
3271 strcpy (buf
, ", PA-RISC 2.0");
3276 if (e_flags
& EF_PARISC_TRAPNIL
)
3277 strcat (buf
, ", trapnil");
3278 if (e_flags
& EF_PARISC_EXT
)
3279 strcat (buf
, ", ext");
3280 if (e_flags
& EF_PARISC_LSB
)
3281 strcat (buf
, ", lsb");
3282 if (e_flags
& EF_PARISC_WIDE
)
3283 strcat (buf
, ", wide");
3284 if (e_flags
& EF_PARISC_NO_KABP
)
3285 strcat (buf
, ", no kabp");
3286 if (e_flags
& EF_PARISC_LAZYSWAP
)
3287 strcat (buf
, ", lazyswap");
3292 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3293 strcat (buf
, ", new calling convention");
3295 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3296 strcat (buf
, ", gnu calling convention");
3300 if ((e_flags
& EF_IA_64_ABI64
))
3301 strcat (buf
, ", 64-bit");
3303 strcat (buf
, ", 32-bit");
3304 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3305 strcat (buf
, ", reduced fp model");
3306 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3307 strcat (buf
, ", no function descriptors, constant gp");
3308 else if ((e_flags
& EF_IA_64_CONS_GP
))
3309 strcat (buf
, ", constant gp");
3310 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3311 strcat (buf
, ", absolute");
3312 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3314 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3315 strcat (buf
, ", vms_linkages");
3316 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3318 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3320 case EF_IA_64_VMS_COMCOD_WARNING
:
3321 strcat (buf
, ", warning");
3323 case EF_IA_64_VMS_COMCOD_ERROR
:
3324 strcat (buf
, ", error");
3326 case EF_IA_64_VMS_COMCOD_ABORT
:
3327 strcat (buf
, ", abort");
3330 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3331 e_flags
& EF_IA_64_VMS_COMCOD
);
3332 strcat (buf
, ", <unknown>");
3338 if ((e_flags
& EF_VAX_NONPIC
))
3339 strcat (buf
, ", non-PIC");
3340 if ((e_flags
& EF_VAX_DFLOAT
))
3341 strcat (buf
, ", D-Float");
3342 if ((e_flags
& EF_VAX_GFLOAT
))
3343 strcat (buf
, ", G-Float");
3347 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3348 strcat (buf
, ", mcm");
3349 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3350 strcat (buf
, ", mcm24");
3351 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3352 strcat (buf
, ", gr6");
3356 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3358 case E_FLAG_RL78_ANY_CPU
: break;
3359 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3360 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3361 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3363 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3364 strcat (buf
, ", 64-bit doubles");
3368 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3369 strcat (buf
, ", 64-bit doubles");
3370 if (e_flags
& E_FLAG_RX_DSP
)
3371 strcat (buf
, ", dsp");
3372 if (e_flags
& E_FLAG_RX_PID
)
3373 strcat (buf
, ", pid");
3374 if (e_flags
& E_FLAG_RX_ABI
)
3375 strcat (buf
, ", RX ABI");
3376 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3377 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3378 ? ", uses String instructions" : ", bans String instructions");
3382 if (e_flags
& EF_S390_HIGH_GPRS
)
3383 strcat (buf
, ", highgprs");
3387 if ((e_flags
& EF_C6000_REL
))
3388 strcat (buf
, ", relocatable module");
3392 strcat (buf
, _(": architecture variant: "));
3393 switch (e_flags
& EF_MSP430_MACH
)
3395 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3396 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3397 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3398 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3399 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3400 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3401 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3402 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3403 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3404 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3405 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3406 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3407 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3408 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3409 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3411 strcat (buf
, _(": unknown")); break;
3414 if (e_flags
& ~ EF_MSP430_MACH
)
3415 strcat (buf
, _(": unknown extra flag bits also present"));
3423 get_osabi_name (unsigned int osabi
)
3425 static char buff
[32];
3429 case ELFOSABI_NONE
: return "UNIX - System V";
3430 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3431 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3432 case ELFOSABI_GNU
: return "UNIX - GNU";
3433 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3434 case ELFOSABI_AIX
: return "UNIX - AIX";
3435 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3436 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3437 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3438 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3439 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3440 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3441 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3442 case ELFOSABI_AROS
: return "AROS";
3443 case ELFOSABI_FENIXOS
: return "FenixOS";
3446 switch (elf_header
.e_machine
)
3451 case ELFOSABI_ARM
: return "ARM";
3462 case ELFOSABI_STANDALONE
: return _("Standalone App");
3471 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3472 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3481 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3487 get_aarch64_segment_type (unsigned long type
)
3491 case PT_AARCH64_ARCHEXT
:
3492 return "AARCH64_ARCHEXT";
3501 get_arm_segment_type (unsigned long type
)
3515 get_mips_segment_type (unsigned long type
)
3519 case PT_MIPS_REGINFO
:
3521 case PT_MIPS_RTPROC
:
3523 case PT_MIPS_OPTIONS
:
3525 case PT_MIPS_ABIFLAGS
:
3535 get_parisc_segment_type (unsigned long type
)
3539 case PT_HP_TLS
: return "HP_TLS";
3540 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3541 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3542 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3543 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3544 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3545 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3546 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3547 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3548 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3549 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3550 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3551 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3552 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3553 case PT_HP_STACK
: return "HP_STACK";
3554 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3555 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3556 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3557 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3566 get_ia64_segment_type (unsigned long type
)
3570 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3571 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3572 case PT_HP_TLS
: return "HP_TLS";
3573 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3574 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3575 case PT_IA_64_HP_STACK
: return "HP_STACK";
3584 get_tic6x_segment_type (unsigned long type
)
3588 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3597 get_segment_type (unsigned long p_type
)
3599 static char buff
[32];
3603 case PT_NULL
: return "NULL";
3604 case PT_LOAD
: return "LOAD";
3605 case PT_DYNAMIC
: return "DYNAMIC";
3606 case PT_INTERP
: return "INTERP";
3607 case PT_NOTE
: return "NOTE";
3608 case PT_SHLIB
: return "SHLIB";
3609 case PT_PHDR
: return "PHDR";
3610 case PT_TLS
: return "TLS";
3612 case PT_GNU_EH_FRAME
:
3613 return "GNU_EH_FRAME";
3614 case PT_GNU_STACK
: return "GNU_STACK";
3615 case PT_GNU_RELRO
: return "GNU_RELRO";
3618 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3620 const char * result
;
3622 switch (elf_header
.e_machine
)
3625 result
= get_aarch64_segment_type (p_type
);
3628 result
= get_arm_segment_type (p_type
);
3631 case EM_MIPS_RS3_LE
:
3632 result
= get_mips_segment_type (p_type
);
3635 result
= get_parisc_segment_type (p_type
);
3638 result
= get_ia64_segment_type (p_type
);
3641 result
= get_tic6x_segment_type (p_type
);
3651 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
3653 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3655 const char * result
;
3657 switch (elf_header
.e_machine
)
3660 result
= get_parisc_segment_type (p_type
);
3663 result
= get_ia64_segment_type (p_type
);
3673 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
3676 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3683 get_mips_section_type_name (unsigned int sh_type
)
3687 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3688 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3689 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3690 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3691 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3692 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3693 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3694 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3695 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3696 case SHT_MIPS_RELD
: return "MIPS_RELD";
3697 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3698 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3699 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3700 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3701 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3702 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3703 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3704 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3705 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3706 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3707 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3708 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3709 case SHT_MIPS_LINE
: return "MIPS_LINE";
3710 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3711 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3712 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3713 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3714 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3715 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3716 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3717 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3718 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3719 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3720 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3721 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3722 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3723 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3724 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3725 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3726 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3734 get_parisc_section_type_name (unsigned int sh_type
)
3738 case SHT_PARISC_EXT
: return "PARISC_EXT";
3739 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3740 case SHT_PARISC_DOC
: return "PARISC_DOC";
3741 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3742 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3743 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3744 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3752 get_ia64_section_type_name (unsigned int sh_type
)
3754 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3755 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
3756 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
3760 case SHT_IA_64_EXT
: return "IA_64_EXT";
3761 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
3762 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
3763 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
3764 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
3765 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
3766 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
3767 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
3768 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
3769 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
3777 get_x86_64_section_type_name (unsigned int sh_type
)
3781 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
3789 get_aarch64_section_type_name (unsigned int sh_type
)
3793 case SHT_AARCH64_ATTRIBUTES
:
3794 return "AARCH64_ATTRIBUTES";
3802 get_arm_section_type_name (unsigned int sh_type
)
3806 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
3807 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
3808 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
3809 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
3810 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
3818 get_tic6x_section_type_name (unsigned int sh_type
)
3822 case SHT_C6000_UNWIND
:
3823 return "C6000_UNWIND";
3824 case SHT_C6000_PREEMPTMAP
:
3825 return "C6000_PREEMPTMAP";
3826 case SHT_C6000_ATTRIBUTES
:
3827 return "C6000_ATTRIBUTES";
3832 case SHT_TI_HANDLER
:
3833 return "TI_HANDLER";
3834 case SHT_TI_INITINFO
:
3835 return "TI_INITINFO";
3836 case SHT_TI_PHATTRS
:
3837 return "TI_PHATTRS";
3845 get_msp430x_section_type_name (unsigned int sh_type
)
3849 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
3850 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
3851 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
3852 default: return NULL
;
3857 get_v850_section_type_name (unsigned int sh_type
)
3861 case SHT_V850_SCOMMON
: return "V850 Small Common";
3862 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
3863 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
3864 case SHT_RENESAS_IOP
: return "RENESAS IOP";
3865 case SHT_RENESAS_INFO
: return "RENESAS INFO";
3866 default: return NULL
;
3871 get_section_type_name (unsigned int sh_type
)
3873 static char buff
[32];
3877 case SHT_NULL
: return "NULL";
3878 case SHT_PROGBITS
: return "PROGBITS";
3879 case SHT_SYMTAB
: return "SYMTAB";
3880 case SHT_STRTAB
: return "STRTAB";
3881 case SHT_RELA
: return "RELA";
3882 case SHT_HASH
: return "HASH";
3883 case SHT_DYNAMIC
: return "DYNAMIC";
3884 case SHT_NOTE
: return "NOTE";
3885 case SHT_NOBITS
: return "NOBITS";
3886 case SHT_REL
: return "REL";
3887 case SHT_SHLIB
: return "SHLIB";
3888 case SHT_DYNSYM
: return "DYNSYM";
3889 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
3890 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
3891 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
3892 case SHT_GNU_HASH
: return "GNU_HASH";
3893 case SHT_GROUP
: return "GROUP";
3894 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
3895 case SHT_GNU_verdef
: return "VERDEF";
3896 case SHT_GNU_verneed
: return "VERNEED";
3897 case SHT_GNU_versym
: return "VERSYM";
3898 case 0x6ffffff0: return "VERSYM";
3899 case 0x6ffffffc: return "VERDEF";
3900 case 0x7ffffffd: return "AUXILIARY";
3901 case 0x7fffffff: return "FILTER";
3902 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
3905 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
3907 const char * result
;
3909 switch (elf_header
.e_machine
)
3912 case EM_MIPS_RS3_LE
:
3913 result
= get_mips_section_type_name (sh_type
);
3916 result
= get_parisc_section_type_name (sh_type
);
3919 result
= get_ia64_section_type_name (sh_type
);
3924 result
= get_x86_64_section_type_name (sh_type
);
3927 result
= get_aarch64_section_type_name (sh_type
);
3930 result
= get_arm_section_type_name (sh_type
);
3933 result
= get_tic6x_section_type_name (sh_type
);
3936 result
= get_msp430x_section_type_name (sh_type
);
3940 case EM_CYGNUS_V850
:
3941 result
= get_v850_section_type_name (sh_type
);
3951 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
3953 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
3955 const char * result
;
3957 switch (elf_header
.e_machine
)
3960 result
= get_ia64_section_type_name (sh_type
);
3970 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
3972 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
3974 switch (elf_header
.e_machine
)
3978 case EM_CYGNUS_V850
:
3979 return get_v850_section_type_name (sh_type
);
3984 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
3987 /* This message is probably going to be displayed in a 15
3988 character wide field, so put the hex value first. */
3989 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
3995 #define OPTION_DEBUG_DUMP 512
3996 #define OPTION_DYN_SYMS 513
3997 #define OPTION_DWARF_DEPTH 514
3998 #define OPTION_DWARF_START 515
3999 #define OPTION_DWARF_CHECK 516
4001 static struct option options
[] =
4003 {"all", no_argument
, 0, 'a'},
4004 {"file-header", no_argument
, 0, 'h'},
4005 {"program-headers", no_argument
, 0, 'l'},
4006 {"headers", no_argument
, 0, 'e'},
4007 {"histogram", no_argument
, 0, 'I'},
4008 {"segments", no_argument
, 0, 'l'},
4009 {"sections", no_argument
, 0, 'S'},
4010 {"section-headers", no_argument
, 0, 'S'},
4011 {"section-groups", no_argument
, 0, 'g'},
4012 {"section-details", no_argument
, 0, 't'},
4013 {"full-section-name",no_argument
, 0, 'N'},
4014 {"symbols", no_argument
, 0, 's'},
4015 {"syms", no_argument
, 0, 's'},
4016 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4017 {"relocs", no_argument
, 0, 'r'},
4018 {"notes", no_argument
, 0, 'n'},
4019 {"dynamic", no_argument
, 0, 'd'},
4020 {"arch-specific", no_argument
, 0, 'A'},
4021 {"version-info", no_argument
, 0, 'V'},
4022 {"use-dynamic", no_argument
, 0, 'D'},
4023 {"unwind", no_argument
, 0, 'u'},
4024 {"archive-index", no_argument
, 0, 'c'},
4025 {"hex-dump", required_argument
, 0, 'x'},
4026 {"relocated-dump", required_argument
, 0, 'R'},
4027 {"string-dump", required_argument
, 0, 'p'},
4028 {"decompress", no_argument
, 0, 'z'},
4029 #ifdef SUPPORT_DISASSEMBLY
4030 {"instruction-dump", required_argument
, 0, 'i'},
4032 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4034 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4035 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4036 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4038 {"version", no_argument
, 0, 'v'},
4039 {"wide", no_argument
, 0, 'W'},
4040 {"help", no_argument
, 0, 'H'},
4041 {0, no_argument
, 0, 0}
4045 usage (FILE * stream
)
4047 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4048 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4049 fprintf (stream
, _(" Options are:\n\
4050 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4051 -h --file-header Display the ELF file header\n\
4052 -l --program-headers Display the program headers\n\
4053 --segments An alias for --program-headers\n\
4054 -S --section-headers Display the sections' header\n\
4055 --sections An alias for --section-headers\n\
4056 -g --section-groups Display the section groups\n\
4057 -t --section-details Display the section details\n\
4058 -e --headers Equivalent to: -h -l -S\n\
4059 -s --syms Display the symbol table\n\
4060 --symbols An alias for --syms\n\
4061 --dyn-syms Display the dynamic symbol table\n\
4062 -n --notes Display the core notes (if present)\n\
4063 -r --relocs Display the relocations (if present)\n\
4064 -u --unwind Display the unwind info (if present)\n\
4065 -d --dynamic Display the dynamic section (if present)\n\
4066 -V --version-info Display the version sections (if present)\n\
4067 -A --arch-specific Display architecture specific information (if any)\n\
4068 -c --archive-index Display the symbol/file index in an archive\n\
4069 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4070 -x --hex-dump=<number|name>\n\
4071 Dump the contents of section <number|name> as bytes\n\
4072 -p --string-dump=<number|name>\n\
4073 Dump the contents of section <number|name> as strings\n\
4074 -R --relocated-dump=<number|name>\n\
4075 Dump the contents of section <number|name> as relocated bytes\n\
4076 -z --decompress Decompress section before dumping it\n\
4077 -w[lLiaprmfFsoRt] or\n\
4078 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4079 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4080 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4082 Display the contents of DWARF2 debug sections\n"));
4083 fprintf (stream
, _("\
4084 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4085 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4087 #ifdef SUPPORT_DISASSEMBLY
4088 fprintf (stream
, _("\
4089 -i --instruction-dump=<number|name>\n\
4090 Disassemble the contents of section <number|name>\n"));
4092 fprintf (stream
, _("\
4093 -I --histogram Display histogram of bucket list lengths\n\
4094 -W --wide Allow output width to exceed 80 characters\n\
4095 @<file> Read options from <file>\n\
4096 -H --help Display this information\n\
4097 -v --version Display the version number of readelf\n"));
4099 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4100 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4102 exit (stream
== stdout
? 0 : 1);
4105 /* Record the fact that the user wants the contents of section number
4106 SECTION to be displayed using the method(s) encoded as flags bits
4107 in TYPE. Note, TYPE can be zero if we are creating the array for
4111 request_dump_bynumber (unsigned int section
, dump_type type
)
4113 if (section
>= num_dump_sects
)
4115 dump_type
* new_dump_sects
;
4117 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4118 sizeof (* dump_sects
));
4120 if (new_dump_sects
== NULL
)
4121 error (_("Out of memory allocating dump request table.\n"));
4124 /* Copy current flag settings. */
4125 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4129 dump_sects
= new_dump_sects
;
4130 num_dump_sects
= section
+ 1;
4135 dump_sects
[section
] |= type
;
4140 /* Request a dump by section name. */
4143 request_dump_byname (const char * section
, dump_type type
)
4145 struct dump_list_entry
* new_request
;
4147 new_request
= (struct dump_list_entry
*)
4148 malloc (sizeof (struct dump_list_entry
));
4150 error (_("Out of memory allocating dump request table.\n"));
4152 new_request
->name
= strdup (section
);
4153 if (!new_request
->name
)
4154 error (_("Out of memory allocating dump request table.\n"));
4156 new_request
->type
= type
;
4158 new_request
->next
= dump_sects_byname
;
4159 dump_sects_byname
= new_request
;
4163 request_dump (dump_type type
)
4169 section
= strtoul (optarg
, & cp
, 0);
4171 if (! *cp
&& section
>= 0)
4172 request_dump_bynumber (section
, type
);
4174 request_dump_byname (optarg
, type
);
4179 parse_args (int argc
, char ** argv
)
4186 while ((c
= getopt_long
4187 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4205 do_section_groups
++;
4213 do_section_groups
++;
4218 do_section_details
++;
4262 request_dump (HEX_DUMP
);
4265 request_dump (STRING_DUMP
);
4268 request_dump (RELOC_DUMP
);
4278 dwarf_select_sections_all ();
4283 dwarf_select_sections_by_letters (optarg
);
4286 case OPTION_DEBUG_DUMP
:
4293 dwarf_select_sections_by_names (optarg
);
4296 case OPTION_DWARF_DEPTH
:
4300 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4303 case OPTION_DWARF_START
:
4307 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4310 case OPTION_DWARF_CHECK
:
4313 case OPTION_DYN_SYMS
:
4316 #ifdef SUPPORT_DISASSEMBLY
4318 request_dump (DISASS_DUMP
);
4322 print_version (program_name
);
4331 /* xgettext:c-format */
4332 error (_("Invalid option '-%c'\n"), c
);
4339 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4340 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4341 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4342 && !do_section_groups
&& !do_archive_index
4348 get_elf_class (unsigned int elf_class
)
4350 static char buff
[32];
4354 case ELFCLASSNONE
: return _("none");
4355 case ELFCLASS32
: return "ELF32";
4356 case ELFCLASS64
: return "ELF64";
4358 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4364 get_data_encoding (unsigned int encoding
)
4366 static char buff
[32];
4370 case ELFDATANONE
: return _("none");
4371 case ELFDATA2LSB
: return _("2's complement, little endian");
4372 case ELFDATA2MSB
: return _("2's complement, big endian");
4374 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4379 /* Decode the data held in 'elf_header'. */
4382 process_file_header (void)
4384 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4385 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4386 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4387 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4390 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4394 init_dwarf_regnames (elf_header
.e_machine
);
4400 printf (_("ELF Header:\n"));
4401 printf (_(" Magic: "));
4402 for (i
= 0; i
< EI_NIDENT
; i
++)
4403 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4405 printf (_(" Class: %s\n"),
4406 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4407 printf (_(" Data: %s\n"),
4408 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4409 printf (_(" Version: %d %s\n"),
4410 elf_header
.e_ident
[EI_VERSION
],
4411 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4413 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4414 ? _("<unknown: %lx>")
4416 printf (_(" OS/ABI: %s\n"),
4417 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4418 printf (_(" ABI Version: %d\n"),
4419 elf_header
.e_ident
[EI_ABIVERSION
]);
4420 printf (_(" Type: %s\n"),
4421 get_file_type (elf_header
.e_type
));
4422 printf (_(" Machine: %s\n"),
4423 get_machine_name (elf_header
.e_machine
));
4424 printf (_(" Version: 0x%lx\n"),
4425 (unsigned long) elf_header
.e_version
);
4427 printf (_(" Entry point address: "));
4428 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4429 printf (_("\n Start of program headers: "));
4430 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4431 printf (_(" (bytes into file)\n Start of section headers: "));
4432 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4433 printf (_(" (bytes into file)\n"));
4435 printf (_(" Flags: 0x%lx%s\n"),
4436 (unsigned long) elf_header
.e_flags
,
4437 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4438 printf (_(" Size of this header: %ld (bytes)\n"),
4439 (long) elf_header
.e_ehsize
);
4440 printf (_(" Size of program headers: %ld (bytes)\n"),
4441 (long) elf_header
.e_phentsize
);
4442 printf (_(" Number of program headers: %ld"),
4443 (long) elf_header
.e_phnum
);
4444 if (section_headers
!= NULL
4445 && elf_header
.e_phnum
== PN_XNUM
4446 && section_headers
[0].sh_info
!= 0)
4447 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4448 putc ('\n', stdout
);
4449 printf (_(" Size of section headers: %ld (bytes)\n"),
4450 (long) elf_header
.e_shentsize
);
4451 printf (_(" Number of section headers: %ld"),
4452 (long) elf_header
.e_shnum
);
4453 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4454 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4455 putc ('\n', stdout
);
4456 printf (_(" Section header string table index: %ld"),
4457 (long) elf_header
.e_shstrndx
);
4458 if (section_headers
!= NULL
4459 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4460 printf (" (%u)", section_headers
[0].sh_link
);
4461 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4462 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4463 printf (_(" <corrupt: out of range>"));
4464 putc ('\n', stdout
);
4467 if (section_headers
!= NULL
)
4469 if (elf_header
.e_phnum
== PN_XNUM
4470 && section_headers
[0].sh_info
!= 0)
4471 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4472 if (elf_header
.e_shnum
== SHN_UNDEF
)
4473 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4474 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4475 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4476 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4477 elf_header
.e_shstrndx
= SHN_UNDEF
;
4478 free (section_headers
);
4479 section_headers
= NULL
;
4486 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4488 Elf32_External_Phdr
* phdrs
;
4489 Elf32_External_Phdr
* external
;
4490 Elf_Internal_Phdr
* internal
;
4492 unsigned int size
= elf_header
.e_phentsize
;
4493 unsigned int num
= elf_header
.e_phnum
;
4495 /* PR binutils/17531: Cope with unexpected section header sizes. */
4496 if (size
== 0 || num
== 0)
4498 if (size
< sizeof * phdrs
)
4500 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4503 if (size
> sizeof * phdrs
)
4504 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4506 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4507 size
, num
, _("program headers"));
4511 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4512 i
< elf_header
.e_phnum
;
4513 i
++, internal
++, external
++)
4515 internal
->p_type
= BYTE_GET (external
->p_type
);
4516 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4517 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4518 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4519 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4520 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4521 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4522 internal
->p_align
= BYTE_GET (external
->p_align
);
4530 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4532 Elf64_External_Phdr
* phdrs
;
4533 Elf64_External_Phdr
* external
;
4534 Elf_Internal_Phdr
* internal
;
4536 unsigned int size
= elf_header
.e_phentsize
;
4537 unsigned int num
= elf_header
.e_phnum
;
4539 /* PR binutils/17531: Cope with unexpected section header sizes. */
4540 if (size
== 0 || num
== 0)
4542 if (size
< sizeof * phdrs
)
4544 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4547 if (size
> sizeof * phdrs
)
4548 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4550 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4551 size
, num
, _("program headers"));
4555 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4556 i
< elf_header
.e_phnum
;
4557 i
++, internal
++, external
++)
4559 internal
->p_type
= BYTE_GET (external
->p_type
);
4560 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4561 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4562 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4563 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4564 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4565 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4566 internal
->p_align
= BYTE_GET (external
->p_align
);
4573 /* Returns 1 if the program headers were read into `program_headers'. */
4576 get_program_headers (FILE * file
)
4578 Elf_Internal_Phdr
* phdrs
;
4580 /* Check cache of prior read. */
4581 if (program_headers
!= NULL
)
4584 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4585 sizeof (Elf_Internal_Phdr
));
4589 error (_("Out of memory reading %u program headers\n"),
4590 elf_header
.e_phnum
);
4595 ? get_32bit_program_headers (file
, phdrs
)
4596 : get_64bit_program_headers (file
, phdrs
))
4598 program_headers
= phdrs
;
4606 /* Returns 1 if the program headers were loaded. */
4609 process_program_headers (FILE * file
)
4611 Elf_Internal_Phdr
* segment
;
4614 if (elf_header
.e_phnum
== 0)
4616 /* PR binutils/12467. */
4617 if (elf_header
.e_phoff
!= 0)
4618 warn (_("possibly corrupt ELF header - it has a non-zero program"
4619 " header offset, but no program headers\n"));
4620 else if (do_segments
)
4621 printf (_("\nThere are no program headers in this file.\n"));
4625 if (do_segments
&& !do_header
)
4627 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4628 printf (_("Entry point "));
4629 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4630 printf (_("\nThere are %d program headers, starting at offset "),
4631 elf_header
.e_phnum
);
4632 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4636 if (! get_program_headers (file
))
4641 if (elf_header
.e_phnum
> 1)
4642 printf (_("\nProgram Headers:\n"));
4644 printf (_("\nProgram Headers:\n"));
4648 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4651 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4655 (_(" Type Offset VirtAddr PhysAddr\n"));
4657 (_(" FileSiz MemSiz Flags Align\n"));
4664 for (i
= 0, segment
= program_headers
;
4665 i
< elf_header
.e_phnum
;
4670 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4674 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4675 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4676 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4677 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4678 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4680 (segment
->p_flags
& PF_R
? 'R' : ' '),
4681 (segment
->p_flags
& PF_W
? 'W' : ' '),
4682 (segment
->p_flags
& PF_X
? 'E' : ' '));
4683 printf ("%#lx", (unsigned long) segment
->p_align
);
4687 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4688 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4691 print_vma (segment
->p_offset
, FULL_HEX
);
4695 print_vma (segment
->p_vaddr
, FULL_HEX
);
4697 print_vma (segment
->p_paddr
, FULL_HEX
);
4700 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4701 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4704 print_vma (segment
->p_filesz
, FULL_HEX
);
4708 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4709 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4712 print_vma (segment
->p_memsz
, FULL_HEX
);
4716 (segment
->p_flags
& PF_R
? 'R' : ' '),
4717 (segment
->p_flags
& PF_W
? 'W' : ' '),
4718 (segment
->p_flags
& PF_X
? 'E' : ' '));
4720 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4721 printf ("%#lx", (unsigned long) segment
->p_align
);
4724 print_vma (segment
->p_align
, PREFIX_HEX
);
4729 print_vma (segment
->p_offset
, FULL_HEX
);
4731 print_vma (segment
->p_vaddr
, FULL_HEX
);
4733 print_vma (segment
->p_paddr
, FULL_HEX
);
4735 print_vma (segment
->p_filesz
, FULL_HEX
);
4737 print_vma (segment
->p_memsz
, FULL_HEX
);
4739 (segment
->p_flags
& PF_R
? 'R' : ' '),
4740 (segment
->p_flags
& PF_W
? 'W' : ' '),
4741 (segment
->p_flags
& PF_X
? 'E' : ' '));
4742 print_vma (segment
->p_align
, HEX
);
4747 putc ('\n', stdout
);
4749 switch (segment
->p_type
)
4753 error (_("more than one dynamic segment\n"));
4755 /* By default, assume that the .dynamic section is the first
4756 section in the DYNAMIC segment. */
4757 dynamic_addr
= segment
->p_offset
;
4758 dynamic_size
= segment
->p_filesz
;
4759 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4760 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
4762 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4763 dynamic_addr
= dynamic_size
= 0;
4766 /* Try to locate the .dynamic section. If there is
4767 a section header table, we can easily locate it. */
4768 if (section_headers
!= NULL
)
4770 Elf_Internal_Shdr
* sec
;
4772 sec
= find_section (".dynamic");
4773 if (sec
== NULL
|| sec
->sh_size
== 0)
4775 /* A corresponding .dynamic section is expected, but on
4776 IA-64/OpenVMS it is OK for it to be missing. */
4777 if (!is_ia64_vms ())
4778 error (_("no .dynamic section in the dynamic segment\n"));
4782 if (sec
->sh_type
== SHT_NOBITS
)
4788 dynamic_addr
= sec
->sh_offset
;
4789 dynamic_size
= sec
->sh_size
;
4791 if (dynamic_addr
< segment
->p_offset
4792 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
4793 warn (_("the .dynamic section is not contained"
4794 " within the dynamic segment\n"));
4795 else if (dynamic_addr
> segment
->p_offset
)
4796 warn (_("the .dynamic section is not the first section"
4797 " in the dynamic segment.\n"));
4802 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
4804 error (_("Unable to find program interpreter name\n"));
4808 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
4810 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
4811 error (_("Internal error: failed to create format string to display program interpreter\n"));
4813 program_interpreter
[0] = 0;
4814 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
4815 error (_("Unable to read program interpreter name\n"));
4818 printf (_(" [Requesting program interpreter: %s]\n"),
4819 program_interpreter
);
4825 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
4827 printf (_("\n Section to Segment mapping:\n"));
4828 printf (_(" Segment Sections...\n"));
4830 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
4833 Elf_Internal_Shdr
* section
;
4835 segment
= program_headers
+ i
;
4836 section
= section_headers
+ 1;
4838 printf (" %2.2d ", i
);
4840 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
4842 if (!ELF_TBSS_SPECIAL (section
, segment
)
4843 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
4844 printf ("%s ", printable_section_name (section
));
4855 /* Find the file offset corresponding to VMA by using the program headers. */
4858 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
4860 Elf_Internal_Phdr
* seg
;
4862 if (! get_program_headers (file
))
4864 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4868 for (seg
= program_headers
;
4869 seg
< program_headers
+ elf_header
.e_phnum
;
4872 if (seg
->p_type
!= PT_LOAD
)
4875 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
4876 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
4877 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
4880 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4881 (unsigned long) vma
);
4886 /* Allocate memory and load the sections headers into the global pointer
4887 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4888 generate any error messages if the load fails. */
4891 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
4893 Elf32_External_Shdr
* shdrs
;
4894 Elf_Internal_Shdr
* internal
;
4896 unsigned int size
= elf_header
.e_shentsize
;
4897 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4899 /* PR binutils/17531: Cope with unexpected section header sizes. */
4900 if (size
== 0 || num
== 0)
4902 if (size
< sizeof * shdrs
)
4905 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4908 if (!probe
&& size
> sizeof * shdrs
)
4909 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4911 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4913 probe
? NULL
: _("section headers"));
4917 if (section_headers
!= NULL
)
4918 free (section_headers
);
4919 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4920 sizeof (Elf_Internal_Shdr
));
4921 if (section_headers
== NULL
)
4924 error (_("Out of memory reading %u section headers\n"), num
);
4928 for (i
= 0, internal
= section_headers
;
4932 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4933 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4934 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4935 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4936 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4937 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4938 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4939 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4940 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
4941 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4949 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
4951 Elf64_External_Shdr
* shdrs
;
4952 Elf_Internal_Shdr
* internal
;
4954 unsigned int size
= elf_header
.e_shentsize
;
4955 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
4957 /* PR binutils/17531: Cope with unexpected section header sizes. */
4958 if (size
== 0 || num
== 0)
4960 if (size
< sizeof * shdrs
)
4963 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4966 if (! probe
&& size
> sizeof * shdrs
)
4967 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4969 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
4971 probe
? NULL
: _("section headers"));
4975 if (section_headers
!= NULL
)
4976 free (section_headers
);
4977 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
4978 sizeof (Elf_Internal_Shdr
));
4979 if (section_headers
== NULL
)
4982 error (_("Out of memory reading %u section headers\n"), num
);
4986 for (i
= 0, internal
= section_headers
;
4990 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
4991 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
4992 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
4993 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
4994 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
4995 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
4996 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
4997 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
4998 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
4999 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5006 static Elf_Internal_Sym
*
5007 get_32bit_elf_symbols (FILE * file
,
5008 Elf_Internal_Shdr
* section
,
5009 unsigned long * num_syms_return
)
5011 unsigned long number
= 0;
5012 Elf32_External_Sym
* esyms
= NULL
;
5013 Elf_External_Sym_Shndx
* shndx
= NULL
;
5014 Elf_Internal_Sym
* isyms
= NULL
;
5015 Elf_Internal_Sym
* psym
;
5018 if (section
->sh_size
== 0)
5020 if (num_syms_return
!= NULL
)
5021 * num_syms_return
= 0;
5025 /* Run some sanity checks first. */
5026 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5028 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5029 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5033 if (section
->sh_size
> current_file_size
)
5035 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5036 printable_section_name (section
), (unsigned long) section
->sh_size
);
5040 number
= section
->sh_size
/ section
->sh_entsize
;
5042 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5044 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5045 (unsigned long) section
->sh_size
,
5046 printable_section_name (section
),
5047 (unsigned long) section
->sh_entsize
);
5051 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5052 section
->sh_size
, _("symbols"));
5057 elf_section_list
* entry
;
5060 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5061 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5063 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5064 entry
->hdr
->sh_offset
,
5065 1, entry
->hdr
->sh_size
,
5066 _("symbol table section indicies"));
5069 /* PR17531: file: heap-buffer-overflow */
5070 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5072 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5073 printable_section_name (entry
->hdr
),
5074 (unsigned long) entry
->hdr
->sh_size
,
5075 (unsigned long) section
->sh_size
);
5081 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5085 error (_("Out of memory reading %lu symbols\n"),
5086 (unsigned long) number
);
5090 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5092 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5093 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5094 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5095 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5096 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5098 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5099 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5100 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5101 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5102 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5111 if (num_syms_return
!= NULL
)
5112 * num_syms_return
= isyms
== NULL
? 0 : number
;
5117 static Elf_Internal_Sym
*
5118 get_64bit_elf_symbols (FILE * file
,
5119 Elf_Internal_Shdr
* section
,
5120 unsigned long * num_syms_return
)
5122 unsigned long number
= 0;
5123 Elf64_External_Sym
* esyms
= NULL
;
5124 Elf_External_Sym_Shndx
* shndx
= NULL
;
5125 Elf_Internal_Sym
* isyms
= NULL
;
5126 Elf_Internal_Sym
* psym
;
5129 if (section
->sh_size
== 0)
5131 if (num_syms_return
!= NULL
)
5132 * num_syms_return
= 0;
5136 /* Run some sanity checks first. */
5137 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5139 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5140 printable_section_name (section
),
5141 (unsigned long) section
->sh_entsize
);
5145 if (section
->sh_size
> current_file_size
)
5147 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5148 printable_section_name (section
),
5149 (unsigned long) section
->sh_size
);
5153 number
= section
->sh_size
/ section
->sh_entsize
;
5155 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5157 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5158 (unsigned long) section
->sh_size
,
5159 printable_section_name (section
),
5160 (unsigned long) section
->sh_entsize
);
5164 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5165 section
->sh_size
, _("symbols"));
5170 elf_section_list
* entry
;
5173 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5174 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5176 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5177 entry
->hdr
->sh_offset
,
5178 1, entry
->hdr
->sh_size
,
5179 _("symbol table section indicies"));
5182 /* PR17531: file: heap-buffer-overflow */
5183 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5185 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5186 printable_section_name (entry
->hdr
),
5187 (unsigned long) entry
->hdr
->sh_size
,
5188 (unsigned long) section
->sh_size
);
5194 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5198 error (_("Out of memory reading %lu symbols\n"),
5199 (unsigned long) number
);
5203 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5205 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5206 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5207 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5208 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5210 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5212 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5213 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5214 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5216 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5217 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5226 if (num_syms_return
!= NULL
)
5227 * num_syms_return
= isyms
== NULL
? 0 : number
;
5233 get_elf_section_flags (bfd_vma sh_flags
)
5235 static char buff
[1024];
5237 int field_size
= is_32bit_elf
? 8 : 16;
5239 int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5240 bfd_vma os_flags
= 0;
5241 bfd_vma proc_flags
= 0;
5242 bfd_vma unknown_flags
= 0;
5250 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5251 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5252 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5253 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5254 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5255 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5256 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5257 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5258 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5259 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5260 /* IA-64 specific. */
5261 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5262 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5263 /* IA-64 OpenVMS specific. */
5264 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5265 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5266 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5267 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5268 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5269 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5271 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5272 /* SPARC specific. */
5273 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5274 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
5277 if (do_section_details
)
5279 sprintf (buff
, "[%*.*lx]: ",
5280 field_size
, field_size
, (unsigned long) sh_flags
);
5281 p
+= field_size
+ 4;
5288 flag
= sh_flags
& - sh_flags
;
5291 if (do_section_details
)
5295 case SHF_WRITE
: sindex
= 0; break;
5296 case SHF_ALLOC
: sindex
= 1; break;
5297 case SHF_EXECINSTR
: sindex
= 2; break;
5298 case SHF_MERGE
: sindex
= 3; break;
5299 case SHF_STRINGS
: sindex
= 4; break;
5300 case SHF_INFO_LINK
: sindex
= 5; break;
5301 case SHF_LINK_ORDER
: sindex
= 6; break;
5302 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5303 case SHF_GROUP
: sindex
= 8; break;
5304 case SHF_TLS
: sindex
= 9; break;
5305 case SHF_EXCLUDE
: sindex
= 18; break;
5306 case SHF_COMPRESSED
: sindex
= 20; break;
5310 switch (elf_header
.e_machine
)
5313 if (flag
== SHF_IA_64_SHORT
)
5315 else if (flag
== SHF_IA_64_NORECOV
)
5318 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5321 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5322 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5323 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5324 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5325 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5326 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5337 case EM_OLD_SPARCV9
:
5338 case EM_SPARC32PLUS
:
5341 if (flag
== SHF_ORDERED
)
5351 if (p
!= buff
+ field_size
+ 4)
5353 if (size
< (10 + 2))
5355 warn (_("Internal error: not enough buffer room for section flag info"));
5356 return _("<unknown>");
5363 size
-= flags
[sindex
].len
;
5364 p
= stpcpy (p
, flags
[sindex
].str
);
5366 else if (flag
& SHF_MASKOS
)
5368 else if (flag
& SHF_MASKPROC
)
5371 unknown_flags
|= flag
;
5377 case SHF_WRITE
: *p
= 'W'; break;
5378 case SHF_ALLOC
: *p
= 'A'; break;
5379 case SHF_EXECINSTR
: *p
= 'X'; break;
5380 case SHF_MERGE
: *p
= 'M'; break;
5381 case SHF_STRINGS
: *p
= 'S'; break;
5382 case SHF_INFO_LINK
: *p
= 'I'; break;
5383 case SHF_LINK_ORDER
: *p
= 'L'; break;
5384 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5385 case SHF_GROUP
: *p
= 'G'; break;
5386 case SHF_TLS
: *p
= 'T'; break;
5387 case SHF_EXCLUDE
: *p
= 'E'; break;
5388 case SHF_COMPRESSED
: *p
= 'C'; break;
5391 if ((elf_header
.e_machine
== EM_X86_64
5392 || elf_header
.e_machine
== EM_L1OM
5393 || elf_header
.e_machine
== EM_K1OM
)
5394 && flag
== SHF_X86_64_LARGE
)
5396 else if (flag
& SHF_MASKOS
)
5399 sh_flags
&= ~ SHF_MASKOS
;
5401 else if (flag
& SHF_MASKPROC
)
5404 sh_flags
&= ~ SHF_MASKPROC
;
5414 if (do_section_details
)
5418 size
-= 5 + field_size
;
5419 if (p
!= buff
+ field_size
+ 4)
5423 warn (_("Internal error: not enough buffer room for section flag info"));
5424 return _("<unknown>");
5430 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5431 (unsigned long) os_flags
);
5432 p
+= 5 + field_size
;
5436 size
-= 7 + field_size
;
5437 if (p
!= buff
+ field_size
+ 4)
5441 warn (_("Internal error: not enough buffer room for section flag info"));
5442 return _("<unknown>");
5448 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5449 (unsigned long) proc_flags
);
5450 p
+= 7 + field_size
;
5454 size
-= 10 + field_size
;
5455 if (p
!= buff
+ field_size
+ 4)
5459 warn (_("Internal error: not enough buffer room for section flag info"));
5460 return _("<unknown>");
5466 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5467 (unsigned long) unknown_flags
);
5468 p
+= 10 + field_size
;
5477 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
)
5481 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5482 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5483 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5484 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5485 return sizeof (*echdr
);
5489 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5490 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5491 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5492 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5493 return sizeof (*echdr
);
5498 process_section_headers (FILE * file
)
5500 Elf_Internal_Shdr
* section
;
5503 section_headers
= NULL
;
5505 if (elf_header
.e_shnum
== 0)
5507 /* PR binutils/12467. */
5508 if (elf_header
.e_shoff
!= 0)
5509 warn (_("possibly corrupt ELF file header - it has a non-zero"
5510 " section header offset, but no section headers\n"));
5511 else if (do_sections
)
5512 printf (_("\nThere are no sections in this file.\n"));
5517 if (do_sections
&& !do_header
)
5518 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5519 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5523 if (! get_32bit_section_headers (file
, FALSE
))
5526 else if (! get_64bit_section_headers (file
, FALSE
))
5529 /* Read in the string table, so that we have names to display. */
5530 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5531 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5533 section
= section_headers
+ elf_header
.e_shstrndx
;
5535 if (section
->sh_size
!= 0)
5537 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5538 1, section
->sh_size
,
5541 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5545 /* Scan the sections for the dynamic symbol table
5546 and dynamic string table and debug sections. */
5547 dynamic_symbols
= NULL
;
5548 dynamic_strings
= NULL
;
5549 dynamic_syminfo
= NULL
;
5550 symtab_shndx_list
= NULL
;
5552 eh_addr_size
= is_32bit_elf
? 4 : 8;
5553 switch (elf_header
.e_machine
)
5556 case EM_MIPS_RS3_LE
:
5557 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5558 FDE addresses. However, the ABI also has a semi-official ILP32
5559 variant for which the normal FDE address size rules apply.
5561 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5562 section, where XX is the size of longs in bits. Unfortunately,
5563 earlier compilers provided no way of distinguishing ILP32 objects
5564 from LP64 objects, so if there's any doubt, we should assume that
5565 the official LP64 form is being used. */
5566 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5567 && find_section (".gcc_compiled_long32") == NULL
)
5573 switch (elf_header
.e_flags
& EF_H8_MACH
)
5575 case E_H8_MACH_H8300
:
5576 case E_H8_MACH_H8300HN
:
5577 case E_H8_MACH_H8300SN
:
5578 case E_H8_MACH_H8300SXN
:
5581 case E_H8_MACH_H8300H
:
5582 case E_H8_MACH_H8300S
:
5583 case E_H8_MACH_H8300SX
:
5591 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5593 case EF_M32C_CPU_M16C
:
5600 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5603 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5604 if (section->sh_entsize != expected_entsize) \
5607 sprintf_vma (buf, section->sh_entsize); \
5608 /* Note: coded this way so that there is a single string for \
5610 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5611 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5612 (unsigned) expected_entsize); \
5613 section->sh_entsize = expected_entsize; \
5618 #define CHECK_ENTSIZE(section, i, type) \
5619 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5620 sizeof (Elf64_External_##type))
5622 for (i
= 0, section
= section_headers
;
5623 i
< elf_header
.e_shnum
;
5626 char * name
= SECTION_NAME (section
);
5628 if (section
->sh_type
== SHT_DYNSYM
)
5630 if (dynamic_symbols
!= NULL
)
5632 error (_("File contains multiple dynamic symbol tables\n"));
5636 CHECK_ENTSIZE (section
, i
, Sym
);
5637 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5639 else if (section
->sh_type
== SHT_STRTAB
5640 && streq (name
, ".dynstr"))
5642 if (dynamic_strings
!= NULL
)
5644 error (_("File contains multiple dynamic string tables\n"));
5648 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5649 1, section
->sh_size
,
5650 _("dynamic strings"));
5651 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
5653 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
5655 elf_section_list
* entry
= xmalloc (sizeof * entry
);
5656 entry
->hdr
= section
;
5657 entry
->next
= symtab_shndx_list
;
5658 symtab_shndx_list
= entry
;
5660 else if (section
->sh_type
== SHT_SYMTAB
)
5661 CHECK_ENTSIZE (section
, i
, Sym
);
5662 else if (section
->sh_type
== SHT_GROUP
)
5663 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
5664 else if (section
->sh_type
== SHT_REL
)
5665 CHECK_ENTSIZE (section
, i
, Rel
);
5666 else if (section
->sh_type
== SHT_RELA
)
5667 CHECK_ENTSIZE (section
, i
, Rela
);
5668 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
5669 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
5670 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
5671 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
5672 || do_debug_addr
|| do_debug_cu_index
)
5673 && (const_strneq (name
, ".debug_")
5674 || const_strneq (name
, ".zdebug_")))
5677 name
+= sizeof (".zdebug_") - 1;
5679 name
+= sizeof (".debug_") - 1;
5682 || (do_debug_info
&& const_strneq (name
, "info"))
5683 || (do_debug_info
&& const_strneq (name
, "types"))
5684 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
5685 || (do_debug_lines
&& strcmp (name
, "line") == 0)
5686 || (do_debug_lines
&& const_strneq (name
, "line."))
5687 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
5688 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
5689 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
5690 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
5691 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
5692 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
5693 || (do_debug_frames
&& const_strneq (name
, "frame"))
5694 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
5695 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
5696 || (do_debug_str
&& const_strneq (name
, "str"))
5697 || (do_debug_loc
&& const_strneq (name
, "loc"))
5698 || (do_debug_addr
&& const_strneq (name
, "addr"))
5699 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
5700 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
5702 request_dump_bynumber (i
, DEBUG_DUMP
);
5704 /* Linkonce section to be combined with .debug_info at link time. */
5705 else if ((do_debugging
|| do_debug_info
)
5706 && const_strneq (name
, ".gnu.linkonce.wi."))
5707 request_dump_bynumber (i
, DEBUG_DUMP
);
5708 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
5709 request_dump_bynumber (i
, DEBUG_DUMP
);
5710 else if (do_gdb_index
&& streq (name
, ".gdb_index"))
5711 request_dump_bynumber (i
, DEBUG_DUMP
);
5712 /* Trace sections for Itanium VMS. */
5713 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
5714 || do_trace_aranges
)
5715 && const_strneq (name
, ".trace_"))
5717 name
+= sizeof (".trace_") - 1;
5720 || (do_trace_info
&& streq (name
, "info"))
5721 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
5722 || (do_trace_aranges
&& streq (name
, "aranges"))
5724 request_dump_bynumber (i
, DEBUG_DUMP
);
5731 if (elf_header
.e_shnum
> 1)
5732 printf (_("\nSection Headers:\n"));
5734 printf (_("\nSection Header:\n"));
5738 if (do_section_details
)
5740 printf (_(" [Nr] Name\n"));
5741 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5745 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5749 if (do_section_details
)
5751 printf (_(" [Nr] Name\n"));
5752 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5756 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5760 if (do_section_details
)
5762 printf (_(" [Nr] Name\n"));
5763 printf (_(" Type Address Offset Link\n"));
5764 printf (_(" Size EntSize Info Align\n"));
5768 printf (_(" [Nr] Name Type Address Offset\n"));
5769 printf (_(" Size EntSize Flags Link Info Align\n"));
5773 if (do_section_details
)
5774 printf (_(" Flags\n"));
5776 for (i
= 0, section
= section_headers
;
5777 i
< elf_header
.e_shnum
;
5780 printf (" [%2u] ", i
);
5781 if (do_section_details
)
5782 printf ("%s\n ", printable_section_name (section
));
5784 print_symbol (-17, SECTION_NAME (section
));
5786 printf (do_wide
? " %-15s " : " %-15.15s ",
5787 get_section_type_name (section
->sh_type
));
5791 const char * link_too_big
= NULL
;
5793 print_vma (section
->sh_addr
, LONG_HEX
);
5795 printf ( " %6.6lx %6.6lx %2.2lx",
5796 (unsigned long) section
->sh_offset
,
5797 (unsigned long) section
->sh_size
,
5798 (unsigned long) section
->sh_entsize
);
5800 if (do_section_details
)
5801 fputs (" ", stdout
);
5803 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5805 if (section
->sh_link
>= elf_header
.e_shnum
)
5808 /* The sh_link value is out of range. Normally this indicates
5809 an error but it can have special values in Solaris binaries. */
5810 switch (elf_header
.e_machine
)
5817 case EM_OLD_SPARCV9
:
5818 case EM_SPARC32PLUS
:
5821 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
5822 link_too_big
= "BEFORE";
5823 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
5824 link_too_big
= "AFTER";
5831 if (do_section_details
)
5833 if (link_too_big
!= NULL
&& * link_too_big
)
5834 printf ("<%s> ", link_too_big
);
5836 printf ("%2u ", section
->sh_link
);
5837 printf ("%3u %2lu\n", section
->sh_info
,
5838 (unsigned long) section
->sh_addralign
);
5841 printf ("%2u %3u %2lu\n",
5844 (unsigned long) section
->sh_addralign
);
5846 if (link_too_big
&& ! * link_too_big
)
5847 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5848 i
, section
->sh_link
);
5852 print_vma (section
->sh_addr
, LONG_HEX
);
5854 if ((long) section
->sh_offset
== section
->sh_offset
)
5855 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
5859 print_vma (section
->sh_offset
, LONG_HEX
);
5862 if ((unsigned long) section
->sh_size
== section
->sh_size
)
5863 printf (" %6.6lx", (unsigned long) section
->sh_size
);
5867 print_vma (section
->sh_size
, LONG_HEX
);
5870 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
5871 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
5875 print_vma (section
->sh_entsize
, LONG_HEX
);
5878 if (do_section_details
)
5879 fputs (" ", stdout
);
5881 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5883 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
5885 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
5886 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
5889 print_vma (section
->sh_addralign
, DEC
);
5893 else if (do_section_details
)
5895 printf (" %-15.15s ",
5896 get_section_type_name (section
->sh_type
));
5897 print_vma (section
->sh_addr
, LONG_HEX
);
5898 if ((long) section
->sh_offset
== section
->sh_offset
)
5899 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
5903 print_vma (section
->sh_offset
, LONG_HEX
);
5905 printf (" %u\n ", section
->sh_link
);
5906 print_vma (section
->sh_size
, LONG_HEX
);
5908 print_vma (section
->sh_entsize
, LONG_HEX
);
5910 printf (" %-16u %lu\n",
5912 (unsigned long) section
->sh_addralign
);
5917 print_vma (section
->sh_addr
, LONG_HEX
);
5918 if ((long) section
->sh_offset
== section
->sh_offset
)
5919 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
5923 print_vma (section
->sh_offset
, LONG_HEX
);
5926 print_vma (section
->sh_size
, LONG_HEX
);
5928 print_vma (section
->sh_entsize
, LONG_HEX
);
5930 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
5932 printf (" %2u %3u %lu\n",
5935 (unsigned long) section
->sh_addralign
);
5938 if (do_section_details
)
5940 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
5941 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
5943 /* Minimum section size is 12 bytes for 32-bit compression
5944 header + 12 bytes for compressed data header. */
5945 unsigned char buf
[24];
5946 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
5947 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
5948 sizeof (buf
), _("compression header")))
5950 Elf_Internal_Chdr chdr
;
5951 get_compression_header (&chdr
, buf
);
5952 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
5955 printf (_(" [<unknown>: 0x%x], "),
5957 print_vma (chdr
.ch_size
, LONG_HEX
);
5958 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
5964 if (!do_section_details
)
5966 if (elf_header
.e_machine
== EM_X86_64
5967 || elf_header
.e_machine
== EM_L1OM
5968 || elf_header
.e_machine
== EM_K1OM
)
5969 printf (_("Key to Flags:\n\
5970 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5971 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5972 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5974 printf (_("Key to Flags:\n\
5975 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5976 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5977 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5984 get_group_flags (unsigned int flags
)
5986 static char buff
[32];
5996 snprintf (buff
, sizeof (buff
), _("[<unknown>: 0x%x] "), flags
);
6003 process_section_groups (FILE * file
)
6005 Elf_Internal_Shdr
* section
;
6007 struct group
* group
;
6008 Elf_Internal_Shdr
* symtab_sec
;
6009 Elf_Internal_Shdr
* strtab_sec
;
6010 Elf_Internal_Sym
* symtab
;
6011 unsigned long num_syms
;
6015 /* Don't process section groups unless needed. */
6016 if (!do_unwind
&& !do_section_groups
)
6019 if (elf_header
.e_shnum
== 0)
6021 if (do_section_groups
)
6022 printf (_("\nThere are no sections to group in this file.\n"));
6027 if (section_headers
== NULL
)
6029 error (_("Section headers are not available!\n"));
6030 /* PR 13622: This can happen with a corrupt ELF header. */
6034 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6035 sizeof (struct group
*));
6037 if (section_headers_groups
== NULL
)
6039 error (_("Out of memory reading %u section group headers\n"),
6040 elf_header
.e_shnum
);
6044 /* Scan the sections for the group section. */
6046 for (i
= 0, section
= section_headers
;
6047 i
< elf_header
.e_shnum
;
6049 if (section
->sh_type
== SHT_GROUP
)
6052 if (group_count
== 0)
6054 if (do_section_groups
)
6055 printf (_("\nThere are no section groups in this file.\n"));
6060 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6062 if (section_groups
== NULL
)
6064 error (_("Out of memory reading %lu groups\n"),
6065 (unsigned long) group_count
);
6075 for (i
= 0, section
= section_headers
, group
= section_groups
;
6076 i
< elf_header
.e_shnum
;
6079 if (section
->sh_type
== SHT_GROUP
)
6081 const char * name
= printable_section_name (section
);
6082 const char * group_name
;
6083 unsigned char * start
;
6084 unsigned char * indices
;
6085 unsigned int entry
, j
, size
;
6086 Elf_Internal_Shdr
* sec
;
6087 Elf_Internal_Sym
* sym
;
6089 /* Get the symbol table. */
6090 if (section
->sh_link
>= elf_header
.e_shnum
6091 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6094 error (_("Bad sh_link in group section `%s'\n"), name
);
6098 if (symtab_sec
!= sec
)
6103 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6108 error (_("Corrupt header in group section `%s'\n"), name
);
6112 if (section
->sh_info
>= num_syms
)
6114 error (_("Bad sh_info in group section `%s'\n"), name
);
6118 sym
= symtab
+ section
->sh_info
;
6120 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6122 if (sym
->st_shndx
== 0
6123 || sym
->st_shndx
>= elf_header
.e_shnum
)
6125 error (_("Bad sh_info in group section `%s'\n"), name
);
6129 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6138 /* Get the string table. */
6139 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6148 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6154 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6155 1, strtab_sec
->sh_size
,
6157 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6159 group_name
= sym
->st_name
< strtab_size
6160 ? strtab
+ sym
->st_name
: _("<corrupt>");
6163 /* PR 17531: file: loop. */
6164 if (section
->sh_entsize
> section
->sh_size
)
6166 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6167 printable_section_name (section
),
6168 (unsigned long) section
->sh_entsize
,
6169 (unsigned long) section
->sh_size
);
6173 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6174 1, section
->sh_size
,
6180 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6181 entry
= byte_get (indices
, 4);
6184 if (do_section_groups
)
6186 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6187 get_group_flags (entry
), i
, name
, group_name
, size
);
6189 printf (_(" [Index] Name\n"));
6192 group
->group_index
= i
;
6194 for (j
= 0; j
< size
; j
++)
6196 struct group_list
* g
;
6198 entry
= byte_get (indices
, 4);
6201 if (entry
>= elf_header
.e_shnum
)
6203 static unsigned num_group_errors
= 0;
6205 if (num_group_errors
++ < 10)
6207 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6208 entry
, i
, elf_header
.e_shnum
- 1);
6209 if (num_group_errors
== 10)
6210 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6215 if (section_headers_groups
[entry
] != NULL
)
6219 static unsigned num_errs
= 0;
6221 if (num_errs
++ < 10)
6223 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6225 section_headers_groups
[entry
]->group_index
);
6227 warn (_("Further error messages about already contained group sections suppressed\n"));
6233 /* Intel C/C++ compiler may put section 0 in a
6234 section group. We just warn it the first time
6235 and ignore it afterwards. */
6236 static int warned
= 0;
6239 error (_("section 0 in group section [%5u]\n"),
6240 section_headers_groups
[entry
]->group_index
);
6246 section_headers_groups
[entry
] = group
;
6248 if (do_section_groups
)
6250 sec
= section_headers
+ entry
;
6251 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6254 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6255 g
->section_index
= entry
;
6256 g
->next
= group
->root
;
6274 /* Data used to display dynamic fixups. */
6276 struct ia64_vms_dynfixup
6278 bfd_vma needed_ident
; /* Library ident number. */
6279 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6280 bfd_vma fixup_needed
; /* Index of the library. */
6281 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6282 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6285 /* Data used to display dynamic relocations. */
6287 struct ia64_vms_dynimgrela
6289 bfd_vma img_rela_cnt
; /* Number of relocations. */
6290 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6293 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6297 dump_ia64_vms_dynamic_fixups (FILE *file
, struct ia64_vms_dynfixup
*fixup
,
6298 const char *strtab
, unsigned int strtab_sz
)
6300 Elf64_External_VMS_IMAGE_FIXUP
*imfs
;
6302 const char *lib_name
;
6304 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6305 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6306 _("dynamic section image fixups"));
6310 if (fixup
->needed
< strtab_sz
)
6311 lib_name
= strtab
+ fixup
->needed
;
6314 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6315 (unsigned long) fixup
->needed
);
6318 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6319 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6321 (_("Seg Offset Type SymVec DataType\n"));
6323 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6328 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6329 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6330 type
= BYTE_GET (imfs
[i
].type
);
6331 rtype
= elf_ia64_reloc_type (type
);
6333 printf (" 0x%08x ", type
);
6335 printf (" %-32s ", rtype
);
6336 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6337 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6343 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6346 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6348 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6351 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6352 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6353 _("dynamic section image relocations"));
6357 printf (_("\nImage relocs\n"));
6359 (_("Seg Offset Type Addend Seg Sym Off\n"));
6361 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6366 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6367 printf ("%08" BFD_VMA_FMT
"x ",
6368 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6369 type
= BYTE_GET (imrs
[i
].type
);
6370 rtype
= elf_ia64_reloc_type (type
);
6372 printf ("0x%08x ", type
);
6374 printf ("%-31s ", rtype
);
6375 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6376 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6377 printf ("%08" BFD_VMA_FMT
"x\n",
6378 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6384 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6387 process_ia64_vms_dynamic_relocs (FILE *file
)
6389 struct ia64_vms_dynfixup fixup
;
6390 struct ia64_vms_dynimgrela imgrela
;
6391 Elf_Internal_Dyn
*entry
;
6393 bfd_vma strtab_off
= 0;
6394 bfd_vma strtab_sz
= 0;
6395 char *strtab
= NULL
;
6397 memset (&fixup
, 0, sizeof (fixup
));
6398 memset (&imgrela
, 0, sizeof (imgrela
));
6400 /* Note: the order of the entries is specified by the OpenVMS specs. */
6401 for (entry
= dynamic_section
;
6402 entry
< dynamic_section
+ dynamic_nent
;
6405 switch (entry
->d_tag
)
6407 case DT_IA_64_VMS_STRTAB_OFFSET
:
6408 strtab_off
= entry
->d_un
.d_val
;
6411 strtab_sz
= entry
->d_un
.d_val
;
6413 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6414 1, strtab_sz
, _("dynamic string section"));
6417 case DT_IA_64_VMS_NEEDED_IDENT
:
6418 fixup
.needed_ident
= entry
->d_un
.d_val
;
6421 fixup
.needed
= entry
->d_un
.d_val
;
6423 case DT_IA_64_VMS_FIXUP_NEEDED
:
6424 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6426 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6427 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6429 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6430 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6432 dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
);
6435 case DT_IA_64_VMS_IMG_RELA_CNT
:
6436 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6438 case DT_IA_64_VMS_IMG_RELA_OFF
:
6439 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6441 dump_ia64_vms_dynamic_relocs (file
, &imgrela
);
6461 } dynamic_relocations
[] =
6463 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6464 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6465 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6468 /* Process the reloc section. */
6471 process_relocs (FILE * file
)
6473 unsigned long rel_size
;
6474 unsigned long rel_offset
;
6480 if (do_using_dynamic
)
6484 int has_dynamic_reloc
;
6487 has_dynamic_reloc
= 0;
6489 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
6491 is_rela
= dynamic_relocations
[i
].rela
;
6492 name
= dynamic_relocations
[i
].name
;
6493 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
6494 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
6496 has_dynamic_reloc
|= rel_size
;
6498 if (is_rela
== UNKNOWN
)
6500 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
6501 switch (dynamic_info
[DT_PLTREL
])
6515 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6516 name
, rel_offset
, rel_size
);
6518 dump_relocations (file
,
6519 offset_from_vma (file
, rel_offset
, rel_size
),
6521 dynamic_symbols
, num_dynamic_syms
,
6522 dynamic_strings
, dynamic_strings_length
,
6528 has_dynamic_reloc
|= process_ia64_vms_dynamic_relocs (file
);
6530 if (! has_dynamic_reloc
)
6531 printf (_("\nThere are no dynamic relocations in this file.\n"));
6535 Elf_Internal_Shdr
* section
;
6539 for (i
= 0, section
= section_headers
;
6540 i
< elf_header
.e_shnum
;
6543 if ( section
->sh_type
!= SHT_RELA
6544 && section
->sh_type
!= SHT_REL
)
6547 rel_offset
= section
->sh_offset
;
6548 rel_size
= section
->sh_size
;
6552 Elf_Internal_Shdr
* strsec
;
6555 printf (_("\nRelocation section "));
6557 if (string_table
== NULL
)
6558 printf ("%d", section
->sh_name
);
6560 printf ("'%s'", printable_section_name (section
));
6562 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6563 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
6565 is_rela
= section
->sh_type
== SHT_RELA
;
6567 if (section
->sh_link
!= 0
6568 && section
->sh_link
< elf_header
.e_shnum
)
6570 Elf_Internal_Shdr
* symsec
;
6571 Elf_Internal_Sym
* symtab
;
6572 unsigned long nsyms
;
6573 unsigned long strtablen
= 0;
6574 char * strtab
= NULL
;
6576 symsec
= section_headers
+ section
->sh_link
;
6577 if (symsec
->sh_type
!= SHT_SYMTAB
6578 && symsec
->sh_type
!= SHT_DYNSYM
)
6581 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
6586 if (symsec
->sh_link
!= 0
6587 && symsec
->sh_link
< elf_header
.e_shnum
)
6589 strsec
= section_headers
+ symsec
->sh_link
;
6591 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6594 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
6597 dump_relocations (file
, rel_offset
, rel_size
,
6598 symtab
, nsyms
, strtab
, strtablen
,
6600 symsec
->sh_type
== SHT_DYNSYM
);
6606 dump_relocations (file
, rel_offset
, rel_size
,
6607 NULL
, 0, NULL
, 0, is_rela
, 0);
6614 printf (_("\nThere are no relocations in this file.\n"));
6620 /* An absolute address consists of a section and an offset. If the
6621 section is NULL, the offset itself is the address, otherwise, the
6622 address equals to LOAD_ADDRESS(section) + offset. */
6626 unsigned short section
;
6630 #define ABSADDR(a) \
6632 ? section_headers [(a).section].sh_addr + (a).offset \
6635 /* Find the nearest symbol at or below ADDR. Returns the symbol
6636 name, if found, and the offset from the symbol to ADDR. */
6639 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
6640 unsigned long nsyms
,
6641 const char * strtab
,
6642 unsigned long strtab_size
,
6643 struct absaddr addr
,
6644 const char ** symname
,
6647 bfd_vma dist
= 0x100000;
6648 Elf_Internal_Sym
* sym
;
6649 Elf_Internal_Sym
* beg
;
6650 Elf_Internal_Sym
* end
;
6651 Elf_Internal_Sym
* best
= NULL
;
6653 REMOVE_ARCH_BITS (addr
.offset
);
6655 end
= symtab
+ nsyms
;
6661 sym
= beg
+ (end
- beg
) / 2;
6663 value
= sym
->st_value
;
6664 REMOVE_ARCH_BITS (value
);
6666 if (sym
->st_name
!= 0
6667 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
6668 && addr
.offset
>= value
6669 && addr
.offset
- value
< dist
)
6672 dist
= addr
.offset
- value
;
6677 if (addr
.offset
< value
)
6685 *symname
= (best
->st_name
>= strtab_size
6686 ? _("<corrupt>") : strtab
+ best
->st_name
);
6692 *offset
= addr
.offset
;
6696 symcmp (const void *p
, const void *q
)
6698 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
6699 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
6701 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
6704 /* Process the unwind section. */
6706 #include "unwind-ia64.h"
6708 struct ia64_unw_table_entry
6710 struct absaddr start
;
6712 struct absaddr info
;
6715 struct ia64_unw_aux_info
6717 struct ia64_unw_table_entry
*table
; /* Unwind table. */
6718 unsigned long table_len
; /* Length of unwind table. */
6719 unsigned char * info
; /* Unwind info. */
6720 unsigned long info_size
; /* Size of unwind info. */
6721 bfd_vma info_addr
; /* Starting address of unwind info. */
6722 bfd_vma seg_base
; /* Starting address of segment. */
6723 Elf_Internal_Sym
* symtab
; /* The symbol table. */
6724 unsigned long nsyms
; /* Number of symbols. */
6725 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
6726 unsigned long nfuns
; /* Number of entries in funtab. */
6727 char * strtab
; /* The string table. */
6728 unsigned long strtab_size
; /* Size of string table. */
6732 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
6734 struct ia64_unw_table_entry
* tp
;
6735 unsigned long j
, nfuns
;
6738 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
6739 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
6740 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
6741 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
6743 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
6745 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
6749 const unsigned char * dp
;
6750 const unsigned char * head
;
6751 const unsigned char * end
;
6752 const char * procname
;
6754 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
6755 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
6757 fputs ("\n<", stdout
);
6761 fputs (procname
, stdout
);
6764 printf ("+%lx", (unsigned long) offset
);
6767 fputs (">: [", stdout
);
6768 print_vma (tp
->start
.offset
, PREFIX_HEX
);
6769 fputc ('-', stdout
);
6770 print_vma (tp
->end
.offset
, PREFIX_HEX
);
6771 printf ("], info at +0x%lx\n",
6772 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
6774 /* PR 17531: file: 86232b32. */
6775 if (aux
->info
== NULL
)
6778 /* PR 17531: file: 0997b4d1. */
6779 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
6781 warn (_("Invalid offset %lx in table entry %ld\n"),
6782 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
6786 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
6787 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
6789 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6790 (unsigned) UNW_VER (stamp
),
6791 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
6792 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
6793 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
6794 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
6796 if (UNW_VER (stamp
) != 1)
6798 printf (_("\tUnknown version.\n"));
6803 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
6804 /* PR 17531: file: 16ceda89. */
6805 if (end
> aux
->info
+ aux
->info_size
)
6806 end
= aux
->info
+ aux
->info_size
;
6807 for (dp
= head
+ 8; dp
< end
;)
6808 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
6815 slurp_ia64_unwind_table (FILE * file
,
6816 struct ia64_unw_aux_info
* aux
,
6817 Elf_Internal_Shdr
* sec
)
6819 unsigned long size
, nrelas
, i
;
6820 Elf_Internal_Phdr
* seg
;
6821 struct ia64_unw_table_entry
* tep
;
6822 Elf_Internal_Shdr
* relsec
;
6823 Elf_Internal_Rela
* rela
;
6824 Elf_Internal_Rela
* rp
;
6825 unsigned char * table
;
6827 Elf_Internal_Sym
* sym
;
6828 const char * relname
;
6832 /* First, find the starting address of the segment that includes
6835 if (elf_header
.e_phnum
)
6837 if (! get_program_headers (file
))
6840 for (seg
= program_headers
;
6841 seg
< program_headers
+ elf_header
.e_phnum
;
6844 if (seg
->p_type
!= PT_LOAD
)
6847 if (sec
->sh_addr
>= seg
->p_vaddr
6848 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
6850 aux
->seg_base
= seg
->p_vaddr
;
6856 /* Second, build the unwind table from the contents of the unwind section: */
6857 size
= sec
->sh_size
;
6858 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
6863 aux
->table_len
= size
/ (3 * eh_addr_size
);
6864 aux
->table
= (struct ia64_unw_table_entry
*)
6865 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
6868 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
6870 tep
->start
.section
= SHN_UNDEF
;
6871 tep
->end
.section
= SHN_UNDEF
;
6872 tep
->info
.section
= SHN_UNDEF
;
6873 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6874 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6875 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
6876 tep
->start
.offset
+= aux
->seg_base
;
6877 tep
->end
.offset
+= aux
->seg_base
;
6878 tep
->info
.offset
+= aux
->seg_base
;
6882 /* Third, apply any relocations to the unwind table: */
6883 for (relsec
= section_headers
;
6884 relsec
< section_headers
+ elf_header
.e_shnum
;
6887 if (relsec
->sh_type
!= SHT_RELA
6888 || relsec
->sh_info
>= elf_header
.e_shnum
6889 || section_headers
+ relsec
->sh_info
!= sec
)
6892 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
6901 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
6903 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
6904 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
6906 /* PR 17531: file: 9fa67536. */
6907 if (relname
== NULL
)
6909 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
6913 if (! const_strneq (relname
, "R_IA64_SEGREL"))
6915 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
6919 i
= rp
->r_offset
/ (3 * eh_addr_size
);
6921 /* PR 17531: file: 5bc8d9bf. */
6922 if (i
>= aux
->table_len
)
6924 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
6928 switch (rp
->r_offset
/ eh_addr_size
% 3)
6931 aux
->table
[i
].start
.section
= sym
->st_shndx
;
6932 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
6935 aux
->table
[i
].end
.section
= sym
->st_shndx
;
6936 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
6939 aux
->table
[i
].info
.section
= sym
->st_shndx
;
6940 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
6954 ia64_process_unwind (FILE * file
)
6956 Elf_Internal_Shdr
* sec
;
6957 Elf_Internal_Shdr
* unwsec
= NULL
;
6958 Elf_Internal_Shdr
* strsec
;
6959 unsigned long i
, unwcount
= 0, unwstart
= 0;
6960 struct ia64_unw_aux_info aux
;
6962 memset (& aux
, 0, sizeof (aux
));
6964 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
6966 if (sec
->sh_type
== SHT_SYMTAB
6967 && sec
->sh_link
< elf_header
.e_shnum
)
6969 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
6971 strsec
= section_headers
+ sec
->sh_link
;
6972 if (aux
.strtab
!= NULL
)
6974 error (_("Multiple auxillary string tables encountered\n"));
6977 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
6980 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
6982 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
6987 printf (_("\nThere are no unwind sections in this file.\n"));
6989 while (unwcount
-- > 0)
6994 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
6995 i
< elf_header
.e_shnum
; ++i
, ++sec
)
6996 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7001 /* We have already counted the number of SHT_IA64_UNWIND
7002 sections so the loop above should never fail. */
7003 assert (unwsec
!= NULL
);
7006 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7008 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7010 /* We need to find which section group it is in. */
7011 struct group_list
* g
;
7013 if (section_headers_groups
== NULL
7014 || section_headers_groups
[i
] == NULL
)
7015 i
= elf_header
.e_shnum
;
7018 g
= section_headers_groups
[i
]->root
;
7020 for (; g
!= NULL
; g
= g
->next
)
7022 sec
= section_headers
+ g
->section_index
;
7024 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7029 i
= elf_header
.e_shnum
;
7032 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7034 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7035 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7036 suffix
= SECTION_NAME (unwsec
) + len
;
7037 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7039 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7040 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7045 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7046 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7047 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7048 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7050 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7051 suffix
= SECTION_NAME (unwsec
) + len
;
7052 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7054 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7055 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7059 if (i
== elf_header
.e_shnum
)
7061 printf (_("\nCould not find unwind info section for "));
7063 if (string_table
== NULL
)
7064 printf ("%d", unwsec
->sh_name
);
7066 printf ("'%s'", printable_section_name (unwsec
));
7070 aux
.info_addr
= sec
->sh_addr
;
7071 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7074 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7076 printf (_("\nUnwind section "));
7078 if (string_table
== NULL
)
7079 printf ("%d", unwsec
->sh_name
);
7081 printf ("'%s'", printable_section_name (unwsec
));
7083 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7084 (unsigned long) unwsec
->sh_offset
,
7085 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7087 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7088 && aux
.table_len
> 0)
7089 dump_ia64_unwind (& aux
);
7092 free ((char *) aux
.table
);
7094 free ((char *) aux
.info
);
7103 free ((char *) aux
.strtab
);
7106 struct hppa_unw_table_entry
7108 struct absaddr start
;
7110 unsigned int Cannot_unwind
:1; /* 0 */
7111 unsigned int Millicode
:1; /* 1 */
7112 unsigned int Millicode_save_sr0
:1; /* 2 */
7113 unsigned int Region_description
:2; /* 3..4 */
7114 unsigned int reserved1
:1; /* 5 */
7115 unsigned int Entry_SR
:1; /* 6 */
7116 unsigned int Entry_FR
:4; /* number saved */ /* 7..10 */
7117 unsigned int Entry_GR
:5; /* number saved */ /* 11..15 */
7118 unsigned int Args_stored
:1; /* 16 */
7119 unsigned int Variable_Frame
:1; /* 17 */
7120 unsigned int Separate_Package_Body
:1; /* 18 */
7121 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7122 unsigned int Stack_Overflow_Check
:1; /* 20 */
7123 unsigned int Two_Instruction_SP_Increment
:1;/* 21 */
7124 unsigned int Ada_Region
:1; /* 22 */
7125 unsigned int cxx_info
:1; /* 23 */
7126 unsigned int cxx_try_catch
:1; /* 24 */
7127 unsigned int sched_entry_seq
:1; /* 25 */
7128 unsigned int reserved2
:1; /* 26 */
7129 unsigned int Save_SP
:1; /* 27 */
7130 unsigned int Save_RP
:1; /* 28 */
7131 unsigned int Save_MRP_in_frame
:1; /* 29 */
7132 unsigned int extn_ptr_defined
:1; /* 30 */
7133 unsigned int Cleanup_defined
:1; /* 31 */
7135 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7136 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7137 unsigned int Large_frame
:1; /* 2 */
7138 unsigned int Pseudo_SP_Set
:1; /* 3 */
7139 unsigned int reserved4
:1; /* 4 */
7140 unsigned int Total_frame_size
:27; /* 5..31 */
7143 struct hppa_unw_aux_info
7145 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7146 unsigned long table_len
; /* Length of unwind table. */
7147 bfd_vma seg_base
; /* Starting address of segment. */
7148 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7149 unsigned long nsyms
; /* Number of symbols. */
7150 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7151 unsigned long nfuns
; /* Number of entries in funtab. */
7152 char * strtab
; /* The string table. */
7153 unsigned long strtab_size
; /* Size of string table. */
7157 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7159 struct hppa_unw_table_entry
* tp
;
7160 unsigned long j
, nfuns
;
7162 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7163 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7164 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7165 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7167 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7169 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7172 const char * procname
;
7174 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7175 aux
->strtab_size
, tp
->start
, &procname
,
7178 fputs ("\n<", stdout
);
7182 fputs (procname
, stdout
);
7185 printf ("+%lx", (unsigned long) offset
);
7188 fputs (">: [", stdout
);
7189 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7190 fputc ('-', stdout
);
7191 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7194 #define PF(_m) if (tp->_m) printf (#_m " ");
7195 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7198 PF(Millicode_save_sr0
);
7199 /* PV(Region_description); */
7205 PF(Separate_Package_Body
);
7206 PF(Frame_Extension_Millicode
);
7207 PF(Stack_Overflow_Check
);
7208 PF(Two_Instruction_SP_Increment
);
7212 PF(sched_entry_seq
);
7215 PF(Save_MRP_in_frame
);
7216 PF(extn_ptr_defined
);
7217 PF(Cleanup_defined
);
7218 PF(MPE_XL_interrupt_marker
);
7219 PF(HP_UX_interrupt_marker
);
7222 PV(Total_frame_size
);
7233 slurp_hppa_unwind_table (FILE * file
,
7234 struct hppa_unw_aux_info
* aux
,
7235 Elf_Internal_Shdr
* sec
)
7237 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7238 Elf_Internal_Phdr
* seg
;
7239 struct hppa_unw_table_entry
* tep
;
7240 Elf_Internal_Shdr
* relsec
;
7241 Elf_Internal_Rela
* rela
;
7242 Elf_Internal_Rela
* rp
;
7243 unsigned char * table
;
7245 Elf_Internal_Sym
* sym
;
7246 const char * relname
;
7248 /* First, find the starting address of the segment that includes
7251 if (elf_header
.e_phnum
)
7253 if (! get_program_headers (file
))
7256 for (seg
= program_headers
;
7257 seg
< program_headers
+ elf_header
.e_phnum
;
7260 if (seg
->p_type
!= PT_LOAD
)
7263 if (sec
->sh_addr
>= seg
->p_vaddr
7264 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7266 aux
->seg_base
= seg
->p_vaddr
;
7272 /* Second, build the unwind table from the contents of the unwind
7274 size
= sec
->sh_size
;
7275 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7281 nentries
= size
/ unw_ent_size
;
7282 size
= unw_ent_size
* nentries
;
7284 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7285 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7287 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7289 unsigned int tmp1
, tmp2
;
7291 tep
->start
.section
= SHN_UNDEF
;
7292 tep
->end
.section
= SHN_UNDEF
;
7294 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7295 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7296 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7297 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7299 tep
->start
.offset
+= aux
->seg_base
;
7300 tep
->end
.offset
+= aux
->seg_base
;
7302 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7303 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7304 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7305 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7306 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7307 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7308 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7309 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7310 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7311 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7312 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7313 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7314 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7315 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7316 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7317 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7318 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7319 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7320 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7321 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7322 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7323 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7324 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7325 tep
->Cleanup_defined
= tmp1
& 0x1;
7327 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7328 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7329 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7330 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7331 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7332 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7336 /* Third, apply any relocations to the unwind table. */
7337 for (relsec
= section_headers
;
7338 relsec
< section_headers
+ elf_header
.e_shnum
;
7341 if (relsec
->sh_type
!= SHT_RELA
7342 || relsec
->sh_info
>= elf_header
.e_shnum
7343 || section_headers
+ relsec
->sh_info
!= sec
)
7346 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7350 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7352 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7353 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7355 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7356 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7358 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7362 i
= rp
->r_offset
/ unw_ent_size
;
7364 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7367 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7368 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7371 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7372 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7382 aux
->table_len
= nentries
;
7388 hppa_process_unwind (FILE * file
)
7390 struct hppa_unw_aux_info aux
;
7391 Elf_Internal_Shdr
* unwsec
= NULL
;
7392 Elf_Internal_Shdr
* strsec
;
7393 Elf_Internal_Shdr
* sec
;
7396 if (string_table
== NULL
)
7399 memset (& aux
, 0, sizeof (aux
));
7401 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7403 if (sec
->sh_type
== SHT_SYMTAB
7404 && sec
->sh_link
< elf_header
.e_shnum
)
7406 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7408 strsec
= section_headers
+ sec
->sh_link
;
7409 if (aux
.strtab
!= NULL
)
7411 error (_("Multiple auxillary string tables encountered\n"));
7414 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7417 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7419 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7424 printf (_("\nThere are no unwind sections in this file.\n"));
7426 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7428 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7430 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7431 printable_section_name (sec
),
7432 (unsigned long) sec
->sh_offset
,
7433 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7435 slurp_hppa_unwind_table (file
, &aux
, sec
);
7436 if (aux
.table_len
> 0)
7437 dump_hppa_unwind (&aux
);
7440 free ((char *) aux
.table
);
7448 free ((char *) aux
.strtab
);
7453 unsigned char * data
; /* The unwind data. */
7454 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7455 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7456 unsigned long nrelas
; /* The number of relocations. */
7457 unsigned int rel_type
; /* REL or RELA ? */
7458 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7461 struct arm_unw_aux_info
7463 FILE * file
; /* The file containing the unwind sections. */
7464 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
7465 unsigned long nsyms
; /* Number of symbols. */
7466 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7467 unsigned long nfuns
; /* Number of these symbols. */
7468 char * strtab
; /* The file's string table. */
7469 unsigned long strtab_size
; /* Size of string table. */
7473 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
7474 bfd_vma fn
, struct absaddr addr
)
7476 const char *procname
;
7479 if (addr
.section
== SHN_UNDEF
)
7482 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7483 aux
->strtab_size
, addr
, &procname
,
7486 print_vma (fn
, PREFIX_HEX
);
7490 fputs (" <", stdout
);
7491 fputs (procname
, stdout
);
7494 printf ("+0x%lx", (unsigned long) sym_offset
);
7495 fputc ('>', stdout
);
7502 arm_free_section (struct arm_section
*arm_sec
)
7504 if (arm_sec
->data
!= NULL
)
7505 free (arm_sec
->data
);
7507 if (arm_sec
->rela
!= NULL
)
7508 free (arm_sec
->rela
);
7511 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7512 cached section and install SEC instead.
7513 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7514 and return its valued in * WORDP, relocating if necessary.
7515 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7516 relocation's offset in ADDR.
7517 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7518 into the string table of the symbol associated with the reloc. If no
7519 reloc was applied store -1 there.
7520 5) Return TRUE upon success, FALSE otherwise. */
7523 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
7524 struct arm_section
* arm_sec
,
7525 Elf_Internal_Shdr
* sec
,
7526 bfd_vma word_offset
,
7527 unsigned int * wordp
,
7528 struct absaddr
* addr
,
7531 Elf_Internal_Rela
*rp
;
7532 Elf_Internal_Sym
*sym
;
7533 const char * relname
;
7535 bfd_boolean wrapped
;
7537 if (sec
== NULL
|| arm_sec
== NULL
)
7540 addr
->section
= SHN_UNDEF
;
7543 if (sym_name
!= NULL
)
7544 *sym_name
= (bfd_vma
) -1;
7546 /* If necessary, update the section cache. */
7547 if (sec
!= arm_sec
->sec
)
7549 Elf_Internal_Shdr
*relsec
;
7551 arm_free_section (arm_sec
);
7554 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
7555 sec
->sh_size
, _("unwind data"));
7556 arm_sec
->rela
= NULL
;
7557 arm_sec
->nrelas
= 0;
7559 for (relsec
= section_headers
;
7560 relsec
< section_headers
+ elf_header
.e_shnum
;
7563 if (relsec
->sh_info
>= elf_header
.e_shnum
7564 || section_headers
+ relsec
->sh_info
!= sec
7565 /* PR 15745: Check the section type as well. */
7566 || (relsec
->sh_type
!= SHT_REL
7567 && relsec
->sh_type
!= SHT_RELA
))
7570 arm_sec
->rel_type
= relsec
->sh_type
;
7571 if (relsec
->sh_type
== SHT_REL
)
7573 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
7575 & arm_sec
->rela
, & arm_sec
->nrelas
))
7578 else /* relsec->sh_type == SHT_RELA */
7580 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
7582 & arm_sec
->rela
, & arm_sec
->nrelas
))
7588 arm_sec
->next_rela
= arm_sec
->rela
;
7591 /* If there is no unwind data we can do nothing. */
7592 if (arm_sec
->data
== NULL
)
7595 /* If the offset is invalid then fail. */
7596 if (word_offset
> (sec
->sh_size
- 4)
7598 || (sec
->sh_size
< 5 && word_offset
>= sec
->sh_size
)
7599 || ((bfd_signed_vma
) word_offset
) < 0)
7602 /* Get the word at the required offset. */
7603 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
7605 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7606 if (arm_sec
->rela
== NULL
)
7612 /* Look through the relocs to find the one that applies to the provided offset. */
7614 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
7616 bfd_vma prelval
, offset
;
7618 if (rp
->r_offset
> word_offset
&& !wrapped
)
7623 if (rp
->r_offset
> word_offset
)
7626 if (rp
->r_offset
& 3)
7628 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7629 (unsigned long) rp
->r_offset
);
7633 if (rp
->r_offset
< word_offset
)
7636 /* PR 17531: file: 027-161405-0.004 */
7637 if (aux
->symtab
== NULL
)
7640 if (arm_sec
->rel_type
== SHT_REL
)
7642 offset
= word
& 0x7fffffff;
7643 if (offset
& 0x40000000)
7644 offset
|= ~ (bfd_vma
) 0x7fffffff;
7646 else if (arm_sec
->rel_type
== SHT_RELA
)
7647 offset
= rp
->r_addend
;
7650 error (_("Unknown section relocation type %d encountered\n"),
7655 /* PR 17531 file: 027-1241568-0.004. */
7656 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
7658 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7659 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
7663 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
7664 offset
+= sym
->st_value
;
7665 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
7667 /* Check that we are processing the expected reloc type. */
7668 if (elf_header
.e_machine
== EM_ARM
)
7670 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7671 if (relname
== NULL
)
7673 warn (_("Skipping unknown ARM relocation type: %d\n"),
7674 (int) ELF32_R_TYPE (rp
->r_info
));
7678 if (streq (relname
, "R_ARM_NONE"))
7681 if (! streq (relname
, "R_ARM_PREL31"))
7683 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
7687 else if (elf_header
.e_machine
== EM_TI_C6000
)
7689 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
7690 if (relname
== NULL
)
7692 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7693 (int) ELF32_R_TYPE (rp
->r_info
));
7697 if (streq (relname
, "R_C6000_NONE"))
7700 if (! streq (relname
, "R_C6000_PREL31"))
7702 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
7710 /* This function currently only supports ARM and TI unwinders. */
7711 warn (_("Only TI and ARM unwinders are currently supported\n"));
7715 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
7716 addr
->section
= sym
->st_shndx
;
7717 addr
->offset
= offset
;
7720 * sym_name
= sym
->st_name
;
7725 arm_sec
->next_rela
= rp
;
7730 static const char *tic6x_unwind_regnames
[16] =
7732 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7733 "A14", "A13", "A12", "A11", "A10",
7734 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7738 decode_tic6x_unwind_regmask (unsigned int mask
)
7742 for (i
= 12; mask
; mask
>>= 1, i
--)
7746 fputs (tic6x_unwind_regnames
[i
], stdout
);
7748 fputs (", ", stdout
);
7754 if (remaining == 0 && more_words) \
7757 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7758 data_offset, & word, & addr, NULL)) \
7764 #define GET_OP(OP) \
7769 (OP) = word >> 24; \
7774 printf (_("[Truncated opcode]\n")); \
7777 printf ("0x%02x ", OP)
7780 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7782 unsigned int remaining
,
7783 unsigned int more_words
,
7784 bfd_vma data_offset
,
7785 Elf_Internal_Shdr
* data_sec
,
7786 struct arm_section
* data_arm_sec
)
7788 struct absaddr addr
;
7790 /* Decode the unwinding instructions. */
7793 unsigned int op
, op2
;
7802 printf (" 0x%02x ", op
);
7804 if ((op
& 0xc0) == 0x00)
7806 int offset
= ((op
& 0x3f) << 2) + 4;
7808 printf (" vsp = vsp + %d", offset
);
7810 else if ((op
& 0xc0) == 0x40)
7812 int offset
= ((op
& 0x3f) << 2) + 4;
7814 printf (" vsp = vsp - %d", offset
);
7816 else if ((op
& 0xf0) == 0x80)
7819 if (op
== 0x80 && op2
== 0)
7820 printf (_("Refuse to unwind"));
7823 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
7828 for (i
= 0; i
< 12; i
++)
7829 if (mask
& (1 << i
))
7835 printf ("r%d", 4 + i
);
7840 else if ((op
& 0xf0) == 0x90)
7842 if (op
== 0x9d || op
== 0x9f)
7843 printf (_(" [Reserved]"));
7845 printf (" vsp = r%d", op
& 0x0f);
7847 else if ((op
& 0xf0) == 0xa0)
7849 int end
= 4 + (op
& 0x07);
7854 for (i
= 4; i
<= end
; i
++)
7870 else if (op
== 0xb0)
7871 printf (_(" finish"));
7872 else if (op
== 0xb1)
7875 if (op2
== 0 || (op2
& 0xf0) != 0)
7876 printf (_("[Spare]"));
7879 unsigned int mask
= op2
& 0x0f;
7884 for (i
= 0; i
< 12; i
++)
7885 if (mask
& (1 << i
))
7896 else if (op
== 0xb2)
7898 unsigned char buf
[9];
7899 unsigned int i
, len
;
7900 unsigned long offset
;
7902 for (i
= 0; i
< sizeof (buf
); i
++)
7905 if ((buf
[i
] & 0x80) == 0)
7908 if (i
== sizeof (buf
))
7909 printf (_("corrupt change to vsp"));
7912 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
7913 assert (len
== i
+ 1);
7914 offset
= offset
* 4 + 0x204;
7915 printf ("vsp = vsp + %ld", offset
);
7918 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
7920 unsigned int first
, last
;
7927 printf ("pop {D%d", first
);
7929 printf ("-D%d", first
+ last
);
7932 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
7934 unsigned int count
= op
& 0x07;
7938 printf ("-D%d", 8 + count
);
7941 else if (op
>= 0xc0 && op
<= 0xc5)
7943 unsigned int count
= op
& 0x07;
7945 printf (" pop {wR10");
7947 printf ("-wR%d", 10 + count
);
7950 else if (op
== 0xc6)
7952 unsigned int first
, last
;
7957 printf ("pop {wR%d", first
);
7959 printf ("-wR%d", first
+ last
);
7962 else if (op
== 0xc7)
7965 if (op2
== 0 || (op2
& 0xf0) != 0)
7966 printf (_("[Spare]"));
7969 unsigned int mask
= op2
& 0x0f;
7974 for (i
= 0; i
< 4; i
++)
7975 if (mask
& (1 << i
))
7981 printf ("wCGR%d", i
);
7987 printf (_(" [unsupported opcode]"));
7993 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
7995 unsigned int remaining
,
7996 unsigned int more_words
,
7997 bfd_vma data_offset
,
7998 Elf_Internal_Shdr
* data_sec
,
7999 struct arm_section
* data_arm_sec
)
8001 struct absaddr addr
;
8003 /* Decode the unwinding instructions. */
8006 unsigned int op
, op2
;
8015 printf (" 0x%02x ", op
);
8017 if ((op
& 0xc0) == 0x00)
8019 int offset
= ((op
& 0x3f) << 3) + 8;
8020 printf (" sp = sp + %d", offset
);
8022 else if ((op
& 0xc0) == 0x80)
8025 if (op
== 0x80 && op2
== 0)
8026 printf (_("Refuse to unwind"));
8029 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8031 printf ("pop compact {");
8035 decode_tic6x_unwind_regmask (mask
);
8039 else if ((op
& 0xf0) == 0xc0)
8047 unsigned int offset
;
8051 /* Scan entire instruction first so that GET_OP output is not
8052 interleaved with disassembly. */
8054 for (i
= 0; nregs
< (op
& 0xf); i
++)
8060 regpos
[nregs
].offset
= i
* 2;
8061 regpos
[nregs
].reg
= reg
;
8068 regpos
[nregs
].offset
= i
* 2 + 1;
8069 regpos
[nregs
].reg
= reg
;
8074 printf (_("pop frame {"));
8076 for (i
= i
* 2; i
> 0; i
--)
8078 if (regpos
[reg
].offset
== i
- 1)
8080 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8087 fputs (name
, stdout
);
8094 else if (op
== 0xd0)
8095 printf (" MOV FP, SP");
8096 else if (op
== 0xd1)
8097 printf (" __c6xabi_pop_rts");
8098 else if (op
== 0xd2)
8100 unsigned char buf
[9];
8101 unsigned int i
, len
;
8102 unsigned long offset
;
8104 for (i
= 0; i
< sizeof (buf
); i
++)
8107 if ((buf
[i
] & 0x80) == 0)
8110 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8111 if (i
== sizeof (buf
))
8113 printf ("<corrupt sp adjust>\n");
8114 warn (_("Corrupt stack pointer adjustment detected\n"));
8118 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8119 assert (len
== i
+ 1);
8120 offset
= offset
* 8 + 0x408;
8121 printf (_("sp = sp + %ld"), offset
);
8123 else if ((op
& 0xf0) == 0xe0)
8125 if ((op
& 0x0f) == 7)
8128 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8132 printf (_(" [unsupported opcode]"));
8139 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8143 offset
= word
& 0x7fffffff;
8144 if (offset
& 0x40000000)
8145 offset
|= ~ (bfd_vma
) 0x7fffffff;
8147 if (elf_header
.e_machine
== EM_TI_C6000
)
8150 return offset
+ where
;
8154 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8156 unsigned int remaining
,
8157 bfd_vma data_offset
,
8158 Elf_Internal_Shdr
* data_sec
,
8159 struct arm_section
* data_arm_sec
)
8162 unsigned int more_words
= 0;
8163 struct absaddr addr
;
8164 bfd_vma sym_name
= (bfd_vma
) -1;
8168 /* Fetch the first word.
8169 Note - when decoding an object file the address extracted
8170 here will always be 0. So we also pass in the sym_name
8171 parameter so that we can find the symbol associated with
8172 the personality routine. */
8173 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8174 & word
, & addr
, & sym_name
))
8180 if ((word
& 0x80000000) == 0)
8182 /* Expand prel31 for personality routine. */
8184 const char *procname
;
8186 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8187 printf (_(" Personality routine: "));
8189 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8190 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8192 procname
= aux
->strtab
+ sym_name
;
8193 print_vma (fn
, PREFIX_HEX
);
8196 fputs (" <", stdout
);
8197 fputs (procname
, stdout
);
8198 fputc ('>', stdout
);
8202 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8203 fputc ('\n', stdout
);
8205 /* The GCC personality routines use the standard compact
8206 encoding, starting with one byte giving the number of
8208 if (procname
!= NULL
8209 && (const_strneq (procname
, "__gcc_personality_v0")
8210 || const_strneq (procname
, "__gxx_personality_v0")
8211 || const_strneq (procname
, "__gcj_personality_v0")
8212 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8219 printf (_(" [Truncated data]\n"));
8222 more_words
= word
>> 24;
8232 /* ARM EHABI Section 6.3:
8234 An exception-handling table entry for the compact model looks like:
8238 1 0 index Data for personalityRoutine[index] */
8240 if (elf_header
.e_machine
== EM_ARM
8241 && (word
& 0x70000000))
8242 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8244 per_index
= (word
>> 24) & 0x7f;
8245 printf (_(" Compact model index: %d\n"), per_index
);
8252 else if (per_index
< 3)
8254 more_words
= (word
>> 16) & 0xff;
8260 switch (elf_header
.e_machine
)
8265 decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8266 data_offset
, data_sec
, data_arm_sec
);
8270 warn (_("Unknown ARM compact model index encountered\n"));
8271 printf (_(" [reserved]\n"));
8278 decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8279 data_offset
, data_sec
, data_arm_sec
);
8281 else if (per_index
< 5)
8283 if (((word
>> 17) & 0x7f) == 0x7f)
8284 printf (_(" Restore stack from frame pointer\n"));
8286 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8287 printf (_(" Registers restored: "));
8289 printf (" (compact) ");
8290 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8292 printf (_(" Return register: %s\n"),
8293 tic6x_unwind_regnames
[word
& 0xf]);
8296 printf (_(" [reserved (%d)]\n"), per_index
);
8300 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8301 elf_header
.e_machine
);
8304 /* Decode the descriptors. Not implemented. */
8308 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8310 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8311 unsigned int i
, exidx_len
;
8312 unsigned long j
, nfuns
;
8314 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8315 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8316 exidx_len
= exidx_sec
->sh_size
/ 8;
8318 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8319 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8320 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8321 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8323 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8325 for (i
= 0; i
< exidx_len
; i
++)
8327 unsigned int exidx_fn
, exidx_entry
;
8328 struct absaddr fn_addr
, entry_addr
;
8331 fputc ('\n', stdout
);
8333 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8334 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8335 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8336 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8339 arm_free_section (& exidx_arm_sec
);
8340 arm_free_section (& extab_arm_sec
);
8344 /* ARM EHABI, Section 5:
8345 An index table entry consists of 2 words.
8346 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8347 if (exidx_fn
& 0x80000000)
8348 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8350 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8352 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8353 fputs (": ", stdout
);
8355 if (exidx_entry
== 1)
8357 print_vma (exidx_entry
, PREFIX_HEX
);
8358 fputs (" [cantunwind]\n", stdout
);
8360 else if (exidx_entry
& 0x80000000)
8362 print_vma (exidx_entry
, PREFIX_HEX
);
8363 fputc ('\n', stdout
);
8364 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8368 bfd_vma table
, table_offset
= 0;
8369 Elf_Internal_Shdr
*table_sec
;
8371 fputs ("@", stdout
);
8372 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8373 print_vma (table
, PREFIX_HEX
);
8376 /* Locate the matching .ARM.extab. */
8377 if (entry_addr
.section
!= SHN_UNDEF
8378 && entry_addr
.section
< elf_header
.e_shnum
)
8380 table_sec
= section_headers
+ entry_addr
.section
;
8381 table_offset
= entry_addr
.offset
;
8383 if (table_offset
> table_sec
->sh_size
8384 || ((bfd_signed_vma
) table_offset
) < 0)
8386 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8387 (unsigned long) table_offset
,
8388 printable_section_name (table_sec
));
8394 table_sec
= find_section_by_address (table
);
8395 if (table_sec
!= NULL
)
8396 table_offset
= table
- table_sec
->sh_addr
;
8398 if (table_sec
== NULL
)
8400 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8401 (unsigned long) table
);
8404 decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8412 arm_free_section (&exidx_arm_sec
);
8413 arm_free_section (&extab_arm_sec
);
8416 /* Used for both ARM and C6X unwinding tables. */
8419 arm_process_unwind (FILE *file
)
8421 struct arm_unw_aux_info aux
;
8422 Elf_Internal_Shdr
*unwsec
= NULL
;
8423 Elf_Internal_Shdr
*strsec
;
8424 Elf_Internal_Shdr
*sec
;
8426 unsigned int sec_type
;
8428 switch (elf_header
.e_machine
)
8431 sec_type
= SHT_ARM_EXIDX
;
8435 sec_type
= SHT_C6000_UNWIND
;
8439 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8440 elf_header
.e_machine
);
8444 if (string_table
== NULL
)
8447 memset (& aux
, 0, sizeof (aux
));
8450 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8452 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
8454 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
8456 strsec
= section_headers
+ sec
->sh_link
;
8458 /* PR binutils/17531 file: 011-12666-0.004. */
8459 if (aux
.strtab
!= NULL
)
8461 error (_("Multiple string tables found in file.\n"));
8464 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
8465 1, strsec
->sh_size
, _("string table"));
8466 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8468 else if (sec
->sh_type
== sec_type
)
8473 printf (_("\nThere are no unwind sections in this file.\n"));
8475 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
8477 if (sec
->sh_type
== sec_type
)
8479 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8480 printable_section_name (sec
),
8481 (unsigned long) sec
->sh_offset
,
8482 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
8484 dump_arm_unwind (&aux
, sec
);
8491 free ((char *) aux
.strtab
);
8495 process_unwind (FILE * file
)
8497 struct unwind_handler
8500 void (* handler
)(FILE *);
8503 { EM_ARM
, arm_process_unwind
},
8504 { EM_IA_64
, ia64_process_unwind
},
8505 { EM_PARISC
, hppa_process_unwind
},
8506 { EM_TI_C6000
, arm_process_unwind
},
8514 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
8515 if (elf_header
.e_machine
== handlers
[i
].machtype
)
8517 handlers
[i
].handler (file
);
8521 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8522 get_machine_name (elf_header
.e_machine
));
8526 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
8528 switch (entry
->d_tag
)
8531 if (entry
->d_un
.d_val
== 0)
8535 static const char * opts
[] =
8537 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8538 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8539 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8540 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8546 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
8547 if (entry
->d_un
.d_val
& (1 << cnt
))
8549 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
8555 case DT_MIPS_IVERSION
:
8556 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
8557 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
8561 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
8562 /* Note: coded this way so that there is a single string for translation. */
8563 printf (_("<corrupt: %s>"), buf
);
8567 case DT_MIPS_TIME_STAMP
:
8571 time_t atime
= entry
->d_un
.d_val
;
8573 tmp
= gmtime (&atime
);
8574 /* PR 17531: file: 6accc532. */
8576 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
8578 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
8579 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8580 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8581 printf (_("Time Stamp: %s"), timebuf
);
8585 case DT_MIPS_RLD_VERSION
:
8586 case DT_MIPS_LOCAL_GOTNO
:
8587 case DT_MIPS_CONFLICTNO
:
8588 case DT_MIPS_LIBLISTNO
:
8589 case DT_MIPS_SYMTABNO
:
8590 case DT_MIPS_UNREFEXTNO
:
8591 case DT_MIPS_HIPAGENO
:
8592 case DT_MIPS_DELTA_CLASS_NO
:
8593 case DT_MIPS_DELTA_INSTANCE_NO
:
8594 case DT_MIPS_DELTA_RELOC_NO
:
8595 case DT_MIPS_DELTA_SYM_NO
:
8596 case DT_MIPS_DELTA_CLASSSYM_NO
:
8597 case DT_MIPS_COMPACT_SIZE
:
8598 print_vma (entry
->d_un
.d_ptr
, DEC
);
8602 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8608 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
8610 switch (entry
->d_tag
)
8612 case DT_HP_DLD_FLAGS
:
8621 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
8622 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
8623 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
8624 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
8625 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
8626 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
8627 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
8628 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
8629 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
8630 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
8631 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
8632 { DT_HP_GST
, "HP_GST" },
8633 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
8634 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
8635 { DT_HP_NODELETE
, "HP_NODELETE" },
8636 { DT_HP_GROUP
, "HP_GROUP" },
8637 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
8641 bfd_vma val
= entry
->d_un
.d_val
;
8643 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
8644 if (val
& flags
[cnt
].bit
)
8648 fputs (flags
[cnt
].str
, stdout
);
8650 val
^= flags
[cnt
].bit
;
8653 if (val
!= 0 || first
)
8657 print_vma (val
, HEX
);
8663 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8671 /* VMS vs Unix time offset and factor. */
8673 #define VMS_EPOCH_OFFSET 35067168000000000LL
8674 #define VMS_GRANULARITY_FACTOR 10000000
8676 /* Display a VMS time in a human readable format. */
8679 print_vms_time (bfd_int64_t vmstime
)
8684 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
8685 tm
= gmtime (&unxtime
);
8686 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8687 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
8688 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
8693 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
8695 switch (entry
->d_tag
)
8697 case DT_IA_64_PLT_RESERVE
:
8698 /* First 3 slots reserved. */
8699 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8701 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
8704 case DT_IA_64_VMS_LINKTIME
:
8706 print_vms_time (entry
->d_un
.d_val
);
8710 case DT_IA_64_VMS_LNKFLAGS
:
8711 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8712 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
8713 printf (" CALL_DEBUG");
8714 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
8715 printf (" NOP0BUFS");
8716 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
8717 printf (" P0IMAGE");
8718 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
8719 printf (" MKTHREADS");
8720 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
8721 printf (" UPCALLS");
8722 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
8724 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
8725 printf (" INITIALIZE");
8726 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
8728 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
8729 printf (" EXE_INIT");
8730 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
8731 printf (" TBK_IN_IMG");
8732 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
8733 printf (" DBG_IN_IMG");
8734 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
8735 printf (" TBK_IN_DSF");
8736 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
8737 printf (" DBG_IN_DSF");
8738 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
8739 printf (" SIGNATURES");
8740 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
8741 printf (" REL_SEG_OFF");
8745 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
8752 get_32bit_dynamic_section (FILE * file
)
8754 Elf32_External_Dyn
* edyn
;
8755 Elf32_External_Dyn
* ext
;
8756 Elf_Internal_Dyn
* entry
;
8758 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8759 dynamic_size
, _("dynamic section"));
8763 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8764 might not have the luxury of section headers. Look for the DT_NULL
8765 terminator to determine the number of entries. */
8766 for (ext
= edyn
, dynamic_nent
= 0;
8767 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8771 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8775 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8777 if (dynamic_section
== NULL
)
8779 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8780 (unsigned long) dynamic_nent
);
8785 for (ext
= edyn
, entry
= dynamic_section
;
8786 entry
< dynamic_section
+ dynamic_nent
;
8789 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8790 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8799 get_64bit_dynamic_section (FILE * file
)
8801 Elf64_External_Dyn
* edyn
;
8802 Elf64_External_Dyn
* ext
;
8803 Elf_Internal_Dyn
* entry
;
8805 /* Read in the data. */
8806 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
8807 dynamic_size
, _("dynamic section"));
8811 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8812 might not have the luxury of section headers. Look for the DT_NULL
8813 terminator to determine the number of entries. */
8814 for (ext
= edyn
, dynamic_nent
= 0;
8815 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
8816 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
8820 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
8824 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
8826 if (dynamic_section
== NULL
)
8828 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8829 (unsigned long) dynamic_nent
);
8834 /* Convert from external to internal formats. */
8835 for (ext
= edyn
, entry
= dynamic_section
;
8836 entry
< dynamic_section
+ dynamic_nent
;
8839 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
8840 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
8849 print_dynamic_flags (bfd_vma flags
)
8857 flag
= flags
& - flags
;
8867 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
8868 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
8869 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
8870 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
8871 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
8872 default: fputs (_("unknown"), stdout
); break;
8878 /* Parse and display the contents of the dynamic section. */
8881 process_dynamic_section (FILE * file
)
8883 Elf_Internal_Dyn
* entry
;
8885 if (dynamic_size
== 0)
8888 printf (_("\nThere is no dynamic section in this file.\n"));
8895 if (! get_32bit_dynamic_section (file
))
8898 else if (! get_64bit_dynamic_section (file
))
8901 /* Find the appropriate symbol table. */
8902 if (dynamic_symbols
== NULL
)
8904 for (entry
= dynamic_section
;
8905 entry
< dynamic_section
+ dynamic_nent
;
8908 Elf_Internal_Shdr section
;
8910 if (entry
->d_tag
!= DT_SYMTAB
)
8913 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
8915 /* Since we do not know how big the symbol table is,
8916 we default to reading in the entire file (!) and
8917 processing that. This is overkill, I know, but it
8919 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8921 if (archive_file_offset
!= 0)
8922 section
.sh_size
= archive_file_size
- section
.sh_offset
;
8925 if (fseek (file
, 0, SEEK_END
))
8926 error (_("Unable to seek to end of file!\n"));
8928 section
.sh_size
= ftell (file
) - section
.sh_offset
;
8932 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
8934 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
8935 section
.sh_name
= string_table_length
;
8937 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
8938 if (num_dynamic_syms
< 1)
8940 error (_("Unable to determine the number of symbols to load\n"));
8946 /* Similarly find a string table. */
8947 if (dynamic_strings
== NULL
)
8949 for (entry
= dynamic_section
;
8950 entry
< dynamic_section
+ dynamic_nent
;
8953 unsigned long offset
;
8956 if (entry
->d_tag
!= DT_STRTAB
)
8959 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
8961 /* Since we do not know how big the string table is,
8962 we default to reading in the entire file (!) and
8963 processing that. This is overkill, I know, but it
8966 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
8968 if (archive_file_offset
!= 0)
8969 str_tab_len
= archive_file_size
- offset
;
8972 if (fseek (file
, 0, SEEK_END
))
8973 error (_("Unable to seek to end of file\n"));
8974 str_tab_len
= ftell (file
) - offset
;
8977 if (str_tab_len
< 1)
8980 (_("Unable to determine the length of the dynamic string table\n"));
8984 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
8986 _("dynamic string table"));
8987 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
8992 /* And find the syminfo section if available. */
8993 if (dynamic_syminfo
== NULL
)
8995 unsigned long syminsz
= 0;
8997 for (entry
= dynamic_section
;
8998 entry
< dynamic_section
+ dynamic_nent
;
9001 if (entry
->d_tag
== DT_SYMINENT
)
9003 /* Note: these braces are necessary to avoid a syntax
9004 error from the SunOS4 C compiler. */
9005 /* PR binutils/17531: A corrupt file can trigger this test.
9006 So do not use an assert, instead generate an error message. */
9007 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9008 error (_("Bad value (%d) for SYMINENT entry\n"),
9009 (int) entry
->d_un
.d_val
);
9011 else if (entry
->d_tag
== DT_SYMINSZ
)
9012 syminsz
= entry
->d_un
.d_val
;
9013 else if (entry
->d_tag
== DT_SYMINFO
)
9014 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9018 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9020 Elf_External_Syminfo
* extsyminfo
;
9021 Elf_External_Syminfo
* extsym
;
9022 Elf_Internal_Syminfo
* syminfo
;
9024 /* There is a syminfo section. Read the data. */
9025 extsyminfo
= (Elf_External_Syminfo
*)
9026 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9027 _("symbol information"));
9031 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9032 if (dynamic_syminfo
== NULL
)
9034 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9035 (unsigned long) syminsz
);
9039 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9040 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9041 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9042 ++syminfo
, ++extsym
)
9044 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9045 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9052 if (do_dynamic
&& dynamic_addr
)
9053 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9054 dynamic_addr
, (unsigned long) dynamic_nent
);
9056 printf (_(" Tag Type Name/Value\n"));
9058 for (entry
= dynamic_section
;
9059 entry
< dynamic_section
+ dynamic_nent
;
9067 print_vma (entry
->d_tag
, FULL_HEX
);
9068 dtype
= get_dynamic_type (entry
->d_tag
);
9069 printf (" (%s)%*s", dtype
,
9070 ((is_32bit_elf
? 27 : 19)
9071 - (int) strlen (dtype
)),
9075 switch (entry
->d_tag
)
9079 print_dynamic_flags (entry
->d_un
.d_val
);
9089 switch (entry
->d_tag
)
9092 printf (_("Auxiliary library"));
9096 printf (_("Filter library"));
9100 printf (_("Configuration file"));
9104 printf (_("Dependency audit library"));
9108 printf (_("Audit library"));
9112 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9113 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9117 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9126 printf (_("Flags:"));
9128 if (entry
->d_un
.d_val
== 0)
9129 printf (_(" None\n"));
9132 unsigned long int val
= entry
->d_un
.d_val
;
9134 if (val
& DTF_1_PARINIT
)
9136 printf (" PARINIT");
9137 val
^= DTF_1_PARINIT
;
9139 if (val
& DTF_1_CONFEXP
)
9141 printf (" CONFEXP");
9142 val
^= DTF_1_CONFEXP
;
9145 printf (" %lx", val
);
9154 printf (_("Flags:"));
9156 if (entry
->d_un
.d_val
== 0)
9157 printf (_(" None\n"));
9160 unsigned long int val
= entry
->d_un
.d_val
;
9162 if (val
& DF_P1_LAZYLOAD
)
9164 printf (" LAZYLOAD");
9165 val
^= DF_P1_LAZYLOAD
;
9167 if (val
& DF_P1_GROUPPERM
)
9169 printf (" GROUPPERM");
9170 val
^= DF_P1_GROUPPERM
;
9173 printf (" %lx", val
);
9182 printf (_("Flags:"));
9183 if (entry
->d_un
.d_val
== 0)
9184 printf (_(" None\n"));
9187 unsigned long int val
= entry
->d_un
.d_val
;
9194 if (val
& DF_1_GLOBAL
)
9199 if (val
& DF_1_GROUP
)
9204 if (val
& DF_1_NODELETE
)
9206 printf (" NODELETE");
9207 val
^= DF_1_NODELETE
;
9209 if (val
& DF_1_LOADFLTR
)
9211 printf (" LOADFLTR");
9212 val
^= DF_1_LOADFLTR
;
9214 if (val
& DF_1_INITFIRST
)
9216 printf (" INITFIRST");
9217 val
^= DF_1_INITFIRST
;
9219 if (val
& DF_1_NOOPEN
)
9224 if (val
& DF_1_ORIGIN
)
9229 if (val
& DF_1_DIRECT
)
9234 if (val
& DF_1_TRANS
)
9239 if (val
& DF_1_INTERPOSE
)
9241 printf (" INTERPOSE");
9242 val
^= DF_1_INTERPOSE
;
9244 if (val
& DF_1_NODEFLIB
)
9246 printf (" NODEFLIB");
9247 val
^= DF_1_NODEFLIB
;
9249 if (val
& DF_1_NODUMP
)
9254 if (val
& DF_1_CONFALT
)
9256 printf (" CONFALT");
9257 val
^= DF_1_CONFALT
;
9259 if (val
& DF_1_ENDFILTEE
)
9261 printf (" ENDFILTEE");
9262 val
^= DF_1_ENDFILTEE
;
9264 if (val
& DF_1_DISPRELDNE
)
9266 printf (" DISPRELDNE");
9267 val
^= DF_1_DISPRELDNE
;
9269 if (val
& DF_1_DISPRELPND
)
9271 printf (" DISPRELPND");
9272 val
^= DF_1_DISPRELPND
;
9274 if (val
& DF_1_NODIRECT
)
9276 printf (" NODIRECT");
9277 val
^= DF_1_NODIRECT
;
9279 if (val
& DF_1_IGNMULDEF
)
9281 printf (" IGNMULDEF");
9282 val
^= DF_1_IGNMULDEF
;
9284 if (val
& DF_1_NOKSYMS
)
9286 printf (" NOKSYMS");
9287 val
^= DF_1_NOKSYMS
;
9289 if (val
& DF_1_NOHDR
)
9294 if (val
& DF_1_EDITED
)
9299 if (val
& DF_1_NORELOC
)
9301 printf (" NORELOC");
9302 val
^= DF_1_NORELOC
;
9304 if (val
& DF_1_SYMINTPOSE
)
9306 printf (" SYMINTPOSE");
9307 val
^= DF_1_SYMINTPOSE
;
9309 if (val
& DF_1_GLOBAUDIT
)
9311 printf (" GLOBAUDIT");
9312 val
^= DF_1_GLOBAUDIT
;
9314 if (val
& DF_1_SINGLETON
)
9316 printf (" SINGLETON");
9317 val
^= DF_1_SINGLETON
;
9319 if (val
& DF_1_STUB
)
9330 printf (" %lx", val
);
9337 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9339 puts (get_dynamic_type (entry
->d_un
.d_val
));
9359 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9365 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9366 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9372 switch (entry
->d_tag
)
9375 printf (_("Shared library: [%s]"), name
);
9377 if (streq (name
, program_interpreter
))
9378 printf (_(" program interpreter"));
9382 printf (_("Library soname: [%s]"), name
);
9386 printf (_("Library rpath: [%s]"), name
);
9390 printf (_("Library runpath: [%s]"), name
);
9394 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9399 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9412 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9416 case DT_INIT_ARRAYSZ
:
9417 case DT_FINI_ARRAYSZ
:
9418 case DT_GNU_CONFLICTSZ
:
9419 case DT_GNU_LIBLISTSZ
:
9422 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9423 printf (_(" (bytes)\n"));
9433 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
9446 if (entry
->d_tag
== DT_USED
9447 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9449 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9453 printf (_("Not needed object: [%s]\n"), name
);
9458 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9464 /* The value of this entry is ignored. */
9469 case DT_GNU_PRELINKED
:
9473 time_t atime
= entry
->d_un
.d_val
;
9475 tmp
= gmtime (&atime
);
9476 /* PR 17533 file: 041-1244816-0.004. */
9478 printf (_("<corrupt time val: %lx"),
9479 (unsigned long) atime
);
9481 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9482 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9483 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9489 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9492 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9498 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
9499 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
9504 switch (elf_header
.e_machine
)
9507 case EM_MIPS_RS3_LE
:
9508 dynamic_section_mips_val (entry
);
9511 dynamic_section_parisc_val (entry
);
9514 dynamic_section_ia64_val (entry
);
9517 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9529 get_ver_flags (unsigned int flags
)
9531 static char buff
[32];
9538 if (flags
& VER_FLG_BASE
)
9539 strcat (buff
, "BASE ");
9541 if (flags
& VER_FLG_WEAK
)
9543 if (flags
& VER_FLG_BASE
)
9544 strcat (buff
, "| ");
9546 strcat (buff
, "WEAK ");
9549 if (flags
& VER_FLG_INFO
)
9551 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
9552 strcat (buff
, "| ");
9554 strcat (buff
, "INFO ");
9557 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
9558 strcat (buff
, _("| <unknown>"));
9563 /* Display the contents of the version sections. */
9566 process_version_sections (FILE * file
)
9568 Elf_Internal_Shdr
* section
;
9575 for (i
= 0, section
= section_headers
;
9576 i
< elf_header
.e_shnum
;
9579 switch (section
->sh_type
)
9581 case SHT_GNU_verdef
:
9583 Elf_External_Verdef
* edefs
;
9590 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9591 printable_section_name (section
),
9594 printf (_(" Addr: 0x"));
9595 printf_vma (section
->sh_addr
);
9596 printf (_(" Offset: %#08lx Link: %u (%s)"),
9597 (unsigned long) section
->sh_offset
, section
->sh_link
,
9598 printable_section_name_from_index (section
->sh_link
));
9600 edefs
= (Elf_External_Verdef
*)
9601 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
9602 _("version definition section"));
9605 endbuf
= (char *) edefs
+ section
->sh_size
;
9607 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9610 Elf_External_Verdef
* edef
;
9611 Elf_Internal_Verdef ent
;
9612 Elf_External_Verdaux
* eaux
;
9613 Elf_Internal_Verdaux aux
;
9617 /* Check for very large indicies. */
9618 if (idx
> (size_t) (endbuf
- (char *) edefs
))
9621 vstart
= ((char *) edefs
) + idx
;
9622 if (vstart
+ sizeof (*edef
) > endbuf
)
9625 edef
= (Elf_External_Verdef
*) vstart
;
9627 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
9628 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
9629 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
9630 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
9631 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
9632 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
9633 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
9635 printf (_(" %#06x: Rev: %d Flags: %s"),
9636 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
9638 printf (_(" Index: %d Cnt: %d "),
9639 ent
.vd_ndx
, ent
.vd_cnt
);
9641 /* Check for overflow. */
9642 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
9645 vstart
+= ent
.vd_aux
;
9647 eaux
= (Elf_External_Verdaux
*) vstart
;
9649 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9650 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9652 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9653 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
9655 printf (_("Name index: %ld\n"), aux
.vda_name
);
9657 isum
= idx
+ ent
.vd_aux
;
9659 for (j
= 1; j
< ent
.vd_cnt
; j
++)
9661 /* Check for overflow. */
9662 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
9665 isum
+= aux
.vda_next
;
9666 vstart
+= aux
.vda_next
;
9668 eaux
= (Elf_External_Verdaux
*) vstart
;
9669 if (vstart
+ sizeof (*eaux
) > endbuf
)
9672 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
9673 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
9675 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
9676 printf (_(" %#06x: Parent %d: %s\n"),
9677 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
9679 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9680 isum
, j
, aux
.vda_name
);
9684 printf (_(" Version def aux past end of section\n"));
9686 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9687 if (idx
+ ent
.vd_next
<= idx
)
9693 if (cnt
< section
->sh_info
)
9694 printf (_(" Version definition past end of section\n"));
9700 case SHT_GNU_verneed
:
9702 Elf_External_Verneed
* eneed
;
9709 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9710 printable_section_name (section
), section
->sh_info
);
9712 printf (_(" Addr: 0x"));
9713 printf_vma (section
->sh_addr
);
9714 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9715 (unsigned long) section
->sh_offset
, section
->sh_link
,
9716 printable_section_name_from_index (section
->sh_link
));
9718 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
9719 section
->sh_offset
, 1,
9721 _("Version Needs section"));
9724 endbuf
= (char *) eneed
+ section
->sh_size
;
9726 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
9728 Elf_External_Verneed
* entry
;
9729 Elf_Internal_Verneed ent
;
9734 if (idx
> (size_t) (endbuf
- (char *) eneed
))
9737 vstart
= ((char *) eneed
) + idx
;
9738 if (vstart
+ sizeof (*entry
) > endbuf
)
9741 entry
= (Elf_External_Verneed
*) vstart
;
9743 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
9744 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
9745 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
9746 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
9747 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
9749 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
9751 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
9752 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
9754 printf (_(" File: %lx"), ent
.vn_file
);
9756 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
9758 /* Check for overflow. */
9759 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
9761 vstart
+= ent
.vn_aux
;
9763 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
9765 Elf_External_Vernaux
* eaux
;
9766 Elf_Internal_Vernaux aux
;
9768 if (vstart
+ sizeof (*eaux
) > endbuf
)
9770 eaux
= (Elf_External_Vernaux
*) vstart
;
9772 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
9773 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
9774 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
9775 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
9776 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
9778 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
9779 printf (_(" %#06x: Name: %s"),
9780 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
9782 printf (_(" %#06x: Name index: %lx"),
9783 isum
, aux
.vna_name
);
9785 printf (_(" Flags: %s Version: %d\n"),
9786 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
9788 /* Check for overflow. */
9789 if (aux
.vna_next
> (size_t) (endbuf
- vstart
)
9790 || (aux
.vna_next
== 0 && j
< ent
.vn_cnt
- 1))
9792 warn (_("Invalid vna_next field of %lx\n"),
9797 isum
+= aux
.vna_next
;
9798 vstart
+= aux
.vna_next
;
9802 warn (_("Missing Version Needs auxillary information\n"));
9804 if (ent
.vn_next
== 0 && cnt
< section
->sh_info
- 1)
9806 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9807 cnt
= section
->sh_info
;
9813 if (cnt
< section
->sh_info
)
9814 warn (_("Missing Version Needs information\n"));
9820 case SHT_GNU_versym
:
9822 Elf_Internal_Shdr
* link_section
;
9825 unsigned char * edata
;
9826 unsigned short * data
;
9828 Elf_Internal_Sym
* symbols
;
9829 Elf_Internal_Shdr
* string_sec
;
9830 unsigned long num_syms
;
9833 if (section
->sh_link
>= elf_header
.e_shnum
)
9836 link_section
= section_headers
+ section
->sh_link
;
9837 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
9839 if (link_section
->sh_link
>= elf_header
.e_shnum
)
9844 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
9845 if (symbols
== NULL
)
9848 string_sec
= section_headers
+ link_section
->sh_link
;
9850 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
9851 string_sec
->sh_size
,
9852 _("version string table"));
9859 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9860 printable_section_name (section
), (unsigned long) total
);
9862 printf (_(" Addr: "));
9863 printf_vma (section
->sh_addr
);
9864 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9865 (unsigned long) section
->sh_offset
, section
->sh_link
,
9866 printable_section_name (link_section
));
9868 off
= offset_from_vma (file
,
9869 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
9870 total
* sizeof (short));
9871 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
9873 _("version symbol data"));
9881 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
9883 for (cnt
= total
; cnt
--;)
9884 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
9889 for (cnt
= 0; cnt
< total
; cnt
+= 4)
9893 char *invalid
= _("*invalid*");
9895 printf (" %03x:", cnt
);
9897 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
9898 switch (data
[cnt
+ j
])
9901 fputs (_(" 0 (*local*) "), stdout
);
9905 fputs (_(" 1 (*global*) "), stdout
);
9909 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
9910 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
9912 /* If this index value is greater than the size of the symbols
9913 array, break to avoid an out-of-bounds read. */
9914 if ((unsigned long)(cnt
+ j
) >= num_syms
)
9916 warn (_("invalid index into symbol array\n"));
9921 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9923 Elf_Internal_Verneed ivn
;
9924 unsigned long offset
;
9926 offset
= offset_from_vma
9927 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9928 sizeof (Elf_External_Verneed
));
9932 Elf_Internal_Vernaux ivna
;
9933 Elf_External_Verneed evn
;
9934 Elf_External_Vernaux evna
;
9935 unsigned long a_off
;
9937 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9938 _("version need")) == NULL
)
9941 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9942 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9944 a_off
= offset
+ ivn
.vn_aux
;
9948 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9949 1, _("version need aux (2)")) == NULL
)
9956 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9957 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9960 a_off
+= ivna
.vna_next
;
9962 while (ivna
.vna_other
!= data
[cnt
+ j
]
9963 && ivna
.vna_next
!= 0);
9965 if (ivna
.vna_other
== data
[cnt
+ j
])
9967 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9969 if (ivna
.vna_name
>= string_sec
->sh_size
)
9972 name
= strtab
+ ivna
.vna_name
;
9976 offset
+= ivn
.vn_next
;
9978 while (ivn
.vn_next
);
9981 if (data
[cnt
+ j
] != 0x8001
9982 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
9984 Elf_Internal_Verdef ivd
;
9985 Elf_External_Verdef evd
;
9986 unsigned long offset
;
9988 offset
= offset_from_vma
9989 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
9994 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
9995 _("version def")) == NULL
)
9998 /* PR 17531: file: 046-1082287-0.004. */
9999 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10004 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10005 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10008 offset
+= ivd
.vd_next
;
10010 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10011 && ivd
.vd_next
!= 0);
10013 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10015 Elf_External_Verdaux evda
;
10016 Elf_Internal_Verdaux ivda
;
10018 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10020 if (get_data (&evda
, file
,
10021 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10023 _("version def aux")) == NULL
)
10026 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10028 if (ivda
.vda_name
>= string_sec
->sh_size
)
10030 else if (name
!= NULL
&& name
!= invalid
)
10031 name
= _("*both*");
10033 name
= strtab
+ ivda
.vda_name
;
10037 nn
+= printf ("(%s%-*s",
10039 12 - (int) strlen (name
),
10043 printf ("%*c", 18 - nn
, ' ');
10061 printf (_("\nNo version information found in this file.\n"));
10066 static const char *
10067 get_symbol_binding (unsigned int binding
)
10069 static char buff
[32];
10073 case STB_LOCAL
: return "LOCAL";
10074 case STB_GLOBAL
: return "GLOBAL";
10075 case STB_WEAK
: return "WEAK";
10077 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10078 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10080 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10082 if (binding
== STB_GNU_UNIQUE
10083 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10084 /* GNU is still using the default value 0. */
10085 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10087 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10090 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10095 static const char *
10096 get_symbol_type (unsigned int type
)
10098 static char buff
[32];
10102 case STT_NOTYPE
: return "NOTYPE";
10103 case STT_OBJECT
: return "OBJECT";
10104 case STT_FUNC
: return "FUNC";
10105 case STT_SECTION
: return "SECTION";
10106 case STT_FILE
: return "FILE";
10107 case STT_COMMON
: return "COMMON";
10108 case STT_TLS
: return "TLS";
10109 case STT_RELC
: return "RELC";
10110 case STT_SRELC
: return "SRELC";
10112 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10114 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10115 return "THUMB_FUNC";
10117 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10120 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10121 return "PARISC_MILLI";
10123 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10125 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10127 if (elf_header
.e_machine
== EM_PARISC
)
10129 if (type
== STT_HP_OPAQUE
)
10130 return "HP_OPAQUE";
10131 if (type
== STT_HP_STUB
)
10135 if (type
== STT_GNU_IFUNC
10136 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10137 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10138 /* GNU is still using the default value 0. */
10139 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10142 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10145 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10150 static const char *
10151 get_symbol_visibility (unsigned int visibility
)
10153 switch (visibility
)
10155 case STV_DEFAULT
: return "DEFAULT";
10156 case STV_INTERNAL
: return "INTERNAL";
10157 case STV_HIDDEN
: return "HIDDEN";
10158 case STV_PROTECTED
: return "PROTECTED";
10160 error (_("Unrecognized visibility value: %u"), visibility
);
10161 return _("<unknown>");
10165 static const char *
10166 get_mips_symbol_other (unsigned int other
)
10176 case STO_MICROMIPS
:
10177 return "MICROMIPS";
10178 case STO_MICROMIPS
| STO_MIPS_PIC
:
10179 return "MICROMIPS, MIPS PIC";
10187 static const char *
10188 get_ia64_symbol_other (unsigned int other
)
10190 if (is_ia64_vms ())
10192 static char res
[32];
10196 /* Function types is for images and .STB files only. */
10197 switch (elf_header
.e_type
)
10201 switch (VMS_ST_FUNC_TYPE (other
))
10203 case VMS_SFT_CODE_ADDR
:
10204 strcat (res
, " CA");
10206 case VMS_SFT_SYMV_IDX
:
10207 strcat (res
, " VEC");
10210 strcat (res
, " FD");
10212 case VMS_SFT_RESERVE
:
10213 strcat (res
, " RSV");
10216 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10217 VMS_ST_FUNC_TYPE (other
));
10218 strcat (res
, " <unknown>");
10225 switch (VMS_ST_LINKAGE (other
))
10227 case VMS_STL_IGNORE
:
10228 strcat (res
, " IGN");
10230 case VMS_STL_RESERVE
:
10231 strcat (res
, " RSV");
10234 strcat (res
, " STD");
10237 strcat (res
, " LNK");
10240 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10241 VMS_ST_LINKAGE (other
));
10242 strcat (res
, " <unknown>");
10254 static const char *
10255 get_ppc64_symbol_other (unsigned int other
)
10257 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10259 static char buf
[32];
10260 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10261 PPC64_LOCAL_ENTRY_OFFSET (other
));
10267 static const char *
10268 get_symbol_other (unsigned int other
)
10270 const char * result
= NULL
;
10271 static char buff
[32];
10276 switch (elf_header
.e_machine
)
10279 result
= get_mips_symbol_other (other
);
10282 result
= get_ia64_symbol_other (other
);
10285 result
= get_ppc64_symbol_other (other
);
10294 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10298 static const char *
10299 get_symbol_index_type (unsigned int type
)
10301 static char buff
[32];
10305 case SHN_UNDEF
: return "UND";
10306 case SHN_ABS
: return "ABS";
10307 case SHN_COMMON
: return "COM";
10309 if (type
== SHN_IA_64_ANSI_COMMON
10310 && elf_header
.e_machine
== EM_IA_64
10311 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10313 else if ((elf_header
.e_machine
== EM_X86_64
10314 || elf_header
.e_machine
== EM_L1OM
10315 || elf_header
.e_machine
== EM_K1OM
)
10316 && type
== SHN_X86_64_LCOMMON
)
10317 return "LARGE_COM";
10318 else if ((type
== SHN_MIPS_SCOMMON
10319 && elf_header
.e_machine
== EM_MIPS
)
10320 || (type
== SHN_TIC6X_SCOMMON
10321 && elf_header
.e_machine
== EM_TI_C6000
))
10323 else if (type
== SHN_MIPS_SUNDEFINED
10324 && elf_header
.e_machine
== EM_MIPS
)
10326 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10327 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10328 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10329 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10330 else if (type
>= SHN_LORESERVE
)
10331 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10332 else if (type
>= elf_header
.e_shnum
)
10333 sprintf (buff
, _("bad section index[%3d]"), type
);
10335 sprintf (buff
, "%3d", type
);
10343 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10345 unsigned char * e_data
;
10348 /* If the size_t type is smaller than the bfd_size_type, eg because
10349 you are building a 32-bit tool on a 64-bit host, then make sure
10350 that when (number) is cast to (size_t) no information is lost. */
10351 if (sizeof (size_t) < sizeof (bfd_size_type
)
10352 && (bfd_size_type
) ((size_t) number
) != number
)
10354 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10355 (unsigned long long) number
, ent_size
);
10359 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10360 attempting to allocate memory when the read is bound to fail. */
10361 if (ent_size
* number
> current_file_size
)
10363 error (_("Invalid number of dynamic entries: %llu\n"),
10364 (unsigned long long) number
);
10368 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10369 if (e_data
== NULL
)
10371 error (_("Out of memory reading %llu dynamic entries\n"),
10372 (unsigned long long) number
);
10376 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10378 error (_("Unable to read in %llu bytes of dynamic data\n"),
10379 (unsigned long long) (number
* ent_size
));
10384 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10385 if (i_data
== NULL
)
10387 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10388 (unsigned long long) number
);
10394 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10402 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10404 Elf_Internal_Sym
* psym
;
10407 n
= print_vma (si
, DEC_5
);
10409 fputs (&" "[n
], stdout
);
10410 printf (" %3lu: ", hn
);
10412 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10414 printf (_("<No info available for dynamic symbol number %lu>\n"),
10415 (unsigned long) si
);
10419 psym
= dynamic_symbols
+ si
;
10420 print_vma (psym
->st_value
, LONG_HEX
);
10422 print_vma (psym
->st_size
, DEC_5
);
10424 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10425 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10426 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10427 /* Check to see if any other bits in the st_other field are set.
10428 Note - displaying this information disrupts the layout of the
10429 table being generated, but for the moment this case is very
10431 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10432 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10433 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10434 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10435 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10437 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10441 static const char *
10442 get_symbol_version_string (FILE *file
, int is_dynsym
,
10443 const char *strtab
,
10444 unsigned long int strtab_size
,
10445 unsigned int si
, Elf_Internal_Sym
*psym
,
10446 enum versioned_symbol_info
*sym_info
,
10447 unsigned short *vna_other
)
10449 unsigned char data
[2];
10450 unsigned short vers_data
;
10451 unsigned long offset
;
10454 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
10457 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10458 sizeof data
+ si
* sizeof (vers_data
));
10460 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10461 sizeof (data
), 1, _("version data")) == NULL
)
10464 vers_data
= byte_get (data
, 2);
10466 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
10469 /* Usually we'd only see verdef for defined symbols, and verneed for
10470 undefined symbols. However, symbols defined by the linker in
10471 .dynbss for variables copied from a shared library in order to
10472 avoid text relocations are defined yet have verneed. We could
10473 use a heuristic to detect the special case, for example, check
10474 for verneed first on symbols defined in SHT_NOBITS sections, but
10475 it is simpler and more reliable to just look for both verdef and
10476 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10478 if (psym
->st_shndx
!= SHN_UNDEF
10479 && vers_data
!= 0x8001
10480 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10482 Elf_Internal_Verdef ivd
;
10483 Elf_Internal_Verdaux ivda
;
10484 Elf_External_Verdaux evda
;
10487 off
= offset_from_vma (file
,
10488 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10489 sizeof (Elf_External_Verdef
));
10493 Elf_External_Verdef evd
;
10495 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
10496 _("version def")) == NULL
)
10504 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10505 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10506 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10509 off
+= ivd
.vd_next
;
10511 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
10513 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
10515 off
-= ivd
.vd_next
;
10518 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
10519 _("version def aux")) != NULL
)
10521 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10523 if (psym
->st_name
!= ivda
.vda_name
)
10525 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10526 ? symbol_hidden
: symbol_public
);
10527 return (ivda
.vda_name
< strtab_size
10528 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
10534 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10536 Elf_External_Verneed evn
;
10537 Elf_Internal_Verneed ivn
;
10538 Elf_Internal_Vernaux ivna
;
10540 offset
= offset_from_vma (file
,
10541 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10545 unsigned long vna_off
;
10547 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10548 _("version need")) == NULL
)
10551 ivna
.vna_other
= 0;
10556 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10557 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10559 vna_off
= offset
+ ivn
.vn_aux
;
10563 Elf_External_Vernaux evna
;
10565 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
10566 _("version need aux (3)")) == NULL
)
10569 ivna
.vna_other
= 0;
10574 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10575 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10576 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10579 vna_off
+= ivna
.vna_next
;
10581 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
10583 if (ivna
.vna_other
== vers_data
)
10586 offset
+= ivn
.vn_next
;
10588 while (ivn
.vn_next
!= 0);
10590 if (ivna
.vna_other
== vers_data
)
10592 *sym_info
= symbol_undefined
;
10593 *vna_other
= ivna
.vna_other
;
10594 return (ivna
.vna_name
< strtab_size
10595 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
10601 /* Dump the symbol table. */
10603 process_symbol_table (FILE * file
)
10605 Elf_Internal_Shdr
* section
;
10606 bfd_size_type nbuckets
= 0;
10607 bfd_size_type nchains
= 0;
10608 bfd_vma
* buckets
= NULL
;
10609 bfd_vma
* chains
= NULL
;
10610 bfd_vma ngnubuckets
= 0;
10611 bfd_vma
* gnubuckets
= NULL
;
10612 bfd_vma
* gnuchains
= NULL
;
10613 bfd_vma gnusymidx
= 0;
10614 bfd_size_type ngnuchains
= 0;
10616 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10619 if (dynamic_info
[DT_HASH
]
10621 || (do_using_dynamic
10623 && dynamic_strings
!= NULL
)))
10625 unsigned char nb
[8];
10626 unsigned char nc
[8];
10627 unsigned int hash_ent_size
= 4;
10629 if ((elf_header
.e_machine
== EM_ALPHA
10630 || elf_header
.e_machine
== EM_S390
10631 || elf_header
.e_machine
== EM_S390_OLD
)
10632 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10636 (archive_file_offset
10637 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10638 sizeof nb
+ sizeof nc
)),
10641 error (_("Unable to seek to start of dynamic information\n"));
10645 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10647 error (_("Failed to read in number of buckets\n"));
10651 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10653 error (_("Failed to read in number of chains\n"));
10657 nbuckets
= byte_get (nb
, hash_ent_size
);
10658 nchains
= byte_get (nc
, hash_ent_size
);
10660 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10661 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10664 if (buckets
== NULL
|| chains
== NULL
)
10666 if (do_using_dynamic
)
10677 if (dynamic_info_DT_GNU_HASH
10679 || (do_using_dynamic
10681 && dynamic_strings
!= NULL
)))
10683 unsigned char nb
[16];
10684 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10685 bfd_vma buckets_vma
;
10688 (archive_file_offset
10689 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10693 error (_("Unable to seek to start of dynamic information\n"));
10697 if (fread (nb
, 16, 1, file
) != 1)
10699 error (_("Failed to read in number of buckets\n"));
10703 ngnubuckets
= byte_get (nb
, 4);
10704 gnusymidx
= byte_get (nb
+ 4, 4);
10705 bitmaskwords
= byte_get (nb
+ 8, 4);
10706 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10708 buckets_vma
+= bitmaskwords
* 4;
10710 buckets_vma
+= bitmaskwords
* 8;
10713 (archive_file_offset
10714 + offset_from_vma (file
, buckets_vma
, 4)),
10717 error (_("Unable to seek to start of dynamic information\n"));
10721 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10723 if (gnubuckets
== NULL
)
10726 for (i
= 0; i
< ngnubuckets
; i
++)
10727 if (gnubuckets
[i
] != 0)
10729 if (gnubuckets
[i
] < gnusymidx
)
10732 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10733 maxchain
= gnubuckets
[i
];
10736 if (maxchain
== 0xffffffff)
10739 maxchain
-= gnusymidx
;
10742 (archive_file_offset
10743 + offset_from_vma (file
, buckets_vma
10744 + 4 * (ngnubuckets
+ maxchain
), 4)),
10747 error (_("Unable to seek to start of dynamic information\n"));
10753 if (fread (nb
, 4, 1, file
) != 1)
10755 error (_("Failed to determine last chain length\n"));
10759 if (maxchain
+ 1 == 0)
10764 while ((byte_get (nb
, 4) & 1) == 0);
10767 (archive_file_offset
10768 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10771 error (_("Unable to seek to start of dynamic information\n"));
10775 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10776 ngnuchains
= maxchain
;
10779 if (gnuchains
== NULL
)
10784 if (do_using_dynamic
)
10789 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10791 && do_using_dynamic
10792 && dynamic_strings
!= NULL
10793 && dynamic_symbols
!= NULL
)
10797 if (dynamic_info
[DT_HASH
])
10801 printf (_("\nSymbol table for image:\n"));
10803 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10805 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10807 for (hn
= 0; hn
< nbuckets
; hn
++)
10812 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10813 print_dynamic_symbol (si
, hn
);
10817 if (dynamic_info_DT_GNU_HASH
)
10819 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10821 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10823 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10825 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10826 if (gnubuckets
[hn
] != 0)
10828 bfd_vma si
= gnubuckets
[hn
];
10829 bfd_vma off
= si
- gnusymidx
;
10833 print_dynamic_symbol (si
, hn
);
10836 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10840 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10841 && section_headers
!= NULL
)
10845 for (i
= 0, section
= section_headers
;
10846 i
< elf_header
.e_shnum
;
10850 char * strtab
= NULL
;
10851 unsigned long int strtab_size
= 0;
10852 Elf_Internal_Sym
* symtab
;
10853 Elf_Internal_Sym
* psym
;
10854 unsigned long num_syms
;
10856 if ((section
->sh_type
!= SHT_SYMTAB
10857 && section
->sh_type
!= SHT_DYNSYM
)
10859 && section
->sh_type
== SHT_SYMTAB
))
10862 if (section
->sh_entsize
== 0)
10864 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10865 printable_section_name (section
));
10869 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10870 printable_section_name (section
),
10871 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10874 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10876 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10878 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10879 if (symtab
== NULL
)
10882 if (section
->sh_link
== elf_header
.e_shstrndx
)
10884 strtab
= string_table
;
10885 strtab_size
= string_table_length
;
10887 else if (section
->sh_link
< elf_header
.e_shnum
)
10889 Elf_Internal_Shdr
* string_sec
;
10891 string_sec
= section_headers
+ section
->sh_link
;
10893 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10894 1, string_sec
->sh_size
,
10895 _("string table"));
10896 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10899 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10901 const char *version_string
;
10902 enum versioned_symbol_info sym_info
;
10903 unsigned short vna_other
;
10905 printf ("%6d: ", si
);
10906 print_vma (psym
->st_value
, LONG_HEX
);
10908 print_vma (psym
->st_size
, DEC_5
);
10909 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10910 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10911 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10912 /* Check to see if any other bits in the st_other field are set.
10913 Note - displaying this information disrupts the layout of the
10914 table being generated, but for the moment this case is very rare. */
10915 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10916 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10917 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10918 print_symbol (25, psym
->st_name
< strtab_size
10919 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10922 = get_symbol_version_string (file
,
10923 section
->sh_type
== SHT_DYNSYM
,
10924 strtab
, strtab_size
, si
,
10925 psym
, &sym_info
, &vna_other
);
10926 if (version_string
)
10928 if (sym_info
== symbol_undefined
)
10929 printf ("@%s (%d)", version_string
, vna_other
);
10931 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10939 if (strtab
!= string_table
)
10945 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10947 if (do_histogram
&& buckets
!= NULL
)
10949 unsigned long * lengths
;
10950 unsigned long * counts
;
10953 unsigned long maxlength
= 0;
10954 unsigned long nzero_counts
= 0;
10955 unsigned long nsyms
= 0;
10956 unsigned long chained
;
10958 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10959 (unsigned long) nbuckets
);
10961 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10962 if (lengths
== NULL
)
10964 error (_("Out of memory allocating space for histogram buckets\n"));
10968 printf (_(" Length Number %% of total Coverage\n"));
10969 for (hn
= 0; hn
< nbuckets
; ++hn
)
10971 for (si
= buckets
[hn
], chained
= 0;
10972 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
10973 si
= chains
[si
], ++chained
)
10976 if (maxlength
< ++lengths
[hn
])
10980 /* PR binutils/17531: A corrupt binary could contain broken
10981 histogram data. Do not go into an infinite loop trying
10983 if (chained
> nchains
)
10985 error (_("histogram chain is corrupt\n"));
10990 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
10991 if (counts
== NULL
)
10994 error (_("Out of memory allocating space for histogram counts\n"));
10998 for (hn
= 0; hn
< nbuckets
; ++hn
)
10999 ++counts
[lengths
[hn
]];
11004 printf (" 0 %-10lu (%5.1f%%)\n",
11005 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11006 for (i
= 1; i
<= maxlength
; ++i
)
11008 nzero_counts
+= counts
[i
] * i
;
11009 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11010 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11011 (nzero_counts
* 100.0) / nsyms
);
11019 if (buckets
!= NULL
)
11025 if (do_histogram
&& gnubuckets
!= NULL
)
11027 unsigned long * lengths
;
11028 unsigned long * counts
;
11030 unsigned long maxlength
= 0;
11031 unsigned long nzero_counts
= 0;
11032 unsigned long nsyms
= 0;
11034 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11035 (unsigned long) ngnubuckets
);
11037 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11038 if (lengths
== NULL
)
11040 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11044 printf (_(" Length Number %% of total Coverage\n"));
11046 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11047 if (gnubuckets
[hn
] != 0)
11049 bfd_vma off
, length
= 1;
11051 for (off
= gnubuckets
[hn
] - gnusymidx
;
11052 /* PR 17531 file: 010-77222-0.004. */
11053 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11056 lengths
[hn
] = length
;
11057 if (length
> maxlength
)
11058 maxlength
= length
;
11062 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11063 if (counts
== NULL
)
11066 error (_("Out of memory allocating space for gnu histogram counts\n"));
11070 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11071 ++counts
[lengths
[hn
]];
11073 if (ngnubuckets
> 0)
11076 printf (" 0 %-10lu (%5.1f%%)\n",
11077 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11078 for (j
= 1; j
<= maxlength
; ++j
)
11080 nzero_counts
+= counts
[j
] * j
;
11081 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11082 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11083 (nzero_counts
* 100.0) / nsyms
);
11097 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11101 if (dynamic_syminfo
== NULL
11103 /* No syminfo, this is ok. */
11106 /* There better should be a dynamic symbol section. */
11107 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11111 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11112 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11114 printf (_(" Num: Name BoundTo Flags\n"));
11115 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11117 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11119 printf ("%4d: ", i
);
11120 if (i
>= num_dynamic_syms
)
11121 printf (_("<corrupt index>"));
11122 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11123 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11125 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11128 switch (dynamic_syminfo
[i
].si_boundto
)
11130 case SYMINFO_BT_SELF
:
11131 fputs ("SELF ", stdout
);
11133 case SYMINFO_BT_PARENT
:
11134 fputs ("PARENT ", stdout
);
11137 if (dynamic_syminfo
[i
].si_boundto
> 0
11138 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11139 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11141 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11145 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11149 if (flags
& SYMINFO_FLG_DIRECT
)
11150 printf (" DIRECT");
11151 if (flags
& SYMINFO_FLG_PASSTHRU
)
11152 printf (" PASSTHRU");
11153 if (flags
& SYMINFO_FLG_COPY
)
11155 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11156 printf (" LAZYLOAD");
11164 /* Check to see if the given reloc needs to be handled in a target specific
11165 manner. If so then process the reloc and return TRUE otherwise return
11169 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11170 unsigned char * start
,
11171 Elf_Internal_Sym
* symtab
)
11173 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11175 switch (elf_header
.e_machine
)
11178 case EM_MSP430_OLD
:
11180 static Elf_Internal_Sym
* saved_sym
= NULL
;
11182 switch (reloc_type
)
11184 case 10: /* R_MSP430_SYM_DIFF */
11185 if (uses_msp430x_relocs ())
11187 case 21: /* R_MSP430X_SYM_DIFF */
11188 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11191 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11192 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11193 goto handle_sym_diff
;
11195 case 5: /* R_MSP430_16_BYTE */
11196 case 9: /* R_MSP430_8 */
11197 if (uses_msp430x_relocs ())
11199 goto handle_sym_diff
;
11201 case 2: /* R_MSP430_ABS16 */
11202 case 15: /* R_MSP430X_ABS16 */
11203 if (! uses_msp430x_relocs ())
11205 goto handle_sym_diff
;
11208 if (saved_sym
!= NULL
)
11212 value
= reloc
->r_addend
11213 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11214 - saved_sym
->st_value
);
11216 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11224 if (saved_sym
!= NULL
)
11225 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11232 case EM_CYGNUS_MN10300
:
11234 static Elf_Internal_Sym
* saved_sym
= NULL
;
11236 switch (reloc_type
)
11238 case 34: /* R_MN10300_ALIGN */
11240 case 33: /* R_MN10300_SYM_DIFF */
11241 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11243 case 1: /* R_MN10300_32 */
11244 case 2: /* R_MN10300_16 */
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);
11260 if (saved_sym
!= NULL
)
11261 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11269 static bfd_vma saved_sym1
= 0;
11270 static bfd_vma saved_sym2
= 0;
11271 static bfd_vma value
;
11273 switch (reloc_type
)
11275 case 0x80: /* R_RL78_SYM. */
11276 saved_sym1
= saved_sym2
;
11277 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11278 saved_sym2
+= reloc
->r_addend
;
11281 case 0x83: /* R_RL78_OPsub. */
11282 value
= saved_sym1
- saved_sym2
;
11283 saved_sym2
= saved_sym1
= 0;
11287 case 0x41: /* R_RL78_ABS32. */
11288 byte_put (start
+ reloc
->r_offset
, value
, 4);
11292 case 0x43: /* R_RL78_ABS16. */
11293 byte_put (start
+ reloc
->r_offset
, value
, 2);
11307 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11308 DWARF debug sections. This is a target specific test. Note - we do not
11309 go through the whole including-target-headers-multiple-times route, (as
11310 we have already done with <elf/h8.h>) because this would become very
11311 messy and even then this function would have to contain target specific
11312 information (the names of the relocs instead of their numeric values).
11313 FIXME: This is not the correct way to solve this problem. The proper way
11314 is to have target specific reloc sizing and typing functions created by
11315 the reloc-macros.h header, in the same way that it already creates the
11316 reloc naming functions. */
11319 is_32bit_abs_reloc (unsigned int reloc_type
)
11321 switch (elf_header
.e_machine
)
11325 return reloc_type
== 1; /* R_386_32. */
11327 return reloc_type
== 1; /* R_68K_32. */
11329 return reloc_type
== 1; /* R_860_32. */
11331 return reloc_type
== 2; /* R_960_32. */
11333 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11335 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11337 return reloc_type
== 1; /* R_ARC_32. */
11338 case EM_ARC_COMPACT
:
11339 case EM_ARC_COMPACT2
:
11340 return reloc_type
== 4; /* R_ARC_32. */
11342 return reloc_type
== 2; /* R_ARM_ABS32 */
11345 return reloc_type
== 1;
11346 case EM_ADAPTEVA_EPIPHANY
:
11347 return reloc_type
== 3;
11349 return reloc_type
== 0x12; /* R_byte4_data. */
11351 return reloc_type
== 3; /* R_CRIS_32. */
11353 return reloc_type
== 3; /* R_CR16_NUM32. */
11355 return reloc_type
== 15; /* R_CRX_NUM32. */
11356 case EM_CYGNUS_FRV
:
11357 return reloc_type
== 1;
11358 case EM_CYGNUS_D10V
:
11360 return reloc_type
== 6; /* R_D10V_32. */
11361 case EM_CYGNUS_D30V
:
11363 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11365 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11366 case EM_CYGNUS_FR30
:
11368 return reloc_type
== 3; /* R_FR30_32. */
11370 return reloc_type
== 1; /* R_FT32_32. */
11374 return reloc_type
== 1; /* R_H8_DIR32. */
11376 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11377 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11380 return reloc_type
== 2; /* R_IP2K_32. */
11382 return reloc_type
== 2; /* R_IQ2000_32. */
11383 case EM_LATTICEMICO32
:
11384 return reloc_type
== 3; /* R_LM32_32. */
11387 return reloc_type
== 3; /* R_M32C_32. */
11389 return reloc_type
== 34; /* R_M32R_32_RELA. */
11391 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11392 case EM_CYGNUS_MEP
:
11393 return reloc_type
== 4; /* R_MEP_32. */
11395 return reloc_type
== 2; /* R_METAG_ADDR32. */
11396 case EM_MICROBLAZE
:
11397 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11399 return reloc_type
== 2; /* R_MIPS_32. */
11401 return reloc_type
== 4; /* R_MMIX_32. */
11402 case EM_CYGNUS_MN10200
:
11404 return reloc_type
== 1; /* R_MN10200_32. */
11405 case EM_CYGNUS_MN10300
:
11407 return reloc_type
== 1; /* R_MN10300_32. */
11409 return reloc_type
== 1; /* R_MOXIE_32. */
11410 case EM_MSP430_OLD
:
11412 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11414 return reloc_type
== 2; /* R_MT_32. */
11416 return reloc_type
== 20; /* R_NDS32_RELA. */
11417 case EM_ALTERA_NIOS2
:
11418 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11420 return reloc_type
== 1; /* R_NIOS_32. */
11422 return reloc_type
== 1; /* R_OR1K_32. */
11424 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11425 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11428 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11430 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11432 return reloc_type
== 1; /* R_PPC_ADDR32. */
11434 return reloc_type
== 1; /* R_RL78_DIR32. */
11436 return reloc_type
== 1; /* R_RX_DIR32. */
11438 return reloc_type
== 1; /* R_I370_ADDR31. */
11441 return reloc_type
== 4; /* R_S390_32. */
11443 return reloc_type
== 8; /* R_SCORE_ABS32. */
11445 return reloc_type
== 1; /* R_SH_DIR32. */
11446 case EM_SPARC32PLUS
:
11449 return reloc_type
== 3 /* R_SPARC_32. */
11450 || reloc_type
== 23; /* R_SPARC_UA32. */
11452 return reloc_type
== 6; /* R_SPU_ADDR32 */
11454 return reloc_type
== 1; /* R_C6000_ABS32. */
11456 return reloc_type
== 2; /* R_TILEGX_32. */
11458 return reloc_type
== 1; /* R_TILEPRO_32. */
11459 case EM_CYGNUS_V850
:
11461 return reloc_type
== 6; /* R_V850_ABS32. */
11463 return reloc_type
== 0x33; /* R_V810_WORD. */
11465 return reloc_type
== 1; /* R_VAX_32. */
11467 return reloc_type
== 3; /* R_VISIUM_32. */
11471 return reloc_type
== 10; /* R_X86_64_32. */
11474 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11476 return reloc_type
== 4; /* R_XGATE_32. */
11478 return reloc_type
== 1; /* R_XSTROMY16_32. */
11479 case EM_XTENSA_OLD
:
11481 return reloc_type
== 1; /* R_XTENSA_32. */
11484 static unsigned int prev_warn
= 0;
11486 /* Avoid repeating the same warning multiple times. */
11487 if (prev_warn
!= elf_header
.e_machine
)
11488 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11489 elf_header
.e_machine
);
11490 prev_warn
= elf_header
.e_machine
;
11496 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11497 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11500 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11502 switch (elf_header
.e_machine
)
11506 return reloc_type
== 2; /* R_386_PC32. */
11508 return reloc_type
== 4; /* R_68K_PC32. */
11510 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11511 case EM_ADAPTEVA_EPIPHANY
:
11512 return reloc_type
== 6;
11514 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11516 return reloc_type
== 3; /* R_ARM_REL32 */
11517 case EM_MICROBLAZE
:
11518 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11520 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11522 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11524 return reloc_type
== 26; /* R_PPC_REL32. */
11526 return reloc_type
== 26; /* R_PPC64_REL32. */
11529 return reloc_type
== 5; /* R_390_PC32. */
11531 return reloc_type
== 2; /* R_SH_REL32. */
11532 case EM_SPARC32PLUS
:
11535 return reloc_type
== 6; /* R_SPARC_DISP32. */
11537 return reloc_type
== 13; /* R_SPU_REL32. */
11539 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11541 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11543 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11547 return reloc_type
== 2; /* R_X86_64_PC32. */
11548 case EM_XTENSA_OLD
:
11550 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11552 /* Do not abort or issue an error message here. Not all targets use
11553 pc-relative 32-bit relocs in their DWARF debug information and we
11554 have already tested for target coverage in is_32bit_abs_reloc. A
11555 more helpful warning message will be generated by apply_relocations
11556 anyway, so just return. */
11561 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11562 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11565 is_64bit_abs_reloc (unsigned int reloc_type
)
11567 switch (elf_header
.e_machine
)
11570 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11572 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11574 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11576 return reloc_type
== 80; /* R_PARISC_DIR64. */
11578 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11579 case EM_SPARC32PLUS
:
11582 return reloc_type
== 54; /* R_SPARC_UA64. */
11586 return reloc_type
== 1; /* R_X86_64_64. */
11589 return reloc_type
== 22; /* R_S390_64. */
11591 return reloc_type
== 1; /* R_TILEGX_64. */
11593 return reloc_type
== 18; /* R_MIPS_64. */
11599 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11600 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11603 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11605 switch (elf_header
.e_machine
)
11608 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11610 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11612 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11614 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11616 return reloc_type
== 44; /* R_PPC64_REL64. */
11617 case EM_SPARC32PLUS
:
11620 return reloc_type
== 46; /* R_SPARC_DISP64. */
11624 return reloc_type
== 24; /* R_X86_64_PC64. */
11627 return reloc_type
== 23; /* R_S390_PC64. */
11629 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11635 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11636 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11639 is_24bit_abs_reloc (unsigned int reloc_type
)
11641 switch (elf_header
.e_machine
)
11643 case EM_CYGNUS_MN10200
:
11645 return reloc_type
== 4; /* R_MN10200_24. */
11651 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11652 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11655 is_16bit_abs_reloc (unsigned int reloc_type
)
11657 switch (elf_header
.e_machine
)
11660 case EM_ARC_COMPACT
:
11661 case EM_ARC_COMPACT2
:
11662 return reloc_type
== 2; /* R_ARC_16. */
11665 return reloc_type
== 4; /* R_AVR_16. */
11666 case EM_ADAPTEVA_EPIPHANY
:
11667 return reloc_type
== 5;
11668 case EM_CYGNUS_D10V
:
11670 return reloc_type
== 3; /* R_D10V_16. */
11674 return reloc_type
== R_H8_DIR16
;
11677 return reloc_type
== 1; /* R_IP2K_16. */
11680 return reloc_type
== 1; /* R_M32C_16 */
11682 if (uses_msp430x_relocs ())
11683 return reloc_type
== 2; /* R_MSP430_ABS16. */
11684 case EM_MSP430_OLD
:
11685 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11687 return reloc_type
== 19; /* R_NDS32_RELA. */
11688 case EM_ALTERA_NIOS2
:
11689 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11691 return reloc_type
== 9; /* R_NIOS_16. */
11693 return reloc_type
== 2; /* R_OR1K_16. */
11695 return reloc_type
== 2; /* R_C6000_ABS16. */
11698 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11699 case EM_CYGNUS_MN10200
:
11701 return reloc_type
== 2; /* R_MN10200_16. */
11702 case EM_CYGNUS_MN10300
:
11704 return reloc_type
== 2; /* R_MN10300_16. */
11706 return reloc_type
== 2; /* R_VISIUM_16. */
11708 return reloc_type
== 3; /* R_XGATE_16. */
11714 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11715 relocation entries (possibly formerly used for SHT_GROUP sections). */
11718 is_none_reloc (unsigned int reloc_type
)
11720 switch (elf_header
.e_machine
)
11722 case EM_68K
: /* R_68K_NONE. */
11723 case EM_386
: /* R_386_NONE. */
11724 case EM_SPARC32PLUS
:
11726 case EM_SPARC
: /* R_SPARC_NONE. */
11727 case EM_MIPS
: /* R_MIPS_NONE. */
11728 case EM_PARISC
: /* R_PARISC_NONE. */
11729 case EM_ALPHA
: /* R_ALPHA_NONE. */
11730 case EM_ADAPTEVA_EPIPHANY
:
11731 case EM_PPC
: /* R_PPC_NONE. */
11732 case EM_PPC64
: /* R_PPC64_NONE. */
11733 case EM_ARC
: /* R_ARC_NONE. */
11734 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
11735 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
11736 case EM_ARM
: /* R_ARM_NONE. */
11737 case EM_IA_64
: /* R_IA64_NONE. */
11738 case EM_SH
: /* R_SH_NONE. */
11740 case EM_S390
: /* R_390_NONE. */
11741 case EM_CRIS
: /* R_CRIS_NONE. */
11742 case EM_X86_64
: /* R_X86_64_NONE. */
11743 case EM_L1OM
: /* R_X86_64_NONE. */
11744 case EM_K1OM
: /* R_X86_64_NONE. */
11745 case EM_MN10300
: /* R_MN10300_NONE. */
11746 case EM_FT32
: /* R_FT32_NONE. */
11747 case EM_MOXIE
: /* R_MOXIE_NONE. */
11748 case EM_M32R
: /* R_M32R_NONE. */
11749 case EM_TI_C6000
:/* R_C6000_NONE. */
11750 case EM_TILEGX
: /* R_TILEGX_NONE. */
11751 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11753 case EM_C166
: /* R_XC16X_NONE. */
11754 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11755 case EM_NIOS32
: /* R_NIOS_NONE. */
11756 case EM_OR1K
: /* R_OR1K_NONE. */
11757 return reloc_type
== 0;
11759 return reloc_type
== 0 || reloc_type
== 256;
11761 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11762 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11763 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11764 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11765 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11766 case EM_XTENSA_OLD
:
11768 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11769 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11770 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11771 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11773 return reloc_type
== 3; /* R_METAG_NONE. */
11778 /* Returns TRUE if there is a relocation against
11779 section NAME at OFFSET bytes. */
11782 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
11784 Elf_Internal_Rela
* relocs
;
11785 Elf_Internal_Rela
* rp
;
11787 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
11790 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
11792 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
11793 if (rp
->r_offset
== offset
)
11799 /* Apply relocations to a section.
11800 Note: So far support has been added only for those relocations
11801 which can be found in debug sections.
11802 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11803 loaded relocs. It is then the caller's responsibility to free them.
11804 FIXME: Add support for more relocations ? */
11807 apply_relocations (void * file
,
11808 const Elf_Internal_Shdr
* section
,
11809 unsigned char * start
,
11810 bfd_size_type size
,
11811 void ** relocs_return
,
11812 unsigned long * num_relocs_return
)
11814 Elf_Internal_Shdr
* relsec
;
11815 unsigned char * end
= start
+ size
;
11817 if (relocs_return
!= NULL
)
11819 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
11820 * num_relocs_return
= 0;
11823 if (elf_header
.e_type
!= ET_REL
)
11826 /* Find the reloc section associated with the section. */
11827 for (relsec
= section_headers
;
11828 relsec
< section_headers
+ elf_header
.e_shnum
;
11831 bfd_boolean is_rela
;
11832 unsigned long num_relocs
;
11833 Elf_Internal_Rela
* relocs
;
11834 Elf_Internal_Rela
* rp
;
11835 Elf_Internal_Shdr
* symsec
;
11836 Elf_Internal_Sym
* symtab
;
11837 unsigned long num_syms
;
11838 Elf_Internal_Sym
* sym
;
11840 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11841 || relsec
->sh_info
>= elf_header
.e_shnum
11842 || section_headers
+ relsec
->sh_info
!= section
11843 || relsec
->sh_size
== 0
11844 || relsec
->sh_link
>= elf_header
.e_shnum
)
11847 is_rela
= relsec
->sh_type
== SHT_RELA
;
11851 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11852 relsec
->sh_size
, & relocs
, & num_relocs
))
11857 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11858 relsec
->sh_size
, & relocs
, & num_relocs
))
11862 /* SH uses RELA but uses in place value instead of the addend field. */
11863 if (elf_header
.e_machine
== EM_SH
)
11866 symsec
= section_headers
+ relsec
->sh_link
;
11867 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11869 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11872 unsigned int reloc_type
;
11873 unsigned int reloc_size
;
11874 unsigned char * rloc
;
11875 unsigned long sym_index
;
11877 reloc_type
= get_reloc_type (rp
->r_info
);
11879 if (target_specific_reloc_handling (rp
, start
, symtab
))
11881 else if (is_none_reloc (reloc_type
))
11883 else if (is_32bit_abs_reloc (reloc_type
)
11884 || is_32bit_pcrel_reloc (reloc_type
))
11886 else if (is_64bit_abs_reloc (reloc_type
)
11887 || is_64bit_pcrel_reloc (reloc_type
))
11889 else if (is_24bit_abs_reloc (reloc_type
))
11891 else if (is_16bit_abs_reloc (reloc_type
))
11895 static unsigned int prev_reloc
= 0;
11896 if (reloc_type
!= prev_reloc
)
11897 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11898 reloc_type
, printable_section_name (section
));
11899 prev_reloc
= reloc_type
;
11903 rloc
= start
+ rp
->r_offset
;
11904 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11906 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11907 (unsigned long) rp
->r_offset
,
11908 printable_section_name (section
));
11912 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11913 if (sym_index
>= num_syms
)
11915 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11916 sym_index
, printable_section_name (section
));
11919 sym
= symtab
+ sym_index
;
11921 /* If the reloc has a symbol associated with it,
11922 make sure that it is of an appropriate type.
11924 Relocations against symbols without type can happen.
11925 Gcc -feliminate-dwarf2-dups may generate symbols
11926 without type for debug info.
11928 Icc generates relocations against function symbols
11929 instead of local labels.
11931 Relocations against object symbols can happen, eg when
11932 referencing a global array. For an example of this see
11933 the _clz.o binary in libgcc.a. */
11935 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11937 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11938 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11939 (long int)(rp
- relocs
),
11940 printable_section_name (relsec
));
11946 addend
+= rp
->r_addend
;
11947 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11948 partial_inplace. */
11950 || (elf_header
.e_machine
== EM_XTENSA
11951 && reloc_type
== 1)
11952 || ((elf_header
.e_machine
== EM_PJ
11953 || elf_header
.e_machine
== EM_PJ_OLD
)
11954 && reloc_type
== 1)
11955 || ((elf_header
.e_machine
== EM_D30V
11956 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11957 && reloc_type
== 12))
11958 addend
+= byte_get (rloc
, reloc_size
);
11960 if (is_32bit_pcrel_reloc (reloc_type
)
11961 || is_64bit_pcrel_reloc (reloc_type
))
11963 /* On HPPA, all pc-relative relocations are biased by 8. */
11964 if (elf_header
.e_machine
== EM_PARISC
)
11966 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
11970 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
11977 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
11978 * num_relocs_return
= num_relocs
;
11987 #ifdef SUPPORT_DISASSEMBLY
11989 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
11991 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
11993 /* FIXME: XXX -- to be done --- XXX */
11999 /* Reads in the contents of SECTION from FILE, returning a pointer
12000 to a malloc'ed buffer or NULL if something went wrong. */
12003 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12005 bfd_size_type num_bytes
;
12007 num_bytes
= section
->sh_size
;
12009 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12011 printf (_("\nSection '%s' has no data to dump.\n"),
12012 printable_section_name (section
));
12016 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12017 _("section contents"));
12020 /* Uncompresses a section that was compressed using zlib, in place. */
12023 uncompress_section_contents (unsigned char **buffer
,
12024 dwarf_size_type uncompressed_size
,
12025 dwarf_size_type
*size
)
12027 dwarf_size_type compressed_size
= *size
;
12028 unsigned char * compressed_buffer
= *buffer
;
12029 unsigned char * uncompressed_buffer
;
12033 /* It is possible the section consists of several compressed
12034 buffers concatenated together, so we uncompress in a loop. */
12035 /* PR 18313: The state field in the z_stream structure is supposed
12036 to be invisible to the user (ie us), but some compilers will
12037 still complain about it being used without initialisation. So
12038 we first zero the entire z_stream structure and then set the fields
12040 memset (& strm
, 0, sizeof strm
);
12041 strm
.avail_in
= compressed_size
;
12042 strm
.next_in
= (Bytef
*) compressed_buffer
;
12043 strm
.avail_out
= uncompressed_size
;
12044 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12046 rc
= inflateInit (& strm
);
12047 while (strm
.avail_in
> 0)
12051 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12052 + (uncompressed_size
- strm
.avail_out
));
12053 rc
= inflate (&strm
, Z_FINISH
);
12054 if (rc
!= Z_STREAM_END
)
12056 rc
= inflateReset (& strm
);
12058 rc
= inflateEnd (& strm
);
12060 || strm
.avail_out
!= 0)
12063 *buffer
= uncompressed_buffer
;
12064 *size
= uncompressed_size
;
12068 free (uncompressed_buffer
);
12069 /* Indicate decompression failure. */
12075 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12077 Elf_Internal_Shdr
* relsec
;
12078 bfd_size_type num_bytes
;
12079 unsigned char * data
;
12080 unsigned char * end
;
12081 unsigned char * real_start
;
12082 unsigned char * start
;
12083 bfd_boolean some_strings_shown
;
12085 real_start
= start
= (unsigned char *) get_section_contents (section
,
12089 num_bytes
= section
->sh_size
;
12091 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12093 if (decompress_dumps
)
12095 dwarf_size_type new_size
= num_bytes
;
12096 dwarf_size_type uncompressed_size
= 0;
12098 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12100 Elf_Internal_Chdr chdr
;
12101 unsigned int compression_header_size
12102 = get_compression_header (& chdr
, (unsigned char *) start
);
12104 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12106 warn (_("section '%s' has unsupported compress type: %d\n"),
12107 printable_section_name (section
), chdr
.ch_type
);
12110 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12112 warn (_("compressed section '%s' is corrupted\n"),
12113 printable_section_name (section
));
12116 uncompressed_size
= chdr
.ch_size
;
12117 start
+= compression_header_size
;
12118 new_size
-= compression_header_size
;
12120 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12122 /* Read the zlib header. In this case, it should be "ZLIB"
12123 followed by the uncompressed section size, 8 bytes in
12124 big-endian order. */
12125 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12126 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12127 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12128 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12129 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12130 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12131 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12132 uncompressed_size
+= start
[11];
12137 if (uncompressed_size
12138 && uncompress_section_contents (& start
,
12139 uncompressed_size
, & new_size
))
12140 num_bytes
= new_size
;
12143 /* If the section being dumped has relocations against it the user might
12144 be expecting these relocations to have been applied. Check for this
12145 case and issue a warning message in order to avoid confusion.
12146 FIXME: Maybe we ought to have an option that dumps a section with
12147 relocs applied ? */
12148 for (relsec
= section_headers
;
12149 relsec
< section_headers
+ elf_header
.e_shnum
;
12152 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12153 || relsec
->sh_info
>= elf_header
.e_shnum
12154 || section_headers
+ relsec
->sh_info
!= section
12155 || relsec
->sh_size
== 0
12156 || relsec
->sh_link
>= elf_header
.e_shnum
)
12159 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12164 end
= start
+ num_bytes
;
12165 some_strings_shown
= FALSE
;
12169 while (!ISPRINT (* data
))
12170 if (++ data
>= end
)
12175 size_t maxlen
= end
- data
;
12178 /* PR 11128: Use two separate invocations in order to work
12179 around bugs in the Solaris 8 implementation of printf. */
12180 printf (" [%6tx] ", data
- start
);
12182 printf (" [%6Ix] ", (size_t) (data
- start
));
12186 print_symbol ((int) maxlen
, (const char *) data
);
12188 data
+= strnlen ((const char *) data
, maxlen
);
12192 printf (_("<corrupt>\n"));
12195 some_strings_shown
= TRUE
;
12199 if (! some_strings_shown
)
12200 printf (_(" No strings found in this section."));
12208 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12210 bfd_boolean relocate
)
12212 Elf_Internal_Shdr
* relsec
;
12213 bfd_size_type bytes
;
12214 bfd_size_type section_size
;
12216 unsigned char * data
;
12217 unsigned char * real_start
;
12218 unsigned char * start
;
12220 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12223 section_size
= section
->sh_size
;
12225 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12227 if (decompress_dumps
)
12229 dwarf_size_type new_size
= section_size
;
12230 dwarf_size_type uncompressed_size
= 0;
12232 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12234 Elf_Internal_Chdr chdr
;
12235 unsigned int compression_header_size
12236 = get_compression_header (& chdr
, start
);
12238 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12240 warn (_("section '%s' has unsupported compress type: %d\n"),
12241 printable_section_name (section
), chdr
.ch_type
);
12244 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12246 warn (_("compressed section '%s' is corrupted\n"),
12247 printable_section_name (section
));
12250 uncompressed_size
= chdr
.ch_size
;
12251 start
+= compression_header_size
;
12252 new_size
-= compression_header_size
;
12254 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12256 /* Read the zlib header. In this case, it should be "ZLIB"
12257 followed by the uncompressed section size, 8 bytes in
12258 big-endian order. */
12259 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12260 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12261 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12262 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12263 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12264 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12265 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12266 uncompressed_size
+= start
[11];
12271 if (uncompressed_size
12272 && uncompress_section_contents (& start
, uncompressed_size
,
12274 section_size
= new_size
;
12279 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12283 /* If the section being dumped has relocations against it the user might
12284 be expecting these relocations to have been applied. Check for this
12285 case and issue a warning message in order to avoid confusion.
12286 FIXME: Maybe we ought to have an option that dumps a section with
12287 relocs applied ? */
12288 for (relsec
= section_headers
;
12289 relsec
< section_headers
+ elf_header
.e_shnum
;
12292 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12293 || relsec
->sh_info
>= elf_header
.e_shnum
12294 || section_headers
+ relsec
->sh_info
!= section
12295 || relsec
->sh_size
== 0
12296 || relsec
->sh_link
>= elf_header
.e_shnum
)
12299 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12304 addr
= section
->sh_addr
;
12305 bytes
= section_size
;
12314 lbytes
= (bytes
> 16 ? 16 : bytes
);
12316 printf (" 0x%8.8lx ", (unsigned long) addr
);
12318 for (j
= 0; j
< 16; j
++)
12321 printf ("%2.2x", data
[j
]);
12329 for (j
= 0; j
< lbytes
; j
++)
12332 if (k
>= ' ' && k
< 0x7f)
12351 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12352 const Elf_Internal_Shdr
* sec
, void * file
)
12354 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12357 /* If it is already loaded, do nothing. */
12358 if (section
->start
!= NULL
)
12361 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12362 section
->address
= sec
->sh_addr
;
12363 section
->user_data
= NULL
;
12364 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12366 sec
->sh_size
, buf
);
12367 if (section
->start
== NULL
)
12371 unsigned char *start
= section
->start
;
12372 dwarf_size_type size
= sec
->sh_size
;
12373 dwarf_size_type uncompressed_size
= 0;
12375 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12377 Elf_Internal_Chdr chdr
;
12378 unsigned int compression_header_size
12379 = get_compression_header (&chdr
, start
);
12380 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12382 warn (_("section '%s' has unsupported compress type: %d\n"),
12383 section
->name
, chdr
.ch_type
);
12386 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12388 warn (_("compressed section '%s' is corrupted\n"),
12392 uncompressed_size
= chdr
.ch_size
;
12393 start
+= compression_header_size
;
12394 size
-= compression_header_size
;
12396 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12398 /* Read the zlib header. In this case, it should be "ZLIB"
12399 followed by the uncompressed section size, 8 bytes in
12400 big-endian order. */
12401 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12402 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12403 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12404 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12405 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12406 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12407 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12408 uncompressed_size
+= start
[11];
12413 if (uncompressed_size
12414 && uncompress_section_contents (&start
, uncompressed_size
,
12417 /* Free the compressed buffer, update the section buffer
12418 and the section size if uncompress is successful. */
12419 free (section
->start
);
12420 section
->start
= start
;
12422 section
->size
= size
;
12425 if (section
->start
== NULL
)
12428 if (debug_displays
[debug
].relocate
)
12429 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12430 & section
->reloc_info
, & section
->num_relocs
);
12433 section
->reloc_info
= NULL
;
12434 section
->num_relocs
= 0;
12440 /* If this is not NULL, load_debug_section will only look for sections
12441 within the list of sections given here. */
12442 unsigned int *section_subset
= NULL
;
12445 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12447 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12448 Elf_Internal_Shdr
* sec
;
12450 /* Locate the debug section. */
12451 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12453 section
->name
= section
->uncompressed_name
;
12456 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12458 section
->name
= section
->compressed_name
;
12463 /* If we're loading from a subset of sections, and we've loaded
12464 a section matching this name before, it's likely that it's a
12466 if (section_subset
!= NULL
)
12467 free_debug_section (debug
);
12469 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12473 free_debug_section (enum dwarf_section_display_enum debug
)
12475 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12477 if (section
->start
== NULL
)
12480 free ((char *) section
->start
);
12481 section
->start
= NULL
;
12482 section
->address
= 0;
12487 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12489 char * name
= SECTION_NAME (section
);
12490 const char * print_name
= printable_section_name (section
);
12491 bfd_size_type length
;
12495 length
= section
->sh_size
;
12498 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12501 if (section
->sh_type
== SHT_NOBITS
)
12503 /* There is no point in dumping the contents of a debugging section
12504 which has the NOBITS type - the bits in the file will be random.
12505 This can happen when a file containing a .eh_frame section is
12506 stripped with the --only-keep-debug command line option. */
12507 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12512 if (const_strneq (name
, ".gnu.linkonce.wi."))
12513 name
= ".debug_info";
12515 /* See if we know how to display the contents of this section. */
12516 for (i
= 0; i
< max
; i
++)
12517 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12518 || (i
== line
&& const_strneq (name
, ".debug_line."))
12519 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12521 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12522 int secondary
= (section
!= find_section (name
));
12525 free_debug_section ((enum dwarf_section_display_enum
) i
);
12527 if (i
== line
&& const_strneq (name
, ".debug_line."))
12529 else if (streq (sec
->uncompressed_name
, name
))
12530 sec
->name
= sec
->uncompressed_name
;
12532 sec
->name
= sec
->compressed_name
;
12533 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12536 /* If this debug section is part of a CU/TU set in a .dwp file,
12537 restrict load_debug_section to the sections in that set. */
12538 section_subset
= find_cu_tu_set (file
, shndx
);
12540 result
&= debug_displays
[i
].display (sec
, file
);
12542 section_subset
= NULL
;
12544 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12545 free_debug_section ((enum dwarf_section_display_enum
) i
);
12553 printf (_("Unrecognized debug section: %s\n"), print_name
);
12560 /* Set DUMP_SECTS for all sections where dumps were requested
12561 based on section name. */
12564 initialise_dumps_byname (void)
12566 struct dump_list_entry
* cur
;
12568 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12573 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12574 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12576 request_dump_bynumber (i
, cur
->type
);
12581 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12587 process_section_contents (FILE * file
)
12589 Elf_Internal_Shdr
* section
;
12595 initialise_dumps_byname ();
12597 for (i
= 0, section
= section_headers
;
12598 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12601 #ifdef SUPPORT_DISASSEMBLY
12602 if (dump_sects
[i
] & DISASS_DUMP
)
12603 disassemble_section (section
, file
);
12605 if (dump_sects
[i
] & HEX_DUMP
)
12606 dump_section_as_bytes (section
, file
, FALSE
);
12608 if (dump_sects
[i
] & RELOC_DUMP
)
12609 dump_section_as_bytes (section
, file
, TRUE
);
12611 if (dump_sects
[i
] & STRING_DUMP
)
12612 dump_section_as_strings (section
, file
);
12614 if (dump_sects
[i
] & DEBUG_DUMP
)
12615 display_debug_section (i
, section
, file
);
12618 /* Check to see if the user requested a
12619 dump of a section that does not exist. */
12620 while (i
++ < num_dump_sects
)
12622 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12626 process_mips_fpe_exception (int mask
)
12631 if (mask
& OEX_FPU_INEX
)
12632 fputs ("INEX", stdout
), first
= 0;
12633 if (mask
& OEX_FPU_UFLO
)
12634 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12635 if (mask
& OEX_FPU_OFLO
)
12636 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12637 if (mask
& OEX_FPU_DIV0
)
12638 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12639 if (mask
& OEX_FPU_INVAL
)
12640 printf ("%sINVAL", first
? "" : "|");
12643 fputs ("0", stdout
);
12646 /* Display's the value of TAG at location P. If TAG is
12647 greater than 0 it is assumed to be an unknown tag, and
12648 a message is printed to this effect. Otherwise it is
12649 assumed that a message has already been printed.
12651 If the bottom bit of TAG is set it assumed to have a
12652 string value, otherwise it is assumed to have an integer
12655 Returns an updated P pointing to the first unread byte
12656 beyond the end of TAG's value.
12658 Reads at or beyond END will not be made. */
12660 static unsigned char *
12661 display_tag_value (int tag
,
12663 const unsigned char * const end
)
12668 printf (" Tag_unknown_%d: ", tag
);
12672 warn (_("<corrupt tag>\n"));
12676 /* PR 17531 file: 027-19978-0.004. */
12677 size_t maxlen
= (end
- p
) - 1;
12682 print_symbol ((int) maxlen
, (const char *) p
);
12683 p
+= strnlen ((char *) p
, maxlen
) + 1;
12687 printf (_("<corrupt string tag>"));
12688 p
= (unsigned char *) end
;
12696 val
= read_uleb128 (p
, &len
, end
);
12698 printf ("%ld (0x%lx)\n", val
, val
);
12705 /* ARM EABI attributes section. */
12710 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12712 const char ** table
;
12713 } arm_attr_public_tag
;
12715 static const char * arm_attr_tag_CPU_arch
[] =
12716 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12717 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12718 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12719 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12720 {"No", "Thumb-1", "Thumb-2"};
12721 static const char * arm_attr_tag_FP_arch
[] =
12722 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12723 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12724 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12725 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12726 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12727 static const char * arm_attr_tag_PCS_config
[] =
12728 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12729 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12730 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12731 {"V6", "SB", "TLS", "Unused"};
12732 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12733 {"Absolute", "PC-relative", "SB-relative", "None"};
12734 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12735 {"Absolute", "PC-relative", "None"};
12736 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12737 {"None", "direct", "GOT-indirect"};
12738 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12739 {"None", "??? 1", "2", "??? 3", "4"};
12740 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12741 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12742 {"Unused", "Needed", "Sign only"};
12743 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12744 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12745 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12746 {"Unused", "Finite", "RTABI", "IEEE 754"};
12747 static const char * arm_attr_tag_ABI_enum_size
[] =
12748 {"Unused", "small", "int", "forced to int"};
12749 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12750 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12751 static const char * arm_attr_tag_ABI_VFP_args
[] =
12752 {"AAPCS", "VFP registers", "custom", "compatible"};
12753 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12754 {"AAPCS", "WMMX registers", "custom"};
12755 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12756 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12757 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12758 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12759 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12760 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12761 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12762 static const char * arm_attr_tag_FP_HP_extension
[] =
12763 {"Not Allowed", "Allowed"};
12764 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12765 {"None", "IEEE 754", "Alternative Format"};
12766 static const char * arm_attr_tag_MPextension_use
[] =
12767 {"Not Allowed", "Allowed"};
12768 static const char * arm_attr_tag_DIV_use
[] =
12769 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12770 "Allowed in v7-A with integer division extension"};
12771 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12772 static const char * arm_attr_tag_Virtualization_use
[] =
12773 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12774 "TrustZone and Virtualization Extensions"};
12775 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12776 {"Not Allowed", "Allowed"};
12778 #define LOOKUP(id, name) \
12779 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12780 static arm_attr_public_tag arm_attr_public_tags
[] =
12782 {4, "CPU_raw_name", 1, NULL
},
12783 {5, "CPU_name", 1, NULL
},
12784 LOOKUP(6, CPU_arch
),
12785 {7, "CPU_arch_profile", 0, NULL
},
12786 LOOKUP(8, ARM_ISA_use
),
12787 LOOKUP(9, THUMB_ISA_use
),
12788 LOOKUP(10, FP_arch
),
12789 LOOKUP(11, WMMX_arch
),
12790 LOOKUP(12, Advanced_SIMD_arch
),
12791 LOOKUP(13, PCS_config
),
12792 LOOKUP(14, ABI_PCS_R9_use
),
12793 LOOKUP(15, ABI_PCS_RW_data
),
12794 LOOKUP(16, ABI_PCS_RO_data
),
12795 LOOKUP(17, ABI_PCS_GOT_use
),
12796 LOOKUP(18, ABI_PCS_wchar_t
),
12797 LOOKUP(19, ABI_FP_rounding
),
12798 LOOKUP(20, ABI_FP_denormal
),
12799 LOOKUP(21, ABI_FP_exceptions
),
12800 LOOKUP(22, ABI_FP_user_exceptions
),
12801 LOOKUP(23, ABI_FP_number_model
),
12802 {24, "ABI_align_needed", 0, NULL
},
12803 {25, "ABI_align_preserved", 0, NULL
},
12804 LOOKUP(26, ABI_enum_size
),
12805 LOOKUP(27, ABI_HardFP_use
),
12806 LOOKUP(28, ABI_VFP_args
),
12807 LOOKUP(29, ABI_WMMX_args
),
12808 LOOKUP(30, ABI_optimization_goals
),
12809 LOOKUP(31, ABI_FP_optimization_goals
),
12810 {32, "compatibility", 0, NULL
},
12811 LOOKUP(34, CPU_unaligned_access
),
12812 LOOKUP(36, FP_HP_extension
),
12813 LOOKUP(38, ABI_FP_16bit_format
),
12814 LOOKUP(42, MPextension_use
),
12815 LOOKUP(44, DIV_use
),
12816 {64, "nodefaults", 0, NULL
},
12817 {65, "also_compatible_with", 0, NULL
},
12818 LOOKUP(66, T2EE_use
),
12819 {67, "conformance", 1, NULL
},
12820 LOOKUP(68, Virtualization_use
),
12821 LOOKUP(70, MPextension_use_legacy
)
12825 static unsigned char *
12826 display_arm_attribute (unsigned char * p
,
12827 const unsigned char * const end
)
12832 arm_attr_public_tag
* attr
;
12836 tag
= read_uleb128 (p
, &len
, end
);
12839 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12841 if (arm_attr_public_tags
[i
].tag
== tag
)
12843 attr
= &arm_attr_public_tags
[i
];
12850 printf (" Tag_%s: ", attr
->name
);
12851 switch (attr
->type
)
12856 case 7: /* Tag_CPU_arch_profile. */
12857 val
= read_uleb128 (p
, &len
, end
);
12861 case 0: printf (_("None\n")); break;
12862 case 'A': printf (_("Application\n")); break;
12863 case 'R': printf (_("Realtime\n")); break;
12864 case 'M': printf (_("Microcontroller\n")); break;
12865 case 'S': printf (_("Application or Realtime\n")); break;
12866 default: printf ("??? (%d)\n", val
); break;
12870 case 24: /* Tag_align_needed. */
12871 val
= read_uleb128 (p
, &len
, end
);
12875 case 0: printf (_("None\n")); break;
12876 case 1: printf (_("8-byte\n")); break;
12877 case 2: printf (_("4-byte\n")); break;
12878 case 3: printf ("??? 3\n"); break;
12881 printf (_("8-byte and up to %d-byte extended\n"),
12884 printf ("??? (%d)\n", val
);
12889 case 25: /* Tag_align_preserved. */
12890 val
= read_uleb128 (p
, &len
, end
);
12894 case 0: printf (_("None\n")); break;
12895 case 1: printf (_("8-byte, except leaf SP\n")); break;
12896 case 2: printf (_("8-byte\n")); break;
12897 case 3: printf ("??? 3\n"); break;
12900 printf (_("8-byte and up to %d-byte extended\n"),
12903 printf ("??? (%d)\n", val
);
12908 case 32: /* Tag_compatibility. */
12910 val
= read_uleb128 (p
, &len
, end
);
12912 printf (_("flag = %d, vendor = "), val
);
12915 size_t maxlen
= (end
- p
) - 1;
12917 print_symbol ((int) maxlen
, (const char *) p
);
12918 p
+= strnlen ((char *) p
, maxlen
) + 1;
12922 printf (_("<corrupt>"));
12923 p
= (unsigned char *) end
;
12929 case 64: /* Tag_nodefaults. */
12930 /* PR 17531: file: 001-505008-0.01. */
12933 printf (_("True\n"));
12936 case 65: /* Tag_also_compatible_with. */
12937 val
= read_uleb128 (p
, &len
, end
);
12939 if (val
== 6 /* Tag_CPU_arch. */)
12941 val
= read_uleb128 (p
, &len
, end
);
12943 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12944 printf ("??? (%d)\n", val
);
12946 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12950 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12955 printf (_("<unknown: %d>\n"), tag
);
12961 return display_tag_value (-1, p
, end
);
12963 return display_tag_value (0, p
, end
);
12966 assert (attr
->type
& 0x80);
12967 val
= read_uleb128 (p
, &len
, end
);
12969 type
= attr
->type
& 0x7f;
12971 printf ("??? (%d)\n", val
);
12973 printf ("%s\n", attr
->table
[val
]);
12978 return display_tag_value (tag
, p
, end
);
12981 static unsigned char *
12982 display_gnu_attribute (unsigned char * p
,
12983 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
12984 const unsigned char * const end
)
12990 tag
= read_uleb128 (p
, &len
, end
);
12993 /* Tag_compatibility is the only generic GNU attribute defined at
12997 val
= read_uleb128 (p
, &len
, end
);
13000 printf (_("flag = %d, vendor = "), val
);
13003 printf (_("<corrupt>\n"));
13004 warn (_("corrupt vendor attribute\n"));
13010 size_t maxlen
= (end
- p
) - 1;
13012 print_symbol ((int) maxlen
, (const char *) p
);
13013 p
+= strnlen ((char *) p
, maxlen
) + 1;
13017 printf (_("<corrupt>"));
13018 p
= (unsigned char *) end
;
13025 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13026 return display_proc_gnu_attribute (p
, tag
, end
);
13028 return display_tag_value (tag
, p
, end
);
13031 static unsigned char *
13032 display_power_gnu_attribute (unsigned char * p
,
13034 const unsigned char * const end
)
13039 if (tag
== Tag_GNU_Power_ABI_FP
)
13041 val
= read_uleb128 (p
, &len
, end
);
13043 printf (" Tag_GNU_Power_ABI_FP: ");
13048 printf (_("Hard or soft float\n"));
13051 printf (_("Hard float\n"));
13054 printf (_("Soft float\n"));
13057 printf (_("Single-precision hard float\n"));
13060 printf ("??? (%d)\n", val
);
13066 if (tag
== Tag_GNU_Power_ABI_Vector
)
13068 val
= read_uleb128 (p
, &len
, end
);
13070 printf (" Tag_GNU_Power_ABI_Vector: ");
13074 printf (_("Any\n"));
13077 printf (_("Generic\n"));
13080 printf ("AltiVec\n");
13086 printf ("??? (%d)\n", val
);
13092 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13096 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13100 val
= read_uleb128 (p
, &len
, end
);
13102 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13106 printf (_("Any\n"));
13109 printf ("r3/r4\n");
13112 printf (_("Memory\n"));
13115 printf ("??? (%d)\n", val
);
13121 return display_tag_value (tag
& 1, p
, end
);
13124 static unsigned char *
13125 display_s390_gnu_attribute (unsigned char * p
,
13127 const unsigned char * const end
)
13132 if (tag
== Tag_GNU_S390_ABI_Vector
)
13134 val
= read_uleb128 (p
, &len
, end
);
13136 printf (" Tag_GNU_S390_ABI_Vector: ");
13141 printf (_("any\n"));
13144 printf (_("software\n"));
13147 printf (_("hardware\n"));
13150 printf ("??? (%d)\n", val
);
13156 return display_tag_value (tag
& 1, p
, end
);
13160 display_sparc_hwcaps (int mask
)
13166 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13167 fputs ("mul32", stdout
), first
= 0;
13168 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13169 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13170 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13171 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13172 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13173 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13174 if (mask
& ELF_SPARC_HWCAP_POPC
)
13175 printf ("%spopc", first
? "" : "|"), first
= 0;
13176 if (mask
& ELF_SPARC_HWCAP_VIS
)
13177 printf ("%svis", first
? "" : "|"), first
= 0;
13178 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13179 printf ("%svis2", first
? "" : "|"), first
= 0;
13180 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13181 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13182 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13183 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13184 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13185 printf ("%svis3", first
? "" : "|"), first
= 0;
13186 if (mask
& ELF_SPARC_HWCAP_HPC
)
13187 printf ("%shpc", first
? "" : "|"), first
= 0;
13188 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13189 printf ("%srandom", first
? "" : "|"), first
= 0;
13190 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13191 printf ("%strans", first
? "" : "|"), first
= 0;
13192 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13193 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13194 if (mask
& ELF_SPARC_HWCAP_IMA
)
13195 printf ("%sima", first
? "" : "|"), first
= 0;
13196 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13197 printf ("%scspare", first
? "" : "|"), first
= 0;
13200 fputc ('0', stdout
);
13201 fputc ('\n', stdout
);
13205 display_sparc_hwcaps2 (int mask
)
13211 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13212 fputs ("fjathplus", stdout
), first
= 0;
13213 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13214 printf ("%svis3b", first
? "" : "|"), first
= 0;
13215 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13216 printf ("%sadp", first
? "" : "|"), first
= 0;
13217 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13218 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13219 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13220 printf ("%smwait", first
? "" : "|"), first
= 0;
13221 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13222 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13223 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13224 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13225 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13226 printf ("%snsec", first
? "" : "|"), first
= 0;
13227 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13228 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13229 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13230 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13231 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13232 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13235 fputc ('0', stdout
);
13236 fputc ('\n', stdout
);
13239 static unsigned char *
13240 display_sparc_gnu_attribute (unsigned char * p
,
13242 const unsigned char * const end
)
13247 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13249 val
= read_uleb128 (p
, &len
, end
);
13251 printf (" Tag_GNU_Sparc_HWCAPS: ");
13252 display_sparc_hwcaps (val
);
13255 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13257 val
= read_uleb128 (p
, &len
, end
);
13259 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13260 display_sparc_hwcaps2 (val
);
13264 return display_tag_value (tag
, p
, end
);
13268 print_mips_fp_abi_value (int val
)
13272 case Val_GNU_MIPS_ABI_FP_ANY
:
13273 printf (_("Hard or soft float\n"));
13275 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13276 printf (_("Hard float (double precision)\n"));
13278 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13279 printf (_("Hard float (single precision)\n"));
13281 case Val_GNU_MIPS_ABI_FP_SOFT
:
13282 printf (_("Soft float\n"));
13284 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13285 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13287 case Val_GNU_MIPS_ABI_FP_XX
:
13288 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13290 case Val_GNU_MIPS_ABI_FP_64
:
13291 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13293 case Val_GNU_MIPS_ABI_FP_64A
:
13294 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13296 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13297 printf (_("NaN 2008 compatibility\n"));
13300 printf ("??? (%d)\n", val
);
13305 static unsigned char *
13306 display_mips_gnu_attribute (unsigned char * p
,
13308 const unsigned char * const end
)
13310 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13315 val
= read_uleb128 (p
, &len
, end
);
13317 printf (" Tag_GNU_MIPS_ABI_FP: ");
13319 print_mips_fp_abi_value (val
);
13324 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13329 val
= read_uleb128 (p
, &len
, end
);
13331 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13335 case Val_GNU_MIPS_ABI_MSA_ANY
:
13336 printf (_("Any MSA or not\n"));
13338 case Val_GNU_MIPS_ABI_MSA_128
:
13339 printf (_("128-bit MSA\n"));
13342 printf ("??? (%d)\n", val
);
13348 return display_tag_value (tag
& 1, p
, end
);
13351 static unsigned char *
13352 display_tic6x_attribute (unsigned char * p
,
13353 const unsigned char * const end
)
13359 tag
= read_uleb128 (p
, &len
, end
);
13365 val
= read_uleb128 (p
, &len
, end
);
13367 printf (" Tag_ISA: ");
13371 case C6XABI_Tag_ISA_none
:
13372 printf (_("None\n"));
13374 case C6XABI_Tag_ISA_C62X
:
13377 case C6XABI_Tag_ISA_C67X
:
13380 case C6XABI_Tag_ISA_C67XP
:
13381 printf ("C67x+\n");
13383 case C6XABI_Tag_ISA_C64X
:
13386 case C6XABI_Tag_ISA_C64XP
:
13387 printf ("C64x+\n");
13389 case C6XABI_Tag_ISA_C674X
:
13390 printf ("C674x\n");
13393 printf ("??? (%d)\n", val
);
13398 case Tag_ABI_wchar_t
:
13399 val
= read_uleb128 (p
, &len
, end
);
13401 printf (" Tag_ABI_wchar_t: ");
13405 printf (_("Not used\n"));
13408 printf (_("2 bytes\n"));
13411 printf (_("4 bytes\n"));
13414 printf ("??? (%d)\n", val
);
13419 case Tag_ABI_stack_align_needed
:
13420 val
= read_uleb128 (p
, &len
, end
);
13422 printf (" Tag_ABI_stack_align_needed: ");
13426 printf (_("8-byte\n"));
13429 printf (_("16-byte\n"));
13432 printf ("??? (%d)\n", val
);
13437 case Tag_ABI_stack_align_preserved
:
13438 val
= read_uleb128 (p
, &len
, end
);
13440 printf (" Tag_ABI_stack_align_preserved: ");
13444 printf (_("8-byte\n"));
13447 printf (_("16-byte\n"));
13450 printf ("??? (%d)\n", val
);
13456 val
= read_uleb128 (p
, &len
, end
);
13458 printf (" Tag_ABI_DSBT: ");
13462 printf (_("DSBT addressing not used\n"));
13465 printf (_("DSBT addressing used\n"));
13468 printf ("??? (%d)\n", val
);
13474 val
= read_uleb128 (p
, &len
, end
);
13476 printf (" Tag_ABI_PID: ");
13480 printf (_("Data addressing position-dependent\n"));
13483 printf (_("Data addressing position-independent, GOT near DP\n"));
13486 printf (_("Data addressing position-independent, GOT far from DP\n"));
13489 printf ("??? (%d)\n", val
);
13495 val
= read_uleb128 (p
, &len
, end
);
13497 printf (" Tag_ABI_PIC: ");
13501 printf (_("Code addressing position-dependent\n"));
13504 printf (_("Code addressing position-independent\n"));
13507 printf ("??? (%d)\n", val
);
13512 case Tag_ABI_array_object_alignment
:
13513 val
= read_uleb128 (p
, &len
, end
);
13515 printf (" Tag_ABI_array_object_alignment: ");
13519 printf (_("8-byte\n"));
13522 printf (_("4-byte\n"));
13525 printf (_("16-byte\n"));
13528 printf ("??? (%d)\n", val
);
13533 case Tag_ABI_array_object_align_expected
:
13534 val
= read_uleb128 (p
, &len
, end
);
13536 printf (" Tag_ABI_array_object_align_expected: ");
13540 printf (_("8-byte\n"));
13543 printf (_("4-byte\n"));
13546 printf (_("16-byte\n"));
13549 printf ("??? (%d)\n", val
);
13554 case Tag_ABI_compatibility
:
13556 val
= read_uleb128 (p
, &len
, end
);
13558 printf (" Tag_ABI_compatibility: ");
13559 printf (_("flag = %d, vendor = "), val
);
13562 size_t maxlen
= (end
- p
) - 1;
13564 print_symbol ((int) maxlen
, (const char *) p
);
13565 p
+= strnlen ((char *) p
, maxlen
) + 1;
13569 printf (_("<corrupt>"));
13570 p
= (unsigned char *) end
;
13576 case Tag_ABI_conformance
:
13578 printf (" Tag_ABI_conformance: \"");
13581 size_t maxlen
= (end
- p
) - 1;
13583 print_symbol ((int) maxlen
, (const char *) p
);
13584 p
+= strnlen ((char *) p
, maxlen
) + 1;
13588 printf (_("<corrupt>"));
13589 p
= (unsigned char *) end
;
13596 return display_tag_value (tag
, p
, end
);
13600 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13602 unsigned long addr
= 0;
13603 size_t bytes
= end
- p
;
13610 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13612 printf (" 0x%8.8lx ", addr
);
13614 for (j
= 0; j
< 16; j
++)
13617 printf ("%2.2x", p
[j
]);
13625 for (j
= 0; j
< lbytes
; j
++)
13628 if (k
>= ' ' && k
< 0x7f)
13644 static unsigned char *
13645 display_msp430x_attribute (unsigned char * p
,
13646 const unsigned char * const end
)
13652 tag
= read_uleb128 (p
, & len
, end
);
13657 case OFBA_MSPABI_Tag_ISA
:
13658 val
= read_uleb128 (p
, &len
, end
);
13660 printf (" Tag_ISA: ");
13663 case 0: printf (_("None\n")); break;
13664 case 1: printf (_("MSP430\n")); break;
13665 case 2: printf (_("MSP430X\n")); break;
13666 default: printf ("??? (%d)\n", val
); break;
13670 case OFBA_MSPABI_Tag_Code_Model
:
13671 val
= read_uleb128 (p
, &len
, end
);
13673 printf (" Tag_Code_Model: ");
13676 case 0: printf (_("None\n")); break;
13677 case 1: printf (_("Small\n")); break;
13678 case 2: printf (_("Large\n")); break;
13679 default: printf ("??? (%d)\n", val
); break;
13683 case OFBA_MSPABI_Tag_Data_Model
:
13684 val
= read_uleb128 (p
, &len
, end
);
13686 printf (" Tag_Data_Model: ");
13689 case 0: printf (_("None\n")); break;
13690 case 1: printf (_("Small\n")); break;
13691 case 2: printf (_("Large\n")); break;
13692 case 3: printf (_("Restricted Large\n")); break;
13693 default: printf ("??? (%d)\n", val
); break;
13698 printf (_(" <unknown tag %d>: "), tag
);
13705 size_t maxlen
= (end
- p
) - 1;
13707 print_symbol ((int) maxlen
, (const char *) p
);
13708 p
+= strnlen ((char *) p
, maxlen
) + 1;
13712 printf (_("<corrupt>"));
13713 p
= (unsigned char *) end
;
13719 val
= read_uleb128 (p
, &len
, end
);
13721 printf ("%d (0x%x)\n", val
, val
);
13731 process_attributes (FILE * file
,
13732 const char * public_name
,
13733 unsigned int proc_type
,
13734 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13735 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13737 Elf_Internal_Shdr
* sect
;
13740 /* Find the section header so that we get the size. */
13741 for (i
= 0, sect
= section_headers
;
13742 i
< elf_header
.e_shnum
;
13745 unsigned char * contents
;
13748 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13751 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13752 sect
->sh_size
, _("attributes"));
13753 if (contents
== NULL
)
13759 bfd_vma section_len
;
13761 section_len
= sect
->sh_size
- 1;
13764 while (section_len
> 0)
13767 unsigned int namelen
;
13768 bfd_boolean public_section
;
13769 bfd_boolean gnu_section
;
13771 if (section_len
<= 4)
13773 error (_("Tag section ends prematurely\n"));
13776 attr_len
= byte_get (p
, 4);
13779 if (attr_len
> section_len
)
13781 error (_("Bad attribute length (%u > %u)\n"),
13782 (unsigned) attr_len
, (unsigned) section_len
);
13783 attr_len
= section_len
;
13785 /* PR 17531: file: 001-101425-0.004 */
13786 else if (attr_len
< 5)
13788 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13792 section_len
-= attr_len
;
13795 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13796 if (namelen
== 0 || namelen
>= attr_len
)
13798 error (_("Corrupt attribute section name\n"));
13802 printf (_("Attribute Section: "));
13803 print_symbol (INT_MAX
, (const char *) p
);
13806 if (public_name
&& streq ((char *) p
, public_name
))
13807 public_section
= TRUE
;
13809 public_section
= FALSE
;
13811 if (streq ((char *) p
, "gnu"))
13812 gnu_section
= TRUE
;
13814 gnu_section
= FALSE
;
13817 attr_len
-= namelen
;
13819 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13824 unsigned char * end
;
13826 /* PR binutils/17531: Safe handling of corrupt files. */
13829 error (_("Unused bytes at end of section\n"));
13835 size
= byte_get (p
, 4);
13836 if (size
> attr_len
)
13838 error (_("Bad subsection length (%u > %u)\n"),
13839 (unsigned) size
, (unsigned) attr_len
);
13842 /* PR binutils/17531: Safe handling of corrupt files. */
13845 error (_("Bad subsection length (%u < 6)\n"),
13852 end
= p
+ size
- 1;
13853 assert (end
<= contents
+ sect
->sh_size
);
13859 printf (_("File Attributes\n"));
13862 printf (_("Section Attributes:"));
13865 printf (_("Symbol Attributes:"));
13871 val
= read_uleb128 (p
, &j
, end
);
13875 printf (" %d", val
);
13880 printf (_("Unknown tag: %d\n"), tag
);
13881 public_section
= FALSE
;
13885 if (public_section
&& display_pub_attribute
!= NULL
)
13888 p
= display_pub_attribute (p
, end
);
13891 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13894 p
= display_gnu_attribute (p
,
13895 display_proc_gnu_attribute
,
13901 printf (_(" Unknown attribute:\n"));
13902 display_raw_attribute (p
, end
);
13911 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13919 process_arm_specific (FILE * file
)
13921 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13922 display_arm_attribute
, NULL
);
13926 process_power_specific (FILE * file
)
13928 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13929 display_power_gnu_attribute
);
13933 process_s390_specific (FILE * file
)
13935 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13936 display_s390_gnu_attribute
);
13940 process_sparc_specific (FILE * file
)
13942 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13943 display_sparc_gnu_attribute
);
13947 process_tic6x_specific (FILE * file
)
13949 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13950 display_tic6x_attribute
, NULL
);
13954 process_msp430x_specific (FILE * file
)
13956 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13957 display_msp430x_attribute
, NULL
);
13960 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13961 Print the Address, Access and Initial fields of an entry at VMA ADDR
13962 and return the VMA of the next entry, or -1 if there was a problem.
13963 Does not read from DATA_END or beyond. */
13966 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
13967 unsigned char * data_end
)
13970 print_vma (addr
, LONG_HEX
);
13972 if (addr
< pltgot
+ 0xfff0)
13973 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
13975 printf ("%10s", "");
13978 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
13982 unsigned char * from
= data
+ addr
- pltgot
;
13984 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
13986 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13987 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
13988 return (bfd_vma
) -1;
13992 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
13993 print_vma (entry
, LONG_HEX
);
13996 return addr
+ (is_32bit_elf
? 4 : 8);
13999 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14000 PLTGOT. Print the Address and Initial fields of an entry at VMA
14001 ADDR and return the VMA of the next entry. */
14004 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14007 print_vma (addr
, LONG_HEX
);
14010 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14015 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14016 print_vma (entry
, LONG_HEX
);
14018 return addr
+ (is_32bit_elf
? 4 : 8);
14022 print_mips_ases (unsigned int mask
)
14024 if (mask
& AFL_ASE_DSP
)
14025 fputs ("\n\tDSP ASE", stdout
);
14026 if (mask
& AFL_ASE_DSPR2
)
14027 fputs ("\n\tDSP R2 ASE", stdout
);
14028 if (mask
& AFL_ASE_EVA
)
14029 fputs ("\n\tEnhanced VA Scheme", stdout
);
14030 if (mask
& AFL_ASE_MCU
)
14031 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14032 if (mask
& AFL_ASE_MDMX
)
14033 fputs ("\n\tMDMX ASE", stdout
);
14034 if (mask
& AFL_ASE_MIPS3D
)
14035 fputs ("\n\tMIPS-3D ASE", stdout
);
14036 if (mask
& AFL_ASE_MT
)
14037 fputs ("\n\tMT ASE", stdout
);
14038 if (mask
& AFL_ASE_SMARTMIPS
)
14039 fputs ("\n\tSmartMIPS ASE", stdout
);
14040 if (mask
& AFL_ASE_VIRT
)
14041 fputs ("\n\tVZ ASE", stdout
);
14042 if (mask
& AFL_ASE_MSA
)
14043 fputs ("\n\tMSA ASE", stdout
);
14044 if (mask
& AFL_ASE_MIPS16
)
14045 fputs ("\n\tMIPS16 ASE", stdout
);
14046 if (mask
& AFL_ASE_MICROMIPS
)
14047 fputs ("\n\tMICROMIPS ASE", stdout
);
14048 if (mask
& AFL_ASE_XPA
)
14049 fputs ("\n\tXPA ASE", stdout
);
14051 fprintf (stdout
, "\n\t%s", _("None"));
14052 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14053 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14057 print_mips_isa_ext (unsigned int isa_ext
)
14062 fputs (_("None"), stdout
);
14065 fputs ("RMI XLR", stdout
);
14067 case AFL_EXT_OCTEON3
:
14068 fputs ("Cavium Networks Octeon3", stdout
);
14070 case AFL_EXT_OCTEON2
:
14071 fputs ("Cavium Networks Octeon2", stdout
);
14073 case AFL_EXT_OCTEONP
:
14074 fputs ("Cavium Networks OcteonP", stdout
);
14076 case AFL_EXT_LOONGSON_3A
:
14077 fputs ("Loongson 3A", stdout
);
14079 case AFL_EXT_OCTEON
:
14080 fputs ("Cavium Networks Octeon", stdout
);
14083 fputs ("Toshiba R5900", stdout
);
14086 fputs ("MIPS R4650", stdout
);
14089 fputs ("LSI R4010", stdout
);
14092 fputs ("NEC VR4100", stdout
);
14095 fputs ("Toshiba R3900", stdout
);
14097 case AFL_EXT_10000
:
14098 fputs ("MIPS R10000", stdout
);
14101 fputs ("Broadcom SB-1", stdout
);
14104 fputs ("NEC VR4111/VR4181", stdout
);
14107 fputs ("NEC VR4120", stdout
);
14110 fputs ("NEC VR5400", stdout
);
14113 fputs ("NEC VR5500", stdout
);
14115 case AFL_EXT_LOONGSON_2E
:
14116 fputs ("ST Microelectronics Loongson 2E", stdout
);
14118 case AFL_EXT_LOONGSON_2F
:
14119 fputs ("ST Microelectronics Loongson 2F", stdout
);
14122 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14127 get_mips_reg_size (int reg_size
)
14129 return (reg_size
== AFL_REG_NONE
) ? 0
14130 : (reg_size
== AFL_REG_32
) ? 32
14131 : (reg_size
== AFL_REG_64
) ? 64
14132 : (reg_size
== AFL_REG_128
) ? 128
14137 process_mips_specific (FILE * file
)
14139 Elf_Internal_Dyn
* entry
;
14140 Elf_Internal_Shdr
*sect
= NULL
;
14141 size_t liblist_offset
= 0;
14142 size_t liblistno
= 0;
14143 size_t conflictsno
= 0;
14144 size_t options_offset
= 0;
14145 size_t conflicts_offset
= 0;
14146 size_t pltrelsz
= 0;
14148 bfd_vma pltgot
= 0;
14149 bfd_vma mips_pltgot
= 0;
14150 bfd_vma jmprel
= 0;
14151 bfd_vma local_gotno
= 0;
14152 bfd_vma gotsym
= 0;
14153 bfd_vma symtabno
= 0;
14155 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14156 display_mips_gnu_attribute
);
14158 sect
= find_section (".MIPS.abiflags");
14162 Elf_External_ABIFlags_v0
*abiflags_ext
;
14163 Elf_Internal_ABIFlags_v0 abiflags_in
;
14165 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14166 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14169 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14170 sect
->sh_size
, _("MIPS ABI Flags section"));
14173 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14174 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14175 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14176 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14177 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14178 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14179 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14180 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14181 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14182 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14183 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14185 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14186 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14187 if (abiflags_in
.isa_rev
> 1)
14188 printf ("r%d", abiflags_in
.isa_rev
);
14189 printf ("\nGPR size: %d",
14190 get_mips_reg_size (abiflags_in
.gpr_size
));
14191 printf ("\nCPR1 size: %d",
14192 get_mips_reg_size (abiflags_in
.cpr1_size
));
14193 printf ("\nCPR2 size: %d",
14194 get_mips_reg_size (abiflags_in
.cpr2_size
));
14195 fputs ("\nFP ABI: ", stdout
);
14196 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14197 fputs ("ISA Extension: ", stdout
);
14198 print_mips_isa_ext (abiflags_in
.isa_ext
);
14199 fputs ("\nASEs:", stdout
);
14200 print_mips_ases (abiflags_in
.ases
);
14201 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14202 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14203 fputc ('\n', stdout
);
14204 free (abiflags_ext
);
14209 /* We have a lot of special sections. Thanks SGI! */
14210 if (dynamic_section
== NULL
)
14211 /* No information available. */
14214 for (entry
= dynamic_section
;
14215 /* PR 17531 file: 012-50589-0.004. */
14216 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14218 switch (entry
->d_tag
)
14220 case DT_MIPS_LIBLIST
:
14222 = offset_from_vma (file
, entry
->d_un
.d_val
,
14223 liblistno
* sizeof (Elf32_External_Lib
));
14225 case DT_MIPS_LIBLISTNO
:
14226 liblistno
= entry
->d_un
.d_val
;
14228 case DT_MIPS_OPTIONS
:
14229 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14231 case DT_MIPS_CONFLICT
:
14233 = offset_from_vma (file
, entry
->d_un
.d_val
,
14234 conflictsno
* sizeof (Elf32_External_Conflict
));
14236 case DT_MIPS_CONFLICTNO
:
14237 conflictsno
= entry
->d_un
.d_val
;
14240 pltgot
= entry
->d_un
.d_ptr
;
14242 case DT_MIPS_LOCAL_GOTNO
:
14243 local_gotno
= entry
->d_un
.d_val
;
14245 case DT_MIPS_GOTSYM
:
14246 gotsym
= entry
->d_un
.d_val
;
14248 case DT_MIPS_SYMTABNO
:
14249 symtabno
= entry
->d_un
.d_val
;
14251 case DT_MIPS_PLTGOT
:
14252 mips_pltgot
= entry
->d_un
.d_ptr
;
14255 pltrel
= entry
->d_un
.d_val
;
14258 pltrelsz
= entry
->d_un
.d_val
;
14261 jmprel
= entry
->d_un
.d_ptr
;
14267 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14269 Elf32_External_Lib
* elib
;
14272 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14274 sizeof (Elf32_External_Lib
),
14275 _("liblist section data"));
14278 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14279 (unsigned long) liblistno
);
14280 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14283 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14290 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14291 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14292 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14293 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14294 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14296 tmp
= gmtime (&atime
);
14297 snprintf (timebuf
, sizeof (timebuf
),
14298 "%04u-%02u-%02uT%02u:%02u:%02u",
14299 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14300 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14302 printf ("%3lu: ", (unsigned long) cnt
);
14303 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14304 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14306 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14307 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14308 liblist
.l_version
);
14310 if (liblist
.l_flags
== 0)
14314 static const struct
14321 { " EXACT_MATCH", LL_EXACT_MATCH
},
14322 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14323 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14324 { " EXPORTS", LL_EXPORTS
},
14325 { " DELAY_LOAD", LL_DELAY_LOAD
},
14326 { " DELTA", LL_DELTA
}
14328 int flags
= liblist
.l_flags
;
14331 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14332 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14334 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14335 flags
^= l_flags_vals
[fcnt
].bit
;
14338 printf (" %#x", (unsigned int) flags
);
14348 if (options_offset
!= 0)
14350 Elf_External_Options
* eopt
;
14351 Elf_Internal_Options
* iopt
;
14352 Elf_Internal_Options
* option
;
14355 sect
= section_headers
;
14357 /* Find the section header so that we get the size. */
14358 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14359 /* PR 17533 file: 012-277276-0.004. */
14362 error (_("No MIPS_OPTIONS header found\n"));
14366 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14367 sect
->sh_size
, _("options"));
14370 iopt
= (Elf_Internal_Options
*)
14371 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14374 error (_("Out of memory allocatinf space for MIPS options\n"));
14381 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14383 Elf_External_Options
* eoption
;
14385 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14387 option
->kind
= BYTE_GET (eoption
->kind
);
14388 option
->size
= BYTE_GET (eoption
->size
);
14389 option
->section
= BYTE_GET (eoption
->section
);
14390 option
->info
= BYTE_GET (eoption
->info
);
14392 /* PR 17531: file: ffa0fa3b. */
14393 if (option
->size
< sizeof (* eopt
)
14394 || offset
+ option
->size
> sect
->sh_size
)
14396 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14399 offset
+= option
->size
;
14405 printf (_("\nSection '%s' contains %d entries:\n"),
14406 printable_section_name (sect
), cnt
);
14415 switch (option
->kind
)
14418 /* This shouldn't happen. */
14419 printf (" NULL %d %lx", option
->section
, option
->info
);
14422 printf (" REGINFO ");
14423 if (elf_header
.e_machine
== EM_MIPS
)
14426 Elf32_External_RegInfo
* ereg
;
14427 Elf32_RegInfo reginfo
;
14429 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14430 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14431 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14432 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14433 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14434 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14435 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14437 printf ("GPR %08lx GP 0x%lx\n",
14438 reginfo
.ri_gprmask
,
14439 (unsigned long) reginfo
.ri_gp_value
);
14440 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14441 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14442 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14447 Elf64_External_RegInfo
* ereg
;
14448 Elf64_Internal_RegInfo reginfo
;
14450 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14451 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14452 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14453 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14454 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14455 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14456 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14458 printf ("GPR %08lx GP 0x",
14459 reginfo
.ri_gprmask
);
14460 printf_vma (reginfo
.ri_gp_value
);
14463 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14464 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14465 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14469 case ODK_EXCEPTIONS
:
14470 fputs (" EXCEPTIONS fpe_min(", stdout
);
14471 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14472 fputs (") fpe_max(", stdout
);
14473 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14474 fputs (")", stdout
);
14476 if (option
->info
& OEX_PAGE0
)
14477 fputs (" PAGE0", stdout
);
14478 if (option
->info
& OEX_SMM
)
14479 fputs (" SMM", stdout
);
14480 if (option
->info
& OEX_FPDBUG
)
14481 fputs (" FPDBUG", stdout
);
14482 if (option
->info
& OEX_DISMISS
)
14483 fputs (" DISMISS", stdout
);
14486 fputs (" PAD ", stdout
);
14487 if (option
->info
& OPAD_PREFIX
)
14488 fputs (" PREFIX", stdout
);
14489 if (option
->info
& OPAD_POSTFIX
)
14490 fputs (" POSTFIX", stdout
);
14491 if (option
->info
& OPAD_SYMBOL
)
14492 fputs (" SYMBOL", stdout
);
14495 fputs (" HWPATCH ", stdout
);
14496 if (option
->info
& OHW_R4KEOP
)
14497 fputs (" R4KEOP", stdout
);
14498 if (option
->info
& OHW_R8KPFETCH
)
14499 fputs (" R8KPFETCH", stdout
);
14500 if (option
->info
& OHW_R5KEOP
)
14501 fputs (" R5KEOP", stdout
);
14502 if (option
->info
& OHW_R5KCVTL
)
14503 fputs (" R5KCVTL", stdout
);
14506 fputs (" FILL ", stdout
);
14507 /* XXX Print content of info word? */
14510 fputs (" TAGS ", stdout
);
14511 /* XXX Print content of info word? */
14514 fputs (" HWAND ", stdout
);
14515 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14516 fputs (" R4KEOP_CHECKED", stdout
);
14517 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14518 fputs (" R4KEOP_CLEAN", stdout
);
14521 fputs (" HWOR ", stdout
);
14522 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14523 fputs (" R4KEOP_CHECKED", stdout
);
14524 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14525 fputs (" R4KEOP_CLEAN", stdout
);
14528 printf (" GP_GROUP %#06lx self-contained %#06lx",
14529 option
->info
& OGP_GROUP
,
14530 (option
->info
& OGP_SELF
) >> 16);
14533 printf (" IDENT %#06lx self-contained %#06lx",
14534 option
->info
& OGP_GROUP
,
14535 (option
->info
& OGP_SELF
) >> 16);
14538 /* This shouldn't happen. */
14539 printf (" %3d ??? %d %lx",
14540 option
->kind
, option
->section
, option
->info
);
14544 len
= sizeof (* eopt
);
14545 while (len
< option
->size
)
14547 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14549 if (ISPRINT (datum
))
14550 printf ("%c", datum
);
14552 printf ("\\%03o", datum
);
14555 fputs ("\n", stdout
);
14557 offset
+= option
->size
;
14565 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14567 Elf32_Conflict
* iconf
;
14570 if (dynamic_symbols
== NULL
)
14572 error (_("conflict list found without a dynamic symbol table\n"));
14576 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14579 error (_("Out of memory allocating space for dynamic conflicts\n"));
14585 Elf32_External_Conflict
* econf32
;
14587 econf32
= (Elf32_External_Conflict
*)
14588 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14589 sizeof (* econf32
), _("conflict"));
14593 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14594 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14600 Elf64_External_Conflict
* econf64
;
14602 econf64
= (Elf64_External_Conflict
*)
14603 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14604 sizeof (* econf64
), _("conflict"));
14608 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14609 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14614 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14615 (unsigned long) conflictsno
);
14616 puts (_(" Num: Index Value Name"));
14618 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14620 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14622 if (iconf
[cnt
] >= num_dynamic_syms
)
14623 printf (_("<corrupt symbol index>"));
14626 Elf_Internal_Sym
* psym
;
14628 psym
= & dynamic_symbols
[iconf
[cnt
]];
14629 print_vma (psym
->st_value
, FULL_HEX
);
14631 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14632 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14634 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14642 if (pltgot
!= 0 && local_gotno
!= 0)
14644 bfd_vma ent
, local_end
, global_end
;
14646 unsigned char * data
;
14647 unsigned char * data_end
;
14651 addr_size
= (is_32bit_elf
? 4 : 8);
14652 local_end
= pltgot
+ local_gotno
* addr_size
;
14654 /* PR binutils/17533 file: 012-111227-0.004 */
14655 if (symtabno
< gotsym
)
14657 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14658 (unsigned long) gotsym
, (unsigned long) symtabno
);
14662 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14663 /* PR 17531: file: 54c91a34. */
14664 if (global_end
< local_end
)
14666 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14670 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14671 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14672 global_end
- pltgot
, 1,
14673 _("Global Offset Table data"));
14676 data_end
= data
+ (global_end
- pltgot
);
14678 printf (_("\nPrimary GOT:\n"));
14679 printf (_(" Canonical gp value: "));
14680 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14683 printf (_(" Reserved entries:\n"));
14684 printf (_(" %*s %10s %*s Purpose\n"),
14685 addr_size
* 2, _("Address"), _("Access"),
14686 addr_size
* 2, _("Initial"));
14687 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14688 printf (_(" Lazy resolver\n"));
14689 if (ent
== (bfd_vma
) -1)
14690 goto got_print_fail
;
14692 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14693 >> (addr_size
* 8 - 1)) != 0)
14695 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14696 printf (_(" Module pointer (GNU extension)\n"));
14697 if (ent
== (bfd_vma
) -1)
14698 goto got_print_fail
;
14702 if (ent
< local_end
)
14704 printf (_(" Local entries:\n"));
14705 printf (" %*s %10s %*s\n",
14706 addr_size
* 2, _("Address"), _("Access"),
14707 addr_size
* 2, _("Initial"));
14708 while (ent
< local_end
)
14710 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14712 if (ent
== (bfd_vma
) -1)
14713 goto got_print_fail
;
14718 if (gotsym
< symtabno
)
14722 printf (_(" Global entries:\n"));
14723 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14724 addr_size
* 2, _("Address"),
14726 addr_size
* 2, _("Initial"),
14727 addr_size
* 2, _("Sym.Val."),
14729 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14730 _("Ndx"), _("Name"));
14732 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14734 for (i
= gotsym
; i
< symtabno
; i
++)
14736 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14739 if (dynamic_symbols
== NULL
)
14740 printf (_("<no dynamic symbols>"));
14741 else if (i
< num_dynamic_syms
)
14743 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14745 print_vma (psym
->st_value
, LONG_HEX
);
14746 printf (" %-7s %3s ",
14747 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14748 get_symbol_index_type (psym
->st_shndx
));
14750 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14751 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14753 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14756 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14757 (unsigned long) i
);
14760 if (ent
== (bfd_vma
) -1)
14771 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14774 size_t offset
, rel_offset
;
14775 unsigned long count
, i
;
14776 unsigned char * data
;
14777 int addr_size
, sym_width
;
14778 Elf_Internal_Rela
* rels
;
14780 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14781 if (pltrel
== DT_RELA
)
14783 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14788 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14793 addr_size
= (is_32bit_elf
? 4 : 8);
14794 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14796 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14797 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14798 1, _("Procedure Linkage Table data"));
14802 printf ("\nPLT GOT:\n\n");
14803 printf (_(" Reserved entries:\n"));
14804 printf (_(" %*s %*s Purpose\n"),
14805 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14806 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14807 printf (_(" PLT lazy resolver\n"));
14808 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14809 printf (_(" Module pointer\n"));
14812 printf (_(" Entries:\n"));
14813 printf (" %*s %*s %*s %-7s %3s %s\n",
14814 addr_size
* 2, _("Address"),
14815 addr_size
* 2, _("Initial"),
14816 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14817 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14818 for (i
= 0; i
< count
; i
++)
14820 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14822 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14825 if (idx
>= num_dynamic_syms
)
14826 printf (_("<corrupt symbol index: %lu>"), idx
);
14829 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14831 print_vma (psym
->st_value
, LONG_HEX
);
14832 printf (" %-7s %3s ",
14833 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14834 get_symbol_index_type (psym
->st_shndx
));
14835 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14836 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14838 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14853 process_nds32_specific (FILE * file
)
14855 Elf_Internal_Shdr
*sect
= NULL
;
14857 sect
= find_section (".nds32_e_flags");
14860 unsigned int *flag
;
14862 printf ("\nNDS32 elf flags section:\n");
14863 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14864 sect
->sh_size
, _("NDS32 elf flags section"));
14866 switch ((*flag
) & 0x3)
14869 printf ("(VEC_SIZE):\tNo entry.\n");
14872 printf ("(VEC_SIZE):\t4 bytes\n");
14875 printf ("(VEC_SIZE):\t16 bytes\n");
14878 printf ("(VEC_SIZE):\treserved\n");
14887 process_gnu_liblist (FILE * file
)
14889 Elf_Internal_Shdr
* section
;
14890 Elf_Internal_Shdr
* string_sec
;
14891 Elf32_External_Lib
* elib
;
14893 size_t strtab_size
;
14900 for (i
= 0, section
= section_headers
;
14901 i
< elf_header
.e_shnum
;
14904 switch (section
->sh_type
)
14906 case SHT_GNU_LIBLIST
:
14907 if (section
->sh_link
>= elf_header
.e_shnum
)
14910 elib
= (Elf32_External_Lib
*)
14911 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14912 _("liblist section data"));
14916 string_sec
= section_headers
+ section
->sh_link
;
14918 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14919 string_sec
->sh_size
,
14920 _("liblist string table"));
14922 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14928 strtab_size
= string_sec
->sh_size
;
14930 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14931 printable_section_name (section
),
14932 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14934 puts (_(" Library Time Stamp Checksum Version Flags"));
14936 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14944 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14945 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14946 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14947 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14948 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14950 tmp
= gmtime (&atime
);
14951 snprintf (timebuf
, sizeof (timebuf
),
14952 "%04u-%02u-%02uT%02u:%02u:%02u",
14953 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14954 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14956 printf ("%3lu: ", (unsigned long) cnt
);
14958 printf ("%-20s", liblist
.l_name
< strtab_size
14959 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14961 printf ("%-20.20s", liblist
.l_name
< strtab_size
14962 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14963 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14964 liblist
.l_version
, liblist
.l_flags
);
14975 static const char *
14976 get_note_type (unsigned e_type
)
14978 static char buff
[64];
14980 if (elf_header
.e_type
== ET_CORE
)
14984 return _("NT_AUXV (auxiliary vector)");
14986 return _("NT_PRSTATUS (prstatus structure)");
14988 return _("NT_FPREGSET (floating point registers)");
14990 return _("NT_PRPSINFO (prpsinfo structure)");
14991 case NT_TASKSTRUCT
:
14992 return _("NT_TASKSTRUCT (task structure)");
14994 return _("NT_PRXFPREG (user_xfpregs structure)");
14996 return _("NT_PPC_VMX (ppc Altivec registers)");
14998 return _("NT_PPC_VSX (ppc VSX registers)");
15000 return _("NT_386_TLS (x86 TLS information)");
15001 case NT_386_IOPERM
:
15002 return _("NT_386_IOPERM (x86 I/O permissions)");
15003 case NT_X86_XSTATE
:
15004 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15005 case NT_S390_HIGH_GPRS
:
15006 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15007 case NT_S390_TIMER
:
15008 return _("NT_S390_TIMER (s390 timer register)");
15009 case NT_S390_TODCMP
:
15010 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15011 case NT_S390_TODPREG
:
15012 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15014 return _("NT_S390_CTRS (s390 control registers)");
15015 case NT_S390_PREFIX
:
15016 return _("NT_S390_PREFIX (s390 prefix register)");
15017 case NT_S390_LAST_BREAK
:
15018 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15019 case NT_S390_SYSTEM_CALL
:
15020 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15022 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15023 case NT_S390_VXRS_LOW
:
15024 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15025 case NT_S390_VXRS_HIGH
:
15026 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15028 return _("NT_ARM_VFP (arm VFP registers)");
15030 return _("NT_ARM_TLS (AArch TLS registers)");
15031 case NT_ARM_HW_BREAK
:
15032 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15033 case NT_ARM_HW_WATCH
:
15034 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15036 return _("NT_PSTATUS (pstatus structure)");
15038 return _("NT_FPREGS (floating point registers)");
15040 return _("NT_PSINFO (psinfo structure)");
15042 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15044 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15045 case NT_WIN32PSTATUS
:
15046 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15048 return _("NT_SIGINFO (siginfo_t data)");
15050 return _("NT_FILE (mapped files)");
15058 return _("NT_VERSION (version)");
15060 return _("NT_ARCH (architecture)");
15065 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15070 print_core_note (Elf_Internal_Note
*pnote
)
15072 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15073 bfd_vma count
, page_size
;
15074 unsigned char *descdata
, *filenames
, *descend
;
15076 if (pnote
->type
!= NT_FILE
)
15082 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15083 /* Still "successful". */
15088 if (pnote
->descsz
< 2 * addr_size
)
15090 printf (_(" Malformed note - too short for header\n"));
15094 descdata
= (unsigned char *) pnote
->descdata
;
15095 descend
= descdata
+ pnote
->descsz
;
15097 if (descdata
[pnote
->descsz
- 1] != '\0')
15099 printf (_(" Malformed note - does not end with \\0\n"));
15103 count
= byte_get (descdata
, addr_size
);
15104 descdata
+= addr_size
;
15106 page_size
= byte_get (descdata
, addr_size
);
15107 descdata
+= addr_size
;
15109 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15111 printf (_(" Malformed note - too short for supplied file count\n"));
15115 printf (_(" Page size: "));
15116 print_vma (page_size
, DEC
);
15119 printf (_(" %*s%*s%*s\n"),
15120 (int) (2 + 2 * addr_size
), _("Start"),
15121 (int) (4 + 2 * addr_size
), _("End"),
15122 (int) (4 + 2 * addr_size
), _("Page Offset"));
15123 filenames
= descdata
+ count
* 3 * addr_size
;
15124 while (count
-- > 0)
15126 bfd_vma start
, end
, file_ofs
;
15128 if (filenames
== descend
)
15130 printf (_(" Malformed note - filenames end too early\n"));
15134 start
= byte_get (descdata
, addr_size
);
15135 descdata
+= addr_size
;
15136 end
= byte_get (descdata
, addr_size
);
15137 descdata
+= addr_size
;
15138 file_ofs
= byte_get (descdata
, addr_size
);
15139 descdata
+= addr_size
;
15142 print_vma (start
, FULL_HEX
);
15144 print_vma (end
, FULL_HEX
);
15146 print_vma (file_ofs
, FULL_HEX
);
15147 printf ("\n %s\n", filenames
);
15149 filenames
+= 1 + strlen ((char *) filenames
);
15155 static const char *
15156 get_gnu_elf_note_type (unsigned e_type
)
15158 static char buff
[64];
15162 case NT_GNU_ABI_TAG
:
15163 return _("NT_GNU_ABI_TAG (ABI version tag)");
15165 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15166 case NT_GNU_BUILD_ID
:
15167 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15168 case NT_GNU_GOLD_VERSION
:
15169 return _("NT_GNU_GOLD_VERSION (gold version)");
15174 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15179 print_gnu_note (Elf_Internal_Note
*pnote
)
15181 switch (pnote
->type
)
15183 case NT_GNU_BUILD_ID
:
15187 printf (_(" Build ID: "));
15188 for (i
= 0; i
< pnote
->descsz
; ++i
)
15189 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15194 case NT_GNU_ABI_TAG
:
15196 unsigned long os
, major
, minor
, subminor
;
15197 const char *osname
;
15199 /* PR 17531: file: 030-599401-0.004. */
15200 if (pnote
->descsz
< 16)
15202 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15206 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15207 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15208 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15209 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15213 case GNU_ABI_TAG_LINUX
:
15216 case GNU_ABI_TAG_HURD
:
15219 case GNU_ABI_TAG_SOLARIS
:
15220 osname
= "Solaris";
15222 case GNU_ABI_TAG_FREEBSD
:
15223 osname
= "FreeBSD";
15225 case GNU_ABI_TAG_NETBSD
:
15228 case GNU_ABI_TAG_SYLLABLE
:
15229 osname
= "Syllable";
15231 case GNU_ABI_TAG_NACL
:
15235 osname
= "Unknown";
15239 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15240 major
, minor
, subminor
);
15244 case NT_GNU_GOLD_VERSION
:
15248 printf (_(" Version: "));
15249 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15250 printf ("%c", pnote
->descdata
[i
]);
15259 static const char *
15260 get_v850_elf_note_type (enum v850_notes n_type
)
15262 static char buff
[64];
15266 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15267 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15268 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15269 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15270 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15271 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15273 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15279 print_v850_note (Elf_Internal_Note
* pnote
)
15283 if (pnote
->descsz
!= 4)
15285 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15289 printf (_("not set\n"));
15293 switch (pnote
->type
)
15295 case V850_NOTE_ALIGNMENT
:
15298 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15299 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15303 case V850_NOTE_DATA_SIZE
:
15306 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15307 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15311 case V850_NOTE_FPU_INFO
:
15314 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15315 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15319 case V850_NOTE_MMU_INFO
:
15320 case V850_NOTE_CACHE_INFO
:
15321 case V850_NOTE_SIMD_INFO
:
15322 if (val
== EF_RH850_SIMD
)
15324 printf (_("yes\n"));
15330 /* An 'unknown note type' message will already have been displayed. */
15334 printf (_("unknown value: %x\n"), val
);
15339 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
15341 unsigned int version
;
15343 switch (pnote
->type
)
15345 case NT_NETBSD_IDENT
:
15346 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
15347 if ((version
/ 10000) % 100)
15348 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
15349 version
, version
/ 100000000, (version
/ 1000000) % 100,
15350 (version
/ 10000) % 100 > 26 ? "Z" : "",
15351 'A' + (version
/ 10000) % 26);
15353 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
15354 version
, version
/ 100000000, (version
/ 1000000) % 100,
15355 (version
/ 100) % 100);
15358 case NT_NETBSD_MARCH
:
15359 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
15367 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
15372 static const char *
15373 get_netbsd_elfcore_note_type (unsigned e_type
)
15375 static char buff
[64];
15377 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15379 /* NetBSD core "procinfo" structure. */
15380 return _("NetBSD procinfo structure");
15383 /* As of Jan 2002 there are no other machine-independent notes
15384 defined for NetBSD core files. If the note type is less
15385 than the start of the machine-dependent note types, we don't
15388 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15390 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15394 switch (elf_header
.e_machine
)
15396 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15397 and PT_GETFPREGS == mach+2. */
15402 case EM_SPARC32PLUS
:
15406 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15407 return _("PT_GETREGS (reg structure)");
15408 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15409 return _("PT_GETFPREGS (fpreg structure)");
15415 /* On all other arch's, PT_GETREGS == mach+1 and
15416 PT_GETFPREGS == mach+3. */
15420 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15421 return _("PT_GETREGS (reg structure)");
15422 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15423 return _("PT_GETFPREGS (fpreg structure)");
15429 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15430 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15434 static const char *
15435 get_stapsdt_note_type (unsigned e_type
)
15437 static char buff
[64];
15442 return _("NT_STAPSDT (SystemTap probe descriptors)");
15448 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15453 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15455 int addr_size
= is_32bit_elf
? 4 : 8;
15456 char *data
= pnote
->descdata
;
15457 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15458 bfd_vma pc
, base_addr
, semaphore
;
15459 char *provider
, *probe
, *arg_fmt
;
15461 pc
= byte_get ((unsigned char *) data
, addr_size
);
15463 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15465 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15469 data
+= strlen (data
) + 1;
15471 data
+= strlen (data
) + 1;
15473 data
+= strlen (data
) + 1;
15475 printf (_(" Provider: %s\n"), provider
);
15476 printf (_(" Name: %s\n"), probe
);
15477 printf (_(" Location: "));
15478 print_vma (pc
, FULL_HEX
);
15479 printf (_(", Base: "));
15480 print_vma (base_addr
, FULL_HEX
);
15481 printf (_(", Semaphore: "));
15482 print_vma (semaphore
, FULL_HEX
);
15484 printf (_(" Arguments: %s\n"), arg_fmt
);
15486 return data
== data_end
;
15489 static const char *
15490 get_ia64_vms_note_type (unsigned e_type
)
15492 static char buff
[64];
15497 return _("NT_VMS_MHD (module header)");
15499 return _("NT_VMS_LNM (language name)");
15501 return _("NT_VMS_SRC (source files)");
15503 return "NT_VMS_TITLE";
15505 return _("NT_VMS_EIDC (consistency check)");
15506 case NT_VMS_FPMODE
:
15507 return _("NT_VMS_FPMODE (FP mode)");
15508 case NT_VMS_LINKTIME
:
15509 return "NT_VMS_LINKTIME";
15510 case NT_VMS_IMGNAM
:
15511 return _("NT_VMS_IMGNAM (image name)");
15513 return _("NT_VMS_IMGID (image id)");
15514 case NT_VMS_LINKID
:
15515 return _("NT_VMS_LINKID (link id)");
15516 case NT_VMS_IMGBID
:
15517 return _("NT_VMS_IMGBID (build id)");
15518 case NT_VMS_GSTNAM
:
15519 return _("NT_VMS_GSTNAM (sym table name)");
15520 case NT_VMS_ORIG_DYN
:
15521 return "NT_VMS_ORIG_DYN";
15522 case NT_VMS_PATCHTIME
:
15523 return "NT_VMS_PATCHTIME";
15525 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15531 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15533 switch (pnote
->type
)
15536 if (pnote
->descsz
> 36)
15538 size_t l
= strlen (pnote
->descdata
+ 34);
15539 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15540 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15541 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15542 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15545 printf (_(" Invalid size\n"));
15548 printf (_(" Language: %s\n"), pnote
->descdata
);
15551 case NT_VMS_FPMODE
:
15552 printf (_(" Floating Point mode: "));
15553 printf ("0x%016" BFD_VMA_FMT
"x\n",
15554 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15556 case NT_VMS_LINKTIME
:
15557 printf (_(" Link time: "));
15559 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15562 case NT_VMS_PATCHTIME
:
15563 printf (_(" Patch time: "));
15565 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15568 case NT_VMS_ORIG_DYN
:
15569 printf (_(" Major id: %u, minor id: %u\n"),
15570 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15571 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15572 printf (_(" Last modified : "));
15574 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15575 printf (_("\n Link flags : "));
15576 printf ("0x%016" BFD_VMA_FMT
"x\n",
15577 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15578 printf (_(" Header flags: 0x%08x\n"),
15579 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15580 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15583 case NT_VMS_IMGNAM
:
15584 printf (_(" Image name: %s\n"), pnote
->descdata
);
15586 case NT_VMS_GSTNAM
:
15587 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15590 printf (_(" Image id: %s\n"), pnote
->descdata
);
15592 case NT_VMS_LINKID
:
15593 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15601 /* Note that by the ELF standard, the name field is already null byte
15602 terminated, and namesz includes the terminating null byte.
15603 I.E. the value of namesz for the name "FSF" is 4.
15605 If the value of namesz is zero, there is no name present. */
15607 process_note (Elf_Internal_Note
* pnote
)
15609 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15612 if (pnote
->namesz
== 0)
15613 /* If there is no note name, then use the default set of
15614 note type strings. */
15615 nt
= get_note_type (pnote
->type
);
15617 else if (const_strneq (pnote
->namedata
, "GNU"))
15618 /* GNU-specific object file notes. */
15619 nt
= get_gnu_elf_note_type (pnote
->type
);
15621 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15622 /* NetBSD-specific core file notes. */
15623 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15625 else if (const_strneq (pnote
->namedata
, "NetBSD"))
15626 /* NetBSD-specific core file notes. */
15627 return process_netbsd_elf_note (pnote
);
15629 else if (strneq (pnote
->namedata
, "SPU/", 4))
15631 /* SPU-specific core file notes. */
15632 nt
= pnote
->namedata
+ 4;
15636 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15637 /* VMS/ia64-specific file notes. */
15638 nt
= get_ia64_vms_note_type (pnote
->type
);
15640 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15641 nt
= get_stapsdt_note_type (pnote
->type
);
15644 /* Don't recognize this note name; just use the default set of
15645 note type strings. */
15646 nt
= get_note_type (pnote
->type
);
15648 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15650 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15651 return print_ia64_vms_note (pnote
);
15652 else if (const_strneq (pnote
->namedata
, "GNU"))
15653 return print_gnu_note (pnote
);
15654 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15655 return print_stapsdt_note (pnote
);
15656 else if (const_strneq (pnote
->namedata
, "CORE"))
15657 return print_core_note (pnote
);
15664 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15666 Elf_External_Note
* pnotes
;
15667 Elf_External_Note
* external
;
15674 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15676 if (pnotes
== NULL
)
15681 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15682 (unsigned long) offset
, (unsigned long) length
);
15683 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15685 end
= (char *) pnotes
+ length
;
15686 while ((char *) external
< end
)
15688 Elf_Internal_Note inote
;
15691 char * temp
= NULL
;
15692 size_t data_remaining
= end
- (char *) external
;
15694 if (!is_ia64_vms ())
15696 /* PR binutils/15191
15697 Make sure that there is enough data to read. */
15698 min_notesz
= offsetof (Elf_External_Note
, name
);
15699 if (data_remaining
< min_notesz
)
15701 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15702 (int) data_remaining
);
15705 inote
.type
= BYTE_GET (external
->type
);
15706 inote
.namesz
= BYTE_GET (external
->namesz
);
15707 inote
.namedata
= external
->name
;
15708 inote
.descsz
= BYTE_GET (external
->descsz
);
15709 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15710 /* PR 17531: file: 3443835e. */
15711 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15713 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15714 inote
.descdata
= inote
.namedata
;
15718 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15719 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15723 Elf64_External_VMS_Note
*vms_external
;
15725 /* PR binutils/15191
15726 Make sure that there is enough data to read. */
15727 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15728 if (data_remaining
< min_notesz
)
15730 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15731 (int) data_remaining
);
15735 vms_external
= (Elf64_External_VMS_Note
*) external
;
15736 inote
.type
= BYTE_GET (vms_external
->type
);
15737 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15738 inote
.namedata
= vms_external
->name
;
15739 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15740 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15741 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15742 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15745 if (inote
.descdata
< (char *) external
+ min_notesz
15746 || next
< (char *) external
+ min_notesz
15747 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15748 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15749 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15750 || data_remaining
< (size_t)(next
- (char *) external
))
15752 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15753 (unsigned long) ((char *) external
- (char *) pnotes
));
15754 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15755 inote
.type
, inote
.namesz
, inote
.descsz
);
15759 external
= (Elf_External_Note
*) next
;
15761 /* Verify that name is null terminated. It appears that at least
15762 one version of Linux (RedHat 6.0) generates corefiles that don't
15763 comply with the ELF spec by failing to include the null byte in
15765 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15767 temp
= (char *) malloc (inote
.namesz
+ 1);
15770 error (_("Out of memory allocating space for inote name\n"));
15775 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15776 temp
[inote
.namesz
] = 0;
15778 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15779 inote
.namedata
= temp
;
15782 res
&= process_note (& inote
);
15797 process_corefile_note_segments (FILE * file
)
15799 Elf_Internal_Phdr
* segment
;
15803 if (! get_program_headers (file
))
15806 for (i
= 0, segment
= program_headers
;
15807 i
< elf_header
.e_phnum
;
15810 if (segment
->p_type
== PT_NOTE
)
15811 res
&= process_corefile_note_segment (file
,
15812 (bfd_vma
) segment
->p_offset
,
15813 (bfd_vma
) segment
->p_filesz
);
15820 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
15822 Elf_External_Note
* pnotes
;
15823 Elf_External_Note
* external
;
15830 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15832 if (pnotes
== NULL
)
15836 end
= (char*) pnotes
+ length
;
15838 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15839 (unsigned long) offset
, (unsigned long) length
);
15841 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
15843 Elf_External_Note
* next
;
15844 Elf_Internal_Note inote
;
15846 inote
.type
= BYTE_GET (external
->type
);
15847 inote
.namesz
= BYTE_GET (external
->namesz
);
15848 inote
.namedata
= external
->name
;
15849 inote
.descsz
= BYTE_GET (external
->descsz
);
15850 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15851 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15853 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
15855 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15856 inote
.descdata
= inote
.namedata
;
15860 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
15862 if ( ((char *) next
> end
)
15863 || ((char *) next
< (char *) pnotes
))
15865 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15866 (unsigned long) ((char *) external
- (char *) pnotes
));
15867 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15868 inote
.type
, inote
.namesz
, inote
.descsz
);
15874 /* Prevent out-of-bounds indexing. */
15875 if ( inote
.namedata
+ inote
.namesz
> end
15876 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
15878 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15879 (unsigned long) ((char *) external
- (char *) pnotes
));
15880 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15881 inote
.type
, inote
.namesz
, inote
.descsz
);
15885 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
15887 if (! print_v850_note (& inote
))
15890 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15891 inote
.namesz
, inote
.descsz
);
15901 process_note_sections (FILE * file
)
15903 Elf_Internal_Shdr
* section
;
15908 for (i
= 0, section
= section_headers
;
15909 i
< elf_header
.e_shnum
&& section
!= NULL
;
15912 if (section
->sh_type
== SHT_NOTE
)
15914 res
&= process_corefile_note_segment (file
,
15915 (bfd_vma
) section
->sh_offset
,
15916 (bfd_vma
) section
->sh_size
);
15920 if (( elf_header
.e_machine
== EM_V800
15921 || elf_header
.e_machine
== EM_V850
15922 || elf_header
.e_machine
== EM_CYGNUS_V850
)
15923 && section
->sh_type
== SHT_RENESAS_INFO
)
15925 res
&= process_v850_notes (file
,
15926 (bfd_vma
) section
->sh_offset
,
15927 (bfd_vma
) section
->sh_size
);
15933 /* Try processing NOTE segments instead. */
15934 return process_corefile_note_segments (file
);
15940 process_notes (FILE * file
)
15942 /* If we have not been asked to display the notes then do nothing. */
15946 if (elf_header
.e_type
!= ET_CORE
)
15947 return process_note_sections (file
);
15949 /* No program headers means no NOTE segment. */
15950 if (elf_header
.e_phnum
> 0)
15951 return process_corefile_note_segments (file
);
15953 printf (_("No note segments present in the core file.\n"));
15958 process_arch_specific (FILE * file
)
15963 switch (elf_header
.e_machine
)
15966 return process_arm_specific (file
);
15968 case EM_MIPS_RS3_LE
:
15969 return process_mips_specific (file
);
15972 return process_nds32_specific (file
);
15975 return process_power_specific (file
);
15979 return process_s390_specific (file
);
15982 case EM_SPARC32PLUS
:
15984 return process_sparc_specific (file
);
15987 return process_tic6x_specific (file
);
15990 return process_msp430x_specific (file
);
15998 get_file_header (FILE * file
)
16000 /* Read in the identity array. */
16001 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
16004 /* Determine how to read the rest of the header. */
16005 switch (elf_header
.e_ident
[EI_DATA
])
16007 default: /* fall through */
16008 case ELFDATANONE
: /* fall through */
16010 byte_get
= byte_get_little_endian
;
16011 byte_put
= byte_put_little_endian
;
16014 byte_get
= byte_get_big_endian
;
16015 byte_put
= byte_put_big_endian
;
16019 /* For now we only support 32 bit and 64 bit ELF files. */
16020 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16022 /* Read in the rest of the header. */
16025 Elf32_External_Ehdr ehdr32
;
16027 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16030 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16031 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16032 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16033 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16034 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16035 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16036 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16037 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16038 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16039 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16040 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16041 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16042 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16046 Elf64_External_Ehdr ehdr64
;
16048 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16049 we will not be able to cope with the 64bit data found in
16050 64 ELF files. Detect this now and abort before we start
16051 overwriting things. */
16052 if (sizeof (bfd_vma
) < 8)
16054 error (_("This instance of readelf has been built without support for a\n\
16055 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16059 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16062 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16063 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16064 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16065 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16066 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16067 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16068 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16069 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16070 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16071 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16072 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16073 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16074 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16077 if (elf_header
.e_shoff
)
16079 /* There may be some extensions in the first section header. Don't
16080 bomb if we can't read it. */
16082 get_32bit_section_headers (file
, TRUE
);
16084 get_64bit_section_headers (file
, TRUE
);
16090 /* Process one ELF object file according to the command line options.
16091 This file may actually be stored in an archive. The file is
16092 positioned at the start of the ELF object. */
16095 process_object (char * file_name
, FILE * file
)
16099 if (! get_file_header (file
))
16101 error (_("%s: Failed to read file header\n"), file_name
);
16105 /* Initialise per file variables. */
16106 for (i
= ARRAY_SIZE (version_info
); i
--;)
16107 version_info
[i
] = 0;
16109 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16110 dynamic_info
[i
] = 0;
16111 dynamic_info_DT_GNU_HASH
= 0;
16113 /* Process the file. */
16115 printf (_("\nFile: %s\n"), file_name
);
16117 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16118 Note we do this even if cmdline_dump_sects is empty because we
16119 must make sure that the dump_sets array is zeroed out before each
16120 object file is processed. */
16121 if (num_dump_sects
> num_cmdline_dump_sects
)
16122 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16124 if (num_cmdline_dump_sects
> 0)
16126 if (num_dump_sects
== 0)
16127 /* A sneaky way of allocating the dump_sects array. */
16128 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16130 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16131 memcpy (dump_sects
, cmdline_dump_sects
,
16132 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16135 if (! process_file_header ())
16138 if (! process_section_headers (file
))
16140 /* Without loaded section headers we cannot process lots of
16142 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16144 if (! do_using_dynamic
)
16145 do_syms
= do_dyn_syms
= do_reloc
= 0;
16148 if (! process_section_groups (file
))
16150 /* Without loaded section groups we cannot process unwind. */
16154 if (process_program_headers (file
))
16155 process_dynamic_section (file
);
16157 process_relocs (file
);
16159 process_unwind (file
);
16161 process_symbol_table (file
);
16163 process_syminfo (file
);
16165 process_version_sections (file
);
16167 process_section_contents (file
);
16169 process_notes (file
);
16171 process_gnu_liblist (file
);
16173 process_arch_specific (file
);
16175 if (program_headers
)
16177 free (program_headers
);
16178 program_headers
= NULL
;
16181 if (section_headers
)
16183 free (section_headers
);
16184 section_headers
= NULL
;
16189 free (string_table
);
16190 string_table
= NULL
;
16191 string_table_length
= 0;
16194 if (dynamic_strings
)
16196 free (dynamic_strings
);
16197 dynamic_strings
= NULL
;
16198 dynamic_strings_length
= 0;
16201 if (dynamic_symbols
)
16203 free (dynamic_symbols
);
16204 dynamic_symbols
= NULL
;
16205 num_dynamic_syms
= 0;
16208 if (dynamic_syminfo
)
16210 free (dynamic_syminfo
);
16211 dynamic_syminfo
= NULL
;
16214 if (dynamic_section
)
16216 free (dynamic_section
);
16217 dynamic_section
= NULL
;
16220 if (section_headers_groups
)
16222 free (section_headers_groups
);
16223 section_headers_groups
= NULL
;
16226 if (section_groups
)
16228 struct group_list
* g
;
16229 struct group_list
* next
;
16231 for (i
= 0; i
< group_count
; i
++)
16233 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16240 free (section_groups
);
16241 section_groups
= NULL
;
16244 free_debug_memory ();
16249 /* Process an ELF archive.
16250 On entry the file is positioned just after the ARMAG string. */
16253 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16255 struct archive_info arch
;
16256 struct archive_info nested_arch
;
16262 /* The ARCH structure is used to hold information about this archive. */
16263 arch
.file_name
= NULL
;
16265 arch
.index_array
= NULL
;
16266 arch
.sym_table
= NULL
;
16267 arch
.longnames
= NULL
;
16269 /* The NESTED_ARCH structure is used as a single-item cache of information
16270 about a nested archive (when members of a thin archive reside within
16271 another regular archive file). */
16272 nested_arch
.file_name
= NULL
;
16273 nested_arch
.file
= NULL
;
16274 nested_arch
.index_array
= NULL
;
16275 nested_arch
.sym_table
= NULL
;
16276 nested_arch
.longnames
= NULL
;
16278 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16284 if (do_archive_index
)
16286 if (arch
.sym_table
== NULL
)
16287 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16290 unsigned long i
, l
;
16291 unsigned long current_pos
;
16293 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16294 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16295 current_pos
= ftell (file
);
16297 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16299 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16301 char * member_name
;
16303 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16305 if (member_name
!= NULL
)
16307 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16309 if (qualified_name
!= NULL
)
16311 printf (_("Contents of binary %s at offset "), qualified_name
);
16312 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16314 free (qualified_name
);
16319 if (l
>= arch
.sym_size
)
16321 error (_("%s: end of the symbol table reached before the end of the index\n"),
16325 /* PR 17531: file: 0b6630b2. */
16326 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16327 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16330 if (arch
.uses_64bit_indicies
)
16335 if (l
< arch
.sym_size
)
16336 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16337 file_name
, arch
.sym_size
- l
);
16339 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16341 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16347 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16348 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16349 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16350 && !do_section_groups
&& !do_dyn_syms
)
16352 ret
= 0; /* Archive index only. */
16363 char * qualified_name
;
16365 /* Read the next archive header. */
16366 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16368 error (_("%s: failed to seek to next archive header\n"), file_name
);
16371 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16372 if (got
!= sizeof arch
.arhdr
)
16376 error (_("%s: failed to read archive header\n"), file_name
);
16380 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16382 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16387 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16389 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16390 if (archive_file_size
& 01)
16391 ++archive_file_size
;
16393 name
= get_archive_member_name (&arch
, &nested_arch
);
16396 error (_("%s: bad archive file name\n"), file_name
);
16400 namelen
= strlen (name
);
16402 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16403 if (qualified_name
== NULL
)
16405 error (_("%s: bad archive file name\n"), file_name
);
16410 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16412 /* This is a proxy for an external member of a thin archive. */
16413 FILE * member_file
;
16414 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16415 if (member_file_name
== NULL
)
16421 member_file
= fopen (member_file_name
, "rb");
16422 if (member_file
== NULL
)
16424 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16425 free (member_file_name
);
16430 archive_file_offset
= arch
.nested_member_origin
;
16432 ret
|= process_object (qualified_name
, member_file
);
16434 fclose (member_file
);
16435 free (member_file_name
);
16437 else if (is_thin_archive
)
16439 /* PR 15140: Allow for corrupt thin archives. */
16440 if (nested_arch
.file
== NULL
)
16442 error (_("%s: contains corrupt thin archive: %s\n"),
16448 /* This is a proxy for a member of a nested archive. */
16449 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16451 /* The nested archive file will have been opened and setup by
16452 get_archive_member_name. */
16453 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16455 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16460 ret
|= process_object (qualified_name
, nested_arch
.file
);
16464 archive_file_offset
= arch
.next_arhdr_offset
;
16465 arch
.next_arhdr_offset
+= archive_file_size
;
16467 ret
|= process_object (qualified_name
, file
);
16470 if (dump_sects
!= NULL
)
16474 num_dump_sects
= 0;
16477 free (qualified_name
);
16481 if (nested_arch
.file
!= NULL
)
16482 fclose (nested_arch
.file
);
16483 release_archive (&nested_arch
);
16484 release_archive (&arch
);
16490 process_file (char * file_name
)
16493 struct stat statbuf
;
16494 char armag
[SARMAG
];
16497 if (stat (file_name
, &statbuf
) < 0)
16499 if (errno
== ENOENT
)
16500 error (_("'%s': No such file\n"), file_name
);
16502 error (_("Could not locate '%s'. System error message: %s\n"),
16503 file_name
, strerror (errno
));
16507 if (! S_ISREG (statbuf
.st_mode
))
16509 error (_("'%s' is not an ordinary file\n"), file_name
);
16513 file
= fopen (file_name
, "rb");
16516 error (_("Input file '%s' is not readable.\n"), file_name
);
16520 if (fread (armag
, SARMAG
, 1, file
) != 1)
16522 error (_("%s: Failed to read file's magic number\n"), file_name
);
16527 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16529 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16530 ret
= process_archive (file_name
, file
, FALSE
);
16531 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16532 ret
= process_archive (file_name
, file
, TRUE
);
16535 if (do_archive_index
)
16536 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16540 archive_file_size
= archive_file_offset
= 0;
16541 ret
= process_object (file_name
, file
);
16546 current_file_size
= 0;
16550 #ifdef SUPPORT_DISASSEMBLY
16551 /* Needed by the i386 disassembler. For extra credit, someone could
16552 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16556 print_address (unsigned int addr
, FILE * outfile
)
16558 fprintf (outfile
,"0x%8.8x", addr
);
16561 /* Needed by the i386 disassembler. */
16563 db_task_printsym (unsigned int addr
)
16565 print_address (addr
, stderr
);
16570 main (int argc
, char ** argv
)
16574 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16575 setlocale (LC_MESSAGES
, "");
16577 #if defined (HAVE_SETLOCALE)
16578 setlocale (LC_CTYPE
, "");
16580 bindtextdomain (PACKAGE
, LOCALEDIR
);
16581 textdomain (PACKAGE
);
16583 expandargv (&argc
, &argv
);
16585 parse_args (argc
, argv
);
16587 if (num_dump_sects
> 0)
16589 /* Make a copy of the dump_sects array. */
16590 cmdline_dump_sects
= (dump_type
*)
16591 malloc (num_dump_sects
* sizeof (* dump_sects
));
16592 if (cmdline_dump_sects
== NULL
)
16593 error (_("Out of memory allocating dump request table.\n"));
16596 memcpy (cmdline_dump_sects
, dump_sects
,
16597 num_dump_sects
* sizeof (* dump_sects
));
16598 num_cmdline_dump_sects
= num_dump_sects
;
16602 if (optind
< (argc
- 1))
16604 else if (optind
>= argc
)
16606 warn (_("Nothing to do.\n"));
16611 while (optind
< argc
)
16612 err
|= process_file (argv
[optind
++]);
16614 if (dump_sects
!= NULL
)
16616 if (cmdline_dump_sects
!= NULL
)
16617 free (cmdline_dump_sects
);