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)
9892 int check_def
, check_need
;
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"));
9922 if (symbols
[cnt
+ j
].st_shndx
>= elf_header
.e_shnum
9923 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
9926 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
9933 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
9935 Elf_Internal_Verneed ivn
;
9936 unsigned long offset
;
9938 offset
= offset_from_vma
9939 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
9940 sizeof (Elf_External_Verneed
));
9944 Elf_Internal_Vernaux ivna
;
9945 Elf_External_Verneed evn
;
9946 Elf_External_Vernaux evna
;
9947 unsigned long a_off
;
9949 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
9950 _("version need")) == NULL
)
9953 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
9954 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
9956 a_off
= offset
+ ivn
.vn_aux
;
9960 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
9961 1, _("version need aux (2)")) == NULL
)
9968 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
9969 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
9972 a_off
+= ivna
.vna_next
;
9974 while (ivna
.vna_other
!= data
[cnt
+ j
]
9975 && ivna
.vna_next
!= 0);
9977 if (ivna
.vna_other
== data
[cnt
+ j
])
9979 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
9981 if (ivna
.vna_name
>= string_sec
->sh_size
)
9982 name
= _("*invalid*");
9984 name
= strtab
+ ivna
.vna_name
;
9985 nn
+= printf ("(%s%-*s",
9987 12 - (int) strlen (name
),
9993 offset
+= ivn
.vn_next
;
9995 while (ivn
.vn_next
);
9998 if (check_def
&& data
[cnt
+ j
] != 0x8001
9999 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10001 Elf_Internal_Verdef ivd
;
10002 Elf_External_Verdef evd
;
10003 unsigned long offset
;
10005 offset
= offset_from_vma
10006 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10011 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10012 _("version def")) == NULL
)
10015 /* PR 17531: file: 046-1082287-0.004. */
10016 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10021 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10022 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10025 offset
+= ivd
.vd_next
;
10027 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10028 && ivd
.vd_next
!= 0);
10030 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10032 Elf_External_Verdaux evda
;
10033 Elf_Internal_Verdaux ivda
;
10035 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10037 if (get_data (&evda
, file
,
10038 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10040 _("version def aux")) == NULL
)
10043 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10045 if (ivda
.vda_name
>= string_sec
->sh_size
)
10046 name
= _("*invalid*");
10048 name
= strtab
+ ivda
.vda_name
;
10049 nn
+= printf ("(%s%-*s",
10051 12 - (int) strlen (name
),
10057 printf ("%*c", 18 - nn
, ' ');
10075 printf (_("\nNo version information found in this file.\n"));
10080 static const char *
10081 get_symbol_binding (unsigned int binding
)
10083 static char buff
[32];
10087 case STB_LOCAL
: return "LOCAL";
10088 case STB_GLOBAL
: return "GLOBAL";
10089 case STB_WEAK
: return "WEAK";
10091 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10092 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10094 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10096 if (binding
== STB_GNU_UNIQUE
10097 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10098 /* GNU is still using the default value 0. */
10099 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10101 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10104 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10109 static const char *
10110 get_symbol_type (unsigned int type
)
10112 static char buff
[32];
10116 case STT_NOTYPE
: return "NOTYPE";
10117 case STT_OBJECT
: return "OBJECT";
10118 case STT_FUNC
: return "FUNC";
10119 case STT_SECTION
: return "SECTION";
10120 case STT_FILE
: return "FILE";
10121 case STT_COMMON
: return "COMMON";
10122 case STT_TLS
: return "TLS";
10123 case STT_RELC
: return "RELC";
10124 case STT_SRELC
: return "SRELC";
10126 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10128 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10129 return "THUMB_FUNC";
10131 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10134 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10135 return "PARISC_MILLI";
10137 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10139 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10141 if (elf_header
.e_machine
== EM_PARISC
)
10143 if (type
== STT_HP_OPAQUE
)
10144 return "HP_OPAQUE";
10145 if (type
== STT_HP_STUB
)
10149 if (type
== STT_GNU_IFUNC
10150 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10151 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10152 /* GNU is still using the default value 0. */
10153 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10156 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10159 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10164 static const char *
10165 get_symbol_visibility (unsigned int visibility
)
10167 switch (visibility
)
10169 case STV_DEFAULT
: return "DEFAULT";
10170 case STV_INTERNAL
: return "INTERNAL";
10171 case STV_HIDDEN
: return "HIDDEN";
10172 case STV_PROTECTED
: return "PROTECTED";
10174 error (_("Unrecognized visibility value: %u"), visibility
);
10175 return _("<unknown>");
10179 static const char *
10180 get_mips_symbol_other (unsigned int other
)
10190 case STO_MICROMIPS
:
10191 return "MICROMIPS";
10192 case STO_MICROMIPS
| STO_MIPS_PIC
:
10193 return "MICROMIPS, MIPS PIC";
10201 static const char *
10202 get_ia64_symbol_other (unsigned int other
)
10204 if (is_ia64_vms ())
10206 static char res
[32];
10210 /* Function types is for images and .STB files only. */
10211 switch (elf_header
.e_type
)
10215 switch (VMS_ST_FUNC_TYPE (other
))
10217 case VMS_SFT_CODE_ADDR
:
10218 strcat (res
, " CA");
10220 case VMS_SFT_SYMV_IDX
:
10221 strcat (res
, " VEC");
10224 strcat (res
, " FD");
10226 case VMS_SFT_RESERVE
:
10227 strcat (res
, " RSV");
10230 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10231 VMS_ST_FUNC_TYPE (other
));
10232 strcat (res
, " <unknown>");
10239 switch (VMS_ST_LINKAGE (other
))
10241 case VMS_STL_IGNORE
:
10242 strcat (res
, " IGN");
10244 case VMS_STL_RESERVE
:
10245 strcat (res
, " RSV");
10248 strcat (res
, " STD");
10251 strcat (res
, " LNK");
10254 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10255 VMS_ST_LINKAGE (other
));
10256 strcat (res
, " <unknown>");
10268 static const char *
10269 get_ppc64_symbol_other (unsigned int other
)
10271 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10273 static char buf
[32];
10274 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10275 PPC64_LOCAL_ENTRY_OFFSET (other
));
10281 static const char *
10282 get_symbol_other (unsigned int other
)
10284 const char * result
= NULL
;
10285 static char buff
[32];
10290 switch (elf_header
.e_machine
)
10293 result
= get_mips_symbol_other (other
);
10296 result
= get_ia64_symbol_other (other
);
10299 result
= get_ppc64_symbol_other (other
);
10308 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10312 static const char *
10313 get_symbol_index_type (unsigned int type
)
10315 static char buff
[32];
10319 case SHN_UNDEF
: return "UND";
10320 case SHN_ABS
: return "ABS";
10321 case SHN_COMMON
: return "COM";
10323 if (type
== SHN_IA_64_ANSI_COMMON
10324 && elf_header
.e_machine
== EM_IA_64
10325 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10327 else if ((elf_header
.e_machine
== EM_X86_64
10328 || elf_header
.e_machine
== EM_L1OM
10329 || elf_header
.e_machine
== EM_K1OM
)
10330 && type
== SHN_X86_64_LCOMMON
)
10331 return "LARGE_COM";
10332 else if ((type
== SHN_MIPS_SCOMMON
10333 && elf_header
.e_machine
== EM_MIPS
)
10334 || (type
== SHN_TIC6X_SCOMMON
10335 && elf_header
.e_machine
== EM_TI_C6000
))
10337 else if (type
== SHN_MIPS_SUNDEFINED
10338 && elf_header
.e_machine
== EM_MIPS
)
10340 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10341 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10342 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10343 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10344 else if (type
>= SHN_LORESERVE
)
10345 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10346 else if (type
>= elf_header
.e_shnum
)
10347 sprintf (buff
, _("bad section index[%3d]"), type
);
10349 sprintf (buff
, "%3d", type
);
10357 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10359 unsigned char * e_data
;
10362 /* If the size_t type is smaller than the bfd_size_type, eg because
10363 you are building a 32-bit tool on a 64-bit host, then make sure
10364 that when (number) is cast to (size_t) no information is lost. */
10365 if (sizeof (size_t) < sizeof (bfd_size_type
)
10366 && (bfd_size_type
) ((size_t) number
) != number
)
10368 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10369 (unsigned long long) number
, ent_size
);
10373 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10374 attempting to allocate memory when the read is bound to fail. */
10375 if (ent_size
* number
> current_file_size
)
10377 error (_("Invalid number of dynamic entries: %llu\n"),
10378 (unsigned long long) number
);
10382 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10383 if (e_data
== NULL
)
10385 error (_("Out of memory reading %llu dynamic entries\n"),
10386 (unsigned long long) number
);
10390 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10392 error (_("Unable to read in %llu bytes of dynamic data\n"),
10393 (unsigned long long) (number
* ent_size
));
10398 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10399 if (i_data
== NULL
)
10401 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10402 (unsigned long long) number
);
10408 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10416 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
10418 Elf_Internal_Sym
* psym
;
10421 n
= print_vma (si
, DEC_5
);
10423 fputs (&" "[n
], stdout
);
10424 printf (" %3lu: ", hn
);
10426 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
10428 printf (_("<No info available for dynamic symbol number %lu>\n"),
10429 (unsigned long) si
);
10433 psym
= dynamic_symbols
+ si
;
10434 print_vma (psym
->st_value
, LONG_HEX
);
10436 print_vma (psym
->st_size
, DEC_5
);
10438 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10439 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10440 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10441 /* Check to see if any other bits in the st_other field are set.
10442 Note - displaying this information disrupts the layout of the
10443 table being generated, but for the moment this case is very
10445 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10446 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10447 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
10448 if (VALID_DYNAMIC_NAME (psym
->st_name
))
10449 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
10451 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
10455 static const char *
10456 get_symbol_version_string (FILE *file
, int is_dynsym
,
10457 const char *strtab
,
10458 unsigned long int strtab_size
,
10459 unsigned int si
, Elf_Internal_Sym
*psym
,
10460 enum versioned_symbol_info
*sym_info
,
10461 unsigned short *vna_other
)
10463 const char *version_string
= NULL
;
10466 && version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
10468 unsigned char data
[2];
10469 unsigned short vers_data
;
10470 unsigned long offset
;
10474 offset
= offset_from_vma
10475 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10476 sizeof data
+ si
* sizeof (vers_data
));
10478 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
10479 sizeof (data
), 1, _("version data")) == NULL
)
10482 vers_data
= byte_get (data
, 2);
10484 is_nobits
= (section_headers
!= NULL
10485 && psym
->st_shndx
< elf_header
.e_shnum
10486 && section_headers
[psym
->st_shndx
].sh_type
10489 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
10491 if ((vers_data
& VERSYM_HIDDEN
) || vers_data
> 1)
10493 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
10494 && (is_nobits
|| ! check_def
))
10496 Elf_External_Verneed evn
;
10497 Elf_Internal_Verneed ivn
;
10498 Elf_Internal_Vernaux ivna
;
10500 /* We must test both. */
10501 offset
= offset_from_vma
10502 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10507 unsigned long vna_off
;
10509 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10510 _("version need")) == NULL
)
10513 ivna
.vna_other
= 0;
10518 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10519 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10521 vna_off
= offset
+ ivn
.vn_aux
;
10525 Elf_External_Vernaux evna
;
10527 if (get_data (&evna
, file
, vna_off
,
10529 _("version need aux (3)")) == NULL
)
10532 ivna
.vna_other
= 0;
10537 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10538 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10539 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10542 vna_off
+= ivna
.vna_next
;
10544 while (ivna
.vna_other
!= vers_data
10545 && ivna
.vna_next
!= 0);
10547 if (ivna
.vna_other
== vers_data
)
10550 offset
+= ivn
.vn_next
;
10552 while (ivn
.vn_next
!= 0);
10554 if (ivna
.vna_other
== vers_data
)
10556 *sym_info
= symbol_undefined
;
10557 *vna_other
= ivna
.vna_other
;
10558 version_string
= (ivna
.vna_name
< strtab_size
10559 ? strtab
+ ivna
.vna_name
10563 else if (! is_nobits
)
10564 error (_("bad dynamic symbol\n"));
10571 if (vers_data
!= 0x8001
10572 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10574 Elf_Internal_Verdef ivd
;
10575 Elf_Internal_Verdaux ivda
;
10576 Elf_External_Verdaux evda
;
10579 off
= offset_from_vma
10581 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10582 sizeof (Elf_External_Verdef
));
10586 Elf_External_Verdef evd
;
10588 if (get_data (&evd
, file
, off
, sizeof (evd
),
10589 1, _("version def")) == NULL
)
10597 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10598 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10599 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10602 off
+= ivd
.vd_next
;
10604 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
)
10605 && ivd
.vd_next
!= 0);
10607 off
-= ivd
.vd_next
;
10610 if (get_data (&evda
, file
, off
, sizeof (evda
),
10611 1, _("version def aux")) == NULL
)
10612 return version_string
;
10614 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10616 if (psym
->st_name
!= ivda
.vda_name
)
10618 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
10619 ? symbol_hidden
: symbol_public
);
10620 version_string
= (ivda
.vda_name
< strtab_size
10621 ? strtab
+ ivda
.vda_name
10628 return version_string
;
10631 /* Dump the symbol table. */
10633 process_symbol_table (FILE * file
)
10635 Elf_Internal_Shdr
* section
;
10636 bfd_size_type nbuckets
= 0;
10637 bfd_size_type nchains
= 0;
10638 bfd_vma
* buckets
= NULL
;
10639 bfd_vma
* chains
= NULL
;
10640 bfd_vma ngnubuckets
= 0;
10641 bfd_vma
* gnubuckets
= NULL
;
10642 bfd_vma
* gnuchains
= NULL
;
10643 bfd_vma gnusymidx
= 0;
10644 bfd_size_type ngnuchains
= 0;
10646 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
10649 if (dynamic_info
[DT_HASH
]
10651 || (do_using_dynamic
10653 && dynamic_strings
!= NULL
)))
10655 unsigned char nb
[8];
10656 unsigned char nc
[8];
10657 unsigned int hash_ent_size
= 4;
10659 if ((elf_header
.e_machine
== EM_ALPHA
10660 || elf_header
.e_machine
== EM_S390
10661 || elf_header
.e_machine
== EM_S390_OLD
)
10662 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10666 (archive_file_offset
10667 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
10668 sizeof nb
+ sizeof nc
)),
10671 error (_("Unable to seek to start of dynamic information\n"));
10675 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
10677 error (_("Failed to read in number of buckets\n"));
10681 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
10683 error (_("Failed to read in number of chains\n"));
10687 nbuckets
= byte_get (nb
, hash_ent_size
);
10688 nchains
= byte_get (nc
, hash_ent_size
);
10690 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
10691 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
10694 if (buckets
== NULL
|| chains
== NULL
)
10696 if (do_using_dynamic
)
10707 if (dynamic_info_DT_GNU_HASH
10709 || (do_using_dynamic
10711 && dynamic_strings
!= NULL
)))
10713 unsigned char nb
[16];
10714 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10715 bfd_vma buckets_vma
;
10718 (archive_file_offset
10719 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
10723 error (_("Unable to seek to start of dynamic information\n"));
10727 if (fread (nb
, 16, 1, file
) != 1)
10729 error (_("Failed to read in number of buckets\n"));
10733 ngnubuckets
= byte_get (nb
, 4);
10734 gnusymidx
= byte_get (nb
+ 4, 4);
10735 bitmaskwords
= byte_get (nb
+ 8, 4);
10736 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
10738 buckets_vma
+= bitmaskwords
* 4;
10740 buckets_vma
+= bitmaskwords
* 8;
10743 (archive_file_offset
10744 + offset_from_vma (file
, buckets_vma
, 4)),
10747 error (_("Unable to seek to start of dynamic information\n"));
10751 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
10753 if (gnubuckets
== NULL
)
10756 for (i
= 0; i
< ngnubuckets
; i
++)
10757 if (gnubuckets
[i
] != 0)
10759 if (gnubuckets
[i
] < gnusymidx
)
10762 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
10763 maxchain
= gnubuckets
[i
];
10766 if (maxchain
== 0xffffffff)
10769 maxchain
-= gnusymidx
;
10772 (archive_file_offset
10773 + offset_from_vma (file
, buckets_vma
10774 + 4 * (ngnubuckets
+ maxchain
), 4)),
10777 error (_("Unable to seek to start of dynamic information\n"));
10783 if (fread (nb
, 4, 1, file
) != 1)
10785 error (_("Failed to determine last chain length\n"));
10789 if (maxchain
+ 1 == 0)
10794 while ((byte_get (nb
, 4) & 1) == 0);
10797 (archive_file_offset
10798 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
10801 error (_("Unable to seek to start of dynamic information\n"));
10805 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
10806 ngnuchains
= maxchain
;
10809 if (gnuchains
== NULL
)
10814 if (do_using_dynamic
)
10819 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
10821 && do_using_dynamic
10822 && dynamic_strings
!= NULL
10823 && dynamic_symbols
!= NULL
)
10827 if (dynamic_info
[DT_HASH
])
10831 printf (_("\nSymbol table for image:\n"));
10833 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10835 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10837 for (hn
= 0; hn
< nbuckets
; hn
++)
10842 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
10843 print_dynamic_symbol (si
, hn
);
10847 if (dynamic_info_DT_GNU_HASH
)
10849 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10851 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10853 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10855 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
10856 if (gnubuckets
[hn
] != 0)
10858 bfd_vma si
= gnubuckets
[hn
];
10859 bfd_vma off
= si
- gnusymidx
;
10863 print_dynamic_symbol (si
, hn
);
10866 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
10870 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
10871 && section_headers
!= NULL
)
10875 for (i
= 0, section
= section_headers
;
10876 i
< elf_header
.e_shnum
;
10880 char * strtab
= NULL
;
10881 unsigned long int strtab_size
= 0;
10882 Elf_Internal_Sym
* symtab
;
10883 Elf_Internal_Sym
* psym
;
10884 unsigned long num_syms
;
10886 if ((section
->sh_type
!= SHT_SYMTAB
10887 && section
->sh_type
!= SHT_DYNSYM
)
10889 && section
->sh_type
== SHT_SYMTAB
))
10892 if (section
->sh_entsize
== 0)
10894 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10895 printable_section_name (section
));
10899 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10900 printable_section_name (section
),
10901 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
10904 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10906 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10908 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
10909 if (symtab
== NULL
)
10912 if (section
->sh_link
== elf_header
.e_shstrndx
)
10914 strtab
= string_table
;
10915 strtab_size
= string_table_length
;
10917 else if (section
->sh_link
< elf_header
.e_shnum
)
10919 Elf_Internal_Shdr
* string_sec
;
10921 string_sec
= section_headers
+ section
->sh_link
;
10923 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
10924 1, string_sec
->sh_size
,
10925 _("string table"));
10926 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
10929 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
10931 const char *version_string
;
10932 enum versioned_symbol_info sym_info
;
10933 unsigned short vna_other
;
10935 printf ("%6d: ", si
);
10936 print_vma (psym
->st_value
, LONG_HEX
);
10938 print_vma (psym
->st_size
, DEC_5
);
10939 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
10940 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
10941 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
10942 /* Check to see if any other bits in the st_other field are set.
10943 Note - displaying this information disrupts the layout of the
10944 table being generated, but for the moment this case is very rare. */
10945 if (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
))
10946 printf (" [%s] ", get_symbol_other (psym
->st_other
^ ELF_ST_VISIBILITY (psym
->st_other
)));
10947 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
10948 print_symbol (25, psym
->st_name
< strtab_size
10949 ? strtab
+ psym
->st_name
: _("<corrupt>"));
10952 = get_symbol_version_string (file
,
10953 section
->sh_type
== SHT_DYNSYM
,
10954 strtab
, strtab_size
, si
,
10955 psym
, &sym_info
, &vna_other
);
10956 if (version_string
)
10958 if (sym_info
== symbol_undefined
)
10959 printf ("@%s (%d)", version_string
, vna_other
);
10961 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
10969 if (strtab
!= string_table
)
10975 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10977 if (do_histogram
&& buckets
!= NULL
)
10979 unsigned long * lengths
;
10980 unsigned long * counts
;
10983 unsigned long maxlength
= 0;
10984 unsigned long nzero_counts
= 0;
10985 unsigned long nsyms
= 0;
10986 unsigned long chained
;
10988 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10989 (unsigned long) nbuckets
);
10991 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
10992 if (lengths
== NULL
)
10994 error (_("Out of memory allocating space for histogram buckets\n"));
10998 printf (_(" Length Number %% of total Coverage\n"));
10999 for (hn
= 0; hn
< nbuckets
; ++hn
)
11001 for (si
= buckets
[hn
], chained
= 0;
11002 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11003 si
= chains
[si
], ++chained
)
11006 if (maxlength
< ++lengths
[hn
])
11010 /* PR binutils/17531: A corrupt binary could contain broken
11011 histogram data. Do not go into an infinite loop trying
11013 if (chained
> nchains
)
11015 error (_("histogram chain is corrupt\n"));
11020 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11021 if (counts
== NULL
)
11024 error (_("Out of memory allocating space for histogram counts\n"));
11028 for (hn
= 0; hn
< nbuckets
; ++hn
)
11029 ++counts
[lengths
[hn
]];
11034 printf (" 0 %-10lu (%5.1f%%)\n",
11035 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11036 for (i
= 1; i
<= maxlength
; ++i
)
11038 nzero_counts
+= counts
[i
] * i
;
11039 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11040 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11041 (nzero_counts
* 100.0) / nsyms
);
11049 if (buckets
!= NULL
)
11055 if (do_histogram
&& gnubuckets
!= NULL
)
11057 unsigned long * lengths
;
11058 unsigned long * counts
;
11060 unsigned long maxlength
= 0;
11061 unsigned long nzero_counts
= 0;
11062 unsigned long nsyms
= 0;
11064 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11065 (unsigned long) ngnubuckets
);
11067 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11068 if (lengths
== NULL
)
11070 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11074 printf (_(" Length Number %% of total Coverage\n"));
11076 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11077 if (gnubuckets
[hn
] != 0)
11079 bfd_vma off
, length
= 1;
11081 for (off
= gnubuckets
[hn
] - gnusymidx
;
11082 /* PR 17531 file: 010-77222-0.004. */
11083 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11086 lengths
[hn
] = length
;
11087 if (length
> maxlength
)
11088 maxlength
= length
;
11092 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11093 if (counts
== NULL
)
11096 error (_("Out of memory allocating space for gnu histogram counts\n"));
11100 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11101 ++counts
[lengths
[hn
]];
11103 if (ngnubuckets
> 0)
11106 printf (" 0 %-10lu (%5.1f%%)\n",
11107 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11108 for (j
= 1; j
<= maxlength
; ++j
)
11110 nzero_counts
+= counts
[j
] * j
;
11111 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11112 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11113 (nzero_counts
* 100.0) / nsyms
);
11127 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11131 if (dynamic_syminfo
== NULL
11133 /* No syminfo, this is ok. */
11136 /* There better should be a dynamic symbol section. */
11137 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11141 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11142 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11144 printf (_(" Num: Name BoundTo Flags\n"));
11145 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11147 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11149 printf ("%4d: ", i
);
11150 if (i
>= num_dynamic_syms
)
11151 printf (_("<corrupt index>"));
11152 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11153 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11155 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11158 switch (dynamic_syminfo
[i
].si_boundto
)
11160 case SYMINFO_BT_SELF
:
11161 fputs ("SELF ", stdout
);
11163 case SYMINFO_BT_PARENT
:
11164 fputs ("PARENT ", stdout
);
11167 if (dynamic_syminfo
[i
].si_boundto
> 0
11168 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11169 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11171 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11175 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11179 if (flags
& SYMINFO_FLG_DIRECT
)
11180 printf (" DIRECT");
11181 if (flags
& SYMINFO_FLG_PASSTHRU
)
11182 printf (" PASSTHRU");
11183 if (flags
& SYMINFO_FLG_COPY
)
11185 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11186 printf (" LAZYLOAD");
11194 /* Check to see if the given reloc needs to be handled in a target specific
11195 manner. If so then process the reloc and return TRUE otherwise return
11199 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11200 unsigned char * start
,
11201 Elf_Internal_Sym
* symtab
)
11203 unsigned int reloc_type
= get_reloc_type (reloc
->r_info
);
11205 switch (elf_header
.e_machine
)
11208 case EM_MSP430_OLD
:
11210 static Elf_Internal_Sym
* saved_sym
= NULL
;
11212 switch (reloc_type
)
11214 case 10: /* R_MSP430_SYM_DIFF */
11215 if (uses_msp430x_relocs ())
11217 case 21: /* R_MSP430X_SYM_DIFF */
11218 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11221 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11222 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11223 goto handle_sym_diff
;
11225 case 5: /* R_MSP430_16_BYTE */
11226 case 9: /* R_MSP430_8 */
11227 if (uses_msp430x_relocs ())
11229 goto handle_sym_diff
;
11231 case 2: /* R_MSP430_ABS16 */
11232 case 15: /* R_MSP430X_ABS16 */
11233 if (! uses_msp430x_relocs ())
11235 goto handle_sym_diff
;
11238 if (saved_sym
!= NULL
)
11242 value
= reloc
->r_addend
11243 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11244 - saved_sym
->st_value
);
11246 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11254 if (saved_sym
!= NULL
)
11255 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11262 case EM_CYGNUS_MN10300
:
11264 static Elf_Internal_Sym
* saved_sym
= NULL
;
11266 switch (reloc_type
)
11268 case 34: /* R_MN10300_ALIGN */
11270 case 33: /* R_MN10300_SYM_DIFF */
11271 saved_sym
= symtab
+ get_reloc_symindex (reloc
->r_info
);
11273 case 1: /* R_MN10300_32 */
11274 case 2: /* R_MN10300_16 */
11275 if (saved_sym
!= NULL
)
11279 value
= reloc
->r_addend
11280 + (symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
11281 - saved_sym
->st_value
);
11283 byte_put (start
+ reloc
->r_offset
, value
, reloc_type
== 1 ? 4 : 2);
11290 if (saved_sym
!= NULL
)
11291 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11299 static bfd_vma saved_sym1
= 0;
11300 static bfd_vma saved_sym2
= 0;
11301 static bfd_vma value
;
11303 switch (reloc_type
)
11305 case 0x80: /* R_RL78_SYM. */
11306 saved_sym1
= saved_sym2
;
11307 saved_sym2
= symtab
[get_reloc_symindex (reloc
->r_info
)].st_value
;
11308 saved_sym2
+= reloc
->r_addend
;
11311 case 0x83: /* R_RL78_OPsub. */
11312 value
= saved_sym1
- saved_sym2
;
11313 saved_sym2
= saved_sym1
= 0;
11317 case 0x41: /* R_RL78_ABS32. */
11318 byte_put (start
+ reloc
->r_offset
, value
, 4);
11322 case 0x43: /* R_RL78_ABS16. */
11323 byte_put (start
+ reloc
->r_offset
, value
, 2);
11337 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11338 DWARF debug sections. This is a target specific test. Note - we do not
11339 go through the whole including-target-headers-multiple-times route, (as
11340 we have already done with <elf/h8.h>) because this would become very
11341 messy and even then this function would have to contain target specific
11342 information (the names of the relocs instead of their numeric values).
11343 FIXME: This is not the correct way to solve this problem. The proper way
11344 is to have target specific reloc sizing and typing functions created by
11345 the reloc-macros.h header, in the same way that it already creates the
11346 reloc naming functions. */
11349 is_32bit_abs_reloc (unsigned int reloc_type
)
11351 switch (elf_header
.e_machine
)
11355 return reloc_type
== 1; /* R_386_32. */
11357 return reloc_type
== 1; /* R_68K_32. */
11359 return reloc_type
== 1; /* R_860_32. */
11361 return reloc_type
== 2; /* R_960_32. */
11363 return reloc_type
== 258; /* R_AARCH64_ABS32 */
11365 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
11367 return reloc_type
== 1; /* R_ARC_32. */
11368 case EM_ARC_COMPACT
:
11369 case EM_ARC_COMPACT2
:
11370 return reloc_type
== 4; /* R_ARC_32. */
11372 return reloc_type
== 2; /* R_ARM_ABS32 */
11375 return reloc_type
== 1;
11376 case EM_ADAPTEVA_EPIPHANY
:
11377 return reloc_type
== 3;
11379 return reloc_type
== 0x12; /* R_byte4_data. */
11381 return reloc_type
== 3; /* R_CRIS_32. */
11383 return reloc_type
== 3; /* R_CR16_NUM32. */
11385 return reloc_type
== 15; /* R_CRX_NUM32. */
11386 case EM_CYGNUS_FRV
:
11387 return reloc_type
== 1;
11388 case EM_CYGNUS_D10V
:
11390 return reloc_type
== 6; /* R_D10V_32. */
11391 case EM_CYGNUS_D30V
:
11393 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
11395 return reloc_type
== 3; /* R_DLX_RELOC_32. */
11396 case EM_CYGNUS_FR30
:
11398 return reloc_type
== 3; /* R_FR30_32. */
11400 return reloc_type
== 1; /* R_FT32_32. */
11404 return reloc_type
== 1; /* R_H8_DIR32. */
11406 return reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
11407 || reloc_type
== 0x25; /* R_IA64_DIR32LSB. */
11410 return reloc_type
== 2; /* R_IP2K_32. */
11412 return reloc_type
== 2; /* R_IQ2000_32. */
11413 case EM_LATTICEMICO32
:
11414 return reloc_type
== 3; /* R_LM32_32. */
11417 return reloc_type
== 3; /* R_M32C_32. */
11419 return reloc_type
== 34; /* R_M32R_32_RELA. */
11421 return reloc_type
== 1; /* R_MCORE_ADDR32. */
11422 case EM_CYGNUS_MEP
:
11423 return reloc_type
== 4; /* R_MEP_32. */
11425 return reloc_type
== 2; /* R_METAG_ADDR32. */
11426 case EM_MICROBLAZE
:
11427 return reloc_type
== 1; /* R_MICROBLAZE_32. */
11429 return reloc_type
== 2; /* R_MIPS_32. */
11431 return reloc_type
== 4; /* R_MMIX_32. */
11432 case EM_CYGNUS_MN10200
:
11434 return reloc_type
== 1; /* R_MN10200_32. */
11435 case EM_CYGNUS_MN10300
:
11437 return reloc_type
== 1; /* R_MN10300_32. */
11439 return reloc_type
== 1; /* R_MOXIE_32. */
11440 case EM_MSP430_OLD
:
11442 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11444 return reloc_type
== 2; /* R_MT_32. */
11446 return reloc_type
== 20; /* R_NDS32_RELA. */
11447 case EM_ALTERA_NIOS2
:
11448 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
11450 return reloc_type
== 1; /* R_NIOS_32. */
11452 return reloc_type
== 1; /* R_OR1K_32. */
11454 return (reloc_type
== 1 /* R_PARISC_DIR32. */
11455 || reloc_type
== 41); /* R_PARISC_SECREL32. */
11458 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
11460 return reloc_type
== 1; /* R_PPC64_ADDR32. */
11462 return reloc_type
== 1; /* R_PPC_ADDR32. */
11464 return reloc_type
== 1; /* R_RL78_DIR32. */
11466 return reloc_type
== 1; /* R_RX_DIR32. */
11468 return reloc_type
== 1; /* R_I370_ADDR31. */
11471 return reloc_type
== 4; /* R_S390_32. */
11473 return reloc_type
== 8; /* R_SCORE_ABS32. */
11475 return reloc_type
== 1; /* R_SH_DIR32. */
11476 case EM_SPARC32PLUS
:
11479 return reloc_type
== 3 /* R_SPARC_32. */
11480 || reloc_type
== 23; /* R_SPARC_UA32. */
11482 return reloc_type
== 6; /* R_SPU_ADDR32 */
11484 return reloc_type
== 1; /* R_C6000_ABS32. */
11486 return reloc_type
== 2; /* R_TILEGX_32. */
11488 return reloc_type
== 1; /* R_TILEPRO_32. */
11489 case EM_CYGNUS_V850
:
11491 return reloc_type
== 6; /* R_V850_ABS32. */
11493 return reloc_type
== 0x33; /* R_V810_WORD. */
11495 return reloc_type
== 1; /* R_VAX_32. */
11497 return reloc_type
== 3; /* R_VISIUM_32. */
11501 return reloc_type
== 10; /* R_X86_64_32. */
11504 return reloc_type
== 3; /* R_XC16C_ABS_32. */
11506 return reloc_type
== 4; /* R_XGATE_32. */
11508 return reloc_type
== 1; /* R_XSTROMY16_32. */
11509 case EM_XTENSA_OLD
:
11511 return reloc_type
== 1; /* R_XTENSA_32. */
11514 static unsigned int prev_warn
= 0;
11516 /* Avoid repeating the same warning multiple times. */
11517 if (prev_warn
!= elf_header
.e_machine
)
11518 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11519 elf_header
.e_machine
);
11520 prev_warn
= elf_header
.e_machine
;
11526 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11527 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11530 is_32bit_pcrel_reloc (unsigned int reloc_type
)
11532 switch (elf_header
.e_machine
)
11536 return reloc_type
== 2; /* R_386_PC32. */
11538 return reloc_type
== 4; /* R_68K_PC32. */
11540 return reloc_type
== 261; /* R_AARCH64_PREL32 */
11541 case EM_ADAPTEVA_EPIPHANY
:
11542 return reloc_type
== 6;
11544 return reloc_type
== 10; /* R_ALPHA_SREL32. */
11546 return reloc_type
== 3; /* R_ARM_REL32 */
11547 case EM_MICROBLAZE
:
11548 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
11550 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
11552 return reloc_type
== 9; /* R_PARISC_PCREL32. */
11554 return reloc_type
== 26; /* R_PPC_REL32. */
11556 return reloc_type
== 26; /* R_PPC64_REL32. */
11559 return reloc_type
== 5; /* R_390_PC32. */
11561 return reloc_type
== 2; /* R_SH_REL32. */
11562 case EM_SPARC32PLUS
:
11565 return reloc_type
== 6; /* R_SPARC_DISP32. */
11567 return reloc_type
== 13; /* R_SPU_REL32. */
11569 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
11571 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
11573 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
11577 return reloc_type
== 2; /* R_X86_64_PC32. */
11578 case EM_XTENSA_OLD
:
11580 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
11582 /* Do not abort or issue an error message here. Not all targets use
11583 pc-relative 32-bit relocs in their DWARF debug information and we
11584 have already tested for target coverage in is_32bit_abs_reloc. A
11585 more helpful warning message will be generated by apply_relocations
11586 anyway, so just return. */
11591 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11592 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11595 is_64bit_abs_reloc (unsigned int reloc_type
)
11597 switch (elf_header
.e_machine
)
11600 return reloc_type
== 257; /* R_AARCH64_ABS64. */
11602 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
11604 return reloc_type
== 0x27; /* R_IA64_DIR64LSB. */
11606 return reloc_type
== 80; /* R_PARISC_DIR64. */
11608 return reloc_type
== 38; /* R_PPC64_ADDR64. */
11609 case EM_SPARC32PLUS
:
11612 return reloc_type
== 54; /* R_SPARC_UA64. */
11616 return reloc_type
== 1; /* R_X86_64_64. */
11619 return reloc_type
== 22; /* R_S390_64. */
11621 return reloc_type
== 1; /* R_TILEGX_64. */
11623 return reloc_type
== 18; /* R_MIPS_64. */
11629 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11630 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11633 is_64bit_pcrel_reloc (unsigned int reloc_type
)
11635 switch (elf_header
.e_machine
)
11638 return reloc_type
== 260; /* R_AARCH64_PREL64. */
11640 return reloc_type
== 11; /* R_ALPHA_SREL64. */
11642 return reloc_type
== 0x4f; /* R_IA64_PCREL64LSB. */
11644 return reloc_type
== 72; /* R_PARISC_PCREL64. */
11646 return reloc_type
== 44; /* R_PPC64_REL64. */
11647 case EM_SPARC32PLUS
:
11650 return reloc_type
== 46; /* R_SPARC_DISP64. */
11654 return reloc_type
== 24; /* R_X86_64_PC64. */
11657 return reloc_type
== 23; /* R_S390_PC64. */
11659 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
11665 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11666 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11669 is_24bit_abs_reloc (unsigned int reloc_type
)
11671 switch (elf_header
.e_machine
)
11673 case EM_CYGNUS_MN10200
:
11675 return reloc_type
== 4; /* R_MN10200_24. */
11681 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11682 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11685 is_16bit_abs_reloc (unsigned int reloc_type
)
11687 switch (elf_header
.e_machine
)
11690 case EM_ARC_COMPACT
:
11691 case EM_ARC_COMPACT2
:
11692 return reloc_type
== 2; /* R_ARC_16. */
11695 return reloc_type
== 4; /* R_AVR_16. */
11696 case EM_ADAPTEVA_EPIPHANY
:
11697 return reloc_type
== 5;
11698 case EM_CYGNUS_D10V
:
11700 return reloc_type
== 3; /* R_D10V_16. */
11704 return reloc_type
== R_H8_DIR16
;
11707 return reloc_type
== 1; /* R_IP2K_16. */
11710 return reloc_type
== 1; /* R_M32C_16 */
11712 if (uses_msp430x_relocs ())
11713 return reloc_type
== 2; /* R_MSP430_ABS16. */
11714 case EM_MSP430_OLD
:
11715 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
11717 return reloc_type
== 19; /* R_NDS32_RELA. */
11718 case EM_ALTERA_NIOS2
:
11719 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
11721 return reloc_type
== 9; /* R_NIOS_16. */
11723 return reloc_type
== 2; /* R_OR1K_16. */
11725 return reloc_type
== 2; /* R_C6000_ABS16. */
11728 return reloc_type
== 2; /* R_XC16C_ABS_16. */
11729 case EM_CYGNUS_MN10200
:
11731 return reloc_type
== 2; /* R_MN10200_16. */
11732 case EM_CYGNUS_MN10300
:
11734 return reloc_type
== 2; /* R_MN10300_16. */
11736 return reloc_type
== 2; /* R_VISIUM_16. */
11738 return reloc_type
== 3; /* R_XGATE_16. */
11744 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11745 relocation entries (possibly formerly used for SHT_GROUP sections). */
11748 is_none_reloc (unsigned int reloc_type
)
11750 switch (elf_header
.e_machine
)
11752 case EM_68K
: /* R_68K_NONE. */
11753 case EM_386
: /* R_386_NONE. */
11754 case EM_SPARC32PLUS
:
11756 case EM_SPARC
: /* R_SPARC_NONE. */
11757 case EM_MIPS
: /* R_MIPS_NONE. */
11758 case EM_PARISC
: /* R_PARISC_NONE. */
11759 case EM_ALPHA
: /* R_ALPHA_NONE. */
11760 case EM_ADAPTEVA_EPIPHANY
:
11761 case EM_PPC
: /* R_PPC_NONE. */
11762 case EM_PPC64
: /* R_PPC64_NONE. */
11763 case EM_ARC
: /* R_ARC_NONE. */
11764 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
11765 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
11766 case EM_ARM
: /* R_ARM_NONE. */
11767 case EM_IA_64
: /* R_IA64_NONE. */
11768 case EM_SH
: /* R_SH_NONE. */
11770 case EM_S390
: /* R_390_NONE. */
11771 case EM_CRIS
: /* R_CRIS_NONE. */
11772 case EM_X86_64
: /* R_X86_64_NONE. */
11773 case EM_L1OM
: /* R_X86_64_NONE. */
11774 case EM_K1OM
: /* R_X86_64_NONE. */
11775 case EM_MN10300
: /* R_MN10300_NONE. */
11776 case EM_FT32
: /* R_FT32_NONE. */
11777 case EM_MOXIE
: /* R_MOXIE_NONE. */
11778 case EM_M32R
: /* R_M32R_NONE. */
11779 case EM_TI_C6000
:/* R_C6000_NONE. */
11780 case EM_TILEGX
: /* R_TILEGX_NONE. */
11781 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
11783 case EM_C166
: /* R_XC16X_NONE. */
11784 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
11785 case EM_NIOS32
: /* R_NIOS_NONE. */
11786 case EM_OR1K
: /* R_OR1K_NONE. */
11787 return reloc_type
== 0;
11789 return reloc_type
== 0 || reloc_type
== 256;
11791 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11792 || reloc_type
== 204 /* R_NDS32_DIFF8. */
11793 || reloc_type
== 205 /* R_NDS32_DIFF16. */
11794 || reloc_type
== 206 /* R_NDS32_DIFF32. */
11795 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
11796 case EM_XTENSA_OLD
:
11798 return (reloc_type
== 0 /* R_XTENSA_NONE. */
11799 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
11800 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
11801 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
11803 return reloc_type
== 3; /* R_METAG_NONE. */
11808 /* Returns TRUE if there is a relocation against
11809 section NAME at OFFSET bytes. */
11812 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
11814 Elf_Internal_Rela
* relocs
;
11815 Elf_Internal_Rela
* rp
;
11817 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
11820 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
11822 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
11823 if (rp
->r_offset
== offset
)
11829 /* Apply relocations to a section.
11830 Note: So far support has been added only for those relocations
11831 which can be found in debug sections.
11832 If RELOCS_RETURN is non-NULL then returns in it a pointer to the
11833 loaded relocs. It is then the caller's responsibility to free them.
11834 FIXME: Add support for more relocations ? */
11837 apply_relocations (void * file
,
11838 const Elf_Internal_Shdr
* section
,
11839 unsigned char * start
,
11840 bfd_size_type size
,
11841 void ** relocs_return
,
11842 unsigned long * num_relocs_return
)
11844 Elf_Internal_Shdr
* relsec
;
11845 unsigned char * end
= start
+ size
;
11847 if (relocs_return
!= NULL
)
11849 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
11850 * num_relocs_return
= 0;
11853 if (elf_header
.e_type
!= ET_REL
)
11856 /* Find the reloc section associated with the section. */
11857 for (relsec
= section_headers
;
11858 relsec
< section_headers
+ elf_header
.e_shnum
;
11861 bfd_boolean is_rela
;
11862 unsigned long num_relocs
;
11863 Elf_Internal_Rela
* relocs
;
11864 Elf_Internal_Rela
* rp
;
11865 Elf_Internal_Shdr
* symsec
;
11866 Elf_Internal_Sym
* symtab
;
11867 unsigned long num_syms
;
11868 Elf_Internal_Sym
* sym
;
11870 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
11871 || relsec
->sh_info
>= elf_header
.e_shnum
11872 || section_headers
+ relsec
->sh_info
!= section
11873 || relsec
->sh_size
== 0
11874 || relsec
->sh_link
>= elf_header
.e_shnum
)
11877 is_rela
= relsec
->sh_type
== SHT_RELA
;
11881 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
11882 relsec
->sh_size
, & relocs
, & num_relocs
))
11887 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
11888 relsec
->sh_size
, & relocs
, & num_relocs
))
11892 /* SH uses RELA but uses in place value instead of the addend field. */
11893 if (elf_header
.e_machine
== EM_SH
)
11896 symsec
= section_headers
+ relsec
->sh_link
;
11897 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
11899 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
11902 unsigned int reloc_type
;
11903 unsigned int reloc_size
;
11904 unsigned char * rloc
;
11905 unsigned long sym_index
;
11907 reloc_type
= get_reloc_type (rp
->r_info
);
11909 if (target_specific_reloc_handling (rp
, start
, symtab
))
11911 else if (is_none_reloc (reloc_type
))
11913 else if (is_32bit_abs_reloc (reloc_type
)
11914 || is_32bit_pcrel_reloc (reloc_type
))
11916 else if (is_64bit_abs_reloc (reloc_type
)
11917 || is_64bit_pcrel_reloc (reloc_type
))
11919 else if (is_24bit_abs_reloc (reloc_type
))
11921 else if (is_16bit_abs_reloc (reloc_type
))
11925 static unsigned int prev_reloc
= 0;
11926 if (reloc_type
!= prev_reloc
)
11927 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11928 reloc_type
, printable_section_name (section
));
11929 prev_reloc
= reloc_type
;
11933 rloc
= start
+ rp
->r_offset
;
11934 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
11936 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11937 (unsigned long) rp
->r_offset
,
11938 printable_section_name (section
));
11942 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
11943 if (sym_index
>= num_syms
)
11945 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11946 sym_index
, printable_section_name (section
));
11949 sym
= symtab
+ sym_index
;
11951 /* If the reloc has a symbol associated with it,
11952 make sure that it is of an appropriate type.
11954 Relocations against symbols without type can happen.
11955 Gcc -feliminate-dwarf2-dups may generate symbols
11956 without type for debug info.
11958 Icc generates relocations against function symbols
11959 instead of local labels.
11961 Relocations against object symbols can happen, eg when
11962 referencing a global array. For an example of this see
11963 the _clz.o binary in libgcc.a. */
11965 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
11967 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11968 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
11969 (long int)(rp
- relocs
),
11970 printable_section_name (relsec
));
11976 addend
+= rp
->r_addend
;
11977 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11978 partial_inplace. */
11980 || (elf_header
.e_machine
== EM_XTENSA
11981 && reloc_type
== 1)
11982 || ((elf_header
.e_machine
== EM_PJ
11983 || elf_header
.e_machine
== EM_PJ_OLD
)
11984 && reloc_type
== 1)
11985 || ((elf_header
.e_machine
== EM_D30V
11986 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
11987 && reloc_type
== 12))
11988 addend
+= byte_get (rloc
, reloc_size
);
11990 if (is_32bit_pcrel_reloc (reloc_type
)
11991 || is_64bit_pcrel_reloc (reloc_type
))
11993 /* On HPPA, all pc-relative relocations are biased by 8. */
11994 if (elf_header
.e_machine
== EM_PARISC
)
11996 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12000 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12007 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12008 * num_relocs_return
= num_relocs
;
12017 #ifdef SUPPORT_DISASSEMBLY
12019 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12021 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12023 /* FIXME: XXX -- to be done --- XXX */
12029 /* Reads in the contents of SECTION from FILE, returning a pointer
12030 to a malloc'ed buffer or NULL if something went wrong. */
12033 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12035 bfd_size_type num_bytes
;
12037 num_bytes
= section
->sh_size
;
12039 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12041 printf (_("\nSection '%s' has no data to dump.\n"),
12042 printable_section_name (section
));
12046 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12047 _("section contents"));
12050 /* Uncompresses a section that was compressed using zlib, in place. */
12053 uncompress_section_contents (unsigned char **buffer
,
12054 dwarf_size_type uncompressed_size
,
12055 dwarf_size_type
*size
)
12057 dwarf_size_type compressed_size
= *size
;
12058 unsigned char * compressed_buffer
= *buffer
;
12059 unsigned char * uncompressed_buffer
;
12063 /* It is possible the section consists of several compressed
12064 buffers concatenated together, so we uncompress in a loop. */
12065 /* PR 18313: The state field in the z_stream structure is supposed
12066 to be invisible to the user (ie us), but some compilers will
12067 still complain about it being used without initialisation. So
12068 we first zero the entire z_stream structure and then set the fields
12070 memset (& strm
, 0, sizeof strm
);
12071 strm
.avail_in
= compressed_size
;
12072 strm
.next_in
= (Bytef
*) compressed_buffer
;
12073 strm
.avail_out
= uncompressed_size
;
12074 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12076 rc
= inflateInit (& strm
);
12077 while (strm
.avail_in
> 0)
12081 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12082 + (uncompressed_size
- strm
.avail_out
));
12083 rc
= inflate (&strm
, Z_FINISH
);
12084 if (rc
!= Z_STREAM_END
)
12086 rc
= inflateReset (& strm
);
12088 rc
= inflateEnd (& strm
);
12090 || strm
.avail_out
!= 0)
12093 *buffer
= uncompressed_buffer
;
12094 *size
= uncompressed_size
;
12098 free (uncompressed_buffer
);
12099 /* Indicate decompression failure. */
12105 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12107 Elf_Internal_Shdr
* relsec
;
12108 bfd_size_type num_bytes
;
12109 unsigned char * data
;
12110 unsigned char * end
;
12111 unsigned char * real_start
;
12112 unsigned char * start
;
12113 bfd_boolean some_strings_shown
;
12115 real_start
= start
= (unsigned char *) get_section_contents (section
,
12119 num_bytes
= section
->sh_size
;
12121 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12123 if (decompress_dumps
)
12125 dwarf_size_type new_size
= num_bytes
;
12126 dwarf_size_type uncompressed_size
= 0;
12128 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12130 Elf_Internal_Chdr chdr
;
12131 unsigned int compression_header_size
12132 = get_compression_header (& chdr
, (unsigned char *) start
);
12134 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12136 warn (_("section '%s' has unsupported compress type: %d\n"),
12137 printable_section_name (section
), chdr
.ch_type
);
12140 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12142 warn (_("compressed section '%s' is corrupted\n"),
12143 printable_section_name (section
));
12146 uncompressed_size
= chdr
.ch_size
;
12147 start
+= compression_header_size
;
12148 new_size
-= compression_header_size
;
12150 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12152 /* Read the zlib header. In this case, it should be "ZLIB"
12153 followed by the uncompressed section size, 8 bytes in
12154 big-endian order. */
12155 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12156 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12157 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12158 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12159 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12160 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12161 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12162 uncompressed_size
+= start
[11];
12167 if (uncompressed_size
12168 && uncompress_section_contents (& start
,
12169 uncompressed_size
, & new_size
))
12170 num_bytes
= new_size
;
12173 /* If the section being dumped has relocations against it the user might
12174 be expecting these relocations to have been applied. Check for this
12175 case and issue a warning message in order to avoid confusion.
12176 FIXME: Maybe we ought to have an option that dumps a section with
12177 relocs applied ? */
12178 for (relsec
= section_headers
;
12179 relsec
< section_headers
+ elf_header
.e_shnum
;
12182 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12183 || relsec
->sh_info
>= elf_header
.e_shnum
12184 || section_headers
+ relsec
->sh_info
!= section
12185 || relsec
->sh_size
== 0
12186 || relsec
->sh_link
>= elf_header
.e_shnum
)
12189 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12194 end
= start
+ num_bytes
;
12195 some_strings_shown
= FALSE
;
12199 while (!ISPRINT (* data
))
12200 if (++ data
>= end
)
12205 size_t maxlen
= end
- data
;
12208 /* PR 11128: Use two separate invocations in order to work
12209 around bugs in the Solaris 8 implementation of printf. */
12210 printf (" [%6tx] ", data
- start
);
12212 printf (" [%6Ix] ", (size_t) (data
- start
));
12216 print_symbol ((int) maxlen
, (const char *) data
);
12218 data
+= strnlen ((const char *) data
, maxlen
);
12222 printf (_("<corrupt>\n"));
12225 some_strings_shown
= TRUE
;
12229 if (! some_strings_shown
)
12230 printf (_(" No strings found in this section."));
12238 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
12240 bfd_boolean relocate
)
12242 Elf_Internal_Shdr
* relsec
;
12243 bfd_size_type bytes
;
12244 bfd_size_type section_size
;
12246 unsigned char * data
;
12247 unsigned char * real_start
;
12248 unsigned char * start
;
12250 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12253 section_size
= section
->sh_size
;
12255 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
12257 if (decompress_dumps
)
12259 dwarf_size_type new_size
= section_size
;
12260 dwarf_size_type uncompressed_size
= 0;
12262 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12264 Elf_Internal_Chdr chdr
;
12265 unsigned int compression_header_size
12266 = get_compression_header (& chdr
, start
);
12268 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12270 warn (_("section '%s' has unsupported compress type: %d\n"),
12271 printable_section_name (section
), chdr
.ch_type
);
12274 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12276 warn (_("compressed section '%s' is corrupted\n"),
12277 printable_section_name (section
));
12280 uncompressed_size
= chdr
.ch_size
;
12281 start
+= compression_header_size
;
12282 new_size
-= compression_header_size
;
12284 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12286 /* Read the zlib header. In this case, it should be "ZLIB"
12287 followed by the uncompressed section size, 8 bytes in
12288 big-endian order. */
12289 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12290 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12291 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12292 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12293 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12294 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12295 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12296 uncompressed_size
+= start
[11];
12301 if (uncompressed_size
12302 && uncompress_section_contents (& start
, uncompressed_size
,
12304 section_size
= new_size
;
12309 apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
);
12313 /* If the section being dumped has relocations against it the user might
12314 be expecting these relocations to have been applied. Check for this
12315 case and issue a warning message in order to avoid confusion.
12316 FIXME: Maybe we ought to have an option that dumps a section with
12317 relocs applied ? */
12318 for (relsec
= section_headers
;
12319 relsec
< section_headers
+ elf_header
.e_shnum
;
12322 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12323 || relsec
->sh_info
>= elf_header
.e_shnum
12324 || section_headers
+ relsec
->sh_info
!= section
12325 || relsec
->sh_size
== 0
12326 || relsec
->sh_link
>= elf_header
.e_shnum
)
12329 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12334 addr
= section
->sh_addr
;
12335 bytes
= section_size
;
12344 lbytes
= (bytes
> 16 ? 16 : bytes
);
12346 printf (" 0x%8.8lx ", (unsigned long) addr
);
12348 for (j
= 0; j
< 16; j
++)
12351 printf ("%2.2x", data
[j
]);
12359 for (j
= 0; j
< lbytes
; j
++)
12362 if (k
>= ' ' && k
< 0x7f)
12381 load_specific_debug_section (enum dwarf_section_display_enum debug
,
12382 const Elf_Internal_Shdr
* sec
, void * file
)
12384 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12387 /* If it is already loaded, do nothing. */
12388 if (section
->start
!= NULL
)
12391 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
12392 section
->address
= sec
->sh_addr
;
12393 section
->user_data
= NULL
;
12394 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
12396 sec
->sh_size
, buf
);
12397 if (section
->start
== NULL
)
12401 unsigned char *start
= section
->start
;
12402 dwarf_size_type size
= sec
->sh_size
;
12403 dwarf_size_type uncompressed_size
= 0;
12405 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
12407 Elf_Internal_Chdr chdr
;
12408 unsigned int compression_header_size
12409 = get_compression_header (&chdr
, start
);
12410 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12412 warn (_("section '%s' has unsupported compress type: %d\n"),
12413 section
->name
, chdr
.ch_type
);
12416 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
12418 warn (_("compressed section '%s' is corrupted\n"),
12422 uncompressed_size
= chdr
.ch_size
;
12423 start
+= compression_header_size
;
12424 size
-= compression_header_size
;
12426 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
12428 /* Read the zlib header. In this case, it should be "ZLIB"
12429 followed by the uncompressed section size, 8 bytes in
12430 big-endian order. */
12431 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12432 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12433 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12434 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12435 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12436 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12437 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12438 uncompressed_size
+= start
[11];
12443 if (uncompressed_size
12444 && uncompress_section_contents (&start
, uncompressed_size
,
12447 /* Free the compressed buffer, update the section buffer
12448 and the section size if uncompress is successful. */
12449 free (section
->start
);
12450 section
->start
= start
;
12452 section
->size
= size
;
12455 if (section
->start
== NULL
)
12458 if (debug_displays
[debug
].relocate
)
12459 apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
12460 & section
->reloc_info
, & section
->num_relocs
);
12463 section
->reloc_info
= NULL
;
12464 section
->num_relocs
= 0;
12470 /* If this is not NULL, load_debug_section will only look for sections
12471 within the list of sections given here. */
12472 unsigned int *section_subset
= NULL
;
12475 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
12477 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12478 Elf_Internal_Shdr
* sec
;
12480 /* Locate the debug section. */
12481 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
12483 section
->name
= section
->uncompressed_name
;
12486 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
12488 section
->name
= section
->compressed_name
;
12493 /* If we're loading from a subset of sections, and we've loaded
12494 a section matching this name before, it's likely that it's a
12496 if (section_subset
!= NULL
)
12497 free_debug_section (debug
);
12499 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
12503 free_debug_section (enum dwarf_section_display_enum debug
)
12505 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
12507 if (section
->start
== NULL
)
12510 free ((char *) section
->start
);
12511 section
->start
= NULL
;
12512 section
->address
= 0;
12517 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
12519 char * name
= SECTION_NAME (section
);
12520 const char * print_name
= printable_section_name (section
);
12521 bfd_size_type length
;
12525 length
= section
->sh_size
;
12528 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
12531 if (section
->sh_type
== SHT_NOBITS
)
12533 /* There is no point in dumping the contents of a debugging section
12534 which has the NOBITS type - the bits in the file will be random.
12535 This can happen when a file containing a .eh_frame section is
12536 stripped with the --only-keep-debug command line option. */
12537 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12542 if (const_strneq (name
, ".gnu.linkonce.wi."))
12543 name
= ".debug_info";
12545 /* See if we know how to display the contents of this section. */
12546 for (i
= 0; i
< max
; i
++)
12547 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
12548 || (i
== line
&& const_strneq (name
, ".debug_line."))
12549 || streq (debug_displays
[i
].section
.compressed_name
, name
))
12551 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
12552 int secondary
= (section
!= find_section (name
));
12555 free_debug_section ((enum dwarf_section_display_enum
) i
);
12557 if (i
== line
&& const_strneq (name
, ".debug_line."))
12559 else if (streq (sec
->uncompressed_name
, name
))
12560 sec
->name
= sec
->uncompressed_name
;
12562 sec
->name
= sec
->compressed_name
;
12563 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
12566 /* If this debug section is part of a CU/TU set in a .dwp file,
12567 restrict load_debug_section to the sections in that set. */
12568 section_subset
= find_cu_tu_set (file
, shndx
);
12570 result
&= debug_displays
[i
].display (sec
, file
);
12572 section_subset
= NULL
;
12574 if (secondary
|| (i
!= info
&& i
!= abbrev
))
12575 free_debug_section ((enum dwarf_section_display_enum
) i
);
12583 printf (_("Unrecognized debug section: %s\n"), print_name
);
12590 /* Set DUMP_SECTS for all sections where dumps were requested
12591 based on section name. */
12594 initialise_dumps_byname (void)
12596 struct dump_list_entry
* cur
;
12598 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
12603 for (i
= 0, any
= 0; i
< elf_header
.e_shnum
; i
++)
12604 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
12606 request_dump_bynumber (i
, cur
->type
);
12611 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12617 process_section_contents (FILE * file
)
12619 Elf_Internal_Shdr
* section
;
12625 initialise_dumps_byname ();
12627 for (i
= 0, section
= section_headers
;
12628 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
12631 #ifdef SUPPORT_DISASSEMBLY
12632 if (dump_sects
[i
] & DISASS_DUMP
)
12633 disassemble_section (section
, file
);
12635 if (dump_sects
[i
] & HEX_DUMP
)
12636 dump_section_as_bytes (section
, file
, FALSE
);
12638 if (dump_sects
[i
] & RELOC_DUMP
)
12639 dump_section_as_bytes (section
, file
, TRUE
);
12641 if (dump_sects
[i
] & STRING_DUMP
)
12642 dump_section_as_strings (section
, file
);
12644 if (dump_sects
[i
] & DEBUG_DUMP
)
12645 display_debug_section (i
, section
, file
);
12648 /* Check to see if the user requested a
12649 dump of a section that does not exist. */
12650 while (i
++ < num_dump_sects
)
12652 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
12656 process_mips_fpe_exception (int mask
)
12661 if (mask
& OEX_FPU_INEX
)
12662 fputs ("INEX", stdout
), first
= 0;
12663 if (mask
& OEX_FPU_UFLO
)
12664 printf ("%sUFLO", first
? "" : "|"), first
= 0;
12665 if (mask
& OEX_FPU_OFLO
)
12666 printf ("%sOFLO", first
? "" : "|"), first
= 0;
12667 if (mask
& OEX_FPU_DIV0
)
12668 printf ("%sDIV0", first
? "" : "|"), first
= 0;
12669 if (mask
& OEX_FPU_INVAL
)
12670 printf ("%sINVAL", first
? "" : "|");
12673 fputs ("0", stdout
);
12676 /* Display's the value of TAG at location P. If TAG is
12677 greater than 0 it is assumed to be an unknown tag, and
12678 a message is printed to this effect. Otherwise it is
12679 assumed that a message has already been printed.
12681 If the bottom bit of TAG is set it assumed to have a
12682 string value, otherwise it is assumed to have an integer
12685 Returns an updated P pointing to the first unread byte
12686 beyond the end of TAG's value.
12688 Reads at or beyond END will not be made. */
12690 static unsigned char *
12691 display_tag_value (int tag
,
12693 const unsigned char * const end
)
12698 printf (" Tag_unknown_%d: ", tag
);
12702 warn (_("<corrupt tag>\n"));
12706 /* PR 17531 file: 027-19978-0.004. */
12707 size_t maxlen
= (end
- p
) - 1;
12712 print_symbol ((int) maxlen
, (const char *) p
);
12713 p
+= strnlen ((char *) p
, maxlen
) + 1;
12717 printf (_("<corrupt string tag>"));
12718 p
= (unsigned char *) end
;
12726 val
= read_uleb128 (p
, &len
, end
);
12728 printf ("%ld (0x%lx)\n", val
, val
);
12735 /* ARM EABI attributes section. */
12740 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12742 const char ** table
;
12743 } arm_attr_public_tag
;
12745 static const char * arm_attr_tag_CPU_arch
[] =
12746 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12747 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12748 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
12749 static const char * arm_attr_tag_THUMB_ISA_use
[] =
12750 {"No", "Thumb-1", "Thumb-2"};
12751 static const char * arm_attr_tag_FP_arch
[] =
12752 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12753 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12754 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
12755 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
12756 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12757 static const char * arm_attr_tag_PCS_config
[] =
12758 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12759 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12760 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
12761 {"V6", "SB", "TLS", "Unused"};
12762 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
12763 {"Absolute", "PC-relative", "SB-relative", "None"};
12764 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
12765 {"Absolute", "PC-relative", "None"};
12766 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
12767 {"None", "direct", "GOT-indirect"};
12768 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
12769 {"None", "??? 1", "2", "??? 3", "4"};
12770 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
12771 static const char * arm_attr_tag_ABI_FP_denormal
[] =
12772 {"Unused", "Needed", "Sign only"};
12773 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
12774 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
12775 static const char * arm_attr_tag_ABI_FP_number_model
[] =
12776 {"Unused", "Finite", "RTABI", "IEEE 754"};
12777 static const char * arm_attr_tag_ABI_enum_size
[] =
12778 {"Unused", "small", "int", "forced to int"};
12779 static const char * arm_attr_tag_ABI_HardFP_use
[] =
12780 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
12781 static const char * arm_attr_tag_ABI_VFP_args
[] =
12782 {"AAPCS", "VFP registers", "custom", "compatible"};
12783 static const char * arm_attr_tag_ABI_WMMX_args
[] =
12784 {"AAPCS", "WMMX registers", "custom"};
12785 static const char * arm_attr_tag_ABI_optimization_goals
[] =
12786 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12787 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12788 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
12789 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12790 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12791 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
12792 static const char * arm_attr_tag_FP_HP_extension
[] =
12793 {"Not Allowed", "Allowed"};
12794 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
12795 {"None", "IEEE 754", "Alternative Format"};
12796 static const char * arm_attr_tag_MPextension_use
[] =
12797 {"Not Allowed", "Allowed"};
12798 static const char * arm_attr_tag_DIV_use
[] =
12799 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12800 "Allowed in v7-A with integer division extension"};
12801 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
12802 static const char * arm_attr_tag_Virtualization_use
[] =
12803 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12804 "TrustZone and Virtualization Extensions"};
12805 static const char * arm_attr_tag_MPextension_use_legacy
[] =
12806 {"Not Allowed", "Allowed"};
12808 #define LOOKUP(id, name) \
12809 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12810 static arm_attr_public_tag arm_attr_public_tags
[] =
12812 {4, "CPU_raw_name", 1, NULL
},
12813 {5, "CPU_name", 1, NULL
},
12814 LOOKUP(6, CPU_arch
),
12815 {7, "CPU_arch_profile", 0, NULL
},
12816 LOOKUP(8, ARM_ISA_use
),
12817 LOOKUP(9, THUMB_ISA_use
),
12818 LOOKUP(10, FP_arch
),
12819 LOOKUP(11, WMMX_arch
),
12820 LOOKUP(12, Advanced_SIMD_arch
),
12821 LOOKUP(13, PCS_config
),
12822 LOOKUP(14, ABI_PCS_R9_use
),
12823 LOOKUP(15, ABI_PCS_RW_data
),
12824 LOOKUP(16, ABI_PCS_RO_data
),
12825 LOOKUP(17, ABI_PCS_GOT_use
),
12826 LOOKUP(18, ABI_PCS_wchar_t
),
12827 LOOKUP(19, ABI_FP_rounding
),
12828 LOOKUP(20, ABI_FP_denormal
),
12829 LOOKUP(21, ABI_FP_exceptions
),
12830 LOOKUP(22, ABI_FP_user_exceptions
),
12831 LOOKUP(23, ABI_FP_number_model
),
12832 {24, "ABI_align_needed", 0, NULL
},
12833 {25, "ABI_align_preserved", 0, NULL
},
12834 LOOKUP(26, ABI_enum_size
),
12835 LOOKUP(27, ABI_HardFP_use
),
12836 LOOKUP(28, ABI_VFP_args
),
12837 LOOKUP(29, ABI_WMMX_args
),
12838 LOOKUP(30, ABI_optimization_goals
),
12839 LOOKUP(31, ABI_FP_optimization_goals
),
12840 {32, "compatibility", 0, NULL
},
12841 LOOKUP(34, CPU_unaligned_access
),
12842 LOOKUP(36, FP_HP_extension
),
12843 LOOKUP(38, ABI_FP_16bit_format
),
12844 LOOKUP(42, MPextension_use
),
12845 LOOKUP(44, DIV_use
),
12846 {64, "nodefaults", 0, NULL
},
12847 {65, "also_compatible_with", 0, NULL
},
12848 LOOKUP(66, T2EE_use
),
12849 {67, "conformance", 1, NULL
},
12850 LOOKUP(68, Virtualization_use
),
12851 LOOKUP(70, MPextension_use_legacy
)
12855 static unsigned char *
12856 display_arm_attribute (unsigned char * p
,
12857 const unsigned char * const end
)
12862 arm_attr_public_tag
* attr
;
12866 tag
= read_uleb128 (p
, &len
, end
);
12869 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
12871 if (arm_attr_public_tags
[i
].tag
== tag
)
12873 attr
= &arm_attr_public_tags
[i
];
12880 printf (" Tag_%s: ", attr
->name
);
12881 switch (attr
->type
)
12886 case 7: /* Tag_CPU_arch_profile. */
12887 val
= read_uleb128 (p
, &len
, end
);
12891 case 0: printf (_("None\n")); break;
12892 case 'A': printf (_("Application\n")); break;
12893 case 'R': printf (_("Realtime\n")); break;
12894 case 'M': printf (_("Microcontroller\n")); break;
12895 case 'S': printf (_("Application or Realtime\n")); break;
12896 default: printf ("??? (%d)\n", val
); break;
12900 case 24: /* Tag_align_needed. */
12901 val
= read_uleb128 (p
, &len
, end
);
12905 case 0: printf (_("None\n")); break;
12906 case 1: printf (_("8-byte\n")); break;
12907 case 2: printf (_("4-byte\n")); break;
12908 case 3: printf ("??? 3\n"); break;
12911 printf (_("8-byte and up to %d-byte extended\n"),
12914 printf ("??? (%d)\n", val
);
12919 case 25: /* Tag_align_preserved. */
12920 val
= read_uleb128 (p
, &len
, end
);
12924 case 0: printf (_("None\n")); break;
12925 case 1: printf (_("8-byte, except leaf SP\n")); break;
12926 case 2: printf (_("8-byte\n")); break;
12927 case 3: printf ("??? 3\n"); break;
12930 printf (_("8-byte and up to %d-byte extended\n"),
12933 printf ("??? (%d)\n", val
);
12938 case 32: /* Tag_compatibility. */
12940 val
= read_uleb128 (p
, &len
, end
);
12942 printf (_("flag = %d, vendor = "), val
);
12945 size_t maxlen
= (end
- p
) - 1;
12947 print_symbol ((int) maxlen
, (const char *) p
);
12948 p
+= strnlen ((char *) p
, maxlen
) + 1;
12952 printf (_("<corrupt>"));
12953 p
= (unsigned char *) end
;
12959 case 64: /* Tag_nodefaults. */
12960 /* PR 17531: file: 001-505008-0.01. */
12963 printf (_("True\n"));
12966 case 65: /* Tag_also_compatible_with. */
12967 val
= read_uleb128 (p
, &len
, end
);
12969 if (val
== 6 /* Tag_CPU_arch. */)
12971 val
= read_uleb128 (p
, &len
, end
);
12973 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
12974 printf ("??? (%d)\n", val
);
12976 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
12980 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
12985 printf (_("<unknown: %d>\n"), tag
);
12991 return display_tag_value (-1, p
, end
);
12993 return display_tag_value (0, p
, end
);
12996 assert (attr
->type
& 0x80);
12997 val
= read_uleb128 (p
, &len
, end
);
12999 type
= attr
->type
& 0x7f;
13001 printf ("??? (%d)\n", val
);
13003 printf ("%s\n", attr
->table
[val
]);
13008 return display_tag_value (tag
, p
, end
);
13011 static unsigned char *
13012 display_gnu_attribute (unsigned char * p
,
13013 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const),
13014 const unsigned char * const end
)
13020 tag
= read_uleb128 (p
, &len
, end
);
13023 /* Tag_compatibility is the only generic GNU attribute defined at
13027 val
= read_uleb128 (p
, &len
, end
);
13030 printf (_("flag = %d, vendor = "), val
);
13033 printf (_("<corrupt>\n"));
13034 warn (_("corrupt vendor attribute\n"));
13040 size_t maxlen
= (end
- p
) - 1;
13042 print_symbol ((int) maxlen
, (const char *) p
);
13043 p
+= strnlen ((char *) p
, maxlen
) + 1;
13047 printf (_("<corrupt>"));
13048 p
= (unsigned char *) end
;
13055 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
13056 return display_proc_gnu_attribute (p
, tag
, end
);
13058 return display_tag_value (tag
, p
, end
);
13061 static unsigned char *
13062 display_power_gnu_attribute (unsigned char * p
,
13064 const unsigned char * const end
)
13069 if (tag
== Tag_GNU_Power_ABI_FP
)
13071 val
= read_uleb128 (p
, &len
, end
);
13073 printf (" Tag_GNU_Power_ABI_FP: ");
13078 printf (_("Hard or soft float\n"));
13081 printf (_("Hard float\n"));
13084 printf (_("Soft float\n"));
13087 printf (_("Single-precision hard float\n"));
13090 printf ("??? (%d)\n", val
);
13096 if (tag
== Tag_GNU_Power_ABI_Vector
)
13098 val
= read_uleb128 (p
, &len
, end
);
13100 printf (" Tag_GNU_Power_ABI_Vector: ");
13104 printf (_("Any\n"));
13107 printf (_("Generic\n"));
13110 printf ("AltiVec\n");
13116 printf ("??? (%d)\n", val
);
13122 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
13126 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
13130 val
= read_uleb128 (p
, &len
, end
);
13132 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13136 printf (_("Any\n"));
13139 printf ("r3/r4\n");
13142 printf (_("Memory\n"));
13145 printf ("??? (%d)\n", val
);
13151 return display_tag_value (tag
& 1, p
, end
);
13154 static unsigned char *
13155 display_s390_gnu_attribute (unsigned char * p
,
13157 const unsigned char * const end
)
13162 if (tag
== Tag_GNU_S390_ABI_Vector
)
13164 val
= read_uleb128 (p
, &len
, end
);
13166 printf (" Tag_GNU_S390_ABI_Vector: ");
13171 printf (_("any\n"));
13174 printf (_("software\n"));
13177 printf (_("hardware\n"));
13180 printf ("??? (%d)\n", val
);
13186 return display_tag_value (tag
& 1, p
, end
);
13190 display_sparc_hwcaps (int mask
)
13196 if (mask
& ELF_SPARC_HWCAP_MUL32
)
13197 fputs ("mul32", stdout
), first
= 0;
13198 if (mask
& ELF_SPARC_HWCAP_DIV32
)
13199 printf ("%sdiv32", first
? "" : "|"), first
= 0;
13200 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
13201 printf ("%sfsmuld", first
? "" : "|"), first
= 0;
13202 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
13203 printf ("%sv8plus", first
? "" : "|"), first
= 0;
13204 if (mask
& ELF_SPARC_HWCAP_POPC
)
13205 printf ("%spopc", first
? "" : "|"), first
= 0;
13206 if (mask
& ELF_SPARC_HWCAP_VIS
)
13207 printf ("%svis", first
? "" : "|"), first
= 0;
13208 if (mask
& ELF_SPARC_HWCAP_VIS2
)
13209 printf ("%svis2", first
? "" : "|"), first
= 0;
13210 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
13211 printf ("%sASIBlkInit", first
? "" : "|"), first
= 0;
13212 if (mask
& ELF_SPARC_HWCAP_FMAF
)
13213 printf ("%sfmaf", first
? "" : "|"), first
= 0;
13214 if (mask
& ELF_SPARC_HWCAP_VIS3
)
13215 printf ("%svis3", first
? "" : "|"), first
= 0;
13216 if (mask
& ELF_SPARC_HWCAP_HPC
)
13217 printf ("%shpc", first
? "" : "|"), first
= 0;
13218 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
13219 printf ("%srandom", first
? "" : "|"), first
= 0;
13220 if (mask
& ELF_SPARC_HWCAP_TRANS
)
13221 printf ("%strans", first
? "" : "|"), first
= 0;
13222 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
13223 printf ("%sfjfmau", first
? "" : "|"), first
= 0;
13224 if (mask
& ELF_SPARC_HWCAP_IMA
)
13225 printf ("%sima", first
? "" : "|"), first
= 0;
13226 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
13227 printf ("%scspare", first
? "" : "|"), first
= 0;
13230 fputc ('0', stdout
);
13231 fputc ('\n', stdout
);
13235 display_sparc_hwcaps2 (int mask
)
13241 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
13242 fputs ("fjathplus", stdout
), first
= 0;
13243 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
13244 printf ("%svis3b", first
? "" : "|"), first
= 0;
13245 if (mask
& ELF_SPARC_HWCAP2_ADP
)
13246 printf ("%sadp", first
? "" : "|"), first
= 0;
13247 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
13248 printf ("%ssparc5", first
? "" : "|"), first
= 0;
13249 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
13250 printf ("%smwait", first
? "" : "|"), first
= 0;
13251 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
13252 printf ("%sxmpmul", first
? "" : "|"), first
= 0;
13253 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
13254 printf ("%sxmont2", first
? "" : "|"), first
= 0;
13255 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
13256 printf ("%snsec", first
? "" : "|"), first
= 0;
13257 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
13258 printf ("%sfjathhpc", first
? "" : "|"), first
= 0;
13259 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
13260 printf ("%sfjdes", first
? "" : "|"), first
= 0;
13261 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
13262 printf ("%sfjaes", first
? "" : "|"), first
= 0;
13265 fputc ('0', stdout
);
13266 fputc ('\n', stdout
);
13269 static unsigned char *
13270 display_sparc_gnu_attribute (unsigned char * p
,
13272 const unsigned char * const end
)
13277 if (tag
== Tag_GNU_Sparc_HWCAPS
)
13279 val
= read_uleb128 (p
, &len
, end
);
13281 printf (" Tag_GNU_Sparc_HWCAPS: ");
13282 display_sparc_hwcaps (val
);
13285 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
13287 val
= read_uleb128 (p
, &len
, end
);
13289 printf (" Tag_GNU_Sparc_HWCAPS2: ");
13290 display_sparc_hwcaps2 (val
);
13294 return display_tag_value (tag
, p
, end
);
13298 print_mips_fp_abi_value (int val
)
13302 case Val_GNU_MIPS_ABI_FP_ANY
:
13303 printf (_("Hard or soft float\n"));
13305 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
13306 printf (_("Hard float (double precision)\n"));
13308 case Val_GNU_MIPS_ABI_FP_SINGLE
:
13309 printf (_("Hard float (single precision)\n"));
13311 case Val_GNU_MIPS_ABI_FP_SOFT
:
13312 printf (_("Soft float\n"));
13314 case Val_GNU_MIPS_ABI_FP_OLD_64
:
13315 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
13317 case Val_GNU_MIPS_ABI_FP_XX
:
13318 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
13320 case Val_GNU_MIPS_ABI_FP_64
:
13321 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
13323 case Val_GNU_MIPS_ABI_FP_64A
:
13324 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
13326 case Val_GNU_MIPS_ABI_FP_NAN2008
:
13327 printf (_("NaN 2008 compatibility\n"));
13330 printf ("??? (%d)\n", val
);
13335 static unsigned char *
13336 display_mips_gnu_attribute (unsigned char * p
,
13338 const unsigned char * const end
)
13340 if (tag
== Tag_GNU_MIPS_ABI_FP
)
13345 val
= read_uleb128 (p
, &len
, end
);
13347 printf (" Tag_GNU_MIPS_ABI_FP: ");
13349 print_mips_fp_abi_value (val
);
13354 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
13359 val
= read_uleb128 (p
, &len
, end
);
13361 printf (" Tag_GNU_MIPS_ABI_MSA: ");
13365 case Val_GNU_MIPS_ABI_MSA_ANY
:
13366 printf (_("Any MSA or not\n"));
13368 case Val_GNU_MIPS_ABI_MSA_128
:
13369 printf (_("128-bit MSA\n"));
13372 printf ("??? (%d)\n", val
);
13378 return display_tag_value (tag
& 1, p
, end
);
13381 static unsigned char *
13382 display_tic6x_attribute (unsigned char * p
,
13383 const unsigned char * const end
)
13389 tag
= read_uleb128 (p
, &len
, end
);
13395 val
= read_uleb128 (p
, &len
, end
);
13397 printf (" Tag_ISA: ");
13401 case C6XABI_Tag_ISA_none
:
13402 printf (_("None\n"));
13404 case C6XABI_Tag_ISA_C62X
:
13407 case C6XABI_Tag_ISA_C67X
:
13410 case C6XABI_Tag_ISA_C67XP
:
13411 printf ("C67x+\n");
13413 case C6XABI_Tag_ISA_C64X
:
13416 case C6XABI_Tag_ISA_C64XP
:
13417 printf ("C64x+\n");
13419 case C6XABI_Tag_ISA_C674X
:
13420 printf ("C674x\n");
13423 printf ("??? (%d)\n", val
);
13428 case Tag_ABI_wchar_t
:
13429 val
= read_uleb128 (p
, &len
, end
);
13431 printf (" Tag_ABI_wchar_t: ");
13435 printf (_("Not used\n"));
13438 printf (_("2 bytes\n"));
13441 printf (_("4 bytes\n"));
13444 printf ("??? (%d)\n", val
);
13449 case Tag_ABI_stack_align_needed
:
13450 val
= read_uleb128 (p
, &len
, end
);
13452 printf (" Tag_ABI_stack_align_needed: ");
13456 printf (_("8-byte\n"));
13459 printf (_("16-byte\n"));
13462 printf ("??? (%d)\n", val
);
13467 case Tag_ABI_stack_align_preserved
:
13468 val
= read_uleb128 (p
, &len
, end
);
13470 printf (" Tag_ABI_stack_align_preserved: ");
13474 printf (_("8-byte\n"));
13477 printf (_("16-byte\n"));
13480 printf ("??? (%d)\n", val
);
13486 val
= read_uleb128 (p
, &len
, end
);
13488 printf (" Tag_ABI_DSBT: ");
13492 printf (_("DSBT addressing not used\n"));
13495 printf (_("DSBT addressing used\n"));
13498 printf ("??? (%d)\n", val
);
13504 val
= read_uleb128 (p
, &len
, end
);
13506 printf (" Tag_ABI_PID: ");
13510 printf (_("Data addressing position-dependent\n"));
13513 printf (_("Data addressing position-independent, GOT near DP\n"));
13516 printf (_("Data addressing position-independent, GOT far from DP\n"));
13519 printf ("??? (%d)\n", val
);
13525 val
= read_uleb128 (p
, &len
, end
);
13527 printf (" Tag_ABI_PIC: ");
13531 printf (_("Code addressing position-dependent\n"));
13534 printf (_("Code addressing position-independent\n"));
13537 printf ("??? (%d)\n", val
);
13542 case Tag_ABI_array_object_alignment
:
13543 val
= read_uleb128 (p
, &len
, end
);
13545 printf (" Tag_ABI_array_object_alignment: ");
13549 printf (_("8-byte\n"));
13552 printf (_("4-byte\n"));
13555 printf (_("16-byte\n"));
13558 printf ("??? (%d)\n", val
);
13563 case Tag_ABI_array_object_align_expected
:
13564 val
= read_uleb128 (p
, &len
, end
);
13566 printf (" Tag_ABI_array_object_align_expected: ");
13570 printf (_("8-byte\n"));
13573 printf (_("4-byte\n"));
13576 printf (_("16-byte\n"));
13579 printf ("??? (%d)\n", val
);
13584 case Tag_ABI_compatibility
:
13586 val
= read_uleb128 (p
, &len
, end
);
13588 printf (" Tag_ABI_compatibility: ");
13589 printf (_("flag = %d, vendor = "), val
);
13592 size_t maxlen
= (end
- p
) - 1;
13594 print_symbol ((int) maxlen
, (const char *) p
);
13595 p
+= strnlen ((char *) p
, maxlen
) + 1;
13599 printf (_("<corrupt>"));
13600 p
= (unsigned char *) end
;
13606 case Tag_ABI_conformance
:
13608 printf (" Tag_ABI_conformance: \"");
13611 size_t maxlen
= (end
- p
) - 1;
13613 print_symbol ((int) maxlen
, (const char *) p
);
13614 p
+= strnlen ((char *) p
, maxlen
) + 1;
13618 printf (_("<corrupt>"));
13619 p
= (unsigned char *) end
;
13626 return display_tag_value (tag
, p
, end
);
13630 display_raw_attribute (unsigned char * p
, unsigned char * end
)
13632 unsigned long addr
= 0;
13633 size_t bytes
= end
- p
;
13640 int lbytes
= (bytes
> 16 ? 16 : bytes
);
13642 printf (" 0x%8.8lx ", addr
);
13644 for (j
= 0; j
< 16; j
++)
13647 printf ("%2.2x", p
[j
]);
13655 for (j
= 0; j
< lbytes
; j
++)
13658 if (k
>= ' ' && k
< 0x7f)
13674 static unsigned char *
13675 display_msp430x_attribute (unsigned char * p
,
13676 const unsigned char * const end
)
13682 tag
= read_uleb128 (p
, & len
, end
);
13687 case OFBA_MSPABI_Tag_ISA
:
13688 val
= read_uleb128 (p
, &len
, end
);
13690 printf (" Tag_ISA: ");
13693 case 0: printf (_("None\n")); break;
13694 case 1: printf (_("MSP430\n")); break;
13695 case 2: printf (_("MSP430X\n")); break;
13696 default: printf ("??? (%d)\n", val
); break;
13700 case OFBA_MSPABI_Tag_Code_Model
:
13701 val
= read_uleb128 (p
, &len
, end
);
13703 printf (" Tag_Code_Model: ");
13706 case 0: printf (_("None\n")); break;
13707 case 1: printf (_("Small\n")); break;
13708 case 2: printf (_("Large\n")); break;
13709 default: printf ("??? (%d)\n", val
); break;
13713 case OFBA_MSPABI_Tag_Data_Model
:
13714 val
= read_uleb128 (p
, &len
, end
);
13716 printf (" Tag_Data_Model: ");
13719 case 0: printf (_("None\n")); break;
13720 case 1: printf (_("Small\n")); break;
13721 case 2: printf (_("Large\n")); break;
13722 case 3: printf (_("Restricted Large\n")); break;
13723 default: printf ("??? (%d)\n", val
); break;
13728 printf (_(" <unknown tag %d>: "), tag
);
13735 size_t maxlen
= (end
- p
) - 1;
13737 print_symbol ((int) maxlen
, (const char *) p
);
13738 p
+= strnlen ((char *) p
, maxlen
) + 1;
13742 printf (_("<corrupt>"));
13743 p
= (unsigned char *) end
;
13749 val
= read_uleb128 (p
, &len
, end
);
13751 printf ("%d (0x%x)\n", val
, val
);
13761 process_attributes (FILE * file
,
13762 const char * public_name
,
13763 unsigned int proc_type
,
13764 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
13765 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, int, const unsigned char * const))
13767 Elf_Internal_Shdr
* sect
;
13770 /* Find the section header so that we get the size. */
13771 for (i
= 0, sect
= section_headers
;
13772 i
< elf_header
.e_shnum
;
13775 unsigned char * contents
;
13778 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
13781 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
13782 sect
->sh_size
, _("attributes"));
13783 if (contents
== NULL
)
13789 bfd_vma section_len
;
13791 section_len
= sect
->sh_size
- 1;
13794 while (section_len
> 0)
13797 unsigned int namelen
;
13798 bfd_boolean public_section
;
13799 bfd_boolean gnu_section
;
13801 if (section_len
<= 4)
13803 error (_("Tag section ends prematurely\n"));
13806 attr_len
= byte_get (p
, 4);
13809 if (attr_len
> section_len
)
13811 error (_("Bad attribute length (%u > %u)\n"),
13812 (unsigned) attr_len
, (unsigned) section_len
);
13813 attr_len
= section_len
;
13815 /* PR 17531: file: 001-101425-0.004 */
13816 else if (attr_len
< 5)
13818 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
13822 section_len
-= attr_len
;
13825 namelen
= strnlen ((char *) p
, attr_len
) + 1;
13826 if (namelen
== 0 || namelen
>= attr_len
)
13828 error (_("Corrupt attribute section name\n"));
13832 printf (_("Attribute Section: "));
13833 print_symbol (INT_MAX
, (const char *) p
);
13836 if (public_name
&& streq ((char *) p
, public_name
))
13837 public_section
= TRUE
;
13839 public_section
= FALSE
;
13841 if (streq ((char *) p
, "gnu"))
13842 gnu_section
= TRUE
;
13844 gnu_section
= FALSE
;
13847 attr_len
-= namelen
;
13849 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
13854 unsigned char * end
;
13856 /* PR binutils/17531: Safe handling of corrupt files. */
13859 error (_("Unused bytes at end of section\n"));
13865 size
= byte_get (p
, 4);
13866 if (size
> attr_len
)
13868 error (_("Bad subsection length (%u > %u)\n"),
13869 (unsigned) size
, (unsigned) attr_len
);
13872 /* PR binutils/17531: Safe handling of corrupt files. */
13875 error (_("Bad subsection length (%u < 6)\n"),
13882 end
= p
+ size
- 1;
13883 assert (end
<= contents
+ sect
->sh_size
);
13889 printf (_("File Attributes\n"));
13892 printf (_("Section Attributes:"));
13895 printf (_("Symbol Attributes:"));
13901 val
= read_uleb128 (p
, &j
, end
);
13905 printf (" %d", val
);
13910 printf (_("Unknown tag: %d\n"), tag
);
13911 public_section
= FALSE
;
13915 if (public_section
&& display_pub_attribute
!= NULL
)
13918 p
= display_pub_attribute (p
, end
);
13921 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
13924 p
= display_gnu_attribute (p
,
13925 display_proc_gnu_attribute
,
13931 printf (_(" Unknown attribute:\n"));
13932 display_raw_attribute (p
, end
);
13941 printf (_("Unknown format '%c' (%d)\n"), *p
, *p
);
13949 process_arm_specific (FILE * file
)
13951 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
13952 display_arm_attribute
, NULL
);
13956 process_power_specific (FILE * file
)
13958 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13959 display_power_gnu_attribute
);
13963 process_s390_specific (FILE * file
)
13965 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13966 display_s390_gnu_attribute
);
13970 process_sparc_specific (FILE * file
)
13972 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
13973 display_sparc_gnu_attribute
);
13977 process_tic6x_specific (FILE * file
)
13979 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
13980 display_tic6x_attribute
, NULL
);
13984 process_msp430x_specific (FILE * file
)
13986 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
13987 display_msp430x_attribute
, NULL
);
13990 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13991 Print the Address, Access and Initial fields of an entry at VMA ADDR
13992 and return the VMA of the next entry, or -1 if there was a problem.
13993 Does not read from DATA_END or beyond. */
13996 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
13997 unsigned char * data_end
)
14000 print_vma (addr
, LONG_HEX
);
14002 if (addr
< pltgot
+ 0xfff0)
14003 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
14005 printf ("%10s", "");
14008 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14012 unsigned char * from
= data
+ addr
- pltgot
;
14014 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
14016 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14017 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
14018 return (bfd_vma
) -1;
14022 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14023 print_vma (entry
, LONG_HEX
);
14026 return addr
+ (is_32bit_elf
? 4 : 8);
14029 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14030 PLTGOT. Print the Address and Initial fields of an entry at VMA
14031 ADDR and return the VMA of the next entry. */
14034 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
14037 print_vma (addr
, LONG_HEX
);
14040 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
14045 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
14046 print_vma (entry
, LONG_HEX
);
14048 return addr
+ (is_32bit_elf
? 4 : 8);
14052 print_mips_ases (unsigned int mask
)
14054 if (mask
& AFL_ASE_DSP
)
14055 fputs ("\n\tDSP ASE", stdout
);
14056 if (mask
& AFL_ASE_DSPR2
)
14057 fputs ("\n\tDSP R2 ASE", stdout
);
14058 if (mask
& AFL_ASE_EVA
)
14059 fputs ("\n\tEnhanced VA Scheme", stdout
);
14060 if (mask
& AFL_ASE_MCU
)
14061 fputs ("\n\tMCU (MicroController) ASE", stdout
);
14062 if (mask
& AFL_ASE_MDMX
)
14063 fputs ("\n\tMDMX ASE", stdout
);
14064 if (mask
& AFL_ASE_MIPS3D
)
14065 fputs ("\n\tMIPS-3D ASE", stdout
);
14066 if (mask
& AFL_ASE_MT
)
14067 fputs ("\n\tMT ASE", stdout
);
14068 if (mask
& AFL_ASE_SMARTMIPS
)
14069 fputs ("\n\tSmartMIPS ASE", stdout
);
14070 if (mask
& AFL_ASE_VIRT
)
14071 fputs ("\n\tVZ ASE", stdout
);
14072 if (mask
& AFL_ASE_MSA
)
14073 fputs ("\n\tMSA ASE", stdout
);
14074 if (mask
& AFL_ASE_MIPS16
)
14075 fputs ("\n\tMIPS16 ASE", stdout
);
14076 if (mask
& AFL_ASE_MICROMIPS
)
14077 fputs ("\n\tMICROMIPS ASE", stdout
);
14078 if (mask
& AFL_ASE_XPA
)
14079 fputs ("\n\tXPA ASE", stdout
);
14081 fprintf (stdout
, "\n\t%s", _("None"));
14082 else if ((mask
& ~AFL_ASE_MASK
) != 0)
14083 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
14087 print_mips_isa_ext (unsigned int isa_ext
)
14092 fputs (_("None"), stdout
);
14095 fputs ("RMI XLR", stdout
);
14097 case AFL_EXT_OCTEON3
:
14098 fputs ("Cavium Networks Octeon3", stdout
);
14100 case AFL_EXT_OCTEON2
:
14101 fputs ("Cavium Networks Octeon2", stdout
);
14103 case AFL_EXT_OCTEONP
:
14104 fputs ("Cavium Networks OcteonP", stdout
);
14106 case AFL_EXT_LOONGSON_3A
:
14107 fputs ("Loongson 3A", stdout
);
14109 case AFL_EXT_OCTEON
:
14110 fputs ("Cavium Networks Octeon", stdout
);
14113 fputs ("Toshiba R5900", stdout
);
14116 fputs ("MIPS R4650", stdout
);
14119 fputs ("LSI R4010", stdout
);
14122 fputs ("NEC VR4100", stdout
);
14125 fputs ("Toshiba R3900", stdout
);
14127 case AFL_EXT_10000
:
14128 fputs ("MIPS R10000", stdout
);
14131 fputs ("Broadcom SB-1", stdout
);
14134 fputs ("NEC VR4111/VR4181", stdout
);
14137 fputs ("NEC VR4120", stdout
);
14140 fputs ("NEC VR5400", stdout
);
14143 fputs ("NEC VR5500", stdout
);
14145 case AFL_EXT_LOONGSON_2E
:
14146 fputs ("ST Microelectronics Loongson 2E", stdout
);
14148 case AFL_EXT_LOONGSON_2F
:
14149 fputs ("ST Microelectronics Loongson 2F", stdout
);
14152 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
14157 get_mips_reg_size (int reg_size
)
14159 return (reg_size
== AFL_REG_NONE
) ? 0
14160 : (reg_size
== AFL_REG_32
) ? 32
14161 : (reg_size
== AFL_REG_64
) ? 64
14162 : (reg_size
== AFL_REG_128
) ? 128
14167 process_mips_specific (FILE * file
)
14169 Elf_Internal_Dyn
* entry
;
14170 Elf_Internal_Shdr
*sect
= NULL
;
14171 size_t liblist_offset
= 0;
14172 size_t liblistno
= 0;
14173 size_t conflictsno
= 0;
14174 size_t options_offset
= 0;
14175 size_t conflicts_offset
= 0;
14176 size_t pltrelsz
= 0;
14178 bfd_vma pltgot
= 0;
14179 bfd_vma mips_pltgot
= 0;
14180 bfd_vma jmprel
= 0;
14181 bfd_vma local_gotno
= 0;
14182 bfd_vma gotsym
= 0;
14183 bfd_vma symtabno
= 0;
14185 process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
14186 display_mips_gnu_attribute
);
14188 sect
= find_section (".MIPS.abiflags");
14192 Elf_External_ABIFlags_v0
*abiflags_ext
;
14193 Elf_Internal_ABIFlags_v0 abiflags_in
;
14195 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
14196 fputs ("\nCorrupt ABI Flags section.\n", stdout
);
14199 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14200 sect
->sh_size
, _("MIPS ABI Flags section"));
14203 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
14204 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
14205 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
14206 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
14207 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
14208 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
14209 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
14210 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
14211 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
14212 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
14213 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
14215 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
14216 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
14217 if (abiflags_in
.isa_rev
> 1)
14218 printf ("r%d", abiflags_in
.isa_rev
);
14219 printf ("\nGPR size: %d",
14220 get_mips_reg_size (abiflags_in
.gpr_size
));
14221 printf ("\nCPR1 size: %d",
14222 get_mips_reg_size (abiflags_in
.cpr1_size
));
14223 printf ("\nCPR2 size: %d",
14224 get_mips_reg_size (abiflags_in
.cpr2_size
));
14225 fputs ("\nFP ABI: ", stdout
);
14226 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
14227 fputs ("ISA Extension: ", stdout
);
14228 print_mips_isa_ext (abiflags_in
.isa_ext
);
14229 fputs ("\nASEs:", stdout
);
14230 print_mips_ases (abiflags_in
.ases
);
14231 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
14232 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
14233 fputc ('\n', stdout
);
14234 free (abiflags_ext
);
14239 /* We have a lot of special sections. Thanks SGI! */
14240 if (dynamic_section
== NULL
)
14241 /* No information available. */
14244 for (entry
= dynamic_section
;
14245 /* PR 17531 file: 012-50589-0.004. */
14246 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
14248 switch (entry
->d_tag
)
14250 case DT_MIPS_LIBLIST
:
14252 = offset_from_vma (file
, entry
->d_un
.d_val
,
14253 liblistno
* sizeof (Elf32_External_Lib
));
14255 case DT_MIPS_LIBLISTNO
:
14256 liblistno
= entry
->d_un
.d_val
;
14258 case DT_MIPS_OPTIONS
:
14259 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
14261 case DT_MIPS_CONFLICT
:
14263 = offset_from_vma (file
, entry
->d_un
.d_val
,
14264 conflictsno
* sizeof (Elf32_External_Conflict
));
14266 case DT_MIPS_CONFLICTNO
:
14267 conflictsno
= entry
->d_un
.d_val
;
14270 pltgot
= entry
->d_un
.d_ptr
;
14272 case DT_MIPS_LOCAL_GOTNO
:
14273 local_gotno
= entry
->d_un
.d_val
;
14275 case DT_MIPS_GOTSYM
:
14276 gotsym
= entry
->d_un
.d_val
;
14278 case DT_MIPS_SYMTABNO
:
14279 symtabno
= entry
->d_un
.d_val
;
14281 case DT_MIPS_PLTGOT
:
14282 mips_pltgot
= entry
->d_un
.d_ptr
;
14285 pltrel
= entry
->d_un
.d_val
;
14288 pltrelsz
= entry
->d_un
.d_val
;
14291 jmprel
= entry
->d_un
.d_ptr
;
14297 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
14299 Elf32_External_Lib
* elib
;
14302 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
14304 sizeof (Elf32_External_Lib
),
14305 _("liblist section data"));
14308 printf (_("\nSection '.liblist' contains %lu entries:\n"),
14309 (unsigned long) liblistno
);
14310 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
14313 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
14320 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14321 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14322 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14323 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14324 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14326 tmp
= gmtime (&atime
);
14327 snprintf (timebuf
, sizeof (timebuf
),
14328 "%04u-%02u-%02uT%02u:%02u:%02u",
14329 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14330 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14332 printf ("%3lu: ", (unsigned long) cnt
);
14333 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
14334 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
14336 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
14337 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
14338 liblist
.l_version
);
14340 if (liblist
.l_flags
== 0)
14344 static const struct
14351 { " EXACT_MATCH", LL_EXACT_MATCH
},
14352 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
14353 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
14354 { " EXPORTS", LL_EXPORTS
},
14355 { " DELAY_LOAD", LL_DELAY_LOAD
},
14356 { " DELTA", LL_DELTA
}
14358 int flags
= liblist
.l_flags
;
14361 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
14362 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
14364 fputs (l_flags_vals
[fcnt
].name
, stdout
);
14365 flags
^= l_flags_vals
[fcnt
].bit
;
14368 printf (" %#x", (unsigned int) flags
);
14378 if (options_offset
!= 0)
14380 Elf_External_Options
* eopt
;
14381 Elf_Internal_Options
* iopt
;
14382 Elf_Internal_Options
* option
;
14385 sect
= section_headers
;
14387 /* Find the section header so that we get the size. */
14388 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
14389 /* PR 17533 file: 012-277276-0.004. */
14392 error (_("No MIPS_OPTIONS header found\n"));
14396 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
14397 sect
->sh_size
, _("options"));
14400 iopt
= (Elf_Internal_Options
*)
14401 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
14404 error (_("Out of memory allocatinf space for MIPS options\n"));
14411 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
14413 Elf_External_Options
* eoption
;
14415 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
14417 option
->kind
= BYTE_GET (eoption
->kind
);
14418 option
->size
= BYTE_GET (eoption
->size
);
14419 option
->section
= BYTE_GET (eoption
->section
);
14420 option
->info
= BYTE_GET (eoption
->info
);
14422 /* PR 17531: file: ffa0fa3b. */
14423 if (option
->size
< sizeof (* eopt
)
14424 || offset
+ option
->size
> sect
->sh_size
)
14426 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
14429 offset
+= option
->size
;
14435 printf (_("\nSection '%s' contains %d entries:\n"),
14436 printable_section_name (sect
), cnt
);
14445 switch (option
->kind
)
14448 /* This shouldn't happen. */
14449 printf (" NULL %d %lx", option
->section
, option
->info
);
14452 printf (" REGINFO ");
14453 if (elf_header
.e_machine
== EM_MIPS
)
14456 Elf32_External_RegInfo
* ereg
;
14457 Elf32_RegInfo reginfo
;
14459 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
14460 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14461 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14462 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14463 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14464 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14465 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14467 printf ("GPR %08lx GP 0x%lx\n",
14468 reginfo
.ri_gprmask
,
14469 (unsigned long) reginfo
.ri_gp_value
);
14470 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14471 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14472 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14477 Elf64_External_RegInfo
* ereg
;
14478 Elf64_Internal_RegInfo reginfo
;
14480 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
14481 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
14482 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
14483 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
14484 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
14485 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
14486 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
14488 printf ("GPR %08lx GP 0x",
14489 reginfo
.ri_gprmask
);
14490 printf_vma (reginfo
.ri_gp_value
);
14493 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
14494 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
14495 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
14499 case ODK_EXCEPTIONS
:
14500 fputs (" EXCEPTIONS fpe_min(", stdout
);
14501 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
14502 fputs (") fpe_max(", stdout
);
14503 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
14504 fputs (")", stdout
);
14506 if (option
->info
& OEX_PAGE0
)
14507 fputs (" PAGE0", stdout
);
14508 if (option
->info
& OEX_SMM
)
14509 fputs (" SMM", stdout
);
14510 if (option
->info
& OEX_FPDBUG
)
14511 fputs (" FPDBUG", stdout
);
14512 if (option
->info
& OEX_DISMISS
)
14513 fputs (" DISMISS", stdout
);
14516 fputs (" PAD ", stdout
);
14517 if (option
->info
& OPAD_PREFIX
)
14518 fputs (" PREFIX", stdout
);
14519 if (option
->info
& OPAD_POSTFIX
)
14520 fputs (" POSTFIX", stdout
);
14521 if (option
->info
& OPAD_SYMBOL
)
14522 fputs (" SYMBOL", stdout
);
14525 fputs (" HWPATCH ", stdout
);
14526 if (option
->info
& OHW_R4KEOP
)
14527 fputs (" R4KEOP", stdout
);
14528 if (option
->info
& OHW_R8KPFETCH
)
14529 fputs (" R8KPFETCH", stdout
);
14530 if (option
->info
& OHW_R5KEOP
)
14531 fputs (" R5KEOP", stdout
);
14532 if (option
->info
& OHW_R5KCVTL
)
14533 fputs (" R5KCVTL", stdout
);
14536 fputs (" FILL ", stdout
);
14537 /* XXX Print content of info word? */
14540 fputs (" TAGS ", stdout
);
14541 /* XXX Print content of info word? */
14544 fputs (" HWAND ", stdout
);
14545 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14546 fputs (" R4KEOP_CHECKED", stdout
);
14547 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14548 fputs (" R4KEOP_CLEAN", stdout
);
14551 fputs (" HWOR ", stdout
);
14552 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
14553 fputs (" R4KEOP_CHECKED", stdout
);
14554 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
14555 fputs (" R4KEOP_CLEAN", stdout
);
14558 printf (" GP_GROUP %#06lx self-contained %#06lx",
14559 option
->info
& OGP_GROUP
,
14560 (option
->info
& OGP_SELF
) >> 16);
14563 printf (" IDENT %#06lx self-contained %#06lx",
14564 option
->info
& OGP_GROUP
,
14565 (option
->info
& OGP_SELF
) >> 16);
14568 /* This shouldn't happen. */
14569 printf (" %3d ??? %d %lx",
14570 option
->kind
, option
->section
, option
->info
);
14574 len
= sizeof (* eopt
);
14575 while (len
< option
->size
)
14577 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
14579 if (ISPRINT (datum
))
14580 printf ("%c", datum
);
14582 printf ("\\%03o", datum
);
14585 fputs ("\n", stdout
);
14587 offset
+= option
->size
;
14595 if (conflicts_offset
!= 0 && conflictsno
!= 0)
14597 Elf32_Conflict
* iconf
;
14600 if (dynamic_symbols
== NULL
)
14602 error (_("conflict list found without a dynamic symbol table\n"));
14606 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
14609 error (_("Out of memory allocating space for dynamic conflicts\n"));
14615 Elf32_External_Conflict
* econf32
;
14617 econf32
= (Elf32_External_Conflict
*)
14618 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14619 sizeof (* econf32
), _("conflict"));
14623 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14624 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
14630 Elf64_External_Conflict
* econf64
;
14632 econf64
= (Elf64_External_Conflict
*)
14633 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
14634 sizeof (* econf64
), _("conflict"));
14638 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14639 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
14644 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14645 (unsigned long) conflictsno
);
14646 puts (_(" Num: Index Value Name"));
14648 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
14650 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
14652 if (iconf
[cnt
] >= num_dynamic_syms
)
14653 printf (_("<corrupt symbol index>"));
14656 Elf_Internal_Sym
* psym
;
14658 psym
= & dynamic_symbols
[iconf
[cnt
]];
14659 print_vma (psym
->st_value
, FULL_HEX
);
14661 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14662 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
14664 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14672 if (pltgot
!= 0 && local_gotno
!= 0)
14674 bfd_vma ent
, local_end
, global_end
;
14676 unsigned char * data
;
14677 unsigned char * data_end
;
14681 addr_size
= (is_32bit_elf
? 4 : 8);
14682 local_end
= pltgot
+ local_gotno
* addr_size
;
14684 /* PR binutils/17533 file: 012-111227-0.004 */
14685 if (symtabno
< gotsym
)
14687 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14688 (unsigned long) gotsym
, (unsigned long) symtabno
);
14692 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
14693 /* PR 17531: file: 54c91a34. */
14694 if (global_end
< local_end
)
14696 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
14700 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
14701 data
= (unsigned char *) get_data (NULL
, file
, offset
,
14702 global_end
- pltgot
, 1,
14703 _("Global Offset Table data"));
14706 data_end
= data
+ (global_end
- pltgot
);
14708 printf (_("\nPrimary GOT:\n"));
14709 printf (_(" Canonical gp value: "));
14710 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
14713 printf (_(" Reserved entries:\n"));
14714 printf (_(" %*s %10s %*s Purpose\n"),
14715 addr_size
* 2, _("Address"), _("Access"),
14716 addr_size
* 2, _("Initial"));
14717 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14718 printf (_(" Lazy resolver\n"));
14719 if (ent
== (bfd_vma
) -1)
14720 goto got_print_fail
;
14722 && (byte_get (data
+ ent
- pltgot
, addr_size
)
14723 >> (addr_size
* 8 - 1)) != 0)
14725 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14726 printf (_(" Module pointer (GNU extension)\n"));
14727 if (ent
== (bfd_vma
) -1)
14728 goto got_print_fail
;
14732 if (ent
< local_end
)
14734 printf (_(" Local entries:\n"));
14735 printf (" %*s %10s %*s\n",
14736 addr_size
* 2, _("Address"), _("Access"),
14737 addr_size
* 2, _("Initial"));
14738 while (ent
< local_end
)
14740 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14742 if (ent
== (bfd_vma
) -1)
14743 goto got_print_fail
;
14748 if (gotsym
< symtabno
)
14752 printf (_(" Global entries:\n"));
14753 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14754 addr_size
* 2, _("Address"),
14756 addr_size
* 2, _("Initial"),
14757 addr_size
* 2, _("Sym.Val."),
14759 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14760 _("Ndx"), _("Name"));
14762 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
14764 for (i
= gotsym
; i
< symtabno
; i
++)
14766 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
14769 if (dynamic_symbols
== NULL
)
14770 printf (_("<no dynamic symbols>"));
14771 else if (i
< num_dynamic_syms
)
14773 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
14775 print_vma (psym
->st_value
, LONG_HEX
);
14776 printf (" %-7s %3s ",
14777 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14778 get_symbol_index_type (psym
->st_shndx
));
14780 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14781 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14783 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14786 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14787 (unsigned long) i
);
14790 if (ent
== (bfd_vma
) -1)
14801 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
14804 size_t offset
, rel_offset
;
14805 unsigned long count
, i
;
14806 unsigned char * data
;
14807 int addr_size
, sym_width
;
14808 Elf_Internal_Rela
* rels
;
14810 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
14811 if (pltrel
== DT_RELA
)
14813 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14818 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
14823 addr_size
= (is_32bit_elf
? 4 : 8);
14824 end
= mips_pltgot
+ (2 + count
) * addr_size
;
14826 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
14827 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
14828 1, _("Procedure Linkage Table data"));
14832 printf ("\nPLT GOT:\n\n");
14833 printf (_(" Reserved entries:\n"));
14834 printf (_(" %*s %*s Purpose\n"),
14835 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
14836 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14837 printf (_(" PLT lazy resolver\n"));
14838 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14839 printf (_(" Module pointer\n"));
14842 printf (_(" Entries:\n"));
14843 printf (" %*s %*s %*s %-7s %3s %s\n",
14844 addr_size
* 2, _("Address"),
14845 addr_size
* 2, _("Initial"),
14846 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14847 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
14848 for (i
= 0; i
< count
; i
++)
14850 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
14852 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
14855 if (idx
>= num_dynamic_syms
)
14856 printf (_("<corrupt symbol index: %lu>"), idx
);
14859 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
14861 print_vma (psym
->st_value
, LONG_HEX
);
14862 printf (" %-7s %3s ",
14863 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
14864 get_symbol_index_type (psym
->st_shndx
));
14865 if (VALID_DYNAMIC_NAME (psym
->st_name
))
14866 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
14868 printf (_("<corrupt: %14ld>"), psym
->st_name
);
14883 process_nds32_specific (FILE * file
)
14885 Elf_Internal_Shdr
*sect
= NULL
;
14887 sect
= find_section (".nds32_e_flags");
14890 unsigned int *flag
;
14892 printf ("\nNDS32 elf flags section:\n");
14893 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
14894 sect
->sh_size
, _("NDS32 elf flags section"));
14896 switch ((*flag
) & 0x3)
14899 printf ("(VEC_SIZE):\tNo entry.\n");
14902 printf ("(VEC_SIZE):\t4 bytes\n");
14905 printf ("(VEC_SIZE):\t16 bytes\n");
14908 printf ("(VEC_SIZE):\treserved\n");
14917 process_gnu_liblist (FILE * file
)
14919 Elf_Internal_Shdr
* section
;
14920 Elf_Internal_Shdr
* string_sec
;
14921 Elf32_External_Lib
* elib
;
14923 size_t strtab_size
;
14930 for (i
= 0, section
= section_headers
;
14931 i
< elf_header
.e_shnum
;
14934 switch (section
->sh_type
)
14936 case SHT_GNU_LIBLIST
:
14937 if (section
->sh_link
>= elf_header
.e_shnum
)
14940 elib
= (Elf32_External_Lib
*)
14941 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
14942 _("liblist section data"));
14946 string_sec
= section_headers
+ section
->sh_link
;
14948 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
14949 string_sec
->sh_size
,
14950 _("liblist string table"));
14952 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
14958 strtab_size
= string_sec
->sh_size
;
14960 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14961 printable_section_name (section
),
14962 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
14964 puts (_(" Library Time Stamp Checksum Version Flags"));
14966 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
14974 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
14975 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
14976 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
14977 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
14978 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
14980 tmp
= gmtime (&atime
);
14981 snprintf (timebuf
, sizeof (timebuf
),
14982 "%04u-%02u-%02uT%02u:%02u:%02u",
14983 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
14984 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
14986 printf ("%3lu: ", (unsigned long) cnt
);
14988 printf ("%-20s", liblist
.l_name
< strtab_size
14989 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14991 printf ("%-20.20s", liblist
.l_name
< strtab_size
14992 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
14993 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
14994 liblist
.l_version
, liblist
.l_flags
);
15005 static const char *
15006 get_note_type (unsigned e_type
)
15008 static char buff
[64];
15010 if (elf_header
.e_type
== ET_CORE
)
15014 return _("NT_AUXV (auxiliary vector)");
15016 return _("NT_PRSTATUS (prstatus structure)");
15018 return _("NT_FPREGSET (floating point registers)");
15020 return _("NT_PRPSINFO (prpsinfo structure)");
15021 case NT_TASKSTRUCT
:
15022 return _("NT_TASKSTRUCT (task structure)");
15024 return _("NT_PRXFPREG (user_xfpregs structure)");
15026 return _("NT_PPC_VMX (ppc Altivec registers)");
15028 return _("NT_PPC_VSX (ppc VSX registers)");
15030 return _("NT_386_TLS (x86 TLS information)");
15031 case NT_386_IOPERM
:
15032 return _("NT_386_IOPERM (x86 I/O permissions)");
15033 case NT_X86_XSTATE
:
15034 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15035 case NT_S390_HIGH_GPRS
:
15036 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15037 case NT_S390_TIMER
:
15038 return _("NT_S390_TIMER (s390 timer register)");
15039 case NT_S390_TODCMP
:
15040 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15041 case NT_S390_TODPREG
:
15042 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15044 return _("NT_S390_CTRS (s390 control registers)");
15045 case NT_S390_PREFIX
:
15046 return _("NT_S390_PREFIX (s390 prefix register)");
15047 case NT_S390_LAST_BREAK
:
15048 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15049 case NT_S390_SYSTEM_CALL
:
15050 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15052 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15053 case NT_S390_VXRS_LOW
:
15054 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15055 case NT_S390_VXRS_HIGH
:
15056 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15058 return _("NT_ARM_VFP (arm VFP registers)");
15060 return _("NT_ARM_TLS (AArch TLS registers)");
15061 case NT_ARM_HW_BREAK
:
15062 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15063 case NT_ARM_HW_WATCH
:
15064 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15066 return _("NT_PSTATUS (pstatus structure)");
15068 return _("NT_FPREGS (floating point registers)");
15070 return _("NT_PSINFO (psinfo structure)");
15072 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15074 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15075 case NT_WIN32PSTATUS
:
15076 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15078 return _("NT_SIGINFO (siginfo_t data)");
15080 return _("NT_FILE (mapped files)");
15088 return _("NT_VERSION (version)");
15090 return _("NT_ARCH (architecture)");
15095 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15100 print_core_note (Elf_Internal_Note
*pnote
)
15102 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
15103 bfd_vma count
, page_size
;
15104 unsigned char *descdata
, *filenames
, *descend
;
15106 if (pnote
->type
!= NT_FILE
)
15112 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15113 /* Still "successful". */
15118 if (pnote
->descsz
< 2 * addr_size
)
15120 printf (_(" Malformed note - too short for header\n"));
15124 descdata
= (unsigned char *) pnote
->descdata
;
15125 descend
= descdata
+ pnote
->descsz
;
15127 if (descdata
[pnote
->descsz
- 1] != '\0')
15129 printf (_(" Malformed note - does not end with \\0\n"));
15133 count
= byte_get (descdata
, addr_size
);
15134 descdata
+= addr_size
;
15136 page_size
= byte_get (descdata
, addr_size
);
15137 descdata
+= addr_size
;
15139 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
15141 printf (_(" Malformed note - too short for supplied file count\n"));
15145 printf (_(" Page size: "));
15146 print_vma (page_size
, DEC
);
15149 printf (_(" %*s%*s%*s\n"),
15150 (int) (2 + 2 * addr_size
), _("Start"),
15151 (int) (4 + 2 * addr_size
), _("End"),
15152 (int) (4 + 2 * addr_size
), _("Page Offset"));
15153 filenames
= descdata
+ count
* 3 * addr_size
;
15154 while (--count
> 0)
15156 bfd_vma start
, end
, file_ofs
;
15158 if (filenames
== descend
)
15160 printf (_(" Malformed note - filenames end too early\n"));
15164 start
= byte_get (descdata
, addr_size
);
15165 descdata
+= addr_size
;
15166 end
= byte_get (descdata
, addr_size
);
15167 descdata
+= addr_size
;
15168 file_ofs
= byte_get (descdata
, addr_size
);
15169 descdata
+= addr_size
;
15172 print_vma (start
, FULL_HEX
);
15174 print_vma (end
, FULL_HEX
);
15176 print_vma (file_ofs
, FULL_HEX
);
15177 printf ("\n %s\n", filenames
);
15179 filenames
+= 1 + strlen ((char *) filenames
);
15185 static const char *
15186 get_gnu_elf_note_type (unsigned e_type
)
15188 static char buff
[64];
15192 case NT_GNU_ABI_TAG
:
15193 return _("NT_GNU_ABI_TAG (ABI version tag)");
15195 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15196 case NT_GNU_BUILD_ID
:
15197 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15198 case NT_GNU_GOLD_VERSION
:
15199 return _("NT_GNU_GOLD_VERSION (gold version)");
15204 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15209 print_gnu_note (Elf_Internal_Note
*pnote
)
15211 switch (pnote
->type
)
15213 case NT_GNU_BUILD_ID
:
15217 printf (_(" Build ID: "));
15218 for (i
= 0; i
< pnote
->descsz
; ++i
)
15219 printf ("%02x", pnote
->descdata
[i
] & 0xff);
15224 case NT_GNU_ABI_TAG
:
15226 unsigned long os
, major
, minor
, subminor
;
15227 const char *osname
;
15229 /* PR 17531: file: 030-599401-0.004. */
15230 if (pnote
->descsz
< 16)
15232 printf (_(" <corrupt GNU_ABI_TAG>\n"));
15236 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
15237 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
15238 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
15239 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
15243 case GNU_ABI_TAG_LINUX
:
15246 case GNU_ABI_TAG_HURD
:
15249 case GNU_ABI_TAG_SOLARIS
:
15250 osname
= "Solaris";
15252 case GNU_ABI_TAG_FREEBSD
:
15253 osname
= "FreeBSD";
15255 case GNU_ABI_TAG_NETBSD
:
15258 case GNU_ABI_TAG_SYLLABLE
:
15259 osname
= "Syllable";
15261 case GNU_ABI_TAG_NACL
:
15265 osname
= "Unknown";
15269 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
15270 major
, minor
, subminor
);
15274 case NT_GNU_GOLD_VERSION
:
15278 printf (_(" Version: "));
15279 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
15280 printf ("%c", pnote
->descdata
[i
]);
15289 static const char *
15290 get_v850_elf_note_type (enum v850_notes n_type
)
15292 static char buff
[64];
15296 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
15297 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
15298 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
15299 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
15300 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
15301 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
15303 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
15309 print_v850_note (Elf_Internal_Note
* pnote
)
15313 if (pnote
->descsz
!= 4)
15315 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
15319 printf (_("not set\n"));
15323 switch (pnote
->type
)
15325 case V850_NOTE_ALIGNMENT
:
15328 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return 1;
15329 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return 1;
15333 case V850_NOTE_DATA_SIZE
:
15336 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return 1;
15337 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return 1;
15341 case V850_NOTE_FPU_INFO
:
15344 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return 1;
15345 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return 1;
15349 case V850_NOTE_MMU_INFO
:
15350 case V850_NOTE_CACHE_INFO
:
15351 case V850_NOTE_SIMD_INFO
:
15352 if (val
== EF_RH850_SIMD
)
15354 printf (_("yes\n"));
15360 /* An 'unknown note type' message will already have been displayed. */
15364 printf (_("unknown value: %x\n"), val
);
15368 static const char *
15369 get_netbsd_elfcore_note_type (unsigned e_type
)
15371 static char buff
[64];
15373 if (e_type
== NT_NETBSDCORE_PROCINFO
)
15375 /* NetBSD core "procinfo" structure. */
15376 return _("NetBSD procinfo structure");
15379 /* As of Jan 2002 there are no other machine-independent notes
15380 defined for NetBSD core files. If the note type is less
15381 than the start of the machine-dependent note types, we don't
15384 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
15386 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15390 switch (elf_header
.e_machine
)
15392 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
15393 and PT_GETFPREGS == mach+2. */
15398 case EM_SPARC32PLUS
:
15402 case NT_NETBSDCORE_FIRSTMACH
+ 0:
15403 return _("PT_GETREGS (reg structure)");
15404 case NT_NETBSDCORE_FIRSTMACH
+ 2:
15405 return _("PT_GETFPREGS (fpreg structure)");
15411 /* On all other arch's, PT_GETREGS == mach+1 and
15412 PT_GETFPREGS == mach+3. */
15416 case NT_NETBSDCORE_FIRSTMACH
+ 1:
15417 return _("PT_GETREGS (reg structure)");
15418 case NT_NETBSDCORE_FIRSTMACH
+ 3:
15419 return _("PT_GETFPREGS (fpreg structure)");
15425 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
15426 e_type
- NT_NETBSDCORE_FIRSTMACH
);
15430 static const char *
15431 get_stapsdt_note_type (unsigned e_type
)
15433 static char buff
[64];
15438 return _("NT_STAPSDT (SystemTap probe descriptors)");
15444 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15449 print_stapsdt_note (Elf_Internal_Note
*pnote
)
15451 int addr_size
= is_32bit_elf
? 4 : 8;
15452 char *data
= pnote
->descdata
;
15453 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
15454 bfd_vma pc
, base_addr
, semaphore
;
15455 char *provider
, *probe
, *arg_fmt
;
15457 pc
= byte_get ((unsigned char *) data
, addr_size
);
15459 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
15461 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
15465 data
+= strlen (data
) + 1;
15467 data
+= strlen (data
) + 1;
15469 data
+= strlen (data
) + 1;
15471 printf (_(" Provider: %s\n"), provider
);
15472 printf (_(" Name: %s\n"), probe
);
15473 printf (_(" Location: "));
15474 print_vma (pc
, FULL_HEX
);
15475 printf (_(", Base: "));
15476 print_vma (base_addr
, FULL_HEX
);
15477 printf (_(", Semaphore: "));
15478 print_vma (semaphore
, FULL_HEX
);
15480 printf (_(" Arguments: %s\n"), arg_fmt
);
15482 return data
== data_end
;
15485 static const char *
15486 get_ia64_vms_note_type (unsigned e_type
)
15488 static char buff
[64];
15493 return _("NT_VMS_MHD (module header)");
15495 return _("NT_VMS_LNM (language name)");
15497 return _("NT_VMS_SRC (source files)");
15499 return "NT_VMS_TITLE";
15501 return _("NT_VMS_EIDC (consistency check)");
15502 case NT_VMS_FPMODE
:
15503 return _("NT_VMS_FPMODE (FP mode)");
15504 case NT_VMS_LINKTIME
:
15505 return "NT_VMS_LINKTIME";
15506 case NT_VMS_IMGNAM
:
15507 return _("NT_VMS_IMGNAM (image name)");
15509 return _("NT_VMS_IMGID (image id)");
15510 case NT_VMS_LINKID
:
15511 return _("NT_VMS_LINKID (link id)");
15512 case NT_VMS_IMGBID
:
15513 return _("NT_VMS_IMGBID (build id)");
15514 case NT_VMS_GSTNAM
:
15515 return _("NT_VMS_GSTNAM (sym table name)");
15516 case NT_VMS_ORIG_DYN
:
15517 return "NT_VMS_ORIG_DYN";
15518 case NT_VMS_PATCHTIME
:
15519 return "NT_VMS_PATCHTIME";
15521 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
15527 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
15529 switch (pnote
->type
)
15532 if (pnote
->descsz
> 36)
15534 size_t l
= strlen (pnote
->descdata
+ 34);
15535 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
15536 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
15537 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
15538 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
15541 printf (_(" Invalid size\n"));
15544 printf (_(" Language: %s\n"), pnote
->descdata
);
15547 case NT_VMS_FPMODE
:
15548 printf (_(" Floating Point mode: "));
15549 printf ("0x%016" BFD_VMA_FMT
"x\n",
15550 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15552 case NT_VMS_LINKTIME
:
15553 printf (_(" Link time: "));
15555 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15558 case NT_VMS_PATCHTIME
:
15559 printf (_(" Patch time: "));
15561 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
15564 case NT_VMS_ORIG_DYN
:
15565 printf (_(" Major id: %u, minor id: %u\n"),
15566 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
15567 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
15568 printf (_(" Last modified : "));
15570 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
15571 printf (_("\n Link flags : "));
15572 printf ("0x%016" BFD_VMA_FMT
"x\n",
15573 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
15574 printf (_(" Header flags: 0x%08x\n"),
15575 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
15576 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
15579 case NT_VMS_IMGNAM
:
15580 printf (_(" Image name: %s\n"), pnote
->descdata
);
15582 case NT_VMS_GSTNAM
:
15583 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
15586 printf (_(" Image id: %s\n"), pnote
->descdata
);
15588 case NT_VMS_LINKID
:
15589 printf (_(" Linker id: %s\n"), pnote
->descdata
);
15597 /* Note that by the ELF standard, the name field is already null byte
15598 terminated, and namesz includes the terminating null byte.
15599 I.E. the value of namesz for the name "FSF" is 4.
15601 If the value of namesz is zero, there is no name present. */
15603 process_note (Elf_Internal_Note
* pnote
)
15605 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
15608 if (pnote
->namesz
== 0)
15609 /* If there is no note name, then use the default set of
15610 note type strings. */
15611 nt
= get_note_type (pnote
->type
);
15613 else if (const_strneq (pnote
->namedata
, "GNU"))
15614 /* GNU-specific object file notes. */
15615 nt
= get_gnu_elf_note_type (pnote
->type
);
15617 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
15618 /* NetBSD-specific core file notes. */
15619 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
15621 else if (strneq (pnote
->namedata
, "SPU/", 4))
15623 /* SPU-specific core file notes. */
15624 nt
= pnote
->namedata
+ 4;
15628 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15629 /* VMS/ia64-specific file notes. */
15630 nt
= get_ia64_vms_note_type (pnote
->type
);
15632 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15633 nt
= get_stapsdt_note_type (pnote
->type
);
15636 /* Don't recognize this note name; just use the default set of
15637 note type strings. */
15638 nt
= get_note_type (pnote
->type
);
15640 printf (" %-20s 0x%08lx\t%s\n", name
, pnote
->descsz
, nt
);
15642 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
15643 return print_ia64_vms_note (pnote
);
15644 else if (const_strneq (pnote
->namedata
, "GNU"))
15645 return print_gnu_note (pnote
);
15646 else if (const_strneq (pnote
->namedata
, "stapsdt"))
15647 return print_stapsdt_note (pnote
);
15648 else if (const_strneq (pnote
->namedata
, "CORE"))
15649 return print_core_note (pnote
);
15656 process_corefile_note_segment (FILE * file
, bfd_vma offset
, bfd_vma length
)
15658 Elf_External_Note
* pnotes
;
15659 Elf_External_Note
* external
;
15666 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15668 if (pnotes
== NULL
)
15673 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15674 (unsigned long) offset
, (unsigned long) length
);
15675 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15677 end
= (char *) pnotes
+ length
;
15678 while ((char *) external
< end
)
15680 Elf_Internal_Note inote
;
15683 char * temp
= NULL
;
15684 size_t data_remaining
= end
- (char *) external
;
15686 if (!is_ia64_vms ())
15688 /* PR binutils/15191
15689 Make sure that there is enough data to read. */
15690 min_notesz
= offsetof (Elf_External_Note
, name
);
15691 if (data_remaining
< min_notesz
)
15693 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15694 (int) data_remaining
);
15697 inote
.type
= BYTE_GET (external
->type
);
15698 inote
.namesz
= BYTE_GET (external
->namesz
);
15699 inote
.namedata
= external
->name
;
15700 inote
.descsz
= BYTE_GET (external
->descsz
);
15701 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15702 /* PR 17531: file: 3443835e. */
15703 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
15705 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15706 inote
.descdata
= inote
.namedata
;
15710 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15711 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
15715 Elf64_External_VMS_Note
*vms_external
;
15717 /* PR binutils/15191
15718 Make sure that there is enough data to read. */
15719 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15720 if (data_remaining
< min_notesz
)
15722 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15723 (int) data_remaining
);
15727 vms_external
= (Elf64_External_VMS_Note
*) external
;
15728 inote
.type
= BYTE_GET (vms_external
->type
);
15729 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
15730 inote
.namedata
= vms_external
->name
;
15731 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
15732 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15733 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15734 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15737 if (inote
.descdata
< (char *) external
+ min_notesz
15738 || next
< (char *) external
+ min_notesz
15739 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15740 || inote
.namedata
+ inote
.namesz
< inote
.namedata
15741 || inote
.descdata
+ inote
.descsz
< inote
.descdata
15742 || data_remaining
< (size_t)(next
- (char *) external
))
15744 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15745 (unsigned long) ((char *) external
- (char *) pnotes
));
15746 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15747 inote
.type
, inote
.namesz
, inote
.descsz
);
15751 external
= (Elf_External_Note
*) next
;
15753 /* Verify that name is null terminated. It appears that at least
15754 one version of Linux (RedHat 6.0) generates corefiles that don't
15755 comply with the ELF spec by failing to include the null byte in
15757 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
15759 temp
= (char *) malloc (inote
.namesz
+ 1);
15762 error (_("Out of memory allocating space for inote name\n"));
15767 strncpy (temp
, inote
.namedata
, inote
.namesz
);
15768 temp
[inote
.namesz
] = 0;
15770 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15771 inote
.namedata
= temp
;
15774 res
&= process_note (& inote
);
15789 process_corefile_note_segments (FILE * file
)
15791 Elf_Internal_Phdr
* segment
;
15795 if (! get_program_headers (file
))
15798 for (i
= 0, segment
= program_headers
;
15799 i
< elf_header
.e_phnum
;
15802 if (segment
->p_type
== PT_NOTE
)
15803 res
&= process_corefile_note_segment (file
,
15804 (bfd_vma
) segment
->p_offset
,
15805 (bfd_vma
) segment
->p_filesz
);
15812 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
15814 Elf_External_Note
* pnotes
;
15815 Elf_External_Note
* external
;
15822 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
15824 if (pnotes
== NULL
)
15828 end
= (char*) pnotes
+ length
;
15830 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
15831 (unsigned long) offset
, (unsigned long) length
);
15833 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
15835 Elf_External_Note
* next
;
15836 Elf_Internal_Note inote
;
15838 inote
.type
= BYTE_GET (external
->type
);
15839 inote
.namesz
= BYTE_GET (external
->namesz
);
15840 inote
.namedata
= external
->name
;
15841 inote
.descsz
= BYTE_GET (external
->descsz
);
15842 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
15843 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
15845 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
15847 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
15848 inote
.descdata
= inote
.namedata
;
15852 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
15854 if ( ((char *) next
> end
)
15855 || ((char *) next
< (char *) pnotes
))
15857 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
15858 (unsigned long) ((char *) external
- (char *) pnotes
));
15859 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15860 inote
.type
, inote
.namesz
, inote
.descsz
);
15866 /* Prevent out-of-bounds indexing. */
15867 if ( inote
.namedata
+ inote
.namesz
> end
15868 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
15870 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
15871 (unsigned long) ((char *) external
- (char *) pnotes
));
15872 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
15873 inote
.type
, inote
.namesz
, inote
.descsz
);
15877 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
15879 if (! print_v850_note (& inote
))
15882 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
15883 inote
.namesz
, inote
.descsz
);
15893 process_note_sections (FILE * file
)
15895 Elf_Internal_Shdr
* section
;
15900 for (i
= 0, section
= section_headers
;
15901 i
< elf_header
.e_shnum
&& section
!= NULL
;
15904 if (section
->sh_type
== SHT_NOTE
)
15906 res
&= process_corefile_note_segment (file
,
15907 (bfd_vma
) section
->sh_offset
,
15908 (bfd_vma
) section
->sh_size
);
15912 if (( elf_header
.e_machine
== EM_V800
15913 || elf_header
.e_machine
== EM_V850
15914 || elf_header
.e_machine
== EM_CYGNUS_V850
)
15915 && section
->sh_type
== SHT_RENESAS_INFO
)
15917 res
&= process_v850_notes (file
,
15918 (bfd_vma
) section
->sh_offset
,
15919 (bfd_vma
) section
->sh_size
);
15925 /* Try processing NOTE segments instead. */
15926 return process_corefile_note_segments (file
);
15932 process_notes (FILE * file
)
15934 /* If we have not been asked to display the notes then do nothing. */
15938 if (elf_header
.e_type
!= ET_CORE
)
15939 return process_note_sections (file
);
15941 /* No program headers means no NOTE segment. */
15942 if (elf_header
.e_phnum
> 0)
15943 return process_corefile_note_segments (file
);
15945 printf (_("No note segments present in the core file.\n"));
15950 process_arch_specific (FILE * file
)
15955 switch (elf_header
.e_machine
)
15958 return process_arm_specific (file
);
15960 case EM_MIPS_RS3_LE
:
15961 return process_mips_specific (file
);
15964 return process_nds32_specific (file
);
15967 return process_power_specific (file
);
15971 return process_s390_specific (file
);
15974 case EM_SPARC32PLUS
:
15976 return process_sparc_specific (file
);
15979 return process_tic6x_specific (file
);
15982 return process_msp430x_specific (file
);
15990 get_file_header (FILE * file
)
15992 /* Read in the identity array. */
15993 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
15996 /* Determine how to read the rest of the header. */
15997 switch (elf_header
.e_ident
[EI_DATA
])
15999 default: /* fall through */
16000 case ELFDATANONE
: /* fall through */
16002 byte_get
= byte_get_little_endian
;
16003 byte_put
= byte_put_little_endian
;
16006 byte_get
= byte_get_big_endian
;
16007 byte_put
= byte_put_big_endian
;
16011 /* For now we only support 32 bit and 64 bit ELF files. */
16012 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
16014 /* Read in the rest of the header. */
16017 Elf32_External_Ehdr ehdr32
;
16019 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
16022 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
16023 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
16024 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
16025 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
16026 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
16027 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
16028 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
16029 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
16030 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
16031 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
16032 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
16033 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
16034 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
16038 Elf64_External_Ehdr ehdr64
;
16040 /* If we have been compiled with sizeof (bfd_vma) == 4, then
16041 we will not be able to cope with the 64bit data found in
16042 64 ELF files. Detect this now and abort before we start
16043 overwriting things. */
16044 if (sizeof (bfd_vma
) < 8)
16046 error (_("This instance of readelf has been built without support for a\n\
16047 64 bit data type and so it cannot read 64 bit ELF files.\n"));
16051 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
16054 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
16055 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
16056 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
16057 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
16058 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
16059 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
16060 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
16061 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
16062 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
16063 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
16064 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
16065 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
16066 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
16069 if (elf_header
.e_shoff
)
16071 /* There may be some extensions in the first section header. Don't
16072 bomb if we can't read it. */
16074 get_32bit_section_headers (file
, TRUE
);
16076 get_64bit_section_headers (file
, TRUE
);
16082 /* Process one ELF object file according to the command line options.
16083 This file may actually be stored in an archive. The file is
16084 positioned at the start of the ELF object. */
16087 process_object (char * file_name
, FILE * file
)
16091 if (! get_file_header (file
))
16093 error (_("%s: Failed to read file header\n"), file_name
);
16097 /* Initialise per file variables. */
16098 for (i
= ARRAY_SIZE (version_info
); i
--;)
16099 version_info
[i
] = 0;
16101 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
16102 dynamic_info
[i
] = 0;
16103 dynamic_info_DT_GNU_HASH
= 0;
16105 /* Process the file. */
16107 printf (_("\nFile: %s\n"), file_name
);
16109 /* Initialise the dump_sects array from the cmdline_dump_sects array.
16110 Note we do this even if cmdline_dump_sects is empty because we
16111 must make sure that the dump_sets array is zeroed out before each
16112 object file is processed. */
16113 if (num_dump_sects
> num_cmdline_dump_sects
)
16114 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
16116 if (num_cmdline_dump_sects
> 0)
16118 if (num_dump_sects
== 0)
16119 /* A sneaky way of allocating the dump_sects array. */
16120 request_dump_bynumber (num_cmdline_dump_sects
, 0);
16122 assert (num_dump_sects
>= num_cmdline_dump_sects
);
16123 memcpy (dump_sects
, cmdline_dump_sects
,
16124 num_cmdline_dump_sects
* sizeof (* dump_sects
));
16127 if (! process_file_header ())
16130 if (! process_section_headers (file
))
16132 /* Without loaded section headers we cannot process lots of
16134 do_unwind
= do_version
= do_dump
= do_arch
= 0;
16136 if (! do_using_dynamic
)
16137 do_syms
= do_dyn_syms
= do_reloc
= 0;
16140 if (! process_section_groups (file
))
16142 /* Without loaded section groups we cannot process unwind. */
16146 if (process_program_headers (file
))
16147 process_dynamic_section (file
);
16149 process_relocs (file
);
16151 process_unwind (file
);
16153 process_symbol_table (file
);
16155 process_syminfo (file
);
16157 process_version_sections (file
);
16159 process_section_contents (file
);
16161 process_notes (file
);
16163 process_gnu_liblist (file
);
16165 process_arch_specific (file
);
16167 if (program_headers
)
16169 free (program_headers
);
16170 program_headers
= NULL
;
16173 if (section_headers
)
16175 free (section_headers
);
16176 section_headers
= NULL
;
16181 free (string_table
);
16182 string_table
= NULL
;
16183 string_table_length
= 0;
16186 if (dynamic_strings
)
16188 free (dynamic_strings
);
16189 dynamic_strings
= NULL
;
16190 dynamic_strings_length
= 0;
16193 if (dynamic_symbols
)
16195 free (dynamic_symbols
);
16196 dynamic_symbols
= NULL
;
16197 num_dynamic_syms
= 0;
16200 if (dynamic_syminfo
)
16202 free (dynamic_syminfo
);
16203 dynamic_syminfo
= NULL
;
16206 if (dynamic_section
)
16208 free (dynamic_section
);
16209 dynamic_section
= NULL
;
16212 if (section_headers_groups
)
16214 free (section_headers_groups
);
16215 section_headers_groups
= NULL
;
16218 if (section_groups
)
16220 struct group_list
* g
;
16221 struct group_list
* next
;
16223 for (i
= 0; i
< group_count
; i
++)
16225 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
16232 free (section_groups
);
16233 section_groups
= NULL
;
16236 free_debug_memory ();
16241 /* Process an ELF archive.
16242 On entry the file is positioned just after the ARMAG string. */
16245 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
16247 struct archive_info arch
;
16248 struct archive_info nested_arch
;
16254 /* The ARCH structure is used to hold information about this archive. */
16255 arch
.file_name
= NULL
;
16257 arch
.index_array
= NULL
;
16258 arch
.sym_table
= NULL
;
16259 arch
.longnames
= NULL
;
16261 /* The NESTED_ARCH structure is used as a single-item cache of information
16262 about a nested archive (when members of a thin archive reside within
16263 another regular archive file). */
16264 nested_arch
.file_name
= NULL
;
16265 nested_arch
.file
= NULL
;
16266 nested_arch
.index_array
= NULL
;
16267 nested_arch
.sym_table
= NULL
;
16268 nested_arch
.longnames
= NULL
;
16270 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
16276 if (do_archive_index
)
16278 if (arch
.sym_table
== NULL
)
16279 error (_("%s: unable to dump the index as none was found\n"), file_name
);
16282 unsigned long i
, l
;
16283 unsigned long current_pos
;
16285 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
16286 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
16287 current_pos
= ftell (file
);
16289 for (i
= l
= 0; i
< arch
.index_num
; i
++)
16291 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
16293 char * member_name
;
16295 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
16297 if (member_name
!= NULL
)
16299 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
16301 if (qualified_name
!= NULL
)
16303 printf (_("Contents of binary %s at offset "), qualified_name
);
16304 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
16306 free (qualified_name
);
16311 if (l
>= arch
.sym_size
)
16313 error (_("%s: end of the symbol table reached before the end of the index\n"),
16317 /* PR 17531: file: 0b6630b2. */
16318 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
16319 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
16322 if (arch
.uses_64bit_indicies
)
16327 if (l
< arch
.sym_size
)
16328 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
16329 file_name
, arch
.sym_size
- l
);
16331 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
16333 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
16339 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
16340 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
16341 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
16342 && !do_section_groups
&& !do_dyn_syms
)
16344 ret
= 0; /* Archive index only. */
16355 char * qualified_name
;
16357 /* Read the next archive header. */
16358 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
16360 error (_("%s: failed to seek to next archive header\n"), file_name
);
16363 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
16364 if (got
!= sizeof arch
.arhdr
)
16368 error (_("%s: failed to read archive header\n"), file_name
);
16372 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
16374 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
16379 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
16381 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
16382 if (archive_file_size
& 01)
16383 ++archive_file_size
;
16385 name
= get_archive_member_name (&arch
, &nested_arch
);
16388 error (_("%s: bad archive file name\n"), file_name
);
16392 namelen
= strlen (name
);
16394 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
16395 if (qualified_name
== NULL
)
16397 error (_("%s: bad archive file name\n"), file_name
);
16402 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
16404 /* This is a proxy for an external member of a thin archive. */
16405 FILE * member_file
;
16406 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
16407 if (member_file_name
== NULL
)
16413 member_file
= fopen (member_file_name
, "rb");
16414 if (member_file
== NULL
)
16416 error (_("Input file '%s' is not readable.\n"), member_file_name
);
16417 free (member_file_name
);
16422 archive_file_offset
= arch
.nested_member_origin
;
16424 ret
|= process_object (qualified_name
, member_file
);
16426 fclose (member_file
);
16427 free (member_file_name
);
16429 else if (is_thin_archive
)
16431 /* PR 15140: Allow for corrupt thin archives. */
16432 if (nested_arch
.file
== NULL
)
16434 error (_("%s: contains corrupt thin archive: %s\n"),
16440 /* This is a proxy for a member of a nested archive. */
16441 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
16443 /* The nested archive file will have been opened and setup by
16444 get_archive_member_name. */
16445 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
16447 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
16452 ret
|= process_object (qualified_name
, nested_arch
.file
);
16456 archive_file_offset
= arch
.next_arhdr_offset
;
16457 arch
.next_arhdr_offset
+= archive_file_size
;
16459 ret
|= process_object (qualified_name
, file
);
16462 if (dump_sects
!= NULL
)
16466 num_dump_sects
= 0;
16469 free (qualified_name
);
16473 if (nested_arch
.file
!= NULL
)
16474 fclose (nested_arch
.file
);
16475 release_archive (&nested_arch
);
16476 release_archive (&arch
);
16482 process_file (char * file_name
)
16485 struct stat statbuf
;
16486 char armag
[SARMAG
];
16489 if (stat (file_name
, &statbuf
) < 0)
16491 if (errno
== ENOENT
)
16492 error (_("'%s': No such file\n"), file_name
);
16494 error (_("Could not locate '%s'. System error message: %s\n"),
16495 file_name
, strerror (errno
));
16499 if (! S_ISREG (statbuf
.st_mode
))
16501 error (_("'%s' is not an ordinary file\n"), file_name
);
16505 file
= fopen (file_name
, "rb");
16508 error (_("Input file '%s' is not readable.\n"), file_name
);
16512 if (fread (armag
, SARMAG
, 1, file
) != 1)
16514 error (_("%s: Failed to read file's magic number\n"), file_name
);
16519 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
16521 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
16522 ret
= process_archive (file_name
, file
, FALSE
);
16523 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
16524 ret
= process_archive (file_name
, file
, TRUE
);
16527 if (do_archive_index
)
16528 error (_("File %s is not an archive so its index cannot be displayed.\n"),
16532 archive_file_size
= archive_file_offset
= 0;
16533 ret
= process_object (file_name
, file
);
16538 current_file_size
= 0;
16542 #ifdef SUPPORT_DISASSEMBLY
16543 /* Needed by the i386 disassembler. For extra credit, someone could
16544 fix this so that we insert symbolic addresses here, esp for GOT/PLT
16548 print_address (unsigned int addr
, FILE * outfile
)
16550 fprintf (outfile
,"0x%8.8x", addr
);
16553 /* Needed by the i386 disassembler. */
16555 db_task_printsym (unsigned int addr
)
16557 print_address (addr
, stderr
);
16562 main (int argc
, char ** argv
)
16566 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
16567 setlocale (LC_MESSAGES
, "");
16569 #if defined (HAVE_SETLOCALE)
16570 setlocale (LC_CTYPE
, "");
16572 bindtextdomain (PACKAGE
, LOCALEDIR
);
16573 textdomain (PACKAGE
);
16575 expandargv (&argc
, &argv
);
16577 parse_args (argc
, argv
);
16579 if (num_dump_sects
> 0)
16581 /* Make a copy of the dump_sects array. */
16582 cmdline_dump_sects
= (dump_type
*)
16583 malloc (num_dump_sects
* sizeof (* dump_sects
));
16584 if (cmdline_dump_sects
== NULL
)
16585 error (_("Out of memory allocating dump request table.\n"));
16588 memcpy (cmdline_dump_sects
, dump_sects
,
16589 num_dump_sects
* sizeof (* dump_sects
));
16590 num_cmdline_dump_sects
= num_dump_sects
;
16594 if (optind
< (argc
- 1))
16596 else if (optind
>= argc
)
16598 warn (_("Nothing to do.\n"));
16603 while (optind
< argc
)
16604 err
|= process_file (argv
[optind
++]);
16606 if (dump_sects
!= NULL
)
16608 if (cmdline_dump_sects
!= NULL
)
16609 free (cmdline_dump_sects
);